@ordewell/core 0.5.4 → 0.5.5

package/dist/plan-utils-BFaPo-IT.d.ts

@@ -0,0 +1,708 @@
+import { r as IsolationTaskStatus, P as PlanIsolation, H as RunnerId, a as DiscoveredModel, T as Task, L as LegacyPlanState, Q as QueuedMessage, a4 as UsageTotals, O as SubagentOutcome, aa as Verdict, U as TaskIsolation, d as IsolationHandoff, k as IsolationMergeResult, E as ResearchStep, F as ResearchStepOutcome, C as ConversationMessage, z as ResearchLogEntry, w as PlannerUsage } from './Task-Vl5Zq_D-.js';
+import { R as RunnerModeInfo } from './ModeResolver-D3XO0fT9.js';
+import { A as ApprovalKind, e as ApprovalSource } from './ApprovalPolicy-BVhGdECT.js';
+
+/** A conflict's files as one surface shows them: every one, up to `max`, then how many more. */
+declare function capConflictFiles(files: string[], max?: number): string;
+/** A task record as ADR-0013 persisted it, for one repository. */
+interface Adr0013TaskRecord {
+    taskId: string;
+    order: number;
+    title: string;
+    branch: string;
+    worktree: string;
+    status: IsolationTaskStatus;
+    linked: string[];
+}
+/** A run as ADR-0013 persisted it (0.4.23): one repository, its refs on the run itself. */
+interface Adr0013IsolationRun {
+    id: string;
+    workspaceRoot: string;
+    baseRef: string;
+    baseBranch?: string;
+    integrationBranch: string;
+    tasks: Record<string, Adr0013TaskRecord>;
+}
+interface Adr0013PlanIsolation {
+    run: Adr0013IsolationRun;
+    resolvers: Record<string, string>;
+}
+/**
+ * A persisted plan isolation in today's shape. A run saved in the ADR-0013
+ * format — recognised by its own `integrationBranch` — becomes a group of one
+ * at `.`, keeping its branches, so a session saved by 0.4.23 resumes and hands
+ * off exactly as it would have.
+ */
+declare function migratePlanIsolation(state: PlanIsolation | Adr0013PlanIsolation): PlanIsolation;
+
+/**
+ * The catalog a model/task-mode edit is checked against — the same discovered
+ * models and manifest modes the planner was shown in the per-turn catalog
+ * block (`PlannerConversation.catalogBlock`), so a refusal here can never name something
+ * as invalid that the planner was never told about, or vice versa.
+ */
+interface EditCatalog {
+    modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>;
+    runnerModes: Partial<Record<RunnerId, RunnerModeInfo[]>>;
+    /** Raw (unfiltered) allowlist, keyed by runner — the same shape `coerceAssignments` takes. */
+    perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
+}
+
+/**
+ * Targeted task edits emitted by the planner conversation (the 'task_ops'
+ * ConversationTurn). Task references accept a task id, a "#<order>" ref, or a
+ * bare order number — cheap models rarely echo UUIDs correctly.
+ */
+type TaskOp = {
+    op: 'update';
+    taskId: string;
+    changes: Partial<Task>;
+} | {
+    op: 'add';
+    task: Partial<Task>;
+    handle?: string;
+} | {
+    op: 'remove';
+    taskId: string;
+} | {
+    op: 'reorder';
+    taskIds: string[];
+} | {
+    op: 'merge';
+    taskIds: string[];
+    merged: Partial<Task>;
+    handle?: string;
+} | {
+    op: 'split';
+    taskId: string;
+    parts: Partial<Task>[];
+    handle?: string;
+} | {
+    op: 'rearm';
+    taskId: string;
+    changes?: Partial<Task>;
+};
+declare function textHasTaskOps(text: string): boolean;
+/** Parse a `{"taskOps":[...]}` reply. Throws PlanParseError when the JSON is unusable. */
+declare function parseTaskOpsJson(text: string): TaskOp[];
+interface ApplyTaskOpsResult {
+    ok: boolean;
+    tasks: Task[];
+    errors: string[];
+    /** Human-readable summary of what changed, for the chat transcript. */
+    summary: string[];
+}
+/**
+ * Pre-flight check for a merge: would collapsing the selected tasks into one
+ * (rewiring every dependent of any selected task to the survivor) keep the
+ * dependency graph valid? Rejects locked tasks and merges whose rewiring would
+ * introduce a cycle. Display order is NOT checked here — neither
+ * consecutiveness (a UI concern) nor a dependency the merge pulls out of order,
+ * which {@link applyTaskOps} repairs; refusing on order would make this
+ * pre-flight stricter than the applier it stands in for.
+ */
+declare function canMergeTasks(tasks: Task[], selectedIds: string[]): {
+    ok: boolean;
+    error?: string;
+};
+/**
+ * The shape the dependency helpers below read. Structural rather than `Task`,
+ * because the TUI projects tasks into its own `TaskView`: a surface's
+ * dependency picker and the API's validation must agree on which dependencies
+ * are legal, and a signature only core can satisfy would have forced the TUI
+ * to keep a second copy of the rule.
+ */
+interface TaskRef {
+    id: string;
+    order: number;
+    title: string;
+    dependencies: string[];
+}
+/** The tasks listing `taskId` as a dependency — exactly what removing it detaches. */
+declare function dependentsOf<T extends Pick<TaskRef, 'id' | 'dependencies'>>(tasks: T[], taskId: string): T[];
+/**
+ * The tasks that may become dependencies of `taskId`: those displayed before it.
+ *
+ * Offering only earlier tasks is what keeps a hand-edited graph valid without a
+ * cycle check — dependencies then only ever point backwards in display order,
+ * the same invariant `applyTaskOps` enforces. Omit `taskId` for a task that does
+ * not exist yet: it lands last, so every current task is a candidate.
+ */
+declare function dependencyCandidates<T extends Pick<TaskRef, 'id' | 'order'>>(tasks: T[], taskId?: string): T[];
+/** Pre-flight check for a hand-edited dependency list: every id exists and comes earlier. */
+declare function canSetDependencies<T extends TaskRef>(tasks: T[], taskId: string, dependencies: string[]): {
+    ok: boolean;
+    error?: string;
+};
+/** Pre-flight check for a split: the task exists and is not locked by execution. */
+declare function canSplitTask(tasks: Task[], taskId: string): {
+    ok: boolean;
+    error?: string;
+};
+/**
+ * Apply task ops to a snapshot of the plan, atomically: either every op
+ * applies and the result validates (deps resolve, no cycles, running and
+ * completed tasks untouched), or nothing is returned and `errors` explains
+ * why. The caller commits `tasks` on ok.
+ */
+declare function applyTaskOps(currentTasks: Task[], ops: TaskOp[], runners: RunnerId[], catalog?: EditCatalog): ApplyTaskOpsResult;
+
+type SerializedTaskStatus = {
+    id: string;
+    status: string;
+    verdict: {
+        outcome: 'pass' | 'fail';
+        reason: string;
+        checks: Verdict['checks'];
+    } | null;
+    /** Advisory silence timestamp from VerdictEngine — not part of task status semantics. */
+    idleSince?: string | null;
+    /** Absent unless the plan has an isolation run, so a shared-root plan's updates are unchanged. */
+    isolation?: TaskIsolation;
+};
+type SerializedTask = {
+    id: string;
+    order: number;
+    title: string;
+    type: string;
+    description: string;
+    dependencies: string[];
+    assignedRunner: RunnerId;
+    assignedModel: Task['assignedModel'] | null;
+    taskMode: string;
+    prompt: string | null;
+    subtasks: SerializedTask[];
+    userSteps: Task['userSteps'];
+    thinkingEffort: Task['thinkingEffort'];
+    autonomy: Task['autonomy'];
+    sliceType: Task['sliceType'];
+    userStoriesCovered: Task['userStoriesCovered'];
+};
+type SerializedPlan = {
+    tasks: SerializedTask[];
+    runners: RunnerId[];
+    generatedAt: string;
+    conversationHistory?: LegacyPlanState['conversationHistory'];
+    prdMarkdown?: string;
+    queuedMessages?: QueuedMessage[];
+};
+/** How a planner turn ended: the reply kind it settled on, a user stop, or a failure. */
+type PlannerTurnOutcome = 'message' | 'plan' | 'task_ops' | 'stopped' | 'error';
+/**
+ * Everything a session tells its surfaces, over one broadcast seam.
+ *
+ * A planner turn (#47) streams between `planner_turn_started` and
+ * `planner_turn_ended` with the same `turnId`; every turn-scoped message in
+ * between carries it. The stream is provisional and the settled messages are
+ * authoritative:
+ * - `planner_message` replaces the streamed text of the turn's final segment —
+ *   a surface drops what it accumulated and shows the message instead.
+ * - A reply that is a JSON envelope (plan, taskOps, taskQuery) never arrives
+ *   as `planner_text_delta`; it streams as `plan_token`, the "building plan"
+ *   display.
+ * - A subagent's own text never appears in the reply; its activity arrives
+ *   tagged with its `subagentId`.
+ */
+type SessionMessage = 
+/**
+ * The plan, whole. `turnId` names the planner turn whose commit this
+ * broadcast carries, so the turn's building plan becomes the marker; it is
+ * absent on every other broadcast of the plan.
+ */
+{
+    type: 'plan_generated';
+    plan: SerializedPlan;
+    goal: string;
+    runners: RunnerId[];
+    turnId?: string;
+}
+/**
+ * The settled reply of a planner turn, emitted by the session once the turn
+ * is classified. Authoritative over any `planner_text_delta` of its turn's
+ * final segment. `turnId` is absent for replies sent outside a streamed turn.
+ */
+ | {
+    type: 'planner_message';
+    content: string;
+    timestamp: string;
+    turnId?: string;
+}
+/**
+ * A planner turn began. Emitted once per turn by whoever runs the turn,
+ * before any other message carrying its `turnId`. `prompt` is the user's
+ * message when the turn answers one.
+ */
+ | {
+    type: 'planner_turn_started';
+    turnId: string;
+    prompt?: string;
+}
+/**
+ * A planner turn is over; nothing more carries its `turnId`. Emitted exactly
+ * once per `planner_turn_started`, stop and failure included, after the
+ * turn's `planner_message` when it has one.
+ */
+ | {
+    type: 'planner_turn_ended';
+    turnId: string;
+    outcome: PlannerTurnOutcome;
+}
+/**
+ * Reply prose as it streams, appended in order within its segment. A segment
+ * is one continuous run of model text; text before a tool call is its own
+ * segment, and a later segment never rewrites an earlier one. Never carries
+ * a JSON envelope or a subagent's text (see the union's invariants).
+ */
+ | {
+    type: 'planner_text_delta';
+    turnId: string;
+    segmentId: string;
+    text: string;
+}
+/**
+ * Exposed reasoning as it streams, from the planner or — tagged with
+ * `subagentId` — from one of its subagents. Never part of the reply. The one
+ * thinking message for every backend: `segmentId` is set only where the
+ * backend streams thinking in segments (the API loops; harness planners do
+ * not), and `turnId` is absent for thinking outside a turn (one-shot plans).
+ */
+ | {
+    type: 'planner_thinking_delta';
+    turnId?: string;
+    segmentId?: string;
+    subagentId?: string;
+    text: string;
+}
+/**
+ * Text streamed for an attempt the turn discarded (a corrective retry) is
+ * taken back: a surface removes it. With `segmentId`, only that segment;
+ * without, all of the turn's text not yet settled by a `planner_message`.
+ * A segment that streamed to the plan display (`plan_token`) takes the
+ * turn's building plan with it.
+ */
+ | {
+    type: 'planner_text_retracted';
+    turnId: string;
+    segmentId?: string;
+}
+/**
+ * The planner's running usage for the session, subagents included, emitted
+ * after a model call reports usage. `totals` already contains every
+ * `bySubagent` entry. `contextFill` is the last planner prompt against the
+ * model's window, omitted when the window is unknown. Cost appears only as
+ * reported by a provider or runner (see `UsageRecord`).
+ */
+ | {
+    type: 'planner_usage';
+    turnId?: string;
+    totals: UsageTotals;
+    bySubagent?: Record<string, UsageTotals>;
+    contextFill?: {
+        usedTokens: number;
+        windowTokens: number;
+    };
+}
+/**
+ * A subagent began work on `brief`. Emitted by the planner backend that
+ * spawned it (ADR-0005 research agents, or a harness planner's own), before
+ * any message tagged with its `subagentId`.
+ */
+ | {
+    type: 'subagent_started';
+    turnId?: string;
+    subagentId: string;
+    brief: string;
+    model?: string;
+}
+/**
+ * A subagent is done; nothing more is tagged with its `subagentId`. Emitted
+ * once per `subagent_started`. `digest` is what it handed back to the
+ * planner; `usage` is its own share, already counted in `planner_usage`.
+ */
+ | {
+    type: 'subagent_finished';
+    turnId?: string;
+    subagentId: string;
+    outcome: SubagentOutcome;
+    digest: string;
+    usage?: UsageTotals;
+} | {
+    type: 'status_update';
+    tasks: SerializedTaskStatus[];
+} | {
+    type: 'review_needed';
+    tasks: SerializedTask[];
+} | {
+    type: 'review_approved';
+} | {
+    type: 'checkpoint';
+    taskId: string;
+    taskTitle: string;
+    summary: string;
+} | {
+    type: 'execution_complete';
+    summary: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+} | {
+    type: 'execution_stopped';
+} | {
+    type: 'queue_ready';
+} | {
+    type: 'task_updated';
+    taskId: string;
+    changes: Record<string, unknown>;
+} | {
+    type: 'task_started';
+    taskId: string;
+    order: number;
+    title: string;
+    runner: RunnerId;
+    modelId?: string;
+} | {
+    type: 'task_output';
+    taskId: string;
+    text: string;
+} | {
+    type: 'isolation_blocked';
+    reason: 'dirty';
+    repos?: string[];
+    message: string;
+} | {
+    type: 'isolation_handoff';
+    repos: IsolationHandoff['repos'];
+    landed: IsolationHandoff['landed'];
+} | {
+    type: 'isolation_merge';
+    result: IsolationMergeResult;
+} | {
+    type: 'planner_liveness';
+} | {
+    type: 'research_step';
+    tool: string;
+    toolLabel?: string;
+    args: string;
+    subagentId?: string;
+    toolCallId?: string;
+    turnId?: string;
+} | {
+    type: 'plan_token';
+    token: string;
+    turnId?: string;
+    segmentId?: string;
+} | {
+    type: 'research_step_done';
+    step: ResearchStep;
+    subagentId?: string;
+    turnId?: string;
+} | {
+    type: 'approval_request';
+    id: string;
+    kind: ApprovalKind;
+    subject: string;
+    scope: string;
+    detail?: string;
+    turnId?: string;
+} | {
+    type: 'approval_settled';
+    id: string;
+    granted: boolean;
+} | {
+    type: 'approval_decided';
+    kind: ApprovalKind;
+    subject: string;
+    scope: string;
+    detail?: string;
+    granted: boolean;
+    source: Exclude<ApprovalSource, 'asked'>;
+};
+/**
+ * A line a run wants the user to read — how it isolates, what it shares. Not a
+ * {@link SessionMessage}: hosts that show notices as toasts already do, and
+ * widening the union would break every exhaustive switch over it. A host with
+ * no toast channel (the daemon) hands these to its clients by its own means.
+ */
+type SessionNotice = {
+    type: 'notice';
+    level: 'info' | 'warn' | 'error';
+    message: string;
+};
+type SessionBroadcaster = (msg: SessionMessage) => void;
+declare function serializeTask(t: Task): SerializedTask;
+declare function serializeTaskStatus(t: Task, idleSince?: string | null, isolation?: TaskIsolation | null): SerializedTaskStatus;
+declare function serializePlan(plan: LegacyPlanState): SerializedPlan;
+declare function executionSummary(tasks: Task[]): {
+    total: number;
+    completed: number;
+    failed: number;
+};
+declare const CHECKPOINT_TRUNCATE_LENGTH = 120;
+/** Truncate a checkpoint summary to a single line of at most CHECKPOINT_TRUNCATE_LENGTH chars. */
+declare function truncateCheckpointSummary(summary: string): string;
+
+/**
+ * @param toolLabel The agent's own name for the tool, when a harness planner
+ * produced the call (ADR-0009). It replaces the member name in the summary, so
+ * the timeline says `Edit` rather than the catch-all `agent_tool` — and says
+ * `WebFetch` rather than claiming a shell command ran.
+ */
+declare function summarizeToolCall(tool: string, argsJson: string, toolLabel?: string): string;
+/**
+ * Classify a tool outcome from its result text and success flag, so a surface
+ * can render a refused `rm` or a denied `npm test` distinctly from a
+ * successful run without re-deriving the refusal signatures per surface. The
+ * refusal/denial strings come from `commandPolicy.ts`, `BaseFileSystem.ts`,
+ * and the research-subagent wrapper — keeping the matching here means the
+ * signatures stay in one place alongside the human summary.
+ */
+declare function classifyOutcome(success: boolean, output: string): ResearchStepOutcome;
+
+/**
+ * What a surface draws for one planner conversation (#51): an ordered list of
+ * display blocks, built once in core from the `SessionMessage` stream and drawn
+ * per surface. Every block carries an `id` that stays the same for as long as
+ * the block exists, so a surface can key its own UI state on it — whether a
+ * block is expanded is that UI state, and deliberately not part of a block.
+ */
+type DisplayBlock = MessageBlock | ThinkingDisplayBlock | ToolBlock | SubagentBlock | ApprovalBlock | PlanBlock | UsageBlock;
+type MessageRole = 'user' | 'planner' | 'system' | 'error';
+interface MessageBlock {
+    type: 'message';
+    id: string;
+    role: MessageRole;
+    text: string;
+    /** Deltas are still arriving. */
+    streaming: boolean;
+    turnId?: string;
+    /**
+     * Present while the text is the streamed segment of a reply rather than a
+     * settled message: provisional, replaced by the turn's `planner_message` when
+     * it is the final segment, and never saved to the transcript.
+     */
+    segmentId?: string;
+}
+interface ThinkingDisplayBlock {
+    type: 'thinking';
+    id: string;
+    text: string;
+    streaming: boolean;
+    turnId?: string;
+    segmentId?: string;
+    /** Set when a subagent thought it; the block then sits among that subagent's children. */
+    subagentId?: string;
+}
+/** The two halves of a Claude Code-style command row: `Name(keyArg)`. */
+interface ToolHeadline {
+    name: string;
+    keyArg: string;
+}
+type ToolStatus = 'pending' | 'ok' | 'error' | 'denied' | 'interrupted';
+interface ToolBlock {
+    type: 'tool';
+    id: string;
+    toolCallId?: string;
+    tool: string;
+    toolLabel?: string;
+    headline: ToolHeadline;
+    /** The arguments exactly as announced (JSON), for the expanded view. */
+    args: string;
+    status: ToolStatus;
+    /** How the call ended, finer than `status`: a refused command and a denied path both read `denied`. */
+    outcome?: ResearchStepOutcome;
+    output: string;
+    /** Every line of `output`, counted as {@link outputPreview} counts them. */
+    outputLineCount: number;
+    turnId?: string;
+    /**
+     * The subagent this call starts. The call becomes that subagent's block once
+     * the subagent announces itself, so the two never show as separate rows.
+     */
+    spawns?: string;
+}
+type SubagentStatus = 'running' | SubagentOutcome;
+type SubagentChild = ToolBlock | ThinkingDisplayBlock | MessageBlock;
+interface SubagentBlock {
+    type: 'subagent';
+    id: string;
+    subagentId: string;
+    /** The planner's call that started it, when one was announced. */
+    toolCallId?: string;
+    brief: string;
+    model?: string;
+    status: SubagentStatus;
+    children: readonly SubagentChild[];
+    /** What it handed back to the planner. */
+    digest: string;
+    /** Its own share, already counted in the usage line. */
+    usage?: UsageTotals;
+    turnId?: string;
+}
+type ApprovalStatus = 'pending' | 'granted' | 'denied';
+interface ApprovalBlock {
+    type: 'approval';
+    id: string;
+    /** The request's id, which a surface answers through. Absent for a decision nobody was asked about. */
+    approvalId?: string;
+    kind: ApprovalKind;
+    subject: string;
+    scope: string;
+    detail?: string;
+    status: ApprovalStatus;
+    /** Absent while pending. */
+    decidedBy?: ApprovalSource;
+    turnId?: string;
+}
+type PlanMarkerStatus = 'building' | 'generated' | 'updated';
+interface PlanBlock {
+    type: 'plan';
+    id: string;
+    status: PlanMarkerStatus;
+    /** The plan envelope streamed so far — `parsePartialPlan` reads rows from it. Empty once settled. */
+    text: string;
+    taskCount?: number;
+    turnId?: string;
+    /** While building: the segment whose envelope is streaming, which a retraction of that segment takes back. */
+    segmentId?: string;
+}
+/** The token line. There is at most one, and it is always the last block. */
+interface UsageBlock {
+    type: 'usage';
+    id: string;
+    totals: UsageTotals;
+    contextFill?: {
+        usedTokens: number;
+        windowTokens: number;
+    };
+    bySubagent?: Record<string, UsageTotals>;
+}
+
+/**
+ * A line a surface adds to the conversation itself rather than receiving from
+ * the session: the user's prompt as it is sent, a notice, an error.
+ */
+interface LocalEntry {
+    type: 'local_entry';
+    role: 'user' | 'system' | 'error';
+    text: string;
+}
+type ConversationInput = SessionMessage | LocalEntry;
+interface ConversationView {
+    readonly blocks: readonly DisplayBlock[];
+    readonly nextId: number;
+    /**
+     * The newest transcript entry the view accounts for. Plan markers and system
+     * notes reach a surface only inside the transcript a `plan_generated`
+     * carries, so entries after this one are what is new in it.
+     */
+    readonly transcriptAt?: string;
+}
+declare const EMPTY_CONVERSATION: ConversationView;
+/**
+ * Fold one input into the view. Pure and incremental: blocks the input does
+ * not touch keep their identity, and an input that changes nothing returns
+ * `view` itself — surfaces memoize their drawing on that, and text deltas
+ * arrive quickly.
+ */
+declare function reduceConversation(view: ConversationView, input: ConversationInput): ConversationView;
+
+/**
+ * The view a saved session reopens with: what its transcript and research log
+ * kept, in the order it happened — messages, notices and the compaction
+ * summary, plan markers, tool calls with each subagent's calls nested under
+ * it, and the token line. Reasoning and streamed text were never saved, so a
+ * reload has none.
+ *
+ * The research log interleaves with the transcript by time. Entries older than
+ * a compaction's first kept message went with the turns it condensed.
+ */
+declare function fromTranscript(conversationHistory: readonly ConversationMessage[] | undefined, researchLog: readonly ResearchLogEntry[] | undefined, plannerUsage?: PlannerUsage): ConversationView;
+
+/**
+ * The one-line head of a command row, shared by every surface: the tool's name
+ * and the argument that says what the call is about.
+ *
+ * @param args The call's arguments as announced (JSON). Anything that is not a
+ * JSON object is shown as it came, on one line.
+ * @param toolLabel A harness planner's own name for the tool (ADR-0009).
+ */
+declare function toolHeadline(tool: string, args: string, toolLabel?: string): ToolHeadline;
+interface OutputPreview {
+    lines: string[];
+    hiddenLineCount: number;
+}
+/** The lines of a tool's output as a reader sees them — what {@link outputPreview} shows and counts. */
+declare function outputLines(output: string): string[];
+/** The head of a tool's output for a collapsed row, and how many lines it leaves out. */
+declare function outputPreview(output: string, maxLines: number): OutputPreview;
+
+/**
+ * Prompts the user sent while a planner turn was in flight, waiting to be the
+ * next turn's input. The hold is a plain immutable list, oldest first, so a
+ * pure reducer can keep it in state and a host can keep it in a field — and
+ * either can draw it as is.
+ */
+type PromptHold = readonly string[];
+declare const EMPTY_HOLD: PromptHold;
+/** One prompt taken out of the hold, and what is left behind. */
+interface TakenPrompt {
+    text: string;
+    rest: PromptHold;
+}
+declare function holdPrompt(hold: PromptHold, text: string): PromptHold;
+/** The prompt a settled turn sends next: the oldest, so they go in the order typed. */
+declare function drainNext(hold: PromptHold): TakenPrompt | undefined;
+/**
+ * Takes back the newest prompt — the one the user most likely just regretted —
+ * while the older ones stay queued behind the turn.
+ */
+declare function unsendLatest(hold: PromptHold): TakenPrompt | undefined;
+/**
+ * A stopped turn takes its queue with it: the prompts were written against a
+ * turn that no longer exists, so they come back as one draft to edit and
+ * resend rather than firing off after the stop.
+ */
+declare function unsendAll(hold: PromptHold): TakenPrompt | undefined;
+/** Where an unsent prompt lands in the drafting input: above what is being typed, never replacing it. */
+declare function aheadOfDraft(text: string, draft: string): string;
+
+/**
+ * The planner turn a surface has open, and the one its user stopped. Kept
+ * beside the view rather than in it: the view is what a turn drew, this is
+ * whether the surface still wants to hear from it.
+ */
+interface TurnGate {
+    readonly open: string | null;
+    readonly stopped: string | null;
+}
+declare const NO_TURN: TurnGate;
+interface GatedConversation {
+    view: ConversationView;
+    gate: TurnGate;
+}
+/**
+ * One input into the view, the stop rule applied: a turn the user stopped is
+ * over on screen, and whatever it streams until the backend notices is
+ * dropped. An input that changes nothing hands back the same view and gate.
+ */
+declare function followTurn(view: ConversationView, gate: TurnGate, input: ConversationInput): GatedConversation;
+/**
+ * The user stopped the planner. The turn ends on screen now rather than when
+ * the backend notices the abort, so the surface is free at once and the
+ * turn's late output never lands. Nothing changes when no turn is open.
+ */
+declare function stopTurn(view: ConversationView, gate: TurnGate): GatedConversation;
+
+/**
+ * Whether the conversation holds anything the collapsed view hides — thinking,
+ * a command row's arguments and output, a subagent's children and digest. The
+ * detail toggle is the only expansion control (ADR-0017, X1), so a surface
+ * offers it only when it would do something.
+ */
+declare function hasHiddenDetail(blocks: readonly DisplayBlock[]): boolean;
+
+/** The conversation line for a task starting, worded the same on every surface. */
+declare function taskStartedNotice(title: string, runner?: string): string;
+
+export { holdPrompt as $, type Adr0013IsolationRun as A, aheadOfDraft as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DisplayBlock as D, EMPTY_CONVERSATION as E, applyTaskOps as F, type GatedConversation as G, canMergeTasks as H, canSetDependencies as I, canSplitTask as J, capConflictFiles as K, type LocalEntry as L, type MessageBlock as M, NO_TURN as N, type OutputPreview as O, type PlanBlock as P, classifyOutcome as Q, dependencyCandidates as R, type SerializedPlan as S, type TakenPrompt as T, type UsageBlock as U, dependentsOf as V, drainNext as W, executionSummary as X, followTurn as Y, fromTranscript as Z, hasHiddenDetail as _, type Adr0013PlanIsolation as a, migratePlanIsolation as a0, outputLines as a1, outputPreview as a2, parseTaskOpsJson as a3, reduceConversation as a4, serializePlan as a5, serializeTask as a6, serializeTaskStatus as a7, stopTurn as a8, summarizeToolCall as a9, taskStartedNotice as aa, textHasTaskOps as ab, toolHeadline as ac, truncateCheckpointSummary as ad, unsendAll as ae, unsendLatest as af, type Adr0013TaskRecord as b, type ApplyTaskOpsResult as c, type ApprovalBlock as d, type ApprovalStatus as e, type ConversationInput as f, type ConversationView as g, EMPTY_HOLD as h, type MessageRole as i, type PlanMarkerStatus as j, type PromptHold as k, type SerializedTask as l, type SerializedTaskStatus as m, type SessionBroadcaster as n, type SessionMessage as o, type SessionNotice as p, type SubagentBlock as q, type SubagentChild as r, type SubagentStatus as s, type TaskOp as t, type TaskRef as u, type ThinkingDisplayBlock as v, type ToolBlock as w, type ToolHeadline as x, type ToolStatus as y, type TurnGate as z };