localcode 0.3.25__tar.gz → 0.3.27__tar.gz

{localcode-0.3.25/src/localcode.egg-info → localcode-0.3.27}/PKG-INFO

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

{localcode-0.3.25 → localcode-0.3.27}/pyproject.toml

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

{localcode-0.3.25 → localcode-0.3.27}/src/localcode/agent/goal.py

@@ -153,10 +153,34 @@ class GoalState:
         return data
 
 
+# NOTE ON THIS CLASSIFIER: goal_type is a WEAK hint, not the authority on
+# whether a task is finished. Completion is governed by the model's own todo
+# list (see the open-todo gate in agent/loop.py) — never by these regexes or by
+# a detected server port. History: "Build me an Anki clone … so I can launch it
+# like a native app" used to match the run_or_launch pattern on the phrase
+# "launch it", which then let a freshly-opened dev-server port count as "app
+# built" at ~10% of the work. The lasting fix is that a port no longer ends a
+# turn while todos are open; the widening below just keeps genuine builds out of
+# run_or_launch in the first place. Misclassifying an edit as build_app is
+# cheap (its criteria are just "code exists + verification passes"); the
+# dangerous direction is a build leaking into run_or_launch, so bias toward
+# build_app and require run_or_launch to be an *unambiguous* run request.
+_BUILD_VERB = r"(?:build|create|make|scaffold|implement|develop|generate|write|design|code)"
+_APP_NOUN = (
+    r"(?:app|application|web ?app|website|web ?page|site|dashboard|api|service|"
+    r"project|clone|game|tool|extension|widget|spa|pwa|frontend|back ?end|"
+    r"platform|bot|cli|ui|component|library|package|script|program|"
+    r"tracker|editor|viewer|generator)"
+)
+
+
 def infer_goal_state(user_text: str) -> GoalState:
     text = (user_text or "").strip()
     lower = text.lower()
-    if re.search(r"\b(build|create|make|scaffold|implement)\b.{0,40}\b(app|application|website|dashboard|api|service|project)\b", lower):
+    # build verb + app-ish noun anywhere in the request → it's a build. No tight
+    # proximity window (the old `.{0,40}` cap is exactly why "Build me a … web
+    # app" fell through — the noun sat 48 chars past the verb).
+    if re.search(rf"\b{_BUILD_VERB}\b", lower) and re.search(rf"\b{_APP_NOUN}\b", lower):
         goal_type, task_kind = "build_app", "new_app"
         criteria = ("Requested implementation exists on disk", "Relevant build or tests pass", "Runtime behavior is verified when applicable")
     elif re.search(r"\b(run|launch|start|serve|open)\b.{0,24}\b(app|server|site|project|it)\b", lower):

{localcode-0.3.25 → localcode-0.3.27}/src/localcode/agent/loop.py

@@ -49,6 +49,7 @@ from .constants import (
 )
 from .goal import GoalState, infer_goal_state
 from .context import (
+    _msg_bytes,
     _prepare_model_messages,
     _summarize_args,
     _truncate_result,
@@ -110,9 +111,7 @@ from .hooks import (
 )
 from .app_tasks import (
     extract_port,
-    format_run_or_launch_summary,
     ground_run_or_launch_text,
-    has_launch_signal,
     has_runtime_verification_signal,
     is_focused_blocking_question,
     looks_like_partial_handoff,
@@ -787,11 +786,6 @@ def run_agent_loop(
             user_text=user_text,
         )
         try:
-            # Compact older tool results so every round's prompt stays small
-            # enough for hybrid-memory models (Qwen 3.6) to re-evaluate fast.
-            # Pass the model's context window (RAM-derived) so compaction is
-            # window-aware: a big machine keeps far more history instead of
-            # crushing it to a fixed 36 KB (which made the model lose track).
             _ctx_chars = None
             try:
                 _nctx = app.engine._target_num_ctx()
@@ -799,11 +793,45 @@ def run_agent_loop(
                     _ctx_chars = int(_nctx * 3.5)  # tokens → ~chars
             except Exception:
                 _ctx_chars = None
-            model_messages = hook_before_model(
-                _prepare_model_messages(messages, ctx_window_chars=_ctx_chars,
-                                        observed_ttft_ms=_observed_ttft_ms),
-                _hook_state,
-            )
+            # ── Append-only transcript between DISCRETE compactions ──
+            # (codex/opencode/pi/claude-code pattern). The old behavior ran the
+            # full shrink pass EVERY round with a moving age boundary: each
+            # round another message crossed "old" and got stubbed, changing
+            # bytes near the START of the prompt, so llama.cpp's prefix cache
+            # missed and the ENTIRE conversation re-prefilled every round. On a
+            # measured 55-min build that was 77% of wall-clock (TTFT grew from
+            # 3 s at round 3 to 95 s at round 53 — pure re-prefill). All four
+            # reference harnesses append-only within a turn and compact as a
+            # discrete event; on a LOCAL model, where prefill is the dominant
+            # cost, the prefix cache is the single biggest speed lever.
+            #
+            # Trigger is dynamic (window-derived, RAM-scaled upstream): compact
+            # when the serialized transcript passes ~55% of the context window
+            # (headroom for the trailing ephemeral block + generation). The
+            # compaction is DURABLE (messages[:] = shrunk) so subsequent rounds
+            # are again byte-stable prefixes — one cache miss per compaction,
+            # zero per round.
+            _trigger_bytes = int((_ctx_chars or 250_000) * 0.55)
+            if _msg_bytes(messages) > _trigger_bytes:
+                # Mid-turn nudges are per-round steering the model has already
+                # consumed; their stored INDICES are only valid on the
+                # uncompacted list, so strip them first and reset bookkeeping.
+                if _ephemeral_nudge_indices:
+                    strip_ephemeral_nudges(messages, _ephemeral_nudge_indices)
+                    _ephemeral_nudge_indices.clear()
+                messages[:] = _prepare_model_messages(
+                    messages, ctx_window_chars=_ctx_chars,
+                    observed_ttft_ms=_observed_ttft_ms,
+                )
+                try:
+                    from ..events import emit as _emit_compact
+                    _emit_compact("discrete_compaction", turn_id=_turn_id,
+                                  round_idx=round_num,
+                                  bytes_after=_msg_bytes(messages),
+                                  trigger_bytes=_trigger_bytes)
+                except Exception:
+                    pass
+            model_messages = hook_before_model(list(messages), _hook_state)
             # Inject a window-scaled progress ledger (Codex-style tool-state
             # awareness): the model always sees what it has already done, so it
             # stops re-reading files / restarting from scratch. Built from
@@ -2152,16 +2180,18 @@ def run_agent_loop(
                 full_response.append(_verified_launch_summary)
             break
 
-        if _goal_state.goal_type == "run_or_launch":
-            _task_port = int(getattr(_task_state, "active_port", 0) or 0)
-            _launched = has_launch_signal(bash_history)
-            _verified = has_runtime_verification_signal(bash_history)
-            if _task_port and (_launched or _verified):
-                grounded_access = format_run_or_launch_summary(_task_port, _verified)
-                _render_markdown(grounded_access, app.console if hasattr(app, 'console') else None)
-                full_response.append(grounded_access)
-                _loop_exit_reason = "verified_run_or_launch" if _verified else "run_or_launch_ready"
-                break
+        # NOTE: there used to be a "run_or_launch + a port opened ⇒ the task is
+        # done" break here. It was an anti-pattern — none of the reference
+        # harnesses (codex, opencode, pi, claude-code) infer completion from a
+        # detected port, a launched process, or output patterns. All of them end
+        # a turn on ONE structural signal: the model returned a message with no
+        # tool calls. That block let `npm run dev` opening a socket count as a
+        # finished app at ~10% of the work. Removed for good. Completion is now
+        # model-driven (the no-tool-calls exit below), backstopped only by the
+        # open-todo gate for the small local models that stop early — the harness
+        # nudges AGAINST stopping, it never invents a "done" signal. If a run
+        # task launches a server, the model reports the URL in its own reply,
+        # exactly like the reference tools do.
 
         # ── Cross-round repeated-call nudge ──
         # The dominant waste in the logs: the model calls the SAME (tool, args)

{localcode-0.3.25 → localcode-0.3.27}/src/localcode/agent/prompts.py

@@ -39,30 +39,36 @@ _STACK_MARKERS: tuple[tuple[str, str], ...] = (
 
 
 SYSTEM_PROMPT = """\
-You are LocalCode, a coding agent running locally on the user's machine with full filesystem access through your tools.
-
-Top rules (most important first):
-1. ACT, DON'T NARRATE. If you say "let me read/fix/write X", the tool call that does it MUST come next, in the same turn. Never end a turn on a statement of intent. At most one short sentence of preamble per tool call.
-2. FINISH THE JOB. Cover every requirement the user named. Write complete, runnable code — no TODOs, stubs, placeholders, or "should I do X next?". If a piece is too big for one call, split it across calls; never drop it.
-3. MATCH SCOPE & BE TERSE. Answer plain questions plainly and briefly — a sentence or two, no preamble ("Here is…") or postamble ("Let me know if…"); build only what was asked. Terseness is about your PROSE, not the code — write complete code, few words around it.
-4. DON'T REPEAT WORK. Don't re-read a file or re-run a command you already did — the result is still above. After a tool result, continue from where you left off; don't restate the plan.
-5. DON'T INVENT. If you don't recognize a term, library, or command, say so — never guess a plausible meaning. Search the web before asserting facts; if results are empty, say that.
-
-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. Keep source in the language's conventional directory (not dumped in the repo root).
-- Don't invent dependencies: before importing a library confirm it's in the project's manifest (package.json / requirements.txt / Cargo.toml / go.mod) or a neighboring file; when installing, don't pin a guessed version — let the package manager's resolver pick a real one.
-- Never assume a library's API. Before using a package's exports, types, or signatures, verify them — read its installed source, check how neighboring files use it, or web_fetch its docs. Don't guess names. Implementing from a spec or reference? Work from the real source (web_fetch it), not memory.
-
-Runtime facts:
-- bash returns an exit code; non-zero = failure. Background long-running commands (`cmd &`) so bash returns.
-- Bulky tool output from older turns is redacted to save context — re-read the file from disk if you need it again.
-
-If the request is ambiguous in a way that changes your approach (stack, interface, scope), ask ONE short question first.
+You are LocalCode, a coding agent running locally on the user's machine with full filesystem access through your tools. You run on a small, quantized model on the user's own hardware — so every token you spend costs the user real latency. Be fast by being decisive, not by cutting the work short.
+
+FINISH THE WHOLE TASK (most important):
+- 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.
+- For any task with 2+ steps, call todo_write FIRST to lay out every step. Keep exactly ONE item in_progress; mark each done the instant it's finished. Your todo list is your contract: if any item is still pending or in_progress, you are NOT done — take the next action, don't stop to ask "should I continue?".
+- Only stop for one of two reasons: (a) every requirement is met and verified, or (b) you have ONE specific blocking question you cannot answer yourself. Nothing else ends your turn.
+- When you say "next I'll do X", the tool call that does X MUST be your very next action. Never end a turn on a statement of intent.
+
+WORK FAST AND CLEAN:
+- ACT, DON'T NARRATE. At most one short sentence before a tool call. No "Here is…" preambles, no "Let me know if…" postambles. Terse PROSE — but complete CODE.
+- Don't repeat work. Never re-read a file or re-run a command whose result is already above. Continue from where you left off.
+- Write complete, runnable code — no TODOs, stubs, placeholders, or "you could add…". If a piece is too big for one call, split it across calls; never drop it.
+- On a tool error, read it, fix the specific cause, and retry with a real change — don't repeat the same failing call, and don't give up after one failure.
+
+TOOLS & FILES:
+- Use read_file / write_file / edit_file / list_files for files — NOT bash (`cat`, `ls`, `>`). bash is only for running commands (npm, git, build, test).
+- edit_file on an existing file: anchor `old_string` on 2–4 adjacent lines (whitespace-tolerant; the read_file line-number prefix is stripped for you). write_file to create or fully rewrite.
+- Use real, repo-relative paths. Keep source in the language's conventional directory, not dumped in the repo root. Match the project's existing conventions and language.
+- Background long-running commands (`cmd &`) so bash returns. Non-zero exit = failure — fix it, don't move on. Bulky tool output from older turns is redacted to save context — re-read from disk if you need it again.
+
+DON'T GUESS:
+- Don't invent dependencies: before importing a library, confirm it's in the project's manifest (package.json / requirements.txt / Cargo.toml / go.mod) or a neighboring file. When installing, don't pin a guessed version — let the resolver pick.
+- Never assume a library's API. Verify exports/types/signatures by reading its installed source, checking neighboring usage, or web_fetch'ing its docs. Implementing from a spec or reference? Work from the real source, not memory.
+- If you don't recognize a term, library, or command, say so — search the web before asserting. If results are empty, say that.
+
+VERIFY BEFORE YOU CLAIM DONE:
+- After building something runnable, actually run it (build, tests, or a real probe) and read the output. "It should work" is not verification.
+- Report outcomes faithfully: if a build/test fails, say so with the output; if you skipped a step, say that.
+
+If the request is ambiguous in a way that changes your approach (stack, interface, scope), ask ONE short question first — otherwise pick the sensible default and proceed.
 
 Working directory: {cwd}
 {network_status}{reasoning_rules}{project_instructions}{skills_block}"""

{localcode-0.3.25 → localcode-0.3.27}/src/localcode/app.py

@@ -245,6 +245,50 @@ class LocalCodeApp:
         except Exception:
             pass
 
+    def _anchor_home_build_root(self, slug: str) -> bool:
+        """Give a $HOME-launched new-app build a real project directory.
+
+        When localcode is started from $HOME with no project root, there is no
+        directory to anchor against, so `repo_root` stays at $HOME. The model
+        then scatters files into some arbitrary deep subdir while the harness —
+        launcher, verification, context, RAG — stays pinned at $HOME and never
+        finds the app it "built". (This is the second half of the Anki-build
+        stop: the build ran with cwd=$HOME.) Fix: anchor the build to a clean
+        canonical dir, $HOME/<slug>, created up-front BEFORE the turn's first
+        tool call, and re-point the path-critical components at it. Everything
+        else (launcher, verify, context, snapshots) reads `self.repo_root` live,
+        so re-pointing here is enough.
+
+        Guarded by the caller to the degenerate $HOME + build_app/new_app case,
+        so a normal in-project launch is never re-pinned. Idempotent — re-running
+        for the same slug re-adopts the existing dir (resume-friendly). Returns
+        True when the anchored dir already had files (a resume).
+        """
+        clean = (slug or "").strip().strip("/")
+        if not clean:
+            return False
+        new_root = (self.repo_root / clean).resolve()
+        # Never escape or re-adopt $HOME; never walk upward.
+        if _is_home_or_shallower(new_root) or self.repo_root.resolve() not in new_root.parents:
+            return False
+        try:
+            new_root.mkdir(parents=True, exist_ok=True)
+            had_files = any(new_root.iterdir())
+        except OSError:
+            return False
+        self.log.info("Anchoring $HOME build to canonical project dir %s", new_root)
+        self.repo_root = new_root
+        self.repo_root_is_home = False
+        # Re-point ONLY the components whose path resolution / write-containment
+        # must follow the new root. The turn_tracker keeps its $HOME baseline
+        # (already snapshotted this turn) — its diff is cosmetic.
+        try:
+            self.toolkit.repo_root = new_root
+            self.toolkit.changes.repo_root = new_root
+        except Exception:
+            pass
+        return had_files
+
     def _record_exec_event(self, event_type: str, payload: dict) -> None:
         detail = payload.get("stage") or payload.get("name") or payload.get("message") or payload.get("chunk") or event_type
         detail_text = str(detail).replace("\n", " ")[:200]
@@ -482,11 +526,25 @@ class LocalCodeApp:
                 goal_summary=goal_state.goal_summary,
                 success_criteria=merged_criteria,
             )
+        # $HOME-launched new-app build: anchor to a clean canonical project dir
+        # BEFORE any tool call, so the model builds in one place and the harness
+        # (launcher/verify/context) follows it. Only fires in the degenerate
+        # $HOME case; a normal in-project launch is untouched.
+        _anchored_resume = False
+        if (
+            self.repo_root_is_home
+            and goal_state.goal_type == "build_app"
+            and goal_state.task_kind == "new_app"
+        ):
+            _anchored_resume = self._anchor_home_build_root(goal_state.task_slug)
         if (
             not _continuing_task
             and goal_state.goal_type == "build_app"
             and goal_state.task_kind == "new_app"
-            and _canonical_project_dir_has_files(self.repo_root, goal_state.task_slug)
+            and (
+                _anchored_resume
+                or _canonical_project_dir_has_files(self.repo_root, goal_state.task_slug)
+            )
         ):
             task_state.current_stage = "scaffolding"
             task_state.goal_summary = (

{localcode-0.3.25 → localcode-0.3.27}/src/localcode/runtime.py

@@ -2055,6 +2055,15 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             "messages": messages,
             "temperature": opts["temperature"],
             "chat_template_kwargs": {"enable_thinking": think},
+            # Explicit KV prefix-cache opt-in. Recent llama.cpp builds default
+            # this to true for /v1/chat/completions, but TurboQuant is a fork —
+            # never rely on the default for the single biggest local-speed
+            # lever. The agent loop keeps the transcript append-only between
+            # discrete compactions precisely so this cache HITS every round
+            # (see loop.py "Append-only transcript"): prefill dominates local
+            # inference, and a hit turns a 40K-token re-read into just the
+            # few hundred new tokens.
+            "cache_prompt": True,
         }
         # Single-knob anti-rephrase: `repeat_penalty=1.05` only.
         # Added 2026-04-29 after stripping the full sampler stack

{localcode-0.3.25 → localcode-0.3.27/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.25 → localcode-0.3.27}/src/localcode.egg-info/SOURCES.txt

@@ -948,6 +948,7 @@ tests/test_embeddings_retrieval.py
 tests/test_evidence_and_lifecycle_hooks.py
 tests/test_execution_policies.py
 tests/test_fresh_install.py
+tests/test_home_build_anchor.py
 tests/test_kv_cap.py
 tests/test_loop_recovery_ladder.py
 tests/test_model_config.py

{localcode-0.3.25 → localcode-0.3.27}/tests/test_agent_state_machine.py

@@ -10,6 +10,24 @@ def test_conservative_goal_classifier_activates_harness_lifecycles() -> None:
     assert infer_goal_state("organize these notes").goal_type == "general_task"
 
 
+def test_build_verb_wins_over_incidental_run_words() -> None:
+    # A build request that also *describes* the finished artifact with run/launch
+    # words ("so I can launch it", "then start it") must stay build_app. The old
+    # classifier let the trailing "launch it"/"start it" phrase flip the whole
+    # task to run_or_launch, after which a freshly-opened dev-server port counted
+    # as a finished build. This pins the class of bug, not one prompt.
+    for text in (
+        "build a web app so I can launch it like a native app",
+        "create an api and then start the server to test it",
+        "make a game I can run in the browser",
+        "implement a dashboard, then open it to check the charts",
+    ):
+        assert infer_goal_state(text).goal_type == "build_app", text
+    # Genuine run/launch requests (no build verb) must stay run_or_launch.
+    for text in ("launch it", "run the app", "start the server", "open the project"):
+        assert infer_goal_state(text).goal_type == "run_or_launch", text
+
+
 def test_task_lifecycle_requires_verification_before_completion() -> None:
     assert transition("planning", TaskEvent.MUTATION_SUCCEEDED).after == TaskStage.IMPLEMENT
     assert transition("implement", TaskEvent.REQUIREMENTS_SATISFIED).after == TaskStage.IMPLEMENT

localcode-0.3.27/tests/test_home_build_anchor.py

@@ -0,0 +1,57 @@
+"""Regression: a $HOME-launched new-app build must anchor to a real project dir.
+
+Half of the Anki-build stop was that the build ran with repo_root=$HOME — the
+model scattered files while launcher/verify/context stayed pinned at $HOME.
+`_anchor_home_build_root` re-pins to $HOME/<slug> before the first tool call.
+Tested in isolation with a lightweight stub so we don't spin up a real model.
+"""
+import logging
+import types
+from pathlib import Path
+
+from localcode.app import LocalCodeApp
+
+
+def _stub(home: Path):
+    changes = types.SimpleNamespace(repo_root=home)
+    toolkit = types.SimpleNamespace(repo_root=home, changes=changes)
+    return types.SimpleNamespace(
+        repo_root=home,
+        repo_root_is_home=True,
+        log=logging.getLogger("test"),
+        toolkit=toolkit,
+    )
+
+
+def test_anchor_creates_and_repins_to_canonical_dir(tmp_path: Path) -> None:
+    fake = _stub(tmp_path)
+    had_files = LocalCodeApp._anchor_home_build_root(fake, "local-first-anki-clone")
+    expected = (tmp_path / "local-first-anki-clone").resolve()
+    assert had_files is False
+    assert expected.is_dir()
+    # repo_root and the path-critical components all follow the new root.
+    assert fake.repo_root == expected
+    assert fake.repo_root_is_home is False
+    assert fake.toolkit.repo_root == expected
+    assert fake.toolkit.changes.repo_root == expected
+
+
+def test_anchor_is_idempotent_and_flags_resume(tmp_path: Path) -> None:
+    # An existing canonical dir with files is a resume, not a fresh build.
+    proj = tmp_path / "my-app"
+    proj.mkdir()
+    (proj / "package.json").write_text("{}\n")
+    fake = _stub(tmp_path)
+    assert LocalCodeApp._anchor_home_build_root(fake, "my-app") is True
+    assert fake.repo_root == proj.resolve()
+
+
+def test_anchor_rejects_empty_slug_and_traversal(tmp_path: Path) -> None:
+    fake = _stub(tmp_path)
+    assert LocalCodeApp._anchor_home_build_root(fake, "") is False
+    assert fake.repo_root == tmp_path  # unchanged
+    assert fake.repo_root_is_home is True
+    # A slug that tries to climb out of $HOME must be refused.
+    fake2 = _stub(tmp_path)
+    LocalCodeApp._anchor_home_build_root(fake2, "..")
+    assert fake2.repo_root == tmp_path

{localcode-0.3.25 → localcode-0.3.27}/tests/test_prompt_language_steering.py

@@ -14,11 +14,10 @@ from localcode.agent.prompts import SYSTEM_PROMPT, project_stack_line
 
 def test_system_prompt_has_language_matching_rule() -> None:
     text = SYSTEM_PROMPT.lower()
-    # The prompt must tell the model to write code valid for the file's actual
-    # language and match the project's conventions (worded concisely — no long
-    # per-language example list, which bloats the prompt for a small model).
-    assert "valid for the file's real language" in text
-    assert "match the project's existing conventions" in text
+    # The prompt must tell the model to match the project's actual language and
+    # conventions (worded concisely — no long per-language example list, which
+    # bloats the prompt for a small model).
+    assert "match the project's existing conventions and language" in text
     assert "conventions" in text