localcode 0.4.7__tar.gz → 0.4.9__tar.gz

{localcode-0.4.7/src/localcode.egg-info → localcode-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.4.7
+Version: 0.4.9
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -99,8 +99,6 @@ start typing. `/models` switches later.
 > Implement the retry decorator in retry.py so every test in test_retry.py passes. Then run: pytest -q
 ```
 
-`localcode --classic` opens the previous (0.3) interface.
-
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
 ## What it does
@@ -137,7 +135,7 @@ localcode recommends a model by your Mac's memory and marks it with a star. You
 
 Min RAM is the memory at which localcode will recommend the model. You can pick a heavier one by hand. DiffusionGemma is a research model that is never recommended automatically.
 
-Measured on a MacBook Pro (M5 Max, 128 GB) with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
+Measured on a top-memory Apple Silicon laptop with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
 
 ## Network
 

{localcode-0.4.7 → localcode-0.4.9}/README.md

@@ -48,8 +48,6 @@ start typing. `/models` switches later.
 > Implement the retry decorator in retry.py so every test in test_retry.py passes. Then run: pytest -q
 ```
 
-`localcode --classic` opens the previous (0.3) interface.
-
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
 ## What it does
@@ -86,7 +84,7 @@ localcode recommends a model by your Mac's memory and marks it with a star. You
 
 Min RAM is the memory at which localcode will recommend the model. You can pick a heavier one by hand. DiffusionGemma is a research model that is never recommended automatically.
 
-Measured on a MacBook Pro (M5 Max, 128 GB) with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
+Measured on a top-memory Apple Silicon laptop with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
 
 ## Network
 

{localcode-0.4.7 → localcode-0.4.9}/pyproject.toml

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

{localcode-0.4.7 → localcode-0.4.9}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.4.7"
+    __version__ = "0.4.9"

localcode-0.4.9/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.4.9/src/localcode/bin/localcode-ui
+size: 102794210 bytes
+sha256: cf52ad70ee07959f7d3a788092340182ecf4f9b2815e06103aab72637c0d6a22

localcode-0.4.9/src/localcode/ui/FORK_COMMIT

@@ -0,0 +1 @@
+86d2d97133a017491e210e0bd00da194ea08c817

localcode-0.4.9/src/localcode/ui/context_budget.py

@@ -0,0 +1,189 @@
+"""How much context a session should use before compacting, measured on this machine.
+
+The server is launched with the largest context that fits in memory (the RAM
+ladder in runtime.py). That is the right ceiling for *fitting*, not for *speed*:
+on the same Mac a model's decode speed halves and its prefill speed drops four
+to six times between a 16k and a 64k prompt, so a session that fills 120k
+tokens spends minutes on every cache miss and crawls on every step.
+
+The budget is derived from the server's own timing lines (llama-server prints
+one per request into server.log, which the supervisor owns):
+
+    slot print_timing: id 0 | task 42 | prompt eval time = 727 ms / 650 tokens (...)
+    slot print_timing: id 0 | task 42 |        eval time = 16471 ms / 852 tokens (...)
+    slot release: id 0 | task 42 | stop processing: n_tokens = 31577, truncated = 0
+
+Each request gives one sample: how long the prompt was, how fast prefill ran
+at that depth, how fast decode ran at that depth. The budget is the largest
+prompt length at which a full re-read still finishes within REREAD_MAX_S and
+decode keeps at least DECODE_FLOOR of its short-prompt speed. Both constants
+are latencies a person feels, never token counts: every token number here is
+relative to the context the server actually loaded.
+"""
+from __future__ import annotations
+
+import re
+from statistics import median
+from typing import NamedTuple
+
+REREAD_MAX_S = 60.0    # a cache miss (compaction, restart, model switch) may cost this long
+DECODE_FLOOR = 0.5     # keep at least half of the short-prompt decode speed
+PP_MIN_CHUNK = 256     # prefill chunks smaller than this measure overhead, not speed
+TG_MIN_TOKENS = 16     # decode timings on fewer tokens are noise
+PRIOR_DEPTH_FACTOR = 0.6  # prefill at the budget depth is slower than the warm-up's cold prefill
+GRID = 16              # candidate budgets: n_ctx/16 steps
+FLOOR_DIV = 4          # never budget below n_ctx/4: the fixed prefix must fit with room to work
+
+_TIMING = re.compile(r"task +(\d+) \| +(prompt eval time|eval time) = +([\d.]+) ms / +(\d+) tokens")
+_RELEASE = re.compile(r"task +(\d+) \| stop processing: n_tokens = (\d+)")
+
+
+class Sample(NamedTuple):
+    n_tokens: int          # prompt length when the request finished
+    pp_tps: float | None   # prefill tokens/s for this request (None: no prefill line)
+    pp_n: int              # tokens prefilled
+    tg_tps: float | None   # decode tokens/s
+    tg_n: int              # tokens decoded
+
+
+class TimingTable:
+    """Accumulates samples from server.log text fed in any chunking."""
+
+    def __init__(self) -> None:
+        self._pending: dict[int, dict] = {}
+        self._carry = ""
+        self.samples: list[Sample] = []
+
+    def feed(self, text: str) -> int:
+        text = self._carry + text
+        lines = text.split("\n")
+        self._carry = lines.pop()  # partial last line
+        added = 0
+        for line in lines:
+            m = _TIMING.search(line)
+            if m:
+                task = int(m.group(1))
+                ms, n = float(m.group(3)), int(m.group(4))
+                tps = n / (ms / 1000.0) if ms > 0 else None
+                d = self._pending.setdefault(task, {})
+                if m.group(2).startswith("prompt"):
+                    d["pp_tps"], d["pp_n"] = tps, n
+                else:
+                    d["tg_tps"], d["tg_n"] = tps, n
+                continue
+            m = _RELEASE.search(line)
+            if m:
+                task, n_tokens = int(m.group(1)), int(m.group(2))
+                d = self._pending.pop(task, None)
+                if d is None:
+                    continue
+                self.samples.append(Sample(n_tokens, d.get("pp_tps"), int(d.get("pp_n", 0)),
+                                           d.get("tg_tps"), int(d.get("tg_n", 0))))
+                added += 1
+        if len(self._pending) > 512:  # a request whose release line never came
+            for k in sorted(self._pending)[:-256]:
+                self._pending.pop(k, None)
+        return added
+
+    def clear(self) -> None:
+        self._pending.clear(); self._carry = ""; self.samples.clear()
+
+
+def _near(samples: list[Sample], c: int, step: int, key: str, min_n: str, min_val: int) -> float | None:
+    """Median speed measured near prompt length c. With nothing near c, the closest
+    measurement below c decides (speed never improves with depth); with nothing
+    below either, the shallowest measurement stands in (optimistic)."""
+    usable = [s for s in samples if getattr(s, key) is not None and getattr(s, min_n) >= min_val]
+    if not usable:
+        return None
+    radius = max(step, c // 4)
+    near = [getattr(s, key) for s in usable if abs(s.n_tokens - c) <= radius]
+    if near:
+        return float(median(near))
+    below = [s for s in usable if s.n_tokens < c]
+    pool = below if below else usable
+    anchor = max(pool, key=lambda s: s.n_tokens) if below else min(pool, key=lambda s: s.n_tokens)
+    band = [getattr(s, key) for s in pool if abs(s.n_tokens - anchor.n_tokens) <= radius]
+    return float(median(band))
+
+
+def budget(n_ctx: int, reserve: int, samples: list[Sample], prior_pp_tps: float | None = None,
+           *, reread_max_s: float = REREAD_MAX_S, decode_floor: float = DECODE_FLOOR) -> tuple[int, dict]:
+    """Prompt tokens a session may reach before compacting, and how that was decided.
+
+    Everything is relative to n_ctx, the context the server actually loaded
+    (per slot). `reserve` is the headroom one step may add (output plus tool
+    results); the budget never exceeds n_ctx - reserve and never drops below
+    n_ctx / FLOOR_DIV."""
+    n_ctx = max(1, int(n_ctx))
+    step = max(1, n_ctx // GRID)
+    cap = max(1, n_ctx - max(0, int(reserve)))
+    # The floor is the larger of a quarter of the context and twice the fixed
+    # prefix (system prompt, tool schemas, first message). Below the prefix a
+    # compaction cannot bring the prompt under the budget, so the runtime would
+    # compact on every step; measured live at 16k ctx before this rule existed.
+    prefix = prefix_tokens(samples)
+    floor = max(1, n_ctx // FLOOR_DIV, 2 * prefix if prefix else 0)
+    if floor > cap:
+        floor = cap
+    info: dict = {"n_ctx": n_ctx, "floor": floor, "cap": cap, "prefix": prefix, "samples": 0, "basis": "cap"}
+
+    measured = [s for s in samples if s.pp_tps is not None and s.pp_n >= PP_MIN_CHUNK]
+    if not measured:
+        if prior_pp_tps and prior_pp_tps > 0:
+            c = int(PRIOR_DEPTH_FACTOR * prior_pp_tps * reread_max_s)
+            info.update(basis="prior", pp_prior=round(prior_pp_tps, 1))
+            return _snap(min(cap, max(floor, c)), step, floor, cap), info
+        return cap, info
+
+    info["samples"] = len(samples)
+    short = [s.tg_tps for s in samples if s.tg_tps is not None and s.tg_n >= TG_MIN_TOKENS and s.n_tokens < n_ctx // 8]
+    if not short:
+        deep = sorted((s for s in samples if s.tg_tps is not None and s.tg_n >= TG_MIN_TOKENS), key=lambda s: s.n_tokens)
+        short = [s.tg_tps for s in deep[: max(1, len(deep) // 4)]] if deep else []
+    tg_short = float(median(short)) if short else None
+    info["tg_short"] = round(tg_short, 1) if tg_short else None
+
+    best = floor
+    for k in range(1, GRID + 1):
+        c = step * k
+        if c > cap:
+            break
+        pp = _near(samples, c, step, "pp_tps", "pp_n", PP_MIN_CHUNK)
+        reread = (c / pp) if pp else 0.0
+        if reread > reread_max_s:
+            info.update(limit="reread", at=c, reread_s=round(reread, 1), pp_tps=round(pp or 0, 1))
+            break
+        if tg_short:
+            tg = _near(samples, c, step, "tg_tps", "tg_n", TG_MIN_TOKENS)
+            if tg is not None and tg < decode_floor * tg_short:
+                info.update(limit="decode", at=c, tg_tps=round(tg, 1))
+                break
+        best = c
+    info["basis"] = "measured"
+    return _snap(best, step, floor, cap), info
+
+
+PREFIX_FIRST_N = 3     # the first main request is among the first few large prefills after load
+
+
+def prefix_tokens(samples: list[Sample]) -> int:
+    """Size of the fixed prompt prefix (system prompt, tool schemas, first
+    message). The first main request of a session prefills it cold; the other
+    early requests are small side requests (title) or the warm-up replay of the
+    same prefix, so the largest of the first few large prefills is the estimate.
+    Later prefills cannot be used: after a compaction they are short. 0 until a
+    large prefill has been observed."""
+    cold = [s.pp_n for s in samples if s.pp_n >= PP_MIN_CHUNK and s.pp_tps is not None][:PREFIX_FIRST_N]
+    return max(cold) if cold else 0
+
+
+def _snap(c: int, step: int, floor: int, cap: int) -> int:
+    c = (c // step) * step
+    return min(cap, max(floor, c))
+
+
+def step_reserve(n_ctx: int, output: int, tool_output_bytes: int) -> int:
+    """Tokens one model step can add: its reply plus a couple of large tool
+    results. Bounded to half the context so tiny contexts keep room to work."""
+    return min(max(1, n_ctx // 2), max(0, output) + 2 * (max(0, tool_output_bytes) // 4))

{localcode-0.4.7 → localcode-0.4.9}/src/localcode/ui/launch.py

@@ -70,7 +70,13 @@ def _context_size(models_dir: Path, ctrl: int) -> int:
         from localcode.ui.server_cmd import context_size
         return context_size(str(models_dir / "x.gguf"))
     except Exception:  # noqa: BLE001
-        return 32768
+        # No server and no runtime gateway to ask: the same policy knob the
+        # gateway starts from, never a literal token count.
+        try:
+            from localcode.config import load_config
+            return max(2048, int(load_config().max_context_chars) // 4)
+        except Exception:  # noqa: BLE001
+            return 2048
 
 
 def write_config(path: Path, *, port: int, ctx: int, alias: str | None) -> None:
@@ -97,6 +103,10 @@ def write_config(path: Path, *, port: int, ctx: int, alias: str | None) -> None:
             }
         },
         "enabled_providers": ["localcode"],
+        # The supervisor's /status budget already includes the headroom one step
+        # can add (ui/context_budget.step_reserve), and the provider sets it as
+        # the model's input limit; a second reserve here would double-count.
+        "compaction": {"reserved": 0},
         "tools": {"task": False},
         "agent": {"plan": {"disable": True}},
         "lsp": True,
@@ -116,9 +126,11 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
     """Open another UI window on the model server a running session owns."""
     port = int(status["port"])
     try:
-        ctx = int(status.get("ctx") or 0) or 32768
+        ctx = int(status.get("ctx") or 0)
     except (TypeError, ValueError):
-        ctx = 32768
+        ctx = 0
+    if not ctx:
+        ctx = _context_size(_models_dir(), ctrl)
     current = status.get("current") or None
     if alias and current and alias != current:
         print(f"localcode: attaching to the running session's model {current}; use /models there to switch.",

{localcode-0.4.7 → localcode-0.4.9}/src/localcode/ui/plugin/localcode.ts

@@ -20,8 +20,11 @@
  *     after failing, a check whose failure set shrinks or shows a new failure
  *     signature, or a todowrite raising the completed count. From round 4 on,
  *     6 consecutive no-progress rounds nudge once ("stop experimenting, deliver
- *     the open items, run the check once, finish"); 8 more stop the session via
- *     client.session.abort and log a partial summary. If the last check
+ *     the open items, run the check once, finish"); 8 more stop the task: further
+ *     tool calls are refused with the reason so the model writes up what it has
+ *     and the turn ends by itself (session.abort only if it ignores 3 refusals).
+ *     A turn that has delivered nothing yet (research, investigation) counts a
+ *     round with a never-seen tool call as progress, so only repetition stops it. If the last check
  *     passed within 2 rounds the stop is replaced once by a "finish now" nudge
  *     and 3 more rounds. Repeated identical check failures are tracked separately:
  *     3 request a focused diagnosis; 8 stop further churn, even after new edits.
@@ -33,7 +36,7 @@
  */
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import type { Plugin } from "@opencode-ai/plugin";
@@ -49,9 +52,11 @@ const PLANNING_RULE = `WORKSPACE TASK COMPLETION:
 - These execution rules apply ONLY when the user asks for work on project files. Answer general questions, advice, greetings, and unrelated web research directly, without todowrite, repository exploration, build checks, or creating files. Do not invent deliverables, compliance requirements, or project work the user did not request.
 - LOCALCODE.md is the only project instruction file and is supplied automatically. Never read, create, or update legacy agent instruction files. Do not seek out configuration or skills for unrelated questions.
 - Keep going until the user's request is COMPLETELY done. Do not end your turn while any part of the work remains. A dev server that starts, a scaffold that installs, a single file written — none of these is "done" unless that was the entire request.
-- PLAN, THEN EXECUTE THE PLAN. For requested multi-step workspace changes, call todowrite FIRST to lay out every concrete step (one per requirement, and every deliverable the user named — a README is a plan item like any feature, not a closing flourish). Skip the plan for one/two-step tasks. Keep exactly ONE item in_progress.
+- ORIENT FROM THE SNAPSHOT, NOT FROM TOOL CALLS. The first user turn carries a snapshot of the workspace (top two levels) and later turns report files changed outside this session. Do not list directories or glob just to see what exists; if a file you need is not in the snapshot or a change report, glob for that specific file. Open only the files you will change or must quote. Every tool call is a full model round trip; a typical small change is read -> edit -> check, three calls.
+- PLAN, THEN EXECUTE THE PLAN. For requested workspace changes of THREE or more steps, call todowrite FIRST to lay out every concrete step (one per requirement, and every deliverable the user named — a README is a plan item like any feature, not a closing flourish). Skip the plan for one/two-step tasks. Keep exactly ONE item in_progress. Mark a step completed as soon as its last edit lands (one todowrite call, which may also set the next item in_progress); never call todowrite twice in a row without an edit or check in between, and never before AND after the same edit.
+- ONE EDIT PER FILE PER STEP: when a step changes several places in one file, make them in a single edit or multi-edit call.
 - Validate incrementally: get the minimal scaffold building before implementing the full app. After each coherent feature, run the relevant check and repair failures before adding more features. Do not defer all integration checks until the end.
-- The last plan item is final verification: run the project's own build/typecheck and one smoke check of the main flow. Do not repeat already-passing checks without new edits, or install browsers and test rigs unless requested.
+- RUN THE CHECK ONCE, AFTER THE EDIT. Do not run tests or builds before you have changed anything unless the user asked for a diagnosis; do not re-run a passing check without a new edit. The last plan item is final verification: the project's own build/typecheck and one smoke check of the main flow. Do not install browsers and test rigs unless requested.
 - Write complete, runnable code — no TODOs, stubs, placeholders, "demo only" or "you could add…". If a piece is too big for one call, split it across calls; never drop it.
 - Only stop for one of two reasons: (a) every todo is completed and verified, or (b) you have ONE specific blocking question you cannot answer yourself. The harness sends you back to the next open item if you stop early.
 - Never run a foreground server (npm run dev, vite, http.server) through bash: start it in the background with nohup ... & and a log file, then curl it.`;
@@ -155,6 +160,7 @@ const PLATEAU_NUDGE_AFTER = 6;      // consecutive no-progress rounds -> nudge o
 const PLATEAU_STOP_AFTER = 8;       // further no-progress rounds after the nudge -> stop
 const PLATEAU_RECENT_PASS = 2;      // a check that passed within this many rounds blocks the stop...
 const PLATEAU_PASS_GRACE = 3;       // ...and grants this many more rounds after a "finish now" nudge
+const PLATEAU_STOP_DENIALS = 3;     // tool calls refused after a stop before the session is aborted as a last resort
 
 type ToolEvent = { tool: string; args: any; output?: string; metadata?: any };
 type ProgressMemory = {
@@ -334,6 +340,12 @@ class RepeatedCheckTracker {
   }
 }
 
+/** Identity of a tool call for repetition detection: same tool, same arguments. */
+function callSignature(ev: ToolEvent): string {
+  const args = ev.tool === "bash" ? { command: String(ev.args?.command ?? "").replace(/\s+/g, " ").trim(), workdir: ev.args?.workdir } : ev.args;
+  return createHash("sha256").update(ev.tool + "\n" + JSON.stringify(args ?? null)).digest("hex");
+}
+
 /** Round bookkeeping and thresholds. One instance per session; reset on a genuine user message. */
 class PlateauTracker {
   constructor(private directory?: string) {}
@@ -347,6 +359,8 @@ class PlateauTracker {
   lastPassRound = -Infinity; // round number (1-based, the round it ran in) of the last passing check
   private open = false;      // a round is open once a tool ran in the current step
   private reasons: string[] = [];
+  private novel = false;     // this round made a tool call not seen before in the turn
+  private callSigs = new Set<string>();
   readonly repeated = new RepeatedCheckTracker();
   private repairDecision: PlateauDecision = "none";
 
@@ -357,6 +371,8 @@ class PlateauTracker {
     if (repair !== "none") this.repairDecision = repair;
     const r = progressOf(ev, this.mem, this.directory);
     if (r) this.reasons.push(r);
+    const sig = callSignature(ev);
+    if (!this.callSigs.has(sig)) { this.callSigs.add(sig); this.novel = true; }
     if (ev.tool === "bash" && isCheckCommand(String(ev.args?.command ?? "")) && this.mem.lastCheckPassed) this.lastPassRound = this.round + 1;
   }
 
@@ -381,8 +397,13 @@ class PlateauTracker {
       if (decision === "stop") { this.stopped = true; this.repairStopped = true; }
       return decision;
     }
-    const progressed = this.reasons.length > 0;
-    this.reasons = [];
+    // A turn that has delivered nothing yet (research, investigation, a
+    // question answered from the code) is measured by whether it is still
+    // covering new ground: a round with at least one never-seen tool call is
+    // progress. Once something has been delivered, only deliverables count.
+    const exploring = this.novel && this.mem.changedPaths.size === 0 && this.mem.completedTodos === 0;
+    const progressed = this.reasons.length > 0 || exploring;
+    this.reasons = []; this.novel = false;
     if (progressed) { this.noProgress = 0; this.nudged = false; this.passNudged = false; return "none"; }
     this.noProgress += 1;
     if (this.round < PLATEAU_MIN_ROUND) return "none";
@@ -409,7 +430,81 @@ function plateauNudgeText(open: Todo[]): string {
 }
 const PLATEAU_PASS_TEXT = `${NUDGE_PREFIX} Your check passed — finish now. Do not start another experiment: write up what is delivered and what is not, then stop.`;
 
+// Workspace layout for the system prompt: two levels, capped, computed ONCE per
+// session so the cached prefix never changes. Removes the agent's orientation
+// reads (read:tests, glob **/*.py) which were ~2 round trips per task.
+const LAYOUT_SKIP = new Set([".git", "node_modules", ".venv", "venv", "__pycache__", ".pytest_cache", ".mypy_cache", "dist", "build", ".localcode-agent", ".eval", ".next", "target", ".cache", ".DS_Store"]);
+const LAYOUT_MAX_ENTRIES = 200;
+const LAYOUT_MAX_CHARS = 6000;
+const CHANGES_MAX = 20;
+const SCAN_MAX_FILES = 4000;
+/** Modification times of every file (skip list applied, depth-unlimited, capped). */
+function scanTree(directory: string): Map<string, number> {
+  const out = new Map<string, number>();
+  const walk = (dir: string, rel: string) => {
+    if (out.size >= SCAN_MAX_FILES) return;
+    let entries: import("node:fs").Dirent[] = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const d of entries) {
+      if (LAYOUT_SKIP.has(d.name)) continue;
+      const r = rel ? rel + "/" + d.name : d.name;
+      if (d.isDirectory()) walk(join(dir, d.name), r);
+      else if (d.isFile()) { try { out.set(r, statSync(join(dir, d.name)).mtimeMs); } catch {} }
+      if (out.size >= SCAN_MAX_FILES) return;
+    }
+  };
+  walk(directory, "");
+  return out;
+}
+/** Files added, modified or removed since `prev`, ignoring paths the agent itself touched. */
+function treeChanges(prev: Map<string, number>, now: Map<string, number>, ignore: Set<string>): string {
+  const added: string[] = [], modified: string[] = [], removed: string[] = [];
+  for (const [k, t] of now) { if (ignore.has(k)) continue; if (!prev.has(k)) added.push(k); else if (prev.get(k) !== t) modified.push(k); }
+  for (const k of prev.keys()) if (!now.has(k) && !ignore.has(k)) removed.push(k);
+  const total = added.length + modified.length + removed.length;
+  if (!total) return "";
+  const cap = (xs: string[]) => xs.slice(0, CHANGES_MAX).join(", ") + (xs.length > CHANGES_MAX ? `, +${xs.length - CHANGES_MAX} more` : "");
+  const parts = [];
+  if (added.length) parts.push("added: " + cap(added));
+  if (modified.length) parts.push("modified: " + cap(modified));
+  if (removed.length) parts.push("removed: " + cap(removed));
+  return "WORKSPACE CHANGED SINCE YOUR LAST TURN (outside this session): " + parts.join("; ") + ".";
+}
+function workspaceLayout(directory: string): string {
+  const lines: string[] = [];
+  let truncated = false;
+  const list = (dir: string): string[] => {
+    try { return readdirSync(dir, { withFileTypes: true }).filter((d) => !LAYOUT_SKIP.has(d.name)).sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name)).map((d) => d.isDirectory() ? d.name + "/" : d.name); } catch { return []; }
+  };
+  for (const top of list(directory)) {
+    if (lines.length >= LAYOUT_MAX_ENTRIES) { truncated = true; break; }
+    lines.push(top);
+    if (top.endsWith("/")) {
+      const kids = list(join(directory, top));
+      for (const k of kids) {
+        if (lines.length >= LAYOUT_MAX_ENTRIES) { truncated = true; break; }
+        lines.push("  " + k);
+      }
+    }
+  }
+  if (!lines.length) return "";
+  let body = lines.join("\n");
+  if (body.length > LAYOUT_MAX_CHARS) { body = body.slice(0, LAYOUT_MAX_CHARS); truncated = true; }
+  return "WORKSPACE SNAPSHOT AT SESSION START (top two levels" + (truncated ? ", truncated" : "") + "; files you or the user add later are reported at the start of each turn):\n" + body;
+}
+
 const LocalcodePlugin: Plugin = async ({ client, directory }) => {
+  const layoutBlock = workspaceLayout(directory);
+  // Per-session workspace state lives on disk, not in memory: a headless `run`
+  // is one process per turn, and a user may close and reopen the UI mid-session.
+  // Without this the snapshot was re-sent on every turn and no change was ever reported.
+  const wsStateDir = join(directory, ".localcode-agent");
+  const wsStatePath = (sessionID: string) => join(wsStateDir, `ws-${sessionID.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  type WsState = { sent: boolean; tree: Record<string, number>; touched: string[] };
+  const loadWs = (sessionID: string): WsState | undefined => { try { return JSON.parse(readFileSync(wsStatePath(sessionID), "utf8")); } catch { return undefined; } };
+  const saveWs = (sessionID: string, st: WsState) => { try { mkdirSync(wsStateDir, { recursive: true }); writeFileSync(wsStatePath(sessionID), JSON.stringify(st)); } catch {} };
+  const touchWs = (sessionID: string, rel: string) => { const st = loadWs(sessionID); if (!st) return; if (!st.touched.includes(rel)) { st.touched.push(rel); saveWs(sessionID, st); } };
+  const agentTouched = new Set<string>();
   let todos: Todo[] = [];
   let workspaceActive = false;
   let continueCount = 0;
@@ -420,6 +515,8 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
   let turnStartedAt = Date.now() - 1000;
   let plateau = new PlateauTracker(directory);
   let plateauStopped = false;
+  let stopDenials = 0;       // tool calls refused since the plateau stop
+  let stopReason = "";
   const interrupted = new Set<string>();
   let activeSession: string | undefined;
   // The agent the user is talking to. Nudges must keep it (a prompt without an
@@ -489,6 +586,7 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
     }
     // stop
     plateauStopped = true;
+    stopDenials = 0;
     const files = [...plateau.mem.changedPaths];
     if (plateau.repairStopped) {
       plog(plateau.repeated.evidence);
@@ -505,7 +603,13 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
       `files delivered ${files.length}${files.length ? ` (${files.slice(0, 12).join(", ")}${files.length > 12 ? ", ..." : ""})` : ""}, ` +
       `open items ${open.length}${open.length ? `: ${open.map((t) => t.content).join("; ")}` : ""}, ` +
       `last check ${plateau.mem.lastCheckPassed === null ? "never run" : plateau.mem.lastCheckPassed ? "passed" : "failed"}; treat as partial`);
-    try { await client.session.abort({ path: { id: sessionID } }); } catch (e: any) { plog(`abort failed: ${e?.message ?? e}`); }
+    // No session.abort here: that killed whatever tool was running and showed
+    // the user "Interrupted" with no explanation. Instead further tool calls are
+    // refused with the reason (tool.execute.before), so the model writes up
+    // what it has and the turn ends on its own.
+    stopReason = plateau.repairStopped
+      ? `${NUDGE_PREFIX} LocalCode stopped this task: the same check has kept failing identically. Do not call any more tools. Reply now, in text: what is delivered, what still fails and why, and what you would try next. The user can send a message to continue.`
+      : `${NUDGE_PREFIX} LocalCode stopped this task: ${plateau.round} tool rounds with no new progress after being asked to finish. Do not call any more tools. Reply now, in text: what is delivered, what is not, and why. The user can send a message to continue.`;
     return decision;
   }
 
@@ -547,7 +651,19 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
         continueCount = 0; stuckCount = 0; lastRemaining = Number.MAX_SAFE_INTEGER;
         buildVerifyNudges = 0; stubNudgeDone = false;
         turnStartedAt = Date.now() - 1000;
-        plateau = new PlateauTracker(directory); plateauStopped = false; seenSteps.clear();
+        plateau = new PlateauTracker(directory); plateauStopped = false; stopDenials = 0; stopReason = ""; seenSteps.clear();
+      }
+      if (!text.startsWith(NUDGE_PREFIX)) {
+        const st = loadWs(input.sessionID);
+        const now = scanTree(directory);
+        if (!st || !st.sent) {
+          if (layoutBlock) output.parts.push({ type: "text", text: layoutBlock, synthetic: true, sessionID: input.sessionID, messageID: input.messageID } as any);
+        } else {
+          const ignore = new Set([...st.touched, ...agentTouched]);
+          const report = treeChanges(new Map(Object.entries(st.tree)), now, ignore);
+          if (report) output.parts.push({ type: "text", text: report, synthetic: true, sessionID: input.sessionID, messageID: input.messageID } as any);
+        }
+        saveWs(input.sessionID, { sent: true, tree: Object.fromEntries(now), touched: [] });
       }
       // Open todos travel with the turn (user message or nudge), never in the
       // system prompt, so the cached prefix stays stable across todo updates.
@@ -559,10 +675,23 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
       if (activeSession && input.sessionID !== activeSession) return;
       if (["read", "glob", "grep", "bash", "write", "edit", "multiedit", "apply_patch"].includes(input.tool)) workspaceActive = true;
       plateau.observe({ tool: input.tool, args: input.args, output: output?.output, metadata: output?.metadata });
+      for (const p of editedPaths({ tool: input.tool, args: input.args, output: output?.output, metadata: output?.metadata })) {
+        const rel = relative(resolve(directory), resolve(directory, p)).replace(/\\/g, "/");
+        agentTouched.add(rel);
+        if (input.sessionID) touchWs(input.sessionID, rel);
+      }
       if (process.env.LOCALCODE_PLUGIN_DEBUG) emit(`[localcode debug] progress: ${plateau.mem.changedPaths.size} delivered files, ${plateau.mem.completedTodos} completed todos`);
     },
 
     "tool.execute.before": async (input, output) => {
+      if (plateauStopped && stopReason && (!activeSession || input.sessionID === activeSession)) {
+        stopDenials += 1;
+        if (stopDenials > PLATEAU_STOP_DENIALS) {
+          plog(`model kept calling tools after the stop (${stopDenials} refused); aborting the session as a last resort`);
+          client.session.abort({ path: { id: input.sessionID } }).catch((e: any) => plog(`abort failed: ${e?.message ?? e}`));
+        }
+        throw new Error(stopReason);
+      }
       if (["read", "glob", "grep", "bash", "write", "edit", "multiedit", "apply_patch"].includes(input.tool)) workspaceActive = true;
       if (["read", "write", "edit", "multiedit"].includes(input.tool)) {
         for (const name of ["filePath", "file_path", "path"]) {
@@ -631,6 +760,7 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
           const next = open.find((t) => t.status === "in_progress") ?? open[0];
           log(`${open.length} todo(s) still open — continuing with: ${next.content}`);
           plateau.freshInstruction();
+          try { void client.tui?.showToast?.({ body: { title: "Continuing", message: `${open.length} todo(s) still open — next: ${next.content.slice(0, 60)}`, variant: "info", duration: 6000 } })?.catch?.(() => {}); } catch {}
           await nudge(sessionID, `${NUDGE_PREFIX} You still have ${open.length} unfinished todo(s). The task is NOT complete — do not stop. Continue now with: ${next.content}. Mark a todo completed via todowrite only when it is genuinely done, and keep going until every item is completed.`);
           return;
         }
@@ -645,6 +775,7 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
           stubNudgeDone = true;
           log(`placeholders found in ${stubs.length} line(s) — sending back`);
           plateau.freshInstruction();
+          try { void client.tui?.showToast?.({ body: { title: "Continuing", message: `${stubs.length} placeholder line(s) still to implement`, variant: "info", duration: 6000 } })?.catch?.(() => {}); } catch {}
           await nudge(sessionID, `${NUDGE_PREFIX} your changes still contain placeholders — the user asked for complete, working features, not stubs:\n${stubs.join("\n")}\nImplement each one for real (reopen it as a todo if needed), or tell the user explicitly which requirement you cannot meet and why.`);
           return;
         }
@@ -675,5 +806,5 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
 // if one is not a function ("Plugin export is not a function") — which silently
 // disabled this whole plugin once test helpers were exported. Expose the helpers
 // as properties on the plugin function instead; tests read them from `default`.
-Object.assign(LocalcodePlugin, { PLATEAU_MIN_ROUND, PLATEAU_NUDGE_AFTER, PLATEAU_STOP_AFTER, PLATEAU_RECENT_PASS, PLATEAU_PASS_GRACE, newProgressMemory, projectCheck, checkDirectory, CHECK_CMD, isCheckCommand, filteredCheck, isTempPath, editedPaths, failureSignatures, checkPassed, progressOf, referenceOnlyTypecheck, RepeatedCheckTracker, PlateauTracker, plateauNudgeText, PLATEAU_PASS_TEXT });
+Object.assign(LocalcodePlugin, { PLATEAU_MIN_ROUND, PLATEAU_NUDGE_AFTER, PLATEAU_STOP_AFTER, PLATEAU_RECENT_PASS, PLATEAU_PASS_GRACE, PLATEAU_STOP_DENIALS, callSignature, newProgressMemory, projectCheck, checkDirectory, CHECK_CMD, isCheckCommand, filteredCheck, isTempPath, editedPaths, failureSignatures, checkPassed, progressOf, referenceOnlyTypecheck, RepeatedCheckTracker, PlateauTracker, plateauNudgeText, PLATEAU_PASS_TEXT });
 export default LocalcodePlugin;