localcode 0.3.21__tar.gz → 0.3.22__tar.gz

{localcode-0.3.21/src/localcode.egg-info → localcode-0.3.22}/PKG-INFO

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

{localcode-0.3.21 → localcode-0.3.22}/pyproject.toml

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

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.21"
+__version__ = "0.3.22"

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/agent/context.py

@@ -605,20 +605,22 @@ def _msg_bytes(messages: list[dict]) -> int:
 
 def _window_aware_compaction(ctx_window_chars: int | None) -> tuple[int, int]:
     """(history_budget_bytes, keep_recent_tool_results) scaled to the context
-    window. The whole point: compaction must be DYNAMIC per machine. A 16 GB
-    Mac with a ~16K window has no room, so aggressive lossy compaction (the
-    old fixed 36 KB / keep-4) is correct. A 128 GB Mac with a 128K window has
-    ~8x the room — crushing its history to 36 KB threw away the data model the
-    model needs and made it lose track / re-read / drift. So budget ~55% of
-    the window to history and keep proportionally more recent tool output.
+    window. Capacity and replay latency are separate budgets: large-RAM Macs
+    can retain richer recent evidence, but hybrid/recurrent local models may
+    still re-process the entire prompt each round. Durable ledgers preserve
+    completed work while this hot transcript remains bounded.
 
     `ctx_window_chars` ≈ num_ctx tokens × ~3.5 chars/token. None/unknown →
     the legacy fixed behaviour (back-compat, safe on tiny windows).
     """
     if not ctx_window_chars or ctx_window_chars <= 0:
         return 36_000, COMPACT_KEEP_RECENT_TOOL_RESULTS
