pi-tuck 1.0.21 → 1.0.23

package/dist/src/request-capacity.d.ts

@@ -0,0 +1,14 @@
+import type { SessionEntry } from '@earendil-works/pi-coding-agent';
+import type { Messages } from './budget.js';
+/** Read Pi's private safety allowance through its public clamp, rather than copying it.
+ * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
+ */
+export declare function piContextSafetyMargin(): Promise<number>;
+/** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
+export declare const REPLY_FLOOR_MIN = 3584;
+/** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
+export declare function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number;
+/** Admission never promises more output than a model with a positive reply cap can produce. */
+export declare function requestReplyFloor(branch: readonly SessionEntry[], reserve: number, maxTokens?: number): number;
+/** Check decoded text, including a whole verbatim user quote in our summary; never JSON-escaped substring matching. */
+export declare function carriesPrompt(messages: Messages, prompt: string): boolean;

package/dist/src/request-capacity.js

@@ -0,0 +1,57 @@
+import { isContextOverflow, normalizeContext } from '@earendil-works/pi-ai';
+import { parseRecords, splitSummary } from './tuck/core/transcript.js';
+/** Read Pi's private safety allowance through its public clamp, rather than copying it.
+ * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
+ */
+export async function piContextSafetyMargin() {
+    try {
+        const [{ clampMaxTokensToContext }, { estimateContextTokens }] = await Promise.all([
+            import('@earendil-works/pi-ai/api/simple-options'), import('@earendil-works/pi-ai/utils/estimate'),
+        ]);
+        const window = 1_000_000, context = normalizeContext({ messages: [] });
+        const margin = window - estimateContextTokens(context).tokens - clampMaxTokensToContext({ contextWindow: window, maxTokens: window }, context, window);
+        if (!Number.isSafeInteger(margin) || margin < 0 || margin >= window)
+            throw new Error('Invalid Pi context margin');
+        return margin;
+    }
+    catch {
+        return 4_096;
+    }
+}
+/** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
+export const REPLY_FLOOR_MIN = 3_584;
+/** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
+export function branchReplyFloor(branch, reserve) {
+    let largest = REPLY_FLOOR_MIN;
+    for (const entry of branch) {
+        if (entry.type !== 'message' || entry.message.role !== 'assistant')
+            continue;
+        const message = entry.message;
+        if (message.stopReason === 'length' || message.stopReason === 'error' && isContextOverflow(message))
+            return reserve;
+        const output = message.usage?.output;
+        if (typeof output === 'number' && Number.isFinite(output) && output > largest)
+            largest = output;
+    }
+    return Math.min(reserve, Math.ceil(largest));
+}
+/** Admission never promises more output than a model with a positive reply cap can produce. */
+export function requestReplyFloor(branch, reserve, maxTokens) {
+    const floor = branchReplyFloor(branch, reserve);
+    return maxTokens !== undefined && maxTokens > 0 ? Math.min(floor, maxTokens) : floor;
+}
+/** Check decoded text, including a whole verbatim user quote in our summary; never JSON-escaped substring matching. */
+export function carriesPrompt(messages, prompt) {
+    if (!prompt.length)
+        return true;
+    return messages.some(message => {
+        if (message.role === 'user') {
+            const text = typeof message.content === 'string' ? message.content : message.content.flatMap(block => block.type === 'text' ? [block.text] : []).join('\n');
+            return text.includes(prompt);
+        }
+        if (message.role !== 'compactionSummary')
+            return false;
+        const split = splitSummary(message.summary);
+        return split !== null && split !== undefined && parseRecords(split.body, split.version).some(record => record.kind === 'excerpt' && record.role === 'user' && record.text.includes(prompt));
+    });
+}

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

