@ordewell/core 0.4.23 → 0.5.1

package/dist/index.d.mts

@@ -1,17 +1,17 @@
-import { h as RunnerId, c as PlanStatus, L as LegacyPlanState, a as DiscoveredModel, T as Task, d as ResearchProgress, R as ResearchLogEntry, C as ConversationMessage, n as TaskSnapshot, Q as QueuedMessage, A as ActiveTaskSession, g as ResearchToolType, b as PlanState, v as Verdict } from './Task-4rDGr8Su.mjs';
-export { D as DiscoveredMode, M as Message, P as PlanModificationWarnings, e as ResearchStep, f as ResearchStepOutcome, S as StreamEvent, i as StreamStepEvent, j as StreamThinkingEvent, k as TaskMode, l as TaskModelAssignment, m as TaskOutputSummary, o as TaskStatus, p as TaskType, q as TaskWithParent, r as ThinkingBlock, U as UserPromptEntry, s as UserStep, V as ValidationCheck, t as ValidationContext, u as ValidationResult, w as VerificationCheck, x as addTaskToPlan, y as createEmptyPlan, z as createTask, B as emptyWarnings, E as flattenTasks, F as flattenTasksWithParents, G as migrateLegacyPlan, H as migratePlanState, I as migrateTask, J as removeTaskFromPlan, K as renumberTasks, N as updateTaskInPlan, O as validateModifiedPlan, W as warningsText } from './Task-4rDGr8Su.mjs';
-import { f as IFileSystem, R as ReadFileOpts, T as ToolOutcome, d as GrepOptions, c as GlobOptions, b as FindSymbolOptions, I as IConfig, A as AiProvider, r as ProviderModelLists, i as ITerminalSession, h as ITerminalRunner, w as RunnerRegistry, k as OrchestratorOption, u as RunnerInvocation, g as IPluginStore, v as RunnerPluginManifest, t as ResolveContext } from './ITerminalRunner-CuNYBnqK.mjs';
-export { a as AllProviderModels, C as CatalogModel, D as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, e as GrepOutputMode, M as ModelCatalog, j as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, l as PluginEntry, m as PluginFeatures, n as PluginMode, o as PluginModelDiscovery, p as PluginRunnerDef, q as ProviderCredentialSource, s as ProviderModelsResult, S as SEARCH_EXCLUSIONS, x as collectProviderCredentials, y as enabledRunners, z as fetchAllProviderModels, B as isReservedRunnerName, E as knownModelId, H as resolveModelShortcut, J as resolveProvider, K as toOrchestratorOptions } from './ITerminalRunner-CuNYBnqK.mjs';
+import { F as RunnerId, u as PlanStatus, L as LegacyPlanState, k as IsolationMergeResult, g as IsolationLandedTask, I as IWorktreeIsolation, w as RepoGroupLayout, a as DiscoveredModel, T as Task, y as ResearchProgress, x as ResearchLogEntry, C as ConversationMessage, V as TaskSnapshot, d as IsolationHandoff, J as TaskIsolation, r as IsolationView, P as PlanIsolation, Q as QueuedMessage, A as ActiveTaskSession, E as ResearchToolType, t as PlanState, a3 as Verdict } from './Task-BxQkPlXO.mjs';
+export { D as DiscoveredMode, b as IntegrationDisposal, c as IsolationAvailability, e as IsolationHandoffRepo, f as IsolationInactiveReason, h as IsolationLanding, i as IsolationMergeBlock, j as IsolationMergeBlockReason, l as IsolationOutcome, m as IsolationRepo, n as IsolationRun, o as IsolationTaskRecord, p as IsolationTaskRepo, q as IsolationTaskStatus, M as Message, s as PlanModificationWarnings, v as PreparedTask, R as RepairEvidence, z as ResearchStep, B as ResearchStepOutcome, S as StreamEvent, G as StreamStepEvent, H as StreamThinkingEvent, K as TaskIsolationState, N as TaskMode, O as TaskModelAssignment, U as TaskOutputSummary, W as TaskStatus, X as TaskType, Y as TaskWithParent, Z as ThinkingBlock, _ as UserPromptEntry, $ as UserStep, a0 as ValidationCheck, a1 as ValidationContext, a2 as ValidationResult, a4 as VerificationCheck, a5 as addTaskToPlan, a6 as createEmptyPlan, a7 as createTask, a8 as emptyWarnings, a9 as flattenTasks, aa as flattenTasksWithParents, ab as migrateLegacyPlan, ac as migratePlanState, ad as migrateTask, ae as removeTaskFromPlan, af as renumberTasks, ag as updateTaskInPlan, ah as validateModifiedPlan, ai as warningsText } from './Task-BxQkPlXO.mjs';
+import { f as IFileSystem, R as ReadFileOpts, T as ToolOutcome, d as GrepOptions, c as GlobOptions, b as FindSymbolOptions, I as IConfig, A as AiProvider, r as ProviderModelLists, i as ITerminalSession, h as ITerminalRunner, w as RunnerRegistry, k as OrchestratorOption, u as RunnerInvocation, g as IPluginStore, v as RunnerPluginManifest, t as ResolveContext } from './ITerminalRunner-DCjsa2-I.mjs';
+export { a as AllProviderModels, C as CatalogModel, D as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, e as GrepOutputMode, M as ModelCatalog, j as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginCloneFn, l as PluginEntry, m as PluginFeatures, n as PluginMode, o as PluginModelDiscovery, p as PluginRunnerDef, q as ProviderCredentialSource, s as ProviderModelsResult, S as SEARCH_EXCLUSIONS, x as collectProviderCredentials, y as enabledRunners, z as fetchAllProviderModels, B as isReservedRunnerName, E as knownModelId, H as resolveModelShortcut, J as resolveProvider, K as toOrchestratorOptions } from './ITerminalRunner-DCjsa2-I.mjs';
 import { I as IApproval, d as ApprovalRequest, a as ApprovalMode } from './ApprovalPolicy-BVhGdECT.mjs';
 export { A as ApprovalKind, b as ApprovalPolicy, c as ApprovalPolicyOptions, e as ApprovalSource, D as DENY_ALL } from './ApprovalPolicy-BVhGdECT.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-mtIWrLXn.mjs';
