dsh-ccgui 0.0.0-stage → 1.0.0

package/lib/session/drive-tool.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The body of the mirror tool: wait for the CLI's result of one call, answering the
+ * CLI's permission requests along the way.
+ * @module dsh-ccgui/session/drive-tool
+ */
+import type { ApprovalOutcome } from '@deepseek-ai/dsh-user-approval';
+import type { ToolOutcome } from '../tool-record.ts';
+import type { PermissionQueue } from './permission-queue.ts';
+import type { ToolMirror } from './tool-mirror.ts';
+/** A question for the harness about a blocked CLI call. */
+export interface PermissionAsk {
+    /** What the person deciding needs to know. */
+    readonly reason: string;
+    /** The call's id in the harness log; absent when the call has no card to attach to yet. */
+    readonly callId?: string;
+}
+/** Asks the harness whether a blocked CLI call may proceed. */
+export type AskPermission = (request: PermissionAsk, signal: AbortSignal) => Promise<ApprovalOutcome>;
+/** The session state a mirror works against. */
+export interface DriveContext {
+    readonly tools: ToolMirror;
+    readonly permissions: PermissionQueue;
+    /** CLI display name used in user-facing messages. */
+    readonly label: string;
+    /** Aborted when the current CLI turn ends, which withdraws any question still on screen. */
+    readonly turnSignal: () => AbortSignal;
+}
+/** One mirrored call. */
+export interface DrivenCall {
+    readonly acpId: string;
+    readonly callId: string;
+}
+/**
+ * Wait until the call finishes. Every open permission request is answered, not only the
+ * call's own: a parent call can be waiting on a child whose mirror cannot start until
+ * this one returns.
+ * @returns the finished call's outcome.
+ */
+export declare function driveTool(context: DriveContext, { acpId, callId }: DrivenCall, ask: AskPermission, signal: AbortSignal): Promise<ToolOutcome>;

package/lib/session/drive-tool.js

@@ -0,0 +1,37 @@
+/**
+ * The body of the mirror tool: wait for the CLI's result of one call, answering the
+ * CLI's permission requests along the way.
+ * @module dsh-ccgui/session/drive-tool
+ */
+import { abortable } from "../abortable.js";
+import { permissionResponse } from "../permission.js";
+import { isFinished, permissionReason, toolOutcome } from "../tool-record.js";
+/**
+ * Wait until the call finishes. Every open permission request is answered, not only the
+ * call's own: a parent call can be waiting on a child whose mirror cannot start until
+ * this one returns.
+ * @returns the finished call's outcome.
+ */
+export async function driveTool(context, { acpId, callId }, ask, signal) {
+    for (;;) {
+        signal.throwIfAborted();
+        const permission = context.permissions.takeNext();
+        if (permission !== undefined) {
+            const ownCallId = permission.acpId === acpId ? callId : undefined;
+            await answerPermission(context, permission, { callId: ownCallId, ask, signal });
+            continue;
+        }
+        const record = context.tools.get(acpId);
+        if (isFinished(record))
+            return toolOutcome(record);
+        await abortable(context.tools.nextChange(), signal);
+    }
+}
+async function answerPermission({ tools, label, turnSignal }, permission, { callId, ask, signal }) {
+    const record = tools.get(permission.acpId);
+    const reason = record === undefined ? `${label} 请求执行一个操作。` : permissionReason(record);
+    const askSignal = AbortSignal.any([signal, turnSignal()]);
+    // A failing approval service must not leave the CLI blocked; `unavailable` rejects.
+    const outcome = await ask({ reason, ...(callId === undefined ? {} : { callId }) }, askSignal).catch(() => 'unavailable');
+    permission.resolve(permissionResponse(outcome, permission.options));
+}

package/lib/session/model-state.d.ts

