@ordewell/core 0.4.23 → 0.5.0

package/dist/{ITerminalRunner-CuNYBnqK.d.mts → ITerminalRunner-DXlJop_f.d.mts}

@@ -1,5 +1,5 @@
 import { I as IApproval, a as ApprovalMode } from './ApprovalPolicy-BVhGdECT.mjs';
-import { h as RunnerId } from './Task-4rDGr8Su.mjs';
+import { B as RunnerId } from './Task-CfTjRQeS.mjs';
 
 interface ToolOutcome {
     success: boolean;
@@ -205,6 +205,31 @@ interface IConfig {
     plannerThinkingEffort?: string;
     planMapEnabled: boolean;
     autonomousMode: boolean;
+    /**
+     * Run each AI task in its own git worktree and integrate the results on a
+     * per-run branch (ADR-0013). Non-git workspaces fall back to the shared
+     * workspace root regardless of this flag.
+     */
+    worktreeIsolation: boolean;
+    /**
+     * Shell command run in a fresh task worktree instead of symlinking ignored
+     * artifacts from the main worktree — for repos where sharing `node_modules`
+     * or a virtualenv is wrong.
+     */
+    worktreeSetupCommand?: string;
+    /**
+     * Repositories of the repo group listed by hand, relative to the workspace
+     * (ADR-0014). When non-empty the group is exactly these, replacing the
+     * repositories auto-detected directly inside the folder; needed for ones
+     * deeper than that, which are never auto-detected.
+     */
+    workspaceRepos: string[];
+    /**
+     * Extra paths or globs, relative to each repo root, linked from the real repo
+     * into its task worktree where they exist — gitignored local state such as
+     * `*.tfstate` that a task must use, not a copy of.
+     */
+    worktreeLinks: string[];
     /**
      * What to do when planner research reaches outside its default envelope — an
      * out-of-workspace path, or a shell command beyond the auto-allowed read-only

package/dist/{ITerminalRunner-Da1gIAFX.d.ts → ITerminalRunner-nupxhtPb.d.ts}

@@ -1,5 +1,5 @@
 import { I as IApproval, a as ApprovalMode } from './ApprovalPolicy-BVhGdECT.js';
-import { h as RunnerId } from './Task-4rDGr8Su.js';
+import { B as RunnerId } from './Task-CfTjRQeS.js';
 
 interface ToolOutcome {
     success: boolean;
@@ -205,6 +205,31 @@ interface IConfig {
     plannerThinkingEffort?: string;
     planMapEnabled: boolean;
     autonomousMode: boolean;
+    /**
+     * Run each AI task in its own git worktree and integrate the results on a
+     * per-run branch (ADR-0013). Non-git workspaces fall back to the shared
+     * workspace root regardless of this flag.
+     */
+    worktreeIsolation: boolean;
+    /**
+     * Shell command run in a fresh task worktree instead of symlinking ignored
+     * artifacts from the main worktree — for repos where sharing `node_modules`
+     * or a virtualenv is wrong.
+     */
+    worktreeSetupCommand?: string;
+    /**
+     * Repositories of the repo group listed by hand, relative to the workspace
+     * (ADR-0014). When non-empty the group is exactly these, replacing the
+     * repositories auto-detected directly inside the folder; needed for ones
+     * deeper than that, which are never auto-detected.
+     */
+    workspaceRepos: string[];
+    /**
+     * Extra paths or globs, relative to each repo root, linked from the real repo
+     * into its task worktree where they exist — gitignored local state such as
+     * `*.tfstate` that a task must use, not a copy of.
+     */
+    worktreeLinks: string[];
     /**
      * What to do when planner research reaches outside its default envelope — an
      * out-of-workspace path, or a shell command beyond the auto-allowed read-only

package/dist/{ModeResolver-Ob-ihQbI.d.ts → ModeResolver-BBVktyiP.d.ts}

@@ -1,4 +1,4 @@
-import { h as RunnerId } from './Task-4rDGr8Su.js';
+import { B as RunnerId } from './Task-CfTjRQeS.js';
 
 interface RunnerModeInfo {
     id: string;

package/dist/{ModeResolver-mtIWrLXn.d.mts → ModeResolver-D1-2xJsE.d.mts}

@@ -1,4 +1,4 @@
-import { h as RunnerId } from './Task-4rDGr8Su.mjs';
+import { B as RunnerId } from './Task-CfTjRQeS.mjs';
 
 interface RunnerModeInfo {
     id: string;

package/dist/Task-CfTjRQeS.d.mts

@@ -0,0 +1,586 @@
+/**
+ * Why isolated execution is unavailable for a workspace. The orchestrator needs
+ * the reason, not just a boolean: `dirty` is offered a stash or an explicit
+ * "run without isolation", while the others fall back to the shared
+ * workspace root with a one-line notice.
+ */
+type IsolationInactiveReason = 'disabled' | 'git-missing' | 'not-git' | 'no-commits' | 'dirty' | 'nested-repos';
+/**
+ * `repos` names, relative to the workspace, the repositories behind the answer:
+ * when active, the ones that will isolate, with `shared` the paths every task
+ * will share live; otherwise the nested ones `nested-repos` refuses, the dirty
+ * ones of a `dirty` group, or the commitless ones of a `no-commits` group. A
+ * group of one names none.
+ */
+type IsolationAvailability = {
+    active: true;
+    repos?: string[];
+    shared?: string[];
+} | {
+    active: false;
+    reason: IsolationInactiveReason;
+    repos?: string[];
+};
+/**
+ * Where a run's tasks work, as the planner is told it: the repos of the group
+ * and the paths shared live between tasks. A lone repository is `['.']` with
+ * nothing shared.
+ */
+interface RepoGroupLayout {
+    repos: string[];
+    shared: string[];
+}
+type IsolationOutcome = 'merged' | 'conflict' | 'failed';
+/**
+ * `active` — worktree exists, a runner may be writing to it.
+ * `kept` — released with its worktree and branch preserved for inspection.
+ * `conflict` — integration stopped on a merge conflict; worktree and refs kept.
+ * `failed` — integration hit a git error other than a conflict; refs kept.
+ * `merged` — landed on the integration branch; worktree and task branch removed.
+ */
+type IsolationTaskStatus = 'active' | 'kept' | 'conflict' | 'failed' | 'merged';
+/** One repo's share of a task: its worktree inside the task workspace. */
+interface IsolationTaskRepo {
+    /** Absolute path of this repo's worktree: the task workspace joined with the repo's path. */
+    worktree: string;
+    /**
+     * Paths bootstrapped from the real repo (symlinks, junctions, copies).
+     * Recorded so the commit step can leave them out — a symlink is not matched
+     * by a `node_modules/` ignore rule and would otherwise be committed.
+     */
+    linked: string[];
+    /** Whether the task brought commits to this repo; unknown until it first integrates. */
+    changed?: boolean;
+}
+interface IsolationTaskRecord {
+    taskId: string;
+    order: number;
+    title: string;
+    /** One branch name, the same in every repo, so a task is one name to look up across the group. */
+    branch: string;
+    /**
+     * Absolute path of the task workspace, holding one worktree per repo at the
+     * repo's path. The Runner's cwd is inside it when the workspace is a repo
+     * subdirectory; for a group of one it is the worktree.
+     */
+    workspace: string;
+    /** For the task as a whole: landing is atomic across the repos it changed. */
+    status: IsolationTaskStatus;
+    /** Keyed by repo path. */
+    repos: Record<string, IsolationTaskRepo>;
+    /** The repo whose merge stopped the task from landing, while `status` is `conflict` or `failed`. */
+    conflictRepo?: string;
+}
+/**
+ * A task's landing in flight: each changed repo's integration tip from before
+ * the task's merge. On the run rather than the task record because it must
+ * outlive that record — a retry drops and recreates it — until every repo is
+ * back at its tip or the task has landed.
+ */
+interface IsolationLanding {
+    taskId: string;
+    /** Keyed by repo path. */
+    tips: Record<string, string>;
+}
+/**
+ * One repository of the group (ADR-0014). Every git operation on it runs in
+ * `root`, never in the workspace root.
+ */
+interface IsolationRepo {
+    /** Relative to the workspace root; `.` when the workspace is itself the repository. */
+    path: string;
+    /**
+     * Absolute: the workspace root joined with `path`. For a group of one that is
+     * the workspace root, which may be a subdirectory of the repository.
+     */
+    root: string;
+    /** The commit checked out at run start. Switching branches mid-run does not retarget it. */
+    baseRef: string;
+    /** Branch name checked out at run start; absent on a detached HEAD. */
+    baseBranch?: string;
+    integrationBranch: string;
+}
+/**
+ * One Execute-Plan click or one manual task run over the workspace's repo
+ * group. Plain JSON on purpose: the orchestrator persists it with the plan
+ * state so a resumed session can find its integration branches again. The
+ * module mutates `tasks` in place.
+ */
+interface IsolationRun {
+    id: string;
+    workspaceRoot: string;
+    repos: IsolationRepo[];
+    /**
+     * Workspace paths outside every isolated repo, linked live into each task
+     * workspace: loose entries of the workspace root, the entries beside a deeper
+     * repo, and `sharedRepos`. Empty for a group of one.
+     */
+    shared: string[];
+    /** Repos of the group that could not be isolated — no commits, or git refused a worktree — and are among `shared`. */
+    sharedRepos: string[];
+    /** Keyed by task id — ids are unique within one plan and a run belongs to one plan. */
+    tasks: Record<string, IsolationTaskRecord>;
+    /**
+     * Set before a task's first merge and cleared once it has landed or been
+     * rolled back. One found set — after a crash, or a rollback git refused —
+     * names exactly what to return each repo's integration branch to.
+     */
+    landing?: IsolationLanding;
+}
+/**
+ * What a plan persists of isolated execution (`LegacyPlanState.isolation`): its
+ * run, and which added tasks resolve which conflicts. Belongs to that plan and
+ * its branches alone, so a copy of the plan (a fork) must not carry it.
+ */
+interface PlanIsolation {
+    run: IsolationRun;
+    /** Resolver task id → the conflicted task whose branch it merges. */
+    resolvers: Record<string, string>;
+}
+/**
+ * A task's isolation as a surface shows it. `kept` covers every record whose
+ * worktree stays for inspection — a failed verdict, an interrupted attempt, an
+ * integration git refused — because to the user they are one thing: work that
+ * did not land and can be looked at. `none` is a task with no worktree in a plan
+ * that has an isolation run.
+ */
+type TaskIsolationState = 'none' | 'active' | 'integrated' | 'conflict' | 'kept';
+type TaskIsolation = {
+    state: 'none';
+} | {
+    state: Exclude<TaskIsolationState, 'none'>;
+    branch: string;
+    /** The task workspace; for a group of one, the task's worktree. */
+    worktree: string;
+    /** Paths of the repos the task changed. */
+    repos: string[];
+    conflictRepo?: string;
+};
+interface IsolationLandedTask {
+    taskId: string;
+    order: number;
+    title: string;
+}
+interface IsolationHandoffRepo {
+    path: string;
+    integrationBranch: string;
+    baseRef: string;
+    /** Tasks whose work landed in this repo, in plan order. */
+    landed: IsolationLandedTask[];
+}
+interface IsolationHandoff {
+    repos: IsolationHandoffRepo[];
+    /** Tasks that landed on the integration branches, in plan order. */
+    landed: IsolationLandedTask[];
+}
+/** A plan's isolation as a surface shows it: a mark for each task the run touched, and its handoff. */
+interface IsolationView {
+    tasks: Record<string, TaskIsolation>;
+    handoff: IsolationHandoff;
+}
+/**
+ * Why "Merge all" would not touch a repo. `partial-landing`: a task's landing
+ * was interrupted and could not be rolled back there, so its integration
+ * branch holds part of a task.
+ */
+type IsolationMergeBlockReason = 'merge-in-progress' | 'conflict' | 'uncommitted-changes' | 'partial-landing' | 'git-error';
+interface IsolationMergeBlock {
+    repo: string;
+    reason: IsolationMergeBlockReason;
+    /** The files that would conflict, or the user's uncommitted ones the merge also changes; empty for the other reasons. */
+    files: string[];
+}
+/**
+ * How "Merge all" went.
+ * - `merged`: every repo with work on its integration branch took it.
+ * - `blocked`: the preflight found repos that could not, so nothing was
+ *   touched anywhere; `blocked` says which and why.
+ * - `conflict` / `failed`: a merge stopped in `repo` — on git older than 2.38,
+ *   which cannot preflight, or for a reason no preflight could foresee. That
+ *   merge was aborted, leaving `repo` as it was; `landed` names the repos
+ *   merged before it, which stay merged, and is absent when there are none.
+ *
+ * A group of one is blocked only by a partial landing; otherwise its one merge
+ * lands or is aborted whole, so it reports as it always has.
+ */
+type IsolationMergeResult = {
+    outcome: 'merged';
+} | {
+    outcome: 'blocked';
+    blocked: IsolationMergeBlock[];
+} | {
+    outcome: 'conflict' | 'failed';
+    repo: string;
+    files?: string[];
+    landed?: string[];
+};
+interface PreparedTask {
+    cwd: string;
+    branch: string;
+    /**
+     * Paths, relative to the task workspace, that are copies rather than links
+     * because a hard link was impossible (Windows, another volume). Edits to them
+     * stay in the task, so the user is told.
+     */
+    copied: string[];
+}
+interface IWorktreeIsolation {
+    /**
+     * A repo group with at least one repo to isolate, a clean tracked tree in
+     * each, and the config enabled; otherwise the reason it is not.
+     */
+    isActive(workspaceRoot: string): Promise<IsolationAvailability>;
+    /**
+     * Put the tracked changes of every dirty repo of the group on its git stash,
+     * the user's way out of a `dirty` refusal. Untracked files stay: they never
+     * block isolation.
+     */
+    stash(workspaceRoot: string): Promise<void>;
+    /**
+     * Mint a run: resolve each repo's base ref to a commit now, and share the
+     * repos that cannot be isolated. Only meaningful after `isActive` said yes;
+     * throws when no repo of the group can be isolated after all.
+     */
+    startRun(workspaceRoot: string): Promise<IsolationRun>;
+    /**
+     * Create the task workspace — one worktree per isolated repo from its
+     * integration tip, the shared paths linked in — and return the cwd to spawn
+     * the Runner into. A second `prepare` for the same task is a retry: the old
+     * attempt is discarded and the workspace recreated from the tips, so the
+     * task sees everything its predecessors have integrated.
+     */
+    prepare(task: Task, run: IsolationRun): Promise<PreparedTask>;
+    /**
+     * Land the task atomically across the repos it changed: commit each
+     * worktree, then `git merge --no-ff` the task branch into each changed
+     * repo's integration branch. If any merge conflicts or fails, it is aborted
+     * and the merges already made for the task are reset away, so `merged`
+     * always means the whole task landed. Serialized inside the module; among
+     * tasks waiting at once the lowest plan order goes first. On anything but
+     * `merged` the worktrees and refs stay, and nothing is ever auto-resolved.
+     *
+     * `persist` is called once `run.landing` is set and before the first
+     * merge; the caller saves the run there, synchronously, which is what
+     * lets `pruneOrphans` finish a landing a crash interrupted.
+     */
+    integrate(task: Task, run: IsolationRun, persist?: () => void): Promise<IsolationOutcome>;
+    /**
+     * `keep: false` removes the task's worktree, branch and record (cancel, task
+     * removal). `keep: true` leaves the worktree and branch exactly as they are
+     * for inspection — a failed verdict — and only moves the task off `active`,
+     * so a crash-recovery prune does not sweep it away. Takes the run rather than
+     * a bare task id: ids are only unique within one plan, and one daemon serves
+     * many (ADR-0007).
+     */
+    release(run: IsolationRun, taskId: string, opts: {
+        keep: boolean;
+    }): Promise<void>;
+    /** End of run: park the integration branch for review and report what landed. */
+    handoff(run: IsolationRun): Promise<IsolationHandoff>;
+    /**
+     * Drop what a crash left behind: a landing it interrupted is rolled back in
+     * every repo, then stale active worktrees and directories no record owns go.
+     */
+    pruneOrphans(run: IsolationRun): Promise<void>;
+    /** Unified diff of each repo's integration branch against its base ref. */
+    reviewDiff(run: IsolationRun): Promise<string>;
+    /**
+     * "Merge all": merge each repo's integration branch into whatever the user
+     * has checked out there. The one irreversible step, so it only ever happens
+     * when a caller asks for it. Every repo with work is preflighted first — no
+     * merge of the user's in progress, no conflict against their HEAD, no
+     * uncommitted edit to a file the merge changes — and unless all pass,
+     * nothing is merged anywhere. Only a merge Ordewell itself just started is
+     * ever aborted; nothing of the user's is reset.
+     */
+    mergeIntoCheckedOut(run: IsolationRun): Promise<IsolationMergeResult>;
+    /**
+     * Remove every worktree and task branch of the run, and the integration
+     * branch too unless `keepIntegration` — the branch outlives a discarded run
+     * until the user explicitly gives it up.
+     */
+    discard(run: IsolationRun, opts: {
+        keepIntegration: boolean;
+    }): Promise<void>;
+}
+
+interface UserStep {
+    order: number;
+    instruction: string;
+    completed: boolean;
+}
+/** One deterministic signal gathered while verifying a completed task. */
+interface VerificationCheck {
+    name: 'exit_code' | 'completion_marker' | 'manual';
+    passed: boolean;
+    /** A check that did not apply. Skipped checks don't affect the verdict. */
+    skipped: boolean;
+    detail: string;
+}
+/** Evidence-based verdict for a completed task. Single end-to-end outcome produced by verification. */
+interface Verdict {
+    outcome: 'pass' | 'fail';
+    reason: string;
+    checks: VerificationCheck[];
+    decidedAt: string;
+}
+interface TaskOutputSummary {
+    reviewReason: string;
+    logTail: string;
+    capturedAt: string;
+}
+type TaskType = 'ai' | 'user';
+type TaskStatus = 'pending' | 'approved' | 'in_progress' | 'completed' | 'failed' | 'blocked' | 'awaiting_user';
+type TaskMode = string;
+interface TaskModelAssignment {
+    modelId: string;
+    modelLabel: string;
+    thinkingEffort?: string;
+    /**
+     * All variant ids the model offered when this assignment was made. Carried
+     * on the assignment because runners need it at spawn time (opencode's TUI
+     * only honors an assigned variant when the others are config-disabled) and
+     * the discovery catalog isn't available there.
+     */
+    availableVariants?: string[];
+}
+type RunnerId = string;
+interface Task {
+    id: string;
+    order: number;
+    title: string;
+    description: string;
+    type: TaskType;
+    status: TaskStatus;
+    dependencies: string[];
+    prompt?: string;
+    userSteps?: UserStep[];
+    subtasks: Task[];
+    verdict?: Verdict;
+    outputSummary?: TaskOutputSummary;
+    assignedModel?: TaskModelAssignment;
+    assignedRunner: RunnerId;
+    thinkingEffort?: string;
+    taskMode?: TaskMode;
+    completionMarker: string;
+    autonomy?: 'AFK' | 'HITL';
+    sliceType?: 'HITL' | 'AFK';
+    userStoriesCovered?: string[];
+}
+interface DiscoveredMode {
+    id: string;
+    label: string;
+    description: string;
+}
+type ResearchToolType = 'read_file' | 'read_files' | 'glob' | 'grep' | 'find_symbol' | 'list_dir' | 'bash' | 'fetch' | 'web_search' | 'spawn_research_agent'
+/**
+ * A tool belonging to a harness planner's own toolbox (ADR-0009) that has no
+ * Ordewell equivalent — Edit, WebFetch, TodoWrite, whatever a coding agent
+ * ships next. The real name travels in `toolLabel` rather than being
+ * relabelled as a tool it is not; the union stays closed so the
+ * exhaustiveness checks in every surface's icon/label switch survive.
+ */
+ | 'agent_tool';
+/**
+ * What happened when a research tool call ran, for honest per-surface
+ * rendering. The broadcast seam carries this on every `research_step_done` so
+ * surfaces do not have to pattern-match refusal text to tell a refused `rm`
+ * from a successful `rm` — the old render path flipped a `✓` for both.
+ */
+type ResearchStepOutcome = 'success' | 'failure' | 'refused' | 'denied' | 'not_executed';
+interface ResearchStep {
+    id: string;
+    tool: ResearchToolType;
+    /** The tool's own name when it came from a harness planner — always set for `agent_tool`. */
+    toolLabel?: string;
+    args: string;
+    result: string;
+    success: boolean;
+    outcome: ResearchStepOutcome;
+    /** The model's tool_call id, so a surface can match `tool_result` to the
+     * pending `tool_call` it announced — robust under parallel same-tool rounds. */
+    toolCallId?: string;
+    timestamp: string;
+    thinkingText?: string;
+}
+interface UserPromptEntry {
+    id: string;
+    type: 'user_prompt' | 'system';
+    content: string;
+    timestamp: string;
+}
+type ResearchLogEntry = ResearchStep | UserPromptEntry;
+interface ResearchProgress {
+    type: 'thinking' | 'tool_call' | 'tool_result' | 'plan_token' | 'interrupted' | 'liveness';
+    text?: string;
+    tool?: string;
+    /** Harness planners (ADR-0009): the agent's own name for a tool Ordewell has no member for. */
+    toolLabel?: string;
+    toolArgs?: string;
+    toolResult?: string;
+    planToken?: string;
+    step?: ResearchStep;
+    /** The model's tool_call id, threaded on tool_call and tool_result so a
+     * surface can match the result to its pending call — robust under parallel
+     * same-tool rounds where LIFO-by-name matching mislabels summaries. */
+    toolCallId?: string;
+    /** Present when this event originates from (or reports on) one spawned research subagent (issue #34). */
+    subagentId?: string;
+}
+interface ThinkingBlock {
+    id: string;
+    text: string;
+}
+interface StreamThinkingEvent {
+    type: 'thinking';
+    block: ThinkingBlock;
+}
+interface StreamStepEvent {
+    type: 'step';
+    step: ResearchStep;
+}
+type StreamEvent = StreamThinkingEvent | StreamStepEvent;
+interface DiscoveredModel {
+    modelId: string;
+    modelLabel: string;
+    runnerProvider?: string;
+    /**
+     * Human-facing provider name as the runner itself reports it (e.g.
+     * "OpenCode Zen" for `runnerProvider: 'opencode'`). Populated from the
+     * runner's own provider catalog when available; when absent the UI derives a
+     * label from `runnerProvider` by title-casing.
+     */
+    runnerProviderLabel?: string;
+    /**
+     * The runner whose catalog listed this model. Stamped once, at the single
+     * `ModelDiscovery.discover` choke point, so a flat cross-runner list can
+     * still say where each entry came from — `runnerProvider` alone cannot:
+     * OpenCode reports most of its catalog as `openrouter`, which names the
+     * serving backend, not the agent Ordewell would spawn.
+     */
+    runnerId?: string;
+    /** The runner's display name (`OpenCode`), from its manifest. */
+    runnerLabel?: string;
+    variants: {
+        id: string;
+        label: string;
+    }[];
+}
+type PlanStatus = 'draft' | 'approved' | 'rejected' | 'running' | 'completed';
+/**
+ * One entry of the planner's persisted dialogue (ADR-0002). The single source
+ * of truth for both UI redisplay and conversational context. Tool-call results
+ * are NOT stored here — they live in the AI service's tool-use history;
+ * `researchLog` remains the persisted tool trace for the UI.
+ */
+interface ConversationMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: string;
+    /**
+     * Timeline marker: 'plan_generated' records the point in the dialogue where
+     * the plan was committed (the UI anchors the plan card there on restore);
+     * 'system' is a host-injected notice; 'compaction' is the summary a
+     * user-triggered compaction left in place of the earlier messages — always
+     * the transcript's first entry. Absent for ordinary chat turns, so
+     * sessions saved before markers existed degrade gracefully.
+     */
+    kind?: 'plan_generated' | 'system' | 'compaction';
+}
+interface QueuedMessage {
+    id: string;
+    text: string;
+    timestamp: string;
+}
+interface PlanModificationWarnings {
+    deletedCompleted: string[];
+    changedCompleted: string[];
+    deletedInProgress: string[];
+    modifiedInProgress: string[];
+    brokenDependencies: string[];
+}
+declare function emptyWarnings(): PlanModificationWarnings;
+interface LegacyPlanState {
+    tasks: Task[];
+    generatedAt: string;
+    status: PlanStatus;
+    runners: RunnerId[];
+    lastUpdated: string;
+    researchLog?: ResearchLogEntry[];
+    /** The planner dialogue — user messages and assistant messages, in order (ADR-0002). */
+    conversationHistory?: ConversationMessage[];
+    /** Full markdown PRD once written by the planner (PRD mode), also saved to .scratch/<slug>/PRD.md. */
+    prdMarkdown?: string;
+    /** Follow-ups queued while tasks execute — applied as plan modifications between batches. */
+    queuedMessages?: QueuedMessage[];
+    /**
+     * The plan's isolation run (ADR-0013), written from the orchestrator at
+     * persist time and read back only when a saved plan is adopted. It names
+     * branches and worktrees that belong to this plan alone: a fork of the plan
+     * must leave it behind rather than share it.
+     */
+    isolation?: PlanIsolation;
+}
+interface Message {
+    id: string;
+    role: 'user' | 'planner' | 'system';
+    content: string;
+    timestamp: number;
+}
+interface TaskSnapshot extends Task {
+    completedAt: number;
+    verdict?: Verdict;
+    retryCount: number;
+    finalized: boolean;
+}
+type PlanState = {
+    phase: 'planning';
+    history: Message[];
+    message: string;
+    pendingTasks: Task[];
+} | {
+    phase: 'executing';
+    history: Message[];
+    message: string;
+    executionLog: TaskSnapshot[];
+    pendingTasks: Task[];
+    goal: string;
+    runners: string[];
+    status: PlanStatus;
+};
+declare function migratePlanState(raw: unknown): PlanState;
+declare function migrateLegacyPlan(legacy: LegacyPlanState): PlanState;
+
+declare function createTask(overrides?: Partial<Task>): Task;
+declare function createEmptyPlan(): LegacyPlanState;
+declare function flattenTasks(tasks: Task[]): Task[];
+/** A flattened task with the parent it hangs under, null for a top-level task. */
+interface TaskWithParent {
+    task: Task;
+    parent: Task | null;
+}
+declare function flattenTasksWithParents(tasks: Task[]): TaskWithParent[];
+declare function migrateTask(task: Record<string, unknown>): Task;
+declare function addTaskToPlan(tasks: Task[], partial: Partial<Task>): Task[];
+declare function removeTaskFromPlan(tasks: Task[], taskId: string): Task[];
+declare function updateTaskInPlan(tasks: Task[], taskId: string, changes: Partial<Task>): Task[];
+declare function renumberTasks(tasks: Task[]): Task[];
+declare function validateModifiedPlan(original: Task[], modified: Task[]): PlanModificationWarnings;
+interface ActiveTaskSession {
+    id: string;
+    taskId: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface ValidationContext {
+    executionLog: TaskSnapshot[];
+    oldPending: Task[];
+    newPending: Task[];
+    activeSessions: Map<string, ActiveTaskSession>;
+}
+type ValidationCheck = (ctx: ValidationContext) => ValidationResult;
+declare function warningsText(w: PlanModificationWarnings): string | null;
+
+export { type ValidationContext as $, type ActiveTaskSession as A, type RunnerId as B, type ConversationMessage as C, type DiscoveredMode as D, type StreamStepEvent as E, type StreamThinkingEvent as F, type TaskIsolation as G, type TaskIsolationState as H, type IWorktreeIsolation as I, type TaskMode as J, type TaskModelAssignment as K, type LegacyPlanState as L, type Message as M, type TaskOutputSummary as N, type TaskSnapshot as O, type PlanIsolation as P, type QueuedMessage as Q, type RepoGroupLayout as R, type StreamEvent as S, type Task as T, type TaskStatus as U, type TaskType as V, type TaskWithParent as W, type ThinkingBlock as X, type UserPromptEntry as Y, type UserStep as Z, type ValidationCheck as _, type DiscoveredModel as a, type ValidationResult as a0, type Verdict as a1, type VerificationCheck as a2, addTaskToPlan as a3, createEmptyPlan as a4, createTask as a5, emptyWarnings as a6, flattenTasks as a7, flattenTasksWithParents as a8, migrateLegacyPlan as a9, migratePlanState as aa, migrateTask as ab, removeTaskFromPlan as ac, renumberTasks as ad, updateTaskInPlan as ae, validateModifiedPlan as af, warningsText as ag, type IsolationAvailability as b, type IsolationHandoff as c, type IsolationHandoffRepo as d, type IsolationInactiveReason as e, type IsolationLandedTask as f, type IsolationLanding as g, type IsolationMergeBlock as h, type IsolationMergeBlockReason as i, type IsolationMergeResult as j, type IsolationOutcome as k, type IsolationRepo as l, type IsolationRun as m, type IsolationTaskRecord as n, type IsolationTaskRepo as o, type IsolationTaskStatus as p, type IsolationView as q, type PlanModificationWarnings as r, type PlanState as s, type PlanStatus as t, type PreparedTask as u, type ResearchLogEntry as v, type ResearchProgress as w, type ResearchStep as x, type ResearchStepOutcome as y, type ResearchToolType as z };