-export { M as ManifestLookup, b as buildModeGuide, f as filteredBuildModes, r as resolveDefaultMode, a as resolveTaskMode, c as runnerModesFrom } from './ModeResolver-mtIWrLXn.mjs';
-import { T as TaskOp, c as SessionBroadcaster } from './plan-utils-s6VL8NDF.mjs';
-export { A as ApplyTaskOpsResult, C as CHECKPOINT_TRUNCATE_LENGTH, S as SerializedPlan, a as SerializedTask, b as SerializedTaskStatus, d as SessionMessage, e as TaskRef, f as applyTaskOps, g as canMergeTasks, h as canSetDependencies, i as canSplitTask, j as classifyOutcome, k as dependencyCandidates, l as dependentsOf, m as executionSummary, p as parseTaskOpsJson, s as serializePlan, n as serializeTask, o as serializeTaskStatus, q as summarizeToolCall, t as textHasTaskOps, r as truncateCheckpointSummary } from './plan-utils-s6VL8NDF.mjs';
+import { T as TaskOp, f as SessionBroadcaster, h as SessionNotice } from './plan-utils-CtB3_Ovf.mjs';
+export { A as Adr0013IsolationRun, a as Adr0013PlanIsolation, b as Adr0013TaskRecord, c as ApplyTaskOpsResult, C as CHECKPOINT_TRUNCATE_LENGTH, S as SerializedPlan, d as SerializedTask, e as SerializedTaskStatus, g as SessionMessage, i as TaskRef, j as applyTaskOps, k as canMergeTasks, l as canSetDependencies, m as canSplitTask, n as capConflictFiles, o as classifyOutcome, p as dependencyCandidates, q as dependentsOf, r as executionSummary, s as migratePlanIsolation, t as parseTaskOpsJson, u as serializePlan, v as serializeTask, w as serializeTaskStatus, x as summarizeToolCall, y as textHasTaskOps, z as truncateCheckpointSummary } from './plan-utils-CtB3_Ovf.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-DVJ7HV3k.mjs';
+export { M as ManifestLookup, b as buildModeGuide, f as filteredBuildModes, r as resolveDefaultMode, a as resolveTaskMode, c as runnerModesFrom } from './ModeResolver-DVJ7HV3k.mjs';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
-import { b as PlanParseError } from './parsing-BWfpLch9.mjs';
-export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as TASK_QUERY_ENVELOPE_KEY, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as looksLikePlanAttempt, p as parsePartialPlan, n as parsePlanJson, s as stripModelNoise, o as stripTrailingCommas, v as validatePlanModification } from './parsing-BWfpLch9.mjs';
+import { b as PlanParseError } from './parsing-DRp4dPC0.mjs';
+export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as TASK_QUERY_ENVELOPE_KEY, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as looksLikePlanAttempt, p as parsePartialPlan, n as parsePlanJson, s as stripModelNoise, o as stripTrailingCommas, v as validatePlanModification } from './parsing-DRp4dPC0.mjs';
 export { resolveOrderLabel, taskOrderLabel } from './order-labels.mjs';
 
 interface SessionMeta {
@@ -523,6 +523,11 @@ declare abstract class BaseConfig implements IConfig {
     get researchMaxFileSize(): number;
     get planMapEnabled(): boolean;
     get autonomousMode(): boolean;
+    get worktreeIsolation(): boolean;
+    get worktreeSetupCommand(): string | undefined;
+    get workspaceRepos(): string[];
+    get worktreeLinks(): string[];
+    get conflictRepairAttempts(): number;
     get approvalMode(): ApprovalMode;
     get approvalPreApproved(): string[];
     protected static detectProvider(fallback: AiProvider): AiProvider;
@@ -553,6 +558,35 @@ interface INotification {
     confirm(msg: string, options: string[]): Promise<string | undefined>;
 }
 
+/**
+ * How "Merge all" went, in words every surface shares. `group` is whether the
+ * run spans more than a lone repo at `.`; only a merge into every repository
+ * has something to say about that. `repaired` names the landed tasks that only
+ * landed after a conflict repair (ADR-0015), so a clean-looking merge still
+ * points review at what changed to get there.
+ */
+declare function describeMergeResult(result: IsolationMergeResult, branch: string, group: boolean, repaired?: IsolationLandedTask[]): {
+    level: 'info' | 'warn' | 'error';
+    message: string;
+};
+
+type GitExecFn = (file: string, args: string[], opts: {
+    cwd?: string;
+    env: NodeJS.ProcessEnv;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+interface WorktreeIsolationDeps {
+    config: Pick<IConfig, 'worktreeIsolation' | 'worktreeSetupCommand' | 'workspaceRepos' | 'worktreeLinks'>;
+    /** Test seam: every git invocation goes through this. */
+    execFileImpl?: GitExecFn;
+    resolvePath?: () => Promise<string>;
+    platform?: NodeJS.Platform;
+    mintRunId?: () => string;
+}
+declare function createWorktreeIsolation(deps: WorktreeIsolationDeps): IWorktreeIsolation;
+
 interface ILogger {
     warn(scope: string, message: string, err?: unknown): void;
 }
@@ -628,9 +662,75 @@ interface PlannerRuntimeToggles {
  * every planner signature used to carry positionally — where a thirteenth
  * parameter was the only place left to put a new toggle.
  */
+/**
+ * Where the run's tasks will work: `false` in the shared workspace root;
+ * otherwise each in its own worktree of every repo of the group (ADR-0013,
+ * ADR-0014), which is what decides if tasks on the same file must be ordered.
+ */
+type IsolatedExecution = false | RepoGroupLayout;
 interface PlannerModes {
     autonomousDefault: boolean;
     verification: boolean;
+    /** Not a toggle: a fact about the run. */
+    isolatedExecution: IsolatedExecution;
+}
+
+/** Context of one task attempt, enough to locate its transcript. */
+interface TranscriptQuery {
+    runner: string;
+    /** The task's working directory (the agent's cwd at spawn). */
+    cwd: string;
+    /** When the agent process started, ISO — used to reject older sessions. */
+    startedAt?: string;
+    /**
+     * The task's completion marker UUID. The prompt carries it, so a transcript
+     * that does not contain it belongs to some other task — parallel attempts in
+     * one cwd are otherwise indistinguishable by directory and recency.
+     */
+    marker: string;
+}
+/** Reads the agent's own session transcript for a task's final answer. */
+interface TranscriptReader {
+    /** Last assistant-authored prose, clamped to `maxChars` from the end, or null. */
+    finalAssistantText(query: TranscriptQuery, maxChars?: number): Promise<string | null>;
+}
+/** The part of a task attempt its output is looked up by. */
+interface TaskOutputAttempt {
+    readonly taskId: string;
+    readonly runner: string;
+    /** Null when the attempt ended before its working directory was settled. */
+    readonly cwd: string | null;
+    readonly startedAt: string;
+    /** The completion marker UUID the attempt's prompt carried. */
+    readonly completionMarker: string;
+}
+interface LiveTailOptions {
+    maxLines: number;
+    /** A previous {@link LiveTail.nextOffset}: only output after it is rendered. */
+    sinceOffset?: number;
+}
+interface LiveTail {
+    /** Clean terminal render, not raw ANSI. */
+    text: string;
+    /** Total output received so far; pass it back as `sinceOffset` to read only what follows. */
+    nextOffset: number;
+    running: boolean;
+}
+/**
+ * The one owner of a task attempt's output: what it printed while running
+ * and what it answered once it ended.
+ */
+interface TaskOutputSource {
+    /** Start capturing a session; replaces any earlier capture of the task. */
+    attach(taskId: string, session: ITerminalSession): void;
+    /** Stop capturing the task's session; what was captured stays readable. */
+    detach(taskId: string): void;
+    /** Drop every capture (a new plan reuses task ids). */
+    reset(): void;
+    /** The attempt's final answer: its transcript first, the clean terminal render otherwise. */
+    finalText(attempt: TaskOutputAttempt, doneToken: string): Promise<string>;
+    /** Recent output of the task's latest capture, or null if it never had one. */
+    liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
 }
 
 /**
@@ -648,8 +748,19 @@ interface PlannerModes {
  * lives in PlanRepair alongside the plan and task-ops envelopes.
  */
 /** The long fields a query may ask for. Everything else is already in the plan block. */
-declare const TASK_QUERY_FIELDS: readonly ["description", "prompt", "userSteps", "verdict", "outputSummary", "userStoriesCovered"];
+declare const TASK_QUERY_FIELDS: readonly ["description", "prompt", "userSteps", "verdict", "outputSummary", "userStoriesCovered", "output"];
 type TaskQueryField = typeof TASK_QUERY_FIELDS[number];
+/** Lines a `output` read returns when the query sets no count. */
+declare const OUTPUT_LINES_DEFAULT = 80;
+/** Hard cap on `outputLines` — the tail read is bounded however the planner asks. */
+declare const OUTPUT_LINES_MAX = 400;
+/**
+ * Character budget the rendered answer converges to. A running output tail is
+ * the only part with no natural bound — a runner may print for minutes — so
+ * the tail absorbs the clamp; everything else (task bodies, the catalog cap)
+ * is bounded upstream.
+ */
+declare const TASK_QUERY_ANSWER_MAX_CHARS = 20000;
 interface TaskQuery {
     /** Task references to read in full — an id, "#order", a bare order, or a title. */
     tasks: string[];
@@ -657,6 +768,10 @@ interface TaskQuery {
     fields?: TaskQueryField[];
     /** Also return the full runner/model catalog with labels, variants and mode descriptions. */
     catalog: boolean;
+    /** Line count for `output` reads. Clamped at render to [1, {@link OUTPUT_LINES_MAX}]. */
+    outputLines?: number;
+    /** A previous answer's next offset: the output tail then covers only what came after it. */
+    outputSince?: number;
 }
 declare function textHasTaskQuery(text: string): boolean;
 /** Parse a `{"taskQuery":...}` reply. Throws PlanParseError when the JSON is unusable. */
@@ -685,12 +800,19 @@ declare const TASK_QUERY_ANSWER_OR_OPS: string;
 declare const TASK_QUERY_PROTOCOL: string[];
 /** The one-line reminder the per-turn plan block carries, so the protocol has a single owner. */
 declare const TASK_QUERY_REMINDER = "- To READ a task in full (prompt, user steps, verdict, output, user stories) or the whole model/mode catalog before editing, reply with ONLY {\"taskQuery\":{\"tasks\":[\"<id or #order>\"],\"catalog\":true}} \u2014 it changes nothing, and you then reply again with your ops.";
+/**
+ * Where an `output` read is answered from: the orchestrator's live capture of
+ * the task's latest attempt. Injected so this module stays planner-side and
+ * never imports the orchestrator.
+ */
+type LiveOutputLookup = (taskId: string, opts: LiveTailOptions) => LiveTail | null;
 /**
  * Render the injected answer to one read. Never persisted — it is context for
  * the planner's next reply and nothing else — so it is built fresh from live
- * state on every query rather than cached.
+ * state on every query rather than cached. `liveOutput` backs the `output`
+ * field; omitting it reads as "nothing captured".
  */
-declare function renderTaskQueryAnswer(query: TaskQuery, tasks: Task[], catalog: TaskQueryCatalog): string;
+declare function renderTaskQueryAnswer(query: TaskQuery, tasks: Task[], catalog: TaskQueryCatalog, liveOutput?: LiveOutputLookup): string;
 
 declare abstract class AbstractTerminalSession implements ITerminalSession {
     id: string;
@@ -967,6 +1089,7 @@ declare class HeadlessRunner extends AbstractRunner<HeadlessSession> {
     private hasScriptCmd;
     private resolvePath;
     private launchDeps;
+    private spawnCount;
     /**
      * Session shape: a piped subprocess is not a terminal, so runners get their
      * non-interactive subcommand. The VS Code runner owns a pseudoterminal and
@@ -976,6 +1099,13 @@ declare class HeadlessRunner extends AbstractRunner<HeadlessSession> {
      */
     protected readonly defaultInteractive: boolean;
     constructor(deps?: HeadlessRunnerDeps);
+    /**
+     * Unique per spawn, not per task: a retry reuses its task id and ids often
+     * share a prefix, and a shared registry key let the old attempt's exit
+     * unregister the new one. Unlike TmuxRunner, nothing outside this process
+     * keys on the id, so a counter is enough to scope it to the attempt.
+     */
+    protected nextSessionId(taskId: string): string;
     protected createSession(id: string, taskId: string): HeadlessSession;
     /** Everything up to, but not including, spawning — so a surface that owns its own child reaches the same decisions. */
     protected prepareLaunch(opts: RunnerSpawnOptions, ptyOptions?: PtyWrapOptions): Promise<PreparedLaunch>;
@@ -1233,6 +1363,8 @@ interface ConversationRequest {
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
     verificationEnabled?: boolean;
+    /** Where tasks will run (ADR-0013, ADR-0014): in worktrees, the prompt drops file-overlap ordering and describes a repo group. */
+    isolatedExecution?: IsolatedExecution;
     signal?: AbortSignal;
     /**
      * Persisted dialogue to seed a resumed conversation (session reload). The
@@ -1308,6 +1440,13 @@ interface IAiService {
      * `continueConversation`, restart instead so the new model takes effect.
      */
     conversationMatchesConfig?(): boolean;
+    /**
+     * Optional: prune bulky raw tool output out of the live conversation, in
+     * place, keeping subagent digests. Returns the characters removed. Absent
+     * where the backend holds no tool transcript to prune (a harness planner's
+     * agent owns its own context).
+     */
+    pruneContext?(): number;
     /**
      * One-shot research + plan for non-conversational surfaces (CLI `plan --goal`,
      * web REST). Never asks questions — it plans with what it can find.
@@ -1391,6 +1530,7 @@ declare abstract class BaseAiService {
     abstract reset(): void;
     abstract ensureInit(): void;
     hasActiveConversation(): boolean;
+    pruneContext(): number;
     protected startAbortScope(callerSignal?: AbortSignal): AbortSignal | undefined;
     protected stopAbortScope(): void;
     sendPlanningPrompt(prompt: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Promise<Task[]>;
@@ -1626,10 +1766,39 @@ interface OrchestratorObserver {
         taskTitle: string;
         summary: string;
     }): void;
+    /** The isolation run record changed and should be persisted with the plan. */
+    onIsolationChanged?(): void;
+    /** A run did not start: the tree is dirty, and the user picks stash or no isolation. `repos` names the dirty repos of a group. */
+    onIsolationBlocked?(data: {
+        reason: 'dirty';
+        repos: string[];
+    }): void;
+    /** An isolated run settled; emitted before `onExecutionComplete`, which surfaces treat as terminal. */
+    onIsolationHandoff?(handoff: IsolationHandoff): void;
+    /**
+     * What a run says about how it isolates — the fallback to the workspace root,
+     * shared paths, copies, a stash. Beside the notification channel, which a
+     * daemon may leave unwired, so a surface without toasts can still show it.
+     */
+    onIsolationNotice?(data: {
+        level: 'info' | 'warn';
+        message: string;
+    }): void;
+}
+type AttemptPhase = 'starting' | 'running' | 'integrating';
+/** Read-only view of a task's live attempt. */
+interface TaskAttemptSnapshot {
+    taskId: string;
+    attempt: number;
+    phase: AttemptPhase;
+    sessionId: string | null;
+    runner: string;
+    cwd: string | null;
+    startedAt: string;
 }
 /**
  * The pure scheduler. Owns execution state (`running`, `planStatus`,
- * `reviewApproved`, `activeTaskSessions`, `messageQueue`) and the verifier.
+ * `reviewApproved`, the live task attempts, `messageQueue`) and the verifier.
  * All task-shaped state — the plan tree, the flat index, the completed set
  * — lives in {@link PlanStore}, injected at construction. The orchestrator
  * calls `store.markCompleted(id)` / `store.markFailed(id)` instead of mutating
@@ -1641,15 +1810,16 @@ declare class TaskOrchestrator {
     private config;
     private notifications;
     private terminalRunner;
+    private output;
     private store;
-    private activeTaskSessions;
-    private startingTaskIds;
+    private attempts;
     private verifier;
     private running;
     private planStatus;
     private messageQueue;
     private reviewApproved;
     private retryCounts;
+    private spawnCounts;
     /**
      * Tasks pulled out of auto-scheduling (user-cancelled or failed to spawn).
      * They stay 'pending' — "not executed" — but the scheduler skips them until
@@ -1657,18 +1827,33 @@ declare class TaskOrchestrator {
      * task whose spawn always throws.
      */
     private onHold;
+    private isolation;
+    /** The plan's isolation run (ADR-0013). Outlives one run: a resumed plan continues it. */
+    private isolationRun;
+    /** Copied paths already reported for the current run: every task gets the same copies. */
+    private reportedCopies;
+    /**
+     * How the open run executes; null while no run is open. A run is one
+     * Execute-Plan or one manual task run, from its start until it settles or
+     * is stopped.
+     */
+    private runMode;
+    /** Resolver task id → the conflicted task it resolves; see {@link linkConflictResolver}. */
+    private resolvers;
+    private opening;
+    /** The start a dirty tree turned away, replayed once the user chooses how to go on. */
+    private blockedStart;
+    /** The dirty repos behind {@link blockedStart}, for the stash notice. */
+    private blockedRepos;
     private registry;
     private workspaceRootFn;
     private observers;
     private tddEnabled;
-    /**
-     * Spawn context per active task, for locating the agent's own session
-     * transcript at verdict time (issue #16). Cleared with the session entry.
-     */
-    private taskSpawnContext;
-    constructor(config: IConfig, notifications: INotification, terminalRunner: ITerminalRunner, store?: PlanStore);
+    constructor(config: IConfig, notifications: INotification, terminalRunner: ITerminalRunner, store?: PlanStore, output?: TaskOutputSource, isolation?: IWorktreeIsolation);
     /** Advisory silence timestamp for a task's live runner, or null if not idle. */
     getIdleSince(taskId: string): string | null;
+    /** Recent clean output of a task's latest attempt, running or ended; null if it never ran. */
+    getLiveOutput(taskId: string, opts: LiveTailOptions): LiveTail | null;
     get storeInstance(): PlanStore;
     setWorkspaceRoot(fn: () => string): void;
     setRegistry(registry: RunnerRegistry): void;
@@ -1694,8 +1879,48 @@ declare class TaskOrchestrator {
     get isReviewApproved(): boolean;
     get status(): 'approved' | 'running' | 'completed';
     get activeTaskIds(): string[];
+    /** Task id → session id of every attempt whose runner is up; a spawn in flight has no session yet. */
     get activeSessionMap(): Map<string, string>;
+    getAttempt(taskId: string): TaskAttemptSnapshot | undefined;
+    /** Where a task's isolated work stands; null when the plan has no isolation run to speak of. */
+    getTaskIsolation(taskId: string): TaskIsolation | null;
+    /**
+     * The plan's isolation as a surface shows it, for one with no stream to have
+     * told it — a reconnected webview, a session just loaded. Null without a run.
+     */
+    isolationView(): IsolationView | null;
+    getAttemptSession(taskId: string): ITerminalSession | undefined;
     get queuedCount(): number;
+    /** A run is waiting on the user to stash or to go on without isolation. */
+    get awaitingIsolationChoice(): boolean;
+    /**
+     * Take over a plan's persisted isolation, or none for a plan that has not
+     * isolated yet. Whatever a crashed process left behind for the run — a
+     * worktree still marked active, a directory no record owns — is pruned,
+     * while kept, failed and conflicted worktrees stay for the user.
+     *
+     * Deliberately silent on the observer: adopting is not a change to persist,
+     * and a host that adopts without persisting (VS Code's restore) would
+     * otherwise write a new session file on every reload.
+     */
+    adoptIsolation(state: PlanIsolation | null): Promise<void>;
+    reviewRunDiff(): Promise<string>;
+    /**
+     * "Merge all": the run's integration branches into whatever the user has
+     * checked out, in every repo or none. Once everything merged, the run has
+     * nothing left to hand over, so it is cleared up and forgotten; a branch
+     * the user's HEAD somehow does not contain stays for the next run's sweep.
+     */
+    mergeRun(): Promise<IsolationMergeResult>;
+    private clearMergedRun;
+    /** Worktrees and task branches go; the integration branch and the record stay for review and merge. */
+    cleanupRun(): Promise<void>;
+    /** The run and everything it made go, and the plan forgets it; the next run starts afresh. */
+    discardRun(): Promise<void>;
+    private forgetRun;
+    private requireRun;
+    /** What the plan persists of isolated execution; null when no run ever isolated. */
+    get isolationRecord(): PlanIsolation | null;
     queueMessage(text: string): void;
     getQueuedMessages(): QueuedMessage[];
     setQueuedMessages(messages: QueuedMessage[]): void;
@@ -1718,7 +1943,63 @@ declare class TaskOrchestrator {
     stop(): void;
     onUserTaskComplete(taskId: string): Promise<void>;
     private onVerdict;
+    private afterVerdict;
+    /**
+     * A repair's verdict decides only whether its work may try to land. It never
+     * replaces the verdict the task's own work earned, and a repair that does not
+     * land leaves the task waiting on the user — never a failed task, so never a
+     * halted run.
+     */
+    private settleRepair;
+    /**
+     * Evidence before the queue: the repair's work is committed and checked, and
+     * only then merged, through the same serialized landing as any other task —
+     * so a repair the tip has moved past again is a fresh conflict, not a pass.
+     */
+    private landRepair;
+    private landedRepair;
+    /** A repair that did not land leaves the task as its conflict did: waiting on the user, worktree and refs kept. */
+    private unrepaired;
+    private describeEvidence;
+    /**
+     * Merge a passed attempt's worktree. The attempt stays live while it waits on
+     * the module's merge queue, so a cancel, retry or stop in that window still
+     * wins, and nothing counts the task as done before its work is on the
+     * integration branch.
+     */
+    private integrate;
+    /** A worktree whose work is not on the integration branch yet. */
+    private hasUnlandedWork;
+    private integrateWork;
+    /** Settle a task whose work passed, by what its integration reported. */
+    private landPassed;
+    private landUnmerged;
+    /** The repair a conflicted task is owed next; null when repair is off, used up, or there is no isolated run to repair it in. */
+    private nextRepair;
+    private noRepairReason;
+    /**
+     * Mark which added task resolves which conflict. The resolver merges the
+     * conflicted task's branch by hand in its own worktree; once that lands, the
+     * conflicted task's branch is already on the integration branch and it can
+     * land in turn — through the same merge, so a resolver that did not really
+     * bring it along conflicts again instead of being taken at its word.
+     */
+    linkConflictResolver(resolverId: string, conflictedId: string): void;
+    private landResolved;
+    /**
+     * Let go of a task's worktree. `keep` leaves it and its branch for
+     * inspection; otherwise both go. A merge still in flight finishes first, so
+     * the worktree is never torn down underneath it.
+     */
+    private releaseWorktree;
     getReadyTasks(): Task[];
+    /**
+     * In an isolated run a dependency is met once its work is on the integration
+     * branch, not merely once it passed: the dependent's worktree is cut from
+     * that branch, so starting earlier would hand it a tree without the work it
+     * depends on.
+     */
+    private dependencyMet;
     isBlocked(task: Task): boolean;
     /**
      * Cancel a running (or scheduled) task: kill its session and return it to
@@ -1728,12 +2009,10 @@ declare class TaskOrchestrator {
     cancelTask(taskId: string): Promise<void>;
     /**
      * Let go of a task that is leaving the plan. A live runner is cancelled
-     * through {@link cancelTask} so the verifier generation is bumped before the
-     * process dies; a spawn still in flight is dropped from `startingTaskIds`,
+     * through {@link cancelTask}; a spawn still in flight just loses its attempt,
      * which is what makes {@link startTask} kill the session it is about to
-     * receive. The id's remaining bookkeeping goes too — a hold or retry count
-     * kept for a task that no longer exists would be inherited by nothing and
-     * leaves `isRunning` reading true forever.
+     * receive. The id's cross-attempt bookkeeping goes too — a hold or retry
+     * count kept for a task that no longer exists would be inherited by nothing.
      */
     releaseTask(taskId: string): Promise<void>;
     markTaskComplete(taskId: string): Promise<void>;
@@ -1779,6 +2058,75 @@ declare class TaskOrchestrator {
     };
     tick(): Promise<void>;
     private startTask;
+    /**
+     * A spawn whose attempt ended while it was in flight: kill what it produced
+     * and take back the claim it made. Only the claim — whatever ended the
+     * attempt may have decided the task since (mark complete, cancel, retry).
+     */
+    private abandonSpawn;
+    private repairPrompt;
+    /**
+     * The one place an attempt's working directory is decided. Async so a
+     * per-attempt workspace (worktree isolation, #12) can be prepared here.
+     */
+    private resolveAttemptCwd;
+    private tell;
+    private reportCopies;
+    /**
+     * Open a run if none is: decide once, at its start, whether it executes in
+     * worktrees. `resume` is what a dirty tree parks until the user chooses how
+     * to go on. Resolves false when the run did not start.
+     */
+    private openRun;
+    /**
+     * Whether the run in force, or else the next one, gives each task its own
+     * worktrees, and of which repo group — what the planner is told, since it
+     * decides whether tasks on the same file have to be ordered and which shared
+     * paths two tasks must not edit at once. A tree that would block counts as
+     * not isolating: the user may yet run without isolation, and ordering is
+     * the safe rule then.
+     */
+    plannerIsolation(): Promise<IsolatedExecution>;
+    private decideRun;
+    private activate;
+    /** What earlier runs left merged in the group goes; a failure here is worth a word, never a stopped run. */
+    private sweep;
+    /**
+     * The plan's run carries on while anything has landed on its integration
+     * branch: a resumed plan's dependents must start from a tip that holds their
+     * predecessors' work, and a fresh branch from the checked-out commit does not.
+     */
+    private continuableRun;
+    /**
+     * A run with nothing landed holds only superseded attempts, so it goes whole.
+     * One that cannot be continued for another reason — it ran from a different
+     * workspace path — keeps its integration branch in each repo that has not
+     * merged it: only the user gives landed work up.
+     */
+    private mintRun;
+    /** Close the open run. An isolated one hands its integration branch over for review. */
+    private closeRun;
+    /**
+     * Replay the start a dirty tree turned away. `stash` puts the user's tracked
+     * changes on the git stash first, so the run isolates; `shared` runs this one
+     * run in the workspace root, knowingly.
+     */
+    continueBlockedRun(how: 'stash' | 'shared'): Promise<void>;
+    /**
+     * The one way an attempt ends. Dropping the record is itself what
+     * invalidates a spawn still in flight ({@link startTask} kills the session
+     * it receives for an attempt that is no longer current).
+     *
+     * A user interruption also bumps the verifier's generation *before* stopping
+     * the runner: some runners (e.g. tmux) fire onExit synchronously from
+     * stop(), and if that exit reaches VerdictEngine under the still-valid
+     * generation it delivers a verdict that marks the task 'completed' for one
+     * tick — long enough for the scheduler to start a dependent task. A verdict
+     * leaves the runner up so its terminal stays readable, and stop/load reset
+     * the whole verifier themselves.
+     */
+    private endAttempt;
+    private endAllAttempts;
 }
 
 /**
@@ -1821,6 +2169,8 @@ interface ModifyDuringExecutionRequest {
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
     perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
+    /** Where the run in force puts each task (ADR-0013, ADR-0014). */
+    isolatedExecution?: IsolatedExecution;
 }
 interface ModifyDuringExecutionResult {
     pendingTasks: Task[];
@@ -2333,6 +2683,39 @@ declare function mapAgentTool(name: string): MappedTool;
  */
 declare function normalizeAgentArgs(tool: ResearchToolType, args: Record<string, unknown>): Record<string, unknown>;
 
+/**
+ * A conversation edit (rewind, fork) the conversation refused because the
+ * request itself is wrong — no such message, nothing to fork. Transport-agnostic
+ * like `PlanEditError`: a route maps it to a status, core carries none.
+ */
+declare class ConversationEditError extends Error {
+    constructor(message: string);
+}
+/**
+ * Refused because a planner turn is in flight. Distinct from a bad request:
+ * the same call succeeds once the turn settles, and the turn would otherwise
+ * append its reply to a transcript that no longer holds the message it
+ * answers.
+ */
+declare class ConversationBusyError extends ConversationEditError {
+    constructor(operation: string);
+}
+/** A user message a rewind can fork the conversation from just before. */
+interface RewindTarget {
+    /** Position in the transcript — what {@link PlannerConversation.cloneBefore} takes. */
+    index: number;
+    preview: string;
+    /** The whole message — the preview cuts it to one line, and a surface confirming the rewind quotes it. */
+    content: string;
+    timestamp: string;
+}
+/** What a compaction left behind. */
+interface ConversationCompaction {
+    summary: string;
+    /** Transcript entries kept verbatim after the summary entry. */
+    keptMessages: number;
+}
+
 declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture"];
 interface SkillMetadata {
     name: string;
@@ -2423,6 +2806,16 @@ declare function resolveSkillInvocation(text: string, skillsService: Pick<Skills
  * settings (tdd, verification) are read live via the `settings` callback so a toggle
  * between generate and execute takes effect.
  */
+/** Where a fork landed: the new session's id, and what adopting it needs. */
+interface ConversationFork {
+    sessionId: string;
+    goal: string;
+    workspace: string;
+}
+/** A fork made by a rewind, and the full text of the message it was made just before. */
+interface ConversationRewind extends ConversationFork {
+    rewoundMessage: string;
+}
 interface SessionDeps {
     config: IConfig;
     notifications: INotification;
@@ -2434,6 +2827,8 @@ interface SessionDeps {
     fsAdapter: IFileSystem;
     /** Emits plan-lifecycle events to the surface. Transport-agnostic. */
     broadcast: SessionBroadcaster;
+    /** Where {@link SessionNotice}s go, for a host whose `notifications` are not seen by the user. */
+    onNotice?: (notice: SessionNotice) => void;
     /** Shared across sessions — sole producer of model catalogs and routing lists. */
     modelResolver: ModelResolver;
     /** Live runtime settings (tdd, verification). Read at each operation that needs them. */
@@ -2457,6 +2852,17 @@ interface SessionDeps {
      * over the session's workspace root.
      */
     skillsService?: SkillsService;
+    /**
+     * Where a task's output and final answer are read. Defaults to the agents'
+     * own transcripts under the user's home; tests inject one that never
+     * touches the disk.
+     */
+    taskOutput?: TaskOutputSource;
+    /**
+     * Git worktree isolation (ADR-0013). Defaults to git itself, gated by
+     * `config.worktreeIsolation`; tests inject `FakeWorktreeIsolation`.
+     */
+    isolation?: IWorktreeIsolation;
 }
 /**
  * The per-session execution stack — deepened from a wiring bag into the
@@ -2486,6 +2892,7 @@ declare class Session {
     private goal;
     private workspace;
     private broadcast;
+    private onNotice?;
     private modelResolver;
     private fsAdapter;
     private approvals;
@@ -2498,6 +2905,7 @@ declare class Session {
     private readonly hostSessionId?;
     private currentSessionId;
     private readonly skillsService;
+    private readonly conversation;
     constructor(deps: SessionDeps);
     /**
      * The planner transport for the provider configured *right now* (ADR-0009).
@@ -2531,6 +2939,7 @@ declare class Session {
     get planTasks(): Task[];
     private attachObserver;
     private buildObserver;
+    private broadcastStatus;
     private translateProgress;
     /** Persists PlanStore state to disk. PlanStore is the single authority;
      * LegacyPlanState.tasks is populated only here, at persist time. */
@@ -2541,8 +2950,8 @@ declare class Session {
      * A new plan starts from zero: drop the live planner conversation and every
      * task, log, and queued message left over from a previous plan on this
      * Session. Without this, a long-lived Session (VS Code hosts exactly one)
-     * leaks the previous session's tasks into `planContextBlock()` — the model
-     * is told they are the CURRENT plan and re-presents them as its draft.
+     * leaks the previous session's tasks into the per-turn plan block — the
+     * model is told they are the CURRENT plan and re-presents them as its draft.
      */
     private beginFreshPlan;
     /**
@@ -2611,8 +3020,8 @@ declare class Session {
     generatePlan(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
      * Kick off the planner conversation (ADR-0002): research + the first planner
-     * message. The AI service retains the tool-use history; the Session persists
-     * the user/assistant dialogue on the plan state.
+     * message. The conversation itself — transcript, live model context, turn
+     * settlement — is {@link PlannerConversation}'s; the Session hosts it.
      */
     startPlanning(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
@@ -2621,69 +3030,31 @@ declare class Session {
      */
     continueConversation(userMessage: string, options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
-     * Answer every read the planner emits until it says something else.
-     *
-     * The channel is a text envelope rather than a registered tool because the
-     * protocol has to be identical on both planner backends (ADR-0009): Ordewell
-     * owns a tool loop only in the API case, and a harness planner running as a
-     * coding-agent subprocess can only be reached this way.
-     *
-     * Draining here — outside {@link repairLoop} — is what keeps reads free of
-     * the repair budget. A planner that looks a task up and *then* fumbles its
-     * ops JSON still gets its two corrective retries; charging it for the read
-     * would cost it the chance to fix the edit.
-     */
-    private drainTaskQueries;
-    /**
-     * Render one read out of live state. Never persisted to the transcript: the
-     * detail is context for the planner's next reply, and re-sending it on every
-     * later turn is exactly the cost this channel exists to avoid.
-     */
-    private taskQueryAnswer;
-    /**
-     * Drive a planner turn to a persisted, broadcast outcome. Task edits apply
-     * atomically; validation failures are fed back to the model for up to 2
-     * silent retries, then surfaced as a message with the plan untouched. The
-     * first turn (startPlanning) and every later turn route through here — one
-     * path, not two.
+     * Copy this conversation and its task list into a new persisted session and
+     * answer its id. This session is untouched — not even its live planner
+     * context, so the original carries on exactly where it was. The fork holds
+     * no run (see {@link forkPlanState}); a host adopts it like any saved
+     * session, and its first message replays the copied transcript.
      */
-    private settleTurn;
+    forkConversation(): ConversationFork;
     /**
-     * The catalog the planner may actually draw from — model ids and task-mode
-     * ids, per selected runner — emitted on EVERY turn, before any plan exists
-     * or after. The system prompt shows this once at conversation start; a long
-     * clarifying conversation outlives that single showing and the planner
-     * starts misquoting it, so this re-states it per turn instead.
-     *
-     * Built from the allowlist-filtered view (`filterModelsForPrompt`), the same
-     * one the system prompt used — a restricted allowlist stays a hard bound on
-     * every turn, not just the first. {@link models} itself is never
-     * filtered: `coerceAssignments` needs the full discovered catalog alongside
-     * the allowlist to resolve labels and clamp effort to real variants.
-     *
-     * Reads `this.plan.runners` live, so a runner admitted mid-session by a
-     * retarget (`admitRunner`) is filtered and shown like every other — there is
-     * no separate "originally selected" list to fall stale.
+     * Fork the conversation from just before a user message (a transcript
+     * position from {@link rewindTargets}): the fork holds everything said
+     * before it and the current task list, like {@link forkConversation}, and
+     * this session keeps its whole history. The message's full text comes back
+     * so a surface can offer it for resending.
      */
-    private catalogBlock;
+    rewindConversation(userMessageIndex: number): ConversationRewind;
+    private saveFork;
     /**
-     * The "you are here" block for post-plan chat: current tasks with stable
-     * references, plus the task-ops protocol. Injected per turn (never
-     * persisted) so the model always sees live statuses — including which tasks
-     * are locked by a running execution.
+     * Condense the conversation on the user's say-so: a hidden planner turn
+     * summarises it, and the summary replaces everything but the last two
+     * exchanges. Conversation only — the tasks, and any run
+     * executing them, are untouched. Atomic: a failed or stopped turn changes
+     * nothing.
      */
-    private planContextBlock;
-    /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
-    private applyTaskOpsTurn;
-    /**
-     * Resume a persisted dialogue onto a fresh AI-service conversation — either
-     * because the in-memory one is gone (session reload, extension restart), or
-     * because {@link continueConversation} found it stale against the planner
-     * config now in effect (a harness planner's model/effort switched mid-chat).
-     * The saved transcript seeds the new conversation; no LLM call happens
-     * before the user's message is sent.
-     */
-    private resumeConversation;
+    compactConversation(signal?: AbortSignal): Promise<ConversationCompaction>;
+    rewindTargets(): RewindTarget[];
     /** Whether the planner conversation is live (started and not yet committed to a plan). */
     get isConversationActive(): boolean;
     /**
@@ -2695,10 +3066,22 @@ declare class Session {
      * bare /unknown through to be mis-resolved.
      */
     private resolveSkillInvocation;
-    /** Append one dialogue entry to the persisted transcript. Callers persist via the mutatePlan ritual. */
-    private appendTranscript;
-    /** Commit a settled (non-task_ops) turn. Both branches run the mutatePlan ritual. */
-    private applyConversationTurn;
+    /**
+     * The one place planning discovers what it may draw from: the runners'
+     * models (cached for later effort clamping), their modes, and the settings
+     * in force. `filteredModels` is the allowlisted view a prompt may show;
+     * `modelsByRunner` stays whole because coercion needs real labels and variants.
+     */
+    private plannerCatalog;
+    private conversationOpening;
+    /**
+     * Load planner-produced tasks, coerced to the allowlist read live — it may
+     * have changed since planning started. An edit on an armed scheduler is
+     * reconciled rather than reloaded: `loadPlan` clears the on-hold set and the
+     * review approval, so a task the user cancelled would be re-armed and
+     * re-spawned by the re-tick that follows.
+     */
+    private adoptPlannerTasks;
     /**
      * PRD mode: when the planner writes the full markdown PRD, save it to
      * .scratch/<slug>/PRD.md (Matt Pocock to-prd convention) and keep it on the plan.
@@ -2724,6 +3107,43 @@ declare class Session {
     get queuedCount(): number;
     getTask(taskId: string): Task | undefined;
     get isReviewApproved(): boolean;
+    /** Replay a run a dirty tree blocked, after stashing the tracked changes. */
+    continueWithStash(): Promise<void>;
+    /** Replay a run a dirty tree blocked, in the workspace root, for this run only. */
+    continueWithoutIsolation(): Promise<void>;
+    /**
+     * Each task's isolation mark and the run's handoff, read from the run record.
+     * The stream reports changes only; a surface that (re)connects or loads a
+     * session asks here instead.
+     */
+    isolationView(): IsolationView | null;
+    /** The run's integration branch against its base ref, as a unified diff. */
+    reviewRunDiff(): Promise<string>;
+    /**
+     * "Merge all": each repo's integration branch into whatever the user has
+     * checked out there — every repo, or none if any cannot take it. The one
+     * irreversible step of isolated execution, so this explicit call is the
+     * only way it ever happens.
+     */
+    mergeRun(): Promise<IsolationMergeResult>;
+    /** Remove the run's worktrees and task branches; keep its integration branch to review or merge. */
+    cleanupRun(): Promise<void>;
+    /**
+     * Give the whole run up, integration branch included. The plan is not
+     * rewritten: a task that landed there stays completed until the user says
+     * otherwise (Mark not done), because only they know whether they kept the work.
+     */
+    discardRun(): Promise<void>;
+    private requireSettledRun;
+    /**
+     * The opt-in way through a merge conflict: add an AI task, on the conflicted
+     * task's own runner and model, that merges its branch by hand in a worktree
+     * of its own. When that task lands, the conflicted one lands through it (see
+     * {@link TaskOrchestrator.linkConflictResolver}). The automatic answer to a
+     * conflict is a repair, a new attempt of the same task (ADR-0015); a task is
+     * only ever added to the plan by this call.
+     */
+    resolveConflictAsTask(taskId: string): Promise<LegacyPlanState | null>;
     stopExecution(): void;
     /**
      * The one mutation seam: every structural plan mutation runs the same
@@ -2740,7 +3160,7 @@ declare class Session {
      * queues — so a task the edit just unblocked would sit ready and never
      * start. `tick()` no-ops while the scheduler is idle, so this costs nothing
      * during plain planning. The planner-driven path re-ticks in
-     * {@link settleTurn} instead; it must not tick twice.
+     * {@link PlannerConversation} instead (`afterEdit`); it must not tick twice.
      */
     private editPlan;
     /**
@@ -2860,25 +3280,31 @@ declare function globalDataDir(): string;
  */
 declare function migrateOldConfigDir(): void;
 
-type VerdictListener = (taskId: string, verdict: Verdict, output: string) => void;
+type VerdictListener = (taskId: string, verdict: Verdict) => void;
 type CheckpointListener = (taskId: string, summary: string) => void;
 /** Fires on every idleSince transition (null→timestamp on silence, timestamp→null on resume/teardown). */
 type IdleListener = (taskId: string, idleSince: string | null) => void;
 declare class VerdictEngine {
     private markerSeen;
-    private buffers;
-    private checkpointCounts;
+    private markerTails;
+    private checkpointCarry;
     private pausedSessions;
     private listeners;
     private checkpointListeners;
     private idleListeners;
     /**
-     * Per-task generation counter. Incremented on every watch() and clear().
+     * Per-task generation. Replaced on every watch(), clear() and verdict.
      * Stale callbacks (from a prior session whose generation doesn't match
      * the current one) bail out instead of delivering a verdict for the
      * wrong session.
      */
     private generations;
+    /**
+     * Generations come from one counter that {@link reset} never rewinds: a
+     * per-task count restarted at 1 after a reset, and the next watch handed a
+     * session that outlived the reset the same generation as its successor.
+     */
+    private lastGeneration;
     private idleTimers;
     private idleSince;
     onVerdict(listener: VerdictListener): void;
@@ -2901,12 +3327,16 @@ declare class VerdictEngine {
     approveCheckpoint(taskId: string): void;
     rejectCheckpoint(taskId: string, reason: string): void;
     /**
-     * Attach to a spawned session: buffer output, scan for the task's completion
+     * Attach to a spawned session: scan the output tail for the task's completion
      * marker (delivering a verdict immediately while leaving interactive sessions
      * open), scan for checkpoint markers, and on exit produce a failed verdict
      * when the marker was never observed.
      */
     watch(task: Task, session: ITerminalSession): void;
+    /** Scan only the new text plus the unmatched carry, so a long run stays linear. */
+    private scanCheckpoints;
+    private bumpGeneration;
+    private forget;
     /** Manual "Mark complete" override: a pass verdict that bypasses evidence. */
     markComplete(task: Task): Verdict;
     /** Clear verification state for a task (used on retry). */
@@ -2916,6 +3346,49 @@ declare class VerdictEngine {
     private decide;
 }
 
+/**
+ * Owns one bounded raw buffer per task attempt, fed from the attempt's
+ * session, and reads final answers from the agent's transcript through an
+ * injected {@link TranscriptReader}.
+ */
+declare class BufferedTaskOutputSource implements TaskOutputSource {
+    private captures;
+    private transcripts;
+    private maxBufferChars;
+    constructor(opts?: {
+        transcripts?: TranscriptReader;
+        maxBufferChars?: number;
+    });
+    attach(taskId: string, session: ITerminalSession): void;
+    detach(taskId: string): void;
+    reset(): void;
+    finalText(attempt: TaskOutputAttempt, doneToken: string): Promise<string>;
+    liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
+    private append;
+}
+
+/**
+ * Read a task's final answer from the agent's own session transcript — the
+ * clean, structured record the agent writes about itself — instead of
+ * reconstructing what a TUI painted (issue #16, built on #14's render).
+ *
+ * These stores are private and undocumented and DO rotate (OpenCode migrated
+ * from files to SQLite mid-2026). Every reader is therefore defensive: any
+ * missing file, unparseable line, or shape drift returns null and the caller
+ * falls back to the terminal capture. Nothing here is a hard dependency.
+ *
+ * Directory and recency only narrow the candidates: with several attempts in
+ * one cwd the newest session is whichever task finished last. A transcript is
+ * accepted only when its content carries the task's completion marker.
+ */
+declare class HomeTranscriptReader implements TranscriptReader {
+    private readonly home;
+    constructor(opts?: {
+        homeDir?: string;
+    });
+    finalAssistantText(query: TranscriptQuery, maxChars?: number): Promise<string | null>;
+}
+
 /**
  * The ids a runner may actually run: the user's allowlist with the ids that
  * provably belong to a *different* runner dropped. `undefined` means no
@@ -2999,9 +3472,18 @@ declare function buildResearchToolsPrompt(): string;
  * never a task plan.
  */
 declare function buildSubagentSystemPrompt(): string;
-declare function buildConversationSystemPrompt(goal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean, verificationEnabled?: boolean, 
-/** Harness planner (ADR-0009): the agent owns its own tools and research budget. */
-harnessMode?: boolean): string;
+/**
+ * Facts about who plans and where tasks will run, as opposed to the user's
+ * mode toggles: they change what the prompt can promise, not what it asks for.
+ */
+interface ConversationVariant {
+    /** Harness planner (ADR-0009): the agent owns its own tools and research budget. */
+    harness?: boolean;
+    /** Every AI task gets its own worktree (ADR-0013), so file overlap no longer forces an order; of every repo of a group (ADR-0014). */
+    isolatedExecution?: IsolatedExecution;
+}
+declare function buildConversationSystemPrompt(goal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean, verificationEnabled?: boolean, variant?: ConversationVariant): string;
+/** The one-shot planner's core rules for tasks that share the workspace root. */
 declare const CORE_PLANNER_PROMPT: string;
 declare function buildResearchPrompt(userGoal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes): string;
 declare function buildPlanWithResults(userGoal: string, context: string, researchResults: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes): string;
@@ -3009,7 +3491,7 @@ declare function buildModifyPlanPrompt(existingPlan: LegacyPlanState, userReques
 declare function modelContextBlock(modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): string;
 declare function executionLogBlock(executionLog: TaskSnapshot[]): string;
 declare function pendingEditRulesBlock(): string;
-declare function buildModifyDuringExecutionPrompt(executionLog: TaskSnapshot[], pendingTasks: string, userMessage: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): string;
+declare function buildModifyDuringExecutionPrompt(executionLog: TaskSnapshot[], pendingTasks: string, userMessage: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: Pick<PlannerModes, 'autonomousDefault' | 'isolatedExecution'>): string;
 /**
  * User-message prompt for a planner-driven merge: asks the model to combine the
  * selected tasks into one. Routed through the conversation loop, so the
@@ -3023,6 +3505,34 @@ declare function buildMergePrompt(taskIds: string[], tasks: Task[]): string;
  * the user does not hand-type the parts.
  */
 declare function buildSplitPrompt(taskId: string, tasks: Task[]): string;
+/**
+ * Runner prompt for the opt-in task that resolves an integration conflict
+ * (ADR-0013). The resolver's own worktree starts at the integration tip, so the
+ * merge it performs is exactly the one that conflicted; the conflicted task
+ * then lands through that merge. Ordewell never resolves a conflict itself.
+ *
+ * In a repo group (ADR-0014) the conflict in one repo rolled the task back in
+ * all of them, so the resolver merges the branch in every repo the task
+ * changed, not only the one that conflicted.
+ */
+declare function buildConflictResolutionPrompt(task: Task, conflict: {
+    branch: string;
+    repos: string[];
+    conflictRepo?: string;
+}, integrationBranch: string): string;
+/**
+ * Runner prompt for a conflict repair (ADR-0015): a new attempt of the
+ * conflicted task itself, in its kept worktree, so the merge runs the other
+ * way round from {@link buildConflictResolutionPrompt} — the integration tip
+ * into the task's branch. Whether it worked is decided by the evidence checks
+ * and the landing that follow, never by the agent's word.
+ */
+declare function buildConflictRepairPrompt(task: Task, conflict: {
+    branch: string;
+    repos: string[];
+    conflictRepo?: string;
+    conflictFiles?: string[];
+}, integrationBranch: string): string;
 
 /**
  * The one owner of "the model emitted something unusable — correct it and
@@ -3677,4 +4187,4 @@ declare class PlannerModelMemory {
     recall(provider: string, catalog: PlannerModelCandidate[]): PlannerModelRecall;
 }
 
-export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalMode, ApprovalRequest, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationMessage, type ConversationRequest, type ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, type PtySize, type PtyWrapOptions, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, ResolveContext, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionMeta, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, TaskOp, TaskOrchestrator, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, createSkillsService, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };
+export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalMode, ApprovalRequest, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationBusyError, type ConversationCompaction, ConversationEditError, type ConversationFork, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, IsolationHandoff, IsolationLandedTask, IsolationMergeResult, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PLUGIN_NAME_PATTERN, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PluginSource, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, type PtySize, type PtyWrapOptions, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, ResolveContext, type RewindTarget, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionMeta, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, TASK_QUERY_ANSWER_MAX_CHARS, TASK_QUERY_ANSWER_OR_OPS, TASK_QUERY_FIELDS, TASK_QUERY_PROTOCOL, TASK_QUERY_REMINDER, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, type TaskAttemptSnapshot, TaskIsolation, TaskOp, TaskOrchestrator, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, createSkillsService, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };