@ordewell/core 0.9.0 → 0.10.0

package/dist/plan-utils-P3PIEwNa.d.mts

@@ -1,1222 +0,0 @@
-import { ag as TaskSkillSnapshot, af as TaskSkillNotice, a8 as SubagentOutcome, ao as UsageRecord, W as RunnerId, c as DiscoveredModel, a9 as Task, L as LegacyPlanState, C as ConversationMessage, a0 as SkillLoadNotice, Q as QueuedMessage, ap as UsageTotals, av as Verdict, aa as TaskIsolation, a as AwaitingReason, g as IsolationHandoff, n as IsolationMergeResult, T as ResearchStep, z as PlanState, ah as TaskSnapshot, U as ResearchStepOutcome, O as ResearchLogEntry, G as PlannerUsage, ab as TaskIsolationState } from './Task-1Q19y7sZ.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-DE-o2lRF.mjs';
-import { aa as StructuredTurnEnd, h as ApprovalDecision, a9 as StructuredEvent, a0 as QueuedTaskMessage, i as ApprovalKind, o as ApprovalSource } from './IRunner-CxiymkP_.mjs';
-import './order-labels.mjs';
-
-/**
- * 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 = 
-/**
- * The task skills this attempt's prompt carried, as read at its spawn
- * (ADR-0024): first in its log. The file keeps their bodies; a surface is
- * sent notices ({@link taskLogForSurface}).
- */
-{
-    type: 'task_skills';
-    skills: TaskSkillSnapshot[] | TaskSkillNotice[];
-}
-/** A turn began by delivering `message`; `messageId` names it when it had been queued, `forced` when it was force sent. */
- | {
-    type: 'turn_start';
-    message: string;
-    messageId?: string;
-    forced?: boolean;
-} | {
-    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;
-}
-/**
- * Waiting in Ordewell's queue — again, for a message the runner was handed
- * and let go of (ADR-0023, D4). `forced` moves it ahead of the rest (F2).
- */
- | {
-    type: 'message_queued';
-    messageId: string;
-    text: string;
-    forced?: boolean;
-} | {
-    type: 'message_removed';
-    messageId: string;
-} | {
-    type: 'message_undelivered';
-    messageId: string;
-    text: string;
-}
-/** The runner accepted a queued message into its running turn; it can no longer be taken back. */
- | {
-    type: 'message_handed_over';
-    messageId: string;
-}
-/**
- * The model read a message inside its running turn (ADR-0023, Q2), logged
- * where it read it. A message that opened a turn is that turn's `turn_start`.
- */
- | {
-    type: 'message_delivered';
-    messageId: string;
-    text: 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;
-/** A log as a surface is sent it, live or read back: everything but the skills' bodies. */
-declare function taskLogForSurface(events: readonly TaskLogEvent[]): TaskLogEvent[];
-/**
- * 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[];
-/**
- * What an attempt did to the world, for the retry of a task whose effects
- * outlive it (ADR-0020): one line per tool call and how it ended.
- */
-declare function digestTaskLog(events: readonly TaskLogEvent[], maxCalls: number): string;
-
-/**
- * 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;
-    /** What an `awaiting_user` task waits on, when it was saved (ADR-0018, W1). */
-    awaitingReason?: AwaitingReason;
-    /** The whole question of the checkpoint the task waits at; absent when it waits at none. */
-    checkpoint?: string;
-    /** 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;
-    /**
-     * The dependencies an ops or user task waits on at its merge gate: their
-     * work has landed but is not merged into the user's branch (ADR-0020).
-     * Absent when it waits for no Merge all.
-     */
-    mergeGate?: string[];
-    /** The dependencies, by title, a force start went past the merge gate of (ADR-0020). */
-    forcedPastGate?: string[];
-};
-/**
- * A run with tasks at a merge gate (ADR-0020), as a surface offers Merge all
- * mid-run: what has landed and is not merged yet, and whether nothing else is
- * running, so the run waits on the user alone.
- */
-interface MergeGateView {
-    paused: boolean;
-    repos: IsolationHandoff['repos'];
-    landed: IsolationHandoff['landed'];
-}
-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'];
-    /** Set only on an ops task (ADR-0020). */
-    ops?: true;
-    /** Task skills attached by name; absent when none. */
-    skills?: string[];
-};
-/** Skill loads go out as notices: their bodies are for the planner, and stay in the session. */
-type SerializedConversationMessage = Omit<ConversationMessage, 'skill'> & {
-    skill?: SkillLoadNotice;
-};
-type SerializedQueuedMessage = Omit<QueuedMessage, 'skills'> & {
-    skills?: SkillLoadNotice[];
-};
-/**
- * A task as a surface is sent it: its attempt's skills are notices, whole in
- * the session only, and its runner session id stays there too — no surface shows it,
- * and only a continue reads the runner's own session id.
- */
-type SurfaceTask<T extends Task = Task> = Omit<T, 'attemptSkills' | 'subtasks' | 'runnerSessionId'> & {
-    attemptSkills?: TaskSkillNotice[];
-    subtasks: SurfaceTask[];
-};
-/** A plan as the daemon and the VS Code webview are sent it: the session's own state, minus every skill body. */
-type SurfacePlan = Omit<LegacyPlanState, 'tasks' | 'conversationHistory' | 'queuedMessages'> & {
-    tasks: SurfaceTask[];
-    conversationHistory?: SerializedConversationMessage[];
-    queuedMessages?: SerializedQueuedMessage[];
-};
-/** The phase-tagged shape of {@link SurfacePlan}. */
-type SurfacePlanState = (Omit<Extract<PlanState, {
-    phase: 'planning';
-}>, 'pendingTasks'> & {
-    pendingTasks: SurfaceTask[];
-}) | (Omit<Extract<PlanState, {
-    phase: 'executing';
-}>, 'pendingTasks' | 'executionLog'> & {
-    pendingTasks: SurfaceTask[];
-    executionLog: SurfaceTask<TaskSnapshot>[];
-});
-type SerializedPlan = {
-    tasks: SerializedTask[];
-    runners: RunnerId[];
-    generatedAt: string;
-    conversationHistory?: SerializedConversationMessage[];
-    prdMarkdown?: string;
-    queuedMessages?: SerializedQueuedMessage[];
-};
-/** 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, as typed, when the turn answers one; `skills` are what its
- * `/name` tokens loaded, absent when none did.
- */
- | {
-    type: 'planner_turn_started';
-    turnId: string;
-    prompt?: string;
-    skills?: SkillLoadNotice[];
-} | {
-    type: 'planner_skill_loaded';
-    turnId: string;
-    skill: SkillLoadNotice;
-}
-/**
- * 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[];
-    gate?: MergeGateView;
-} | {
-    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: '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.
- */
- | {
-    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, mergeGate?: readonly string[], checkpoint?: string): SerializedTaskStatus;
-/** The one place a plan's skill bodies come off before it leaves the session: every wire path that carries plan state goes through here. */
-declare function surfacePlan(plan: LegacyPlanState): SurfacePlan;
-declare function surfacePlanState(state: PlanState): SurfacePlanState;
-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 | SkillLoadBlock | 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;
-    /** A user's message: the skills its `/name` tokens loaded, for a surface to mark those tokens (see `loadedSkillTokens`). */
-    skills?: readonly 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';
-/** What a file edit changed, counted from its diff. */
-interface DiffStat {
-    added: number;
-    removed: number;
-}
-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;
-    /** Present when the call edited a file and `output` is its diff: a surface draws it as one. */
-    diff?: DiffStat;
-    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;
-}
-/** A skill loaded into the conversation: one line naming it and the SKILL.md that won. Its body is never shown. */
-interface SkillLoadBlock extends SkillLoadNotice {
-    type: 'skill_load';
-    id: string;
-    turnId?: 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 SerializedConversationMessage[] | 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 not yet delivered, oldest first; `handedOver` marks the ones the runner already has. */
-    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;
-/**
- * The lines a diff adds and removes, or null when `output` is not one: every
- * line a hunk header, context, an addition or a removal, and at least one of
- * the last two.
- */
-declare function diffStat(output: string): DiffStat | null;
-/** `gap` stands between two hunks, for the lines a diff leaves out. */
-type DiffRowKind = 'added' | 'removed' | 'context' | 'gap';
-interface DiffRow {
-    kind: DiffRowKind;
-    /** The line in the file: the old file's for a removal, the new file's otherwise. */
-    line?: number;
-    text: string;
-}
-/** A diff as the rows a surface draws, numbered as an editor would number them. */
-declare function diffRows(output: string): DiffRow[];
-/** "Added 2 lines, removed 1 line": the summary every surface puts on an edit's row. */
-declare function diffSummary({ added, removed }: DiffStat): string;
-
-/**
- * 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;
-
-/** Where a skill name is invoked: `start` is its `/`, `end` is just past the name, before any punctuation. */
-interface SkillToken {
-    name: string;
-    start: number;
-    end: number;
-}
-/**
- * The first `/name` token for each name in `text`, names lower-cased. Only
- * the first counts because a skill loads once per message however often it is
- * named, so a later repeat is plain text.
- */
-declare function skillTokens(text: string): SkillToken[];
-/** The tokens in a sent message that loaded one of `loaded` — what a surface highlights in the user's bubble. */
-declare function loadedSkillTokens(text: string, loaded: readonly string[]): SkillToken[];
-
-/**
- * What a row's status means to a reader, before any surface picks a word,
- * icon or colour for it. `quiet` is a running task whose runner has printed
- * nothing for a while — the status is still `in_progress`, so only the row,
- * never the store, tells the two apart.
- */
-type TaskStatusKind = 'todo' | 'running' | 'quiet' | 'awaiting' | 'blocked' | 'failed' | 'done';
-/** A task with a runner live behind it. `in_progress` is the store's own status. */
-declare const isTaskRunning: (task: {
-    status: string;
-}) => boolean;
-/** Statuses of a task that has not started: what can still be started by hand, or flipped between change and ops (ADR-0020). */
-declare const NOT_STARTED: ReadonlySet<string>;
-declare function taskStatusKind(task: {
-    status: string;
-    idleSince?: string | null;
-}): TaskStatusKind;
-/** What an awaiting_user task waits on (ADR-0018, W1); null when no reason was saved. */
-declare function awaitingLabel(task: {
-    status: string;
-    awaitingReason?: AwaitingReason;
-}): string | null;
-/** Runner requests a task waits on (ADR-0018, A1); null when none do. */
-declare function approvalLabel(count: number | undefined): string | null;
-
-/** What a user can do to one task from its row. */
-type TaskRowAction = 'cancel' | 'skip' | 'force-start' | 'complete' | 'uncomplete';
-/** A subtask runs with its parent, so its row offers a different set than a top-level task's. */
-type TaskRowPlacement = 'task' | 'subtask';
-interface ActionSubject {
-    status: string;
-    type: 'ai' | 'user';
-}
-/** The actions a task's row offers while a plan runs, in the order they are laid out. */
-declare function taskRowActions(task: ActionSubject, placement?: TaskRowPlacement): TaskRowAction[];
-/**
- * One toggle in both directions: a done task is taken back, anything else is
- * marked done. A second control for the reverse is one nobody remembers.
- */
-declare function markAction(task: {
-    status: string;
-}): 'complete' | 'uncomplete';
-/**
- * The mark an action asks the session for, or null when it is not a mark.
- * Skip has no request of its own: a skipped task is marked complete, so the
- * run moves on past it.
- */
-declare function markRequestFor(action: string): 'complete' | 'uncomplete' | null;
-/** Change versus ops can still be flipped (ADR-0020): an AI task that has not started. */
-declare function opsEditable(task: ActionSubject): boolean;
-
-/**
- * A task as both surfaces hold it, with the live state each tracks beside it
- * (silence, approvals, isolation, the merge gate). Structural, because the TUI
- * projects tasks into its own shape.
- */
-interface TaskRowSubject {
-    id: string;
-    order: number;
-    type: 'ai' | 'user';
-    status: string;
-    dependencies: readonly string[];
-    taskMode?: string;
-    ops?: boolean;
-    idleSince?: string | null;
-    awaitingReason?: AwaitingReason;
-    awaitingApproval?: number;
-    isolation?: TaskRowIsolation | null;
-    mergeGate?: readonly string[];
-    forcedPastGate?: readonly string[];
-}
-interface TaskRowIsolation {
-    state: TaskIsolationState;
-    repos?: string[];
-    conflictRepo?: string;
-    conflictFiles?: string[];
-    repair?: {
-        attempt: number;
-        limit: number;
-    };
-    repairedFiles?: string[];
-}
-interface TaskRowContext {
-    /** Set for a subtask: it is labelled by its dotted order. */
-    parent?: {
-        order: number;
-    } | null;
-    /** Which action set the row offers; a row with a parent is a subtask's unless told otherwise. */
-    placement?: TaskRowPlacement;
-    /** Order of each task a dependency or gate may name; one missing from it is shown by id. */
-    orderOf?: ReadonlyMap<string, number>;
-    /** The modes the task's runner declares; autonomy is a tag on one of them (ADR-0001). */
-    modes?: readonly {
-        id: string;
-        autonomous?: boolean;
-    }[];
-}
-/** Whether the row stands for an AI task, a manual one, or an ops task (ADR-0020). */
-type TaskRowKind = 'ai' | 'user' | 'ops';
-interface TaskRowView {
-    /** "2", or "2.1" for a subtask. */
-    orderLabel: string;
-    kind: TaskRowKind;
-    status: TaskStatusKind;
-    /** A runner is live behind it — `quiet` included. */
-    running: boolean;
-    /** What an awaiting task waits on, in sentence case; null when nothing was saved. */
-    awaiting: string | null;
-    /** Runner requests waiting on the user, in sentence case; null when none do. */
-    approvals: 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. */
-    repos: string[];
-    /** Integration stopped on a conflict: the one isolation state that needs the user. */
-    conflict: {
-        repo: string | null;
-        files: string | null;
-    } | null;
-    /** A conflict repair in flight (ADR-0015) — progress, not a blocker. */
-    repairing: {
-        files: string | null;
-        attempt: {
-            attempt: number;
-            limit: number;
-        } | null;
-    } | null;
-    /** The files a conflict repair was started for; `landed` once the task is integrated. */
-    repaired: {
-        files: string;
-        landed: boolean;
-    } | null;
-    /** The dependencies, by reference, whose work is not merged into the user's branch yet. */
-    mergeGate: string[] | null;
-    /** An ops task changed tracked files in the user's checkout and nothing was committed. */
-    opsChangedFiles: boolean;
-    /** The dependencies, by title, a force start went past the merge gate of. */
-    forcedPastGate: readonly string[] | null;
-    /** The task's dependencies, by reference. */
-    dependencies: string[];
-    /** What the row offers while a plan runs. */
-    actions: TaskRowAction[];
-    /** The one mark its toggle sets. */
-    mark: 'complete' | 'uncomplete';
-    opsEditable: boolean;
-}
-/** The repos a task changed, for a row that names them; none for a group of one. */
-declare const namedRepos: (repos: readonly string[] | undefined) => string[];
-/**
- * Everything a plan row says about one task, decided once: each surface picks
- * its own words, glyphs and casing for these facts, and derives none of them.
- */
-declare function taskRowView(task: TaskRowSubject, context?: TaskRowContext): TaskRowView;
-
-interface Named {
-    id: string;
-    order: number;
-    title: string;
-    subtasks?: readonly Named[];
-}
-/** Each id as "#N title", subtasks included; one the plan no longer holds stays a bare id. */
-declare function titledRefs(ids: readonly string[], tasks: readonly Named[]): string[];
-/**
- * What removing a task does to the tasks that depend on it, or null when none
- * do. Named rather than counted: the removal rewrites their dependency lists,
- * and a bare "Remove task?" would hide that.
- */
-declare function dependentsNotice(dependents: readonly {
-    order: number;
-    title: string;
-}[]): string | null;
-/**
- * What a start past a merge gate is asked with (ADR-0020): the work the task
- * would act without, named. `subject` is how the asking surface refers to the
- * task — "It" under a title that already names it.
- */
-declare function pastGateConfirmation(unmerged: readonly string[], subject?: string): string;
-interface NewTaskFields {
-    title: string;
-    description: string;
-    prompt: string;
-    type: 'ai';
-}
-/**
- * What a hand-added task starts as: an AI task whose description is its title
- * and whose prompt, unless one was typed, is too. Null for a title with nothing
- * in it, rather than a nameless task. Assignments are left for the session to
- * derive from the runner's catalog.
- */
-declare function newTaskFields(title: string, prompt?: string): NewTaskFields | null;
-
-export { type TaskRowView as $, type ApplyTaskOpsResult as A, type SubagentChild as B, CHECKPOINT_TRUNCATE_LENGTH as C, type DiffRow as D, EMPTY_CONVERSATION as E, type SubagentStatus as F, type GatedConversation as G, type SurfacePlan as H, type SurfacePlanState as I, type SurfaceTask as J, type TaskLogEvent as K, type LocalEntry as L, type MergeGateView as M, NOT_STARTED as N, type OutputPreview as O, type PlanBlock as P, type TaskLogView as Q, type TaskOp as R, type SerializedConversationMessage as S, type TakenPrompt as T, type TaskRef as U, type TaskRowAction as V, type TaskRowContext as W, type TaskRowIsolation as X, type TaskRowKind as Y, type TaskRowPlacement as Z, type TaskRowSubject as _, type ApprovalBlock as a, truncateCheckpointSummary as a$, type TaskStatusKind as a0, type ThinkingDisplayBlock as a1, type ToolBlock as a2, type ToolHeadline as a3, type ToolStatus as a4, type TurnGate as a5, type UsageBlock as a6, aheadOfDraft as a7, applyTaskOps as a8, approvalLabel as a9, opsEditable as aA, outputLines as aB, outputPreview as aC, parseTaskOpsJson as aD, pastGateConfirmation as aE, reduceConversation as aF, reduceTaskLog as aG, replayTaskLog as aH, runnerToolSubject as aI, serializePlan as aJ, serializeTask as aK, serializeTaskStatus as aL, skillTokens as aM, stopTurn as aN, summarizeToolCall as aO, surfacePlan as aP, surfacePlanState as aQ, taskLogForSurface as aR, taskRowActions as aS, taskRowView as aT, taskStartedNotice as aU, taskStatusKind as aV, textHasTaskOps as aW, titledRefs as aX, toTaskLogEvent as aY, toolHeadline as aZ, trimToolOutput as a_, awaitingLabel as aa, canMergeTasks as ab, canSetDependencies as ac, canSplitTask as ad, capConflictFiles as ae, classifyOutcome as af, coalesceTaskLog as ag, dependencyCandidates as ah, dependentsNotice as ai, dependentsOf as aj, diffRows as ak, diffStat as al, diffSummary as am, digestTaskLog as an, drainNext as ao, executionSummary as ap, followTurn as aq, fromTranscript as ar, hasHiddenDetail as as, holdPrompt as at, isTaskRunning as au, loadedSkillTokens as av, markAction as aw, markRequestFor as ax, namedRepos as ay, newTaskFields as az, type ApprovalStatus as b, unsendAll as b0, unsendLatest as b1, type ConversationInput as c, type ConversationView as d, type DiffRowKind as e, type DiffStat as f, type DisplayBlock as g, EMPTY_HOLD as h, EMPTY_TASK_LOG as i, type EditCatalog as j, type MessageBlock as k, type MessageRole as l, NO_TURN as m, type NewTaskFields as n, type PlanMarkerStatus as o, type PromptHold as p, type SerializedPlan as q, type SerializedQueuedMessage as r, type SerializedTask as s, type SerializedTaskStatus as t, type SessionBroadcaster as u, type SessionMessage as v, type SessionNotice as w, type SkillLoadBlock as x, type SkillToken as y, type SubagentBlock as z };