localcode 0.3.15__tar.gz → 0.3.17__tar.gz

{localcode-0.3.15/src/localcode.egg-info → localcode-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.15
+Version: 0.3.17
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.15 → localcode-0.3.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.15"
+version = "0.3.17"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.15"
+__version__ = "0.3.17"

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/context.py

@@ -76,10 +76,45 @@ def _spill_tool_output(result: str, tool_name: str) -> str | None:
         return None
 
 
-def _truncate_result(result: str, tool_name: str) -> str:
+# How much of the context window (in chars) a single tool result may occupy,
+# per tool. The static RESULT_LIMITS values act as the FLOOR, so small machines
+# (64K window ≈ 224K chars → these fractions fall below the floor) are
+# byte-identical to before, while a big machine (256K ≈ 900K chars) lets the
+# model keep far more of the output it has room for instead of a fixed 20–50K
+# slice. grep matches are dense/repetitive so get the smallest share; read_file
+# is the primary code-ingestion path so gets the most.
+_RESULT_LIMIT_WINDOW_FRACTION: dict[str, float] = {
+    "grep": 0.03,
+    "bash": 0.05,
+    "read_file": 0.08,
+    "default": 0.08,
+}
+
+
+def _dynamic_result_limit(tool_name: str, ctx_tokens: int) -> int:
+    """Per-tool truncation budget (chars), scaled to the real context window.
+
+    Returns the static RESULT_LIMITS value as a floor; on a large window the
+    limit grows to a fraction of the window so the model isn't starved of output
+    it has room for. web_search and any tool without a fraction stay at the
+    fixed floor (web results don't benefit from window-scaling).
+    """
+    floor = RESULT_LIMITS.get(tool_name, RESULT_LIMITS["default"])
+    frac = _RESULT_LIMIT_WINDOW_FRACTION.get(tool_name)
+    if not ctx_tokens or frac is None:
+        return floor
+    # CHARS_PER_TOKEN=4 is the internal estimate; use 3.5 to match loop.py's
+    # tokens→chars conversion and stay conservative.
+    return max(floor, int(ctx_tokens * 3.5 * frac))
+
+
+def _truncate_result(result: str, tool_name: str, ctx_tokens: int = 0) -> str:
     """Truncate a tool result to its per-tool size limit with a
     strategy tuned to what each tool's output actually looks like.
 
+    `ctx_tokens` (the model's real context window) scales the limit up on big
+    machines; 0 falls back to the static floor (small machines unchanged).
+
     Strategies:
       • `read_file` — keep HEAD only. File content is ordered; the
         model can paginate with `offset=` to see more. Middle-dropping
@@ -96,7 +131,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
 
     Returns the result unchanged when it's within the limit.
     """
-    limit = RESULT_LIMITS.get(tool_name, RESULT_LIMITS["default"])
+    limit = _dynamic_result_limit(tool_name, ctx_tokens)
     if len(result) <= limit:
         return result
 

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/helpers.py

@@ -287,6 +287,49 @@ def _render_markdown(text: str, console: Console | None = None) -> None:
     else:
         c.print(Padding(text, (0, 2, 0, 2)))
 
+def _split_exit_code(result: str) -> tuple[int | None, str]:
+    """Split a bash result into (exit_code, body).
+
+    bash.py prepends `[exit code N]\\n` to a failed command's output as a
+    model-facing failure marker. Return the parsed code and the remaining body,
+    or (None, result) when the marker is absent (command succeeded).
+    """
+    s = result.lstrip()
+    if s.startswith("[exit code "):
+        end = s.find("]")
+        if end != -1:
+            try:
+                code = int(s[len("[exit code "):end].strip())
+            except ValueError:
+                return None, result
+            body = s[end + 1:]
+            return code, body[1:] if body.startswith("\n") else body
+    return None, result
+
+
+def _redirect_note(result: str) -> str:
+    """Turn an internal `REJECTED …` string into a short user-facing note.
+
+    The full REJECTED payload (routing hints, "Suggested tool call: …",
+    hard-stop instructions) is for the model's recovery, not the user. Two
+    cases: a routing redirect ("use X instead") → "→ used X instead"; anything
+    else (repeat/hard-stop/unsafe/oversize block) → a neutral "→ skipped …"
+    note. Never show the raw protocol text.
+    """
+    import re
+    m = re.search(r"\buse\s+([a-z_]+)\s+instead", result)
+    if m:
+        return f"→ used {m.group(1)} instead"
+    low = result.lower()
+    if "hard stop" in low or "already failed" in low or "already ran" in low or "rewritten" in low:
+        return "→ skipped (repeating a call that won't help)"
+    if "safety ceiling" in low or "over the" in low:
+        return "→ skipped (too large — splitting instead)"
+    if "defer" in low or "blocked" in low or "live server" in low:
+        return "→ skipped that step"
+    return "→ adjusted approach"
+
+
 def _brief_result(tool_name: str, result: str) -> str:
     """Short summary of a tool result for terminal display."""
     lines = result.strip().splitlines()
@@ -301,6 +344,11 @@ def _brief_result(tool_name: str, result: str) -> str:
         return "already done — using cached result"
     if s.startswith("[FILE UNCHANGED"):
         return "unchanged — see earlier read"
+    # Internal tool-routing/hard-stop correction. This is a signal FOR THE
+    # MODEL, not the user — render a short neutral note, never the raw
+    # "REJECTED: …" / "REJECTED — HARD STOP: …" protocol text (both forms).
+    if s.startswith("REJECTED"):
+        return _redirect_note(s)
     if tool_name == "read_file":
         return f"{len(lines)} lines"
     if tool_name == "write_file":
@@ -308,11 +356,20 @@ def _brief_result(tool_name: str, result: str) -> str:
     if tool_name == "edit_file":
         return result.strip()[:80] if result.strip() else "edited"
     if tool_name == "bash":
-        if not result.strip():
+        # `[exit code N]` is a model-facing marker prepended to the output so the
+        # model knows the command failed. Don't show that raw token to the user:
+        # strip it, and render a clean "failed (exit N)" plus any real output.
+        exit_code, body = _split_exit_code(result)
+        body_lines = body.strip().splitlines()
+        if exit_code is not None:
+            head = body_lines[0][:80] if body_lines and body_lines[0].strip() else ""
+            tail = f"  …({len(body_lines)} lines)" if len(body_lines) > 1 else ""
+            return f"failed (exit {exit_code}){(': ' + head) if head else ''}{tail}"
+        if not body.strip():
             return "done (no output)"
-        if len(lines) <= 3:
-            return "\n".join(lines)[:200]
-        return f"{lines[0][:80]}  …({len(lines)} lines)"
+        if len(body_lines) <= 3:
+            return "\n".join(body_lines)[:200]
+        return f"{body_lines[0][:80]}  …({len(body_lines)} lines)"
     if tool_name == "grep":
         return f"{len(lines)} matches" if lines and lines[0] else "no matches"
     if tool_name in ("glob", "list_files"):

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/loop.py

@@ -52,8 +52,6 @@ from .context import (
     _prepare_model_messages,
     _summarize_args,
     _truncate_result,
-    _estimate_tokens,
-    _compact_messages,
     build_progress_ledger,
 )
 from .helpers import (
@@ -334,14 +332,23 @@ def run_agent_loop(
             messages.append(m)
     elif use_thinking:
         # Thinking mode: keep context shorter but preserve recent assistant responses
-        # Only drop very large blocks (repo structure dumps, huge tool results)
+        # Only drop very large blocks (repo structure dumps, huge tool results).
+        # The "large block" threshold scales with the model's real context window
+        # instead of a fixed 1500 chars — on a 256K window 1500 chars is ~1% of
+        # the budget, so the old fixed value silently stripped tool results the
+        # big machine had ample room to keep (and needs, to track its work).
+        try:
+            _tw = int(app.engine._target_num_ctx())
+        except Exception:
+            _tw = 0
+        _big_block_chars = max(1500, int(_tw * 3.5 * 0.02)) if _tw else 1500
         for m in composed_messages:
             if m.get("role") == "system":
                 continue
             content = str(m.get("content", ""))
             # Skip very large context blocks (repo structure, bulk retrieval results)
             # but keep normal assistant responses so model remembers recent conversation
-            if len(content) > 1500 and m.get("role") not in ("user", "assistant"):
+            if len(content) > _big_block_chars and m.get("role") not in ("user", "assistant"):
                 continue
             messages.append(m)
     else:
@@ -373,8 +380,23 @@ def run_agent_loop(
     )
     hook_before_turn(_hook_state)
     _app_build_request = is_app_build_request(user_text) or _goal_state.goal_type == "build_app"
-    _aggregate_budget = 24_000 if _app_build_request else MAX_AGGREGATE_PER_TURN
-    _compact_token_limit = 12_000 if _app_build_request else 27_000
+    # Per-turn tool-output budget (in chars) scales with the model's REAL
+    # context window instead of a fixed cap: allow tool results to fill up to
+    # ~35% of the window before further output this turn is truncated. Dynamic
+    # per RAM/model — a 256K window keeps far more than a 64K one. The old fixed
+    # values (24K for app builds, 100K otherwise) starved big machines and,
+    # perversely, gave app builds — which read/write the MOST — the LEAST. The
+    # floor keeps small windows usable; within-turn overflow is still caught by
+    # the window-aware compaction pass at the top of each round.
+    try:
+        _ctx_tokens_turn = int(app.engine._target_num_ctx())
+    except Exception:
+        _ctx_tokens_turn = 0
+    _aggregate_budget = (
+        max(MAX_AGGREGATE_PER_TURN, int(_ctx_tokens_turn * 3.5 * 0.35))
+        if _ctx_tokens_turn
+        else MAX_AGGREGATE_PER_TURN
+    )
     _completion_gate_retries = 0
     _MAX_COMPLETION_GATE_RETRIES = 1
     _edit_recovery_nudges = 0
@@ -1805,9 +1827,15 @@ def run_agent_loop(
                 _write_existing_rejections_this_turn += 1
             # Show result to user — send full result for write/edit so TUI can render diff
             is_error = tool_result_is_error(tool_result)
-            is_rejected = tool_result.startswith("REJECTED:")
+            # Match BOTH "REJECTED:" and "REJECTED — HARD STOP:" (em-dash) — the
+            # latter used to slip past this colon-only check and render as a raw
+            # red protocol line to the user.
+            is_rejected = tool_result.startswith("REJECTED")
             if is_rejected:
-                out.tool_result(tool_result, error=True, idx=idx)
+                # Internal tool-routing redirect — the model needs the full
+                # REJECTED payload (kept in `messages` below), but the user sees
+                # only a short neutral note, not a red error block.
+                out.tool_result(_brief_result(tool_name, tool_result), error=False, idx=idx)
             elif tool_name in ("write_file", "append_file", "edit_file") and not is_error:
                 out.tool_result(tool_result, error=False, idx=idx)
             else:
@@ -1817,12 +1845,16 @@ def run_agent_loop(
             _facts_note = facts_suffix(_tool_facts)
             if _facts_note and _facts_note not in tool_result:
                 tool_result = f"{tool_result}{_facts_note}"
-            tool_result = _truncate_result(tool_result, tool_name)
+            tool_result = _truncate_result(tool_result, tool_name, ctx_tokens=_ctx_tokens_turn)
             aggregate_size += len(tool_result)
 
-            # Aggregate budget
+            # Aggregate budget. The post-budget clamp scales with the window too:
+            # once a turn's cumulative tool output crosses the (dynamic) budget,
+            # a big machine still keeps a proportionally larger stub than a 16 GB
+            # one instead of a brutal fixed 500 chars.
             if aggregate_size > _aggregate_budget:
-                tool_result = tool_result[:500] + "\n[Truncated — context budget exceeded this turn]"
+                _stub_chars = max(500, int(_ctx_tokens_turn * 3.5 * 0.01)) if _ctx_tokens_turn else 500
+                tool_result = tool_result[:_stub_chars] + "\n[Truncated — context budget exceeded this turn]"
 
             # Add to history
             messages.append({
@@ -1982,9 +2014,13 @@ def run_agent_loop(
         if loop_detected:
             break
 
-        # Context compaction check (85% of 32K = ~27K tokens)
-        if _estimate_tokens(messages) > _compact_token_limit:
-            messages = _compact_messages(messages, out)
+        # Compaction is handled ONCE per round at the TOP of the loop by the
+        # window-aware `should_compact`/`compact` path (see ~line 612), whose
+        # threshold scales with the model's real context window and the user's
+        # RAM. The old fixed-12K/27K second pass that used to live here fired at
+        # <5% of a 256K window, crushed all but 8 messages into a 5-line note,
+        # and made the model lose provenance of its own writes → the re-read /
+        # "fix systematically" churn loop. Removed: one dynamic system only.
 
     else:
         # `for…else` only fires when the loop exhausted naturally

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/prompts.py

@@ -51,6 +51,7 @@ Top rules (most important first):
 Plan & tools:
 - For a task with 3+ steps, call todo_write first to lay out the steps, then keep exactly one in_progress and mark each done the instant it's finished. Your list is shown back each round — use it to see what's left.
 - Use real, repo-relative paths (don't improvise `/Users/...` paths).
+- For files and dirs use list_files/read_file/write_file/edit_file — NOT bash (`ls`, `cat`, `cat >`, `>`). bash is only for running commands (npm, git, build, test).
 - edit_file for existing files: anchor `old_string` on 2–4 adjacent lines (matching is whitespace-tolerant; the leading `<n>\\t` from read_file is stripped for you). write_file to create or fully rewrite.
 - On a tool error, read it, fix the specific cause, and retry — don't give up after one failure, and don't repeat the same failing call.
 - New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions.

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/recovery.py

@@ -43,6 +43,10 @@ __all__ = [
     "ChurnSignal",
     "detect_churn",
     "churn_nudge_for",
+    "NOT_FOUND_LOOP_LIMIT",
+    "not_found_key",
+    "detect_not_found_loop",
+    "not_found_nudge",
 ]
 
 
@@ -401,3 +405,79 @@ def rewrite_hard_stop(path, file_write_counts) -> str | None:
         "targeted edit_file change to the broken line, or leave this file and "
         "move on. Do NOT call write_file on this path again."
     )
+
+
+# ── Repeated file-not-found (typo death loop) ───────────────────────
+#
+# read_file's own _confident_match auto-reads a real file when the typo
+# is unambiguous, which breaks MOST of these loops at the source. But
+# when the guessed paths are too far off to match (or point at a dir
+# that doesn't exist), the model can still bounce "file not found" 20+
+# times, each time with a slightly different wrong spelling/case. The
+# byte-identical breakers miss it (each path differs); the churn
+# detectors miss it (read_file is read-only, so it just extends the
+# investigation streak). This is the read-side analogue of the bash
+# command-failure guard: key on the PARENT DIRECTORY (differing typos
+# of one filename share a parent) and count not-found failures.
+
+NOT_FOUND_LOOP_LIMIT = 3
+"""How many 'file not found' read_file failures against the SAME parent
+directory may occur in one turn before we pin the correct path. 3 (like
+CHURN_COMMAND_FAIL_LIMIT): a genuine "read A, oops try B" correction is 1-2
+misses; a 3rd not-found in the same dir means the model is spraying spelling
+variants of a real filename it should just list_files for."""
+
+
+def not_found_key(path: str) -> str:
+    """Normalize a missing read path to the family we count not-found errors
+    by: its parent directory. Different typos of the same file
+    (Aki.md / Anki.md / anki.md) all share a parent, so keying on the parent
+    collapses them into one repeat count. Returns "." for a bare filename."""
+    from pathlib import PurePosixPath
+    p = PurePosixPath(str(path or "").strip().replace("\\", "/"))
+    return str(p.parent)
+
+
+def detect_not_found_loop(not_found_counts: dict[str, int]) -> tuple[str, int] | None:
+    """Return (parent_dir, count) when read_file has failed 'file not found'
+    NOT_FOUND_LOOP_LIMIT+ times against the same parent directory this turn —
+    the model is guessing typo/case variants of a real filename instead of
+    listing the directory once.
+
+    Pure function. Caller maintains `not_found_counts` across the turn
+    (parent-dir key via `not_found_key` → count of not-found read failures).
+    Returns None when nothing crosses the threshold.
+    """
+    worst = ""
+    worst_n = 0
+    for key, n in not_found_counts.items():
+        if n > worst_n:
+            worst, worst_n = key, n
+    if worst_n >= NOT_FOUND_LOOP_LIMIT:
+        return worst, worst_n
+    return None
+
+
+def not_found_nudge(parent_dir: str, real_names: list[str] | None = None) -> str:
+    """Hard, forward-only nudge pinning the correct recovery path for a
+    not-found loop: list the directory ONCE, then read an EXACT name from it.
+
+    Like `churn_nudge_for`, this is a FORWARD-ONLY imperative with NO
+    echo-able self-critical loop language ("you keep failing", "stop
+    guessing in circles") that a small model would parrot back into its own
+    context. When `real_names` is supplied (caller listed the dir), the exact
+    names are pinned so the model can't invent another variant.
+    """
+    listing = ""
+    if real_names:
+        shown = ", ".join(sorted(real_names)[:20])
+        listing = (
+            f" The files that actually exist in {parent_dir} are: {shown}. "
+            "Read one of those EXACT names."
+        )
+    return (
+        f"SYSTEM: read_file cannot find that file in {parent_dir}. Do not try "
+        "another spelling or capitalization. Call list_files on "
+        f"{parent_dir} ONCE, then read_file with an EXACT name from that "
+        "listing." + listing
+    )

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/agent/tool_execution.py

@@ -33,6 +33,15 @@ class ToolExecutionState:
     # times in a row and nothing stopped it. Telemetry behind the
     # removal didn't include info-fetch loops.
     success_counts: dict[tuple[str, str], int] = field(default_factory=dict)
+    # Successful write/edit calls keyed by PATH ONLY (not exact args), so
+    # rewriting the same file with slightly different content each round
+    # still accrues. Feeds the write-churn guard in `dedup_stub_for_tool`.
+    # Motivating logs (2026-06): a turn wrote `useData.ts` 14×, `database.ts`
+    # 8×, `package.json` 4× — plus near-duplicate misspelled siblings
+    # (ReviewSession/ReviewSesssion/ReivewSession.tsx). The per-exact-args
+    # `failed_calls`/`success_counts` guards miss this because each rewrite
+    # is a DISTINCT arg blob; only a path-keyed counter catches the churn.
+    write_path_counts: dict[str, int] = field(default_factory=dict)
     # Last error text seen for a failed bash command, keyed by the same
     # whitespace-normalized cmd_key as `bash_failures`. Lets the rejection
     # stub name the ACTUAL cause ("No such file or directory", syntax error,
@@ -49,6 +58,16 @@ class ToolExecutionState:
 # blocked but never steered.
 _HARD_STOP_THRESHOLD = 4
 
+# After this many SUCCESSFUL writes to the SAME path within one turn, the
+# next write/edit to that path is rejected with a "stop rewriting, go
+# verify" nudge. Keyed by path (not exact args) so near-identical rewrites
+# and typo'd-content re-saves both count. The threshold is deliberately
+# generous — this is a DYNAMIC harness where a couple of legitimate
+# rewrites of the same file per turn are normal (scaffold → fill in →
+# fix a syntax error). We only step in once a file is clearly being
+# churned (4th write of the same path this turn).
+_WRITE_CHURN_THRESHOLD = 3
+
 
 def _diagnose_bash_error(err: str) -> str | None:
     """Translate a raw shell error into a concrete corrective action.
@@ -190,6 +209,29 @@ def dedup_stub_for_tool(
                 "exact anchor, use multi_edit/edit_diff where appropriate, or "
                 "move on if the file is already correct."
             )
+        # Write-churn guard: repeated SUCCESSFUL rewrites of the SAME path
+        # this turn. Keyed by path (not exact args) so near-duplicate content
+        # each round still accrues — the failed_calls/success_counts guards
+        # above miss this because every rewrite is a distinct arg blob. Once
+        # a file has already been written `_WRITE_CHURN_THRESHOLD` times, the
+        # earlier writes already landed on disk; another rewrite is churn.
+        # Nudge the model to STOP and verify (run the build) or move to the
+        # next file instead of rewriting the same path again.
+        churn_path = args.get("path") or args.get("file_path") or ""
+        if isinstance(churn_path, str) and churn_path:
+            writes = state.write_path_counts.get(churn_path, 0)
+            if writes >= _WRITE_CHURN_THRESHOLD:
+                return (
+                    f"REJECTED: {churn_path} has already been written {writes} "
+                    "times this turn. Those writes already landed on disk — "
+                    "rewriting the same file again is churn, not progress. "
+                    "STOP rewriting this path. Instead: run the build/test "
+                    "command (bash) to verify what you have and read the ACTUAL "
+                    "error it reports, or move on to the NEXT file. Only write "
+                    f"{churn_path} again if a concrete build error tells you "
+                    "exactly what line to change — and if so, use a small "
+                    "targeted edit_file, not a full rewrite."
+                )
     return None
 
 
@@ -292,6 +334,12 @@ def track_tool_result(
             state.files_modified.add(modified_path)
             state.files_read.pop(modified_path, None)
             state.io_calls.clear()
+            # Path-keyed write tally feeds the write-churn guard. Only
+            # successful writes count — a rejected/failed write did NOT
+            # land on disk, so it isn't churn.
+            state.write_path_counts[modified_path] = (
+                state.write_path_counts.get(modified_path, 0) + 1
+            )
     if (
         tool_name in {"write_file", "append_file", "edit_file", "multi_edit", "edit_diff"}
         and not failed

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/app.py

@@ -15,7 +15,7 @@ from .composer import compose_messages
 # loading were dead code (no user configured an MCP server; Playwright
 # browser path was unreachable from the agent loop).
 from .config import AppConfig, ensure_home_dirs, save_config
-from .context import build_context_block, find_repo_root
+from .context import build_context_block, find_repo_root, _is_home_or_shallower
 from .indexer import build_index, load_index, search_index
 from .models import GEMMA_PROFILES, get_runtime_model, resolve_profile
 from .patching import build_diff, parse_diff
@@ -138,6 +138,20 @@ class LocalCodeApp:
             _, preset = benchmark_report(self.config, self.config.runtime.mode)
             apply_preset(self.config, preset, model=self.config.runtime.model)
         self.repo_root = find_repo_root(cwd or Path.cwd())
+        # Degenerate case: no .git and no project marker anywhere above the
+        # launch dir, and that launch dir is $HOME (or shallower). We can't
+        # invent a better root, but we MUST flag it — otherwise the model ends
+        # up carrying 70-char absolute paths (with spaces/mixed-case) on every
+        # tool call and corrupts them into failed-read loops. Mark it so the
+        # rest of the app (and logs) know paths are unanchored, and prefer the
+        # deepest dir the model actually builds in once files start landing.
+        self.repo_root_is_home = _is_home_or_shallower(self.repo_root)
+        if self.repo_root_is_home:
+            self.log.warning(
+                "No project root found above %s; running unanchored at $HOME. "
+                "Paths will be resolved relative to whatever directory the task "
+                "builds in.", self.repo_root,
+            )
         self.store = SessionStore()
         if session_id:
             self.session = self.store.load(session_id)

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/auto_compact.py

@@ -58,25 +58,33 @@ def _build_summary(old: list[dict]) -> str:
             if result:
                 key_actions.append(f"Tool {tool_name or 'unknown'}: {result}")
 
-    summary_lines = ["[Conversation summary]"]
+    # Second-person, self-referential framing: everything below is the
+    # ASSISTANT's OWN prior work, NOT files/work the user handed over. This
+    # stops the model from reading its own build after compaction as
+    # pre-existing user-provided code ("the user created these files…").
+    summary_lines = [
+        "Summary of what YOU have already done this task (this is YOUR OWN prior "
+        "work — NOT the user's, and NOT pre-existing files on disk; build on it — "
+        "do NOT restart, re-read, or ask the user what to build):"
+    ]
     if latest_user_goal:
-        summary_lines.append(f"Current objective: {latest_user_goal}")
+        summary_lines.append(f"The user's task: {latest_user_goal}")
     if summary_parts:
-        summary_lines.append("Topics discussed:")
+        summary_lines.append("Context so far:")
         for s in summary_parts[-8:]:
             summary_lines.append(f"  - {s}")
     if key_actions:
-        summary_lines.append("Work already completed:")
+        summary_lines.append("You already did:")
         for a in key_actions[-10:]:
             summary_lines.append(f"  - {a}")
     if open_questions:
-        summary_lines.append("Open issues / pending follow-ups:")
+        summary_lines.append("Still to do:")
         for q in open_questions[-6:]:
             summary_lines.append(f"  - {q}")
     if files_mentioned:
-        summary_lines.append(f"Files involved: {', '.join(sorted(files_mentioned)[:20])}")
+        summary_lines.append(f"Files YOU created/edited: {', '.join(sorted(files_mentioned)[:20])}")
     if tools_used:
-        summary_lines.append(f"Tools used: {', '.join(sorted(tools_used))}")
+        summary_lines.append(f"Tools YOU used: {', '.join(sorted(tools_used))}")
     return "\n".join(summary_lines)
 
 
@@ -110,12 +118,24 @@ def auto_compact(messages: list[dict], max_chars: int,
 
     summary_text = _build_summary(old)
 
+    # Frame the summary as a role:"system" memo (matching compaction.py) so the
+    # model never mistakes its OWN compacted work for user-authored code. The
+    # old approach injected the summary under role:"user" with passive
+    # third-person wording ("Work already completed:"), which made the model
+    # read its own build as pre-existing files the user had handed over ("the
+    # user created these files", "what would you like me to build?").
+    memo = (
+        "Earlier turns of THIS task were compacted to save context. The summary "
+        "below is YOUR OWN work already done — build on it and do NOT restart, "
+        "re-read files, redo steps, or ask the user what to build:\n\n"
+        f"{summary_text}"
+    )
+
     # Build compacted messages
     compacted = []
     if system_msg:
         compacted.append(system_msg)
-    compacted.append({"role": "user", "content": summary_text})
-    compacted.append({"role": "assistant", "content": "Understood. I have the context from our earlier conversation. How can I continue helping?"})
+    compacted.append({"role": "system", "content": memo})
     compacted.extend(recent)
 
     return compacted, summary_text

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/bootstrap.py

@@ -132,6 +132,10 @@ def _runner_panel(label: str, detail: str, tick: int, steps: list[SetupStep], cu
 
 _progress_status: dict[str, str] = {}
 
+# Generic return type for run_with_runner (the TypeVar was imported but never
+# bound — ruff F821, and it broke the E9/F82 lint gate in CI).
+T = TypeVar("T")
+
 
 def run_with_runner(console: Console, step: SetupStep, steps: list[SetupStep], fn: Callable[[], T]) -> T:
     result: dict[str, T] = {}

{localcode-0.3.15 → localcode-0.3.17}/src/localcode/context.py

@@ -16,11 +16,68 @@ IGNORE_DIRS = {
 }
 
 
+# Non-.git project markers, in the same spirit as agent/context._PROJECT_MARKERS.
+# When a directory has no git history, one of these still identifies the ROOT of
+# a real project — so a deep build dir anchors to its own project instead of
+# silently adopting $HOME.
+_ROOT_PROJECT_MARKERS = (
+    "package.json",
+    "pyproject.toml",
+    "go.mod",
+    "Cargo.toml",
+    "tsconfig.json",
+)
+
+
+def _is_home_or_shallower(path: Path) -> bool:
+    """True when `path` is $HOME, its parent, or the filesystem root/anchor.
+
+    These are never legitimate project roots. Adopting one forces the model to
+    carry long absolute paths (e.g. `$HOME/Desktop/Github/.../Anki/<model>/…`)
+    on every tool call, which it then corrupts (`Aki`, `gitHub`, hallucinated
+    users) and dies in failed-read loops. This predicate lets us refuse them.
+    """
+    try:
+        home = Path.home().resolve()
+    except (RuntimeError, OSError):
+        return False
+    return path in {home, home.parent, Path(path.anchor)}
+
+
 def find_repo_root(start: Path) -> Path:
+    """Locate the project root to anchor the model's paths against.
+
+    Order of preference:
+      1. The nearest ancestor containing `.git` — a real VCS root. This path is
+         behaviour-IDENTICAL to the original implementation and is what runs
+         whenever the user is inside a git checkout.
+      2. If there is no `.git` anywhere above `start`, the nearest ancestor
+         carrying a non-git project marker (package.json / pyproject.toml /
+         go.mod / Cargo.toml / tsconfig.json). This pins a *real* project dir
+         instead of walking all the way up to (and silently adopting) $HOME.
+      3. Otherwise `start` itself — but NEVER bare $HOME (or shallower). When
+         `start` resolves to $HOME with no project marker, we still hand back
+         $HOME (there is nothing nearer to anchor to), but callers can detect
+         that degenerate case via `_is_home_or_shallower` and mark it.
+    """
     current = start.resolve()
-    for candidate in [current, *current.parents]:
+    chain = [current, *current.parents]
+
+    # 1. A real .git root always wins — identical to the original behaviour.
+    for candidate in chain:
         if (candidate / ".git").exists():
             return candidate
+
+    # 2. No .git: prefer the nearest non-git project marker, but never accept a
+    #    marker at $HOME or shallower (those are not project roots).
+    for candidate in chain:
+        if _is_home_or_shallower(candidate):
+            break
+        if any((candidate / marker).exists() for marker in _ROOT_PROJECT_MARKERS):
+            return candidate
+
+    # 3. Nothing better than the launch dir. Return it unchanged (this is cwd);
+    #    if it IS $HOME the caller is responsible for marking the degenerate case.
     return current