@@ -0,0 +1,40 @@
+/**
+ * What is known about a CLI session's model, and switching it to the harness's choice.
+ * @module dsh-ccgui/session/model-state
+ */
+import { readModelList } from '../model-options.ts';
+import type { CliModelList } from '../model-options.ts';
+import type { AcpTransport } from '../transport.ts';
+type ConfigOptions = Parameters<typeof readModelList>[0];
+/** Where a model switch is sent. */
+export interface ModelTarget {
+    readonly transport: AcpTransport;
+    readonly acpSessionId: string;
+    /** CLI display name used in user-facing messages. */
+    readonly label: string;
+}
+/** The model side of one CLI session. */
+export declare class ModelState {
+    private readonly knownModels?;
+    private optionId;
+    /** The model a new session started on, which the `default` selection stands for. */
+    private cliDefault;
+    /** The CLI's model as far as is known; unset while a change is unconfirmed. */
+    private active;
+    constructor(knownModels?: (() => CliModelList | undefined) | undefined);
+    /**
+     * Only a new session says what `default` stands for: a resumed one reports the model it
+     * was left on, which may be one the user chose.
+     */
+    adopt(options: ConfigOptions, isNewSession: boolean): void;
+    /** The CLI reported a change of its own. */
+    observe(options: ConfigOptions): void;
+    /**
+     * Switch the CLI to the harness's selection, unless it is already there.
+     * @param model - the selected model; omitted or `default` means the CLI's own.
+     * @param where - the session to switch.
+     * @param signal - cancellation for the wait.
+     */
+    apply(model: string | undefined, where: ModelTarget, signal: AbortSignal | undefined): Promise<void>;
+}
+export {};

package/lib/session/model-state.js

@@ -0,0 +1,68 @@
+/**
+ * What is known about a CLI session's model, and switching it to the harness's choice.
+ * @module dsh-ccgui/session/model-state
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { abortable } from "../abortable.js";
+import { DEFAULT_MODEL_ID } from "../constants.js";
+import { readModelList } from "../model-options.js";
+import { errorMessage } from "./outcomes.js";
+/** Used when a CLI reports no model option, as some do when resuming. */
+const CONVENTIONAL_MODEL_OPTION_ID = 'model';
+/** The model side of one CLI session. */
+export class ModelState {
+    knownModels;
+    optionId;
+    /** The model a new session started on, which the `default` selection stands for. */
+    cliDefault;
+    /** The CLI's model as far as is known; unset while a change is unconfirmed. */
+    active;
+    constructor(knownModels) {
+        this.knownModels = knownModels;
+    }
+    /**
+     * Only a new session says what `default` stands for: a resumed one reports the model it
+     * was left on, which may be one the user chose.
+     */
+    adopt(options, isNewSession) {
+        const list = readModelList(options);
+        this.optionId = list?.configId;
+        this.active = list?.current;
+        if (isNewSession)
+            this.cliDefault = list?.current;
+    }
+    /** The CLI reported a change of its own. */
+    observe(options) {
+        this.active = readModelList(options)?.current ?? this.active;
+    }
+    /**
+     * Switch the CLI to the harness's selection, unless it is already there.
+     * @param model - the selected model; omitted or `default` means the CLI's own.
+     * @param where - the session to switch.
+     * @param signal - cancellation for the wait.
+     */
+    async apply(model, where, signal) {
+        const known = this.knownModels?.();
+        const target = model === undefined || model === DEFAULT_MODEL_ID ? (this.cliDefault ?? known?.current) : model;
+        if (target === undefined || target === this.active)
+            return;
+        const optionId = this.optionId ?? known?.configId ?? CONVENTIONAL_MODEL_OPTION_ID;
+        // The CLI may still carry out a request this side stops waiting for, so from here
+        // its model is unknown until confirmed. The next step will then always set it.
+        this.active = undefined;
+        try {
+            const options = await abortable(where.transport.setConfigOption(where.acpSessionId, optionId, target), signal);
+            const confirmed = readModelList(options)?.current;
+            if (confirmed !== undefined && confirmed !== target)
+                throw new Error(`CLI 仍在使用 ${confirmed}`);
+            this.active = target;
+        }
+        catch (error) {
+            if (signal?.aborted === true)
+                throw error;
+            throw new LlmError(`${where.label} 无法切换到模型 ${target}：${errorMessage(error)}`, 'CLI_MODEL_FAILED', {
+                cause: error,
+            });
+        }
+    }
+}

