code-context-control 2.38.1__tar.gz → 2.39.0__tar.gz

{code_context_control-2.38.1/code_context_control.egg-info → code_context_control-2.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.38.1
+Version: 2.39.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/_hook_utils.py

@@ -74,9 +74,46 @@ def get_tool_output(data: dict) -> tuple:
 
 
 def get_tool_input_path(data: dict) -> str:
-    """Extract file path from tool_input, handling both Claude (file_path) and Gemini (path)."""
+    """Extract file path from tool_input, handling Claude (file_path),
+    Gemini (path), and NotebookEdit (notebook_path)."""
     tool_input = data.get("tool_input", {})
-    return tool_input.get("file_path", "") or tool_input.get("path", "")
+    return (
+        tool_input.get("file_path", "")
+        or tool_input.get("path", "")
+        or tool_input.get("notebook_path", "")
+    )
+
+
+def record_json_unlocks(editable: list, project_path: Path | None = None) -> None:
+    """Record file paths as read+edit unlocked in .c3/unlocked_files.json.
+
+    This is the map that hook_pretool_enforce.py actually reads (the plain
+    .txt unlock list is not consumed by any hook). Mirrors the behaviour of
+    cli/hook_c3read._record_json_unlocks so c3_compress/c3_agent sticky
+    unlocks reach the enforcer. Fails silently on I/O errors.
+    """
+    base = project_path if project_path is not None else Path.cwd()
+    json_path = base / ".c3" / "unlocked_files.json"
+    try:
+        existing: dict = {}
+        if json_path.exists():
+            try:
+                existing = json.loads(json_path.read_text(encoding="utf-8"))
+                if not isinstance(existing, dict):
+                    existing = {}
+            except Exception:
+                existing = {}
+        for fp in editable:
+            if not fp:
+                continue
+            normalized = str(Path(fp).resolve())
+            cats = set(existing.get(normalized, []))
+            cats.update({"read", "edit"})
+            existing[normalized] = sorted(cats)
+        json_path.parent.mkdir(parents=True, exist_ok=True)
+        json_path.write_text(json.dumps(existing), encoding="utf-8")
+    except Exception:
+        pass
 
 
 def emit_additional_context(text: str, is_gemini: bool) -> None:

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.38.1"
+__version__ = "2.39.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -4084,7 +4084,11 @@ def _upsert_toml_section(toml_path: Path, section: str, entries: dict) -> None:
     content = toml_path.read_text(encoding="utf-8") if toml_path.exists() else ""
     header = f"[{section}]"
 
-    # Strip existing section (header + its key=value lines)
+    # Strip existing section (header + its key=value lines). Also strip any
+    # dotted child subtables (e.g. "[mcp_servers.c3.env]" under
+    # "[mcp_servers.c3]") so they are not orphaned beneath the re-appended
+    # section, which would corrupt the file on re-run.
+    child_prefix = f"{header[:-1]}."  # "[mcp_servers.c3]" -> "[mcp_servers.c3."
     lines = content.splitlines()
     new_lines: list[str] = []
     skip = False
@@ -4094,7 +4098,8 @@ def _upsert_toml_section(toml_path: Path, section: str, entries: dict) -> None:
             skip = True
             continue
         if skip and stripped.startswith("["):
-            skip = False
+            if not stripped.startswith(child_prefix):
+                skip = False
         if not skip:
             new_lines.append(line)
 
@@ -4577,41 +4582,48 @@ def _ensure_global_claude_md() -> None:
 
     existing = global_md.read_text(encoding="utf-8")
 
-    if _GLOBAL_CLAUDE_MD_MARKER not in existing:
-        # User has their own CLAUDE.md — append C3 section
-        merged = existing.rstrip() + "\n\n" + _GLOBAL_CLAUDE_MD_CONTENT
-        global_md.write_text(merged, encoding="utf-8")
-        print(f"Updated {global_md}  (appended C3 enforcement)")
-        return
+    # The C3-managed region is delimited by explicit BEGIN/END sentinels (the
+    # same ones used for project instruction docs). This is unambiguous, so
+    # user-written content outside the markers — including H1 headings that
+    # happen to mention "C3" or "Tool Discipline" — is never swallowed.
+    from services.claude_md import C3_BLOCK_BEGIN, C3_BLOCK_END, merge_c3_block
 
-    # C3 section exists — replace it with the latest version
-    # Find the C3 section boundaries: starts at the marker, ends at next # heading or EOF
-    start = existing.index(_GLOBAL_CLAUDE_MD_MARKER)
-    # Find the next top-level heading after the C3 section
-    rest = existing[start + len(_GLOBAL_CLAUDE_MD_MARKER):]
-    lines_after = rest.split("\n")
-    end_offset = len(rest)  # default: to EOF
-    running = 0
-    for line in lines_after:
-        running += len(line) + 1
-        # A top-level heading that's NOT part of C3's sub-headings
-        if line.startswith("# ") and "C3" not in line and "Tool Discipline" not in line:
-            end_offset = running - len(line) - 1
-            break
-
-    end = start + len(_GLOBAL_CLAUDE_MD_MARKER) + end_offset
-    before = existing[:start].rstrip()
-    after = existing[end:].lstrip()
+    wrapped = f"{C3_BLOCK_BEGIN}\n{_GLOBAL_CLAUDE_MD_CONTENT.strip()}\n{C3_BLOCK_END}"
 
-    parts = []
-    if before:
-        parts.append(before)
-    parts.append(_GLOBAL_CLAUDE_MD_CONTENT.strip())
-    if after:
-        parts.append(after)
+    # Markers already present → surgical, marker-bounded replacement.
+    if C3_BLOCK_BEGIN in existing:
+        global_md.write_text(merge_c3_block(existing, wrapped), encoding="utf-8")
+        print(f"Updated {global_md}  (refreshed C3 enforcement)")
+        return
 
-    global_md.write_text("\n\n".join(parts) + "\n", encoding="utf-8")
-    print(f"Updated {global_md}  (refreshed C3 enforcement)")
+    # Legacy marker-less C3 region → one-time migration into the marked block.
+    # Bound the region from the legacy heading to the NEXT top-level (``# ``)
+    # heading. C3's own content has exactly one H1 (the legacy heading itself),
+    # so the next H1 reliably marks where user content resumes; we deliberately
+    # do NOT skip H1s containing "C3"/"Tool Discipline" (the old heuristic did,
+    # which is what swallowed user headings).
+    if _GLOBAL_CLAUDE_MD_MARKER in existing:
+        start = existing.index(_GLOBAL_CLAUDE_MD_MARKER)
+        rest = existing[start + len(_GLOBAL_CLAUDE_MD_MARKER):]
+        end_offset = len(rest)  # default: to EOF
+        running = 0
+        for line in rest.split("\n"):
+            running += len(line) + 1
+            if line.startswith("# "):
+                end_offset = running - len(line) - 1
+                break
+        end = start + len(_GLOBAL_CLAUDE_MD_MARKER) + end_offset
+        before = existing[:start].rstrip()
+        after = existing[end:].lstrip()
+        parts = [p for p in (before, wrapped, after) if p]
+        global_md.write_text("\n\n".join(parts) + "\n", encoding="utf-8")
+        print(f"Updated {global_md}  (migrated C3 enforcement to markers)")
+        return
+
+    # User has their own CLAUDE.md with no C3 content — append the marked block.
+    merged = existing.rstrip() + "\n\n" + wrapped + "\n"
+    global_md.write_text(merged, encoding="utf-8")
+    print(f"Updated {global_md}  (appended C3 enforcement)")
 
 
 def _instruction_documents_for_project() -> list[tuple[str, str]]:
@@ -5019,6 +5031,8 @@ def cmd_install_mcp(args):
             glob_matcher   = "find_files"
             edit_matcher   = "edit_file"
             write_matcher  = "write_file"
+            # Gemini has no MultiEdit / NotebookEdit equivalents.
+            extra_edit_matchers = []
         else:
             shell_matcher  = "Bash"
             read_matcher   = "Read"
@@ -5026,6 +5040,9 @@ def cmd_install_mcp(args):
             glob_matcher   = "Glob"
             edit_matcher   = "Edit"
             write_matcher  = "Write"
+            # Claude Code also exposes MultiEdit (batch edits) and NotebookEdit;
+            # both bypass enforcement/logging unless their matchers are registered.
+            extra_edit_matchers = ["MultiEdit", "NotebookEdit"]
 
         # ── PostToolUse hooks ──
         desired_post_hooks = [
@@ -5120,6 +5137,10 @@ def cmd_install_mcp(args):
                 "matcher": write_matcher,
                 "hooks": [{"type": "command", "command": hook_edit_ledger_cmd}]
             },
+            *[
+                {"matcher": m, "hooks": [{"type": "command", "command": hook_edit_ledger_cmd}]}
+                for m in extra_edit_matchers
+            ],
         ]
 
         # ── PreToolUse hooks (enforcement — blocks native tools without prior c3_*) ──
@@ -5144,6 +5165,10 @@ def cmd_install_mcp(args):
                 "matcher": write_matcher,
                 "hooks": [{"type": "command", "command": hook_enforce_cmd}]
             },
+            *[
+                {"matcher": m, "hooks": [{"type": "command", "command": hook_enforce_cmd}]}
+                for m in extra_edit_matchers
+            ],
         ]
 
         # Merge: replace existing C3 hooks (so re-running install-mcp updates commands),

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/hook_edit_ledger.py

@@ -10,6 +10,7 @@ EditLedgerEnricherAgent running in the MCP server background.
 
 import json
 import sys
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -25,7 +26,7 @@ EDITABLE_EXTS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
     ".rb", ".c", ".cpp", ".h", ".cs", ".html", ".css",
     ".json", ".yaml", ".yml", ".toml", ".sql", ".md", ".txt",
-    ".sh", ".bat", ".ps1", ".r",
+    ".sh", ".bat", ".ps1", ".r", ".ipynb",
 }
 
 # How many tail lines to scan for version/seq (avoids full-file parse)
@@ -95,8 +96,11 @@ def _next_seq(ledger_file: Path, now: datetime) -> int:
             continue
         eid = entry.get("id", "")
         if eid.startswith(prefix):
+            # ids may carry a random suffix ("..._001_a1b2"); take the leading
+            # numeric run after the prefix so same-second seq counting survives.
+            seq_part = eid[len(prefix):].split("_", 1)[0]
             try:
