@itookit/dsht 0.3.8 → 0.5.2

package/dist/session/history-reader.d.ts

@@ -0,0 +1,32 @@
+import type { HostAccess } from '../transport/host.ts';
+import { Transcript } from './transcript.ts';
+import type { HistorySearch } from './types.ts';
+interface Selection {
+    sessionId: string;
+    revision: number;
+    record: Transcript;
+}
+/** History reads cannot navigate, change status, or write another domain's state. */
+export interface HistoryHost extends Pick<HostAccess, 'require' | 'online' | 'signal'> {
+    selected(): Selection;
+    current(selection: Selection): boolean;
+    owns(transcript: Transcript): boolean;
+    changed(): void;
+}
+export declare class HistoryReader {
+    private readonly host;
+    private readonly tasks;
+    constructor(host: HistoryHost);
+    /** A selection change cancels everything; closing one detached window cancels only its pages. */
+    cancel(source?: Transcript): void;
+    settle(): Promise<void>;
+    private read;
+    waitForHistory(signal: AbortSignal): Promise<void>;
+    older(signal?: AbortSignal, transcript?: Transcript): Promise<void>;
+    private page;
+    historyThrough(target: number | 'first', signal: AbortSignal): Promise<void>;
+    searchHistory(query: string, signal: AbortSignal): Promise<HistorySearch>;
+    /** The returned window belongs to the caller until it is installed as the reading view. */
+    historyAt(target: number, signal: AbortSignal): Promise<Transcript>;
+}
+export {};

package/dist/session/history-reader.js