@@ -129,7 +129,9 @@ export declare function healDelayMs(attempts: number, integrity: boolean, delays
 export type SemanticState = 'disabled' | 'unavailable' | 'preparing' | 'ready' | 'waiting';
 /** Where the current view starts, as a branch position: the latest compaction entry's first kept entry. Earlier entries were compacted away. With no compaction, nothing is out of view. */
 export declare function viewStart(branch: SessionEntry[]): number;
-export declare function semanticEligibleSources(ctx: Pick<ExtensionContext, 'sessionManager' | 'cwd'>, policy: RecallPolicy, access: () => void): Snapshot;
+/** `pendingKeptId`: the first kept entry of a cut pi-tuck has applied to the requests but Pi has not yet saved (a prompt's cut is saved at the end of
+ * the first turn). Tools in that turn see the history as the model does: everything before that entry is out of view. */
+export declare function semanticEligibleSources(ctx: Pick<ExtensionContext, 'sessionManager' | 'cwd'>, policy: RecallPolicy, access: () => void, pendingKeptId?: string): Snapshot;
 export declare class SemanticRecallController {
     private readonly timing;
     private readonly ownerId;
@@ -294,6 +296,9 @@ export declare class SemanticRecallController {
     /** A plan for this snapshot that is fully indexed or, for a search, has all its out-of-view conversation indexed. The tool output behind it and the in-view tail are not worth waiting for: they keep indexing in the background and the coverage statement says how far they got.
     * With no out-of-view conversation (no cut) nothing waits: the search returns at once. Only a window whose out-of-view part is tool output alone still waits for the whole window. */
     private readyFor;
+    /** A search may rank a plan its own snapshot has grown from (every source in the plan still eligible, unchanged), as long as the session has not
+     * moved since the search took that snapshot; a move during the search still fails it. Indexing keeps the exact `recheck`. */
+    private recheckGrown;
     private recheck;
     private joinPreparation;
     search(query: string, provider: () => Snapshot, signal?: AbortSignal, prior?: PriorResult[], words?: any): Promise<SemanticPage>;

package/dist/src/semantic-recall.js

@@ -427,6 +427,15 @@ export function viewStart(branch) {
 }
 const TOOL_OUTPUT = new Set(['toolResult', 'bashExecution']);
 const isToolOutput = (source) => TOOL_OUTPUT.has(source.row.role);
+/** Whether `now` only grew from `plan`: the same session and project, and every source the plan ranks still eligible with the same hash. */
+function grownFrom(now, plan) {
+    if (now.session !== plan.session || now.project !== plan.project)
+        return false;
+    if (now.id === plan.id)
+        return true;
+    const shas = new Map(now.sources.map(source => [source.entry.id, source.sha]));
+    return plan.sources.every(source => shas.get(source.entry.id) === source.sha);
+}
 /** Sources in the order they are covered: out-of-view conversation (user messages, assistant text, tool-call names and arguments), then out-of-view tool output, then what is in view.
  * Each part is newest first, extending backward. */
 function windowOrder(snapshot) {
@@ -464,7 +473,9 @@ function windowCoverage(snapshot, prefix = indexedPrefix(snapshot)) {
     return { indexedCharacters, windowCharacters: window.windowCharacters, outOfViewCharacters: window.conversationOutOfView + window.toolOutOfView, eligibleCharacters: window.eligibleCharacters, oldestCoveredEntryId: oldest?.entry.id ?? null, oldestCoveredTime: time(oldest),
         conversation: { indexedCharacters: conversation, outOfViewCharacters: window.conversationOutOfView }, toolResults: { indexedCharacters: tools, outOfViewCharacters: window.toolOutOfView, oldestCoveredTime: time(oldestTool) } };
 }
-export function semanticEligibleSources(ctx, policy, access) {
+/** `pendingKeptId`: the first kept entry of a cut pi-tuck has applied to the requests but Pi has not yet saved (a prompt's cut is saved at the end of
+ * the first turn). Tools in that turn see the history as the model does: everything before that entry is out of view. */
+export function semanticEligibleSources(ctx, policy, access, pendingKeptId) {
     try {
         access();
     }
@@ -486,8 +497,9 @@ export function semanticEligibleSources(ctx, policy, access) {
     const orders = new Map(branch.map((entry, order) => [entry.id, order]));
     const sources = eligible.flatMap(entry => { const order = orders.get(entry.id); const row = recall.discoveryEntry(entry, attempts, links); if (!row)
         return []; const { sourceText: unusedText, ranges: unusedRanges, ...readable } = row; return [{ entry, row: readable, sourceText: row.sourceText, ranges: row.ranges, order, sha: hash({ entry, order, row: readable, ranges: row.ranges, index: indices.get(entry.id) }) }]; });
-    const session = ctx.sessionManager.getSessionId(), id = hash({ session, project: resolve(ctx.cwd), branch: branch.map(e => [e.id, e.parentId]), sources: sources.map(s => [s.entry.id, s.sha]) });
-    return { id, session, project: ctx.cwd, sources, units: [], complete: false, throughEntryId: sources.at(-1)?.entry.id ?? null, viewStart: viewStart(branch), indexed: new Set() };
+    const pending = pendingKeptId === undefined ? -1 : branch.findIndex(e => e.id === pendingKeptId), start = Math.max(viewStart(branch), pending);
+    const session = ctx.sessionManager.getSessionId(), id = hash({ session, project: resolve(ctx.cwd), branch: branch.map(e => [e.id, e.parentId]), sources: sources.map(s => [s.entry.id, s.sha]), ...(pending >= 0 ? { pendingKeptId } : {}) });
+    return { id, session, project: ctx.cwd, sources, units: [], complete: false, throughEntryId: sources.at(-1)?.entry.id ?? null, viewStart: start, indexed: new Set() };
 }
 export class SemanticRecallController {
     timing;
@@ -647,11 +659,19 @@ export class SemanticRecallController {
         return this.worker;
     }
     path(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'); }
-    async index(action, snapshot, extra = {}) { 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; }
+    async index(action, snapshot, extra = {}, boundId) { 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) {
+        if (boundId !== undefined)
+            this.recheckGrown(this.provider, snapshot, boundId);
+        else
+            this.recheck(this.provider, snapshot);
+    } /* a search's scoring may read a plan its snapshot grew from */ /* a search's scoring may read a plan its snapshot grew from */ 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) {
+        if (boundId !== undefined)
+            this.recheckGrown(this.provider, snapshot, boundId);
+        else
+            this.recheck(this.provider, snapshot);
+    } return result; }
     async prepare(provider, full = true) {
         if (!this.enabled)
             return;
@@ -801,6 +821,10 @@ export class SemanticRecallController {
     /** A plan for this snapshot that is fully indexed or, for a search, has all its out-of-view conversation indexed. The tool output behind it and the in-view tail are not worth waiting for: they keep indexing in the background and the coverage statement says how far they got.
     * With no out-of-view conversation (no cut) nothing waits: the search returns at once. Only a window whose out-of-view part is tool output alone still waits for the whole window. */
     readyFor(id, forSearch) { const plan = this.current; return Boolean(plan && plan.id === id && (plan.complete || (forSearch && plan.window !== undefined && plan.window.searchUnits > 0 && plan.units.slice(0, plan.window.searchUnits).every(unit => plan.indexed.has(unit.key))))); }
+    /** A search may rank a plan its own snapshot has grown from (every source in the plan still eligible, unchanged), as long as the session has not
+     * moved since the search took that snapshot; a move during the search still fails it. Indexing keeps the exact `recheck`. */
+    recheckGrown(provider, snapshot, boundId) { const now = provider(); if (now.id !== boundId || !grownFrom(now, snapshot))
+        throw new Error('Eligible branch or source changed before semantic admission'); }
     recheck(provider, snapshot) { const now = provider(); if (now.id !== snapshot.id || now.session !== snapshot.session || now.project !== snapshot.project)
         throw new Error('Eligible branch or source changed before semantic admission'); }
     async joinPreparation(deadline, signal) {
@@ -868,22 +892,25 @@ export class SemanticRecallController {
                 const prepared = !this.task || await this.joinPreparation(deadline, signal);
                 if (signal?.aborted || queryGeneration !== this.generation)
                     throw abort();
-                if (!prepared || performance.now() >= deadline)
-                    return incomplete();
-                this.error = null;
-                this.schedule(provider);
+                if (prepared && performance.now() < deadline) {
+                    this.error = null;
+                    this.schedule(provider);
+                    await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
+                }
             }
-            else if (!this.current.complete) {
-                this.error = null;
-                this.schedule(provider);
+            else {
+                if (!this.current.complete) {
+                    this.error = null;
+                    this.schedule(provider);
+                }
+                await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
             }
-            await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
             if (signal?.aborted || queryGeneration !== this.generation)
                 throw abort();
         }
         // Ranking needs a plan for the bound snapshot and an indexed prefix; the coverage statement describes exactly that prefix and nothing else is ranked, so a search that reaches its wait limit with part of the window indexed ranks that part. Only an empty prefix is `indexing_incomplete`.
-        const snapshot = this.current;
-        if (!snapshot || snapshot.id !== bound.id || (snapshot.units.length ? indexedPrefix(snapshot) === 0 : !snapshot.complete)) {
+        const snapshot = this.current, older = snapshot !== undefined && snapshot.id !== bound.id && grownFrom(bound, snapshot);
+        if (!snapshot || (snapshot.id !== bound.id && !older) || (snapshot.units.length ? indexedPrefix(snapshot) === 0 : !snapshot.complete)) {
             const failure = this.error ?? this.healReason;
             return failure && !CHURN.test(failure) ? unavailable() : incomplete();
         }
@@ -891,15 +918,15 @@ export class SemanticRecallController {
             return { status: 'no_matches', notice: 'No eligible original source units in this snapshot.', coverage: this.status(), method: 'embedding', groups: [] };
         try {
             const worker = await this.runtime(snapshot.project);
-            this.recheck(provider, snapshot);
+            this.recheckGrown(provider, snapshot, bound.id);
             const encoded = await worker.call('embed', { texts: [query], kind: 'query' }, signal);
             this.operations.queryEmbeddings++;
-            this.recheck(provider, snapshot);
+            this.recheckGrown(provider, snapshot, bound.id);
             const prefix = indexedPrefix(snapshot), stored = snapshot.units.slice(0, prefix), byKey = new Map(stored.map(u => [u.key, u])), covered = windowCoverage(snapshot, prefix);
             let ranked = [], observed = 0;
             for (let offset = 0; offset < stored.length; offset += SCORE_CHUNK) {
-                this.recheck(provider, snapshot);
-                const scored = await this.index('score', snapshot, { keys: stored.slice(offset, offset + SCORE_CHUNK).map(u => u.key), query: encoded.vectors[0] });
+                this.recheckGrown(provider, snapshot, bound.id);
+                const scored = await this.index('score', snapshot, { keys: stored.slice(offset, offset + SCORE_CHUNK).map(u => u.key), query: encoded.vectors[0] }, bound.id);
                 observed += scored.observed;
                 ranked.push(...scored.ranked.map(row => ({ unit: byKey.get(row.key), score: row.score })));
                 ranked.sort((a, b) => b.score - a.score);
@@ -912,7 +939,7 @@ export class SemanticRecallController {
                 throw new Error('Snapshot index coverage changed');
             if (signal?.aborted || queryGeneration !== this.generation || !this.enabled)
                 throw abort();
-            this.recheck(provider, snapshot);
+            this.recheckGrown(provider, snapshot, bound.id);
             const final = provider();
             const finalSources = new Map(final.sources.map(source => [source.entry.id, source.sha]));
             if (snapshot.sources.some(source => finalSources.get(source.entry.id) !== source.sha))
@@ -920,7 +947,7 @@ export class SemanticRecallController {
             // What the caller already read only spares it a repeat. A reference that does not match this history spares nothing, and it must not fail the search.
             const usable = prior.filter(reference => { const source = snapshot.sources.find(s => s.entry.id === reference.entryId); return Number.isSafeInteger(reference.start) && Number.isSafeInteger(reference.end) && reference.start <= reference.end && source !== undefined && reference.sourceSha === source.sha && reference.end <= source.sourceText.length; }), ignored = prior.length - usable.length;
             const previous = [...usable, ...(words?.hits ?? []).map((hit) => ({ entryId: hit.entryId, start: hit.read.offset, end: hit.read.offset + hit.read.limit, sourceSha: snapshot.sources.find(s => s.entry.id === hit.entryId)?.sha }))];
-            return { status: 'ok', notice: 'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.' + (ignored ? ` ${ignored} of the priorResults did not match this history and were ignored, so their text may appear again.` : '') + ` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime ?? covered.oldestCoveredTime ?? 'an unknown time'}); use tuck_recall for the rest.`, coverage: { ...this.status(), window: covered }, method: 'embedding', groups: this.assemble(ranked.map(hit => hit.unit), snapshot, previous) };
+            return { status: 'ok', notice: 'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.' + (ignored ? ` ${ignored} of the priorResults did not match this history and were ignored, so their text may appear again.` : '') + ` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime ?? covered.oldestCoveredTime ?? 'an unknown time'}); use tuck_recall for the rest.` + (older ? ` This ranking covers the history through entry ${snapshot.throughEntryId}: later entries are still being indexed, so search them by keyword.` : ''), coverage: { ...this.status(), window: covered }, method: 'embedding', groups: this.assemble(ranked.map(hit => hit.unit), snapshot, previous) };
         }
         catch (error) {
             if (error instanceof Error && error.name === 'SemanticAccessError') {

package/dist/src/tuck/core/search-entries.js

@@ -16,8 +16,8 @@ const startBudget = () => {
     const deadline = Date.now() + SEARCH_BUDGET_MS;
     return () => {
         if (Date.now() > deadline) {
-            throw new Error(`Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms. Simplify the pattern — ` +
-                "nested quantifiers such as (a+)+ can make matching blow up.");
+            throw new Error(`Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms on this history. ` +
+                "Use more specific words, or read an entry by index.");
         }
     };
 };

package/dist/src/tuck.d.ts

@@ -74,7 +74,7 @@ export interface Tuck {
 import { compileDialogue } from "./tuck/core/summarize.js";
 export declare const tuck: Tuck;
 /** 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, newPrompt?: boolean): Draft;
+export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean, protectedPromptEntryId?: string): 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.
@@ -86,6 +86,7 @@ export declare function tuckObservedDraft(tuck: Tuck, input: {
     operatorManual?: boolean;
     newPrompt?: boolean;
     reRenderSummary?: boolean;
+    protectedPromptEntryId?: string;
 }, 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

@@ -19,8 +19,8 @@ import { prepareKeywordQuery } from "./tuck/core/keyword-query.js";
 import { searchEntriesDetailed } from "./tuck/core/search-entries.js";
 export const tuck = { buildOwnCut, applyTailBudget, calibrateCharsPerToken, buildGlobalIndexById, compileDialogue, prepareKeywordQuery, searchEntriesDetailed };
 /** 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, newPrompt = false) {
-    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt }, ctx, reserveTokens, measure, policy, retainCurrentInput);
+export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false, protectedPromptEntryId) {
+    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt, protectedPromptEntryId }, 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
@@ -115,6 +115,9 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     const current = entries[userPosition];
     const userContent = current?.type === "message" && current.message.role === "user" ? current.message.content : undefined;
     const textOnly = isTextOnly(userContent);
+    // Steering can become the latest user source while the run still owns its original prompt.
+    const startingPosition = entries.findIndex(entry => entry.id === input.protectedPromptEntryId && entry.type === "message" && entry.message.role === "user");
+    const starting = entries[startingPosition];
     // Anchor the actual first source only; a native omission never promotes a later prompt.
     const firstUser = branch.find(entry => entry.type === "message" && entry.message.role === "user");
     const firstUserPosition = entries.findIndex(entry => entry.id === firstUser?.id && entry.type === "message");
@@ -277,8 +280,10 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             };
             if (userPosition >= 0 && userPosition < boundary && textOnly)
                 add(current, Infinity);
+            if (startingPosition >= 0 && startingPosition < boundary && starting?.id !== current?.id)
+                add(starting, Infinity);
             for (const entry of anchors)
-                if (entry.id !== current?.id && positions.get(entry.id) < boundary)
+                if (entry.id !== current?.id && entry.id !== starting?.id && positions.get(entry.id) < boundary)
                     add(entry, length);
             const omissions = [];
             for (const role of ["user", "assistant", "toolResult"]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Deterministic compaction for Pi with no model call, plus exact recall of earlier history. Search by meaning on Apple silicon.",
   "keywords": [
     "pi-package",

package/src/build-id.ts

@@ -1 +1 @@
-export const BUILD_ID = "82df9e9954f1d33eb2d6c6c653220c13bd3c36c2f0250afa2a17ab51295cfb0c";
+export const BUILD_ID = "37e6c0132f0638bca430bc165bef86ac4814e136c47e4672e06b086310a2de70";