-                max_seq = max(max_seq, int(eid[len(prefix):]))
+                max_seq = max(max_seq, int(seq_part))
             except ValueError:
                 pass
     return max_seq + 1
@@ -172,7 +176,9 @@ def main():
         git_pending = tracking_level != "minimal"
 
         entry = {
-            "id": f"edit_{now.strftime('%Y%m%d_%H%M%S')}_{_next_seq(ledger_file, now):03d}",
+            # Random suffix prevents id collisions when the hook process and the
+            # server process (services/edit_ledger.py) write within the same second.
+            "id": f"edit_{now.strftime('%Y%m%d_%H%M%S')}_{_next_seq(ledger_file, now):03d}_{uuid.uuid4().hex[:4]}",
             "timestamp": now.isoformat(),
             "session_id": "",
             "file": rel,

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/hook_edit_unlock.py

@@ -14,7 +14,11 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from cli._hook_utils import emit_additional_context, log_hook_error  # noqa: E402
+from cli._hook_utils import (  # noqa: E402
+    emit_additional_context,
+    log_hook_error,
+    record_json_unlocks,
+)
 
 EDITABLE_EXTS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java",
@@ -144,6 +148,10 @@ def main():
         except Exception:
             pass
 
+        # Fix 2: also write the .json unlock map — the .txt list above is read
+        # by NO hook; hook_pretool_enforce.py only consults unlocked_files.json.
+        record_json_unlocks(editable)
+
         # Emit batched nudge with all pending files
         # Prefer c3_edit (no unlock needed). Native Edit is also unlocked via sticky file set.
         if len(pending) == 1:

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/hook_pretool_enforce.py

@@ -180,24 +180,30 @@ def _is_file_unlocked(project_path: Path, file_path: str, category: str) -> bool
     return category in cats or "both" in cats
 
 
-def _check_signal_file(project_path: Path) -> tuple[bool, bool]:
+def _check_signal_file(project_path: Path) -> tuple[bool, bool, str]:
     """Read last_c3_call.json written by hook_c3_signal.py.
 
-    Returns (recent, read_unlocked):
+    Returns (recent, read_unlocked, c3_tool):
       recent:        True if a c3_* tool completed within _SIGNAL_MAX_AGE_SECS
       read_unlocked: True if that tool was c3_search/c3_compress/c3_filter
+      c3_tool:       short name of the c3 tool that wrote the signal (e.g.
+                     "c3_edit"), or "" if recent is False / unparseable.
+
+    Fails closed: on any parse error, returns (False, False, "").
     """
     signal_path = project_path / _SIGNAL_FILE
     if not signal_path.exists():
-        return False, False
+        return False, False, ""
     try:
         data = json.loads(signal_path.read_text(encoding="utf-8"))
         ts = datetime.fromisoformat(data["timestamp"])
         age = (datetime.now(timezone.utc) - ts).total_seconds()
         recent = age <= _SIGNAL_MAX_AGE_SECS
-        return recent, bool(data.get("read_unlocked", False)) and recent
+        if not recent:
+            return False, False, ""
+        return True, bool(data.get("read_unlocked", False)), str(data.get("tool", ""))
     except Exception:
-        return False, False
+        return False, False, ""
 
 
 def _check_c3_used(project_path: Path, tool_name: str, tool_input: dict) -> tuple[bool, str]:
@@ -223,10 +229,20 @@ def _check_c3_used(project_path: Path, tool_name: str, tool_input: dict) -> tupl
     required_cat = _TOOL_CATEGORY.get(tool_name, "read")
 
     # ── Fix 4: signal file — primary, fast, reliable ─────────────────────────
-    signal_recent, signal_read_unlocked = _check_signal_file(project_path)
+    signal_recent, signal_read_unlocked, signal_tool = _check_signal_file(project_path)
     if signal_recent:
+        # Bypass fix: for write-class tools (Edit/Write/MultiEdit), the signal
+        # may only unlock them when the c3 tool that wrote it actually satisfies
+        # this tool's prereqs (e.g. c3_edit/c3_edits/c3_agent). A read-class
+        # signal (c3_status, c3_search, …) must NOT unlock a native write.
+        if tool_name in _BLOCKED_TOOLS:
+            if signal_tool in allowed:
+                if native_target:
+                    _record_unlock(project_path, native_target, required_cat)
+                return True, "signal"
+            # Fresh signal exists but it's not a write-prereq tool — fall through
         # Fix 5: Grep/Glob without file path needs a read-unlocking tool
-        if not native_target and tool_name in ("Grep", "Glob", "FindFiles", "SearchText"):
+        elif not native_target and tool_name in ("Grep", "Glob", "FindFiles", "SearchText"):
             if signal_read_unlocked:
                 return True, "signal"
             # Signal exists but not read-unlocking (e.g. c3_memory) — fall through

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/tools/delegate.py

@@ -40,6 +40,7 @@ def _kill_proc_tree(proc):
             subprocess.run(
                 ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
                 capture_output=True, stdin=subprocess.DEVNULL,
+                creationflags=subprocess.CREATE_NO_WINDOW,
             )
         else:
             proc.kill()
@@ -51,8 +52,10 @@ def _kill_proc_tree(proc):
 def _communicate_with_heartbeat(proc, timeout=45, idle_timeout=15):
     """communicate() replacement with idle-activity watchdog.
 
-    Monitors stderr for activity. If no stderr output for idle_timeout seconds,
-    kills the process early (catches MCP startup hangs). Also enforces total timeout.
+    Monitors both stdout and stderr for activity. If neither stream produces
+    output for idle_timeout seconds, kills the process early (catches MCP startup
+    hangs) without killing a backend that streams its answer only on stdout.
+    Also enforces total timeout.
 
     Returns (stdout, stderr, status) where status is 'ok', 'timeout', or 'idle_timeout'.
     """
@@ -71,7 +74,7 @@ def _communicate_with_heartbeat(proc, timeout=45, idle_timeout=15):
         except (ValueError, OSError):
             pass
 
-    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts), daemon=True)
+    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts, True), daemon=True)
     t_err = threading.Thread(target=_read_stream, args=(proc.stderr, stderr_parts, True), daemon=True)
     t_out.start()
     t_err.start()
