pi-tuck 1.0.26 → 1.0.28

package/src/request-capacity.ts

@@ -62,20 +62,26 @@ export const thinkingOnlyLength = (message: AgentMessage): boolean => message.ro
 export const needsFullReplyReserve = (message: AgentMessage): boolean => message.role === 'assistant' &&
     (message.stopReason === 'length' && !thinkingOnlyLength(message) || message.stopReason === 'error' && isContextOverflow(message));
 
-/** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
-export function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number {
-    let largest = REPLY_FLOOR_MIN, thinkingStop = false;
+/** One branch reader for the reserve override and reply floor, including history before cuts. */
+export function replyFit(branch: readonly SessionEntry[]): { failed: boolean; largestOutput: number; thinkingStop: boolean } {
+    let failed = false, largestOutput = 0, thinkingStop = false;
     for (const entry of branch) {
         if (entry.type !== 'message' || entry.message.role !== 'assistant') continue;
         const message = entry.message;
-        if (needsFullReplyReserve(message)) return reserve;
+        failed ||= needsFullReplyReserve(message);
         thinkingStop ||= thinkingOnlyLength(message);
         const output = message.usage?.output;
-        if (typeof output === 'number' && Number.isFinite(output) && output > largest) largest = output;
+        if (typeof output === 'number' && Number.isFinite(output) && output > largestOutput) largestOutput = output;
     }
-    // Include the exhausted thinking reply itself, even across later cuts/restarts. Its observed output must fit again;
-    // requestReplyFloor applies the model cap. Ordinary branches retain their existing reserve cap.
-    return thinkingStop ? Math.ceil(largest) : Math.min(reserve, Math.ceil(largest));
+    return { failed, largestOutput, thinkingStop };
+}
+
+export function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number {
+    const { failed, largestOutput, thinkingStop } = replyFit(branch);
+    if (failed) return reserve;
+    // Include exhausted thinking output across cuts/restarts; requestReplyFloor applies the model cap.
+    const largest = Math.ceil(Math.max(REPLY_FLOOR_MIN, largestOutput));
+    return thinkingStop ? largest : Math.min(reserve, largest);
 }
 
 /** Admission never promises more output than a model with a positive reply cap can produce. */
@@ -84,17 +90,17 @@ export function requestReplyFloor(branch: readonly SessionEntry[], reserve: numb
     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: Messages, prompt: string): boolean {
+/** Check decoded starting text, native or quoted whole with its original role; never JSON-escaped substring matching. */
+export function carriesPrompt(messages: Messages, prompt: string, role: 'user' | 'custom' = 'user'): boolean {
     if (!prompt.length) return true;
     return messages.some(message => {
-        if (message.role === 'user') {
+        if (message.role === role) {
             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));
+            record.kind === 'excerpt' && record.role === role && record.text.includes(prompt));
     });
 }

package/src/run.ts

