inTact: Self-Healing File Edits for Agents

Left-rule blocks mark artificial prose; quotations retain their own attribution.

A formatter changes the indentation; the edit you prepared no longer matches. tact can still find it. It works through seven increasingly permissive kinds of text match, reports the one it used, and refuses unresolved ambiguity. It reconciles text; deciding whether the edit is a good idea is still your job.

Documentation: intact.docs.doering.ai

Installation

Python 3.13+. The package is intact; the command is tact.

uv tool install intact
# or, in your Python environment:
python -m pip install intact

The core has no runtime dependencies. For the optional MCP server, use "intact[mcp]" in either command.

Preview an edit

Save this small example as answer.py:

def answer():
    return 41

tact check answer.py --old 'return 41' --new 'return 42'

The old text omits the file's indentation, but check finds the block at INDENT and previews the replacement. The result reports would_apply=True; the file still contains return 41. Use edit in place of check when you're ready to write.

Use it from the CLI

Start with check when you want to inspect the match. heal gives a read-only recovery result for a failed exact edit; edit writes the replacement. These examples assume config.py contains DEBUG = True (possibly with changed whitespace).

# Inspect a proposed match without writing.
tact check config.py --old "DEBUG = True" --new "DEBUG = False"

# Get a read-only recovery result for a previously failed exact edit.
tact heal config.py --old "DEBUG = True" --new "DEBUG = False"

# Machine-readable output and a single atomic write.
tact --json edit config.py --old "DEBUG = True" --new "DEBUG = False"

# Multi-line blocks without shell quoting: read them from files, or pipe a JSON batch.
tact edit config.py --old-file old.txt --new-file new.txt
echo '[{"old_block": "DEBUG = True", "new_block": "DEBUG = False"}]' | tact edit config.py

# A patch in any common dialect: *** Begin Patch, unified diff, SEARCH/REPLACE, or fenced blocks.
tact apply-patch change.patch

Each result reports the match or refusal. If several places match, inspect the candidates before supplying --near LINE to choose by proximity. That hint breaks ties; it cannot make absent text appear. Exit status 1 means a structured refusal.

Input is forgiving about shape and strict about meaning. Common option aliases (--old-string, --search), Codex's *** Begin Patch text, and diffs with miscounted hunk headers are accepted. Text whose newlines arrived as a literal backslash and n is decoded only when it is not in the file as written and the decoded text then matches, and the result says so. A shape that two readings fit, such as a patch mixing two dialects, is refused by name. Patch text that parses to nothing is a refusal, never a success.

The CLI also handles patches, undo/history, durable anchors, drift reads, and LSP-backed navigation and rename. Run tact --help for the available commands.

What the public replay shows

The committed public fixture set contains 59 historical edit failures, reviewed for privacy: 56 have enough evidence to replay, and 3 do not. The current replay reports:

The false-heal check found zero candidates among seven checkable same-intent pairs. That isn't a general error rate: the check needs a later, resolvable follow-up similar enough to plausibly represent the same edit. It also misses a wrong write that overlaps its retry. Two such FUZZY heals passed it until 1.2.1 refused them, which is why 44 became 42. See the fixture provenance and evaluation test.

The shape-map methodology and full PCA triptych explore the same fixtures. Nearby points have similar edit shapes; proximity is not evidence that an edit was correct.

Use it from Python

from tact import Edit, apply_edits, read_file

snapshot = read_file('config.py')
result = apply_edits(
    'config.py',
    [Edit(old_block='DEBUG = True', new_block='DEBUG = False')],
    expected_sha256=snapshot.sha256,
)
print(result.results[0].rung)

apply_edits resolves the whole batch before writing the file. Here, expected_sha256 reports drift without rejecting an otherwise valid reconciliation. For cross-file changes, apply_many resolves and stages every file before committing any; its required_sha256s check refuses a stale snapshot. The distinction matters: expected hashes are advisory, required hashes are gates.

Multi-file commits still use separate renames. A crash or write failure between them can leave a partial batch; resolve-first is not filesystem-wide atomicity.

Use it through MCP

After installing the mcp extra, start the server with:

tact-mcp

The server exposes the same core through tools such as tact_read, tact_edit, tact_check, tact_heal, tact_anchor, and tact_delta. It keeps its LSP client alive across navigation and rename calls. tact_edit also takes one flat edit (path, old_block, new_block) and common aliases such as file_path or old_string/new_string. An unknown argument or replace_all: true is refused with the accepted shapes, never silently dropped. See the MCP setup guide for host configuration.

How matching stays safe

The ladder tries exact text, normalized Unicode, trailing-space-insensitive text, indentation shifts, exact substrings, reflowed prose, then bounded fuzzy matching. At each rung, no candidates means try the next; one candidate ends the search; several require a proximity hint or produce an ambiguity refusal. If the whole ladder finds nothing, the result is a no-match refusal.

Matching is only part of the write checks: overlapping edits and unsafe replacements can still be refused. Patch ingestion and multi-edit batches use the same resolve-first machinery. The undo journal keeps pre-images for convenience; keep using version control. LSP-backed rename refuses when it cannot establish bindings, with no textual fallback.

Advanced integration

Optional agent-harness routing directs eligible editor calls through Tact and checks installation readiness. You don't need the hooks to use the CLI, library, or MCP server.

License and provenance

Apache-2.0. See LICENSE and NOTICE. The reconciliation ladder's canonicalization and fuzzy primitives adapt attributed Apache-2.0 code from dirac; the original SUBLINE and REFLOW rungs are documented in the design explanation.