@@ -218,10 +221,17 @@ def _run_claude(task: str, context: str, cwd: str | None = None,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True, cwd=cwd,
+            text=True, encoding="utf-8", errors="replace", cwd=cwd,
             **_popen_kwargs(),
         )
-        output, err = _communicate_with_heartbeat(proc, timeout=timeout, idle_timeout=idle_timeout)
+        output, err, status = _communicate_with_heartbeat(
+            proc, timeout=timeout, idle_timeout=idle_timeout,
+        )
+        if status == "idle_timeout":
+            return (f"[claude:idle_timeout] No stderr activity for {idle_timeout}s "
+                    f"(likely MCP startup hang)"), False
+        if status == "timeout":
+            return f"[claude:timeout] No response after {timeout}s", False
         if proc.returncode == 0 and output.strip():
             return output.strip(), True
         return f"[claude:error] {(err or '').strip() or 'no output'}", False
@@ -307,7 +317,7 @@ def _start_gemini_early(model: str, timeout: int = 45, idle_timeout: int = 15,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.PIPE,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -344,7 +354,7 @@ def _finish_gemini_early(proc, task: str, context: str,
         except (ValueError, OSError):
             pass
 
-    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts), daemon=True)
+    t_out = threading.Thread(target=_read_stream, args=(proc.stdout, stdout_parts, True), daemon=True)
     t_err = threading.Thread(target=_read_stream, args=(proc.stderr, stderr_parts, True), daemon=True)
     t_out.start()
     t_err.start()