@@ -0,0 +1,170 @@
+/** Selected-session history I/O, with cancellation tied to the record or window being read. */
+import { setTimeout as delay } from 'node:timers/promises';
+import { object } from "../json.js";
+import { toolLine } from "../text.js";
+import { Transcript } from "./transcript.js";
+const SEARCH_MATCH_LIMIT = 200;
+export class HistoryReader {
+    host;
+    tasks = new Set();
+    constructor(host) {
+        this.host = host;
+    }
+    /** A selection change cancels everything; closing one detached window cancels only its pages. */
+    cancel(source) {
+        for (const task of this.tasks)
+            if (source === undefined || task.source === source)
+                task.abort.abort();
+    }
+    async settle() { await Promise.allSettled([...this.tasks].map(task => task.promise)); }
+    read(caller, source, work, discard) {
+        const abort = new AbortController();
+        const signal = AbortSignal.any([abort.signal, this.host.signal(), ...(caller ? [caller] : [])]);
+        // Register before dispatch so even a synchronous observer can cancel this operation.
+        const task = { abort, source, promise: Promise.resolve() };
+        const promise = Promise.resolve().then(async () => {
+            signal.throwIfAborted();
+            const selected = this.host.selected();
+            const check = () => {
+                signal.throwIfAborted();
+                if (!this.host.online() || !this.host.current(selected))
+                    throw new Error('Session changed while reading history');
+                if (source !== undefined && !this.host.owns(source))
+                    throw new Error('History window closed');
+            };
+            check();
+            const value = await work({ ...selected, client: this.host.require(), signal, check });
+            try {
+                check();
+                return value;
+            }
+            catch (error) {
+                discard?.(value);
+                throw error;
+            }
+        }).finally(() => { this.tasks.delete(task); });
+        task.promise = promise;
+        this.tasks.add(task);
+        return promise;
+    }
+    waitForHistory(signal) {
+        return this.read(signal, undefined, async (context) => {
+            const deadline = Date.now() + context.client.timeoutMs;
+            while (!context.record.ready) {
+                context.check();
+                if (Date.now() >= deadline)
+                    throw new Error('Session snapshot timed out');
+                await delay(20, undefined, { signal: context.signal });
+            }
+            context.check();
+        });
+    }
+    older(signal, transcript) {
+        return this.read(signal, transcript, context => this.page(context, transcript ?? context.record));
+    }
+    async page(context, transcript) {
+        context.check();
+        if (!transcript.ready || !transcript.hasMore || transcript.beforeSeq === undefined)
+            return;
+        const before = transcript.beforeSeq;
+        const result = await context.client.call('session/page', { request: {
+                address: { kind: 'session', sessionId: context.sessionId }, throughSeq: transcript.cursor,
+                beforeSeq: before, maxMessages: 80,
+            } }, context.signal);
+        context.check();
+        if (!this.host.owns(transcript))
+            throw new Error('History window closed');
+        transcript.addPage(result);
+        this.host.changed();
+        if (transcript.hasMore && (transcript.beforeSeq === undefined || transcript.beforeSeq >= before)) {
+            throw new Error('Host history page did not advance');
+        }
+    }
+    historyThrough(target, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const transcript = context.record;
+            if (!transcript.ready)
+                throw new Error('Wait for the session snapshot');
+            while (transcript.hasMore && (target === 'first' || transcript.beforeSeq !== undefined && transcript.beforeSeq > target)) {
+                await this.page(context, transcript);
+            }
+        });
+    }
+    searchHistory(query, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const source = context.record;
+            if (!source.ready)
+                throw new Error('Wait for the session snapshot');
+            const throughSeq = source.readThrough;
+            const needle = query.toLowerCase();
+            const result = { items: [], truncated: false };
+            const scan = (transcript) => {
+                const messages = transcript.messages;
+                for (let index = messages.length - 1; index >= 0; index--) {
+                    context.check();
+                    const message = messages[index];
+                    if (message.role === 'Tool')
+                        continue;
+                    const text = message.text;
+                    const match = text.toLowerCase().indexOf(needle);
+                    if (match < 0)
+                        continue;
+                    if (result.items.length === SEARCH_MATCH_LIMIT) {
+                        result.truncated = true;
+                        return false;
+                    }
+                    result.items.push({ seq: message.seq, role: message.role,
+                        preview: Buffer.from(toolLine(text.slice(Math.max(0, match - 40), match + needle.length + 100), 160)).toString('utf8') });
+                }
+                return true;
+            };
+            if (!scan(source))
+                return result;
+            let beforeSeq = source.beforeSeq;
+            let hasMore = source.hasMore;
+            while (hasMore && beforeSeq !== undefined) {
+                const page = object(await context.client.call('session/page', { request: {
+                        address: { kind: 'session', sessionId: context.sessionId }, throughSeq, beforeSeq, maxMessages: 80,
+                    } }, context.signal));
+                context.check();
+                const temporary = new Transcript();
+                try {
+                    temporary.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+                    const next = temporary.beforeSeq;
+                    if (temporary.hasMore && (next === undefined || next >= beforeSeq))
+                        throw new Error('Host history page did not advance');
+                    if (!scan(temporary))
+                        return result;
+                    beforeSeq = next;
+                    hasMore = temporary.hasMore;
+                }
+                finally {
+                    temporary.dispose();
+                }
+            }
+            return result;
+        });
+    }
+    /** The returned window belongs to the caller until it is installed as the reading view. */
+    historyAt(target, signal) {
+        return this.read(signal, undefined, async (context) => {
+            const throughSeq = context.record.readThrough;
+            const page = object(await context.client.call('session/page', { request: {
+                    address: { kind: 'session', sessionId: context.sessionId }, throughSeq,
+                    beforeSeq: target + 1, maxMessages: 80,
+                } }, context.signal));
+            context.check();
+            const window = new Transcript();
+            try {
+                window.accept({ type: 'snapshot', cursor: throughSeq, assistantStream: { revision: 0 }, records: page.records, hasMore: page.hasMore });
+                if (!window.messages.some(message => message.seq === target))
+                    throw new Error('The host did not return the requested message');
+                return window;
+            }
+            catch (error) {
+                window.dispose();
+                throw error;
+            }
+        }, window => window.dispose());
+    }
+}

package/dist/session/history.d.ts

@@ -14,24 +14,6 @@ export interface HistoryRow {
     /** Draw the row on the theme's local-command bar, used by `!` commands. */
     highlight?: boolean;
 }