package/lib/session/outcomes.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How a CLI turn's ending reads to the harness, and the chunks that close a harness step.
+ * @module dsh-ccgui/session/outcomes
+ */
+import type { StopReason } from '@agentclientprotocol/sdk';
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import type { StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { BlockState, BlockTransition } from '../stream-blocks.ts';
+import type { ToolRecord } from '../tool-record.ts';
+/** Extra fields every `finish` chunk carries so the harness can resume the native session. */
+export type ReplayFields = Partial<Pick<Extract<StreamChunk, {
+    type: 'finish';
+}>, 'replayState'>>;
+/** One step of reading, and whether it ends the harness step. */
+export interface StepResult extends BlockTransition {
+    readonly done: boolean;
+}
+/** @returns the error's message, or its string form for anything thrown that is not an Error. */
+export declare function errorMessage(error: unknown): string;
+/**
+ * End a harness step at a tool call the harness should run as the mirror tool.
+ * @returns the tool-call chunks followed by a `tool-calls` finish.
+ */
+export declare function toolCallStep(blocks: BlockState, record: ToolRecord, replay: ReplayFields): StepResult;
+/**
+ * End a harness step at the end of the CLI turn.
+ * @returns the closing chunks followed by the turn's finish.
+ */
+export declare function turnEndStep(blocks: BlockState, stopReason: StopReason, label: string, replay: ReplayFields): StepResult;
+/** @returns the turn's failure as the error the harness reports. */
+export declare function turnFailure(error: Error, label: string): LlmError;

package/lib/session/outcomes.js

@@ -0,0 +1,67 @@
+/**
+ * How a CLI turn's ending reads to the harness, and the chunks that close a harness step.
+ * @module dsh-ccgui/session/outcomes
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { CLI_TOOL_NAME } from "../constants.js";
+import { closeOpenBlock, toolCallChunks } from "../stream-blocks.js";
+import { toCliToolArgs } from "../tool-record.js";
+/** @returns the error's message, or its string form for anything thrown that is not an Error. */
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failureFinish(message, code) {
+    return { kind: 'error', failure: { message, code } };
+}
+/**
+ * Map an ACP stop reason onto the harness's finish reason.
+ * @param stopReason - why the CLI ended its turn.
+ * @param label - CLI display name used in user-facing messages.
+ * @returns the finish reason the harness should record.
+ */
+function finishReason(stopReason, label) {
+    switch (stopReason) {
+        case 'end_turn':
+            return { kind: 'stop' };
+        case 'max_tokens':
+            return { kind: 'max-tokens' };
+        case 'cancelled':
+            return { kind: 'aborted', failure: { message: `${label} 已取消本轮。`, code: 'ABORTED' } };
+        case 'refusal':
+            return failureFinish(`${label} 拒绝继续这个请求。`, 'CLI_REFUSAL');
+        case 'max_turn_requests':
+            return failureFinish(`${label} 达到了单轮请求次数上限。`, 'CLI_TURN_LIMIT');
+        default:
+            return failureFinish(`${label} 以未知原因结束：${String(stopReason)}`, 'CLI_UNKNOWN_STOP');
+    }
+}
+/**
+ * End a harness step at a tool call the harness should run as the mirror tool.
+ * @returns the tool-call chunks followed by a `tool-calls` finish.
+ */
+export function toolCallStep(blocks, record, replay) {
+    const { state, chunks } = toolCallChunks(blocks, {
+        id: record.callId,
+        name: CLI_TOOL_NAME,
+        arguments: JSON.stringify(toCliToolArgs(record)),
+    });
+    return { state, chunks: [...chunks, { type: 'finish', reason: { kind: 'tool-calls' }, ...replay }], done: true };
+}
+/**
+ * End a harness step at the end of the CLI turn.
+ * @returns the closing chunks followed by the turn's finish.
+ */
+export function turnEndStep(blocks, stopReason, label, replay) {
+    const { state, chunks } = closeOpenBlock(blocks);
+    return {
+        state,
+        chunks: [...chunks, { type: 'finish', reason: finishReason(stopReason, label), ...replay }],
+        done: true,
+    };
+}
+/** @returns the turn's failure as the error the harness reports. */
+export function turnFailure(error, label) {
+    return error instanceof LlmError
+        ? error
+        : new LlmError(`${label} 执行失败：${error.message}`, 'CLI_PROMPT_FAILED', { cause: error });
+}

package/lib/session/permission-queue.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Permission requests from the CLI that are still waiting for an answer.
+ * @module dsh-ccgui/session/permission-queue
+ */
+import type { PermissionOption, RequestPermissionResponse } from '@agentclientprotocol/sdk';
+import { CANCELLED } from '../permission.ts';
+export { CANCELLED };
+/** One CLI request blocked on a decision. */
+export interface PendingPermission {
+    readonly acpId: string;
+    readonly options: readonly PermissionOption[];
+    readonly resolve: (response: RequestPermissionResponse) => void;
+}
+/** Open permission requests, answered in the order the CLI asked. */
+export declare class PermissionQueue {
+    private open;
+    add(permission: PendingPermission): void;
+    /** @returns the oldest open request, removed from the queue. */
+    takeNext(): PendingPermission | undefined;
+    /** Answer every open request as cancelled. */
+    cancelAll(): void;
+    /** Refuse the open requests of one call, whose mirror will never ask the harness. */
+    rejectFor(acpId: string): void;
+}

package/lib/session/permission-queue.js

@@ -0,0 +1,33 @@
+/**
+ * Permission requests from the CLI that are still waiting for an answer.
+ * @module dsh-ccgui/session/permission-queue
+ */
+import { CANCELLED, permissionResponse } from "../permission.js";
+export { CANCELLED };
+/** Open permission requests, answered in the order the CLI asked. */
+export class PermissionQueue {
+    open = [];
+    add(permission) {
+        this.open = [...this.open, permission];
+    }
+    /** @returns the oldest open request, removed from the queue. */
+    takeNext() {
+        const [next, ...rest] = this.open;
+        this.open = rest;
+        return next;
+    }
+    /** Answer every open request as cancelled. */
+    cancelAll() {
+        const open = this.open;
+        this.open = [];
+        for (const permission of open)
+            permission.resolve(CANCELLED);
+    }
+    /** Refuse the open requests of one call, whose mirror will never ask the harness. */
+    rejectFor(acpId) {
+        const own = this.open.filter((permission) => permission.acpId === acpId);
+        this.open = this.open.filter((permission) => permission.acpId !== acpId);
+        for (const permission of own)
+            permission.resolve(permissionResponse('rejected', permission.options));
+    }
+}

package/lib/session/read-step.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Reading one harness step out of a CLI turn: text and reasoning stream through, and the
+ * step ends at the next tool call or at the end of the turn.
+ * @module dsh-ccgui/session/read-step
+ */
+import type { LlmError, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { ToolRecord } from '../tool-record.ts';
+import type { ReplayFields } from './outcomes.ts';
+import type { SessionEvent } from './types.ts';
+/** What reading a step needs from its session. */
+export interface StepSource {
+    /** CLI display name used in user-facing messages. */
+    readonly label: string;
+    /** @returns the next event; a failed or aborted wait abandons the turn. */
+    readonly nextEvent: (signal: AbortSignal | undefined) => Promise<SessionEvent>;
+    /** Whether a turn is running or waiting, or events are still unread. */
+    readonly hasWork: () => boolean;
+    /** Whether this dead session holds user input it can no longer deliver. */
+    readonly owesInput: () => boolean;
+    readonly failure: () => LlmError | undefined;
+    /** @returns the call to hand to the harness, marked as handed off; undefined if it is gone. */
+    readonly handOff: (acpId: string) => ToolRecord | undefined;
+    readonly replay: () => ReplayFields;
+}
+/**
+ * Read until the next tool call or the end of the CLI turn.
+ * @param source - the session being read.
+ * @param signal - cancellation; aborting abandons the turn.
+ * @yields the step's stream chunks, ending with `finish`.
+ */
+export declare function readStep(source: StepSource, signal: AbortSignal | undefined): AsyncGenerator<StreamChunk>;

package/lib/session/read-step.js

@@ -0,0 +1,53 @@
+/**
+ * Reading one harness step out of a CLI turn: text and reasoning stream through, and the
+ * step ends at the next tool call or at the end of the turn.
+ * @module dsh-ccgui/session/read-step
+ */
+import { appendDelta, closeOpenBlock, EMPTY_BLOCKS } from "../stream-blocks.js";
+import { toolCallStep, turnEndStep, turnFailure } from "./outcomes.js";
+/**
+ * Read until the next tool call or the end of the CLI turn.
+ * @param source - the session being read.
+ * @param signal - cancellation; aborting abandons the turn.
+ * @yields the step's stream chunks, ending with `finish`.
+ */
+export async function* readStep(source, signal) {
+    let blocks = EMPTY_BLOCKS;
+    while (source.hasWork()) {
+        const event = await source.nextEvent(signal);
+        if (source.owesInput() && event.type === 'turn-end')
+            continue;
+        const step = applyEvent(source, blocks, event);
+        blocks = step.state;
+        yield* step.chunks;
+        if (step.done)
+            return;
+    }
+    if (source.owesInput())
+        throw source.failure();
+    yield* closeOpenBlock(blocks).chunks;
+    yield { type: 'finish', reason: { kind: 'stop' }, ...source.replay() };
+}
+function applyEvent(source, blocks, event) {
+    switch (event.type) {
+        case 'text':
+        case 'reasoning':
+            return { ...appendDelta(blocks, event.type, event.text), done: false };
+        case 'tool-ready': {
+            const record = source.handOff(event.acpId);
+            return record === undefined
+                ? { state: blocks, chunks: [], done: false }
+                : toolCallStep(blocks, record, source.replay());
+        }
+        case 'turn-end':
+            return applyTurnEnd(source, blocks, event.stopReason);
+        case 'failure':
+            throw turnFailure(event.error, source.label);
+    }
+}
+/** Queued steering runs as the next CLI turn inside the same harness turn. */
+function applyTurnEnd(source, blocks, stopReason) {
+    if (source.hasWork())
+        return { state: blocks, chunks: [], done: false };
+    return turnEndStep(blocks, stopReason, source.label, source.replay());
+}

package/lib/session/tool-mirror.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The CLI's tool calls as the harness sees them: what each call has reported, which
+ * ones were handed to the harness, which have a mirror tool waiting on them, and which
+ * the harness is finished with.
+ * @module dsh-ccgui/session/tool-mirror
+ */
+import type { ToolCallUpdate } from '@agentclientprotocol/sdk';
+import type { ToolRecord } from '../tool-record.ts';
+/** Construction inputs for a tool mirror. */
+export interface ToolMirrorOptions {
+    readonly mintCallId: () => string;
+    /** How long a pending command's reports must stay quiet before it counts as started. */
+    readonly settleMs: number;
+    /** Told once per call when the harness should receive it as a tool call. */
+    readonly onReady: (acpId: string) => void;
+}
+/** Tool-call bookkeeping for one CLI session. */
+export declare class ToolMirror {
+    private readonly options;
+    private tools;
+    /** Pending commands waiting for their reports to go quiet. */
+    private settling;
+    private callIds;
+    /** Calls already announced through `onReady`; each is announced once. */
+    private published;
+    /** Calls the harness received as tool calls; their mirrors may or may not run. */
+    private handedOff;
+    /** Calls whose mirror is running right now. */
+    private mirrors;
+    /** Calls the harness is finished with; their late updates are ignored. */
+    private claimed;
+    private changeWaiters;
+    constructor(options: ToolMirrorOptions);
+    get(acpId: string): ToolRecord | undefined;
+    acpIdFor(callId: string): string | undefined;
+    isClaimed(acpId: string): boolean;
+    /** A call the CLI reports again, or asks permission for, is live once more. */
+    reopen(acpId: string): void;
+    handOff(acpId: string): void;
+    startMirror(acpId: string): void;
+    /** Calls handed to the harness whose mirror never started: denied by a policy or skipped by a stop. */
+    skippedMirrors(): readonly string[];
+    apply(update: ToolCallUpdate, permission: boolean): void;
+    /**
+     * A turn can end with calls still open. Their mirrors would otherwise wait forever,
+     * so they finish as failed; an unpublished call is still published so the log shows
+     * what the CLI attempted.
+     */
+    failOpen(): void;
+    dropUnmirrored(): void;
+    forget(acpId: string): void;
+    /** @returns a promise that settles at the next change to any call. */
+    nextChange(): Promise<void>;
+    private publish;
+    /**
+     * claude-agent-acp goes from pending straight to completed, so a long command would show
+     * nothing until it ended. Its input arrives over several updates with nothing marking the
+     * end, so a command counts as started once they stop. Only commands, because a file write
+     * reports its path and then goes quiet while its content is generated: showing it then
+     * would freeze a card with no diff in it.
+     */
+    private publishOnceQuiet;
+    private stopSettling;
+    private notifyChange;
+}

package/lib/session/tool-mirror.js

@@ -0,0 +1,131 @@
+/**
+ * The CLI's tool calls as the harness sees them: what each call has reported, which
+ * ones were handed to the harness, which have a mirror tool waiting on them, and which
+ * the harness is finished with.
+ * @module dsh-ccgui/session/tool-mirror
+ */
+import { commandOf, isFinished, isReadyToPublish, mergeToolUpdate } from "../tool-record.js";
+const INTERRUPTED_OUTPUT = 'CLI 在这个工具完成之前结束了本轮。';
+/** Tool-call bookkeeping for one CLI session. */
+export class ToolMirror {
+    options;
+    tools = new Map();
+    /** Pending commands waiting for their reports to go quiet. */
+    settling = new Map();
+    callIds = new Map();
+    /** Calls already announced through `onReady`; each is announced once. */
+    published = new Set();
+    /** Calls the harness received as tool calls; their mirrors may or may not run. */
+    handedOff = new Set();
+    /** Calls whose mirror is running right now. */
+    mirrors = new Set();
+    /** Calls the harness is finished with; their late updates are ignored. */
+    claimed = new Set();
+    changeWaiters = [];
+    constructor(options) {
+        this.options = options;
+    }
+    get(acpId) {
+        return this.tools.get(acpId);
+    }
+    acpIdFor(callId) {
+        return this.callIds.get(callId);
+    }
+    isClaimed(acpId) {
+        return this.claimed.has(acpId);
+    }
+    /** A call the CLI reports again, or asks permission for, is live once more. */
+    reopen(acpId) {
+        this.claimed = new Set([...this.claimed].filter((id) => id !== acpId));
+    }
+    handOff(acpId) {
+        this.handedOff = new Set([...this.handedOff, acpId]);
+    }
+    startMirror(acpId) {
+        this.mirrors = new Set([...this.mirrors, acpId]);
+    }
+    /** Calls handed to the harness whose mirror never started: denied by a policy or skipped by a stop. */
+    skippedMirrors() {
+        return [...this.handedOff].filter((acpId) => !this.mirrors.has(acpId));
+    }
+    apply(update, permission) {
+        const merged = mergeToolUpdate(this.tools.get(update.toolCallId), update, this.options.mintCallId);
+        const record = permission ? { ...merged, permissionRequested: true } : merged;
+        this.tools = new Map([...this.tools, [record.acpId, record]]);
+        this.callIds = new Map([...this.callIds, [record.callId, record.acpId]]);
+        if (isReadyToPublish(record))
+            this.publish(record.acpId);
+        else
+            this.publishOnceQuiet(record);
+        this.notifyChange();
+    }
+    /**
+     * A turn can end with calls still open. Their mirrors would otherwise wait forever,
+     * so they finish as failed; an unpublished call is still published so the log shows
+     * what the CLI attempted.
+     */
+    failOpen() {
+        for (const record of this.tools.values()) {
+            if (isFinished(record))
+                continue;
+            this.apply({ toolCallId: record.acpId, status: 'failed', rawOutput: INTERRUPTED_OUTPUT }, false);
+        }
+    }
+    dropUnmirrored() {
+        for (const acpId of this.tools.keys()) {
+            if (!this.mirrors.has(acpId))
+                this.forget(acpId);
+        }
+    }
+    forget(acpId) {
+        this.stopSettling(acpId);
+        const callId = this.tools.get(acpId)?.callId;
+        this.tools = new Map([...this.tools].filter(([id]) => id !== acpId));
+        this.callIds = new Map([...this.callIds].filter(([id]) => id !== callId));
+        this.published = new Set([...this.published].filter((id) => id !== acpId));
+        this.handedOff = new Set([...this.handedOff].filter((id) => id !== acpId));
+        this.mirrors = new Set([...this.mirrors].filter((id) => id !== acpId));
+        this.claimed = new Set([...this.claimed, acpId]);
+    }
+    /** @returns a promise that settles at the next change to any call. */
+    nextChange() {
+        const { promise, resolve } = Promise.withResolvers();
+        this.changeWaiters = [...this.changeWaiters, resolve];
+        return promise;
+    }
+    publish(acpId) {
+        this.stopSettling(acpId);
+        if (this.published.has(acpId))
+            return;
+        this.published = new Set([...this.published, acpId]);
+        this.options.onReady(acpId);
+    }
+    /**
+     * claude-agent-acp goes from pending straight to completed, so a long command would show
+     * nothing until it ended. Its input arrives over several updates with nothing marking the
+     * end, so a command counts as started once they stop. Only commands, because a file write
+     * reports its path and then goes quiet while its content is generated: showing it then
+     * would freeze a card with no diff in it.
+     */
+    publishOnceQuiet(record) {
+        const { acpId } = record;
+        this.stopSettling(acpId);
+        if (this.published.has(acpId) || commandOf(record) === undefined)
+            return;
+        const timer = setTimeout(() => {
+            this.publish(acpId);
+        }, this.options.settleMs);
+        timer.unref();
+        this.settling = new Map([...this.settling, [acpId, timer]]);
+    }
+    stopSettling(acpId) {
+        clearTimeout(this.settling.get(acpId));
+        this.settling = new Map([...this.settling].filter(([id]) => id !== acpId));
+    }
+    notifyChange() {
+        const waiters = this.changeWaiters;
+        this.changeWaiters = [];
+        for (const wake of waiters)
+            wake();
+    }
+}