@ordewell/core 0.5.4 → 0.5.6

package/dist/plan-utils-BMyEiDKv.d.ts

@@ -0,0 +1,877 @@
+import { aR as StructuredTurnEnd, aT as SubagentOutcome, b9 as UsageRecord, k as ApprovalDecision, aP as StructuredEvent, aG as RunnerId, w as DiscoveredModel, aU as Task, a6 as LegacyPlanState, aw as QueuedMessage, ba as UsageTotals, bg as Verdict, aV as TaskIsolation, b4 as TaskTransport, r as AwaitingReason, ax as QueuedTaskMessage, Q as IsolationHandoff, X as IsolationMergeResult, aC as ResearchStep, l as ApprovalKind, q as ApprovalSource, aD as ResearchStepOutcome, u as ConversationMessage, aA as ResearchLogEntry, ai as PlannerUsage } from './Task-Dyxp67s2.js';
+import { R as RunnerModeInfo } from './ModeResolver-CjpG5Wli.js';
+
+/**
+ * One entry of a structured task's log (ADR-0018, P1): what a runner did,
+ * normalized and serializable, streamed live as `task_log` and appended to
+ * the attempt's `.jsonl` file. The live view and the reload fold the same
+ * events through `reduceTaskLog`, so the two cannot disagree.
+ *
+ * Readers skip a type they do not know, which is how later events join
+ * without a format version.
+ */
+type TaskLogEvent = 
+/** A turn began by delivering `message`; `messageId` names it when it had been queued. */
+{
+    type: 'turn_start';
+    message: string;
+    messageId?: string;
+} | {
+    type: 'turn_end';
+    reason: StructuredTurnEnd;
+} | {
+    type: 'text_delta';
+    text: string;
+}
+/** A complete run of the agent's reply, authoritative over the deltas streamed for it. */
+ | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'thinking_delta';
+    text: string;
+    subagentId?: string;
+} | {
+    type: 'thinking';
+    text: string;
+    subagentId?: string;
+}
+/** `args` is the call's arguments as JSON, exactly as the runner announced them. */
+ | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    args: string;
+    subagentId?: string;
+}
+/** `omittedLines` is set when {@link trimToolOutput} cut the middle of `output`. */
+ | {
+    type: 'tool_result';
+    id: string;
+    output: string;
+    success: boolean;
+    omittedLines?: number;
+    subagentId?: string;
+} | {
+    type: 'subagent_started';
+    subagentId: string;
+    brief: string;
+    model?: string;
+} | {
+    type: 'subagent_finished';
+    subagentId: string;
+    outcome: SubagentOutcome;
+    digest: string;
+} | {
+    type: 'usage';
+    record: UsageRecord;
+} | {
+    type: 'message_queued';
+    messageId: string;
+    text: string;
+} | {
+    type: 'message_removed';
+    messageId: string;
+}
+/** The agent's own words for a failed turn. */
+ | {
+    type: 'error';
+    message: string;
+}
+/**
+ * The runner asked to use a tool its mode does not cover (ADR-0018, A1).
+ * `approvalId` is what the answer is given under; `args` is the call's
+ * arguments as JSON; `allowForTask` says the runner offered its own
+ * session-scoped grant.
+ */
+ | {
+    type: 'approval_requested';
+    approvalId: string;
+    tool: string;
+    args: string;
+    allowForTask: boolean;
+    toolCallId?: string;
+} | {
+    type: 'approval_decided';
+    approvalId: string;
+    decision: ApprovalDecision['decision'];
+    note?: string;
+}
+/** The request went unanswered: the runner withdrew it, or its process ended. */
+ | {
+    type: 'approval_withdrawn';
+    approvalId: string;
+};
+/**
+ * Keep a tool result's head and tail. A build log or a whole file read can
+ * run to megabytes, and every attempt's file keeps it for good; the ends are
+ * where a reader looks — the command's start, and how it finished.
+ */
+declare function trimToolOutput(output: string): {
+    output: string;
+    omittedLines?: number;
+};
+/**
+ * The log entry for one structured event, or null for what the log does not
+ * keep: background-agent launches, which the subagent's own events already show.
+ */
+declare function toTaskLogEvent(event: StructuredEvent): TaskLogEvent | null;
+/**
+ * Merge runs of deltas into one event each. Deltas arrive a few characters at
+ * a time; merged, a batch is one message on the wire and one line on disk,
+ * and the view folds to the same blocks either way.
+ */
+declare function coalesceTaskLog(events: readonly TaskLogEvent[]): TaskLogEvent[];
+
+/**
+ * Pure, no-imports helper so a browser surface can format a conflict's files
+ * without pulling `isolationRecord` — and its `path` import — into a webview
+ * bundle. Kept out of `isolationRecord.ts` for exactly that reason.
+ */
+declare function capConflictFiles(files: string[], max?: number): string;
+
+/**
+ * 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: readonly 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: readonly 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: readonly 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: readonly 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: readonly 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: readonly 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;
+    /** Absent unless the task's plan asked for the structured transport (ADR-0018): what it ran on, or why it fell back. */
+    transport?: Pick<TaskTransport, 'kind' | 'fallback'>;
+    /** What an `awaiting_user` task waits on, when it was saved (ADR-0018, W1). */
+    awaitingReason?: AwaitingReason;
+    /** Messages waiting for a structured task's turn to end, oldest first; absent when there are none. */
+    queued?: QueuedTaskMessage[];
+    /** Set when the task can be continued in its saved runner session (ADR-0018, K1); the id itself stays in the daemon. */
+    continuable?: true;
+    /**
+     * How many of a structured task's runner requests wait for an answer
+     * (ADR-0018, A1) — "waiting for approval", which leaves `status` alone.
+     * Absent when none do.
+     */
+    awaitingApproval?: number;
+};
+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;
+}
+/**
+ * A structured task's log as it happens (ADR-0018, P1): the next events of
+ * the task's attempt `attempt`, in order — the same ones appended to that
+ * attempt's file, so a surface folding these and one replaying the file
+ * draw the same blocks. Terminal-transport tasks send none.
+ */
+ | {
+    type: 'task_log';
+    taskId: string;
+    attempt: number;
+    events: TaskLogEvent[];
+} | {
+    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, queued?: readonly QueuedTaskMessage[], awaitingApproval?: number): SerializedTaskStatus;
+declare function serializePlan(plan: LegacyPlanState): SerializedPlan;
+declare function executionSummary(tasks: readonly 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;
+/** `agent` is a task runner speaking in a structured task's log (ADR-0018); the planner is `planner`. */
+type MessageRole = 'user' | 'planner' | 'agent' | '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;
+}
+/** `withdrawn`: a runner's request that went unanswered — the runner cancelled it, or its process ended. */
+type ApprovalStatus = 'pending' | 'granted' | 'denied' | 'withdrawn';
+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;
+    /** A runner's request (`runner_tool`) that can also be allowed for the rest of its task. */
+    allowForTask?: boolean;
+    /** Granted for the rest of the task, not this call alone. */
+    forTask?: boolean;
+    /** What a denial told the agent. */
+    note?: string;
+    /** The runner's tool call the request is about. */
+    toolCallId?: 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>;
+}
+
+/** What every view over display blocks holds; each view adds its own state beside it. */
+interface BlockList {
+    readonly blocks: readonly DisplayBlock[];
+    readonly nextId: number;
+}
+
+/**
+ * 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 extends BlockList {
+    /**
+     * 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;
+
+/**
+ * What a surface draws for one attempt of a structured task (ADR-0018, O1b):
+ * the same display blocks as the planner conversation, built from the task's
+ * {@link TaskLogEvent}s. No planner turn ids — a task's turns are its own,
+ * one at a time.
+ */
+interface TaskLogView extends BlockList {
+    /** Messages waiting for the running turn to end, oldest first. */
+    readonly queued: readonly QueuedTaskMessage[];
+    /** A turn is running. */
+    readonly working: boolean;
+    /** How the last turn ended; absent before the first one does. */
+    readonly lastTurnEnd?: StructuredTurnEnd;
+    /** What the runner reported over the attempt, subagents included. */
+    readonly usage?: PlannerUsage;
+    /**
+     * The block each run of deltas streams into, keyed by stream, so the run's
+     * authoritative copy replaces it instead of repeating it below.
+     */
+    readonly streams: Readonly<Record<string, string>>;
+}
+declare const EMPTY_TASK_LOG: TaskLogView;
+/** A runner's tool request, read the way its call's row reads: `Bash(npm test)`. */
+declare function runnerToolSubject(tool: string, args: string): string;
+/**
+ * Fold one task-log event into the view. Pure and incremental, like
+ * `reduceConversation`: an event that changes nothing returns `view` itself,
+ * and an event of a type this build does not know is skipped — a log written
+ * by a newer Ordewell still reads.
+ */
+declare function reduceTaskLog(view: TaskLogView, event: TaskLogEvent): TaskLogView;
+/** A whole attempt's events, folded from the start — what a reload shows. */
+declare function replayTaskLog(events: readonly TaskLogEvent[], from?: TaskLogView): TaskLogView;
+
+/**
+ * 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 { hasHiddenDetail as $, type ApplyTaskOpsResult 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, coalesceTaskLog as R, type SerializedPlan as S, type TakenPrompt as T, type UsageBlock as U, dependencyCandidates as V, dependentsOf as W, drainNext as X, executionSummary as Y, followTurn as Z, fromTranscript as _, type ApprovalBlock as a, holdPrompt as a0, outputLines as a1, outputPreview as a2, parseTaskOpsJson as a3, reduceConversation as a4, reduceTaskLog as a5, replayTaskLog as a6, runnerToolSubject as a7, serializePlan as a8, serializeTask as a9, serializeTaskStatus as aa, stopTurn as ab, summarizeToolCall as ac, taskStartedNotice as ad, textHasTaskOps as ae, toTaskLogEvent as af, toolHeadline as ag, trimToolOutput as ah, truncateCheckpointSummary as ai, unsendAll as aj, unsendLatest as ak, type ApprovalStatus as b, type ConversationInput as c, type ConversationView as d, EMPTY_HOLD as e, EMPTY_TASK_LOG as f, type MessageRole as g, type PlanMarkerStatus as h, type PromptHold as i, type SerializedTask as j, type SerializedTaskStatus as k, type SessionBroadcaster as l, type SessionMessage as m, type SessionNotice as n, type SubagentBlock as o, type SubagentChild as p, type SubagentStatus as q, type TaskLogEvent as r, type TaskLogView 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 };