pi-tuck 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 All notable changes to pi-tuck. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
 [Semantic Versioning](https://semver.org/).
 
+## [1.0.6] - 2026-11-01
+
+### Changed
+
+- Semantic recall embeds on the GPU (Metal) on Apple silicon. The pinned llama.cpp build already includes Metal, but pi-tuck started it on the
+  CPU only. On an Apple M5 under heavy load (load average 44-76), a batch of 8 passages took a median 38.6 s on the CPU and 0.69 s on Metal,
+  56 times faster, with nearly the same vectors (97.9% top-10 overlap with the CPU's). Indexing therefore finishes, and `tuck_search` ranks
+  by meaning instead of falling back to keywords. Where Metal cannot start (a VM, CI, no GPU), the same server starts on the CPU. The
+  installed runtime is kept; each session's index is rebuilt once.
+
+### Fixed
+
+- Semantic recall no longer switches itself off on a busy machine. The worker's start (Python, the runtime check, the model load) now has
+  its own deadline instead of the 60 s per-call limit, and an embed call's deadline grows with the number of texts it carries, so a slow
+  machine slows indexing down instead of making it fail. A worker that still fails is retried in the same session and recovers once the
+  machine is free.
+
+## [1.0.5] - 2026-10-31
+
+### Fixed
+
+- One oversize tool result no longer leaves a session unusable. A fresh tool round larger than the input room is still refused, since it must
+  reach the model whole; but after that run ended (its reply aborted, or hidden by Pi when it recovered from an overflow), the result was
+  still treated as not yet seen and kept whole, so
+  every later prompt was refused, and a manual `/compact` refused too. Once the session moves on (a new prompt, a manual `/compact`, or a
+  run a custom message starts) it is now ordinary history, and the next cut summarizes it; `tuck_recall` still reads it in full.
+- A cut that is needed when Pi has nothing to compact (no history older than its `keepRecentTokens` since the last cut) now refuses that
+  request only. Before, Pi's "Nothing to compact" or "Already compacted" stayed as a fault, and every later prompt of the session failed on it.
+- No failure outlives its attempt: after any refusal or fault, the next prompt, a manual cut or the end of the run plans afresh from the
+  session as it is. Before, a fault other than a refusal stayed until the session restarted. The one exception is a cut pi-tuck supplied that
+  Pi then failed to write: the session may hold a cut its file lacks, so that fault still stays until the session restarts.
+- A refusal no longer turns semantic recall off. Background indexing read any compaction failure as the host revoking access, so it disabled
+  semantic recall and deleted its index for the rest of the session.
+
 ## [1.0.4] - 2026-10-31
 
 ### Changed

package/README.md

@@ -1,6 +1,6 @@
 # pi-tuck
 
-**Compaction for [Pi](https://pi.dev) with no model call, and a history the agent can search by keyword or by meaning, all on your machine.** A cut takes about a tenth of a second. It costs no tokens. The same session always gives the same summary. And nothing is lost: the agent can read back anything earlier, word for word, and on Apple silicon it can find it by meaning.
+**Compaction for [Pi](https://pi.dev) with no model call, and a history the agent can search by keyword or by meaning, all on your machine.** In our live run, a cut took a median 0.09 s. It costs no tokens. The same session always gives the same summary. And nothing is lost: the agent can read back anything earlier, word for word, and on Apple silicon it can find it by meaning.
 
 ```sh
 pi install npm:pi-tuck
@@ -8,22 +8,23 @@ pi install npm:pi-tuck
 
 ## pi-tuck against Pi's built-in compaction
 
-Pi's built-in compaction asks a model to write a summary. pi-tuck builds the summary from the session itself.
+Pi's built-in compaction asks a model to write a summary. pi-tuck builds the summary from the session itself. The two time and context rows compare pi-tuck 1.0.1 with Pi 1.4.0's built-in compaction, where a local model writes the summary. Each measured result in this README names the pi-tuck build or version it was measured on; the release you install may be newer.
 
-| | Pi's built-in | pi-tuck |
+| | Pi's built-in (local model writes the summary) | pi-tuck |
 |---|---|---|
 | Model call per cut | One, to a model you pay for or wait on | None |
 | Time per cut | **269 s** (median) | **0.09 s** (median) |
 | Context carried after a cut | 29,200 tokens | 27,800 tokens (about the same) |
-| Same session, same summary | No | Yes |
-| Can the agent get dropped detail back | No recall tool. The full history stays in the session file, but the agent has no tool made to search it | Yes. `tuck_recall` reads any original exactly |
+| Same session, same summary | Not guaranteed, since a model writes it | Yes |
+| Can the agent get dropped detail back | No recall tool in Pi 1.4.0. The full history stays in the session file, but the agent has no tool made to search it | Yes. `tuck_recall` reads any original exactly |
 | Search history by meaning | No | Yes, with `tuck_search`, on macOS with Apple silicon. It runs locally, and no text leaves your machine. Elsewhere it searches by keyword |
-| Can the summary invent history | Yes, a model wrote it | No, it holds only recorded text |
+| Can the summary invent history | It can, since a model writes it | No, it holds only recorded text |
 | What the summary leaves out | Whatever the model dropped | Tool output only; the agent reads it back exactly |
-| Billed input from cutting early (simulated) | | 10–18% less than cutting at the full room |
-| Answer quality against LLM compactors | | **Being measured. Not claimed yet.** |
+| Billed input at the default 60% cut point (simulated) | Not measured | 10–18% less than pi-tuck cutting at the full room. This is not a comparison with the built-in |
+| Answer quality against Pi's own compaction on a local model (`mac-studio/main`) | | **Being measured. Not claimed yet.** |
+| Answer quality against Pi's compaction prompts on a frontier model | | **Untested.** |
 
-The time and context rows are live runs on a local model with a 131k window: 27 cuts per arm over 5 chains, interim, pi-tuck 1.0.1. Every number comes from a file in this repository. Conditions, sample sizes and links are in [Benchmarks](#benchmarks). The last row is the one that matters most, and it is not finished: see [What is proven, and what is not](#what-is-proven-and-what-is-not).
+The time and context rows are live runs with a 131k window: 27 cuts per arm over 5 chains, interim. Every number comes from a file in this repository. Conditions, sample sizes and links are in [Benchmarks](#benchmarks). The last row is the one that matters most, and it is not finished: see [What is proven, and what is not](#what-is-proven-and-what-is-not).
 
 ## Ask your history
 
@@ -57,8 +58,8 @@ Then start a new Pi session. That is all. pi-tuck takes over Pi's compaction, bo
 
 - Needs Pi 1.1 or later (tested on 1.1.0 and 1.4.0), on macOS or Linux.
 - On macOS with Apple silicon, the first session also downloads a local search model in the background (about 390 MB, once). Until it is ready, search works by keyword. See [Semantic search](#semantic-search).
-- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.4`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.4`.
+- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.6`.
+- To pin a version, add it: `pi install npm:pi-tuck@1.0.6`.
 
 ## How it works
 
@@ -89,22 +90,22 @@ Both tools cost about 1,050 tokens of tool description per request.
 
 ## What is proven, and what is not
 
-**Measured so far:** a cut takes a fraction of a second, where a model-written summary takes minutes on a local model. A cut calls no model, so it costs no tokens. pi-tuck carries about as many tokens after a cut as the built-in does, not fewer. Cutting early saves billed input in simulation, and answers held in replay.
+**Measured so far:** in the live run, a pi-tuck cut took a median 0.09 s, where Pi's built-in compaction with a local model writing the summary took a median 269 s. A cut calls no model, so it costs no tokens. After a cut, pi-tuck carried about as many tokens as the built-in did, not fewer. In simulation, cutting at 60% of the room instead of 100% saved billed input for pi-tuck itself, and answers held in replay.
 
-**Not proven yet: that the summary is as good as a model-written one.** The claim is that pi-tuck compacts as well as the best LLM compactors, in far less time and at no cost. That claim has a pre-registered test. The test is running now. It was written down before any result came in, and a failed test will be reported as failed. When the result is final, it goes in [`benchmark/`](benchmark) and in this README. Until then, this README does not claim that pi-tuck is as good as, or better than, an LLM compactor.
+**Not proven yet: that the summary is as good as a model-written one.** The claim is that pi-tuck compacts as well as an LLM compactor, in far less time and at no cost. The comparator is Pi's own summarize prompts, run on a local model (`mac-studio/main`). The frontier comparison is untested: the model first named for it (`openai/gpt-6-astra`) was retired on 2026-10-31, and its recordings are a labelled partial view that feeds no test. A replacement, GPT-6.1 Terra, is pre-registered in [`benchmark/PREREG-TERRA.md`](benchmark/PREREG-TERRA.md). See [`benchmark/PINS.md`](benchmark/PINS.md). That claim has a pre-registered test. The test is running now. It was written down before any result came in, and a failed test will be reported as failed. When the result is final, it goes in [`benchmark/`](benchmark) and in this README. Until then, this README does not claim that pi-tuck is as good as, or better than, any LLM compactor.
 
 The test has three parts:
 
-1. **A live run** at a 128k window on a local model. Ten chains of 30 SWE-bench Verified tasks per arm, with Pi's built-in compaction in one arm and pi-tuck in the other. Official grading.
-2. **A paired replay with probe questions.** The same cuts, made by pi-tuck and by LLM compactors, then questions about facts that fell before the cut. Pre-registered rule: the claim holds only if pi-tuck is no more than 3 points worse than the better LLM compactor, with a 95% bound.
+1. **A live run** at a 128k window on a local model, with pi-tuck 1.0.1. Ten chains of 30 SWE-bench Verified tasks per arm, with Pi's built-in compaction in one arm and pi-tuck in the other. Official grading.
+2. **A paired replay with probe questions.** The same cuts, made by pi-tuck and by Pi's summarize prompts on the local model, then questions about facts that fell before the cut. Pre-registered rule: the claim holds only if pi-tuck is no more than 3 points worse than the better compactor, with a 95% bound. The comparators are named above and in `benchmark/`.
 3. **A 32k suite**, where tasks are bigger than the room, so cuts must summarise work in progress.
 
-The plan: [`benchmark/PREREG.md`](benchmark/PREREG.md), [`benchmark/PREREG-32K.md`](benchmark/PREREG-32K.md), and every change after the freeze in [`benchmark/DEVIATIONS.md`](benchmark/DEVIATIONS.md).
+The plan: [`benchmark/PREREG.md`](benchmark/PREREG.md), [`benchmark/PREREG-32K.md`](benchmark/PREREG-32K.md), [`benchmark/PREREG-TERRA.md`](benchmark/PREREG-TERRA.md), and every change after the freeze in [`benchmark/DEVIATIONS.md`](benchmark/DEVIATIONS.md).
 
 Known limits today:
 
 - pi-tuck's summary does not explain why things happened. It holds the words that were said, not a model's reading of them. The agent must look things up. Each look-up costs a tool call.
-- Small windows: an upstream that spends far more context on tool schemas than others (some OpenRouter upstreams do) can leave a small input room too little space, and pi-tuck then refuses to cut rather than overflow. This is what made 1.0.1 refuse at a 32k window with Pi's default 16,384 reserve. Since 1.0.4 the notice says when the provider is counting far above pi-tuck's estimate, and a refusal no longer affects the next prompt. Pin a different upstream, lower the reserve, or use a larger window; see [Small windows](#small-windows).
+- Small windows: an upstream that spends far more context on tool schemas than others (some OpenRouter upstreams do) can leave a small input room too little space, and pi-tuck then refuses to cut rather than overflow. This is what made 1.0.1 refuse at a 32k window with Pi's default 16,384 reserve. Since 1.0.4 the notice says when the provider is counting far above pi-tuck's estimate. In 1.0.4, after an oversize tool result or a "Nothing to compact" error from Pi, a session could keep refusing later prompts. 1.0.5 fixes both. Pin a different upstream, lower the reserve, or use a larger window; see [Small windows](#small-windows).
 - Semantic search runs only on macOS with Apple silicon.
 
 ## Benchmarks
@@ -114,12 +115,12 @@ Each row says what was measured, under which conditions, and where the data is.
 | What | Result | Conditions | Source |
 |---|---|---|---|
 | Cut time, live | pi-tuck median 0.087 s (90th percentile 0.205 s); Pi's built-in median 268.8 s (90th percentile 421.6 s). Context carried after a cut, median: 27,751 against 29,241 tokens | **Interim.** pi-tuck 1.0.1, Pi 1.4.0, SWE-bench Verified chains of 30 tasks, 131,072-token window, reply reserve 32,768, local model `mac-studio/main` writing Pi's summaries. 27 cuts per arm, 5 chains. The built-in time depends on that model and on server load. pi-tuck's time is an upper bound read from the session file | [`benchmark/RESULTS-INTERIM.md`](benchmark/RESULTS-INTERIM.md) section 1 |
-| Cut time, paired replay | pi-tuck median 0.062 s (range 0.005 to 0.48 s); local-model summarizer 193.4 s (77.3 to 413.3 s); frontier summarizer 96.1 s (39.1 to 267.8 s). Context carried after a cut, median: 28,006 (pi-tuck), 26,424 (local), 25,555 (frontier) tokens | **Interim.** The same recorded sessions cut at the same positions. pi-tuck: 10 recordings, 52 cuts. Summarizers: 6 recordings, 28 and 29 cuts. Frontier is `openai/gpt-6-astra`. pi-tuck's time leaves out the background search index | [`benchmark/RESULTS-INTERIM.md`](benchmark/RESULTS-INTERIM.md) section 2 |
+| Cut time, paired replay | pi-tuck median 0.062 s (range 0.005 to 0.48 s); local-model summarizer 193.4 s (77.3 to 413.3 s); frontier summarizer 96.1 s (39.1 to 267.8 s; measured on the retired model `openai/gpt-6-astra`; feeds no test). Context carried after a cut, median: 28,006 (pi-tuck), 26,424 (local), 25,555 (frontier) tokens | **Interim.** The same recorded sessions cut at the same positions. pi-tuck: 10 recordings, 52 cuts. Summarizers: 6 recordings, 28 and 29 cuts. pi-tuck's time leaves out the background search index | [`benchmark/RESULTS-INTERIM.md`](benchmark/RESULTS-INTERIM.md) section 2 |
 | Billed input, cutting at 60% of the room instead of 100% | −17.9% at 128k, −14.0% at 32k with automatic prompt caching; −17.0% and −9.6% with explicit cache breakpoints. Cuts go from 6 to 12 (128k) and from 84 to 157 (32k); none frees under a tenth of the room | Simulated billing, not provider bills. Prompt caching priced. Build `1bda64b` (the default shipped in 1.0.3). 5 recorded live sessions. 128k = 131,072 window, reserve 32,768. 32k = 32,768 window, reserve 16,384 | [`rnd/replay32/RESULT-lean.md`](rnd/replay32/RESULT-lean.md) |
 | Answers after cutting at 60% instead of 100% | No more losses than the limit on all 4 sets. Losses / wins over n questions: 128k shared 3 / 7 of 99; 128k asymmetric 3 / 1 of 67; 32k shared 5 / 3 of 77; 32k asymmetric 9 / 5 of 343. In the 32k asymmetric set the losses lean against 60% (test_result 4 / 2, error_hit 3 / 1); it is the set to watch | Paired replay, same 5 sessions, DeepSeek flash as agent and judge. Limit, set in advance: losses minus wins at most max(2, 5% of n). Asymmetric = evidence the base keeps native and the variant has summarised | [`rnd/replay32/RESULT-lean.md`](rnd/replay32/RESULT-lean.md) |
 | 1.0.2 changes (plain-text summary, shrinking dialogue view, time on user turns only) against 1.0.1 | No more losses than the limit on all 4 sets. Losses / wins: 128k 1 / 2 of 128; 128k time questions 0 / 0 of 48; 32k 4 / 2 of 127; 32k asymmetric 0 / 2 of 56 | Paired replay, 5 recorded live sessions, DeepSeek flash as agent and judge. 11 of 146 answer sessions hit a 15-minute wall limit and drop out of the pairing | [`rnd/replay32/RESULT-lean.md`](rnd/replay32/RESULT-lean.md), [`CHANGELOG.md`](CHANGELOG.md) |
 | Summary size, plain-text format against the 1.0.1 JSON format | About 30% shorter where the agent writes little, about 14% shorter where it writes a lot | Same dialogue | [`CHANGELOG.md`](CHANGELOG.md) 1.0.2 |
-| Small-window fix | A session that writes little prose cut 174 times in 300 tool rounds at 32k with a 16k reserve (1.0.1 code). With the fix, a test pins that no cut frees under a tenth of the room | Real planner on synthetic sessions (R&D's planner replay) | [`test/cut-yield.test.ts`](test/cut-yield.test.ts), which pins that every cut frees at least a tenth of the room |
+| Small-window fix | A session that writes little prose cut 174 times in 300 tool rounds at 32k with a 16k reserve (1.0.1 code). With the fix, a test pins that no cut frees under a tenth of the room | Real planner on synthetic sessions | [`CHANGELOG.md`](CHANGELOG.md) 1.0.2 (the 174 cuts); [`test/cut-yield.test.ts`](test/cut-yield.test.ts), which pins that every cut frees at least a tenth of the room |
 | Stall fix: a long session's cut | A cut at 3,888 entries took 72 s in 1.0.0 and takes 174 ms since 1.0.1. Since 1.0.1 the cost grows linearly with the session | One machine, the same synthetic session for both numbers (little prose, 128k window, reserve 16,384, turn 644) | [`CHANGELOG.md`](CHANGELOG.md) 1.0.1 |
 
 Notes:
@@ -150,6 +151,8 @@ pi-tuck keeps room for the model's reply: the larger of the model's output limit
 { "compaction": { "modelOverrides": { "my-provider/my-model": { "reserveTokens": 8192 } } } }
 ```
 
+The reserve is the larger of `reserveTokens` and the model's `maxTokens`, so lowering `reserveTokens` alone does nothing when `models.json` sets a larger `maxTokens` for that model. Lower both, and keep `maxTokens` above your largest expected reply.
+
 If you reach the model through OpenRouter, you can also pin one upstream, so that every request is served by the same one. Put this in `models.json` in Pi's agent folder, and name the upstream you want:
 
 ```json

package/dist/src/build-id.d.ts

@@ -1 +1 @@
-export declare const BUILD_ID = "fb0ab667f5bfcd22fd5cc6edb89cd859426fd7c28bb58c2bc7b9fbec6fcdd3da";
+export declare const BUILD_ID = "d2b2e6b0e594b5dd41e9771c43f4ed0355d8fd048c4e247541199f3b812751d3";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "fb0ab667f5bfcd22fd5cc6edb89cd859426fd7c28bb58c2bc7b9fbec6fcdd3da";
+export const BUILD_ID = "d2b2e6b0e594b5dd41e9771c43f4ed0355d8fd048c4e247541199f3b812751d3";

package/dist/src/compaction.js

@@ -36,11 +36,14 @@ const RecallInput = Type.Union([
 ]);
 const SearchInput = Type.Object({ query, priorResults: Type.Optional(Type.Array(Type.Object({ entryId, sourceSha: Type.String({ minLength: 64, maxLength: 64 }), start: Type.Integer({ minimum: 0 }), end: Type.Integer({ minimum: 0 }) }, { additionalProperties: false }), { maxItems: 20 })) }, { additionalProperties: false });
 const reply = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }], details: {} });
-/** The compactor's verdict that this attempt cannot be made: the cut it needs cannot be made, or the request cannot fit. It is a decision about the
- * state as it was, so it ends with the attempt (`forgetRefusal`) and the next attempt decides afresh. Any other failure is a fault in the compactor
- * or its host, and stays until the session restarts. */
+/** The compactor's verdict that this attempt cannot be made: the cut it needs cannot be made, or the request cannot fit. Like every failure but
+ * a `CommitFault`, it ends with its attempt (`forgetFailure`), and the next attempt plans afresh from the session as it is. */
 class Refusal extends Error {
 }
+/** A cut this compactor supplied that Pi then failed to commit. Pi appends a cut to the session in memory before it writes the file, so the
+ * session may hold a cut its file lacks; what is written after would build on it. The one failure that stays until the session restarts. */
+class CommitFault extends Error {
+}
 /** A refusal for want of room, which the user can remedy: it carries advice. */
 class CapacityError extends Refusal {
 }
@@ -95,10 +98,17 @@ export async function installCompaction(pi, options = {}) {
     if (!validCutAt(cutAt))
         throw new Error("Invalid cut point: cutAt must be a number above 0 and at most 1");
     const semantic = options.semanticRecall ?? createSemanticRecall();
+    const hostAccess = () => {
+        if (!active())
+            throw new Error("Compaction host is inactive");
+        options.assertAccess?.();
+    };
     let semanticTransition = Promise.resolve();
     let semanticRequest = 0;
     const semanticPending = new Set();
-    const semanticProvider = (ctx) => () => memoizedEligibleSources(ctx, options.recallPolicy, access);
+    // Semantic indexing outlives any one attempt, so it checks only that the host still grants access: a compactor failure, which ends with its
+    // attempt, must not read as a revocation (that disables semantic recall and deletes its index for the rest of the session).
+    const semanticProvider = (ctx) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess);
     const recorder = new IncidentRecorder(options.diagnostics);
     let proposalId;
     const observe = (ctx) => recorder.measureInline(() => {
@@ -259,7 +269,7 @@ export async function installCompaction(pi, options = {}) {
             learn(ratio);
     });
     pi.on("agent_start", () => { admittedRun = true; pending = undefined; phase = "idle"; });
-    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetRefusal(); });
+    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); });
     const active = () => options.active?.() ?? true;
     const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
     // The standalone default reserves the model's catalogue maximum output: a transport may omit the output cap, and then only that