@@ -0,0 +1,91 @@
+import { SessionManager, type ExtensionContext, type SessionEntry, type SessionBoundaryDraft } from '@earendil-works/pi-coding-agent';
+import { hasTuckCut } from './history-tools.js';
+import { viewStart } from './semantic-recall.js';
+import { textOf } from './tuck/core/content.js';
+import type { Clip } from './clip.js';
+
+export type CutEntry = { type: 'compaction'; summary: string; firstKeptEntryId: string; tokensBefore: number; details?: unknown };
+type Context = Pick<ExtensionContext, 'cwd' | 'sessionManager'>;
+export interface CutView { session: ExtensionContext['sessionManager']; keptFromId: string | undefined; viewStart: number; hasTuckCut: boolean; pending: boolean }
+
+/** The only owner of a cut that requests carry before Pi saves it. */
+export class PendingCut {
+    private cut?: CutEntry;
+    private branchLength = 0;
+    private preview?: { manager: Context['sessionManager']; cwd: string; leaf: string | null; view: CutView };
+    plan(cut: CutEntry, branchLength: number) { this.cut = cut; this.branchLength = branchLength; this.preview = undefined; }
+    clear() { this.cut = undefined; this.branchLength = 0; this.preview = undefined; }
+    take() { const cut = this.cut; this.clear(); return cut; }
+    view(ctx: Context, entries: readonly SessionBoundaryDraft[] = []): CutView {
+        const live = ctx.sessionManager, leaf = live.getLeafId?.(), held = this.preview;
+        // Native entries are append-only; a leaf move invalidates both the saved and pending views, as in the eligibility cache.
+        if (!entries.length && leaf !== undefined && held && held.manager === live && held.cwd === ctx.cwd && held.leaf === leaf) return held.view;
+        const branch = live.getBranch(), cut = this.cut;
+        const remember = (view: CutView) => {
+            if (!entries.length && leaf !== undefined) this.preview = { manager: live, cwd: ctx.cwd, leaf, view };
+            return view;
+        };
+        if (!cut && !entries.length) {
+            const last = branch.findLast(entry => entry.type === 'compaction');
+            return remember({ session: live, keptFromId: last?.type === 'compaction' ? last.firstKeptEntryId : undefined,
+                viewStart: viewStart(branch), hasTuckCut: hasTuckCut(branch), pending: false });
+        }
+        // A compact-all plan predates the prompt. Keep from the first appended entry, skipping our capacity receipts.
+        const keptFromId = cut && (cut.firstKeptEntryId || branch.slice(this.branchLength)
+            .find(entry => entry.type !== 'custom' || entry.customType !== 'pi-tuck-capacity')?.id || '');
+        const header = live.getHeader();
+        if (!header) throw new Error("Missing native session header for the prompt's cut");
+        const session = SessionManager.inMemory(ctx.cwd, undefined, [header, ...branch]);
+        if (cut) session.appendCompaction(cut.summary, keptFromId!, 0, cut.details, true);
+        // Retry/settlement drafts model the same request view, including an omitted failed reply.
+        for (const entry of entries) {
+            if (entry.type === 'context_edit') session.appendContextEdit(entry.targetId, entry.replacement);
+            else if (entry.type === 'compaction') session.appendCompaction(entry.summary, entry.firstKeptEntryId, 0, entry.details, true, entry.usage);
+            else if (entry.type === 'custom') session.appendCustomEntry(entry.customType, entry.data);
+            else session.appendCustomMessageEntry(entry.customType, entry.content, entry.display, entry.details);
+        }
+        const previewBranch = session.getBranch(), last = previewBranch.findLast(entry => entry.type === 'compaction');
+        return remember({ session, keptFromId: last?.type === 'compaction' ? last.firstKeptEntryId : undefined,
+            viewStart: viewStart(previewBranch), hasTuckCut: hasTuckCut(previewBranch), pending: Boolean(cut) });
+    }
+}
+
+/** Text bridges before Pi appends the starting message. Once visible, every reader uses its entry id.
+ * Bind on the first request/compaction read after message_end (which Pi emits before appending), before steering can replace it. */
+export class StartingPrompt {
+    private entryId?: string;
+    private bridge?: string;
+    constructor(bridge: string, private readonly branchLength: number, readonly role: 'user' | 'custom' = 'user') { this.bridge = bridge; }
+    id(branch: readonly SessionEntry[]) {
+        if (!this.entryId && this.bridge !== undefined) {
+            const text = this.bridge;
+            this.entryId = branch.slice(this.branchLength).find(entry => this.role === 'custom'
+                ? entry.type === 'custom_message' && textOf(entry.content) === text
+                : entry.type === 'message' && entry.message.role === 'user' && textOf(entry.message.content).includes(text))?.id;
+            if (this.entryId) this.bridge = undefined;
+        }
+        return this.entryId;
+    }
+    text(branch: readonly SessionEntry[]) {
+        const id = this.id(branch), entry = branch.find(entry => entry.id === id);
+        if (entry?.type === 'message' && entry.message.role === 'user') return textOf(entry.message.content);
+        if (entry?.type === 'custom_message') return textOf(entry.content);
+        if (this.bridge !== undefined) return this.bridge;
+        throw new Error('The starting prompt entry is no longer on this branch');
+    }
+}
+
+export interface Run {
+    phase: 'decided' | 'starting' | 'admitted' | 'failed';
+    claimed: boolean;
+    expired: boolean;
+    prompt?: StartingPrompt;
+    cut: PendingCut;
+    clips: Map<string, Clip>;
+    pendingBoundaryCommit: boolean;
+    thinkingRetryPending: boolean;
+    failure?: Error;
+    refusalReceipted: boolean;
+}
+export const createRun = (phase: Run['phase']): Run => ({ phase, claimed: false, expired: false,
+    cut: new PendingCut(), clips: new Map(), pendingBoundaryCommit: false, thinkingRetryPending: false, refusalReceipted: false });

package/src/semantic-recall.ts

@@ -55,7 +55,7 @@ const expandedGroups = Symbol('expanded semantic groups');
 export interface SemanticEvidenceReference extends PriorResult {basis:'explicit prior or word result'|'earlier source text in this response';}
 export interface SemanticSourceEvidence extends ReadableEntry {sourceOrder?:number;sourceSha:string;textOffset:number;totalCharacters:number;read:{entryId:string;offset:number;limit:number};complete:boolean;evidenceReference?:SemanticEvidenceReference;notice?:string;}
 export interface SemanticGroup {sources:SemanticSourceEvidence[];notice:string;}