-/** Wrap text into rows with the per-kind trimming rule.
- * @param text - Text to wrap.
- * @param width - Available terminal columns.
- * @param kind - Part kind, which decides whether wrapped lines are trimmed.
- * @param seq - Durable sequence, for committed parts.
- * @returns The wrapped rows.
- */
-/** Wrap plain local text into terminal rows, preserving its own whitespace.
- *
- * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
- * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
- * @param text - Raw text, possibly containing newlines.
- * @param width - Available terminal columns.
- * @param kind - Row kind used for coloring.
- * @param highlight - Whether the rows are a local command line drawn on the command bar.
- * @returns One row per wrapped terminal line; empty text yields one empty row.
- */
-export declare function plainRows(text: string, width: number, kind: RowKind, highlight?: boolean): HistoryRow[];
 /** Drop all terminal rows and layout metadata for an evicted or inactive transcript.
  * @param transcript - Transcript whose previously returned layout is no longer used.
  */
@@ -59,6 +41,12 @@ export declare function layoutStats(transcript: Transcript): {
  * @param liveReasoning - Fold mode for completed live blocks; below 60 content columns it also folds active reasoning.
  * @returns Row count, sequence offsets, and a viewport reader; `lines` materializes all rows for exports only.
  */
+/** Plain view of one laid-out record: the projection engine's only public product.
+ *
+ * It exposes rows through `viewport` and message positions through `offsets`, so a caller can render
+ * a window without holding the record itself.
+ */
+export type SessionRender = ReturnType<typeof historyLayout>;
 export declare function historyLayout(transcript: Transcript, width: number, reasoning?: Reasoning, overrides?: ReadonlySet<number>, liveReasoning?: Reasoning): {
     messages: Message[];
     offsets: Map<number, number>;

package/dist/session/history.js

@@ -1,7 +1,7 @@
 /** Indexed semantic history with bounded terminal-row caching and viewport-only materialization. */
 import wrapAnsi from 'wrap-ansi';
-import { toolLine } from "./transcript.js";
 import { hasMarkdown, markdownRows } from "./markdown.js";
+import { toolLine } from "../text.js";
 /** A session owns one layout cache; dropped sessions release their entire cache. */
 class LayoutIndex {
     width;
@@ -140,21 +140,6 @@ const liveRows = new WeakMap();
  * @param seq - Durable sequence, for committed parts.
  * @returns The wrapped rows.
  */
-/** Wrap plain local text into terminal rows, preserving its own whitespace.
- *
- * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
- * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
- * @param text - Raw text, possibly containing newlines.
- * @param width - Available terminal columns.
- * @param kind - Row kind used for coloring.
- * @param highlight - Whether the rows are a local command line drawn on the command bar.
- * @returns One row per wrapped terminal line; empty text yields one empty row.
- */
-export function plainRows(text, width, kind, highlight = false) {
-    const columns = Math.max(1, width);
-    const wrapped = wrapAnsi(text === '' ? ' ' : text, columns, { hard: true, trim: false });
-    return wrapped.split('\n').map(line => ({ text: line, kind, ...(highlight ? { highlight: true } : {}) }));
-}
 function wrapRows(text, width, kind, seq) {
     return wrapAnsi(text, width, { hard: true, trim: !['tool', 'success', 'error'].includes(kind) })
         .split('\n').map(text => ({ text, kind, seq }));
@@ -295,14 +280,6 @@ export function layoutStats(transcript) {
         return undefined;
     return { ...index.stats(), liveWraps: index.liveWraps.size, liveMarkdown: index.liveMarkdown.size };
 }
-/** Lay out an indexed conversation without concatenating its historical rows on every stream frame.
- * @param transcript - Selected session's semantic content and unfinished assistant output.
- * @param width - Available terminal columns.
- * @param reasoning - Global committed/completed reasoning fold mode.
- * @param overrides - Sequences whose fold mode differs from the global mode; replace the set on changes.
- * @param liveReasoning - Fold mode for completed live blocks; below 60 content columns it also folds active reasoning.
- * @returns Row count, sequence offsets, and a viewport reader; `lines` materializes all rows for exports only.
- */
 export function historyLayout(transcript, width, reasoning = 'row', overrides = noOverrides, liveReasoning = reasoning) {
     let index = indexes.get(transcript);
     if (!index || index.width !== width || index.reasoning !== reasoning || index.overrides !== overrides) {

package/dist/session/index.d.ts

@@ -1,6 +1,9 @@
 /** Session domain: the selected session, its transcript, layout, telemetry and navigation. */
 export { SessionController } from './controller.ts';
-export { contentText, toolLine, Transcript } from './transcript.ts';
+export { SessionMutationGate } from './mutation-gate.ts';
+export type { MutationAdmission, MutationLane } from './mutation-gate.ts';
+export { contentText, Transcript } from './transcript.ts';
+export { toolLine } from '../text.ts';
 export type { LivePhase, Message, MessagePart, ThoughtEntry } from './transcript.ts';
 export { historyLayout, layoutStats, releaseHistoryLayout } from './history.ts';
 export { markdownCacheStats } from './markdown.ts';
@@ -10,9 +13,11 @@ export type { QueuedInput } from './telemetry.ts';
 export { DEFAULT_HISTORY_LIMITS, historyLimits } from './memory.ts';
 export type { HistoryLimits } from './memory.ts';
 export { DEFAULT_PROMPT_LIMITS, promptText, PromptIndex, SessionInfo } from './info.ts';
-export type { ComposerState, InteractionState, ModelState, OptionState, PanelState, PromptEntry, PromptLimits, PromptRecord, ReferenceState, ViewState } from './info.ts';
-export { navigationCommand, resolveTarget, sessionLabel } from './navigation.ts';
-export { activeReference, fileMention, fileReferences } from './references.ts';
+export type { InteractionState, OptionState, PromptEntry, PromptLimits, PromptRecord, } from './info.ts';
+export { resolveTarget } from './navigation.ts';
+export { sessionLabel } from '../session-title.ts';
+export { fileReferences } from './references.ts';
+export { activeReference, fileMention } from '../references.ts';
 export type { FileReference } from './references.ts';
 export { saveSessionLog } from './export.ts';
 export type { HistorySearch, RemovalTarget } from './types.ts';

package/dist/session/index.js

@@ -1,11 +1,15 @@
 /** Session domain: the selected session, its transcript, layout, telemetry and navigation. */
 export { SessionController } from "./controller.js";
-export { contentText, toolLine, Transcript } from "./transcript.js";
+export { SessionMutationGate } from "./mutation-gate.js";
+export { contentText, Transcript } from "./transcript.js";
+export { toolLine } from "../text.js";
 export { historyLayout, layoutStats, releaseHistoryLayout } from "./history.js";
 export { markdownCacheStats } from "./markdown.js";
 export { Telemetry } from "./telemetry.js";
 export { DEFAULT_HISTORY_LIMITS, historyLimits } from "./memory.js";
 export { DEFAULT_PROMPT_LIMITS, promptText, PromptIndex, SessionInfo } from "./info.js";
-export { navigationCommand, resolveTarget, sessionLabel } from "./navigation.js";
-export { activeReference, fileMention, fileReferences } from "./references.js";
+export { resolveTarget } from "./navigation.js";
+export { sessionLabel } from "../session-title.js";
+export { fileReferences } from "./references.js";
+export { activeReference, fileMention } from "../references.js";
 export { saveSessionLog } from "./export.js";

package/dist/session/info.d.ts

@@ -1,23 +1,6 @@
-/** Session-owned prompt index: every user prompt of the selected session, plus its recall cursor.
- *
- * The index replaces a plain bounded recall buffer. Each durable entry carries the sequence it came
- * from, so an entry evicted by the budgets stays recoverable: the loaded window refills anything the
- * transcript still holds, and `session/page` refetches anything older than the window. Budgets
- * therefore bound memory without deciding reachability — which is what a base-200 buffer got wrong.
- *
- * Locally submitted slash commands never become durable records, so they are retained too, marked as
- * non-durable. A durable echo of a locally recorded prompt upgrades that entry instead of adding a
- * second copy, keeping the refill boundary (the oldest durable sequence) exact.
- */
-import { type Reasoning } from './history.ts';
-import { Transcript } from './transcript.ts';
-import type { HistorySearch } from './types.ts';
-import type { ObjectValue } from '../transport/wire.ts';
-/** A durable user prompt as the transcript reports it, before retention. */
-export interface PromptRecord {
-    seq: number;
-    text: string;
-}
+import { Transcript, type PromptRecord } from './transcript.ts';
+export type { PromptRecord } from './transcript.ts';
+import type { AnswerValue } from './types.ts';
 /** One retained prompt: its text, plus the durable sequence when the host also recorded it. */
 export interface PromptEntry extends PromptRecord {
     durable: boolean;
@@ -31,61 +14,6 @@ export interface PromptLimits {
 export declare const DEFAULT_PROMPT_LIMITS: PromptLimits;
 /** Flatten one transcript prompt into the single line the composer recalls. */
 export declare function promptText(value: string): string;
-/** The selected session's composer: its draft, the caret in it, and a draft a dialog parked aside. */
-export interface ComposerState {
-    draft: string;
-    cursor: number;
-    parked: string;
-}
-/** How the selected session's record is being read: which window, where, and what is expanded.
- *
- * Everything here changes how the record renders, which is why it is session state rather than a
- * transient panel flag; the record's content stays in `Transcript`. `window` is a strong reference
- * released by `closeWindow`, and the layout cache keyed by it is a weak one.
- */
-export interface ViewState {
-    /** Detached record shown instead of the live transcript while reading jumped-to history. */
-    window?: Transcript;
-    scroll: number;
-    /** Reading protection: reclamation pauses until the reader returns to the live end. */
-    pinned: boolean;
-    /** Message sequences whose reasoning is expanded beyond the default fold. */
-    folds: ReadonlySet<number>;
-    /** Fold mode for the live attempt's completed reasoning. */
-    liveReasoning: Reasoning;
-}
-/** Composer-adjacent `@` reference menu: the highlighted row and the draft that dismissed it. */
-export interface ReferenceState {
-    index: number;
-    dismissed?: string;
-}
-/** Model dialog step: the catalog plus the provider or model being inspected. */
-export interface ModelState {
-    catalog: ObjectValue;
-    provider?: string;
-    model?: ObjectValue;
-}
-/** Panels the reader opened for the selected session.
- *
- * Only visibility and query text: every panel's rows come from the record, so closing one loses
- * nothing and a session switch may clear all of it. The row cursor inside a panel is not here — it
- * is focus, held by `Picker` and reset through its `key`.
- */
-export interface PanelState {
-    thoughts: boolean;
-    queue: boolean;
-    model?: ModelState;
-    history?: {
-        query: string;
-        contentSearch: boolean;
-        matches?: HistorySearch;
-    };
-    search?: {
-        query: string;
-        items: ObjectValue[];
-        hasMore: boolean;
-    };
-}
 /** Keyboard state of one pending question's options. */
 export interface OptionState {
     key: string;
@@ -98,7 +26,7 @@ export interface OptionState {
  *  `SessionController.interactions`, which is derived per session on every publish.
  */
 export interface InteractionState {
-    answers: Record<string, ObjectValue[]>;
+    answers: Record<string, AnswerValue['answers']>;
     option?: OptionState;
     approval?: {
         eventId: string;
@@ -107,7 +35,7 @@ export interface InteractionState {
 }
 /** Client-owned state of the selected session, reset whenever another session is opened.
  *
- * It holds the record, the prompt index, the composer, the reading view and the local interaction
+ * It holds the record, the prompt index, the reading view and the local interaction
  * state because all five belong to one session and none of them is owned by the host beyond what the
  * record mirrors; everything derivable from `Telemetry` or `CostLedger` stays out (see the design's
  * §5.7.6). The record is referenced here and nowhere else, so "the selected session" has one entry.
@@ -117,11 +45,9 @@ export declare class SessionInfo {
     /** The selected session's record. Replaced — never mutated in place — when another session opens. */
     record: Transcript;
     readonly prompts: PromptIndex;
-    readonly composer: ComposerState;
-    readonly view: ViewState;
+    /** Detached history window the reader jumped to; released by `closeWindow` and `reset`. */
+    window?: Transcript;
     readonly interaction: InteractionState;
-    readonly reference: ReferenceState;
-    readonly panels: PanelState;
     constructor(sessionId?: string);
     /** Forget everything a previous session owned, keeping this instance identity-stable for `State`. */
     reset(sessionId?: string): void;
@@ -143,6 +69,12 @@ export declare class PromptIndex {
     private shed;
     private position;
     private draft;
+    /** Prompts the client sent on the operator's behalf; their durable echo never enters recall.
+     *
+     * Kept across `reset()` so re-opening the session in the same process stays clean, and bounded
+     * because an agent loop can send a prompt per attempt.
+     */
+    private readonly internal;
     constructor(limits?: PromptLimits);
     /** Retained entry count, so a caller can tell an empty index from a parked cursor. */
     get length(): number;
@@ -167,8 +99,14 @@ export declare class PromptIndex {
      * live window holds, so the lazy backward step could not recover them.
      */
     markComplete(): void;
-    /** Forget one session's prompts and cursor. */
+    /** Forget one session's prompts and cursor; client-generated suppression is process-wide. */
     reset(): void;
+    /** Remember one prompt the client sent itself, so its durable echo never enters recall.
+     *
+     * An agent loop submits many turns; without this they would crowd out what the operator typed.
+     * @param value - Prompt text the client sent on the operator's behalf.
+     */
+    suppress(value: string): void;
     /** Fold one transcript scan: its prompts, plus the watermark it covered.
      *
      * The watermark advances even when the scan found no prompt, so a turn of assistant and tool

package/dist/session/info.js

@@ -15,11 +15,13 @@ import { Transcript } from "./transcript.js";
 export const DEFAULT_PROMPT_LIMITS = { maxEntries: 2000, maxBytes: 512 * 1024 };
 /** Longest single prompt worth recalling; a larger one is skipped rather than truncated in place. */
 const MAX_ENTRY_CHARS = 128 * 1024;
+/** Client-generated prompts remembered for recall suppression; a bounded run needs far fewer. */
+const MAX_INTERNAL_PROMPTS = 512;
 /** Flatten one transcript prompt into the single line the composer recalls. */
 export function promptText(value) { return value.replace(/\r?\n/g, ' ').trim(); }
 /** Client-owned state of the selected session, reset whenever another session is opened.
  *
- * It holds the record, the prompt index, the composer, the reading view and the local interaction
+ * It holds the record, the prompt index, the reading view and the local interaction
  * state because all five belong to one session and none of them is owned by the host beyond what the
  * record mirrors; everything derivable from `Telemetry` or `CostLedger` stays out (see the design's
  * §5.7.6). The record is referenced here and nowhere else, so "the selected session" has one entry.
@@ -29,11 +31,9 @@ export class SessionInfo {
     /** The selected session's record. Replaced — never mutated in place — when another session opens. */
     record = new Transcript();
     prompts = new PromptIndex();
-    composer = { draft: '', cursor: 0, parked: '' };
-    view = { scroll: 0, pinned: false, folds: new Set(), liveReasoning: 'row' };
+    /** Detached history window the reader jumped to; released by `closeWindow` and `reset`. */
+    window;
     interaction = { answers: {} };
-    reference = { index: 0 };
-    panels = { thoughts: false, queue: false };
     constructor(sessionId = '') {
         this.sessionId = sessionId;
     }
@@ -45,32 +45,18 @@ export class SessionInfo {
         this.record.dispose();
         this.record = new Transcript();
         this.prompts.reset();
-        this.composer.draft = '';
-        this.composer.cursor = 0;
-        this.composer.parked = '';
-        this.view.scroll = 0;
-        this.view.pinned = false;
-        this.view.folds = new Set();
-        this.view.liveReasoning = 'row';
         this.interaction.answers = {};
         this.interaction.option = undefined;
         this.interaction.approval = undefined;
-        this.reference.index = 0;
-        this.reference.dismissed = undefined;
-        this.panels.thoughts = false;
-        this.panels.queue = false;
-        this.panels.model = undefined;
-        this.panels.history = undefined;
-        this.panels.search = undefined;
     }
     /** Release the detached history window, if the reader has one open. */
     closeWindow() {
-        const window = this.view.window;
+        const window = this.window;
         if (!window)
             return;
         releaseHistoryLayout(window);
         window.dispose();
-        this.view.window = undefined;
+        this.window = undefined;
     }
 }
 /** Seq-ordered prompts with a recall cursor, owned by the selected session.
@@ -88,6 +74,12 @@ export class PromptIndex {
     shed = false;
     position;
     draft = '';
+    /** Prompts the client sent on the operator's behalf; their durable echo never enters recall.
+     *
+     * Kept across `reset()` so re-opening the session in the same process stays clean, and bounded
+     * because an agent loop can send a prompt per attempt.
+     */
+    internal = new Set();
     constructor(limits = DEFAULT_PROMPT_LIMITS) {
         this.limits = limits;
     }
@@ -122,7 +114,7 @@ export class PromptIndex {
      */
     markComplete() { if (!this.shed)
         this.complete = true; }
-    /** Forget one session's prompts and cursor. */
+    /** Forget one session's prompts and cursor; client-generated suppression is process-wide. */
     reset() {
         this.entries = [];
         this.bytes = 0;
@@ -132,6 +124,24 @@ export class PromptIndex {
         this.position = undefined;
         this.draft = '';
     }
+    /** Remember one prompt the client sent itself, so its durable echo never enters recall.
+     *
+     * An agent loop submits many turns; without this they would crowd out what the operator typed.
+     * @param value - Prompt text the client sent on the operator's behalf.
+     */
+    suppress(value) {
+        const text = promptText(value);
+        if (!text)
+            return;
+        this.internal.delete(text);
+        this.internal.add(text);
+        while (this.internal.size > MAX_INTERNAL_PROMPTS) {
+            const oldest = this.internal.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.internal.delete(oldest);
+        }
+    }
     /** Fold one transcript scan: its prompts, plus the watermark it covered.
      *
      * The watermark advances even when the scan found no prompt, so a turn of assistant and tool
@@ -154,7 +164,10 @@ export class PromptIndex {
      * @param value - Submitted command text; consecutive repeats coalesce.
      */
     record(value) {
-        const entry = { seq: this.newestSeq, text: promptText(value), durable: false };
+        const text = promptText(value);
+        if (this.internal.has(text))
+            return;
+        const entry = { seq: this.newestSeq, text, durable: false };
         if (!this.retainable(entry) || this.entries.at(-1)?.text === entry.text)
             return;
         this.entries.push(entry);
@@ -166,8 +179,16 @@ export class PromptIndex {
      * @returns How many entries were actually retained.
      */
     prepend(values) {
+        const oldest = this.oldest;
+        const seen = new Set();
         const older = values.map(value => ({ seq: value.seq, text: promptText(value.text), durable: true }))
-            .filter(value => this.retainable(value));
+            .filter(value => {
+            if (oldest !== undefined && value.seq >= oldest || seen.has(value.seq)
+                || this.internal.has(value.text) || !this.retainable(value))
+                return false;
+            seen.add(value.seq);
+            return true;
+        });
         if (!older.length)
             return 0;
         this.entries = [...older, ...this.entries];
@@ -213,7 +234,8 @@ export class PromptIndex {
     /** Retain one durable prompt; a durable echo upgrades a local entry instead of duplicating it. */
     push(value) {
         const entry = { seq: value.seq, text: promptText(value.text), durable: true };
-        if (!this.retainable(entry))
+        // A prompt the client itself sent (an agent loop) is durable history, but not composer recall.
+        if (this.internal.has(entry.text) || !this.retainable(entry))
             return;
         const last = this.entries.at(-1);
         if (last && last.text === entry.text) {
@@ -227,10 +249,15 @@ export class PromptIndex {
     }
     /** Drop the oldest entries until both budgets hold; a dropped prefix stays reloadable. */
     trim() {
+        let removed = 0;
         while (this.entries.length > this.limits.maxEntries || this.bytes > this.limits.maxBytes) {
             this.bytes -= this.entries.shift().text.length * 2;
+            removed++;
             this.shed = true;
+            this.complete = false;
         }
+        if (this.position !== undefined)
+            this.position = Math.max(0, this.position - removed);
     }
 }
 /** Bytes of prompt text the process keeps across sessions before evicting the least recently used. */