@@ -448,7 +458,7 @@ def _run_gemini(task: str, context: str, model: str,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -563,7 +573,7 @@ def _run_codex(task: str, context: str, model: str, sandbox: str,
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
             **_popen_kwargs(),
         )
@@ -592,25 +602,18 @@ def _run_codex_resume(follow_up: str, timeout: int = 120,
     """Resume last Codex session with a follow-up prompt."""
     cmd = ["codex", "exec", "--skip-git-repo-check", "resume", "--last"]
     try:
-        import sys
         proc = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
             stdin=subprocess.PIPE,
-            text=True,
+            text=True, encoding="utf-8", errors="replace",
             cwd=cwd,
+            **_popen_kwargs(),
         )
         try:
             stdout, stderr = proc.communicate(input=follow_up, timeout=timeout)
         except subprocess.TimeoutExpired:
-            if sys.platform == "win32":
-                subprocess.run(
-                    ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
-                    capture_output=True, stdin=subprocess.DEVNULL,
-                )
-            else:
-                proc.kill()
-            proc.wait(timeout=5)
+            _kill_proc_tree(proc)
             return f"[codex:timeout] Resume timed out after {timeout}s", False
 
         if proc.returncode != 0:
@@ -1166,7 +1169,10 @@ def handle_delegate(task: str, task_type: str, context: str, file_path: str,
                 model=fallback, system=tdef["system"],
                 temperature=tdef.get("temperature", 0.3),
                 max_tokens=int(dcfg.get("max_tokens", 512) or 512),
-            )
+                timeout=timeout_s)
+            if retry_resp is None:
+                # Timeout/failure on the fallback — not a valid empty answer.
+                continue
             retry_conf = _estimate_confidence(task_type, retry_resp, count_tokens(retry_resp))
             if retry_conf != "low":
                 resp = retry_resp

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/tools/edit.py

@@ -25,6 +25,37 @@ def _get_file_lock(path: Path) -> threading.Lock:
         return _file_locks[key]
 
 
+def _read_preserving_newlines(path: Path) -> tuple[str, str]:
+    """Read a file's text and detect its dominant newline style.
+
+    Returns (content, newline) where `content` has all line endings
+    normalized to ``\n`` (so existing replace logic is unchanged) and
+    `newline` is the EOL to write back: ``\r\n`` if CRLF dominates the
+    file, otherwise ``\n``. This avoids Python's text-mode write rewriting
+    every line to ``os.linesep`` on Windows.
+    """
+    raw = path.read_bytes()
+    crlf = raw.count(b"\r\n")
+    lf_only = raw.count(b"\n") - crlf
+    newline = "\r\n" if crlf > lf_only else "\n"
+    content = raw.decode("utf-8")
+    # Normalize to \n internally so replacement matching is EOL-agnostic.
+    content = content.replace("\r\n", "\n").replace("\r", "\n")
+    return content, newline
+
+
+def _write_preserving_newlines(path: Path, content: str, newline: str) -> None:
+    """Write `content` (which uses ``\n``) back using the original EOL style.
+
+    Uses ``newline=""`` so Python performs no translation; we emit the
+    detected EOL explicitly so an LF-only file stays LF-only on Windows.
+    """
+    if newline != "\n":
+        content = content.replace("\n", newline)
+    with open(path, "w", encoding="utf-8", newline="") as fh:
+        fh.write(content)
+
+
 # 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