-export interface SemanticPage {status:string;notice:string;coverage:ReturnType<SemanticRecallController["status"]>;groups:SemanticGroup[];method?:string;}
+export interface SemanticPage {status:string;notice:string;coverage:ReturnType<SemanticRecallController["requestCoverage"]>;groups:SemanticGroup[];method?:string;}
 interface NativeReceipt {op:'settled';activeProcesses:0;exitCode:number|null;}
 const nativeBase64=/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 function nativeObject(text:string):Record<string,unknown>{
@@ -122,6 +122,32 @@ export function healDelayMs(attempts:number,integrity:boolean,delays:readonly nu
 /** Errors that mean "the history moved or a slice ended; try again", not that the runtime failed. They do not make the state `unavailable`. */
 const CHURN=/indexing incomplete|history changed|source changed before|branch or source changed|cancelled/i;
 export type SemanticState='disabled'|'unavailable'|'preparing'|'ready'|'waiting';
+export type SemanticSetup = 'off-settings' | 'off-user' | 'not-installed' | 'off-platform' | 'off-project' | 'starting' | 'failed' | 'ready';
+interface SetupDetail { installed?: boolean; reason?: string; stage?: 'setup' | 'start'; notice?: string; announced?: boolean }
+/** Setup and operator wording have one owner; runtime indexing state remains separate. */
+export function semanticSetupMessage(setup: SemanticSetup, detail: SetupDetail = {}): string | null {
+ switch (setup) {
+  case 'not-installed': return 'Semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works meanwhile';
+  case 'starting': return detail.installed ? 'Semantic recall is starting; word recall works meanwhile' : 'Semantic recall is being set up; word recall works meanwhile';
+  case 'failed': return detail.stage === 'start' ? detail.reason ?? 'Semantic recall could not start' : `Semantic recall setup failed: ${detail.reason}`;
+  default: return null;
+ }
+}
+export function semanticSetupNotice(setup: SemanticSetup, detail: SetupDetail = {}): { message: string; level: 'info' | 'warning' } | undefined {
+ let message: string | undefined, level: 'info' | 'warning' = 'info';
+ switch (setup) {
+  case 'off-platform': message = 'pi-tuck: semantic recall needs macOS on Apple silicon; compaction and word recall work.'; break;
+  case 'off-project': message = "pi-tuck: semantic recall is off here because Pi's agent folder is inside this folder; open Pi in a project folder to use it."; break;
+  case 'not-installed': message = 'pi-tuck: semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works.'; level = 'warning'; break;
+  case 'starting': message = detail.notice; break;
+  case 'ready': if (detail.announced) message = 'pi-tuck: semantic recall is set up. Search by meaning works from the first cut on.'; break;
+  case 'failed': message = detail.stage === 'start'
+   ? `pi-tuck: semantic recall could not start (${detail.reason}); it tries again when a session starts.`
+   : `pi-tuck: semantic recall setup failed (${detail.reason}). Word recall works; setup retries when a session starts.`; level = 'warning'; break;
+ }
+ return message ? { message, level } : undefined;
+}
+
 const PROBE_TEXT='pi-tuck semantic recall status probe';
 class LocalWorker {
  private nativeHelper=false;private jobId?:string;private helperReceipt?:()=>NativeReceipt|undefined;private nativeExit?:{code:number|null;signal:NodeJS.Signals|null};
@@ -232,12 +258,13 @@ export function semanticEligibleSources(ctx:Pick<ExtensionContext,'sessionManage
  const eligible=branch.filter(e=>!omitted.has(e.id)&&ids.get(e.id)===1),recall=createRecall(policy),attempts=recall.recallAttempts(eligible),links=recall.producerReads(eligible),indices=buildGlobalIndexById(all);
  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 pending=pendingKeptId===undefined?-1:branch.findIndex(e=>e.id===pendingKeptId),start=Math.max(viewStart(branch),pending);
+ const pending=pendingKeptId===undefined?-1:pendingKeptId===''?branch.length: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 {
  private readonly ownerId=randomUUID();private readonly indexFiles=new Set<string>();private closing?:Promise<void>;private joiningSearches=0;private activeSearches=new Set<Promise<SemanticPage>>();private config?:SemanticRecallConfig;private worker?:LocalWorker;private identity='';private provider?:()=>Snapshot;private generation=0;private cleanupError:string|null=null;private dirty=false;private operations={preparationEmbeddings:0,queryEmbeddings:0};
  // The fields below decide `status().state`; their setters announce a change to `onStateChange` listeners.
+ private setup: SemanticSetup = 'off-user'; private setupDetail: SetupDetail = {};
  private _enabled=false;private _current?:Snapshot;private _task?:Promise<void>;private _timer?:ReturnType<typeof setTimeout>;private _error:string|null=null;
  private get enabled(){return this._enabled;}private set enabled(value:boolean){this._enabled=value;this.touch();}
  private get current(){return this._current;}private set current(value:Snapshot|undefined){this._current=value;this.touch();}
@@ -259,14 +286,19 @@ export class SemanticRecallController {
  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{}});}
  /** A host that could not configure the runtime records why a requested start failed. The controller stays disabled and `lastError` carries the reason until the next `enable`. */
- refuse(reason:string){this.error=reason;}
+ setSetup(setup: SemanticSetup, detail: SetupDetail = {}) { const announced = setup === 'ready' && this.setupDetail.announced; this.setup = setup; this.setupDetail = announced ? { ...detail, announced: true } : detail; this.touch(); }
+ /** Compatibility for hosts that already record an external start failure. */
+ refuse(reason:string){this.setSetup('failed', { stage: 'start', reason });}
+ setupNotice(){return semanticSetupNotice(this.setup, this.setupDetail);}
  configure(config:SemanticRecallConfig){if(this.enabled||this.worker||this.task)throw new Error('Disable before changing semantic configuration');for(const [key,max] of [['queryWaitMs',120000],['prepareWorkMs',120000],['maxUnits',MAX_INDEX_UNITS],['maxSourceCharacters',2000000]] as const){const value=config[key];if(value!==undefined&&(!Number.isSafeInteger(value)||value<1||value>max))throw new Error('Invalid bounded semantic configuration: '+key);}if('rerank' in config)throw new Error('Obsolete rerank configuration: this release supports embeddings only');for(const key of ['pythonPath','runtimeRoot','indexDirectory'] as const)if(typeof config[key]!=='string'||!config[key])throw new Error('Invalid semantic runtime configuration');if(config.scratchDirectory!==undefined&&(typeof config.scratchDirectory!=='string'||!config.scratchDirectory||!isAbsolute(config.scratchDirectory)))throw new Error('Invalid semantic scratchDirectory; absolute directory required');if(config.nativeOwnerHelperPath!==undefined&&(typeof config.nativeOwnerHelperPath!=='string'||!config.nativeOwnerHelperPath||!isAbsolute(config.nativeOwnerHelperPath)))throw new Error('Invalid semantic nativeOwnerHelperPath; absolute verified helper required');const normalized={...config,pythonPath:resolve(config.pythonPath),runtimeRoot:resolve(config.runtimeRoot),indexDirectory:resolve(config.indexDirectory),...(config.scratchDirectory===undefined?{}:{scratchDirectory:resolve(config.scratchDirectory)})};outsideRuntime(normalized.runtimeRoot,normalized.indexDirectory,'index');outsideRuntime(normalized.runtimeRoot,scratchParent(normalized),'scratch');this.config=normalized;}
  /** Ordinary external settings remain caller-selected/outside-project. The
   * optional override is a current-process verified dependency, not Task data. */
  async configureExternal(project:string,selectedPath=runtimeConfigPath(defaultRoot()),runtime?:{nativeOwnerHelperPath?:string}){const path=resolve(selectedPath);outsideProject(project,path,'configuration');if(runtime?.nativeOwnerHelperPath!==undefined)outsideProject(project,runtime.nativeOwnerHelperPath,'runtime');const text=await readFile(path,'utf8').catch((error:NodeJS.ErrnoException)=>{throw error.code==='ENOENT'?new Error('Semantic recall is not set up yet: pi-tuck sets it up when a session starts, unless pi-tuck.json turns it off'):error;});
   this.configure({...JSON.parse(text) as SemanticRecallConfig,...(runtime?.nativeOwnerHelperPath===undefined?{}:{nativeOwnerHelperPath:runtime.nativeOwnerHelperPath})});}
- enable(){if(this.closing||this.joiningSearches||this.cleanupError)throw new Error('Semantic cleanup is unresolved; retry close before enable');if(!this.config)throw new Error('Optional local semantic runtime is not configured');this.enabled=true;this.error=null;this.healReason=null;this.healAttempts=0;this.cancelHeal();if(this.provider&&this.active)this.schedule(this.provider);}
- status(){return{enabled:this.enabled,configured:Boolean(this.config),cleanupError:this.cleanupError,state:(!this.enabled?'disabled':this.healReason!==null||(this.error!==null&&!CHURN.test(this.error))?'unavailable':this.task||this.timer?'preparing':this.current?.complete?'ready':'waiting') as SemanticState,snapshotId:this.current?.id??null,throughEntryId:this.current?.throughEntryId??null,eligibleSources:this.current?.sources.length??0,totalUnits:this.current?.units.length??0,coveredUnits:this.current?.indexed.size??0,indexingComplete:Boolean(this.current?.complete),lastError:this.error??this.healReason,window:this.current?windowCoverage(this.current):null,recovery:this.healReason===null?null:{attempts:this.healAttempts,integrity:this.healIntegrity,retryAt:this.healRetryAt===null?null:new Date(this.healRetryAt).toISOString()},operations:{...this.operations},limits:{keyword:16000,broad:20000}};}
+ enable(){if(this.closing||this.joiningSearches||this.cleanupError)throw new Error('Semantic cleanup is unresolved; retry close before enable');if(!this.config)throw new Error('Optional local semantic runtime is not configured');this.setSetup('ready');this.enabled=true;this.error=null;this.healReason=null;this.healAttempts=0;this.cancelHeal();if(this.provider&&this.active)this.schedule(this.provider);}
+ status(){return{setup:this.setup,setupMessage:semanticSetupMessage(this.setup,this.setupDetail),enabled:this.enabled,configured:Boolean(this.config),cleanupError:this.cleanupError,state:(!this.enabled?'disabled':this.healReason!==null||(this.error!==null&&!CHURN.test(this.error))?'unavailable':this.task||this.timer?'preparing':this.current?.complete?'ready':'waiting') as SemanticState,snapshotId:this.current?.id??null,throughEntryId:this.current?.throughEntryId??null,eligibleSources:this.current?.sources.length??0,totalUnits:this.current?.units.length??0,coveredUnits:this.current?.indexed.size??0,indexingComplete:Boolean(this.current?.complete),lastError:this.error??this.healReason??semanticSetupMessage(this.setup,this.setupDetail),window:this.current?windowCoverage(this.current):null,recovery:this.healReason===null?null:{attempts:this.healAttempts,integrity:this.healIntegrity,retryAt:this.healRetryAt===null?null:new Date(this.healRetryAt).toISOString()},operations:{...this.operations},limits:{keyword:16000,broad:20000}};}
+ /** The existing model-facing coverage contract: setup metadata belongs to operator status, not the request. */
+ requestCoverage(){const {setup,setupMessage,...coverage}=this.status();return coverage;}
  schedule(provider:()=>Snapshot){this.provider=provider;if(!this.enabled||this.timer||!this.active||this.healTimer)return;this.timer=setTimeout(()=>{this.timer=undefined;if(this.task){this.dirty=true;return;}this.task=this.prepare(provider,this.fullIndexing).catch(async error=>{if(this.quietStop||!this.enabled)return;this.error=error instanceof Error?error.message:'local failure';if(error instanceof Error&&error.name==='SemanticAccessError'){this.enabled=false;this.generation++;this.dirty=false;try{await this.closeResources();}catch(cleanup){this.cleanupError=cleanup instanceof Error?cleanup.message:'Semantic cleanup failed';this.error=this.cleanupError;}}else this.heal(error);}).finally(()=>{this.task=undefined;if(this.enabled&&this.dirty){this.dirty=false;this.error=null;this.schedule(this.provider!);}});},5);}
  /** A saved cut has moved entries out of view: start indexing them now, for a session that has searched before but is not searching now, or whose worker the idle limit stopped. Awaits nothing; a failure goes to `heal` like any preparation.
   * Only a session that ran a search earlier (`searched`) indexes at a cut: a host may give every session its own controller and worker, so indexing at every node's cut could run several encoders at once on a 16 GB machine.
@@ -355,27 +387,27 @@ export class SemanticRecallController {
   finally{if(timer)clearTimeout(timer);if(onAbort)signal?.removeEventListener('abort',onAbort);}
  }
  search(query:string,provider:()=>Snapshot,signal?:AbortSignal,prior:PriorResult[]=[],words?:any):Promise<SemanticPage>{const task=this.searchOwned(query,provider,signal,prior,words);this.activeSearches.add(task);const settled=()=>{this.activeSearches.delete(task);this.armIdle();};void task.then(settled,settled);return task;}
- private async searchOwned(query:string,provider:()=>Snapshot,signal?:AbortSignal,prior:PriorResult[]=[],words?:any):Promise<SemanticPage>{if(signal?.aborted)throw abort();if(!this.enabled)return{status:'disabled',notice:'Optional semantic recall is disabled; ordinary word recall remains available.',coverage:this.status(),groups:[]};
+ private async searchOwned(query:string,provider:()=>Snapshot,signal?:AbortSignal,prior:PriorResult[]=[],words?:any):Promise<SemanticPage>{if(signal?.aborted)throw abort();if(!this.enabled)return{status:'disabled',notice:'Optional semantic recall is disabled; ordinary word recall remains available.',coverage:this.requestCoverage(),groups:[]};
   this.demand();this.searched=true;
-  const deadline=performance.now()+(this.config!.queryWaitMs??30000),incomplete=():SemanticPage=>({status:'indexing_incomplete',notice:'No semantic ranking performed: nothing of the requested eligible snapshot is indexed yet.',coverage:this.status(),groups:[]}),
-   unavailable=():SemanticPage=>({status:'unavailable',notice:'Local semantic preparation unavailable; permitted ordinary recall remains available.',coverage:this.status(),groups:[]});
+  const deadline=performance.now()+(this.config!.queryWaitMs??30000),incomplete=():SemanticPage=>({status:'indexing_incomplete',notice:'No semantic ranking performed: nothing of the requested eligible snapshot is indexed yet.',coverage:this.requestCoverage(),groups:[]}),
+   unavailable=():SemanticPage=>({status:'unavailable',notice:'Local semantic preparation unavailable; permitted ordinary recall remains available.',coverage:this.requestCoverage(),groups:[]});
   const queryGeneration=this.generation;let bound:Snapshot;try{bound=provider();}catch(error){await this.revoked(error);throw error;}this.provider=provider;if(this.healTimer)return unavailable(); // a retry is waiting: it owns the next attempt, a search does not bypass the backoff
   // Nothing out of view (no cut yet, or the cut kept everything): the whole history is in the agent's context, so a search never waits for indexing, and the query never starts a worker itself (background preparation may). It ranks what an already running worker has indexed, else it says so at once; a recorded failure is still reported as unavailable, as on the waiting path.
   if(bound.sources.every(source=>source.order>=bound.viewStart)){
    const failure=this.error??this.healReason,failed=failure!==null&&!CHURN.test(failure),planned=this.current?.id===bound.id&&this.current.complete,page=failed?unavailable():null; // built before the retry clears the error, so the page's coverage reports it
    if(!planned){this.error=null;this.schedule(provider);}
-   if(!(this.current?.id===bound.id&&((this.current.complete&&!this.current.units.length)||(indexedPrefix(this.current)>0&&this.worker!==undefined&&!this.recycle&&!this.idling)))){if(page)return page;return{status:'indexing_incomplete',notice:'No semantic ranking performed: nothing is out of view, so the whole history is in your context.',coverage:this.status(),groups:[]};}
+   if(!(this.current?.id===bound.id&&((this.current.complete&&!this.current.units.length)||(indexedPrefix(this.current)>0&&this.worker!==undefined&&!this.recycle&&!this.idling)))){if(page)return page;return{status:'indexing_incomplete',notice:'No semantic ranking performed: nothing is out of view, so the whole history is in your context.',coverage:this.requestCoverage(),groups:[]};}
   }else{
   if(this.current?.id!==bound.id){const prepared=!this.task||await this.joinPreparation(deadline,signal);if(signal?.aborted||queryGeneration!==this.generation)throw abort();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);}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,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();}
-  if(!snapshot.units.length)return{status:'no_matches',notice:'No eligible original source units in this snapshot.',coverage:this.status(),method:'embedding',groups:[]};
+  if(!snapshot.units.length)return{status:'no_matches',notice:'No eligible original source units in this snapshot.',coverage:this.requestCoverage(),method:'embedding',groups:[]};
   try{const worker=await this.runtime(snapshot.project);this.recheckGrown(provider,snapshot,bound.id);const encoded=await worker.call('embed',{texts:[query],kind:'query'},signal);this.operations.queryEmbeddings++;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:{unit:Unit;score:number}[]=[],observed=0;for(let offset=0;offset<stored.length;offset+=SCORE_CHUNK){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) as {ranked:{key:string;score:number}[];observed:number};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);ranked=ranked.slice(0,24);if(signal?.aborted)throw abort();await yieldWork();}if(observed!==stored.length)throw new Error('Snapshot index coverage changed');
    if(signal?.aborted||queryGeneration!==this.generation||!this.enabled)throw abort();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))throw new Error('Eligible source changed or access revoked before return');
    // 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:any)=>({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.`+(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'){await this.revoked(error);throw error;}if(signal?.aborted||queryGeneration!==this.generation||error instanceof Error&&error.name==='AbortError'){await this.cancelled();throw abort();}this.heal(error);return{status:'unavailable',notice:'Local semantic search failed; ordinary recall remains available. '+(error instanceof Error?error.message:'failure'),coverage:this.status(),groups:[]};}
+   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:any)=>({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.`+(older?` This ranking covers the history through entry ${snapshot.throughEntryId}: later entries are still being indexed, so search them by keyword.`:''),coverage:{...this.requestCoverage(),window:covered},method:'embedding',groups:this.assemble(ranked.map(hit=>hit.unit),snapshot,previous)};
+  }catch(error){if(error instanceof Error&&error.name==='SemanticAccessError'){await this.revoked(error);throw error;}if(signal?.aborted||queryGeneration!==this.generation||error instanceof Error&&error.name==='AbortError'){await this.cancelled();throw abort();}this.heal(error);return{status:'unavailable',notice:'Local semantic search failed; ordinary recall remains available. '+(error instanceof Error?error.message:'failure'),coverage:this.requestCoverage(),groups:[]};}
  }
  private assemble(units:Unit[],snapshot:Snapshot,previous:PriorResult[]):SemanticGroup[]{
   // Collapse coordinate overlap only; disjoint evidence in one entry remains independent.
@@ -405,7 +437,7 @@ export class SemanticRecallController {
   return{source,start,end};
  }
  private evidence(source:Source,start:number,end:number){return{...source.row,sourceOrder:source.order,sourceSha:source.sha,text:source.sourceText.slice(start,end),textOffset:start,totalCharacters:source.sourceText.length,read:{entryId:source.entry.id,offset:start,limit:end-start},complete:start===0&&end===source.sourceText.length};}
- async disable(joinSearches=true){if(joinSearches)this.joiningSearches++;try{if(!this.closing){const stop=this.stopOwner();this.closing=stop;void stop.finally(()=>{if(this.closing===stop)this.closing=undefined;}).catch(()=>{});}await this.closing;if(joinSearches)await Promise.allSettled([...this.activeSearches]);}finally{if(joinSearches)this.joiningSearches--;}}
+ async disable(joinSearches=true, userOff=true){if(userOff)this.setSetup('off-user');if(joinSearches)this.joiningSearches++;try{if(!this.closing){const stop=this.stopOwner();this.closing=stop;void stop.finally(()=>{if(this.closing===stop)this.closing=undefined;}).catch(()=>{});}await this.closing;if(joinSearches)await Promise.allSettled([...this.activeSearches]);}finally{if(joinSearches)this.joiningSearches--;}}
  private async closeResources(){this.fullIndexing=false;this.cancelHeal();this.cancelIdle();this.active=false;this.healReason=null;this.healAttempts=0;this.recycle=false;const worker=this.worker;await worker?.close();await Promise.all([...this.indexFiles].flatMap(path=>[path,path+'-wal',path+'-shm']).map(path=>rm(path,{force:true})));this.indexFiles.clear();if(this.worker===worker)this.worker=undefined;this.identity='';this.current=undefined;this.tokenized.clear();this.cleanupError=null;}
  private async stopOwner(){this.dirty=false;this.enabled=false;this.generation++;if(this.timer){clearTimeout(this.timer);this.timer=undefined;}try{await this.closeResources();await this.task;this.task=undefined;}catch(error){this.cleanupError=error instanceof Error?error.message:'Semantic cleanup failed';throw error;}}
 
@@ -458,7 +490,7 @@ export class SemanticRecallController {
  // A source that can no longer be read stops recall; the reason stays readable until the next enable, so this never looks like recall that was never on.
  private async revoked(error:unknown){await this.disable(false);this.error=error instanceof Error?error.message:'Source access denied';}
  async invalidate(){await this.disable();this.error='Caller invalidated semantic source access; explicit enable required';}
- async close(){await this.disable();this.provider=undefined;this.searched=false;} // a closed controller serves a new session, which has not searched; a disable and enable keeps it
+ async close(){await this.disable(true,false);this.provider=undefined;this.searched=false;} // a closed controller serves a new session, which has not searched; a disable and enable keeps it
 }
 export const createSemanticRecall=(config?:SemanticRecallConfig)=>new SemanticRecallController(config);
 /** Consolidate only source-bound coordinate overlap; equal text in distinct events is retained.

package/src/status.ts

@@ -16,6 +16,7 @@ export function statusText(input: {
     version: string;
     active: boolean;
     branch: readonly { type: string; tokensBefore?: unknown; details?: unknown; customType?: unknown; data?: unknown }[];
+    pending?: boolean;
     cutAt: number | undefined;
     search: boolean;
     semantic: { state: SemanticState; lastError: string | null };
@@ -24,7 +25,7 @@ export function statusText(input: {
     const cuts = input.branch.filter(e => e.type === "compaction"), ours = cuts.filter(e => (e.details as { compactor?: unknown } | null | undefined)?.compactor === "pi-tuck");
     const last = ours.at(-1), before = last?.tokensBefore, after = (last?.details as { tokensAfter?: unknown } | undefined)?.tokensAfter;
     const count = (n: number) => n.toLocaleString("en-US");
-    const cutLine = ours.length === 0 ? "Cuts: none yet in this session. The recall tools appear after the first cut."
+    const cutLine = ours.length === 0 ? input.pending ? "Cuts: none saved yet in this session." : "Cuts: none yet in this session. The recall tools appear after the first cut."
         : `Cuts: ${ours.length} by pi-tuck in this session` + (typeof before === "number" && typeof after === "number" ? `, the last from ${count(before)} to ${count(after)} tokens.` : ".");
     const native = cuts.length - ours.length;
     const retries = input.branch.filter(entry => entry.type === "custom" && entry.customType === "pi-tuck-capacity" &&
@@ -37,6 +38,7 @@ export function statusText(input: {
         `pi-tuck ${input.version} (the version this session loaded; restart Pi after an update).`,
         cutLine,
         ...(retries ? [`Retries: ${retries} after thinking-only length stops in this session.`] : []),
+        ...(input.pending ? ["A cut is pending: requests already carry it; the first boundary saves it."] : []),
         ...(native > 0 ? [`Pi's own compaction cut ${native} time${native === 1 ? "" : "s"} in this session.`] : []),
         input.cutAt === undefined ? "Cut point: adapts by itself." : `Cut point: fixed at cutAt ${input.cutAt} of the input room. Remove cutAt from pi-tuck.json to let it adapt.`,
         searchLine,

package/src/tuck.ts

@@ -136,16 +136,17 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         if (!prefix.ok) return { unavailable: "No reducible history before the fresh shell output" };
         cut = cutBefore(cut, freshBash, prefix);
     }
-    // Preserve the actual latest user source, never an inferred task/decision.
-    // Explicit omission of it must not promote an earlier user source instead.
+    // The latest user source still owns first exposure and non-text native floors. An omission never promotes an older source.
     const latestUser = retainCurrentInput ? branch.findLast(entry => entry.type === "message" && entry.message.role === "user") : undefined;
-    const userPosition = entries.findIndex(entry => entry.id === latestUser?.id && entry.type === "message");
-    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];
+    const latestPosition = entries.findIndex(entry => entry.id === latestUser?.id && entry.type === "message");
+    const latest = entries[latestPosition];
+    const latestContent = latest?.type === "message" && latest.message.role === "user" ? latest.message.content : undefined;
+    const latestTextOnly = isTextOnly(latestContent);
+    // During a run, current input is the run owner's starting entry, even after steering. Manual cuts use the latest source.
+    const currentId = input.protectedPromptEntryId ?? latestUser?.id;
+    const currentPosition = entries.findIndex(entry => entry.id === currentId &&
+        (entry.type === "custom_message" || entry.type === "message" && entry.message.role === "user"));
+    const current = entries[currentPosition];
     // 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");
@@ -153,10 +154,10 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const selectedBoundary = cut.compactAll ? entries.length : entries.findIndex(entry => entry.id === selectedKeptId);
     // An unobserved input or non-text input stays native. Quoting cannot deliver
     // its pixels/unknown blocks, and must not count as first exposure.
-    if (userPosition >= 0 && userPosition < selectedBoundary && (!textOnly || userPosition > lastResponse)) {
-        const prefix = tuck.buildOwnCut(entries.slice(0, userPosition), 0);
+    if (latestPosition >= 0 && latestPosition < selectedBoundary && (!latestTextOnly || latestPosition > lastResponse)) {
+        const prefix = tuck.buildOwnCut(entries.slice(0, latestPosition), 0);
         if (!prefix.ok) return { unavailable: "No reducible history before the current user input" };
-        cut = cutBefore(cut, userPosition, prefix);
+        cut = cutBefore(cut, latestPosition, prefix);
     }
 
 	if (cut.messages.length !== cut.selectedIds.length || (!cut.compactAll && !entries.some((e) => e.id === cut.firstKeptEntryId)))
@@ -165,7 +166,7 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     let preferredBoundary = cut.compactAll ? entries.length : entries.findIndex(entry => entry.id === cut.firstKeptEntryId);
     let floorBoundary = freshRound ? lastResponse : entries.length;
     if (freshBash >= 0) floorBoundary = Math.min(floorBoundary, freshBash);
-    if (userPosition >= 0 && (!textOnly || userPosition > lastResponse)) floorBoundary = Math.min(floorBoundary, userPosition);
+    if (latestPosition >= 0 && (!latestTextOnly || latestPosition > lastResponse)) floorBoundary = Math.min(floorBoundary, latestPosition);
     // One fill owns the summary and the contiguous native suffix. Protocol/current-input
     // floors are representation constraints; every other source competes by rank.
     return rankedFill();
@@ -265,10 +266,12 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
             let cached = quoteCache.get(key);
             if (cached) return cached;
             const index = indices.get(entry.id);
-            const text = entry.type === "message" && entry.message.role === "user" ? textOf(entry.message.content) : "";
+            const text = entry.type === "custom_message" ? textOf(entry.content) : entry.type === "message" && entry.message.role === "user" ? textOf(entry.message.content) : "";
             const sourceTimes = index === undefined ? undefined : [{ sourceIndex: index, ...resolveSourceTime(entry) }];
-            const records: TranscriptRecord[] = index === undefined ? [] : take === Infinity
-                ? [{ kind: "excerpt", role: "user", sourceIndex: index, text, sourceTimes }]
+            // Custom entries have a native identity but no global message index.
+            const records: TranscriptRecord[] = index === undefined && entry.type !== "custom_message" ? [] : take === Infinity
+                ? [{ kind: "excerpt", role: entry.type === "custom_message" ? "custom" : "user", ...(index === undefined ? {} : { sourceIndex: index }), text, sourceTimes,
+                    ...(entry.type === "custom_message" ? { sourceEntryId: entry.id } : {}) }]
                 : userPrefixRecords({ kind: "user", text, originalText: text, startsSource: true, sourceIndex: index }, undefined, take).map(record => ({ ...record, sourceTimes }));
             cached = { records, cost: lineCost(records), whole: take >= text.length };
             quoteCache.set(key, cached);
@@ -282,9 +285,9 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
                 kept.push(...quoted.records); cost += quoted.cost;
                 if (index !== undefined && quoted.records.length) { selected.add(index); if (quoted.whole) whole.add(index); }
             };
-            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 && entry.id !== starting?.id && positions.get(entry.id)! < boundary) add(entry, length);
+            if (latestPosition >= 0 && latestPosition < boundary && latestTextOnly) add(latest!, Infinity);
+            if (currentPosition >= 0 && currentPosition < boundary && current?.id !== latest?.id) add(current!, Infinity);
+            for (const entry of anchors) if (entry.id !== latest?.id && entry.id !== current?.id && positions.get(entry.id)! < boundary) add(entry, length);
             const omissions: TranscriptRecord[] = [];
             for (const role of ["user", "assistant", "toolResult"] as const) {
                 const list = units[role], prefix = prefixes[role];
@@ -383,19 +386,23 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         for (const row of sourceRows) if (row.message.role === "user" && Array.isArray(row.message.content))
             imageLabels.set(row.index, new Set(row.message.content.flatMap(part => part.type === "image" ? [`[image: ${part.mimeType}]`] : [])));
         const compiledBoundary = boundary;
+        // A protected custom prompt uses its native entry ID in the same anchoring/movement path as indexed user prompts.
+        const sourceKey = (record: TranscriptRecord) => current?.type === "custom_message" && record.sourceEntryId === current.id ? current.id : record.sourceIndex;
         const assemble = (compiled: string, at = compiledBoundary) => {
             const split = compiled ? splitSummary(compiled) : undefined;
             if (compiled && !split) throw new Error("pi-tuck returned an invalid summary");
             const inputRecords = split ? parseRecords(split.body, split.version) : protectedView.omissions;
             const expanded = new Set(protectedView.kept.filter(record => record.kind === "excerpt" && inputRecords.some(row =>
-                row.kind === "excerpt" && row.role === "user" && row.sourceIndex === record.sourceIndex && row.text.startsWith(record.text!) && row.text.length >= record.text!.length)).map(record => record.sourceIndex));
-            const anchored = new Set(protectedView.kept.map(record => record.sourceIndex));
-            const moved = new Set(rows.filter(row => row.position >= at && row.position < compiledBoundary).map(row => row.index));
+                row.kind === "excerpt" && row.role === record.role && sourceKey(row) === sourceKey(record) && row.text.startsWith(record.text!) && row.text.length >= record.text!.length)).map(sourceKey));
+            const anchored = new Set(protectedView.kept.map(sourceKey));
+            const moved = new Set(rows.filter(row => row.position >= at && row.position < compiledBoundary).map(row =>
+                current?.type === "custom_message" && row.id === current.id ? row.id : row.index));
             const records = [...inputRecords.filter(record => {
-                if (record.sourceIndex !== undefined && moved.has(record.sourceIndex)) return false;
+                const key = sourceKey(record);
+                if (key !== undefined && moved.has(key)) return false;
                 if (record.kind === "excerpt" && record.role === "user" && imageLabels.get(record.sourceIndex)?.has(record.text)) return true;
-                return record.role !== "user" || record.sourceIndex === undefined || !anchored.has(record.sourceIndex) || expanded.has(record.sourceIndex);
-            }), ...protectedView.kept.filter(record => !expanded.has(record.sourceIndex) && !moved.has(record.sourceIndex))];
+                return record.role !== "user" && record.role !== "custom" || key === undefined || !anchored.has(key) || expanded.has(key);
+            }), ...protectedView.kept.filter(record => !expanded.has(sourceKey(record)) && !moved.has(sourceKey(record)))];
             // Mixed user turns keep their text opening, while their image
             // metadata remains in the ordinary lower-ranked dialogue lane.
             const wholeUser = new Set(records.filter(record => record.kind === "excerpt" && record.role === "user" && record.text === userTexts.get(record.sourceIndex)).map(record => record.sourceIndex));