@@ -308,7 +318,9 @@ export async function installCompaction(pi, options = {}) {
     const fail = (error, ctx) => {
         recorder.stop("native-attempt-failed");
         const notify = !failure && error instanceof CapacityError;
-        failure = error instanceof Error ? error : new Error(String(error));
+        // A CommitFault stays whatever fails after it.
+        if (!(failure instanceof CommitFault))
+            failure = error instanceof Error ? error : new Error(String(error));
         pendingBoundaryCommit = false;
         pending = undefined;
         try {
@@ -324,16 +336,14 @@ export async function installCompaction(pi, options = {}) {
             }
         }
     };
-    // The one place a refusal is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
-    // input started (a custom message) has only the first of these.
-    const forgetRefusal = () => { if (failure instanceof Refusal)
+    // The one place a failure is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
+    // input started (a custom message) has only the first of these. No failure but a CommitFault outlives its attempt.
+    const forgetFailure = () => { if (!(failure instanceof CommitFault))
         failure = undefined; };
     const access = () => {
         if (failure)
             throw failure;
-        if (!active())
-            throw new Error("Compaction host is inactive");
-        options.assertAccess?.();
+        hostAccess();
     };
     // Abort alone is insufficient: Pi starts a fresh abort controller after
     // before_agent_start. Keep this attempt blocked, then recheck on new idle input.
@@ -343,7 +353,7 @@ export async function installCompaction(pi, options = {}) {
     pi.on("input", async (event, ctx) => {
         if (!ctx.isIdle() || phase === "starting")
             return; // a steering or follow-up message joins the running request
-        forgetRefusal();
+        forgetFailure();
         phase = "decided";
         try {
             await preflight(ctx, incomingTokens(event.text, event.images), ctx.getSystemPrompt(), pi.getActiveTools());
@@ -418,7 +428,7 @@ export async function installCompaction(pi, options = {}) {
             const incoming = pendingCut;
             const operatorManual = event.reason === "manual" && !(incoming && !admittedRun);
             if (operatorManual && !admittedRun)
-                forgetRefusal();
+                forgetFailure();
             access();
             if (event.customInstructions?.trim()) {
                 recorder.stop("no-cut-custom-instructions");
@@ -453,7 +463,9 @@ export async function installCompaction(pi, options = {}) {
                     : "Compaction did not reduce context within the estimated request budget",
                 plan: (target) => {
                     const reserve = planReserve(target, room, mandatory, ctx);
-                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual);
+                    // Every cut asked while no run is admitted (a prompt's preflight, an operator's cut, Pi's own cut before a run a custom message
+                    // starts) is planned for a run that has not begun: the session has moved on from any run that ended. A retry is inside its run.
+                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, Boolean(incoming) || operatorManual || !admittedRun);
                     return draft.compaction ? { draft: true, after: draft.after, mode: draft.mode, compaction: draft.compaction, reserve }
                         : { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 },
@@ -526,10 +538,14 @@ export async function installCompaction(pi, options = {}) {
                     // An opportunistic cut is not needed to send the request, which is below the room: the guard decides. However it ends (the
                     // planner declined it, Pi had nothing to compact, an earlier handler cancelled it) it is no fault, unless a failure is latched
                     // or the compactor proposed a cut that then failed to commit (the session may hold what the file lacks).
+                    // A needed cut that Pi has nothing to make (no history older than its keepRecentTokens since the last cut) is a refusal of
+                    // this request, which ends with it: as a fault it stayed, and every later prompt of the session failed on it.
                     if (cut.opportunistic && !failure && !cut.proposed)
                         resolve();
+                    else if (!cut.proposed && isNoWork(error.message))
+                        reject(new CapacityError(`The request needs a cut and Pi has none to make (${error.message})`));
                     else
-                        reject(error.message === "Compaction cancelled" && failure instanceof Refusal ? failure : error);
+                        reject(error.message === "Compaction cancelled" && failure instanceof Refusal ? failure : cut.proposed ? new CommitFault(error.message) : error);
                 } }));
         }
         finally {
@@ -645,13 +661,13 @@ export async function installCompaction(pi, options = {}) {
         if (event.reason === "manual" && !event.fromExtension && !event.aborted && isNoWork(event.errorMessage))
             return;
         if (active() && !event.aborted)
-            fail(new Error(event.errorMessage ?? "Compaction failed"), ctx);
+            fail(new (event.fromExtension ? CommitFault : Error)(event.errorMessage ?? "Compaction failed"), ctx);
     });
     pi.on("agent_before_settle", (event, ctx) => {
         if (!pendingBoundaryCommit)
             return;
         if (event.outcome === "error")
-            fail(new Error("Native tool-loop boundary draft remained unconfirmed at error settlement"), ctx);
+            fail(new CommitFault("Native tool-loop boundary draft remained unconfirmed at error settlement"), ctx);
         else
             pendingBoundaryCommit = false;
     });

package/dist/src/diagnostics.d.ts

@@ -1,6 +1,6 @@
 import { type RecallPolicy } from './recall.js';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
-export declare const DIAGNOSTIC_BUILD = "fb0ab667f5bfcd22fd5cc6edb89cd859426fd7c28bb58c2bc7b9fbec6fcdd3da";
+export declare const DIAGNOSTIC_BUILD = "d2b2e6b0e594b5dd41e9771c43f4ed0355d8fd048c4e247541199f3b812751d3";
 export interface Receipt {
     id: string;
     build: string;

package/dist/src/semantic-recall.d.ts

@@ -110,6 +110,16 @@ export declare const HEAL_DELAYS_MS: readonly number[];
 export declare const HEAL_STEADY_MS = 600000;
 /** A session that has not searched for this long gives its worker back (the index stays on disk). Enabling starts nothing; a search starts the worker again. */
 export declare const IDLE_STOP_MS = 600000;
+/** A worker call's deadline once the worker has answered a call after `ready`: index, embed and tokenize on a loaded model. */
+export declare const CALL_DEADLINE_MS = 60000;
+/** What an `embed` call adds to its deadline for each text it carries. A batch of 8 passages on a starved CPU took longer than the per-call
+ * deadline, and the worker failed when it should have slowed down; a query (one text) still fails fast when the server hangs. The worker
+ * scales its native request timeout by the same amount (semantic-worker.py), so that limit is not reached first. */
+export declare const EMBED_TEXT_MS = 30000;
+/** The deadline for a worker's start: Python start, `ready` (which verifies every runtime file) and the first call after it, which loads the
+ * model and starts its native server. On a busy machine that takes minutes; held to the per-call deadline, the worker never started and
+ * semantic recall went unavailable. It stays above the worker's own native start limits (120 s on Metal, then 400 s on the CPU, in semantic-worker.py). */
+export declare const START_DEADLINE_MS = 600000;
 /** The most units one index window holds. The worker's SQLite store stops at 8,008 rows (`PRAGMA max_page_count=8192` in scripts/semantic-worker.py), so a cap below that keeps a window of short units from filling the store and sticking in `unavailable`. Raise it only together with the store. */
 export declare const MAX_INDEX_UNITS = 8000;
 /** The wait before the next automatic attempt, given how many were already armed since the last success. */
@@ -168,6 +178,9 @@ export declare class SemanticRecallController {
         healDelaysMs?: readonly number[];
         healSteadyMs?: number;
         idleStopMs?: number;
+        startDeadlineMs?: number;
+        callDeadlineMs?: number;
+        embedTextMs?: number;
     });
     /** Be told when `status().state` or `lastError` changes: once per change, after the synchronous work that caused it. Returns the unsubscribe. A listener that throws is ignored. */
     onStateChange(listener: (state: SemanticState, reason: string | null) => void): () => void;

package/dist/src/semantic-recall.js

@@ -169,6 +169,16 @@ export const HEAL_DELAYS_MS = [5000, 30000, 120000];
 export const HEAL_STEADY_MS = 600000;
 /** A session that has not searched for this long gives its worker back (the index stays on disk). Enabling starts nothing; a search starts the worker again. */
 export const IDLE_STOP_MS = 600000;
+/** A worker call's deadline once the worker has answered a call after `ready`: index, embed and tokenize on a loaded model. */
+export const CALL_DEADLINE_MS = 60000;
+/** What an `embed` call adds to its deadline for each text it carries. A batch of 8 passages on a starved CPU took longer than the per-call
+ * deadline, and the worker failed when it should have slowed down; a query (one text) still fails fast when the server hangs. The worker
+ * scales its native request timeout by the same amount (semantic-worker.py), so that limit is not reached first. */
+export const EMBED_TEXT_MS = 30000;
+/** The deadline for a worker's start: Python start, `ready` (which verifies every runtime file) and the first call after it, which loads the
+ * model and starts its native server. On a busy machine that takes minutes; held to the per-call deadline, the worker never started and
+ * semantic recall went unavailable. It stays above the worker's own native start limits (120 s on Metal, then 400 s on the CPU, in semantic-worker.py). */
+export const START_DEADLINE_MS = 600000;
 /** The most units one index window holds. The worker's SQLite store stops at 8,008 rows (`PRAGMA max_page_count=8192` in scripts/semantic-worker.py), so a cap below that keeps a window of short units from filling the store and sticking in `unavailable`. Raise it only together with the store. */
 export const MAX_INDEX_UNITS = 8000;
 /** Keys per worker `score` request: a multiple of the worker's 128-key sub-batches, aligned from the start of the covered prefix. A key is a SHA-256 hex digest (64 characters, see `hash`), so 1024 keys and the 768-float query make a request of about 90 KiB, far under both the 512 KiB design bound and the worker's 1 MiB line limit. */
@@ -183,6 +193,7 @@ class LocalWorker {
     project;
     cleanupFailure;
     onLoss;
+    deadlines;
     nativeHelper = false;
     jobId;
     helperReceipt;
@@ -202,11 +213,13 @@ class LocalWorker {
     stopped = false;
     lost = false;
     closing;
-    constructor(config, project, cleanupFailure, onLoss = () => { }) {
+    loaded = false;
+    constructor(config, project, cleanupFailure, onLoss = () => { }, deadlines = { startMs: START_DEADLINE_MS, callMs: CALL_DEADLINE_MS, embedTextMs: EMBED_TEXT_MS }) {
         this.config = config;
         this.project = project;
         this.cleanupFailure = cleanupFailure;
         this.onLoss = onLoss;
+        this.deadlines = deadlines;
     }
     closeInBackground() { void this.close().catch(error => this.cleanupFailure(error)); }
     // The worker stopped without the controller asking: report it once, then join it like any other background close.
@@ -303,7 +316,8 @@ class LocalWorker {
         const id = ++this.next, body = JSON.stringify({ id, op, ...input }) + '\n';
         if (Buffer.byteLength(body) > 1048576)
             throw new Error('Local worker input bound');
-        return new Promise((resolveReply, reject) => { const onAbort = () => { this.closeInBackground(); reject(abort()); }; signal?.addEventListener('abort', onAbort, { once: true }); const finish = (callback, value) => { signal?.removeEventListener('abort', onAbort); callback(value); }; const timer = setTimeout(() => { this.lose('Local runtime deadline'); finish(reject, new WorkerFailure('Local runtime deadline')); }, 60000); this.pending.set(id, { resolve: value => finish(resolveReply, value), reject: error => finish(reject, error), timer }); if (this.nativeHelper) {
+        return new Promise((resolveReply, reject) => { const onAbort = () => { this.closeInBackground(); reject(abort()); }; signal?.addEventListener('abort', onAbort, { once: true }); const finish = (callback, value) => { signal?.removeEventListener('abort', onAbort); callback(value); }; const timer = setTimeout(() => { this.lose('Local runtime deadline'); finish(reject, new WorkerFailure('Local runtime deadline')); }, this.loaded ? this.deadlines.callMs + (op === 'embed' ? this.deadlines.embedTextMs * (input.texts?.length ?? 0) : 0) : this.deadlines.startMs); this.pending.set(id, { resolve: value => { if (op !== 'ready')
+                this.loaded = true; finish(resolveReply, value); }, reject: error => finish(reject, error), timer }); if (this.nativeHelper) {
             const control = { op: 'input', input: Buffer.from(body).toString('base64') };
             this.nativeInputs.push({ id, control: JSON.stringify(control) + '\n' });
             this.pumpNativeInput();
@@ -620,7 +634,7 @@ export class SemanticRecallController {
         if (!this.worker) {
             const worker = new LocalWorker(this.config, project, error => { if (this.worker !== worker)
                 return; this.cleanupError = error instanceof Error ? error.message : 'Semantic cleanup failed'; this.error = this.cleanupError; this.enabled = false; this.generation++; }, reason => { if (this.worker === worker)
-                this.heal(new WorkerFailure(reason)); });
+                this.heal(new WorkerFailure(reason)); }, { startMs: this.timing.startDeadlineMs ?? START_DEADLINE_MS, callMs: this.timing.callDeadlineMs ?? CALL_DEADLINE_MS, embedTextMs: this.timing.embedTextMs ?? EMBED_TEXT_MS });
             this.worker = worker;
         }
         if (!this.identity) {

package/dist/src/tuck.d.ts

@@ -81,13 +81,16 @@ export declare const tuck: Tuck;
  * initiating prompt, file ledger) are already charged in base. */
 export declare function historicalAllowance(window: number, reserve: number, base: number, before: number): number;
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean): Draft;
+export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean): Draft;
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
+/** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
+ * a run a custom message starts); the session has moved on from an ended run. */
 export declare function tuckObservedDraft(tuck: Tuck, input: {
     branchEntries: SessionEntry[];
     tokensBefore: number;
     previousSummary?: string;
     operatorManual?: boolean;
+    newPrompt?: boolean;
 }, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean): Draft;
 /** Numeric references use the original session index, then intersect with readable current-branch entries. */
 export declare function tuckRecall(tuck: Tuck, entries: readonly SessionEntry[], branch: readonly SessionEntry[], input: RecallOptions & {

package/dist/src/tuck.js

@@ -26,10 +26,12 @@ export function historicalAllowance(window, reserve, base, before) {
     return Math.max(0, Math.min(Math.floor(free / 4), before - base - 1)) * 4;
 }
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true, operatorManual = false) {
-    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual }, ctx, reserveTokens, measure, policy, retainCurrentInput);
+export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false) {
+    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt }, ctx, reserveTokens, measure, policy, retainCurrentInput);
 }
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
+/** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
+ * a run a custom message starts); the session has moved on from an ended run. */
 export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true) {
     const { isHistorySource, readable } = createRecall(policy);
     const projected = ctx.sessionManager.buildSessionProjection();
@@ -73,10 +75,14 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         const calls = new Set(response.message.content.flatMap(block => block.type === "toolCall" ? [block.id] : []));
         const hasFreshReceipt = entries.slice(lastResponse + 1).some(entry => entry.type === "message" &&
             entry.message.role === "toolResult" && calls.has(entry.message.toolCallId));
-        freshRound = hasFreshReceipt;
+        // Fresh means the receipts are the answer the next request of this run carries. Once the session has moved on (the cut is planned for a
+        // run that has not begun, or a prompt has arrived since them) they are ordinary history, whatever ended their run: a reply discarded
+        // or one Pi hid when it recovered. Kept native, a receipt that never fits would refuse every later prompt. A retry is inside its run.
+        const superseded = input.newPrompt || entries.slice(lastResponse + 1).some(entry => entry.type === "message" && entry.message.role === "user");
+        freshRound = hasFreshReceipt && !superseded;
         const keptId = cut.firstKeptEntryId;
         const chosenBoundary = cut.compactAll ? entries.length : entries.findIndex(entry => entry.id === keptId);
-        if (hasFreshReceipt && lastResponse < chosenBoundary) {
+        if (freshRound && lastResponse < chosenBoundary) {
             const prefix = tuck.buildOwnCut(entries.slice(0, lastResponse), 0);
             if (!prefix.ok)
                 return { unavailable: "No reducible history before the fresh tool round" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Deterministic compaction for Pi: compact summaries that keep the dialogue and the files touched, plus history recall by keyword and by meaning, all local.",
   "keywords": [
     "pi-package",

package/scripts/semantic-worker.py

@@ -12,12 +12,13 @@ WINDOWS=os.name=='nt';encoder_port=None;encoder_token=None
 class LocalHTTP(http.client.HTTPConnection):
  def connect(self):
   self.sock=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM);self.sock.settimeout(self.timeout);self.sock.connect('encoder.sock')
-def request(path,data=None):
+# A native request's timeout: 55 s, plus 30 s per text it embeds (the host's EMBED_TEXT_MS), so a starved CPU slows a batch down and does not fail it.
+def request(path,data=None,texts=0):
  if path not in ('/health','/props','/v1/embeddings'):raise Refusal('native_path_failure')
  if WINDOWS:
   if encoder_port is None or not encoder_token:raise Refusal('native_transport_unavailable')
-  connection=http.client.HTTPConnection('127.0.0.1',encoder_port,timeout=55)
- else:connection=LocalHTTP('localhost',timeout=55)
+  connection=http.client.HTTPConnection('127.0.0.1',encoder_port,timeout=55+30*texts)
+ else:connection=LocalHTTP('localhost',timeout=55+30*texts)
  try:
   headers={'Content-Type':'application/json'}
   if WINDOWS:headers['Authorization']='Bearer '+encoder_token
@@ -26,6 +27,7 @@ def request(path,data=None):
   if len(payload)>16*1024*1024:raise Refusal('native_response_bound')
   if response.status!=200:raise Refusal('native_request_failure')
   return json.loads(payload)
+ except TimeoutError:raise Refusal('native_request_failure')
  finally:connection.close()
 def native_executable():
  executable=ROOT/('native/llama-server.exe' if WINDOWS else 'native/llama-server')
@@ -90,18 +92,27 @@ def load():
    # Pinned common/arg.cpp supports LLAMA_API_KEY; server-http.cpp requires Bearer
    # on /props and embeddings, but /health is public. No token in process argv.
    env['LLAMA_API_KEY']=encoder_token
-  server=subprocess.Popen([str(executable),'-m',str(ROOT/'model.gguf'),'--embedding','--pooling','mean','--embd-normalize','2','--ctx-size','8192','--batch-size','8192','--ubatch-size','8192','--parallel','1','--n-gpu-layers','0','--cache-type-k','f32','--cache-type-v','f32','--flash-attn','off','--threads','4',*transport,'--no-webui','--log-disable'],stdin=subprocess.DEVNULL,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,env=env)
-  started=time.monotonic()
-  while True:
-   if server.poll() is not None:raise Refusal('native_start_failure')
-   try:
-    if request('/health').get('status')=='ok':
-     if WINDOWS:request('/props') # Public health alone is not authenticated readiness.
-     if server.poll() is not None:raise Refusal('native_start_failure')
-     break
-   except (OSError,Refusal):pass
-   if time.monotonic()-started>50:raise Refusal('native_start_timeout')
-   time.sleep(.02)
+  def launch(gpu_layers,limit):
+   """The server, or None when it exits or is not healthy within `limit` seconds (it is then stopped)."""
+   child=subprocess.Popen([str(executable),'-m',str(ROOT/'model.gguf'),'--embedding','--pooling','mean','--embd-normalize','2','--ctx-size','8192','--batch-size','8192','--ubatch-size','8192','--parallel','1','--n-gpu-layers',str(gpu_layers),'--cache-type-k','f32','--cache-type-v','f32','--flash-attn','off','--threads','4',*transport,'--no-webui','--log-disable'],stdin=subprocess.DEVNULL,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,env=env)
+   started=time.monotonic()
+   while child.poll() is None and time.monotonic()-started<=limit:
+    try:
+     if request('/health').get('status')=='ok':
+      if WINDOWS:request('/props') # Public health alone is not authenticated readiness.
+      if child.poll() is None:return child
+    except (OSError,Refusal):pass
+    time.sleep(.02)
+   if child.poll() is None:
+    child.kill();child.wait()
+   return None
+  # Metal first: on Apple silicon it embeds a batch about 56 times faster than the CPU (0.7 s against 39 s for 8 passages at load 44-76),
+  # with vectors of cosine 0.9998 or more to the CPU's. Where Metal cannot start (a VM, CI, no GPU) the server exits or never becomes
+  # healthy, and the same server starts on the CPU. A busy machine can take minutes to start it; both limits stay under the host's start
+  # deadline (START_DEADLINE_MS, 600 s). Windows has no Metal.
+  server=None if WINDOWS else launch(99,120)
+  if server is None:server=launch(0,400)
+  if server is None:raise Refusal('native_start_failure')
  return server
 def run(req):
  op=req['op']
@@ -132,7 +143,7 @@ def run(req):
   if len(a)>8:raise Refusal('batch_limit')
   ids=[enc(framed(t,kind)) for t in a]
   if not a:return {'vectors':[],'identity':IDENTITY}
-  load();out=request('/v1/embeddings',{'input':ids,'encoding_format':'float','truncate':False})['data'];out.sort(key=lambda row:row['index']);vectors=[row['embedding'] for row in out]
+  load();out=request('/v1/embeddings',{'input':ids,'encoding_format':'float','truncate':False},len(ids))['data'];out.sort(key=lambda row:row['index']);vectors=[row['embedding'] for row in out]
   if len(vectors)!=len(a) or any(len(v)!=768 or any(not math.isfinite(x) for x in v) or abs(sum(x*x for x in v)**.5-1)>1e-5 for v in vectors):raise Refusal('invalid_vector')
   return {'vectors':vectors,'identity':IDENTITY,'nativePID':server.pid}
  if op=='index':return index(req)

package/src/build-id.ts

@@ -1 +1 @@
-export const BUILD_ID = "fb0ab667f5bfcd22fd5cc6edb89cd859426fd7c28bb58c2bc7b9fbec6fcdd3da";
+export const BUILD_ID = "d2b2e6b0e594b5dd41e9771c43f4ed0355d8fd048c4e247541199f3b812751d3";

package/src/compaction.ts

@@ -40,10 +40,12 @@ const RecallInput = Type.Union([
 ]);
 const SearchInput = Type.Object({query,priorResults:Type.Optional(Type.Array(Type.Object({entryId,sourceSha:Type.String({minLength:64,maxLength:64}),start:Type.Integer({minimum:0}),end:Type.Integer({minimum:0})},{additionalProperties:false}),{maxItems:20}))},{additionalProperties:false});
 const reply = (value: unknown) => ({ content: [{ type: "text" as const, text: JSON.stringify(value) }], details: {} });
-/** The compactor's verdict that this attempt cannot be made: the cut it needs cannot be made, or the request cannot fit. It is a decision about the
- * state as it was, so it ends with the attempt (`forgetRefusal`) and the next attempt decides afresh. Any other failure is a fault in the compactor
- * or its host, and stays until the session restarts. */
+/** The compactor's verdict that this attempt cannot be made: the cut it needs cannot be made, or the request cannot fit. Like every failure but
+ * a `CommitFault`, it ends with its attempt (`forgetFailure`), and the next attempt plans afresh from the session as it is. */
 class Refusal extends Error {}
+/** A cut this compactor supplied that Pi then failed to commit. Pi appends a cut to the session in memory before it writes the file, so the
+ * session may hold a cut its file lacks; what is written after would build on it. The one failure that stays until the session restarts. */
+class CommitFault extends Error {}
 /** A refusal for want of room, which the user can remedy: it carries advice. */
 class CapacityError extends Refusal {}
 /** What a capacity refusal tells the operator. When the provider has counted far more input than pi-tuck's estimate, the refusal most
@@ -118,10 +120,16 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     const cutAt = options.cutAt ?? DEFAULT_CUT_AT;
     if (!validCutAt(cutAt)) throw new Error("Invalid cut point: cutAt must be a number above 0 and at most 1");
     const semantic = options.semanticRecall ?? createSemanticRecall();
+    const hostAccess = () => {
+        if (!active()) throw new Error("Compaction host is inactive");
+        options.assertAccess?.();
+    };
     let semanticTransition: Promise<void> = Promise.resolve();
     let semanticRequest = 0;
     const semanticPending = new Set<Promise<unknown>>();
-    const semanticProvider = (ctx: ExtensionContext) => () => memoizedEligibleSources(ctx, options.recallPolicy, access);
+    // Semantic indexing outlives any one attempt, so it checks only that the host still grants access: a compactor failure, which ends with its
+    // attempt, must not read as a revocation (that disables semantic recall and deletes its index for the rest of the session).
+    const semanticProvider = (ctx: ExtensionContext) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess);
     const recorder = new IncidentRecorder(options.diagnostics);
     let proposalId: string | undefined;
     const observe = (ctx: ExtensionContext) => recorder.measureInline(() => {
@@ -230,7 +238,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         if (input > 0 && Number.isSafeInteger(input) && Number.isFinite(ratio)) learn(ratio);
     });
     pi.on("agent_start", () => { admittedRun = true; pending = undefined; phase = "idle"; });
-    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetRefusal(); });
+    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); });
 	const active = () => options.active?.() ?? true;
 	const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
 	// The standalone default reserves the model's catalogue maximum output: a transport may omit the output cap, and then only that
@@ -280,7 +288,8 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 	const fail = (error: unknown, ctx: ExtensionContext) => {
 		recorder.stop("native-attempt-failed");
         const notify = !failure && error instanceof CapacityError;
-		failure = error instanceof Error ? error : new Error(String(error));
+		// A CommitFault stays whatever fails after it.
+		if (!(failure instanceof CommitFault)) failure = error instanceof Error ? error : new Error(String(error));
         pendingBoundaryCommit = false;
         pending = undefined;
 		try { options.fail?.(error); } finally {
@@ -288,13 +297,12 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             finally { ctx.abort(); }
         }
 	};
-	// The one place a refusal is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
-	// input started (a custom message) has only the first of these.
-	const forgetRefusal = () => { if (failure instanceof Refusal) failure = undefined; };
+	// The one place a failure is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
+	// input started (a custom message) has only the first of these. No failure but a CommitFault outlives its attempt.
+	const forgetFailure = () => { if (!(failure instanceof CommitFault)) failure = undefined; };
 	const access = () => {
 		if (failure) throw failure;
-		if (!active()) throw new Error("Compaction host is inactive");
-		options.assertAccess?.();
+		hostAccess();
 	};
     // Abort alone is insufficient: Pi starts a fresh abort controller after
     // before_agent_start. Keep this attempt blocked, then recheck on new idle input.
@@ -303,7 +311,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     let phase: "idle" | "decided" | "starting" = "idle";
     pi.on("input", async (event, ctx) => {
         if (!ctx.isIdle() || phase === "starting") return; // a steering or follow-up message joins the running request
-        forgetRefusal();
+        forgetFailure();
         phase = "decided";
         try { await preflight(ctx, incomingTokens(event.text, event.images), ctx.getSystemPrompt(), pi.getActiveTools()); }
         catch (error) { fail(error, ctx); }
@@ -359,7 +367,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             // Pi also labels the awaited idle incoming preflight "manual".
             const incoming = pendingCut;
             const operatorManual = event.reason === "manual" && !(incoming && !admittedRun);
-            if (operatorManual && !admittedRun) forgetRefusal();
+            if (operatorManual && !admittedRun) forgetFailure();
 			access();
 			if (event.customInstructions?.trim()) {
 				recorder.stop("no-cut-custom-instructions");
@@ -393,7 +401,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
                     : "Compaction did not reduce context within the estimated request budget",
                 plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckDraft>["compaction"]>; reserve: number }> => {
                     const reserve = planReserve(target, room, mandatory, ctx);
-                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual);
+                    // Every cut asked while no run is admitted (a prompt's preflight, an operator's cut, Pi's own cut before a run a custom message
+                    // starts) is planned for a run that has not begun: the session has moved on from any run that ended. A retry is inside its run.
+                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, Boolean(incoming) || operatorManual || !admittedRun);
                     return draft.compaction ? { draft: true, after: draft.after, mode: draft.mode, compaction: draft.compaction, reserve }
                         : { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 },
@@ -450,8 +460,11 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
                     // An opportunistic cut is not needed to send the request, which is below the room: the guard decides. However it ends (the
                     // planner declined it, Pi had nothing to compact, an earlier handler cancelled it) it is no fault, unless a failure is latched
                     // or the compactor proposed a cut that then failed to commit (the session may hold what the file lacks).
+                    // A needed cut that Pi has nothing to make (no history older than its keepRecentTokens since the last cut) is a refusal of
+                    // this request, which ends with it: as a fault it stayed, and every later prompt of the session failed on it.
                     if (cut.opportunistic && !failure && !cut.proposed) resolve();
-                    else reject(error.message === "Compaction cancelled" && failure instanceof Refusal ? failure : error);
+                    else if (!cut.proposed && isNoWork(error.message)) reject(new CapacityError(`The request needs a cut and Pi has none to make (${error.message})`));
+                    else reject(error.message === "Compaction cancelled" && failure instanceof Refusal ? failure : cut.proposed ? new CommitFault(error.message) : error);
                 } }));
         } finally { pendingCut = undefined; }
         access();
@@ -536,11 +549,11 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 		if (exhausted) return;
 		// Pi reports manual no-work as failures; an accepted pi-tuck draft cannot be a no-op.
 		if (event.reason === "manual" && !event.fromExtension && !event.aborted && isNoWork(event.errorMessage)) return;
-		if (active() && !event.aborted) fail(new Error(event.errorMessage ?? "Compaction failed"), ctx);
+		if (active() && !event.aborted) fail(new (event.fromExtension ? CommitFault : Error)(event.errorMessage ?? "Compaction failed"), ctx);
 	});
     pi.on("agent_before_settle", (event, ctx) => {
         if (!pendingBoundaryCommit) return;
-        if (event.outcome === "error") fail(new Error("Native tool-loop boundary draft remained unconfirmed at error settlement"), ctx);
+        if (event.outcome === "error") fail(new CommitFault("Native tool-loop boundary draft remained unconfirmed at error settlement"), ctx);
         else pendingBoundaryCommit = false;
     });
 	pi.on("context_with_system", (event, ctx) => {

package/src/semantic-recall.ts

@@ -102,6 +102,16 @@ export const HEAL_DELAYS_MS:readonly number[]=[5000,30000,120000];
 export const HEAL_STEADY_MS=600000;
 /** A session that has not searched for this long gives its worker back (the index stays on disk). Enabling starts nothing; a search starts the worker again. */
 export const IDLE_STOP_MS=600000;
+/** A worker call's deadline once the worker has answered a call after `ready`: index, embed and tokenize on a loaded model. */
+export const CALL_DEADLINE_MS=60000;
+/** What an `embed` call adds to its deadline for each text it carries. A batch of 8 passages on a starved CPU took longer than the per-call
+ * deadline, and the worker failed when it should have slowed down; a query (one text) still fails fast when the server hangs. The worker
+ * scales its native request timeout by the same amount (semantic-worker.py), so that limit is not reached first. */
+export const EMBED_TEXT_MS=30000;
+/** The deadline for a worker's start: Python start, `ready` (which verifies every runtime file) and the first call after it, which loads the
+ * model and starts its native server. On a busy machine that takes minutes; held to the per-call deadline, the worker never started and
+ * semantic recall went unavailable. It stays above the worker's own native start limits (120 s on Metal, then 400 s on the CPU, in semantic-worker.py). */
+export const START_DEADLINE_MS=600000;
 /** The most units one index window holds. The worker's SQLite store stops at 8,008 rows (`PRAGMA max_page_count=8192` in scripts/semantic-worker.py), so a cap below that keeps a window of short units from filling the store and sticking in `unavailable`. Raise it only together with the store. */
 export const MAX_INDEX_UNITS=8000;
 /** Keys per worker `score` request: a multiple of the worker's 128-key sub-batches, aligned from the start of the covered prefix. A key is a SHA-256 hex digest (64 characters, see `hash`), so 1024 keys and the 768-float query make a request of about 90 KiB, far under both the 512 KiB design bound and the worker's 1 MiB line limit. */
@@ -118,8 +128,8 @@ class LocalWorker {
  // This leaves room for the previous native write to finish plus one queued
  // control, even when the child replies before that writer goroutine retires.
  private nativeInputs:{id:number;control:string}[]=[];private nativeInputId?:number;
- private child?:ChildProcessWithoutNullStreams;private scratch?:string;private starting?:Promise<void>;private exited?:Promise<void>;private buffer='';private next=0;private pending=new Map<number,{resolve:(value:any)=>void;reject:(error:Error)=>void;timer:ReturnType<typeof setTimeout>}>();private stopped=false;private lost=false;private closing?:Promise<void>;
- constructor(private config:SemanticRecallConfig, private project:string, private cleanupFailure:(error:unknown)=>void, private onLoss:(reason:string)=>void=()=>{}){}
+ private child?:ChildProcessWithoutNullStreams;private scratch?:string;private starting?:Promise<void>;private exited?:Promise<void>;private buffer='';private next=0;private pending=new Map<number,{resolve:(value:any)=>void;reject:(error:Error)=>void;timer:ReturnType<typeof setTimeout>}>();private stopped=false;private lost=false;private closing?:Promise<void>;private loaded=false;
+ constructor(private config:SemanticRecallConfig, private project:string, private cleanupFailure:(error:unknown)=>void, private onLoss:(reason:string)=>void=()=>{}, private deadlines:{startMs:number;callMs:number;embedTextMs:number}={startMs:START_DEADLINE_MS,callMs:CALL_DEADLINE_MS,embedTextMs:EMBED_TEXT_MS}){}
  private closeInBackground(){void this.close().catch(error=>this.cleanupFailure(error));}
  // The worker stopped without the controller asking: report it once, then join it like any other background close.
  private lose(reason:string){if(!this.stopped&&!this.lost){this.lost=true;this.onLoss(reason);}this.closeInBackground();}
@@ -152,7 +162,7 @@ class LocalWorker {
   if(signal?.aborted)throw abort();if(this.stopped)throw new WorkerFailure('Local worker closed');
   await this.start();if(this.stopped||signal?.aborted)throw this.lost&&!signal?.aborted?new WorkerFailure('Local worker stopped'):abort();if(this.pending.size>=2)throw new Error('Local semantic concurrency bound');
   const id=++this.next,body=JSON.stringify({id,op,...input})+'\n';if(Buffer.byteLength(body)>1048576)throw new Error('Local worker input bound');
-  return new Promise((resolveReply,reject)=>{const onAbort=()=>{this.closeInBackground();reject(abort());};signal?.addEventListener('abort',onAbort,{once:true});const finish=(callback:(value:any)=>void,value:any)=>{signal?.removeEventListener('abort',onAbort);callback(value);};const timer=setTimeout(()=>{this.lose('Local runtime deadline');finish(reject,new WorkerFailure('Local runtime deadline'));},60000);this.pending.set(id,{resolve:value=>finish(resolveReply,value),reject:error=>finish(reject,error),timer});if(this.nativeHelper){const control:NativeOwnerInputControl={op:'input',input:Buffer.from(body).toString('base64')};this.nativeInputs.push({id,control:JSON.stringify(control)+'\n'});this.pumpNativeInput();}else this.child!.stdin.write(body);});
+  return new Promise((resolveReply,reject)=>{const onAbort=()=>{this.closeInBackground();reject(abort());};signal?.addEventListener('abort',onAbort,{once:true});const finish=(callback:(value:any)=>void,value:any)=>{signal?.removeEventListener('abort',onAbort);callback(value);};const timer=setTimeout(()=>{this.lose('Local runtime deadline');finish(reject,new WorkerFailure('Local runtime deadline'));},this.loaded?this.deadlines.callMs+(op==='embed'?this.deadlines.embedTextMs*((input as {texts?:unknown[]}).texts?.length??0):0):this.deadlines.startMs);this.pending.set(id,{resolve:value=>{if(op!=='ready')this.loaded=true;finish(resolveReply,value);},reject:error=>finish(reject,error),timer});if(this.nativeHelper){const control:NativeOwnerInputControl={op:'input',input:Buffer.from(body).toString('base64')};this.nativeInputs.push({id,control:JSON.stringify(control)+'\n'});this.pumpNativeInput();}else this.child!.stdin.write(body);});
  }
  private pumpNativeInput(){if(this.stopped||this.nativeInputId!==undefined)return;const next=this.nativeInputs.shift();if(next){this.nativeInputId=next.id;this.child!.stdin.write(next.control);}}
  private rejectAll(error:Error){for(const p of this.pending.values()){clearTimeout(p.timer);p.reject(error);}this.pending.clear();this.nativeInputs=[];this.nativeInputId=undefined;}
@@ -235,7 +245,7 @@ export class SemanticRecallController {
  // Whether this session ran a search since the controller was created or last closed; it survives idle stops, so a cut after a long quiet spell still indexes.
  private searched=false;
  private readonly listeners=new Set<(state:SemanticState,reason:string|null)=>void>();private announced='disabled\0';private announcing=false;
- constructor(config?:SemanticRecallConfig,private readonly timing:{healDelaysMs?:readonly number[];healSteadyMs?:number;idleStopMs?:number}={}){if(config)this.configure(config);}
+ constructor(config?:SemanticRecallConfig,private readonly timing:{healDelaysMs?:readonly number[];healSteadyMs?:number;idleStopMs?:number;startDeadlineMs?:number;callDeadlineMs?:number;embedTextMs?:number}={}){if(config)this.configure(config);}
  /** Be told when `status().state` or `lastError` changes: once per change, after the synchronous work that caused it. Returns the unsubscribe. A listener that throws is ignored. */
  onStateChange(listener:(state:SemanticState,reason:string|null)=>void):()=>void{this.listeners.add(listener);return()=>{this.listeners.delete(listener);};}
  private touch(){if(this.announcing)return;this.announcing=true;queueMicrotask(()=>{this.announcing=false;const {state,lastError}=this.status(),key=state+'\0'+(lastError??'');if(key===this.announced)return;this.announced=key;for(const listener of [...this.listeners])try{listener(state,lastError);}catch{}});}
@@ -254,7 +264,7 @@ export class SemanticRecallController {
   * It is the conversation that left the view only (kind first, no full pass), a heal backoff in progress is not bypassed, and the idle limit applies afterwards. */
  indexAtCut(provider:()=>Snapshot){if(this.enabled&&!this.healTimer&&this.searched&&!this.active){this.active=true;this.armIdle();}this.schedule(provider);}
  private async runtime(project:string){if(this.idling)await this.idling;if(!this.enabled)throw abort();outsideProject(project,this.config!.runtimeRoot,'runtime');outsideProject(project,scratchParent(this.config!),'scratch');outsideRuntime(this.config!.runtimeRoot,scratchParent(this.config!),'scratch');if(this.worker&&this.recycle){const old=this.worker;await old.close();if(this.worker===old){this.worker=undefined;this.identity='';this.recycle=false;}if(!this.enabled)throw abort();}
-  if(!this.worker){const worker=new LocalWorker(this.config!,project,error=>{if(this.worker!==worker)return;this.cleanupError=error instanceof Error?error.message:'Semantic cleanup failed';this.error=this.cleanupError;this.enabled=false;this.generation++;},reason=>{if(this.worker===worker)this.heal(new WorkerFailure(reason));});this.worker=worker;}if(!this.identity){const ready=await this.worker.call('ready');if(ready.dimensions!==768||ready.maxTokens!==8192||!ready.offline)throw new Error('Incompatible semantic model; EG2 768/8192 offline required');this.identity=hash({worker:ready.identity,chunk:'eg2-passage256-focused-disjoint-direct-v3'});}return this.worker;}
+  if(!this.worker){const worker=new LocalWorker(this.config!,project,error=>{if(this.worker!==worker)return;this.cleanupError=error instanceof Error?error.message:'Semantic cleanup failed';this.error=this.cleanupError;this.enabled=false;this.generation++;},reason=>{if(this.worker===worker)this.heal(new WorkerFailure(reason));},{startMs:this.timing.startDeadlineMs??START_DEADLINE_MS,callMs:this.timing.callDeadlineMs??CALL_DEADLINE_MS,embedTextMs:this.timing.embedTextMs??EMBED_TEXT_MS});this.worker=worker;}if(!this.identity){const ready=await this.worker.call('ready');if(ready.dimensions!==768||ready.maxTokens!==8192||!ready.offline)throw new Error('Incompatible semantic model; EG2 768/8192 offline required');this.identity=hash({worker:ready.identity,chunk:'eg2-passage256-focused-disjoint-direct-v3'});}return this.worker;}
  private path(snapshot:Snapshot){const directory=this.config!.indexDirectory;outsideProject(snapshot.project,directory,'index');return join(directory,hash({owner:this.ownerId,session:snapshot.session,project:resolve(snapshot.project)})+'.sqlite');}
  private async index(action:string,snapshot:Snapshot,extra:object={}){const path=this.path(snapshot),generation=this.generation,worker=await this.runtime(snapshot.project);if(!this.enabled||generation!==this.generation)throw abort();if(this.provider)this.recheck(this.provider,snapshot);this.indexFiles.add(path);const result=await worker.call('index',{path,identity:this.identity,action,projectDirectory:snapshot.project,...extra});if(!this.enabled||generation!==this.generation)throw abort();if(this.provider)this.recheck(this.provider,snapshot);return result;}
  private async prepare(provider:()=>Snapshot,full=true){

package/src/tuck.ts

@@ -58,11 +58,13 @@ export function historicalAllowance(window: number, reserve: number, base: numbe
     return Math.max(0, Math.min(Math.floor(free / 4), before - base - 1)) * 4;
 }
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true, operatorManual = false) {
- return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual }, ctx, reserveTokens, measure, policy, retainCurrentInput);
+export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false) {
+ return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt }, ctx, reserveTokens, measure, policy, retainCurrentInput);
 }
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
-export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean }, ctx: ExtensionContext,
+/** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
+ * a run a custom message starts); the session has moved on from an ended run. */
+export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean }, ctx: ExtensionContext,
  reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true): Draft {
  const { isHistorySource, readable } = createRecall(policy);
 	const projected = ctx.sessionManager.buildSessionProjection();
@@ -102,10 +104,14 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         const calls = new Set(response.message.content.flatMap(block => block.type === "toolCall" ? [block.id] : []));
         const hasFreshReceipt = entries.slice(lastResponse + 1).some(entry => entry.type === "message" &&
             entry.message.role === "toolResult" && calls.has(entry.message.toolCallId));
-        freshRound = hasFreshReceipt;
+        // Fresh means the receipts are the answer the next request of this run carries. Once the session has moved on (the cut is planned for a
+        // run that has not begun, or a prompt has arrived since them) they are ordinary history, whatever ended their run: a reply discarded
+        // or one Pi hid when it recovered. Kept native, a receipt that never fits would refuse every later prompt. A retry is inside its run.
+        const superseded = input.newPrompt || entries.slice(lastResponse + 1).some(entry => entry.type === "message" && entry.message.role === "user");
+        freshRound = hasFreshReceipt && !superseded;
         const keptId = cut.firstKeptEntryId;
         const chosenBoundary = cut.compactAll ? entries.length : entries.findIndex(entry => entry.id === keptId);
-        if (hasFreshReceipt && lastResponse < chosenBoundary) {
+        if (freshRound && lastResponse < chosenBoundary) {
             const prefix = tuck.buildOwnCut(entries.slice(0, lastResponse), 0);
             if (!prefix.ok) return { unavailable: "No reducible history before the fresh tool round" };
             cut = { ...cut, messages: prefix.messages, selectedIds: prefix.selectedIds,