@@ -131,7 +162,10 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
 
         try:
             path.parent.mkdir(parents=True, exist_ok=True)
-            path.write_text(new_string, encoding="utf-8")
+            # newline="" → write content exactly as given; no os.linesep
+            # translation, so the caller's line endings are preserved verbatim.
+            with open(path, "w", encoding="utf-8", newline="") as fh:
+                fh.write(new_string)
         except Exception as e:
             return finalize("c3_edit", {"file": file_path},
                             f"Create error: {e}", "create error")
@@ -161,15 +195,22 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
             return finalize("c3_edit", {"file": file_path},
                             "edits must be a non-empty JSON list", "bad edits param")
 
+        if not all(isinstance(p, dict) for p in edit_list):
+            return finalize("c3_edit", {"file": file_path},
+                            "edits must be a JSON list of objects "
+                            "({old_string, new_string, ...}); a non-object element was found",
+                            "bad edits param")
+
         with file_lock:
             try:
-                content = path.read_text(encoding="utf-8")
+                content, _newline = _read_preserving_newlines(path)
             except Exception as e:
                 return finalize("c3_edit", {"file": file_path},
                                 f"Read error: {e}", "read error")
 
             results = []
             any_normalized = False
+            any_applied = False
             for i, patch in enumerate(edit_list):
                 old = patch.get("old_string", "")
                 new = patch.get("new_string", "")
@@ -190,6 +231,7 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
                     continue
 
                 content = new_content
+                any_applied = True
                 n = count if r_all else 1
                 if used_fallback:
                     any_normalized = True
@@ -202,22 +244,27 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
                                 + (" [norm]" if used_fallback else "")
                                 + f" | {desc}")
 
-            try:
-                path.write_text(content, encoding="utf-8")
-            except Exception as e:
-                return finalize("c3_edit", {"file": file_path},
-                                f"Write error: {e}", "write error")
+            # Only touch the file when at least one patch actually changed it —
+            # avoids rewriting (and re-EOL-normalizing) an unchanged file and
+            # logging a phantom ledger entry when every patch missed.
+            if any_applied:
+                try:
+                    _write_preserving_newlines(path, content, _newline)
+                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)
-        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
-        ]}
-        _log_to_ledger(rel, summary or f"Batch edit: {len(edit_list)} patches", tag_list, svc, detail=batch_detail)
+        if any_applied:
+            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
+            ]}
+            _log_to_ledger(rel, summary or f"Batch edit: {len(edit_list)} patches", tag_list, svc, detail=batch_detail)
 
         applied = sum(1 for r in results if "NOT FOUND" not in r and "AMBIGUOUS" not in r and "skipped" not in r)
         norm_tag = " [unicode-normalized]" if any_normalized else ""
@@ -234,7 +281,7 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
 
     with file_lock:
         try:
-            content = path.read_text(encoding="utf-8")
+            content, _newline = _read_preserving_newlines(path)
         except Exception as e:
             return finalize("c3_edit", {"file": file_path},
                             f"Read error: {e}", "read error")
@@ -260,7 +307,7 @@ def handle_edit(file_path: str, old_string: str, new_string: str,
         occurrences = count if replace_all else 1
 
         try:
-            path.write_text(new_content, encoding="utf-8")
+            _write_preserving_newlines(path, new_content, _newline)
         except Exception as e:
             return finalize("c3_edit", {"file": file_path},
                             f"Write error: {e}", "write error")

{code_context_control-2.38.1 → code_context_control-2.39.0}/cli/tools/memory.py

@@ -5,6 +5,10 @@ from datetime import datetime, timezone
 def handle_memory(action: str, query: str, fact: str, category: str,
                   top_k: int, svc, finalize, fact_id: str = "") -> str:
     if action == "add":
+        if not fact or not fact.strip():
+            return finalize("c3_memory", {"action": action},
+                            "fact is required to add a memory (got empty/whitespace)",
+                            "missing fact")
         sid = (svc.session_mgr.current_session or {}).get("id", "")
         res = svc.memory.remember(fact, category or "general", sid)
         return finalize("c3_memory", {"action": action},