@ordewell/core 0.5.5 → 0.6.0

package/dist/{plan-utils-pE4TBwxl.d.mts → plan-utils-Ba-l8EZS.d.mts}

@@ -1,39 +1,134 @@
-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-.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-D-SUFRNF.mjs';
-import { A as ApprovalKind, e as ApprovalSource } from './ApprovalPolicy-BVhGdECT.mjs';
+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-CZJr6rmz.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-a4xJFlEp.mjs';
 
-/** 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[];
+/**
+ * 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;
 }
-/** A run as ADR-0013 persisted it (0.4.23): one repository, its refs on the run itself. */
-interface Adr0013IsolationRun {
+/** `args` is the call's arguments as JSON, exactly as the runner announced them. */
+ | {
+    type: 'tool_call';
     id: string;
-    workspaceRoot: string;
-    baseRef: string;
-    baseBranch?: string;
-    integrationBranch: string;
-    tasks: Record<string, Adr0013TaskRecord>;
+    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;
 }
-interface Adr0013PlanIsolation {
-    run: Adr0013IsolationRun;
-    resolvers: Record<string, 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[];
+
 /**
- * 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.
+ * 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 migratePlanIsolation(state: PlanIsolation | Adr0013PlanIsolation): PlanIsolation;
+declare function capConflictFiles(files: string[], max?: number): string;
 
 /**
  * The catalog a model/task-mode edit is checked against — the same discovered
@@ -87,7 +182,7 @@ declare function textHasTaskOps(text: string): boolean;
 declare function parseTaskOpsJson(text: string): TaskOp[];
 interface ApplyTaskOpsResult {
     ok: boolean;
-    tasks: Task[];
+    tasks: readonly Task[];
     errors: string[];
     /** Human-readable summary of what changed, for the chat transcript. */
     summary: string[];
@@ -101,7 +196,7 @@ interface ApplyTaskOpsResult {
  * 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[]): {
+declare function canMergeTasks(tasks: readonly Task[], selectedIds: string[]): {
     ok: boolean;
     error?: string;
 };
@@ -128,14 +223,14 @@ declare function dependentsOf<T extends Pick<TaskRef, 'id' | 'dependencies'>>(ta
  * 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[];
+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: T[], taskId: string, dependencies: string[]): {
+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: Task[], taskId: string): {
+declare function canSplitTask(tasks: readonly Task[], taskId: string): {
     ok: boolean;
     error?: string;
 };
@@ -145,7 +240,7 @@ declare function canSplitTask(tasks: Task[], taskId: string): {
  * 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;
+declare function applyTaskOps(currentTasks: readonly Task[], ops: TaskOp[], runners: RunnerId[], catalog?: EditCatalog): ApplyTaskOpsResult;
 
 type SerializedTaskStatus = {
     id: string;
@@ -159,6 +254,20 @@ type SerializedTaskStatus = {
     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;
@@ -365,6 +474,18 @@ type SessionMessage =
     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';
@@ -431,9 +552,9 @@ type SessionNotice = {
 };
 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 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: Task[]): {
+declare function executionSummary(tasks: readonly Task[]): {
     total: number;
     completed: number;
     failed: number;
@@ -467,7 +588,8 @@ declare function classifyOutcome(success: boolean, output: string): ResearchStep
  * 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';
+/** `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;
@@ -539,7 +661,8 @@ interface SubagentBlock {
     usage?: UsageTotals;
     turnId?: string;
 }
-type ApprovalStatus = 'pending' | 'granted' | 'denied';
+/** `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;
@@ -553,6 +676,14 @@ interface ApprovalBlock {
     /** 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 {
@@ -578,6 +709,12 @@ interface UsageBlock {
     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.
@@ -588,9 +725,7 @@ interface LocalEntry {
     text: string;
 }
 type ConversationInput = SessionMessage | LocalEntry;
-interface ConversationView {
-    readonly blocks: readonly DisplayBlock[];
-    readonly nextId: number;
+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`
@@ -619,6 +754,40 @@ declare function reduceConversation(view: ConversationView, input: ConversationI
  */
 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.
@@ -705,4 +874,4 @@ 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 };
+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 };