-    budget = max(36_000, int(ctx_window_chars * 0.55))
-    keep = max(COMPACT_KEEP_RECENT_TOOL_RESULTS, min(24, ctx_window_chars // 20_000))
+    # A large KV window is capacity, not a latency target. Live 128 GB / Qwen
+    # traces showed TTFT rising from ~2 s to 44 s as one build replayed ~28K
+    # prompt tokens. Cap the hot transcript while the durable progress ledger
+    # and filesystem-state block preserve what was completed.
+    budget = max(36_000, min(48_000, int(ctx_window_chars * 0.20)))
+    keep = max(COMPACT_KEEP_RECENT_TOOL_RESULTS, min(8, ctx_window_chars // 40_000))
     return budget, keep
 
 
@@ -704,31 +706,36 @@ def _microcompact_for_prompt_budget(messages: list[dict], *, target_bytes: int =
         return messages
 
     system_count = 1 if messages and messages[0].get("role") == "system" else 0
-    boundary = max(system_count, len(messages) - 12)
-    while boundary > system_count:
-        if messages[boundary].get("role") == "tool":
-            boundary -= 1
-            continue
-        prev = messages[boundary - 1]
-        if prev.get("role") == "assistant" and prev.get("tool_calls"):
-            boundary -= 1
+    best = messages
+    # Tighten the protocol-safe suffix until the serialized prompt fits. A
+    # fixed 12-message tail can itself contain several complete source files.
+    for tail_size in (12, 10, 8, 6, 4):
+        boundary = max(system_count, len(messages) - tail_size)
+        while boundary > system_count:
+            if messages[boundary].get("role") == "tool":
+                boundary -= 1
+                continue
+            prev = messages[boundary - 1]
+            if prev.get("role") == "assistant" and prev.get("tool_calls"):
+                boundary -= 1
+                continue
+            break
+        if boundary <= system_count:
             continue
-        break
-    if boundary <= system_count:
-        return messages
-
-    old = messages[system_count:boundary]
-    recent = messages[boundary:]
-    summary = _compact_history_summary(old)
-    candidate = [
-        *messages[:system_count],
-        {"role": "user", "content": summary},
-        {"role": "assistant", "content": "Continuing with the summarized prior work."},
-        *recent,
-    ]
-    if _msg_bytes(candidate) >= _msg_bytes(messages):
-        return messages
-    return candidate
+        old = messages[system_count:boundary]
+        recent = messages[boundary:]
+        summary = _compact_history_summary(old)
+        candidate = [
+            *messages[:system_count],
+            {"role": "user", "content": summary},
+            {"role": "assistant", "content": "Continuing with the summarized prior work."},
+            *recent,
+        ]
+        if _msg_bytes(candidate) < _msg_bytes(best):
+            best = candidate
+        if _msg_bytes(candidate) <= target_bytes:
+            return candidate
+    return best
 
 
 def _compact_history_summary(messages: list[dict]) -> str:

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/agent/loop.py

@@ -1739,6 +1739,18 @@ def run_agent_loop(
             _round_tool_exec_ms += int(
                 (time.monotonic() - _tool_started_at) * 1000
             )
+            if _goal_state.goal_type == "build_app":
+                from ..thinking import next_task_stage_after_tool
+                _next_stage = next_task_stage_after_tool(
+                    _current_task_stage_for_thinking(),
+                    tool_name,
+                    succeeded=(
+                        bool(_tool_facts.get("ok", True))
+                        and not tool_result_is_error(str(tool_result))
+                    ),
+                )
+                if _next_stage == "running":
+                    _announce_task_stage(_next_stage)
             if tool_name == "bash":
                 _bash_cmd = str(args.get("command", ""))
                 bash_history.append((_bash_cmd, str(tool_result)))
@@ -2079,11 +2091,18 @@ def run_agent_loop(
         # counts as another re-planning round. Quiet rounds (no progress, no
         # narration) leave the streak unchanged.
         _round_changed_new_file = len(changed_files) > _changed_files_at_round_start
-        _round_ran_build = ran_build_or_test(bash_history[_bash_history_at_round_start:])
+        _round_bash = bash_history[_bash_history_at_round_start:]
+        _round_ran_build = ran_build_or_test(_round_bash)
+        # Successful setup/scaffolding is concrete progress too. The live trace
+        # incorrectly called mkdir + npm create "re-planning without progress".
+        _round_ran_successful_bash = any(
+            result and not str(result).startswith(("[exit code ", "Error:", "REJECTED:"))
+            for _cmd, result in _round_bash
+        )
         _round_had_reasoning = bool(
             (content and content.strip()) or _round_reasoning_chars > 0
         )
-        if _round_changed_new_file or _round_ran_build:
+        if _round_changed_new_file or _round_ran_build or _round_ran_successful_bash:
             _planning_streak = 0
         elif _round_had_reasoning and not _round_was_readonly:
             _planning_streak += 1

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/model_config.py

@@ -32,10 +32,12 @@ from __future__ import annotations
 # tier whose min_ram_gb is satisfied wins, else DEFAULT.
 #
 # Only 16 GB→64K and 64 GB→128K are hardware-measured; 24/32/36 hold at 64K
-# pending real-hardware OOM measurement. 96 GB+ unlocks 256K (every current
-# catalog model trains to >=256K, so on a big machine RAM is the binding cap).
+# pending real-hardware OOM measurement. 96 GB+ stays at 128K: at 256K the
+# Qwen checkpoint path is disabled due a measured Metal SIGKILL, forcing a
+# full prompt prefill every round. 128K keeps four checkpoints and is faster
+# for long agentic tasks; 256K remains an explicit override.
 RAM_CTX_CEILING_TIERS: tuple[tuple[int, int], ...] = (
-    (96, 262144),   # 256K — 96/128/192 GB hold a 256K KV easily
+    (96, 131072),   # 128K — checkpointed fast path; 256K is experimental
     (64, 131072),   # 128K (validated; 256K KV is tight beside a Q8 model on 64 GB)
     (48, 98304),    # 96K
 )
@@ -162,15 +164,15 @@ def keep_recent_for_window(context_window: int) -> int:
 # The always-injected "what I've already done" ledger (Codex-style tool-state
 # awareness) must be COMPACT on a 16 GB Mac (64K window — the window is
 # precious, the ledger is the model's primary surviving memory) and can be
-# RICHER on a 128 GB Mac (256K window — plenty of room, it's a safety net).
+# RICHER on a 128 GB Mac (128K default window; it is still a safety net).
 # A single ladder keyed on the launched window covers every RAM tier
-# (8/16/24/32/36/48/64/96/128/192 GB → 64K…256K via _ram_ctx_ceiling).
+# (8/16/24/32/36/48/64/96/128/192 GB → 64K…128K by default).
 def progress_ledger_budget_chars(context_window_tokens: int) -> int:
     """Max chars for the per-round progress ledger, scaled to the window."""
     w = context_window_tokens or 0
-    if w >= 262144:   # 96 GB+ → 256K
+    if w >= 262144:   # explicit experimental 256K override
         return 3500
-    if w >= 131072:   # 64 GB → 128K
+    if w >= 131072:   # 64 GB+ → 128K
         return 2200
     if w >= 98304:    # 48 GB → 96K
         return 1600

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/runtime.py

@@ -629,8 +629,8 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
 
         The tier ladder lives in `model_config.RAM_CTX_CEILING_TIERS` (the
         central per-Mac config); this delegates so the numbers are edited in
-        one place. Every current catalog model trains to >=256K, so on a big
-        machine RAM is the binding constraint — 96 GB+ unlocks 256K; small-RAM
+        one place. The normal high-RAM default is the checkpointed 128K path;
+        256K remains available as an explicit experimental override. Small-RAM
         tiers stay conservative (16 GB→64K, 64 GB→128K hardware-measured).
         """
         from .model_config import ram_ctx_ceiling

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/thinking.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__all__ = ["should_use_thinking"]
+__all__ = ["should_use_thinking", "next_task_stage_after_tool"]
 
 
 _AUTO_REASONING_HINTS = (
@@ -26,6 +26,25 @@ _NO_THINKING_STAGES = {
 }
 
 
+def next_task_stage_after_tool(
+    current_stage: str,
+    tool_name: str,
+    *,
+    succeeded: bool,
+) -> str:
+    """Leave reasoning-heavy scaffolding after successful implementation work."""
+    stage = (current_stage or "").strip().lower()
+    tool = (tool_name or "").strip().lower()
+    if not succeeded or stage not in {"planning", "scaffolding"}:
+        return stage
+    if tool in {
+        "write_file", "edit_file", "multi_edit", "apply_patch",
+        "bash", "launch_app",
+    }:
+        return "running"
+    return stage
+
+
 def should_use_thinking(
     runtime_mode: str,
     internal_thinking_mode: str,

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/tools/bash.py

@@ -159,6 +159,18 @@ _PACKAGE_INSTALL_RE = re.compile(
     re.IGNORECASE,
 )
 
+_MASKED_FAILURE_RE = re.compile(
+    r"traceback \(most recent call last\)|"
+    r"error:\s+cannot find module|module_not_found|modulenotfounderror|"
+    r"command not found|no such file or directory",
+    re.IGNORECASE,
+)
+
+
+def _masked_shell_failure(output: str) -> bool:
+    """True when shell control flow hid an obvious failure behind exit 0."""
+    return bool(output and _MASKED_FAILURE_RE.search(output))
+
 _APP_SOURCE_SUFFIXES = (
     ".py", ".js", ".jsx", ".ts", ".tsx", ".html", ".css", ".vue", ".svelte",
     ".rs", ".go", ".java", ".kt", ".swift", ".rb", ".php", ".dart",
@@ -686,8 +698,10 @@ _GUI_PATTERNS = [
     "php -S",
 ]
 
-# Detect explicit shell backgrounding: lone `&` (not `&&`)
-_BG_RE = re.compile(r"(?<!&)&(?!&)")
+# Detect explicit shell backgrounding: lone `&` (not `&&`, `2>&1`, or
+# descriptor duplication such as `<&3`). The old expression matched the `&`
+# in `2>&1`, detaching ordinary build/typecheck commands.
+_BG_RE = re.compile(r"(?<![&<>])&(?!&)")
 
 
 def _normalize_repo_root_variants(cmd: str, repo: str) -> str:
@@ -1089,6 +1103,15 @@ def execute(ctx: ToolContext, args: dict) -> str:
             _dh = _dependency_error_hint(output)
             if _dh:
                 output = _dh + "\n\n" + output
+        elif _masked_shell_failure(output):
+            # `failing-command || echo fallback` returns zero even though the
+            # output contains a real stack trace/missing dependency. Mark it as
+            # failed so tool facts, recovery, and the UI cannot show a green ✓.
+            output = (
+                "[exit code 1]\n"
+                "A shell fallback masked the failing command's exit status.\n"
+                + output
+            )
         # AirPlay-collision detector: if the model curls localhost:5000
         # or :7000, those are squatted by macOS AirPlay Receiver /
         # AirTunes — bare `curl -s` sees a 200 with empty body and

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/tui/screens/chat.py

@@ -691,7 +691,7 @@ from ..widgets.chat_log import ChatLog
 from ...autonomy import AutonomyLevel, apply_autonomy_to_permissions, get_policy
 
 _SLASH_COMMANDS = [
-    ("/permissions", "Toggle ask/auto-approve for commands"),
+    ("/permissions", "Toggle command approvals on/off"),
     ("/status", "Show runtime: server health, current model, perf config"),
     ("/restart", "Restart the model server (use when /status shows 'unreachable')"),
     ("/mcp", "List or reload MCP servers from ~/.localcode/mcp.json"),
@@ -1707,7 +1707,8 @@ class ChatScreen(Screen):
         left = RichText.from_markup(
             f"[{C.primary}]LocalCode[/]"
             + (f" · [dim]{cwd_seg}[/]" if cwd_seg else "")
-            + f" · {server_label} · context: {pct_remaining}% free · "
+            + f" · {server_label} · permissions: {self._permissions_label()} · "
+            f"context: {pct_remaining}% free · "
             f"thinking: {thinking_label}"
             + (f" · task: {task_stage}" if task_stage else "")
             + f" · model: {short_model}"
@@ -1742,6 +1743,12 @@ class ChatScreen(Screen):
                 left.truncate(bar_width, overflow="ellipsis")
             bar.update(left)
 
+    def _permissions_label(self) -> str:
+        engine = self.tui.engine
+        if engine is not None and engine._autonomy == AutonomyLevel.FULL_AUTO:
+            return "off"
+        return "on"
+
     def _update_queue(self) -> None:
         q = self.query_one("#queue-line", Static)
         if self._pending_messages:
@@ -2206,12 +2213,17 @@ class ChatScreen(Screen):
             if app:
                 if app._autonomy == AutonomyLevel.FULL_AUTO:
                     app._autonomy = AutonomyLevel.AUTO_EDIT
+                    # Turning approvals back on must revoke broad grants cached
+                    # while the session was prompt-free.
+                    app._session_allow.clear()
+                    app.perms._session_approved.clear()
                     apply_autonomy_to_permissions(app.perms, get_policy(app._autonomy))
-                    log.append_info("Permissions ON — will ask before running commands")
+                    log.append_info("Permissions ON — asks only for high-impact commands")
                 else:
                     app._autonomy = AutonomyLevel.FULL_AUTO
                     apply_autonomy_to_permissions(app.perms, get_policy(app._autonomy))
-                    log.append_info("Permissions OFF — full auto, no questions asked")
+                    log.append_info("Permissions OFF — no approval prompts")
+                self._update_status()
         elif text == "/search":
             self.action_toggle_search()
         elif text == "/model" or text.startswith("/model "):

{localcode-0.3.21 → localcode-0.3.22}/src/localcode/tui/widgets/chat_log.py

@@ -1697,17 +1697,25 @@ class ChatLog(RichLog):
                 self._track_lines()
 
     def _render_approval(self, tool_name: str, command: str) -> None:
-        # Collapse multi-line commands (heredocs etc) to single line.
-        # Don't pre-truncate — the no_wrap+ellipsis widget handles overflow at
-        # the actual terminal width.
-        cmd_oneline = command.replace("\n", " ↵ ").strip()
-        line = Text(no_wrap=True, overflow="ellipsis")
+        line = Text()
         line.append("  Allow ", style=f"bold {C.warning}")
         line.append(f"{tool_name}", style=f"bold {C.warning}")
-        line.append("? ", style=f"bold {C.warning}")
-        line.append(cmd_oneline, style="dim")
+        line.append("?", style=f"bold {C.warning}")
         self.write(line)
         self._track_lines()
+        # Show the complete command. Wrap rather than hiding pipes, redirects,
+        # heredocs, or secondary segments behind an ellipsis.
+        for raw_line in command.strip().splitlines() or [""]:
+            preview = Text("    ")
+            preview.append(raw_line, style="white")
+            self.write(preview)
+            self._track_lines()
+        effects = _approval_effects(tool_name, command)
+        if effects:
+            impact = Text("    affects: ", style="dim")
+            impact.append(" · ".join(effects), style=f"bold {C.warning}")
+            self.write(impact)
+            self._track_lines()
         # First token is what the "always allow" option will whitelist
         # for the rest of the session — e.g. "git", "pip", "python".
         first_token = (command.strip().split() or [""])[0][:20] or tool_name
@@ -1730,6 +1738,24 @@ class ChatLog(RichLog):
         self._track_lines()
 
 
+def _approval_effects(tool_name: str, detail: str) -> list[str]:
+    """Human preview only; the safety decision remains in the policy layer."""
+    lower = detail.lower()
+    effects: list[str] = []
+    if tool_name in {"write_file", "append_file", "edit_file", "multi_edit"}:
+        effects.append("files")
+    if tool_name == "bash":
+        if any(x in lower for x in ("curl ", "wget ", "npm install", "pip install", "brew install", "git push")):
+            effects.append("network")
+        if any(x in lower for x in (">", "tee ", "rm ", "mv ", "cp ", "mkdir ", " install")):
+            effects.append("files")
+        if any(x in lower for x in ("kill ", "pkill ", "killall ", "launchctl ")):
+            effects.append("processes")
+        if any(x in detail for x in ("&&", "||", ";", "|", "$(", "`")):
+            effects.append("compound command")
+    return effects
+
+
 def _is_diff(text: str) -> bool:
     lines = text.strip().splitlines()[:10]
     diff_markers = sum(1 for l in lines if l.startswith(("+", "-", "@@", "diff ")))

{localcode-0.3.21 → localcode-0.3.22/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.21 → localcode-0.3.22}/tests/test_agent_event_regressions.py

@@ -797,6 +797,27 @@ def test_bash_does_not_background_probe_commands_that_mention_app_py() -> None:
     assert _looks_like_detached_server_command("cd demo && python3 app.py")
 
 
+def test_bash_redirection_is_not_explicit_backgrounding() -> None:
+    from localcode.tools.bash import _BG_RE, _masked_shell_failure
+
+    assert _BG_RE.search("npx tsc --noEmit 2>&1 | head -60") is None
+    assert _BG_RE.search("command 3<&0") is None
+    assert _BG_RE.search("npm run dev &") is not None
+    assert _masked_shell_failure("Error: Cannot find module 'canvas'\nMODULE_NOT_FOUND")
+    assert not _masked_shell_failure("vite build completed successfully")
+
+
+def test_successful_build_mutation_leaves_reasoning_heavy_scaffolding() -> None:
+    from localcode.thinking import next_task_stage_after_tool, should_use_thinking
+
+    assert should_use_thinking("", "auto", goal_type="build_app", task_stage="scaffolding")
+    stage = next_task_stage_after_tool("scaffolding", "write_file", succeeded=True)
+    assert stage == "running"
+    assert not should_use_thinking("", "auto", goal_type="build_app", task_stage=stage)
+    assert next_task_stage_after_tool("scaffolding", "read_file", succeeded=True) == "scaffolding"
+    assert next_task_stage_after_tool("scaffolding", "bash", succeeded=False) == "scaffolding"
+
+
 def test_bash_server_launch_surfaces_startup_crash(tmp_path: Path, monkeypatch) -> None:
     # A server command that exits during startup must report the FAILURE +
     # the captured error (so the agent fixes it), NOT a blind "it's running".

{localcode-0.3.21 → localcode-0.3.22}/tests/test_context.py

@@ -212,10 +212,20 @@ def test_window_aware_compaction_scales_with_ram():
     small_b, small_k = W(int(16384 * 3.5))      # 16K window
     big_b, big_k = W(int(131072 * 3.5))         # 128K window
     assert small_b == 36_000 and small_k == 4   # small stays aggressive
-    assert big_b > 200_000 and big_k >= 16      # big keeps much more
+    # A large KV window is available for hard tasks, but live Qwen traces show
+    # that replaying >200KB every agent round pushes TTFT past one minute.
+    assert big_b == 48_000 and big_k <= 8
     assert big_b > small_b and big_k > small_k  # strictly scales up
 
 
+def test_approval_effects_surface_hidden_command_impact():
+    from localcode.tui.widgets.chat_log import _approval_effects
+
+    effects = _approval_effects("bash", "git status && npm install x | tail -5")
+    assert "network" in effects
+    assert "compound command" in effects
+
+
 def test_progress_ledger_dedups_and_shows_outcomes():
     from localcode.agent.context import build_progress_ledger
     led = build_progress_ledger(

{localcode-0.3.21 → localcode-0.3.22}/tests/test_model_config.py

@@ -24,6 +24,11 @@ def test_ram_ctx_ceiling_delegates():
         assert GW._ram_ctx_ceiling(ram) == mc.ram_ctx_ceiling(ram)
 
 
+def test_high_ram_default_keeps_checkpointed_128k_path():
+    assert mc.ram_ctx_ceiling(96) == 131072
+    assert mc.ram_ctx_ceiling(128) == 131072
+
+
 def test_cohere_ctx_ceiling_delegates():
     from localcode.runtime import LocalCodeRuntimeGateway as GW
     for ram in (8, 16, 24, 32, 36, 48, 64, 96, 128, 192):

{localcode-0.3.21 → localcode-0.3.22}/tests/test_runtime.py

@@ -312,11 +312,11 @@ class TestTargetNumCtx:
         # A capable machine should get a large context on the balanced/default
         # preset, not the flat max_context_chars//4. (Regression: 128 GB Macs
         # were stuck at ~50K, starving long agentic sessions into re-read loops.)
-        # 96 GB+ now unlocks 256K since every catalog model trains to >=256K;
-        # the fake model path here is unreadable so _model_max_ctx doesn't clamp.
+        # High-RAM machines default to the checkpointed 128K fast path. 256K
+        # remains available only through an explicit experimental override.
         gw = self._make_gw(max_context_chars=200000, quant_preset="balanced")
         gw._system_ram_gb = lambda: 128  # type: ignore[assignment]
-        assert gw._target_num_ctx() == 262144
+        assert gw._target_num_ctx() == 131072
 
     def test_balanced_preset(self) -> None:
         gw = self._make_gw(max_context_chars=40000, quant_preset="balanced")