@ordewell/core 0.10.4 → 0.10.5

package/dist/parsing.mjs

@@ -1,12 +1,12 @@
 import {
   parsePlanJson
-} from "./chunk-645FALZX.mjs";
+} from "./chunk-F3KIX7WR.mjs";
 import {
   PlanParseError,
   extractJsonObject,
   stripModelNoise
-} from "./chunk-A57ITQE7.mjs";
-import "./chunk-SM6BV6XS.mjs";
+} from "./chunk-4QLFM73A.mjs";
+import "./chunk-RT4NQ2BZ.mjs";
 
 // src/services/PartialPlanParser.ts
 function parsePartialPlan(partial) {

package/dist/{plan-utils-POIz5d8z.d.ts → plan-utils-BVJCzNvm.d.ts}

@@ -1,6 +1,6 @@
-import { af as Task, a2 as RunnerId, an as TaskSnapshot, b as AwaitingReason, ar as UsageRecord, d as DiscoveredModel, ac as SkillsService, a7 as SkillInfo, X as RepoGroupLayout, I as IWorktreeIsolation, w as IsolationRun, k as IsolationHandoff, J as PlanIsolation, x as IsolationTaskRecord, ai as TaskIsolation, H as IsolationView, R as PrepareIntent, U as PreviousWork, s as IsolationOutcome, W as RepairEvidence, ap as TreeSnapshot, ag as TaskDiffRead, ah as TaskDiffResult, r as IsolationMergeResult, at as Verdict, am as TaskSkillSnapshot, al as TaskSkillNotice, ad as SubagentOutcome, L as LegacyPlanState, C as ConversationMessage, a9 as SkillLoadNotice, P as PendingPlanTurn, a as AttemptUsage, M as ModelUsage, as as UsageTotals, O as PlanUsage, f as ExecutionRecord, _ as ResearchStep, a1 as RunSettings, K as PlanState, ae as SupervisorLevel, $ as ResearchStepOutcome, Y as ResearchLogEntry, Q as PlannerUsage, aj as TaskIsolationState, aq as UsageLine } from './Task-DZs9eKgg.js';
-import { R as RunnerModeInfo } from './ModeResolver-Dy3Ef6p-.js';
-import { B as IRunnerSession, y as IConfig, aC as TaskMessageFrom, ai as RunnerCommand, an as RunnerMcpServer, av as StructuredTurnEnd, j as ApprovalDecision, au as StructuredEvent, ab as QueuedTaskMessage, k as ApprovalKind, q as ApprovalSource, z as IRunner, aq as RunnerRegistry } from './IRunner-D_UkkMbJ.js';
+import { ah as Task, a3 as RunnerId, ap as TaskSnapshot, b as AwaitingReason, au as UsageRecord, a4 as RunnerSessionCost, d as DiscoveredModel, ae as SkillsService, a9 as SkillInfo, Y as RepoGroupLayout, I as IWorktreeIsolation, w as IsolationRun, k as IsolationHandoff, J as PlanIsolation, x as IsolationTaskRecord, ak as TaskIsolation, H as IsolationView, S as PrepareIntent, V as PreviousWork, s as IsolationOutcome, X as RepairEvidence, as as TreeSnapshot, ai as TaskDiffRead, aj as TaskDiffResult, r as IsolationMergeResult, aw as Verdict, ao as TaskSkillSnapshot, an as TaskSkillNotice, af as SubagentOutcome, L as LegacyPlanState, C as ConversationMessage, ab as SkillLoadNotice, P as PendingPlanTurn, a as AttemptUsage, M as ModelUsage, av as UsageTotals, O as PlanUsage, f as ExecutionRecord, $ as ResearchStep, a2 as RunSettings, K as PlanState, ag as SupervisorLevel, a0 as ResearchStepOutcome, Z as ResearchLogEntry, R as PlannerUsage, al as TaskIsolationState, ar as TaskUsageSummary } from './Task-D4QHjdGv.js';
+import { R as RunnerModeInfo } from './ModeResolver-CUR5jCSU.js';
+import { B as IRunnerSession, y as IConfig, aD as TaskMessageFrom, aq as RunnerModelRef, ai as RunnerCommand, an as RunnerMcpServer, aw as StructuredTurnEnd, j as ApprovalDecision, av as StructuredEvent, ab as QueuedTaskMessage, k as ApprovalKind, q as ApprovalSource, z as IRunner, ar as RunnerRegistry } from './IRunner-Crkt3tHD.js';
 
 type NotificationAction = {
     label: string;
@@ -146,11 +146,13 @@ declare class PlanStore {
     unblockDependents(id: string): void;
     setTaskVerdict(id: string, verdict: Task['verdict']): void;
     setTaskOutputSummary(id: string, summary: Task['outputSummary']): void;
-    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined): void;
+    /** The owner is saved with the session it belongs to, and dropped with it. */
+    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined, owner?: RunnerId): void;
+    setCarriedFrom(id: string, runner: RunnerId): void;
     clearCarriedFrom(id: string): void;
     startAttemptUsage(id: string, attempt: number, runner: string, startedAt: string): void;
     recordAttemptUsage(id: string, attempt: number, record: UsageRecord, now: string): void;
-    endAttemptUsage(id: string, attempt: number, now: string): void;
+    endAttemptUsage(id: string, attempt: number, now: string, runnerSessionCost?: RunnerSessionCost, sessionId?: string): void;
     setTaskAttemptSkills(id: string, skills: Task['attemptSkills']): void;
     /**
      * Widen the plan's runner set. Retargeting a task onto a runner the plan has
@@ -177,6 +179,13 @@ interface EditCatalog {
     perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
     /** Full (true) or Guarded: the mode a task the planner writes lands on unless it is read-only (ADR-0031). Full when absent. */
     autonomousDefault?: boolean;
+    /**
+     * Whether a task's runner is up now. Its model is then the runner's (#106):
+     * the process was started on one and only the runner's own command moves it,
+     * so an edit from outside would leave the plan naming what is not running.
+     * Absent means none is.
+     */
+    liveRunner?: (taskId: string) => boolean;
 }
 
 /**
@@ -799,6 +808,23 @@ type TaskLogEvent =
     preTokens?: number;
     postTokens?: number;
 }
+/**
+ * The runner's main thread moved to another model, and what the plan says
+ * once the write-back settled (#106): written from its outcome, not from the
+ * runner's event, so the line never claims an edit that did not land.
+ * `kept` says why the plan did not follow, when it did not. A log saved
+ * before the plan's side was recorded has no `plan`: it says nothing of it.
+ */
+ | {
+    type: 'model_switched';
+    from: RunnerModelRef;
+    to: RunnerModelRef;
+    plan?: {
+        model?: RunnerModelRef;
+        effort?: string;
+    };
+    kept?: string;
+}
 /** What the runner loaded from the user's and the project's setup, as its process started. */
  | {
     type: 'runner_loaded';
@@ -940,7 +966,8 @@ declare function trimToolOutput(output: string): {
 };
 /**
  * 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.
+ * keep: background-agent launches, which the subagent's own events already
+ * show, and a model change, which is logged with what the plan made of it.
  */
 declare function toTaskLogEvent(event: StructuredEvent): TaskLogEvent | null;
 /** A log as a surface is sent it, live or read back: everything but the skills' bodies. */
@@ -1078,6 +1105,8 @@ type SurfacePlanState = (Omit<Extract<PlanState, {
 });
 type SerializedPlan = {
     runSettings?: LegacyPlanState['runSettings'];
+    /** What waits on the planner's usage limit, and when it goes, so a surface can say so and offer to cancel it. */
+    plannerResend?: LegacyPlanState['plannerResend'];
     tasks: SerializedTask[];
     runners: RunnerId[];
     generatedAt: string;
@@ -1511,6 +1540,22 @@ interface OrchestratorObserver {
         resumeAt: string | null;
         cancelled?: true;
     }): void;
+    /**
+     * A task's runner now answers on another model (#106). `asked` when a model
+     * command sent through its chat chose it: the user's own choice, which the
+     * plan is to follow. `attemptEnded` when the attempt that runs `sessionId`
+     * is no longer the task's, so the switch says nothing of what runs next.
+     * `effort` only where the runner reported one.
+     */
+    onModelSwitched?(data: {
+        taskId: string;
+        sessionId: string;
+        from: RunnerModelRef;
+        model: RunnerModelRef;
+        effort?: string;
+        asked: boolean;
+        attemptEnded: boolean;
+    }): void;
     /** A live task's runner went silent (ADR-0018's idle timer); paused while it waits on input, a checkpoint or an approval. */
     onTaskIdle?(data: {
         taskId: string;
@@ -1596,6 +1641,12 @@ interface TaskOrchestratorDeps {
     skillsAt: (roots: readonly string[]) => SkillLookup;
     /** What the task's last saved attempt did, or null when it left no log (ADR-0020). */
     previousAttemptFromLog: (taskId: string) => string | null;
+    /**
+     * The newest attempt the task has a saved log for, 0 for none. An attempt's
+     * log is saved under its number, so a new one is numbered past a log kept
+     * from before the task had ledgers.
+     */
+    lastLoggedAttempt: (taskId: string) => number;
     /**
      * The open run's settings, read as each automatic merge is decided rather
      * than copied when the run opens, so a change to the run under way applies
@@ -1625,6 +1676,7 @@ interface TaskOrchestratorOptions {
     workspaceEnv?: (cwd: string) => Promise<WorkspaceEnv>;
     skillsAt?: (roots: readonly string[]) => SkillLookup;
     previousAttemptFromLog?: (taskId: string) => string | null;
+    lastLoggedAttempt?: (taskId: string) => number;
     runSettings?: () => SchedulerRunSettings | undefined;
     /** Every task is approved unless a Session supplies its record: an orchestrator on its own has no user to ask. */
     isApproved?: (taskId: string) => boolean;
@@ -1683,6 +1735,12 @@ declare class TaskOrchestrator {
      * task whose spawn always throws.
      */
     private onHold;
+    /**
+     * Force starts queued behind dependencies the scheduler will not start them
+     * after: outside a run it drives, or past a failed dependency, which it
+     * never forces. Each starts once those still under way have finished.
+     */
+    private queuedStarts;
     /**
      * Tasks Mark complete is landing after it ended their attempt: in progress
      * with no attempt for as long as that takes, and not orphans for it.
@@ -1704,6 +1762,7 @@ declare class TaskOrchestrator {
     private observers;
     private skillsAt;
     private previousAttemptFromLog;
+    private lastLoggedAttempt;
     private runSettings;
     private isApproved;
     constructor(deps: TaskOrchestratorDeps);
@@ -1820,8 +1879,9 @@ declare class TaskOrchestrator {
     admitStart(): StartAdmission;
     /**
      * Something can still start that nobody has to ask for again: a start
-     * admitted and not yet claimed, or a task that resumes on its own at its
-     * usage limit's reset. A Stop is owed to it, whether or not anything runs.
+     * admitted and not yet claimed, a force start queued behind its
+     * dependencies, or a task that resumes on its own at its usage limit's
+     * reset. A Stop is owed to it, whether or not anything runs.
      */
     get startsPending(): boolean;
     /** Run `work`, which awaits before it claims, under an admission it holds throughout; it is handed the generation it was admitted under. */
@@ -2022,6 +2082,13 @@ declare class TaskOrchestrator {
      * runner has to call first. False when no resume was scheduled for it.
      */
     cancelScheduledResume(taskId: string): boolean;
+    /**
+     * The runner whose attempt left the task's work, when the task has been
+     * moved off it since: a session cannot cross runners, so whatever starts
+     * the task next is a carry-over of that work, the rule a paused task's move
+     * follows (ADR-0018, U1).
+     */
+    private movedFrom;
     /**
      * Run before writing assignments so cancellation sees the old runner's
      * shared wait. A session cannot cross runners, so the next attempt is a
@@ -2080,16 +2147,38 @@ declare class TaskOrchestrator {
      */
     private mayResumeAtReset;
     /**
-     * Manually start a single AI task right now, bypassing dependency/readiness
-     * gating (the "force start" affordance on a task card) but never the claim:
-     * it still needs the user's approval, a free slot, and no Stop since it was
-     * asked for, and throws {@link TaskControlError} saying which it lacks.
+     * Manually start a single AI task right now (the "force start" affordance on
+     * a task card), past a failed dependency (ADR-0034) or a merge gate
+     * (ADR-0020), but never past the claim: it still needs the user's approval,
+     * a free slot, and no Stop since it was asked for, and throws
+     * {@link TaskControlError} saying which it lacks. A dependency still under
+     * way or yet to run is not forced past: the task is released to the
+     * scheduler instead, which starts it once they finish, and the line saying
+     * so is the answer.
      * Reuses the scheduler's own claim so a force-started task gets the same
      * augmented prompt, session tracking, and exit handling — callers must not
      * re-spawn the runner themselves. No-op if the task is unknown, not an AI
      * task, or already running.
      */
-    forceStartTask(taskId: string, origin?: RunOrigin): Promise<void>;
+    forceStartTask(taskId: string, origin?: RunOrigin): Promise<string | undefined>;
+    /**
+     * A force start of a task whose dependencies are still under way or yet to
+     * run: started now, it would build on work that is not there, so it waits
+     * for them in the run, off any hold, and says so. Dependencies are never
+     * bypassed silently. A blocked task is forced past its failure as asked.
+     */
+    private queuedBehindDependencies;
+    /**
+     * A task's unmet dependencies, less the failed or blocked ones a force start
+     * goes past. A blocked one is gone past for its failure only: the work under
+     * way or yet to run that it waits on is still waited for, through it.
+     */
+    private underWayBefore;
+    /**
+     * Starts the queued force starts whose dependencies have now finished. One
+     * the scheduler now drives the run for, and nothing blocks, is left to it.
+     */
+    private startQueued;
     private refuseOpsDuringMerge;
     /**
      * A force start passes a merge gate (ADR-0020), and the surface confirmed it
@@ -2193,6 +2282,51 @@ declare class TaskOrchestrator {
     private endAllAttempts;
 }
 
+/**
+ * What the user allows the plan to be built from right now: the enabled
+ * runners and each runner's model allowlist. Structural, so a surface that
+ * only holds the two lists can ask without a session.
+ */
+interface AssignmentScope {
+    enabledRunners: readonly string[];
+    allowlist: Readonly<Record<string, readonly string[] | undefined>>;
+    /**
+     * The models discovery has found per runner, where the holder has them. An
+     * allowlist is read against them exactly as the planner's catalog reads it
+     * (ids only another runner lists limit nothing), so a flag never says a
+     * model is off a list the planner sees as no limit.
+     */
+    models?: Readonly<Partial<Record<RunnerId, readonly DiscoveredModel[]>>>;
+}
+/** The part of a task an assignment is read from. */
+interface AssignedTask {
+    type: string;
+    status: string;
+    assignedRunner: string;
+    assignedModel?: {
+        modelId: string;
+        modelLabel?: string;
+    };
+}
+type AssignmentIssue = {
+    kind: 'runner-off';
+    runner: string;
+} | {
+    kind: 'model-off-list';
+    runner: string;
+    modelId: string;
+    modelLabel: string;
+};
+/**
+ * Whether a task sits outside the scope it is read against. This only names
+ * the mismatch: such a task still runs (ADR-0003, P1) — the allowlist and the
+ * enabled runners shape what is planned, not what is started — and the user or
+ * the planner may move it. A runner that is off settles the matter before its
+ * model is looked at.
+ */
+declare function assignmentIssue(task: AssignedTask, scope: AssignmentScope): AssignmentIssue | null;
+declare function assignmentIssueText(issue: AssignmentIssue): string;
+
 /**
  * Task references: the one grammar for naming a task in a plan, both ways.
  * A label is rendered from a task's order under its parent ("2", "2.1"), and
@@ -2304,10 +2438,29 @@ declare function runSettingsOf(settings: UserSettings): GlobalRunSettings;
 declare class SettingsService {
     private filePath;
     private cache;
-    private cachedMtimeMs;
+    private cachedStamp;
     constructor(filePath?: string);
     getAll(): UserSettings;
-    private fileMtimeMs;
+    /**
+     * Every write replaces the file, so its inode changes with it; the mtime
+     * alone cannot tell two writes apart on a filesystem whose timestamps are
+     * coarse, and a write that shares the last one's tick stayed unseen.
+     */
+    private fileStamp;
+    /**
+     * What a change is applied to: the file as it is now, never a copy held since
+     * an earlier read. Another process may have saved in between, and writing
+     * the whole file back would silently undo it.
+     */
+    private current;
+    /**
+     * Calls `listener` when another process (or this one) saves the file. The
+     * directory is watched, not the file: a write that swaps the file in leaves
+     * a watch on the old one pointing at nothing.
+     */
+    watch(listener: () => void): {
+        dispose(): void;
+    };
     getModelAllowlist(runner: string): string[] | undefined;
     setModelAllowlist(runner: string, ids: string[] | undefined): void;
     getPlannerModel(provider: string): {
@@ -2320,6 +2473,16 @@ declare class SettingsService {
     } | undefined): void;
     getEnabledRunners(): string[] | undefined;
     setEnabledRunners(ids: string[]): void;
+    /**
+     * Change the list from what the file holds at this moment: the change is
+     * handed the saved list (undefined when the user never chose) and its result
+     * is saved in the same call. A list worked out from an earlier read would
+     * save over what another surface set since. It may be handed the list again,
+     * when another process saved before this one could (see {@link save}).
+     */
+    updateEnabledRunners(change: (saved: string[] | undefined) => string[]): string[];
+    /** Save `ids` as the user's choice unless one is saved already, judged on the file as it is now. */
+    setEnabledRunnersIfUnset(ids: string[]): boolean;
     /**
      * Full or Guarded (ADR-0001), as saved here (ADR-0030). A value set in the
      * environment wins, so a script or CI run can fix its own without touching
@@ -2333,6 +2496,17 @@ declare class SettingsService {
     /** Checks every value before writing any, so a refused change saves nothing. */
     updateRunSettings(changes: Partial<GlobalRunSettings>): GlobalRunSettings;
     private load;
+    /**
+     * Makes `change` to the file as it is now, and saves it. Another process can
+     * save between that read and this write; the file is looked at again just
+     * before ours replaces it, and when it moved the change is made afresh from
+     * what that process saved, so neither save undoes the other. A file that
+     * keeps moving is written over after {@link SAVE_TRIES} tries rather than
+     * never. The look and the swap are one step under the file's lock
+     * ({@link withFileLock}). A change that changes nothing writes nothing.
+     */
+    private save;
+    /** False, saving nothing, when the file is no longer the one stamped `expected`. */
     private persist;
 }
 
@@ -2837,7 +3011,7 @@ declare function skippedLabel(reason: string | null): string;
  * for them (ADR-0035). Not a runner approval: nothing has started, so no
  * runner is asking anything.
  */
-declare const WAITS_FOR_APPROVAL_LABEL = "Waiting for your approval to start";
+declare const WAITS_FOR_APPROVAL_LABEL = "Waits for your approval";
 /** Runner requests a task waits on (ADR-0018, A1); null when none do. */
 declare function approvalLabel(count: number | undefined): string | null;
 /**
@@ -2914,6 +3088,11 @@ interface TaskRowSubject {
     mergeGate?: readonly string[];
     forcedPastGate?: readonly string[];
     attemptUsage?: readonly AttemptUsage[];
+    assignedRunner?: string;
+    assignedModel?: {
+        modelId: string;
+        modelLabel?: string;
+    };
 }
 interface TaskRowIsolation {
     state: TaskIsolationState;
@@ -2955,12 +3134,14 @@ interface TaskRowContext {
     }[];
     /** What a resume time is read against; the clock when absent. */
     now?: Date;
+    /** The enabled runners and allowlist an assignment is read against; without it no assignment is flagged. */
+    runnerScope?: AssignmentScope;
 }
 /** Whether the row stands for an AI task, a manual one, or an ops task (ADR-0020). */
 type TaskRowKind = 'ai' | 'user' | 'ops';
-interface TaskRowUsage extends UsageLine {
+/** The task's whole spend (see `taskUsageSummary`); `attempt` is the latest one, 0 before any reported. */
+interface TaskRowUsage extends Pick<TaskUsageSummary, 'totals' | 'contextFill'> {
     attempt: number;
-    wallTimeMs?: number;
 }
 interface TaskRowView {
     usage: TaskRowUsage | null;
@@ -2978,6 +3159,10 @@ interface TaskRowView {
     approvals: string | null;
     /** That it waits for the user's approval to start, in sentence case; null once it started, or when it needs none. */
     waitsForApproval: string | null;
+    /** Why the task's runner or model is one the user has since moved away from, in sentence case; null when it is not. The task still runs. */
+    assignmentFlag: string | null;
+    /** What the flag means for this task as it stands (a failed one runs again only if retried); set exactly when `assignmentFlag` is. */
+    assignmentConsequence: string | null;
     /** The task's mode is tagged autonomous: it runs without permission prompts. */
     autonomous: boolean;
     /** The repos its isolated work changed, by path; empty for a group of one. */
@@ -3075,4 +3260,4 @@ declare function parseSwitch(arg: string): boolean | null;
 /** A whole number at least `min`, as typed; null for anything else. */
 declare function parseCount(arg: string | undefined, min: number): number | null;
 
-export { type RunTask as $, ACT_RISK as A, type BlockingSubject as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DiffRow as D, EMPTY_CONVERSATION as E, NO_TURN as F, type GatedConversation as G, type HeldEdit as H, type INotification as I, type NewTaskFields as J, type NotificationAction as K, type LiveTail as L, type MarkdownToken as M, NOT_STARTED as N, type OrchestratorObserver as O, type OutputPreview as P, type PlanBlock as Q, type PlanMarkerStatus as R, type PlanSnapshot as S, PlanStore as T, type PlannerModes as U, type PromptHold as V, RUN_SETTINGS_DEFAULTS as W, type RefTask as X, type RunInput as Y, type RunMergeView as Z, RunSettingsError as _, AUTORUN_RISK as a, capConflictFiles as a$, type RunTaskStatus as a0, type RunView as a1, type RunnerLoadedBlock as a2, STOPPED_BEFORE_START as a3, SUPERVISOR_LEVEL_LABEL as a4, type SerializedConversationMessage as a5, type SerializedPendingTurn as a6, type SerializedPlan as a7, type SerializedTask as a8, type SerializedTaskStatus as a9, type TaskRowContext as aA, type TaskRowIsolation as aB, type TaskRowKind as aC, type TaskRowPlacement as aD, type TaskRowSubject as aE, type TaskRowUsage as aF, type TaskRowView as aG, type TaskStatusKind as aH, type ThinkingDisplayBlock as aI, type ToolBlock as aJ, type ToolHeadline as aK, type ToolStatus as aL, type TurnGate as aM, type UsageBlock as aN, type UserSettings as aO, WAITS_FOR_APPROVAL_LABEL as aP, aheadOfDraft as aQ, applyTaskOps as aR, approvalLabel as aS, automergeSummary as aT, autorunSummary as aU, awaitingLabel as aV, blockedByLabel as aW, blockingFailures as aX, canMergeTasks as aY, canSetDependencies as aZ, canSplitTask as a_, type SessionBroadcaster as aa, type SessionMessage as ab, type SessionNotice as ac, SettingsService as ad, type SkillLoadBlock as ae, type SkillLookup as af, type SkillToken as ag, type StartAdmission as ah, type SubagentBlock as ai, type SubagentChild as aj, type SubagentStatus as ak, type SurfacePlan as al, type SurfacePlanState as am, type SurfaceTask as an, type TakenPrompt as ao, type TaskAttemptSnapshot as ap, TaskControlError as aq, type TaskLogEvent as ar, type TaskLogView as as, type TaskOp as at, TaskOrchestrator as au, type TaskOrchestratorDeps as av, type TaskOrchestratorOptions as aw, type TaskOutputSource as ax, type TaskRef as ay, type TaskRowAction as az, type ApplyTaskOpsResult as b, titledTaskRefOf as b$, classifyOutcome as b0, coalesceTaskLog as b1, dependencyCandidates as b2, dependentsNotice as b3, dependentsOf as b4, diffRows as b5, diffStat as b6, diffSummary as b7, digestTaskLog as b8, drainNext as b9, resolveTaskRef as bA, resumeLabel as bB, resumeTime as bC, runSettingsOf as bD, runnerToolSubject as bE, serializePlan as bF, serializeTask as bG, serializeTaskStatus as bH, skillTokens as bI, skippedLabel as bJ, stopTurn as bK, summarizeToolCall as bL, supervisorSummary as bM, surfacePlan as bN, surfacePlanState as bO, takeAt as bP, taskLogForSurface as bQ, taskOrderLabel as bR, taskRef as bS, taskRefOf as bT, taskRowActions as bU, taskRowView as bV, taskStartedNotice as bW, taskStatusKind as bX, textHasTaskOps as bY, titledRefs as bZ, titledTaskRef as b_, executionSummary as ba, followTurn as bb, fromTranscript as bc, getSettingsPath as bd, hasHiddenDetail as be, holdPrompt as bf, isTaskRunning as bg, loadedSkillTokens as bh, markAction as bi, markRequestFor as bj, markdownHtml as bk, markdownTokens as bl, namedRepos as bm, newTaskFields as bn, opsEditable as bo, outputLines as bp, outputPreview as bq, parseCount as br, parseSwitch as bs, parseTaskOpsJson as bt, pastGateConfirmation as bu, reconcileApprovals as bv, reduceConversation as bw, reduceRun as bx, reduceTaskLog as by, replayTaskLog as bz, type ApprovalBlock as c, toTaskLogEvent as c0, toolHeadline as c1, trimToolOutput as c2, truncateCheckpointSummary as c3, unsendAll as c4, unsendLatest as c5, type ApprovalStatus as d, type AutoMergeTrigger as e, type CommandBlock as f, type CommandStatus as g, type CompactionBlock as h, type ConversationInput as i, type ConversationView as j, type DiffRowKind as k, type DiffStat as l, type DisplayBlock as m, EMPTY_HOLD as n, EMPTY_RUN as o, EMPTY_TASK_LOG as p, type EditCatalog as q, type ExecutionSummary as r, type GlobalRunSettings as s, type HeldEditMark as t, type IsolatedExecution as u, IsolationRunController as v, type LiveTailOptions as w, type LocalEntry as x, type MessageBlock as y, type MessageRole as z };
+export { type RunMergeView as $, ACT_RISK as A, type BlockingSubject as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DiffRow as D, EMPTY_CONVERSATION as E, type MessageBlock as F, type GatedConversation as G, type HeldEdit as H, type INotification as I, type MessageRole as J, NO_TURN as K, type LiveTail as L, type MarkdownToken as M, NOT_STARTED as N, type NewTaskFields as O, type NotificationAction as P, type OrchestratorObserver as Q, type OutputPreview as R, type PlanBlock as S, type PlanMarkerStatus as T, type PlanSnapshot as U, PlanStore as V, type PlannerModes as W, type PromptHold as X, RUN_SETTINGS_DEFAULTS as Y, type RefTask as Z, type RunInput as _, AUTORUN_RISK as a, blockingFailures as a$, RunSettingsError as a0, type RunTask as a1, type RunTaskStatus as a2, type RunView as a3, type RunnerLoadedBlock as a4, STOPPED_BEFORE_START as a5, SUPERVISOR_LEVEL_LABEL as a6, type SerializedConversationMessage as a7, type SerializedPendingTurn as a8, type SerializedPlan as a9, type TaskRef as aA, type TaskRowAction as aB, type TaskRowContext as aC, type TaskRowIsolation as aD, type TaskRowKind as aE, type TaskRowPlacement as aF, type TaskRowSubject as aG, type TaskRowUsage as aH, type TaskRowView as aI, type TaskStatusKind as aJ, type ThinkingDisplayBlock as aK, type ToolBlock as aL, type ToolHeadline as aM, type ToolStatus as aN, type TurnGate as aO, type UsageBlock as aP, type UserSettings as aQ, WAITS_FOR_APPROVAL_LABEL as aR, aheadOfDraft as aS, applyTaskOps as aT, approvalLabel as aU, assignmentIssue as aV, assignmentIssueText as aW, automergeSummary as aX, autorunSummary as aY, awaitingLabel as aZ, blockedByLabel as a_, type SerializedTask as aa, type SerializedTaskStatus as ab, type SessionBroadcaster as ac, type SessionMessage as ad, type SessionNotice as ae, SettingsService as af, type SkillLoadBlock as ag, type SkillLookup as ah, type SkillToken as ai, type StartAdmission as aj, type SubagentBlock as ak, type SubagentChild as al, type SubagentStatus as am, type SurfacePlan as an, type SurfacePlanState as ao, type SurfaceTask as ap, type TakenPrompt as aq, type TaskAttemptSnapshot as ar, TaskControlError as as, type TaskLogEvent as at, type TaskLogView as au, type TaskOp as av, TaskOrchestrator as aw, type TaskOrchestratorDeps as ax, type TaskOrchestratorOptions as ay, type TaskOutputSource as az, type ApplyTaskOpsResult as b, taskStatusKind as b$, canMergeTasks as b0, canSetDependencies as b1, canSplitTask as b2, capConflictFiles as b3, classifyOutcome as b4, coalesceTaskLog as b5, dependencyCandidates as b6, dependentsNotice as b7, dependentsOf as b8, diffRows as b9, reduceConversation as bA, reduceRun as bB, reduceTaskLog as bC, replayTaskLog as bD, resolveTaskRef as bE, resumeLabel as bF, resumeTime as bG, runSettingsOf as bH, runnerToolSubject as bI, serializePlan as bJ, serializeTask as bK, serializeTaskStatus as bL, skillTokens as bM, skippedLabel as bN, stopTurn as bO, summarizeToolCall as bP, supervisorSummary as bQ, surfacePlan as bR, surfacePlanState as bS, takeAt as bT, taskLogForSurface as bU, taskOrderLabel as bV, taskRef as bW, taskRefOf as bX, taskRowActions as bY, taskRowView as bZ, taskStartedNotice as b_, diffStat as ba, diffSummary as bb, digestTaskLog as bc, drainNext as bd, executionSummary as be, followTurn as bf, fromTranscript as bg, getSettingsPath as bh, hasHiddenDetail as bi, holdPrompt as bj, isTaskRunning as bk, loadedSkillTokens as bl, markAction as bm, markRequestFor as bn, markdownHtml as bo, markdownTokens as bp, namedRepos as bq, newTaskFields as br, opsEditable as bs, outputLines as bt, outputPreview as bu, parseCount as bv, parseSwitch as bw, parseTaskOpsJson as bx, pastGateConfirmation as by, reconcileApprovals as bz, type ApprovalBlock as c, textHasTaskOps as c0, titledRefs as c1, titledTaskRef as c2, titledTaskRefOf as c3, toTaskLogEvent as c4, toolHeadline as c5, trimToolOutput as c6, truncateCheckpointSummary as c7, unsendAll as c8, unsendLatest as c9, type ApprovalStatus as d, type AssignmentIssue as e, type AssignmentScope as f, type AutoMergeTrigger as g, type CommandBlock as h, type CommandStatus as i, type CompactionBlock as j, type ConversationInput as k, type ConversationView as l, type DiffRowKind as m, type DiffStat as n, type DisplayBlock as o, EMPTY_HOLD as p, EMPTY_RUN as q, EMPTY_TASK_LOG as r, type EditCatalog as s, type ExecutionSummary as t, type GlobalRunSettings as u, type HeldEditMark as v, type IsolatedExecution as w, IsolationRunController as x, type LiveTailOptions as y, type LocalEntry as z };