code-context-control 2.152.0__py3-none-any.whl → 2.153.0__py3-none-any.whl

cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.152.0"
+__version__ = "2.153.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

cli/guide/tools.html

@@ -481,7 +481,13 @@ c3_filter(text=<span class="str">"&lt;webpack build output&gt;"</span>, pattern=
                 <td class="param-name">edits</td>
                 <td class="param-type">array</td>
                 <td class="param-default">null</td>
-                <td class="param-desc">List of <code>{old_string, new_string}</code> objects for batch edits to the same file</td>
+                <td class="param-desc">List of <code>{old_string, new_string}</code> objects for batch edits to the same file. Applied in order, all or none: if one patch cannot be placed, nothing is written</td>
+              </tr>
+              <tr>
+                <td class="param-name">overwrite</td>
+                <td class="param-type">bool</td>
+                <td class="param-default">false</td>
+                <td class="param-desc">Replace all of an existing file with <code>new_string</code>. Refused unless this session has read the file with c3_read and the file has not changed since. Keeps the file's line endings and BOM, stores a pre-image, and can be reverted</td>
               </tr>
             </tbody>
           </table>
@@ -514,7 +520,7 @@ c3_filter(text=<span class="str">"&lt;webpack build output&gt;"</span>, pattern=
           <div class="callout callout-info">
             <span class="callout-icon">💡</span>
             <div class="callout-body">
-              <strong>Unicode lookalikes are matched automatically.</strong> If <code>old_string</code> uses straight quotes but the file has curly quotes (or vice versa), or the two differ only by ASCII vs. unicode dashes (<code>-</code>/<code>–</code>/<code>—</code>) or non-breaking spaces, c3_edit retries with a normalized match and splices your <code>new_string</code> in at the matched offsets; unrelated lookalikes elsewhere are left intact. The response is tagged <code>[unicode-normalized]</code> when the fallback was used.
+              <strong>Unicode lookalikes are reported, not applied.</strong> If <code>old_string</code> uses straight quotes but the file has curly quotes (or vice versa), or the two differ only by ASCII vs. unicode dashes (<code>-</code>/<code>–</code>/<code>—</code>) or non-breaking spaces, c3_edit writes nothing and answers <code>[c3_edit:lookalike]</code> with the file's exact text for that region, so the retry can copy it. Applying such a match would replace the file's characters with the retyped ones.
             </div>
           </div>
         </div>

cli/guide/workflow.html

@@ -623,7 +623,7 @@ c3_impact(target=<span class="str">'MemoryStore'</span>, mode=<span class="str">
         </div>
         <div class="workflow-step-body">
 
-          <p><code>c3_edit</code> does read + patch + write + edit ledger log in one step. It also validates the old_string match before writing. If the literal match fails but the strings differ only by unicode lookalikes (curly quotes, em/en-dashes, NBSP), c3_edit retries with a 1:1 normalized match and tags the response <code>[unicode-normalized]</code>.</p>
+          <p><code>c3_edit</code> does read + patch + write + edit ledger log in one step. It also validates the old_string match before writing. If the literal match fails but the strings differ only by unicode lookalikes (curly quotes, em/en-dashes, NBSP), c3_edit writes nothing and returns the file's exact text under <code>[c3_edit:lookalike]</code>.</p>
 
           <pre><code>c3_edit(
   file_path=<span class="str">'services/auth.py'</span>,

cli/mcp_server.py

@@ -543,7 +543,9 @@ def _with_hint(resp, make_hint) -> str:
 
 def _finalize_response(ctx: Context, tool_name: str, args: dict,
                        response: str, summary: str = "",
-                       response_tokens: int = 0) -> str:
+                       response_tokens: int = 0,
+                       ok: bool | None = None) -> str:
+    """ok: the tool's own verdict on the call; None reads it off the response text."""
     global _last_tool_call_time, _last_badge_count
 
     deferred_snapshot = False
@@ -586,11 +588,14 @@ def _finalize_response(ctx: Context, tool_name: str, args: dict,
     svc.session_mgr.log_tool_call(tool_name, args, summary)
     # ok=False lets hook_pretool_enforce's activity scan skip a failed call
     # (ISSUE-3: "Error: File not found" used to count as "c3 was used").
-    try:
-        from cli._hook_utils import response_text_failed as _failed
-        call_ok = not _failed(response)
-    except Exception:
-        call_ok = True
+    if ok is not None:
+        call_ok = ok
+    else:
+        try:
+            from cli._hook_utils import response_text_failed as _failed
+            call_ok = not _failed(response)
+        except Exception:
+            call_ok = True
     # Both session ids on every tool_call row (D0b): C3's own id joins the
     # row to session_start / the saved session file, the host id joins it to
     # the hooks' session_open / session_end rows. Either may be absent.
@@ -903,12 +908,13 @@ async def c3_agent(workflow: str, scope: str = "", context: str = "",
 @mcp.tool()
 async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
                   summary: str = "", tags: str = "", replace_all: bool = False,
-                  edits: str | list[dict] = "",
+                  edits: str | list[dict] = "", overwrite: bool = False,
                   ctx: Context = None) -> str:
     """EDIT — read+patch+write+log in one step. Primary code-change tool; always prefer over native Edit.
     old_string: text to replace. new_string: replacement. summary: ledger description.
-    edits: list (or JSON string) of {old_string, new_string, summary?} for multi-hunk batch on one file.
-    Parallel across files. Create new file: non-existent file_path + old_string='' + new_string=<content>.
+    edits: list (or JSON string) of {old_string, new_string, summary?} for multi-hunk batch on one file,
+    applied all or none. Parallel across files. Create new file: non-existent file_path + old_string='' + new_string=<content>.
+    Rewrite a whole existing file: overwrite=true + new_string=<content>, after a c3_read of it.
     If this call ERRORS OR TIMES OUT, do not retry blind — a failed c3_edit may still have
     written the file. Re-send the same args to c3_edits(action='verify') for a verdict."""
     path_err = validate_file_path(file_path)
@@ -920,7 +926,8 @@ async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
     resp = await asyncio.to_thread(handle_edit, file_path, old_string, new_string,
-                                   summary, tags, replace_all, svc, finalize, edits)
+                                   summary, tags, replace_all, svc, finalize, edits,
+                                   overwrite)
     return _with_hint(resp, lambda: delegate_hints.after_edit(
         svc, file_path, delegate_hints.edit_chars(new_string, edits)))
 

cli/tools/_edit_report.py

@@ -4,8 +4,9 @@ Two concerns, both read-only:
 - ``locate``: a RELATIVE file_path resolves against the project root, which is
   the main checkout. When the repo has other git worktrees, the caller may have
   meant one of them, so the response names the resolved path and any worktree
-  holding the same relative path, and refuses outright when the path exists only
-  in a worktree.
+  holding the same relative path. It refuses outright when the path exists only
+  in a worktree, or when this process last wrote to a worktree that the path
+  could equally mean.
 - ``diff_block``: a compact unified diff of the whole file, before → after.
 """
 import difflib
@@ -19,6 +20,7 @@ from pathlib import Path
 _WORKTREE_TTL_S = 60.0
 _GIT_TIMEOUT_S = 3.0
 _worktree_cache: dict[str, tuple[float, list[Path]]] = {}
+_last_tree: dict[str, Path] = {}
 _cache_lock = threading.Lock()
 
 DIFF_MAX_LINES = 24
@@ -98,13 +100,26 @@ def _other_trees(project_root: Path, roots: list[Path]) -> list[tuple[Path, Path
     return [(root, root / prefix) for root in roots if root != own]
 
 
+def note_write(path: Path, project_path: str) -> None:
+    """Record the worktree a write landed in, for ``locate`` to compare the
+    next relative path against."""
+    holding = [r for r in worktree_roots(project_path)
+               if r == path or r in path.parents]
+    if holding:
+        with _cache_lock:
+            _last_tree[str(Path(project_path).resolve())] = max(
+                holding, key=lambda r: len(r.parts))
+
+
 def locate(file_path: str, path: Path, project_path: str) -> tuple[str, str]:
     """Check a resolved edit target against the repo's other worktrees.
 
     Returns ``(refusal, note)``, at most one non-empty. ``refusal`` is set when a
     relative ``file_path`` does not exist in this checkout but does in another
-    worktree. ``note`` is extra response text for a relative path in a repo
-    with other worktrees. Absolute paths always return ``("", "")``.
+    worktree, or when the last write went to another worktree where the path
+    exists or would be created. ``note`` is extra response text for a relative
+    path in a repo with other worktrees. Absolute paths always return
+    ``("", "")``.
     """
     if Path(file_path).is_absolute():
         return "", ""
@@ -117,6 +132,18 @@ def locate(file_path: str, path: Path, project_path: str) -> tuple[str, str]:
     except ValueError:
         return "", ""
     hits = [proj / rel for _, proj in others if (proj / rel).exists()]
+    with _cache_lock:
+        last = _last_tree.get(str(project_root))
+    recent = next((proj / rel for root, proj in others if root == last), None)
+    if recent is not None and (recent.exists() or not path.exists()):
+        there = ("where the same path is" if recent.exists()
+                 else "where this path would be")
+        return (f"[c3_edit:wrong-tree] {file_path} is relative, so it means "
+                f"{path} in this checkout, but this session's last edit went "
+                f"to another git worktree, {there}:\n"
+                f"    {recent}\n"
+                f"  Nothing was written. Pass the absolute path of the one "
+                f"you mean."), ""
     if not path.exists() and hits:
         listed = "\n".join(f"    {h}" for h in hits)
         return (f"[c3_edit:wrong-tree] {file_path} does not exist in this checkout "

cli/tools/edit.py

@@ -15,21 +15,108 @@ Parallel safety:
 See docs/agent-locks.md §5 (Layer A).
 """
 import bisect
+import codecs
 import difflib
 import hashlib
 import json
 import os
 import re
 import threading
+import time
 from contextlib import contextmanager
 from pathlib import Path
 
 from cli.tools import _edit_report, _grants
+from cli.tools._helpers import finalize_with_tokens
 from services import access_guard, agent_locks, edit_blobs, read_stamps
 from services import credential_store as _cs
 from services.atomic_json import write_bytes_atomic
 from services.task_store import _FileLock
 
+_FAILURES = {
+    "missing param": "invalid",
+    "bad edits param": "invalid",
+    "empty old_string": "invalid",
+    "bad overwrite": "invalid",
+    "vault-protected": "denied",
+    "access-denied": "denied",
+    "wrong tree": "wrong_tree",
+    "lock held": "locked",
+    "lock busy": "locked",
+    "stale read": "stale",
+    "not found": "not_found",
+    "ambiguous": "ambiguous",
+    "lookalike": "lookalike",
+    "encoding": "encoding",
+    "unread": "unread",
+    "read error": "io_error",
+    "write error": "io_error",
+    "create error": "io_error",
+}
+_NOOP = "noop"
+_BATCH_FAILURES = {"miss": "not_found", "ambiguous": "ambiguous",
+                   "lookalike": "lookalike", "skipped": "invalid"}
+
+
+class _Report:
+    """`finalize` for one c3_edit call: records the outcome and wall time of
+    whichever exit is taken, and remembers in `wrote` whether it wrote.
+
+    The outcome is the `outcome` keyword when a call site passes one, else the
+    code `_FAILURES` gives the summary slug, else "success". Other keywords
+    land in the telemetry detail. `ok` reaches the activity log, which the
+    enforcement hook reads to decide whether this call unlocks native Edit.
+    """
+
+    def __init__(self, finalize, svc):
+        self._finalize = finalize
+        self._svc = svc
+        self._started = time.monotonic()
+        self.wrote = False
+
+    def __call__(self, tool, args, text, summary="", **detail):
+        outcome = detail.pop("outcome", "") or _FAILURES.get(summary, "success")
+        self.wrote = outcome == "success"
+        return finalize_with_tokens(
+            self._finalize, self._svc, tool, args, text, summary,
+            duration_ms=round((time.monotonic() - self._started) * 1000, 1),
+            detail={"outcome": outcome, **detail},
+            ok=outcome in ("success", _NOOP))
+
+
+_in_flight: dict[tuple[str, str], dict] = {}
+
+
+@contextmanager
+def _lease_scope(path: Path, project_path: str, session_id: str, report):
+    """Give back the lease on `path` when this process's calls took it and
+    none of them wrote.
+
+    Calls on one path overlap (each runs on its own thread until
+    `_edit_lock`), so they are counted as a group: whether the session held
+    the lease is sampled when the group forms, and the lease is judged when
+    the last call leaves. A call that fails cannot drop the lease a
+    concurrent call is writing under.
+    """
+    key = (session_id, str(path))
+    with _locks_lock:
+        group = _in_flight.get(key)
+        if group is None:
+            group = _in_flight[key] = {
+                "calls": 0,
+                "keep": agent_locks.holds(str(path), project_path, session_id)}
+        group["calls"] += 1
+    try:
+        yield
+    finally:
+        with _locks_lock:
+            group["calls"] -= 1
+            group["keep"] = group["keep"] or report.wrote
+            if group["calls"] == 0:
+                del _in_flight[key]
+                if not group["keep"]:
+                    agent_locks.give_back(str(path), project_path, session_id)
+
 
 def _session_id(svc) -> str:
     """This agent's lease identity — see `cli.tools._grants.session_id`.
@@ -107,6 +194,24 @@ def _read_preserving_newlines(path: Path) -> str:
     return path.read_bytes().decode("utf-8", errors="surrogateescape")
 
 
+# UTF-32 first: its little-endian BOM begins with the UTF-16 one.
+_FOREIGN_BOMS = ((codecs.BOM_UTF32_LE, "UTF-32"), (codecs.BOM_UTF32_BE, "UTF-32"),
+                 (codecs.BOM_UTF16_LE, "UTF-16"), (codecs.BOM_UTF16_BE, "UTF-16"))
+
+
+def _encoding_refusal(raw: bytes, file_label: str) -> str:
+    """A refusal when `raw` opens with a UTF-16 or UTF-32 byte-order mark,
+    else "". Read as UTF-8 such a file is NUL-separated characters that no
+    old_string matches."""
+    name = next((n for bom, n in _FOREIGN_BOMS if raw.startswith(bom)), "")
+    if not name:
+        return ""
+    return (f"[c3_edit:encoding] {file_label} is {name} text. c3_edit and "
+            f"c3_read work on UTF-8 only, so nothing was written.\n"
+            f"  Convert the file to UTF-8 first, or change it with the tool "
+            f"that owns it.")
+
+
 def _write_preserving_newlines(path: Path, content: str) -> None:
     """Atomically replace `path` with `content`, encoded the way it was read.
 
@@ -137,10 +242,10 @@ def _dominant_eol(text: str, default: str = "\n") -> str:
     return max(_EOLS, key=counts.__getitem__)
 
 
-# Unicode lookalike substitutions used as a fallback when the literal
-# old_string is not found. Strictly 1:1 (same-length) substitutions so
-# positions are preserved — we locate the match on the normalized string
-# and splice the replacement into the original content at the same offsets.
+# Typographic characters a model tends to retype as ASCII. An old_string that
+# matches only after this fold is refused, not applied: new_string would
+# overwrite the file's characters inside the span with the retyped ones.
+# Strictly 1:1 so a folded offset is also an offset in the file text.
 _LOOKALIKE_TRANS = str.maketrans({
     "‘": "'", "’": "'", "‚": "'", "‛": "'",  # single curly quotes
     "“": '"', "”": '"', "„": '"', "‟": '"',  # double curly quotes
@@ -173,8 +278,7 @@ def _positional_replace(content: str, view: str, crlf_at: list, needle: str,
                         new: str, replace_all: bool, file_eol: str) -> str:
     """Replace `needle` found in `view` by splicing `new` into `content`.
 
-    `view` is `content` with every EOL as ``\\n`` (optionally lookalike-folded,
-    which is 1:1); `crlf_at` holds the sorted view offsets of the ``\\n``
+    `view` is `content` with every EOL as ``\\n``; `crlf_at` holds the sorted view offsets of the ``\\n``
     characters that are ``\\r\\n`` in `content`, so view offset v is raw
     offset v + bisect_left(crlf_at, v). `new` uses ``\\n`` and is written with
     the dominant EOL of the span it replaces (`file_eol` when that span has
@@ -203,15 +307,16 @@ def _apply_replacement(content: str, old: str, new: str, replace_all: bool):
     """Replace `old` with `new` in `content` without disturbing other bytes.
 
     Matching ignores EOL style (``\\r\\n``, ``\\r`` and ``\\n`` are equal), so a
-    LF old_string matches a CRLF, CR-only or mixed file; on zero matches it
-    retries with unicode-lookalike normalization (curly quotes, unicode
-    dashes, NBSP). Only the matched spans change.
-
-    Returns (new_content, count, used_fallback):
-      - (str, count, bool) when at least one match was applied
-      - (None, 0, False)   when no match is found (even after fallback), or
-                           `old` is empty
-      - (None, count, bool) when count > 1 and replace_all is False
+    LF old_string matches a CRLF, CR-only or mixed file, and reads an
+    undecodable byte as the U+FFFD that c3_read showed for it. Only the
+    matched spans change.
+
+    Returns (new_content, count, lookalike):
+      - (str, count, False)   when at least one match was applied
+      - (None, 0, False)      when no match is found, or `old` is empty
+      - (None, count, False)  when count > 1 and replace_all is False
+      - (None, count, True)   when `old` matches only after the lookalike
+                              fold; never applied
     """
     if not old:
         return (None, 0, False)
@@ -220,21 +325,18 @@ def _apply_replacement(content: str, old: str, new: str, replace_all: bool):
     crlf_at = [m.start() - k for k, m in enumerate(re.finditer("\r\n", content))]
     file_eol = _dominant_eol(content)
 
-    used_fallback = False
+    # c3_read shows an undecodable byte and a real U+FFFD alike, so the two
+    # are one character here: an old_string that fits both is ambiguous.
+    view = view.translate(_SURROGATE_TRANS)
+    old = old.translate(_SURROGATE_TRANS)
     count = view.count(old)
     if count == 0:
-        nv, no = _norm(view), _norm(old)
-        if nv == view and no == old:
-            # Neither side contained any lookalike chars — genuinely not found.
-            return (None, 0, False)
-        view, old, used_fallback = nv, no, True
-        count = view.count(old)
-        if count == 0:
-            return (None, 0, False)
+        folded = _norm(view).count(_norm(old))
+        return (None, folded, folded > 0)
     if count > 1 and not replace_all:
-        return (None, count, used_fallback)
+        return (None, count, False)
     return (_positional_replace(content, view, crlf_at, old, new, replace_all,
-                                file_eol), count, used_fallback)
+                                file_eol), count, False)
 
 
 def _closest_region(content: str, old: str,
@@ -293,35 +395,80 @@ def _closest_region(content: str, old: str,
 _REGION_CAP = 4000
 
 
-def _not_found_payload(near, file_label: str) -> str:
-    """Render a _closest_region result as an error-message appendix. The
-    region text is emitted verbatim (no indentation) so it can be copied
-    straight into a retry old_string."""
-    if not near:
-        return ""
-    lo, hi, region, ratio = near
+def _marked_region(lo: int, hi: int, region: str, file_label: str) -> str:
+    """File lines lo..hi between markers, verbatim and unindented so they can
+    be copied straight into a retry old_string."""
     region = _display_safe(region)
     if len(region) > _REGION_CAP:
         region = (region[:_REGION_CAP]
                   + f"\n⟦trimmed — run c3_read(file_path='{file_label}', "
                   f"lines=[{lo},{hi}]) for the rest⟧")
+    return f"⟦L{lo}-L{hi}⟧\n{region}\n⟦end⟧\n"
+
+
+def _not_found_payload(near, file_label: str) -> str:
+    """Render a _closest_region result as an error-message appendix."""
+    if not near:
+        return ""
+    lo, hi, region, ratio = near
     return (f"\n  closest match: L{lo}-L{hi} ({ratio:.0%} similar). "
             f"Actual file text between the markers:\n"
-            f"⟦L{lo}-L{hi}⟧\n{region}\n⟦end⟧\n"
-            f"  Retry with old_string copied exactly from the text above "
-            f"(markers excluded) — no need to re-read the file.")
+            + _marked_region(lo, hi, region, file_label)
+            + "  Retry with old_string copied exactly from the text above "
+              "(markers excluded) — no need to re-read the file.")
+
+
+def _revert_note(project_path, images: dict) -> str:
+    """Response text for a write that c3_edits(action='revert') will refuse:
+    no post-image hash on the row, or a pre-image that is not in the store."""
+    blob = images.get("blob") or ""
+    if not blob.startswith("skipped:"):
+        return ""
+    pre = images.get("pre_sha256")
+    if "post_sha256" in images and (
+            pre is None or edit_blobs.has(project_path, pre)):
+        return ""
+    return (f"\n  ⚠ c3_edits cannot revert this edit: the file as it was "
+            f"before is not kept ({blob.partition(':')[2]}).")
+
+
+def _lookalike_payload(content: str, old: str, count: int,
+                       file_label: str) -> str:
+    """The file's own text for the first place `old` matches after the
+    lookalike fold, as an error-message appendix."""
+    view, old = _eol_norm(content), _eol_norm(old)
+    pos = _norm(view).find(_norm(old))
+    lo = view.count("\n", 0, pos) + 1
+    hi = lo + old.removesuffix("\n").count("\n")
+    region = "\n".join(view.split("\n")[lo - 1:hi])
+    places = f" ({count} places; the first is shown)" if count > 1 else ""
+    return (f"\n  It matches only when curly quotes, dashes and non-breaking "
+            f"spaces are read as their ASCII lookalikes{places}. "
+            f"Nothing was written.\n"
+            f"  Actual file text between the markers:\n"
+            + _marked_region(lo, hi, region, file_label)
+            + "  Retry with old_string copied exactly from the text above "
+              "(markers excluded), and keep those characters in new_string "
+              "unless you mean to change them.")
 
 
 def handle_edit(file_path: str, old_string: str, new_string: str,
                 summary: str, tags: str, replace_all: bool,
-                svc, finalize, edits: str = "") -> str:
+                svc, finalize, edits: str = "", overwrite: bool = False) -> str:
     """Find old_string in file, replace with new_string, write back, log to ledger.
 
     edits: optional JSON list of {old_string, new_string, summary?} dicts for
            batch same-file patching in a single read/write cycle.
+    overwrite: replace all of an existing file with new_string. The session
+           must have read the file, and it must not have changed since.
     """
+    finalize = _Report(finalize, svc)
     if not file_path:
         return finalize("c3_edit", {}, "file_path is required", "missing param")
+    if overwrite and (old_string or edits):
+        return finalize("c3_edit", {"file": file_path},
+                        "overwrite replaces the whole file: pass new_string "
+                        "only, without old_string or edits", "bad overwrite")
 
     # Resolve path
     path = Path(file_path)
@@ -345,6 +492,16 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
     if wrong_tree:
         return finalize("c3_edit", {"file": file_path}, wrong_tree, "wrong tree")
 
+    with _lease_scope(path, svc.project_path, _session_id(svc), finalize):
+        return _gated_edit(path, rel, file_path, old_string, new_string,
+                           summary, tags, replace_all, svc, finalize, edits,
+                           where, overwrite)
+
+
+def _gated_edit(path: Path, rel: str, file_path: str, old_string: str,
+                new_string: str, summary: str, tags: str, replace_all: bool,
+                svc, finalize, edits: str, where: str, overwrite: bool) -> str:
+    """The write gates, then the edit under `_edit_lock`."""
     op = "write" if path.exists() else "create"
     refusal = _write_gate(svc, path, rel, file_path, op, "c3_edit", summary,
                           finalize)
@@ -357,6 +514,9 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
     # loser's content is silently gone.
     try:
         with _edit_lock(path):
+            if overwrite and path.exists():
+                return _overwrite_locked(path, rel, file_path, new_string,
+                                         summary, tags, svc, finalize, where)
             return _edit_locked(path, rel, file_path, old_string, new_string,
                                 summary, tags, replace_all, svc, finalize, edits,
                                 where)
@@ -368,6 +528,9 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
             f"  This is contention, not an error — do not route around it via "
             f"c3_shell or native Write. Retry, or edit a different file.",
             "lock busy")
+    finally:
+        if finalize.wrote:
+            _edit_report.note_write(path, svc.project_path)
 
 
 def _write_gate(svc, path: Path, rel: str, file_path: str, op: str,
@@ -398,12 +561,69 @@ def _write_gate(svc, path: Path, rel: str, file_path: str, op: str,
     session_id = _session_id(svc)
     holder = agent_locks.check(str(path), svc.project_path, session_id)
     if holder:
-        return finalize(tool, {"file": file_path},
+        held_for = round(time.time() - holder.get("acquired_at", time.time()))
+        return finalize(tool, {"file": file_path,
+                               "holder": holder.get("agent_id", ""),
+                               "held_for_s": held_for},
                         agent_locks.refusal(holder, rel), "lock held")
     agent_locks.lease(str(path), svc.project_path, session_id, intent=intent)
     return None
 
 
+def _overwrite_locked(path: Path, rel: str, file_path: str, new_string: str,
+                      summary: str, tags: str, svc, finalize, where: str) -> str:
+    """Replace all of an existing file, keeping its line endings and BOM.
+    Always called under _edit_lock."""
+    args = {"file": file_path, "overwrite": True}
+    try:
+        pre_image = path.read_bytes()
+    except OSError as e:
+        return finalize("c3_edit", args, f"Read error: {e}", "read error")
+    slug = "unread" if read_stamps.get(path) is None else "stale read"
+    guard = read_stamps.check_whole(path, file_path, pre_image)
+    if guard.refusal:
+        return finalize("c3_edit", args, guard.refusal, slug)
+    foreign = _encoding_refusal(pre_image, file_path)
+    if foreign:
+        return finalize("c3_edit", args, foreign, "encoding")
+
+    content = pre_image.decode("utf-8", errors="surrogateescape")
+    eol = _dominant_eol(content)
+    new_content = _eol_norm(new_string)
+    if eol != "\n":
+        new_content = new_content.replace("\n", eol)
+    if content.startswith("") and not new_content.startswith(""):
+        new_content = "" + new_content
+    if new_content == content:
+        return finalize("c3_edit", args,
+                        f"{rel} unchanged — new_string is the file's current "
+                        f"text; nothing was written or logged.",
+                        f"{rel} unchanged", outcome=_NOOP, n_attempted=1,
+                        n_applied=0)
+
+    edit_blobs.keep_pre(svc.project_path, path, pre_image)
+    try:
+        _write_preserving_newlines(path, new_content)
+        guard.written()
+    except Exception as e:
+        return finalize("c3_edit", args, f"Write error: {e}", "write error")
+
+    images = edit_blobs.record_edit(svc.project_path, path, pre_image)
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
+    n_old = len(content.splitlines())
+    n_new = len(new_content.splitlines())
+    deferred = _log_to_ledger(
+        rel, summary or f"Overwrote {rel} ({n_new}L)", tag_list, svc,
+        detail={"old_string": "", "new_string": new_string[:_DETAIL_CAP],
+                "overwritten": True, **images})
+    short = (f"✓ {rel} [overwritten, -{n_old}+{n_new}L]"
+             + (f" — {summary}" if summary else "")
+             + where + _revert_note(svc.project_path, images) + _display_safe(
+                 _edit_report.diff_block(content, new_content, svc.project_path)))
+    return finalize("c3_edit", args, short + deferred, f"{rel} overwritten",
+                    n_attempted=1, n_applied=1, blob=images.get("blob"))
+
+
 def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
                  new_string: str, summary: str, tags: str, replace_all: bool,
                  svc, finalize, edits: str, where: str = "") -> str:
@@ -444,9 +664,11 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
             rel, create_summary, tag_list, svc,
             detail={"old_string": "", "new_string": new_string[:_DETAIL_CAP],
                     "created": True, **images})
-        short = f"✓ {rel} [created, +{n_new}L]" + (f" — {summary}" if summary else "") + where
+        short = (f"✓ {rel} [created, +{n_new}L]" + (f" — {summary}" if summary else "")
+                 + where + _revert_note(svc.project_path, images))
         return finalize("c3_edit", {"file": file_path}, short + deferred,
-                        f"{rel} created")
+                        f"{rel} created", n_attempted=1, n_applied=1,
+                        blob=images.get("blob"))
 
     # Parse tag list once
     tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else None
@@ -475,11 +697,13 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
         except Exception as e:
             return finalize("c3_edit", {"file": file_path},
                             f"Read error: {e}", "read error")
+        foreign = _encoding_refusal(pre_image, file_path)
+        if foreign:
+            return finalize("c3_edit", {"file": file_path}, foreign, "encoding")
         original = content
 
         results = []
-        statuses = []   # parallel to results: 'ok' | 'miss' | 'ambiguous' | 'skipped' | 'noop'
-        any_normalized = False
+        statuses = []   # parallel to results: 'ok' | 'miss' | 'lookalike' | 'ambiguous' | 'skipped' | 'noop'
         first_miss = ""
         for i, patch in enumerate(edit_list):
             old = patch.get("old_string", "")
@@ -492,9 +716,22 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
                 statuses.append("skipped")
                 continue
 
-            new_content, count, used_fallback = _apply_replacement(content, old, new, r_all)
+            new_content, count, lookalike = _apply_replacement(content, old, new, r_all)
+            if lookalike:
+                results.append(f"  patch[{i}]: LOOKALIKE ONLY — {old[:80]!r}")
+                statuses.append("lookalike")
+                if not first_miss:
+                    on_disk = _apply_replacement(original, old, new, r_all)
+                    first_miss = (
+                        _lookalike_payload(original, old, on_disk[1], file_path)
+                        if on_disk[2] else
+                        _lookalike_payload(content, old, count, file_path))
+                continue
             if new_content is None and count == 0:
-                near = _closest_region(_eol_norm(content), _eol_norm(old))
+                # Nothing is written on a miss, so line numbers are the
+                # file's; an earlier patch's result is the second choice.
+                near = (_closest_region(_eol_norm(original), _eol_norm(old))
+                        or _closest_region(_eol_norm(content), _eol_norm(old)))
                 loc = (f" (closest: L{near[0]}-L{near[1]}, {near[3]:.0%} similar)"
                        if near else "")
                 results.append(f"  patch[{i}]: NOT FOUND — {old[:80]!r}{loc}")
@@ -503,8 +740,7 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
                     first_miss = _not_found_payload(near, file_path)
                 continue
             if new_content is None:
-                tag = " (unicode-normalized)" if used_fallback else ""
-                results.append(f"  patch[{i}]: AMBIGUOUS ({count} matches){tag} — {old[:60]!r}")
+                results.append(f"  patch[{i}]: AMBIGUOUS ({count} matches) — {old[:60]!r}")
                 statuses.append("ambiguous")
                 continue
             if new_content == content:
@@ -515,65 +751,73 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
 
             content = new_content
             n = count if r_all else 1
-            if used_fallback:
-                any_normalized = True
 
             n_old = old.count("\n") + 1
             n_new = new.count("\n") + 1
             desc = patch_summary or f"{old[:50]!r} → {new[:50]!r}"
             results.append(f"  patch[{i}]: -{n_old}L +{n_new}L"
                             + (f" ({n}x)" if n > 1 else "")
-                            + (" [norm]" if used_fallback else "")
                             + f" | {desc}")
             statuses.append("ok")
 
-        # Only touch the file when the patches changed it — no rewrite and no
-        # phantom ledger entry when every patch missed or was a no-op.
-        changed = content != original
-        if changed:
-            try:
-                _write_preserving_newlines(path, content)
-                stale.written()
-            except Exception as e:
-                return finalize("c3_edit", {"file": file_path},
-                                f"Write error: {e}", "write error")
-
-        # Log batch to ledger as one entry (store each patch's old/new for diff view)
-        deferred = ""
-        if changed:
-            batch_detail = {"patches": [
-                {
-                    "old_string": p.get("old_string", "")[:_DETAIL_CAP],
-                    "new_string": p.get("new_string", "")[:_DETAIL_CAP],
-                    **({"summary": p["summary"]} if p.get("summary") else {}),
-                }
-                for p in edit_list if p.get("old_string") is not None
-            ]}
-            batch_detail.update(
-                edit_blobs.record_edit(svc.project_path, path, pre_image))
-            deferred = _log_to_ledger(
-                rel, summary or f"Batch edit: {len(edit_list)} patches",
-                tag_list, svc, detail=batch_detail)
-
-        # Classify from the structured status list, not by substring-scanning
-        # the human-readable result lines — a patch *summary* containing words
-        # like 'NOT FOUND' used to be miscounted as a failure.
+        # All or nothing: the patches that did match are half of a change
+        # once one of them cannot be placed.
+        total = len(edit_list)
+        failed = [r for r, s in zip(results, statuses) if s in _BATCH_FAILURES]
+        if failed:
+            outcome = next(_BATCH_FAILURES[s] for s in statuses
+                           if s in _BATCH_FAILURES)
+            return finalize(
+                "c3_edit", {"file": file_path},
+                f"{rel} unchanged — {len(failed)} of {total} patches could not "
+                f"be placed, so none were applied.\n" + "\n".join(failed)
+                + first_miss
+                + "\n  Resend the whole batch with those patches corrected.",
+                f"{rel} batch refused", outcome=outcome, n_attempted=total,
+                n_applied=0)
+
+        unchanged = [r for r, s in zip(results, statuses) if s == "noop"]
+        if content == original:
+            return finalize(
+                "c3_edit", {"file": file_path},
+                f"{rel} unchanged — no patch changes the text; nothing was "
+                f"written or logged.\n" + "\n".join(unchanged),
+                f"{rel} unchanged", outcome=_NOOP, n_attempted=total,
+                n_applied=0)
+
+        edit_blobs.keep_pre(svc.project_path, path, pre_image)
+        try:
+            _write_preserving_newlines(path, content)
+            stale.written()
+        except Exception as e:
+            return finalize("c3_edit", {"file": file_path},
+                            f"Write error: {e}", "write error")
+
+        # One ledger entry for the batch, with each patch's old/new for the diff view.
+        batch_detail = {"patches": [
+            {
+                "old_string": p.get("old_string", "")[:_DETAIL_CAP],
+                "new_string": p.get("new_string", "")[:_DETAIL_CAP],
+                **({"summary": p["summary"]} if p.get("summary") else {}),
+            }
+            for p in edit_list if p.get("old_string") is not None
+        ]}
+        batch_detail.update(
+            edit_blobs.record_edit(svc.project_path, path, pre_image))
+        deferred = _log_to_ledger(
+            rel, summary or f"Batch edit: {total} patches",
+            tag_list, svc, detail=batch_detail)
+
         applied = statuses.count("ok")
-        norm_tag = " [unicode-normalized]" if any_normalized else ""
-        short = f"✓ {rel} — {applied}/{len(edit_list)} patches applied{norm_tag}"
-        if not changed:
-            short = (f"{rel} unchanged — {applied}/{len(edit_list)} patches "
-                     f"applied; nothing was written or logged.")
-        if applied < len(edit_list):
-            failed = [r for r, s in zip(results, statuses) if s != "ok"]
-            short += "\n" + "\n".join(failed)
-            if first_miss:
-                short += first_miss
-        if changed:
-            short += where + _display_safe(
-                _edit_report.diff_block(original, content, svc.project_path))
+        short = (f"✓ {rel} — {applied}/{total} patches applied"
+                 + "".join(f"\n{r}" for r in unchanged)
+                 + where + _revert_note(svc.project_path, batch_detail)
+                 + _display_safe(
+                     _edit_report.diff_block(original, content, svc.project_path)))
         return finalize("c3_edit", {"file": file_path}, short + deferred,
-                        f"{rel} patched ({len(edit_list)} patches)")
+                        f"{rel} patched ({applied}/{total} patches)",
+                        n_attempted=total, n_applied=applied,
+                        blob=batch_detail.get("blob"))
 
     # ── Single-edit mode ──────────────────────────────────────────────────────
     if not old_string:
@@ -587,34 +831,41 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
     except Exception as e:
         return finalize("c3_edit", {"file": file_path},
                         f"Read error: {e}", "read error")
+    foreign = _encoding_refusal(pre_image, file_path)
+    if foreign:
+        return finalize("c3_edit", {"file": file_path}, foreign, "encoding")
 
-    new_content, count, used_fallback = _apply_replacement(
+    new_content, count, lookalike = _apply_replacement(
         content, old_string, new_string, replace_all)
 
+    if lookalike:
+        return finalize("c3_edit", {"file": file_path},
+                        f"[c3_edit:lookalike] old_string is not in {file_path} "
+                        f"as written."
+                        + _lookalike_payload(content, old_string, count, file_path),
+                        "lookalike")
     if new_content is None and count == 0:
-        hint = ""
-        if _norm(old_string) != old_string or _norm(content) != content:
-            hint = "\n  hint: unicode-lookalike normalization also failed to match."
-        hint += _not_found_payload(
+        hint = _not_found_payload(
             _closest_region(_eol_norm(content), _eol_norm(old_string)), file_path)
         return finalize("c3_edit", {"file": file_path},
                         f"old_string not found in {file_path}\n"
                         f"  searched for: {old_string[:120]!r}{hint}",
                         "not found")
     if new_content is None:
-        hint = " (after unicode-lookalike normalization)" if used_fallback else ""
         return finalize("c3_edit", {"file": file_path},
-                        f"old_string matches {count} locations{hint} — add more context to make it unique, "
+                        f"old_string matches {count} locations — add more context to make it unique, "
                         f"or pass replace_all=true to replace all occurrences.",
                         "ambiguous")
 
     if new_content == content:
         return finalize("c3_edit", {"file": file_path},
                         f"{rel} unchanged — new_string equals old_string; "
-                        f"nothing was written or logged.", f"{rel} unchanged")
+                        f"nothing was written or logged.", f"{rel} unchanged",
+                        outcome=_NOOP, n_attempted=1, n_applied=0)
 
     occurrences = count if replace_all else 1
 
+    edit_blobs.keep_pre(svc.project_path, path, pre_image)
     try:
         _write_preserving_newlines(path, new_content)
         stale.written()
@@ -629,8 +880,6 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
         "old_string": old_string[:_DETAIL_CAP],
         "new_string": new_string[:_DETAIL_CAP],
     }
-    if used_fallback:
-        single_detail["unicode_normalized"] = True
     single_detail.update(
         edit_blobs.record_edit(svc.project_path, path, pre_image))
     deferred = _log_to_ledger(rel, auto_summary, tag_list, svc,
@@ -640,12 +889,13 @@ def _edit_locked(path: Path, rel: str, file_path: str, old_string: str,
     n_new = new_string.count("\n") + 1
     delta = f"-{n_old}+{n_new}L"
     occ = f" ({occurrences}x)" if occurrences > 1 else ""
-    norm_tag = " [unicode-normalized]" if used_fallback else ""
-    short = (f"✓ {rel} [{delta}]{occ}{norm_tag}" + (f" — {summary}" if summary else "")
-             + where + _display_safe(
+    short = (f"✓ {rel} [{delta}]{occ}" + (f" — {summary}" if summary else "")
+             + where + _revert_note(svc.project_path, single_detail)
+             + _display_safe(
                  _edit_report.diff_block(content, new_content, svc.project_path)))
     return finalize("c3_edit", {"file": file_path}, short + deferred,
-                    f"{rel} patched")
+                    f"{rel} patched", n_attempted=1, n_applied=1,
+                    blob=single_detail.get("blob"))
 
 
 _DETAIL_CAP = 2000  # chars stored per old/new string in the ledger

cli/tools/edit_verify.py

@@ -244,12 +244,11 @@ def verify(file_path: str, old_string: str, new_string: str, edits: str,
                             str(patch.get("new_string", "")), ledger, rel, limit)
             verdicts.append(r["verdict"])
             lines.append(f"  patch[{i}]: {r['verdict']} — {r['why']}")
-        # A batch writes once, so a mixed result means individual hunks did not
-        # match — not that the file was left half-written. Say so, rather than
-        # letting the caller infer a torn write that cannot happen.
-        lines.append("  note: c3_edit's batch mode writes the file once after "
-                     "applying every hunk in memory, so a mixed result means "
-                     "some hunks did not match — not a partial write.")
+        # Say what a mixed result means, rather than letting the caller infer
+        # a torn write that cannot happen.
+        lines.append("  note: c3_edit applies a batch whole or not at all, so "
+                     "a mixed result means the batch was refused or the file "
+                     "changed afterwards — not a partial write.")
         counts = {v: verdicts.count(v) for v in sorted(set(verdicts))}
         summary = ", ".join(f"{n} {v.lower()}" for v, n in counts.items())
         return "\n".join(lines), f"{rel}: {summary}"

{code_context_control-2.152.0.dist-info → code_context_control-2.153.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.152.0
+Version: 2.153.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.152.0.dist-info → code_context_control-2.153.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 cli/__init__.py,sha256=ec66drCZGNMRU4V6ov0zVhYZph1us12Vn8OvG_LJyRY,22
 cli/_hook_utils.py,sha256=RhfS2WS5VMSi2w2Jxcts1wg5WC-UFp89JOQvcO5Jjb8,23002
 cli/_shell_writes.py,sha256=XzUNlUDljmg-wZxK03xHnRe36WeQxe4tpO9HKVFwP5o,5090
-cli/c3.py,sha256=RiJDVqJAqlnm1tjqM-ytMi8O3VPf-Lx2eAVQeNgqCxE,431810
+cli/c3.py,sha256=CPRYdoG-9oXxk71V6ISYoMSjIFmq3FC9li8NxYS5ixY,431810
 cli/docs.html,sha256=pPxcP5ieY0DcfEDvegwIcRxbz1woLZoKLVSF-4JVy0Q,146784
 cli/edits.html,sha256=UjAhoCmBmQ89cklGvJqzC6eyNP2tc8H6T-e01DVkLvE,43418
 cli/hook_access_guard.py,sha256=tzK3pQBGehDDZi6fECcYk8nRhy0QkmUtTF2TuJG7nbY,27928
@@ -26,7 +26,7 @@ cli/hook_terse_advisor.py,sha256=W_zaTfX2akgX-ifuUTsLu2H1atM8XmWt6jpPoeU7Pm0,625
 cli/hub_server.py,sha256=VgDAlVmWgvh57KUbMgL2PT4303fmlr578QLk6ehe2pA,227863
 cli/hub_ui.html,sha256=v41R_JAH4Jwodpy3tbeBUel-80FbNmffBrey-QH5Q64,2963
 cli/mcp_proxy.py,sha256=r-Qhlie7gCtotex8yQUudCyBLRUK-IW6cNIW5RhBW0o,17648
-cli/mcp_server.py,sha256=0Gi0ajZ1ZUOJPlBhQxrGfxaVNsuXWUhPCActgltaGRk,74559
+cli/mcp_server.py,sha256=VzzsJFckLdtwXYnX_CH-57eObOUP-IN-i5IIb8BWu8Y,74956
 cli/progress.py,sha256=qTkNy0howOD3hXraMo4ok3dYTpBW5yG_tenKfF4UDM0,1470
 cli/server.py,sha256=dJOOXYU1zmN-UBuMmHhv8XlnknSyO8xj7mXWSDAGIBY,173188
 cli/ui.html,sha256=uuPwIJNKDQH_fsaR3xNB2AKky9WzKfaXnKr_k3aTtxo,5715
@@ -47,8 +47,8 @@ cli/guide/masking.html,sha256=BcsTxlnpRD-fdJKBKn7naUfXPfNFnU0lM4mPi4GLOqs,20126
 cli/guide/oracle.html,sha256=yRNN9xH8KPIT72C1bl9ZHv8m0ENvaFMvreN-gbtXXoo,33352
 cli/guide/sessions.html,sha256=fBcbX61mvy2T5fX9Lkojb8Gw7n2RZ4Oo95EE_SC5Q6A,31707
 cli/guide/shared.css,sha256=Mmm7W6aYxrkDq2RPOcyXiQFYGR-yB3auwX1uIWi6C74,15967
-cli/guide/tools.html,sha256=xi84IbAarhTNN7c1jYqUTwwYOKxf7F8LkdaA1kU2Z_8,133740
-cli/guide/workflow.html,sha256=T_5HW4YOPng02vrxBWknz4LYSx2vC9Iogdwb81YlWqA,78604
+cli/guide/tools.html,sha256=0XcaKfUZSt7oSHfjnhJcEAT8wtdGLO7w14LXZUnZfcA,134275
+cli/guide/workflow.html,sha256=NTTVmP0Ru8Y4xoL6Zmvk__eUgnpUD3Egvw2uaNMojJY,78600
 cli/hub_ui/app.js,sha256=AWzlFht1Fmn4559KfooKC03CvoG2I6AXbYUEZ2w8ZfU,7362
 cli/hub_ui/state.js,sha256=OrIQ_kx_wUdyiyXlKmMKC8bbKzMPve1ZuFClRXOrDEw,7593
 cli/hub_ui/components/add_project.js,sha256=j5m0mX0gePcEYQW_0vodJkw5v8Vn2lQqPAI0miIGdv4,3182
@@ -80,7 +80,7 @@ cli/hub_ui/components/task_board.js,sha256=QiWKmj1NkhkloGlfzZj_tWd7Sgz3xSxwVLp8I
 cli/hub_ui/components/toasts.js,sha256=caj_x3npcM_wMv9E_xEde88jyfXI-jt8RrDQW_yXz5k,3376
 cli/hub_ui/components/topbar.js,sha256=xg8RqDmJpweISw55NFT07tMiwrFaG9fpDEHHblzkLk4,4817
 cli/tools/__init__.py,sha256=HO6eVKzDm1KPqsKTHY6lfIsnFnv3C7Bd9o3Q_V88idg,127
-cli/tools/_edit_report.py,sha256=3TIhPoBDpqeXfB_oheAC0PhHi4k6f_fjDcGhM3wJ-vM,7058
+cli/tools/_edit_report.py,sha256=uZuhMQABN6z9R_FXusoYNNrdYrES3rhbADXmJupwc0c,8392
 cli/tools/_grants.py,sha256=xJwEZWC9r4exq0OuabQy-fFMZFayUYZe0Eub7NS3ikQ,4974
 cli/tools/_helpers.py,sha256=xhF6sSc9wcJjLQmFFipnUgxQusU1PDPcl0DGMGcgK6E,9420
 cli/tools/agent.py,sha256=RmEEh5HhCZLvYu0gSRcwA_NENpd4iIYJW3exBzT8kVs,47983
@@ -90,8 +90,8 @@ cli/tools/ci.py,sha256=1--Ak18ikHkO7q4HWlDCVac-U969eEFejkd-24T0xuY,20057
 cli/tools/compress.py,sha256=PcgxEw7KfofmJsTLfRf3mjWMxyNlqkcSNzMTlT27SW0,12534
 cli/tools/credentials.py,sha256=NczO0KT3LTJlD3ZedXWRAtH_8YTPhya0Txja3ystdzE,20039
 cli/tools/delegate.py,sha256=TrHPXEyufQh0in3Ay7XcOG5wQwCYbnbz9r4naIuhbN8,126990
-cli/tools/edit.py,sha256=vn1mOwSHmhoj48dnvi893c7Ou0hm4Jcu_wwj2gkt0Vg,33281
-cli/tools/edit_verify.py,sha256=lbuk9rLgOb3YnJmnG_eexGMPCAvduJmZbYxrIykVCqA,11972
+cli/tools/edit.py,sha256=YPcrXfOvaUCiddg9qABFXqEk9kb9TNHMLFEo2Xq-sBQ,44715
+cli/tools/edit_verify.py,sha256=3Y156LikO3Q4v0OSNjKDJUaOB3nRfceFvXCmpSV8amA,11858
 cli/tools/edits.py,sha256=Qkcl7Asa_qyIH2aIn5IYamfKavtfEZF429Bmg8TF0aY,10963
 cli/tools/federate.py,sha256=tE65p06gM6O_yzg08SKeficFCZUH0yOFhCHFUjlTRo0,5126
 cli/tools/filter.py,sha256=mwNabPe7bCvdsIGFsWc4E1HsfiRYx5ZevnxdsitJTAw,12702
@@ -132,7 +132,7 @@ cli/ui/components/sessions.js,sha256=FIKtil76B8tCkAmcFV7hlj6GQ_DCJK2jCzvEmdK7NBE
 cli/ui/components/settings.js,sha256=FXcn-UQE2mXC6HFsLeEas-wAUFKt0OJaLySroZQMhGA,84095
 cli/ui/components/sidebar.js,sha256=K2ym2kUgpbyG-EBA_wBIIiqQY8qTatsiBZwzseMWuIQ,9939
 cli/ui/components/tasks.js,sha256=vyKQ3uwoppMwvdEaHlhWXW4oWcAisx4NveqzMhsYqHo,38438
-code_context_control-2.152.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
+code_context_control-2.153.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
 core/__init__.py,sha256=TSDCEcM4V7gcZVM3w2ykJaqEUch4Dkon-rivV17T73s,2501
 core/codex_patch.py,sha256=CxvT_rQIwPNTRJZj9EHJmx0ZdOeSLxjiixuLI3Z7lPc,2107
 core/config.py,sha256=wCjrZKXRywUbR6WRcO7optyOirAQ2DeRNdPCU0X5zIY,23762
@@ -194,7 +194,7 @@ services/access_telemetry.py,sha256=9pOCLS9LgDtM7Z4cCEyl7osxhj-m3wsPubcXolBKuV4,
 services/activity_log.py,sha256=c_jTOsR-d1d5B3u67eg8mRA7LZhtP6H1-6leeGa0Go4,7990
 services/agent_base.py,sha256=a-gdSd_jtZtbjXo1WS8CnWCagXgKaGZd5ShcG6s0kT4,4809
 services/agent_downshift.py,sha256=hGFg-knqa6NUqmZUijyTDV82Fz88ieh1YjN_mG5tz8U,8444
-services/agent_locks.py,sha256=nRAPuRSoet7BG9oOsNyA5WhlNy-UMhpsq6z5ggIPmLA,22421
+services/agent_locks.py,sha256=1eCOiJ4UkpandhlgHqtO5DpwOjN7bGWYrEEE1puoFc0,23524
 services/agents.py,sha256=q3GgxyzomyjhbixARDQrSM3EpjIhboeKQY5jsQeHQ0g,83609
 services/agents_workflow.py,sha256=ttve887E6SIY2twHx_OxwFBEtLUcuok72_8g3ZkOAkE,502
 services/artifact_defs.py,sha256=4bJAcg2maJCtMhY3ub_IxZg49bVg1mD_B5Z4Bn5NF0o,9805
@@ -234,7 +234,7 @@ services/doc_index.py,sha256=cIb1jk4GrKK7cLwD6phoc04TvKA7Ee94kKHXxB7tT_k,19223
 services/e2e_benchmark.py,sha256=5Z3rE42o08MKVbIX_769V0RX2yAzSVcApCvdAQ9YLAU,134988
 services/e2e_evaluator.py,sha256=FsB4vMzcFUcmicfIwRtA8JZ_XeMpuk2_-86F2iVNEDc,17783
 services/e2e_tasks.py,sha256=Ln5VbGDIcS3NY3aml5ERbgjfjLxEslmRZ8AyaYxpWEo,34524
-services/edit_blobs.py,sha256=GnAeKFyxTduLaBSMtZJcjI1aRXZBpZqKNEDG37kQfQk,6041
+services/edit_blobs.py,sha256=iPxHo7k_FMq8tsAKmEyb1e7yVlDZmt5_udmTYJPrlNA,6548
 services/edit_ledger.py,sha256=Tj8Q14o19VHQHpofRHdbZKKcVs17v-ctZ3LOeVTqvdQ,29362
 services/embedding_index.py,sha256=wqq7odpGzAxyO-lxr6N1WusyEGInGgEQUjuEw445Bxs,27711
 services/enforcement_policy.py,sha256=znjABRB-8TSl0ELazY2ALzux2YJ5nWf8TvxLRhDsL2w,18905
@@ -281,7 +281,7 @@ services/project_manager.py,sha256=7NvQau5x0PCVagQsXpuXZ4VtXCkCfy9es_v1oEHmzgs,4
 services/project_runtime.py,sha256=yyftX48BFjq4B2KcR4KGszDAAa4xR6gn6j0SgTyro1s,11603
 services/protocol.py,sha256=CWZ0BWWd-jPui-11hZlvGgkNk18gMFhhLWbp-BP35Kk,12861
 services/proxy_state.py,sha256=u5rd0k6CrOsywZA8FpRu_hMLwhR0TAJhZjy5MdWbCGc,6107
-services/read_stamps.py,sha256=k1O9OikG26uVAYDKju3K8k5DmowA3zyabnyOTFK_yK8,9557
+services/read_stamps.py,sha256=CTAy350FJ079-mDBXFZXU5OXhUdPobGnYelkC28W65Q,10654
 services/repo_map.py,sha256=o-Z3c7ZqIxRKPyqquGafTngdooe1n-yRIcqpmOz5i2M,23208
 services/repo_shape.py,sha256=QF0mXkY-bnBU8Q8mc5iimw2YBhMgZ4IYhoPc09Z8OBQ,4978
 services/reranker.py,sha256=pnyNSzM7gXQ3ZodjY3rGIRCwpD2OIjookYkAJXb_LVE,4694
@@ -337,8 +337,8 @@ tui/screens/search_view.py,sha256=MMHjVdlk3HZSuDBSvq8IGrqv_Mh5Us6YqXQ80bcWSMk,19
 tui/screens/session_view.py,sha256=eZ1eDwHTvPOck1wCCviixtOaCxIkBT_95ytNNNriGNA,5991
 tui/screens/stats.py,sha256=p81PjzdaIv7hllb8f45-rlVe4lJZwSdIMqu7e86_u5s,6223
 tui/screens/ui_view.py,sha256=1QJCgLh2YfgWIpvzRG1KOGXYEaOYX6ojN61Azjf2oX0,2125
-code_context_control-2.152.0.dist-info/METADATA,sha256=W6GTn1zrn0N3Jp7mvhGalkGBBDAwxImBNz2pJ5XNuEI,28902
-code_context_control-2.152.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-code_context_control-2.152.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
-code_context_control-2.152.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
-code_context_control-2.152.0.dist-info/RECORD,,
+code_context_control-2.153.0.dist-info/METADATA,sha256=bdkGNw00IveYo5nIYOYSVzPnK_1f3BwZsQhAWrYdpG4,28902
+code_context_control-2.153.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+code_context_control-2.153.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
+code_context_control-2.153.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
+code_context_control-2.153.0.dist-info/RECORD,,

services/agent_locks.py

@@ -282,6 +282,18 @@ class LockStore:
                 return dict(row)
         return None
 
+    def held_by(self, path, session_id: str) -> bool:
+        """True when ``session_id`` has a live lease on ``path``."""
+        try:
+            rel = self._rel(path)
+        except UnsupportedPathError:
+            return False
+        now = self._clock()
+        return any(row.get("relpath") == rel
+                   and row.get("expires_at", 0) > now
+                   and row.get("session_id") == session_id
+                   for row in self._load()["locks"])
+
     # -- mutations ---------------------------------------------------------
 
     def acquire(self, paths, *, agent_id: str, session_id: str,
@@ -507,6 +519,24 @@ def lease(path, project_path=".", session_id: str = "", intent: str = "") -> boo
         return False
 
 
+def holds(path, project_path=".", session_id: str = "") -> bool:
+    """True when this session already has a live lease on ``path``. Never raises."""
+    try:
+        return store_for(project_path).held_by(path, session_id)
+    except Exception:
+        return False
+
+
+def give_back(path, project_path=".", session_id: str = "") -> bool:
+    """Drop this session's lease on ``path``, for a c3_edit call that took one
+    and then wrote nothing. Never raises."""
+    try:
+        res = store_for(project_path).release([path], session_id=session_id)
+        return bool(res.get("count"))
+    except Exception:
+        return False
+
+
 def refusal(holder: dict, path) -> str:
     """The agent-facing refusal. The last line is load-bearing: without an
     explicit 'do not route around this', models reach for c3_shell with a

services/edit_blobs.py

@@ -88,6 +88,11 @@ def get(project_path, sha: str) -> bytes | None:
     return data if sha256(data) == sha else None
 
 
+def has(project_path, sha: str) -> bool:
+    """True when a blob for ``sha`` is in the store."""
+    return bool(sha) and _blob_path(project_path, sha).exists()
+
+
 def sweep(project_path) -> int:
     """Evict oldest blobs until the store is within 90% of its cap.
 
@@ -153,6 +158,17 @@ def _skip_reason(project_path, path, pre: bytes | None,
     return ""
 
 
+def keep_pre(project_path, path, pre: bytes) -> None:
+    """Store the pre-image of a write that is about to happen, when policy
+    allows, so a crash after the write still leaves it. Never raises."""
+    if _skip_reason(project_path, path, pre, None):
+        return
+    try:
+        put(project_path, pre)
+    except OSError:
+        pass
+
+
 def record(project_path, path, pre: bytes | None,
            post: bytes | None) -> dict:
     """Ledger ``detail`` fields for a write that took ``path`` from ``pre`` to

services/read_stamps.py

@@ -227,6 +227,33 @@ def _region_block(text: str, lo: int, hi: int, label: str) -> str:
             f"⟦L{lo}-L{hi}⟧\n{region}\n⟦end⟧\n")
 
 
+def check_whole(path, label: str, raw: bytes) -> Guard:
+    """Compare `raw`, the bytes of `path` about to be replaced, to this
+    session's stamp.
+
+    Refuses when the session holds no stamp for the file, or when `raw`
+    differs from the stamp at all: every line is in the region being edited.
+    """
+    guard = Guard(path)
+    stamp = get(path)
+    if stamp is None:
+        guard.refusal = (
+            f"[c3_edit:unread] {label} has not been read in this session, and "
+            f"overwrite replaces all of it. Nothing was written.\n"
+            f"  Read it with c3_read, then resend.")
+        return guard
+    if hashlib.sha256(raw).hexdigest() == stamp.sha256:
+        return guard
+    where = (f": {_fmt(changed_ranges(stamp.text, _decode(raw)))}"
+             if stamp.text is not None else "")
+    guard.refusal = (
+        f"[c3_edit:stale] {label} changed outside this session since your "
+        f"last read{where}.\n"
+        f"  overwrite would discard that change. Nothing was written.\n"
+        f"  Read the file again with c3_read, then resend.")
+    return guard
+
+
 def check(path, project_path, label: str, old_string: str, edits,
           replace_all: bool, norm=None) -> Guard:
     """Compare `path` to this session's stamp before an edit is applied.