@hcflabs/pi-subagent 0.0.0-stage → 27.10.8

package/dist/schema.d.ts

@@ -0,0 +1,2560 @@
+import { Type, type Static } from "typebox";
+export declare const RUN_STATE_VERSION = 5;
+export declare const MAX_TASKS = 8;
+export declare const MAX_EXECUTE_REQUEST_BYTES: number;
+export declare const MAX_PERSISTED_RUNTIME_TEXT_BYTES: number;
+export declare const MAX_POSSIBLE_RESOURCES = 32;
+export type ModelClass = Static<typeof ModelClassSchema>;
+declare const ModelClassSchema: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+export declare const CheckCommandSchema: Type.TObject<{
+    command: Type.TString;
+    args: Type.TArray<Type.TString>;
+}>;
+/** One display form for a check command; quoted args keep argv boundaries visible. */
+export declare function formatCheckCommand({ command, args }: {
+    command: string;
+    args: readonly string[];
+}): string;
+export declare const JudgmentSchema: Type.TObject<{
+    role: Type.TString;
+    modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+    criterion: Type.TString;
+}>;
+declare const TextTaskRequestSchema: Type.TObject<{
+    role: Type.TString;
+    modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+    requirements: Type.TString;
+    deliverable: Type.TString;
+    dependsOn: Type.TArray<Type.TString>;
+    contextFrom: Type.TArray<Type.TString>;
+    id: Type.TString;
+    kind: Type.TLiteral<"text">;
+}>;
+declare const ChangesetTaskRequestSchema: Type.TObject<{
+    role: Type.TString;
+    modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+    requirements: Type.TString;
+    deliverable: Type.TString;
+    dependsOn: Type.TArray<Type.TString>;
+    contextFrom: Type.TArray<Type.TString>;
+    id: Type.TString;
+    kind: Type.TLiteral<"changeset">;
+    checks: Type.TArray<Type.TObject<{
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+    }>>;
+    judgment: Type.TOptional<Type.TObject<{
+        role: Type.TString;
+        modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+        criterion: Type.TString;
+    }>>;
+}>;
+export declare const TaskRequestSchema: Type.TUnion<[Type.TObject<{
+    role: Type.TString;
+    modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+    requirements: Type.TString;
+    deliverable: Type.TString;
+    dependsOn: Type.TArray<Type.TString>;
+    contextFrom: Type.TArray<Type.TString>;
+    id: Type.TString;
+    kind: Type.TLiteral<"text">;
+}>, Type.TObject<{
+    role: Type.TString;
+    modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+    requirements: Type.TString;
+    deliverable: Type.TString;
+    dependsOn: Type.TArray<Type.TString>;
+    contextFrom: Type.TArray<Type.TString>;
+    id: Type.TString;
+    kind: Type.TLiteral<"changeset">;
+    checks: Type.TArray<Type.TObject<{
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+    }>>;
+    judgment: Type.TOptional<Type.TObject<{
+        role: Type.TString;
+        modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+        criterion: Type.TString;
+    }>>;
+}>]>;
+export declare const ExecuteRequestSchema: Type.TObject<{
+    mode: Type.TLiteral<"isolated">;
+    id: Type.TString;
+    goal: Type.TString;
+    tasks: Type.TArray<Type.TUnion<[Type.TObject<{
+        role: Type.TString;
+        modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+        requirements: Type.TString;
+        deliverable: Type.TString;
+        dependsOn: Type.TArray<Type.TString>;
+        contextFrom: Type.TArray<Type.TString>;
+        id: Type.TString;
+        kind: Type.TLiteral<"text">;
+    }>, Type.TObject<{
+        role: Type.TString;
+        modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+        requirements: Type.TString;
+        deliverable: Type.TString;
+        dependsOn: Type.TArray<Type.TString>;
+        contextFrom: Type.TArray<Type.TString>;
+        id: Type.TString;
+        kind: Type.TLiteral<"changeset">;
+        checks: Type.TArray<Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+        }>>;
+        judgment: Type.TOptional<Type.TObject<{
+            role: Type.TString;
+            modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+            criterion: Type.TString;
+        }>>;
+    }>]>>;
+    finalChecks: Type.TOptional<Type.TArray<Type.TObject<{
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+    }>>>;
+    finalJudgment: Type.TOptional<Type.TObject<{
+        role: Type.TString;
+        modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+        criterion: Type.TString;
+    }>>;
+}>;
+export declare const IdOnlySchema: Type.TObject<{
+    id: Type.TString;
+}>;
+export declare const ResumeRequestSchema: Type.TUnion<[Type.TObject<{
+    id: Type.TString;
+    action: Type.TLiteral<"retry">;
+    taskId: Type.TString;
+    instruction: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    id: Type.TString;
+    action: Type.TLiteral<"verify">;
+    taskId: Type.TString;
+}>, Type.TObject<{
+    id: Type.TString;
+    action: Type.TLiteral<"finalize">;
+}>]>;
+export declare const ResumeRequestParameters: Type.TObject<{
+    id: Type.TString;
+    action: Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"verify">, Type.TLiteral<"finalize">]>;
+    taskId: Type.TOptional<Type.TString>;
+    instruction: Type.TOptional<Type.TString>;
+}>;
+export type IdOnly = Static<typeof IdOnlySchema>;
+export type CheckCommand = Static<typeof CheckCommandSchema>;
+export type Judgment = Static<typeof JudgmentSchema>;
+export type TextTaskRequest = Static<typeof TextTaskRequestSchema>;
+export type ChangesetTaskRequest = Static<typeof ChangesetTaskRequestSchema>;
+export type TaskRequest = Static<typeof TaskRequestSchema>;
+type ExecuteRequestInput = Static<typeof ExecuteRequestSchema>;
+export type ExecuteRequest = Omit<ExecuteRequestInput, "finalChecks"> & {
+    finalChecks: CheckCommand[];
+};
+export type ExecutionPolicySnapshot = Static<typeof ExecutionPolicySnapshotSchema>;
+export type ResumeRequest = Static<typeof ResumeRequestSchema>;
+export type WorkspaceIdentity = Static<typeof WorkspaceSchema>;
+declare const WorktreeRecordSchema: Type.TObject<{
+    path: Type.TString;
+    cwd: Type.TString;
+    branch: Type.TString;
+    repoRoot: Type.TString;
+    baseCommit: Type.TString;
+}>;
+declare const WorktreeAllocationIntentSchema: Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"worktree">;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        cwd: Type.TString;
+        branch: Type.TString;
+        repoRoot: Type.TString;
+        baseCommit: Type.TString;
+    }>>;
+}>;
+declare const WorkspaceAllocationIntentSchema: Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"workspace">;
+    label: Type.TString;
+    worktreeCwd: Type.TString;
+    mainRoot: Type.TString;
+    repoKey: Type.TString;
+    herdrRepoRoot: Type.TString;
+    workspaceId: Type.TOptional<Type.TString>;
+    rootTabId: Type.TOptional<Type.TString>;
+    rootPaneId: Type.TOptional<Type.TString>;
+}>;
+declare const WorkerTabAllocationIntentSchema: Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"worker_tab">;
+    label: Type.TString;
+    workspaceId: Type.TString;
+    workspaceRootTabId: Type.TString;
+    workspaceRootPaneId: Type.TString;
+    worktreeCwd: Type.TString;
+    leasePath: Type.TString;
+    tabId: Type.TOptional<Type.TString>;
+    paneId: Type.TOptional<Type.TString>;
+}>;
+declare const AgentAllocationIntentSchema: Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"agent">;
+    agentName: Type.TString;
+    workspaceId: Type.TString;
+    tabId: Type.TString;
+    paneId: Type.TString;
+    worktreeCwd: Type.TString;
+    leasePath: Type.TString;
+}>;
+export declare const AllocationIntentSchema: Type.TUnion<[Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"worktree">;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        cwd: Type.TString;
+        branch: Type.TString;
+        repoRoot: Type.TString;
+        baseCommit: Type.TString;
+    }>>;
+}>, Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"workspace">;
+    label: Type.TString;
+    worktreeCwd: Type.TString;
+    mainRoot: Type.TString;
+    repoKey: Type.TString;
+    herdrRepoRoot: Type.TString;
+    workspaceId: Type.TOptional<Type.TString>;
+    rootTabId: Type.TOptional<Type.TString>;
+    rootPaneId: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"worker_tab">;
+    label: Type.TString;
+    workspaceId: Type.TString;
+    workspaceRootTabId: Type.TString;
+    workspaceRootPaneId: Type.TString;
+    worktreeCwd: Type.TString;
+    leasePath: Type.TString;
+    tabId: Type.TOptional<Type.TString>;
+    paneId: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    generation: Type.TInteger;
+    token: Type.TString;
+    status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+    possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+    failure: Type.TOptional<Type.TString>;
+    kind: Type.TLiteral<"agent">;
+    agentName: Type.TString;
+    workspaceId: Type.TString;
+    tabId: Type.TString;
+    paneId: Type.TString;
+    worktreeCwd: Type.TString;
+    leasePath: Type.TString;
+}>]>;
+export type WorktreeRecord = Static<typeof WorktreeRecordSchema>;
+export type WorktreeAllocationIntent = Static<typeof WorktreeAllocationIntentSchema>;
+export type WorkspaceAllocationIntent = Static<typeof WorkspaceAllocationIntentSchema>;
+export type WorkerTabAllocationIntent = Static<typeof WorkerTabAllocationIntentSchema>;
+export type AgentAllocationIntent = Static<typeof AgentAllocationIntentSchema>;
+export type AllocationIntent = Static<typeof AllocationIntentSchema>;
+export type AllocationKind = AllocationIntent["kind"];
+export type WorktreeAllocationPlan = WorktreeRecord;
+export type WorkspaceAllocationPlan = Pick<WorkspaceAllocationIntent, "kind" | "label" | "worktreeCwd" | "mainRoot" | "repoKey" | "herdrRepoRoot">;
+export type WorkerTabAllocationPlan = Pick<WorkerTabAllocationIntent, "kind" | "label" | "workspaceId" | "workspaceRootTabId" | "workspaceRootPaneId" | "worktreeCwd" | "leasePath">;
+export type AgentAllocationPlan = Pick<AgentAllocationIntent, "kind" | "agentName" | "workspaceId" | "tabId" | "paneId" | "worktreeCwd" | "leasePath">;
+export type HostAllocationIntent = WorkspaceAllocationIntent | WorkerTabAllocationIntent | AgentAllocationIntent;
+export type HostAllocationPlan = WorkspaceAllocationPlan | WorkerTabAllocationPlan | AgentAllocationPlan;
+export type PromptRecord = Static<typeof PromptRecordSchema>;
+export type CommandEvidence = Static<typeof CommandEvidenceSchema>;
+export type CheckBatchEvidence = Static<typeof CheckBatchEvidenceSchema>;
+export type ReusedCheckSource = NonNullable<CommandEvidence["reusedFrom"]>;
+export type ReviewEvidence = Static<typeof ReviewEvidenceSchema>;
+export declare const CLEANUP_KINDS: readonly ["worker_tab", "workspace", "worktree", "branch"];
+export type CleanupStep = Static<typeof CleanupStepSchema>;
+export type CleanupKind = CleanupStep["kind"];
+export type ChangesetTaskAttempt = Static<typeof TaskAttemptSchema>;
+export type TaskAttempt = ChangesetTaskAttempt;
+export type TextTaskAttempt = Static<typeof TextTaskAttemptSchema>;
+export type ChangesetTaskState = Static<typeof ChangesetTaskStateSchema>;
+export type TextTaskState = Static<typeof TextTaskStateSchema>;
+export type TaskState = Static<typeof TaskStateSchema>;
+export type WaveState = Static<typeof WaveStateSchema>;
+export type RunState = Static<typeof RunStateSchema>;
+declare const WorkspaceSchema: Type.TObject<{
+    branch: Type.TString;
+    head: Type.TString;
+    index: Type.TString;
+    tree: Type.TString;
+}>;
+export declare const StageRequestSchema: Type.TObject<{
+    id: Type.TString;
+    action: Type.TUnion<[Type.TLiteral<"stage">, Type.TLiteral<"resolve">, Type.TLiteral<"reject">, Type.TLiteral<"revise">]>;
+    generation: Type.TInteger;
+    taskId: Type.TString;
+    attempt: Type.TInteger;
+    candidate: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    instruction: Type.TOptional<Type.TString>;
+}>;
+export type StageRequest = Static<typeof StageRequestSchema>;
+export declare const IntegrationActionSchema: Type.TUnion<[Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TLiteral<"refresh">;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    expectedMain: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    newMain: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+}>, Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TUnion<[Type.TLiteral<"advance">, Type.TLiteral<"validate">, Type.TLiteral<"correct">, Type.TLiteral<"promote">, Type.TLiteral<"reconcile">, Type.TLiteral<"cleanup">]>;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+}>, Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TLiteral<"release">;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    taskId: Type.TOptional<Type.TString>;
+    attempt: Type.TOptional<Type.TInteger>;
+}>]>;
+export declare const IntegrationActionParameters: Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TUnion<[Type.TLiteral<"refresh">, Type.TUnion<[Type.TLiteral<"advance">, Type.TLiteral<"validate">, Type.TLiteral<"correct">, Type.TLiteral<"promote">, Type.TLiteral<"reconcile">, Type.TLiteral<"cleanup">]>, Type.TLiteral<"release">]>;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    expectedMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    newMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    taskId: Type.TOptional<Type.TString>;
+    attempt: Type.TOptional<Type.TInteger>;
+}>;
+export type IntegrationAction = Static<typeof IntegrationActionSchema>;
+export declare function parseIntegrationAction(value: unknown): IntegrationAction;
+export declare function parseStageRequest(value: unknown): StageRequest;
+declare const PromptRecordSchema: Type.TObject<{
+    kind: Type.TUnion<[Type.TLiteral<"initial">, Type.TLiteral<"correction">, Type.TLiteral<"followup">]>;
+    status: Type.TUnion<[Type.TLiteral<"submitting">, Type.TLiteral<"not_sent">, Type.TLiteral<"settled">, Type.TLiteral<"ambiguous">]>;
+    preCandidate: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    candidate: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    instruction: Type.TOptional<Type.TString>;
+    failure: Type.TOptional<Type.TString>;
+    at: Type.TInteger;
+}>;
+declare const CommandEvidenceSchema: Type.TObject<{
+    command: Type.TString;
+    args: Type.TArray<Type.TString>;
+    code: Type.TInteger;
+    killed: Type.TBoolean;
+    stdout: Type.TString;
+    stderr: Type.TString;
+    reusedFrom: Type.TOptional<Type.TObject<{
+        taskId: Type.TString;
+        attempt: Type.TInteger;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+    }>>;
+}>;
+declare const CheckBatchEvidenceSchema: Type.TObject<{
+    phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+    candidate: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    identityAfter: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    results: Type.TArray<Type.TObject<{
+        command: Type.TString;
+        args: Type.TArray<Type.TString>;
+        code: Type.TInteger;
+        killed: Type.TBoolean;
+        stdout: Type.TString;
+        stderr: Type.TString;
+        reusedFrom: Type.TOptional<Type.TObject<{
+            taskId: Type.TString;
+            attempt: Type.TInteger;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+        }>>;
+    }>>;
+    passed: Type.TBoolean;
+    at: Type.TInteger;
+}>;
+declare const ReviewEvidenceSchema: Type.TObject<{
+    phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+    criterion: Type.TString;
+    base: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    tip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    identityAfter: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    verdict: Type.TString;
+    passed: Type.TBoolean;
+    at: Type.TInteger;
+}>;
+declare const CleanupStepSchema: Type.TObject<{
+    kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+    failure: Type.TOptional<Type.TString>;
+}>;
+declare const TaskAttemptSchema: Type.TObject<{
+    number: Type.TInteger;
+    waveNumber: Type.TInteger;
+    waveBase: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    correlationToken: Type.TString;
+    allocationGeneration: Type.TInteger;
+    allocations: Type.TArray<Type.TUnion<[Type.TObject<{
+        generation: Type.TInteger;
+        token: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+        possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+        failure: Type.TOptional<Type.TString>;
+        kind: Type.TLiteral<"worktree">;
+        worktree: Type.TOptional<Type.TObject<{
+            path: Type.TString;
+            cwd: Type.TString;
+            branch: Type.TString;
+            repoRoot: Type.TString;
+            baseCommit: Type.TString;
+        }>>;
+    }>, Type.TObject<{
+        generation: Type.TInteger;
+        token: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+        possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+        failure: Type.TOptional<Type.TString>;
+        kind: Type.TLiteral<"workspace">;
+        label: Type.TString;
+        worktreeCwd: Type.TString;
+        mainRoot: Type.TString;
+        repoKey: Type.TString;
+        herdrRepoRoot: Type.TString;
+        workspaceId: Type.TOptional<Type.TString>;
+        rootTabId: Type.TOptional<Type.TString>;
+        rootPaneId: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        generation: Type.TInteger;
+        token: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+        possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+        failure: Type.TOptional<Type.TString>;
+        kind: Type.TLiteral<"worker_tab">;
+        label: Type.TString;
+        workspaceId: Type.TString;
+        workspaceRootTabId: Type.TString;
+        workspaceRootPaneId: Type.TString;
+        worktreeCwd: Type.TString;
+        leasePath: Type.TString;
+        tabId: Type.TOptional<Type.TString>;
+        paneId: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        generation: Type.TInteger;
+        token: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+        possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+        failure: Type.TOptional<Type.TString>;
+        kind: Type.TLiteral<"agent">;
+        agentName: Type.TString;
+        workspaceId: Type.TString;
+        tabId: Type.TString;
+        paneId: Type.TString;
+        worktreeCwd: Type.TString;
+        leasePath: Type.TString;
+    }>]>>;
+    prompts: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"initial">, Type.TLiteral<"correction">, Type.TLiteral<"followup">]>;
+        status: Type.TUnion<[Type.TLiteral<"submitting">, Type.TLiteral<"not_sent">, Type.TLiteral<"settled">, Type.TLiteral<"ambiguous">]>;
+        preCandidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        candidate: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        instruction: Type.TOptional<Type.TString>;
+        failure: Type.TOptional<Type.TString>;
+        at: Type.TInteger;
+    }>>;
+    candidate: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    candidateBase: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    preliminaryChecks: Type.TOptional<Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        results: Type.TArray<Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+            code: Type.TInteger;
+            killed: Type.TBoolean;
+            stdout: Type.TString;
+            stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
+        }>>;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>>;
+    readiness: Type.TOptional<Type.TObject<{
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        at: Type.TInteger;
+    }>>;
+    superseded: Type.TOptional<Type.TLiteral<true>>;
+    termination: Type.TOptional<Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"terminating">, Type.TLiteral<"terminated">, Type.TLiteral<"unknown">]>;
+        workerId: Type.TString;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        at: Type.TOptional<Type.TInteger>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+    preliminaryReview: Type.TOptional<Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        criterion: Type.TString;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        verdict: Type.TString;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>>;
+    cleanup: Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+}>;
+declare const ChangesetTaskStateSchema: Type.TObject<{
+    taskId: Type.TString;
+    kind: Type.TLiteral<"changeset">;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"allocating">, Type.TLiteral<"working">, Type.TLiteral<"ready_to_integrate">, Type.TLiteral<"integrating">, Type.TLiteral<"cleanup">, Type.TLiteral<"completed">, Type.TLiteral<"rejected">, Type.TLiteral<"needs_attention">]>;
+    attempts: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        waveNumber: Type.TInteger;
+        waveBase: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        correlationToken: Type.TString;
+        allocationGeneration: Type.TInteger;
+        allocations: Type.TArray<Type.TUnion<[Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"worktree">;
+            worktree: Type.TOptional<Type.TObject<{
+                path: Type.TString;
+                cwd: Type.TString;
+                branch: Type.TString;
+                repoRoot: Type.TString;
+                baseCommit: Type.TString;
+            }>>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"workspace">;
+            label: Type.TString;
+            worktreeCwd: Type.TString;
+            mainRoot: Type.TString;
+            repoKey: Type.TString;
+            herdrRepoRoot: Type.TString;
+            workspaceId: Type.TOptional<Type.TString>;
+            rootTabId: Type.TOptional<Type.TString>;
+            rootPaneId: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"worker_tab">;
+            label: Type.TString;
+            workspaceId: Type.TString;
+            workspaceRootTabId: Type.TString;
+            workspaceRootPaneId: Type.TString;
+            worktreeCwd: Type.TString;
+            leasePath: Type.TString;
+            tabId: Type.TOptional<Type.TString>;
+            paneId: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"agent">;
+            agentName: Type.TString;
+            workspaceId: Type.TString;
+            tabId: Type.TString;
+            paneId: Type.TString;
+            worktreeCwd: Type.TString;
+            leasePath: Type.TString;
+        }>]>>;
+        prompts: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"initial">, Type.TLiteral<"correction">, Type.TLiteral<"followup">]>;
+            status: Type.TUnion<[Type.TLiteral<"submitting">, Type.TLiteral<"not_sent">, Type.TLiteral<"settled">, Type.TLiteral<"ambiguous">]>;
+            preCandidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            candidate: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            instruction: Type.TOptional<Type.TString>;
+            failure: Type.TOptional<Type.TString>;
+            at: Type.TInteger;
+        }>>;
+        candidate: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        candidateBase: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        preliminaryChecks: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            results: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+                code: Type.TInteger;
+                killed: Type.TBoolean;
+                stdout: Type.TString;
+                stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
+            }>>;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        readiness: Type.TOptional<Type.TObject<{
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            at: Type.TInteger;
+        }>>;
+        superseded: Type.TOptional<Type.TLiteral<true>>;
+        termination: Type.TOptional<Type.TObject<{
+            status: Type.TUnion<[Type.TLiteral<"terminating">, Type.TLiteral<"terminated">, Type.TLiteral<"unknown">]>;
+            workerId: Type.TString;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            at: Type.TOptional<Type.TInteger>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        preliminaryReview: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            criterion: Type.TString;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            verdict: Type.TString;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        cleanup: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+    }>>;
+    failure: Type.TOptional<Type.TString>;
+}>;
+declare const TextTaskAttemptSchema: Type.TObject<{
+    number: Type.TInteger;
+    status: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"superseded">]>;
+    failure: Type.TOptional<Type.TString>;
+    output: Type.TOptional<Type.TObject<{
+        text: Type.TString;
+    }>>;
+    cleanup: Type.TOptional<Type.TUnion<[Type.TObject<{
+        outcome: Type.TLiteral<"pruned">;
+        path: Type.TString;
+        branch: Type.TString;
+    }>, Type.TObject<{
+        outcome: Type.TLiteral<"retained">;
+        path: Type.TString;
+        branch: Type.TString;
+        commits: Type.TInteger;
+        dirty: Type.TBoolean;
+    }>, Type.TObject<{
+        outcome: Type.TLiteral<"recovery">;
+        path: Type.TString;
+        branch: Type.TString;
+        note: Type.TString;
+        commits: Type.TOptional<Type.TInteger>;
+        dirty: Type.TOptional<Type.TBoolean>;
+    }>]>>;
+}>;
+declare const TextTaskStateSchema: Type.TObject<{
+    taskId: Type.TString;
+    kind: Type.TLiteral<"text">;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+    attempts: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        status: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"superseded">]>;
+        failure: Type.TOptional<Type.TString>;
+        output: Type.TOptional<Type.TObject<{
+            text: Type.TString;
+        }>>;
+        cleanup: Type.TOptional<Type.TUnion<[Type.TObject<{
+            outcome: Type.TLiteral<"pruned">;
+            path: Type.TString;
+            branch: Type.TString;
+        }>, Type.TObject<{
+            outcome: Type.TLiteral<"retained">;
+            path: Type.TString;
+            branch: Type.TString;
+            commits: Type.TInteger;
+            dirty: Type.TBoolean;
+        }>, Type.TObject<{
+            outcome: Type.TLiteral<"recovery">;
+            path: Type.TString;
+            branch: Type.TString;
+            note: Type.TString;
+            commits: Type.TOptional<Type.TInteger>;
+            dirty: Type.TOptional<Type.TBoolean>;
+        }>]>>;
+    }>>;
+    failure: Type.TOptional<Type.TString>;
+}>;
+declare const TaskStateSchema: Type.TUnion<[Type.TObject<{
+    taskId: Type.TString;
+    kind: Type.TLiteral<"text">;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+    attempts: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        status: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"superseded">]>;
+        failure: Type.TOptional<Type.TString>;
+        output: Type.TOptional<Type.TObject<{
+            text: Type.TString;
+        }>>;
+        cleanup: Type.TOptional<Type.TUnion<[Type.TObject<{
+            outcome: Type.TLiteral<"pruned">;
+            path: Type.TString;
+            branch: Type.TString;
+        }>, Type.TObject<{
+            outcome: Type.TLiteral<"retained">;
+            path: Type.TString;
+            branch: Type.TString;
+            commits: Type.TInteger;
+            dirty: Type.TBoolean;
+        }>, Type.TObject<{
+            outcome: Type.TLiteral<"recovery">;
+            path: Type.TString;
+            branch: Type.TString;
+            note: Type.TString;
+            commits: Type.TOptional<Type.TInteger>;
+            dirty: Type.TOptional<Type.TBoolean>;
+        }>]>>;
+    }>>;
+    failure: Type.TOptional<Type.TString>;
+}>, Type.TObject<{
+    taskId: Type.TString;
+    kind: Type.TLiteral<"changeset">;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"allocating">, Type.TLiteral<"working">, Type.TLiteral<"ready_to_integrate">, Type.TLiteral<"integrating">, Type.TLiteral<"cleanup">, Type.TLiteral<"completed">, Type.TLiteral<"rejected">, Type.TLiteral<"needs_attention">]>;
+    attempts: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        waveNumber: Type.TInteger;
+        waveBase: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        correlationToken: Type.TString;
+        allocationGeneration: Type.TInteger;
+        allocations: Type.TArray<Type.TUnion<[Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"worktree">;
+            worktree: Type.TOptional<Type.TObject<{
+                path: Type.TString;
+                cwd: Type.TString;
+                branch: Type.TString;
+                repoRoot: Type.TString;
+                baseCommit: Type.TString;
+            }>>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"workspace">;
+            label: Type.TString;
+            worktreeCwd: Type.TString;
+            mainRoot: Type.TString;
+            repoKey: Type.TString;
+            herdrRepoRoot: Type.TString;
+            workspaceId: Type.TOptional<Type.TString>;
+            rootTabId: Type.TOptional<Type.TString>;
+            rootPaneId: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"worker_tab">;
+            label: Type.TString;
+            workspaceId: Type.TString;
+            workspaceRootTabId: Type.TString;
+            workspaceRootPaneId: Type.TString;
+            worktreeCwd: Type.TString;
+            leasePath: Type.TString;
+            tabId: Type.TOptional<Type.TString>;
+            paneId: Type.TOptional<Type.TString>;
+        }>, Type.TObject<{
+            generation: Type.TInteger;
+            token: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+            possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+            failure: Type.TOptional<Type.TString>;
+            kind: Type.TLiteral<"agent">;
+            agentName: Type.TString;
+            workspaceId: Type.TString;
+            tabId: Type.TString;
+            paneId: Type.TString;
+            worktreeCwd: Type.TString;
+            leasePath: Type.TString;
+        }>]>>;
+        prompts: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"initial">, Type.TLiteral<"correction">, Type.TLiteral<"followup">]>;
+            status: Type.TUnion<[Type.TLiteral<"submitting">, Type.TLiteral<"not_sent">, Type.TLiteral<"settled">, Type.TLiteral<"ambiguous">]>;
+            preCandidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            candidate: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            instruction: Type.TOptional<Type.TString>;
+            failure: Type.TOptional<Type.TString>;
+            at: Type.TInteger;
+        }>>;
+        candidate: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        candidateBase: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        preliminaryChecks: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            results: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+                code: Type.TInteger;
+                killed: Type.TBoolean;
+                stdout: Type.TString;
+                stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
+            }>>;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        readiness: Type.TOptional<Type.TObject<{
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            at: Type.TInteger;
+        }>>;
+        superseded: Type.TOptional<Type.TLiteral<true>>;
+        termination: Type.TOptional<Type.TObject<{
+            status: Type.TUnion<[Type.TLiteral<"terminating">, Type.TLiteral<"terminated">, Type.TLiteral<"unknown">]>;
+            workerId: Type.TString;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            at: Type.TOptional<Type.TInteger>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        preliminaryReview: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            criterion: Type.TString;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            verdict: Type.TString;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        cleanup: Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+    }>>;
+    failure: Type.TOptional<Type.TString>;
+}>]>;
+declare const WaveStateSchema: Type.TObject<{
+    number: Type.TInteger;
+    base: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    taskIds: Type.TArray<Type.TString>;
+    status: Type.TUnion<[Type.TLiteral<"dispatching">, Type.TLiteral<"integrating">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+}>;
+declare const ExecutionPolicySnapshotSchema: Type.TObject<{
+    maxSubagents: Type.TInteger;
+    maxTurns: Type.TInteger;
+    maxTokens: Type.TOptional<Type.TInteger>;
+    childIdleMs: Type.TNumber;
+    childMaxMs: Type.TNumber;
+    maxCorrections: Type.TInteger;
+}>;
+declare const IntegrationCandidateSchema: Type.TObject<{
+    taskId: Type.TString;
+    attempt: Type.TInteger;
+    base: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    tip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    checks: Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        results: Type.TArray<Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+            code: Type.TInteger;
+            killed: Type.TBoolean;
+            stdout: Type.TString;
+            stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
+        }>>;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>;
+    review: Type.TOptional<Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        criterion: Type.TString;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        verdict: Type.TString;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>>;
+    worker: Type.TUnion<[Type.TLiteral<"retained">, Type.TLiteral<"release_pending">, Type.TLiteral<"released">]>;
+    decision: Type.TOptional<Type.TLiteral<"rejected">>;
+}>;
+declare const IntegrationGenerationSchema: Type.TObject<{
+    number: Type.TInteger;
+    status: Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validating">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"promotion_unknown">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"superseded">]>;
+    expectedMain: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    integrationBase: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    order: Type.TArray<Type.TString>;
+    stages: Type.TArray<Type.TObject<{
+        taskId: Type.TString;
+        attempt: Type.TInteger;
+        source: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        onto: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"staging">, Type.TLiteral<"staged">, Type.TLiteral<"conflict">]>;
+        tip: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        cwd: Type.TString;
+        branch: Type.TString;
+        repoRoot: Type.TString;
+        baseCommit: Type.TString;
+    }>>;
+    combinedTip: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    correction: Type.TOptional<Type.TObject<{
+        from: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        to: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+    }>>;
+    checks: Type.TOptional<Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        candidate: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        results: Type.TArray<Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+            code: Type.TInteger;
+            killed: Type.TBoolean;
+            stdout: Type.TString;
+            stderr: Type.TString;
+            reusedFrom: Type.TOptional<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
+        }>>;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>>;
+    review: Type.TOptional<Type.TObject<{
+        phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+        criterion: Type.TString;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        identityAfter: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        verdict: Type.TString;
+        passed: Type.TBoolean;
+        at: Type.TInteger;
+    }>>;
+    promotion: Type.TOptional<Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+        expectedMain: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        mainAfter: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        outcome: Type.TOptional<Type.TLiteral<"drift">>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+    supersededPromotion: Type.TOptional<Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+        expectedMain: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        mainAfter: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        outcome: Type.TOptional<Type.TLiteral<"drift">>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+    cleanup: Type.TOptional<Type.TArray<Type.TObject<{
+        kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+        failure: Type.TOptional<Type.TString>;
+    }>>>;
+    supersededFrom: Type.TOptional<Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"discarded">]>>;
+    failure: Type.TOptional<Type.TString>;
+}>;
+export declare const IntegrationStateSchema: Type.TObject<{
+    candidates: Type.TArray<Type.TObject<{
+        taskId: Type.TString;
+        attempt: Type.TInteger;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tip: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        checks: Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            results: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+                code: Type.TInteger;
+                killed: Type.TBoolean;
+                stdout: Type.TString;
+                stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
+            }>>;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>;
+        review: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            criterion: Type.TString;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            verdict: Type.TString;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        worker: Type.TUnion<[Type.TLiteral<"retained">, Type.TLiteral<"release_pending">, Type.TLiteral<"released">]>;
+        decision: Type.TOptional<Type.TLiteral<"rejected">>;
+    }>>;
+    generations: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        status: Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validating">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"promotion_unknown">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"superseded">]>;
+        expectedMain: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        integrationBase: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        order: Type.TArray<Type.TString>;
+        stages: Type.TArray<Type.TObject<{
+            taskId: Type.TString;
+            attempt: Type.TInteger;
+            source: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            onto: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"staging">, Type.TLiteral<"staged">, Type.TLiteral<"conflict">]>;
+            tip: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        worktree: Type.TOptional<Type.TObject<{
+            path: Type.TString;
+            cwd: Type.TString;
+            branch: Type.TString;
+            repoRoot: Type.TString;
+            baseCommit: Type.TString;
+        }>>;
+        combinedTip: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        correction: Type.TOptional<Type.TObject<{
+            from: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            to: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+        }>>;
+        checks: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            results: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+                code: Type.TInteger;
+                killed: Type.TBoolean;
+                stdout: Type.TString;
+                stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
+            }>>;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        review: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            criterion: Type.TString;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            verdict: Type.TString;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        promotion: Type.TOptional<Type.TObject<{
+            status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+            expectedMain: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            mainAfter: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            outcome: Type.TOptional<Type.TLiteral<"drift">>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        supersededPromotion: Type.TOptional<Type.TObject<{
+            status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+            expectedMain: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            mainAfter: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            outcome: Type.TOptional<Type.TLiteral<"drift">>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        cleanup: Type.TOptional<Type.TArray<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+            failure: Type.TOptional<Type.TString>;
+        }>>>;
+        supersededFrom: Type.TOptional<Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"discarded">]>>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+    refresh: Type.TOptional<Type.TObject<{
+        from: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        to: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        generation: Type.TInteger;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"ready">, Type.TLiteral<"unknown">]>;
+        failure: Type.TOptional<Type.TString>;
+    }>>;
+}>;
+export type IntegrationCandidate = Static<typeof IntegrationCandidateSchema>;
+export type IntegrationGeneration = Static<typeof IntegrationGenerationSchema>;
+export type IntegrationState = Static<typeof IntegrationStateSchema>;
+declare const TerminalRunStatusSchema: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
+export declare const TERMINAL_RUN_STATUSES: readonly Static<typeof TerminalRunStatusSchema>[];
+declare const RunStateSchema: Type.TObject<{
+    version: Type.TLiteral<5>;
+    request: Type.TObject<{
+        mode: Type.TLiteral<"isolated">;
+        id: Type.TString;
+        goal: Type.TString;
+        tasks: Type.TArray<Type.TUnion<[Type.TObject<{
+            role: Type.TString;
+            modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+            requirements: Type.TString;
+            deliverable: Type.TString;
+            dependsOn: Type.TArray<Type.TString>;
+            contextFrom: Type.TArray<Type.TString>;
+            id: Type.TString;
+            kind: Type.TLiteral<"text">;
+        }>, Type.TObject<{
+            role: Type.TString;
+            modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+            requirements: Type.TString;
+            deliverable: Type.TString;
+            dependsOn: Type.TArray<Type.TString>;
+            contextFrom: Type.TArray<Type.TString>;
+            id: Type.TString;
+            kind: Type.TLiteral<"changeset">;
+            checks: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+            }>>;
+            judgment: Type.TOptional<Type.TObject<{
+                role: Type.TString;
+                modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+                criterion: Type.TString;
+            }>>;
+        }>]>>;
+        finalChecks: Type.TOptional<Type.TArray<Type.TObject<{
+            command: Type.TString;
+            args: Type.TArray<Type.TString>;
+        }>>>;
+        finalJudgment: Type.TOptional<Type.TObject<{
+            role: Type.TString;
+            modelClass: Type.TUnion<[Type.TLiteral<"fast">, Type.TLiteral<"balanced">, Type.TLiteral<"frontier">, Type.TLiteral<"fav">]>;
+            criterion: Type.TString;
+        }>>;
+    }>;
+    policy: Type.TObject<{
+        maxSubagents: Type.TInteger;
+        maxTurns: Type.TInteger;
+        maxTokens: Type.TOptional<Type.TInteger>;
+        childIdleMs: Type.TNumber;
+        childMaxMs: Type.TNumber;
+        maxCorrections: Type.TInteger;
+    }>;
+    correctionCount: Type.TInteger;
+    root: Type.TString;
+    requestStartMain: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    main: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"needs_attention">, Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
+    tasks: Type.TArray<Type.TUnion<[Type.TObject<{
+        taskId: Type.TString;
+        kind: Type.TLiteral<"text">;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+        attempts: Type.TArray<Type.TObject<{
+            number: Type.TInteger;
+            status: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"superseded">]>;
+            failure: Type.TOptional<Type.TString>;
+            output: Type.TOptional<Type.TObject<{
+                text: Type.TString;
+            }>>;
+            cleanup: Type.TOptional<Type.TUnion<[Type.TObject<{
+                outcome: Type.TLiteral<"pruned">;
+                path: Type.TString;
+                branch: Type.TString;
+            }>, Type.TObject<{
+                outcome: Type.TLiteral<"retained">;
+                path: Type.TString;
+                branch: Type.TString;
+                commits: Type.TInteger;
+                dirty: Type.TBoolean;
+            }>, Type.TObject<{
+                outcome: Type.TLiteral<"recovery">;
+                path: Type.TString;
+                branch: Type.TString;
+                note: Type.TString;
+                commits: Type.TOptional<Type.TInteger>;
+                dirty: Type.TOptional<Type.TBoolean>;
+            }>]>>;
+        }>>;
+        failure: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        taskId: Type.TString;
+        kind: Type.TLiteral<"changeset">;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"allocating">, Type.TLiteral<"working">, Type.TLiteral<"ready_to_integrate">, Type.TLiteral<"integrating">, Type.TLiteral<"cleanup">, Type.TLiteral<"completed">, Type.TLiteral<"rejected">, Type.TLiteral<"needs_attention">]>;
+        attempts: Type.TArray<Type.TObject<{
+            number: Type.TInteger;
+            waveNumber: Type.TInteger;
+            waveBase: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            correlationToken: Type.TString;
+            allocationGeneration: Type.TInteger;
+            allocations: Type.TArray<Type.TUnion<[Type.TObject<{
+                generation: Type.TInteger;
+                token: Type.TString;
+                status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+                possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+                failure: Type.TOptional<Type.TString>;
+                kind: Type.TLiteral<"worktree">;
+                worktree: Type.TOptional<Type.TObject<{
+                    path: Type.TString;
+                    cwd: Type.TString;
+                    branch: Type.TString;
+                    repoRoot: Type.TString;
+                    baseCommit: Type.TString;
+                }>>;
+            }>, Type.TObject<{
+                generation: Type.TInteger;
+                token: Type.TString;
+                status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+                possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+                failure: Type.TOptional<Type.TString>;
+                kind: Type.TLiteral<"workspace">;
+                label: Type.TString;
+                worktreeCwd: Type.TString;
+                mainRoot: Type.TString;
+                repoKey: Type.TString;
+                herdrRepoRoot: Type.TString;
+                workspaceId: Type.TOptional<Type.TString>;
+                rootTabId: Type.TOptional<Type.TString>;
+                rootPaneId: Type.TOptional<Type.TString>;
+            }>, Type.TObject<{
+                generation: Type.TInteger;
+                token: Type.TString;
+                status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+                possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+                failure: Type.TOptional<Type.TString>;
+                kind: Type.TLiteral<"worker_tab">;
+                label: Type.TString;
+                workspaceId: Type.TString;
+                workspaceRootTabId: Type.TString;
+                workspaceRootPaneId: Type.TString;
+                worktreeCwd: Type.TString;
+                leasePath: Type.TString;
+                tabId: Type.TOptional<Type.TString>;
+                paneId: Type.TOptional<Type.TString>;
+            }>, Type.TObject<{
+                generation: Type.TInteger;
+                token: Type.TString;
+                status: Type.TUnion<[Type.TLiteral<"allocating">, Type.TLiteral<"owned">, Type.TLiteral<"absent">, Type.TLiteral<"unknown">]>;
+                possibleResources: Type.TOptional<Type.TArray<Type.TString>>;
+                failure: Type.TOptional<Type.TString>;
+                kind: Type.TLiteral<"agent">;
+                agentName: Type.TString;
+                workspaceId: Type.TString;
+                tabId: Type.TString;
+                paneId: Type.TString;
+                worktreeCwd: Type.TString;
+                leasePath: Type.TString;
+            }>]>>;
+            prompts: Type.TArray<Type.TObject<{
+                kind: Type.TUnion<[Type.TLiteral<"initial">, Type.TLiteral<"correction">, Type.TLiteral<"followup">]>;
+                status: Type.TUnion<[Type.TLiteral<"submitting">, Type.TLiteral<"not_sent">, Type.TLiteral<"settled">, Type.TLiteral<"ambiguous">]>;
+                preCandidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                candidate: Type.TOptional<Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>>;
+                instruction: Type.TOptional<Type.TString>;
+                failure: Type.TOptional<Type.TString>;
+                at: Type.TInteger;
+            }>>;
+            candidate: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            candidateBase: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            preliminaryChecks: Type.TOptional<Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                results: Type.TArray<Type.TObject<{
+                    command: Type.TString;
+                    args: Type.TArray<Type.TString>;
+                    code: Type.TInteger;
+                    killed: Type.TBoolean;
+                    stdout: Type.TString;
+                    stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
+                }>>;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>>;
+            readiness: Type.TOptional<Type.TObject<{
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                base: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                at: Type.TInteger;
+            }>>;
+            superseded: Type.TOptional<Type.TLiteral<true>>;
+            termination: Type.TOptional<Type.TObject<{
+                status: Type.TUnion<[Type.TLiteral<"terminating">, Type.TLiteral<"terminated">, Type.TLiteral<"unknown">]>;
+                workerId: Type.TString;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                at: Type.TOptional<Type.TInteger>;
+                failure: Type.TOptional<Type.TString>;
+            }>>;
+            preliminaryReview: Type.TOptional<Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                criterion: Type.TString;
+                base: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                verdict: Type.TString;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>>;
+            cleanup: Type.TArray<Type.TObject<{
+                kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+                status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+                failure: Type.TOptional<Type.TString>;
+            }>>;
+        }>>;
+        failure: Type.TOptional<Type.TString>;
+    }>]>>;
+    waves: Type.TArray<Type.TObject<{
+        number: Type.TInteger;
+        base: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        taskIds: Type.TArray<Type.TString>;
+        status: Type.TUnion<[Type.TLiteral<"dispatching">, Type.TLiteral<"integrating">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+    }>>;
+    integration: Type.TObject<{
+        candidates: Type.TArray<Type.TObject<{
+            taskId: Type.TString;
+            attempt: Type.TInteger;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            checks: Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                results: Type.TArray<Type.TObject<{
+                    command: Type.TString;
+                    args: Type.TArray<Type.TString>;
+                    code: Type.TInteger;
+                    killed: Type.TBoolean;
+                    stdout: Type.TString;
+                    stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
+                }>>;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>;
+            review: Type.TOptional<Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                criterion: Type.TString;
+                base: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                verdict: Type.TString;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>>;
+            worker: Type.TUnion<[Type.TLiteral<"retained">, Type.TLiteral<"release_pending">, Type.TLiteral<"released">]>;
+            decision: Type.TOptional<Type.TLiteral<"rejected">>;
+        }>>;
+        generations: Type.TArray<Type.TObject<{
+            number: Type.TInteger;
+            status: Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validating">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"promotion_unknown">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"superseded">]>;
+            expectedMain: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            integrationBase: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            order: Type.TArray<Type.TString>;
+            stages: Type.TArray<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                source: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                onto: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"staging">, Type.TLiteral<"staged">, Type.TLiteral<"conflict">]>;
+                tip: Type.TOptional<Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>>;
+                failure: Type.TOptional<Type.TString>;
+            }>>;
+            worktree: Type.TOptional<Type.TObject<{
+                path: Type.TString;
+                cwd: Type.TString;
+                branch: Type.TString;
+                repoRoot: Type.TString;
+                baseCommit: Type.TString;
+            }>>;
+            combinedTip: Type.TOptional<Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>>;
+            correction: Type.TOptional<Type.TObject<{
+                from: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                to: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+            }>>;
+            checks: Type.TOptional<Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                candidate: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                results: Type.TArray<Type.TObject<{
+                    command: Type.TString;
+                    args: Type.TArray<Type.TString>;
+                    code: Type.TInteger;
+                    killed: Type.TBoolean;
+                    stdout: Type.TString;
+                    stderr: Type.TString;
+                    reusedFrom: Type.TOptional<Type.TObject<{
+                        taskId: Type.TString;
+                        attempt: Type.TInteger;
+                        candidate: Type.TObject<{
+                            branch: Type.TString;
+                            head: Type.TString;
+                            index: Type.TString;
+                            tree: Type.TString;
+                        }>;
+                    }>>;
+                }>>;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>>;
+            review: Type.TOptional<Type.TObject<{
+                phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+                criterion: Type.TString;
+                base: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                identityAfter: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                verdict: Type.TString;
+                passed: Type.TBoolean;
+                at: Type.TInteger;
+            }>>;
+            promotion: Type.TOptional<Type.TObject<{
+                status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+                expectedMain: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                mainAfter: Type.TOptional<Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>>;
+                outcome: Type.TOptional<Type.TLiteral<"drift">>;
+                failure: Type.TOptional<Type.TString>;
+            }>>;
+            supersededPromotion: Type.TOptional<Type.TObject<{
+                status: Type.TUnion<[Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"unknown">, Type.TLiteral<"failed">]>;
+                expectedMain: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                mainAfter: Type.TOptional<Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>>;
+                outcome: Type.TOptional<Type.TLiteral<"drift">>;
+                failure: Type.TOptional<Type.TString>;
+            }>>;
+            cleanup: Type.TOptional<Type.TArray<Type.TObject<{
+                kind: Type.TUnion<[Type.TLiteral<"worker_tab">, Type.TLiteral<"workspace">, Type.TLiteral<"worktree">, Type.TLiteral<"branch">]>;
+                status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">]>;
+                failure: Type.TOptional<Type.TString>;
+            }>>>;
+            supersededFrom: Type.TOptional<Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"discarded">]>>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+        refresh: Type.TOptional<Type.TObject<{
+            from: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            to: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            generation: Type.TInteger;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"ready">, Type.TLiteral<"unknown">]>;
+            failure: Type.TOptional<Type.TString>;
+        }>>;
+    }>;
+    final: Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"interrupted">, Type.TLiteral<"passed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">]>;
+        identity: Type.TOptional<Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>>;
+        checks: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            candidate: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            results: Type.TArray<Type.TObject<{
+                command: Type.TString;
+                args: Type.TArray<Type.TString>;
+                code: Type.TInteger;
+                killed: Type.TBoolean;
+                stdout: Type.TString;
+                stderr: Type.TString;
+                reusedFrom: Type.TOptional<Type.TObject<{
+                    taskId: Type.TString;
+                    attempt: Type.TInteger;
+                    candidate: Type.TObject<{
+                        branch: Type.TString;
+                        head: Type.TString;
+                        index: Type.TString;
+                        tree: Type.TString;
+                    }>;
+                }>>;
+            }>>;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        review: Type.TOptional<Type.TObject<{
+            phase: Type.TUnion<[Type.TLiteral<"preliminary">, Type.TLiteral<"final">]>;
+            criterion: Type.TString;
+            base: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            tip: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            identityAfter: Type.TObject<{
+                branch: Type.TString;
+                head: Type.TString;
+                index: Type.TString;
+                tree: Type.TString;
+            }>;
+            verdict: Type.TString;
+            passed: Type.TBoolean;
+            at: Type.TInteger;
+        }>>;
+        failure: Type.TOptional<Type.TString>;
+    }>;
+    recovery: Type.TOptional<Type.TObject<{
+        kind: Type.TLiteral<"resume">;
+        action: Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"verify">, Type.TLiteral<"finalize">]>;
+        taskId: Type.TOptional<Type.TString>;
+    }>>;
+    accepted: Type.TBoolean;
+    acceptedAt: Type.TOptional<Type.TInteger>;
+    createdAt: Type.TInteger;
+    updatedAt: Type.TInteger;
+}>;
+/**
+ * `subagent_status` structured output: the bounded public projection that Main reads, never raw
+ * run state. Objects stay open so bounded evidence fields pass; the identities and statuses that
+ * drive stage, integrate, resume, and release decisions are typed.
+ */
+export declare const StatusOutputSchema: Type.TObject<{
+    state: Type.TObject<{
+        version: Type.TLiteral<5>;
+        id: Type.TString;
+        status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"needs_attention">, Type.TLiteral<"completed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">, Type.TLiteral<"aborted">]>;
+        accepted: Type.TBoolean;
+        main: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        tasks: Type.TArray<Type.TObject<{
+            taskId: Type.TString;
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"allocating">, Type.TLiteral<"working">, Type.TLiteral<"ready_to_integrate">, Type.TLiteral<"integrating">, Type.TLiteral<"cleanup">, Type.TLiteral<"completed">, Type.TLiteral<"rejected">, Type.TLiteral<"needs_attention">, Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
+        }>>;
+        final: Type.TObject<{
+            status: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"running">, Type.TLiteral<"interrupted">, Type.TLiteral<"passed">, Type.TLiteral<"final_failed">, Type.TLiteral<"superseded">]>;
+        }>;
+        integration: Type.TObject<{
+            candidates: Type.TArray<Type.TObject<{
+                taskId: Type.TString;
+                attempt: Type.TInteger;
+                base: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                tip: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                checked: Type.TBoolean;
+                worker: Type.TUnion<[Type.TLiteral<"retained">, Type.TLiteral<"release_pending">, Type.TLiteral<"released">]>;
+                decision: Type.TOptional<Type.TLiteral<"rejected">>;
+            }>>;
+            generations: Type.TArray<Type.TObject<{
+                number: Type.TInteger;
+                status: Type.TUnion<[Type.TLiteral<"staging">, Type.TLiteral<"conflict">, Type.TLiteral<"validating">, Type.TLiteral<"validation_failed">, Type.TLiteral<"ready">, Type.TLiteral<"promoting">, Type.TLiteral<"promoted">, Type.TLiteral<"promotion_unknown">, Type.TLiteral<"promotion_failed">, Type.TLiteral<"superseded">]>;
+                integrationBase: Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>;
+                combinedTip: Type.TOptional<Type.TObject<{
+                    branch: Type.TString;
+                    head: Type.TString;
+                    index: Type.TString;
+                    tree: Type.TString;
+                }>>;
+                retainedWorktree: Type.TOptional<Type.TObject<{
+                    path: Type.TString;
+                    branch: Type.TString;
+                }>>;
+            }>>;
+        }>;
+        needsAttention: Type.TOptional<Type.TObject<{
+            scope: Type.TUnion<[Type.TLiteral<"task">, Type.TLiteral<"final">, Type.TLiteral<"request">]>;
+            taskId: Type.TOptional<Type.TString>;
+            failure: Type.TOptional<Type.TString>;
+            nextAction: Type.TOptional<Type.TString>;
+            failedReview: Type.TOptional<Type.TObject<{
+                verdict: Type.TString;
+                verdictTruncated: Type.TBoolean;
+            }>>;
+        }>>;
+        createdAt: Type.TInteger;
+        updatedAt: Type.TInteger;
+    }>;
+    main: Type.TOptional<Type.TUnion<[Type.TObject<{
+        status: Type.TUnion<[Type.TLiteral<"current">, Type.TLiteral<"drifted">]>;
+        expected: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        actual: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+    }>, Type.TObject<{
+        status: Type.TLiteral<"unavailable">;
+        expected: Type.TObject<{
+            branch: Type.TString;
+            head: Type.TString;
+            index: Type.TString;
+            tree: Type.TString;
+        }>;
+        failure: Type.TString;
+    }>]>>;
+    continuation: Type.TOptional<Type.TUnion<[Type.TObject<{
+        id: Type.TString;
+        action: Type.TLiteral<"retry">;
+        taskId: Type.TString;
+        instruction: Type.TOptional<Type.TString>;
+    }>, Type.TObject<{
+        id: Type.TString;
+        action: Type.TLiteral<"verify">;
+        taskId: Type.TString;
+    }>, Type.TObject<{
+        id: Type.TString;
+        action: Type.TLiteral<"finalize">;
+    }>]>>;
+}>;
+export declare function taskDependencies(task: TaskRequest): string[];
+export declare function validateGraph(tasks: readonly TaskRequest[]): void;
+export declare function parseExecuteRequest(value: unknown): ExecuteRequest;
+export declare function parseIdOnly(value: unknown): IdOnly;
+export declare function parseResumeRequest(value: unknown): ResumeRequest;
+export declare function sameIdentity(left: WorkspaceIdentity, right: WorkspaceIdentity): boolean;
+export declare function isCleanCommitted(identity: WorkspaceIdentity): boolean;
+/** Reused results pass only when they still cite one of `sources` exactly; no sources accept no reuse. */
+export declare function checkBatchPasses(evidence: CheckBatchEvidence | undefined, checks: readonly CheckCommand[], candidate: WorkspaceIdentity, sources?: readonly IntegrationCandidate[]): boolean;
+/** Candidates exactly staged in this generation; only they can supply reused final results. */
+export declare function stagedCheckSources(generation: IntegrationGeneration, candidates: readonly IntegrationCandidate[]): IntegrationCandidate[];
+/** A passed preliminary result stands in for a final check only on the same tree with identical command and argv. */
+export declare function reusableCheckSource(check: CheckCommand, tip: WorkspaceIdentity, sources: readonly IntegrationCandidate[]): ReusedCheckSource | undefined;
+export declare function reviewEvidencePasses(evidence: ReviewEvidence | undefined, phase: ReviewEvidence["phase"], criterion: string, base: WorkspaceIdentity, tip: WorkspaceIdentity): boolean;
+/** Check the persisted integration projection against the request before recovery or promotion. */
+export declare function parseIntegrationState(value: unknown, request: ExecuteRequest): IntegrationState;
+/** Passing final evidence is bound to the exact assembled identity, not any worker tip. */
+export declare function integrationGenerationPasses(generation: IntegrationGeneration, request: ExecuteRequest, candidates: readonly IntegrationCandidate[]): boolean;
+export declare function parseRunState(value: unknown): RunState;
+export {};