@ordewell/core 0.7.2 → 0.8.1

package/dist/index.d.ts

@@ -1,16 +1,18 @@
-import { b0 as RunnerId, ay as PlanStatus, ac as LegacyPlanState, M as IApproval, p as ApprovalRequest, k as ApprovalDecision, j as ApprovalAnswer, P as ITerminalRunner, N as IConfig, h as AiProvider, aN as ProviderModelLists, m as ApprovalMode, $ as IsolationMergeResult, X as IsolationLandedTask, R as IWorktreeIsolation, a8 as IsolationTaskStatus, av as PlanIsolation, b5 as RunnerTransport, aV as RepoGroupLayout, Q as ITerminalSession, z as DiscoveredModel, bi as Task, f as AgentProcessDeps, c as AgentAdapter, as as OrdewellMcpServer, aX as ResearchProgress, aW as ResearchLogEntry, w as ConversationMessage, aB as PlannerToolHandler, bF as UsageRecord, bu as TaskSnapshot, r as AwaitingReason, U as IsolationHandoff, a4 as IsolationRun, a5 as IsolationTaskRecord, bk as TaskIsolation, a9 as IsolationView, a0 as IsolationOutcome, aU as RepairEvidence, bD as TreeSnapshot, bM as Verdict, b3 as RunnerRegistry, aS as QueuedTaskMessage, aR as QueuedMessage, b as ActiveTaskSession, ar as OrchestratorOption, bn as TaskModeAgentAdapter, g as AgentStartOptions, e as AgentEvent, a_ as ResearchToolType, aC as PlannerUsage, n as ApprovalPolicy, ax as PlanState, bj as TaskCompleteArgs, t as CheckpointAnswer, b1 as RunnerInvocation, A as AbstractRunner, a as AbstractTerminalSession, b6 as RunnerVersionProbe, bb as StructuredSessionCapability, bv as TaskStartOptions, bx as TaskTokenScope, bc as StructuredTurnEnd, ba as StructuredEvent, b4 as RunnerSpawnOptions, O as IPluginStore, b2 as RunnerPluginManifest, a$ as ResolveContext, bt as TaskRunnerFlags } from './Task-BpzIbunq.js';
-export { d as AgentAdapterFactory, i as AllProviderModels, l as ApprovalKind, o as ApprovalPolicyOptions, q as ApprovalSource, B as BlockingPrompt, C as CMD_EXE_MAX_COMMAND_LINE, s as CatalogModel, u as CheckpointArgs, v as CommandLineTooLongError, D as DEFAULT_RUNNERS, x as DENY_ALL, y as DiscoveredMode, E as DiscoveryCommand, F as EditPlanArgs, G as EmbeddedNewlineError, H as ExecutableNotFoundError, I as FetchAllProviderModelsOptions, J as HeadlessRunner, K as HeadlessRunnerDeps, L as HeadlessSession, S as IntegrationDisposal, T as IsolationAvailability, V as IsolationHandoffRepo, W as IsolationInactiveReason, Y as IsolationLanding, Z as IsolationMergeBlock, _ as IsolationMergeBlockReason, a1 as IsolationPruneResult, a2 as IsolationRemoval, a3 as IsolationRepo, a6 as IsolationTaskRef, a7 as IsolationTaskRepo, aa as LaunchDeps, ab as LaunchPlan, ad as LineBuffer, ae as ListModelsArgs, af as ListRunnersArgs, ag as McpClientConfig, ah as McpCredential, ai as McpTool, aj as McpToolContext, ak as McpToolReply, al as Message, am as ModelCatalog, an as ModelShortcut, ao as ORCHESTRATOR_SHORTCUTS, ap as ORDEWELL_MCP_PATH, aq as ORDEWELL_MCP_SERVER_NAME, at as OwnerOnlyFile, au as PLANNER_TOOLS, aw as PlanModificationWarnings, az as PlannerStartOptions, aA as PlannerTokenScope, aD as PluginCloneFn, aE as PluginEntry, aF as PluginFeatures, aG as PluginMode, aH as PluginModelDiscovery, aI as PluginRunnerDef, aJ as PreparedLaunch, aK as PreparedTask, aL as PreservedWork, aM as ProviderCredentialSource, aO as ProviderModelsResult, aP as PtySize, aQ as PtyWrapOptions, aT as RefusedRemoval, aY as ResearchStep, aZ as ResearchStepOutcome, b7 as StreamEvent, b8 as StreamStepEvent, b9 as StreamThinkingEvent, bd as SubagentLogEntry, be as SubagentOutcome, bf as SubmitPlanArgs, bg as TASK_COMPLETE_TOOL, bh as TASK_TOOLS, bl as TaskIsolationState, bm as TaskMode, bo as TaskModeUnsupportedError, bp as TaskModelAssignment, bq as TaskOutputArgs, br as TaskOutputSummary, bs as TaskQueryArgs, bw as TaskStatus, by as TaskToolHandler, bz as TaskTransport, bA as TaskType, bB as TaskWithParent, bC as ThinkingBlock, bE as UsageLine, bG as UsageTotals, bH as UserPromptEntry, bI as UserStep, bJ as ValidationCheck, bK as ValidationContext, bL as ValidationResult, bN as VerificationCheck, bO as WINDOWS_MAX_COMMAND_LINE, bP as addPlannerUsage, bQ as addTaskToPlan, bR as addUsage, bS as approvalScopes, bT as buildShellInvocation, bU as collectProviderCredentials, bV as createEmptyPlan, bW as createTask, bX as emptyWarnings, bY as enabledRunners, bZ as fetchAllProviderModels, b_ as flattenTasks, b$ as flattenTasksWithParents, c0 as inheritedOps, c1 as isAwaitingReason, c2 as isExecutableResolved, c3 as isGranted, c4 as isMeasured, c5 as isReservedRunnerName, c6 as isRunnerApproval, c7 as isRunnerTransport, c8 as isStructuredSession, c9 as keepExecutionState, ca as knownModelId, cb as mcpClientConfig, cc as migrateLegacyPlan, cd as migratePlanState, ce as migrateTask, cf as opsFlag, cg as ownerOnlyConfigFile, ch as partedPromptUsage, ci as planDirectLaunch, cj as planShellLaunch, ck as plannerContextFill, cl as posixShellQuote, cm as removeTaskFromPlan, cn as renumberTasks, co as resolveModelShortcut, cp as resolveProvider, cq as sharedMcpServer, cr as stripAnsi, cs as toApprovalDecision, ct as toOrchestratorOptions, cu as updateTaskInPlan, cv as usageLine, cw as validateModifiedPlan, cx as warningsText, cy as windowsCommandLine, cz as wrapWithPty } from './Task-BpzIbunq.js';
-import { B as TaskOp, M as MergeGateView, j as EditCatalog, s as SessionBroadcaster, A as ApplyTaskOpsResult, t as SessionMessage, u as SessionNotice, y as TaskLogEvent } from './plan-utils-D4Z8UyLL.js';
-export { a as ApprovalBlock, b as ApprovalStatus, C as CHECKPOINT_TRUNCATE_LENGTH, c as ConversationInput, d as ConversationView, D as DiffRow, e as DiffRowKind, f as DiffStat, g as DisplayBlock, E as EMPTY_CONVERSATION, h as EMPTY_HOLD, i as EMPTY_TASK_LOG, G as GatedConversation, L as LocalEntry, k as MessageBlock, l as MessageRole, N as NOT_STARTED, m as NO_TURN, n as NewTaskFields, O as OutputPreview, P as PlanBlock, o as PlanMarkerStatus, p as PromptHold, S as SerializedPlan, q as SerializedTask, r as SerializedTaskStatus, v as SubagentBlock, w as SubagentChild, x as SubagentStatus, T as TakenPrompt, z as TaskLogView, F as TaskRef, H as TaskRowAction, I as TaskRowContext, J as TaskRowIsolation, K as TaskRowKind, Q as TaskRowPlacement, R as TaskRowSubject, U as TaskRowView, V as TaskStatusKind, W as ThinkingDisplayBlock, X as ToolBlock, Y as ToolHeadline, Z as ToolStatus, _ as TurnGate, $ as UsageBlock, a0 as aheadOfDraft, a1 as applyTaskOps, a2 as approvalLabel, a3 as awaitingLabel, a4 as canMergeTasks, a5 as canSetDependencies, a6 as canSplitTask, a7 as capConflictFiles, a8 as classifyOutcome, a9 as coalesceTaskLog, aa as dependencyCandidates, ab as dependentsNotice, ac as dependentsOf, ad as diffRows, ae as diffStat, af as diffSummary, ag as digestTaskLog, ah as drainNext, ai as executionSummary, aj as followTurn, ak as fromTranscript, al as hasHiddenDetail, am as holdPrompt, an as isTaskRunning, ao as markAction, ap as markRequestFor, aq as namedRepos, ar as newTaskFields, as as opsEditable, at as outputLines, au as outputPreview, av as parseTaskOpsJson, aw as pastGateConfirmation, ax as reduceConversation, ay as reduceTaskLog, az as replayTaskLog, aA as runnerToolSubject, aB as serializePlan, aC as serializeTask, aD as serializeTaskStatus, aE as stopTurn, aF as summarizeToolCall, aG as taskRowActions, aH as taskRowView, aI as taskStartedNotice, aJ as taskStatusKind, aK as textHasTaskOps, aL as titledRefs, aM as toTaskLogEvent, aN as toolHeadline, aO as trimToolOutput, aP as truncateCheckpointSummary, aQ as unsendAll, aR as unsendLatest } from './plan-utils-D4Z8UyLL.js';
-import { I as IFileSystem, R as ReadFileOpts, T as ToolOutcome, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-CbCmUDBn.js';
-export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-CbCmUDBn.js';
-import { R as RunnerModeInfo } from './ModeResolver-DtfhWeVL.js';
-export { M as ManifestLookup, a as autonomyLevelLabel, b as buildModeGuide, f as filteredBuildModes, p as parseAutonomyLevel, r as resolveDefaultMode, c as resolveTaskMode, d as runnerModesFrom } from './ModeResolver-DtfhWeVL.js';
+import { W as RunnerId, E as PlanStatus, L as LegacyPlanState, n as IsolationMergeResult, j as IsolationLandedTask, I as IWorktreeIsolation, w as IsolationTaskStatus, P as PlanIsolation, a3 as SkillsService, _ as SkillInfo, N as RepoGroupLayout, c as DiscoveredModel, a9 as Task, S as ResearchProgress, O as ResearchLogEntry, C as ConversationMessage, ao as UsageRecord, ah as TaskSnapshot, a as AwaitingReason, g as IsolationHandoff, s as IsolationRun, t as IsolationTaskRecord, aa as TaskIsolation, x as IsolationView, o as IsolationOutcome, K as RepairEvidence, am as TreeSnapshot, av as Verdict, ag as TaskSkillSnapshot, $ as SkillLoad, Q as QueuedMessage, A as ActiveTaskSession, V as ResearchToolType, G as PlannerUsage, z as PlanState } from './Task-1Q19y7sZ.js';
+export { B as BUILTIN_SKILL_NAMES, D as DEFAULT_RUNNERS, b as DiscoveredMode, d as IntegrationDisposal, e as InvalidSkill, f as IsolationAvailability, h as IsolationHandoffRepo, i as IsolationInactiveReason, k as IsolationLanding, l as IsolationMergeBlock, m as IsolationMergeBlockReason, p as IsolationPruneResult, q as IsolationRemoval, r as IsolationRepo, u as IsolationTaskRef, v as IsolationTaskRepo, M as Message, y as PlanModificationWarnings, F as PlannerTaskView, H as PreparedTask, J as PreservedWork, R as RefusedRemoval, T as ResearchStep, U as ResearchStepOutcome, X as ShadowedSkill, Y as SkillAppliesTo, Z as SkillCatalog, a0 as SkillLoadNotice, a1 as SkillMetadata, a2 as SkillSource, a4 as StreamEvent, a5 as StreamStepEvent, a6 as StreamThinkingEvent, a7 as SubagentLogEntry, a8 as SubagentOutcome, ab as TaskIsolationState, ac as TaskMode, ad as TaskModelAssignment, ae as TaskOutputSummary, af as TaskSkillNotice, ai as TaskStatus, aj as TaskType, ak as TaskWithParent, al as ThinkingBlock, an as UsageLine, ap as UsageTotals, aq as UserPromptEntry, ar as UserStep, as as ValidationCheck, at as ValidationContext, au as ValidationResult, aw as VerificationCheck, ax as addPlannerUsage, ay as addTaskToPlan, az as addUsage, aA as createEmptyPlan, aB as createSkillsService, aC as createTask, aD as emptyWarnings, aE as flattenTasks, aF as flattenTasksWithParents, aG as inheritedOps, aH as inheritedSkills, aI as isAwaitingReason, aJ as isMeasured, aK as isSkillName, aL as isUserMessage, aM as keepExecutionState, aN as migrateLegacyPlan, aO as migrateLoadedTasks, aP as migratePlanState, aQ as migrateTask, aR as opsFlag, aS as partedPromptUsage, aT as plannerContextFill, aU as plannerTaskView, aV as removeTaskFromPlan, aW as renumberTasks, aX as skillNames, aY as updateTaskInPlan, aZ as usageLine, a_ as validateModifiedPlan, a$ as warningsText } from './Task-1Q19y7sZ.js';
+import { R as TaskOp, M as MergeGateView, j as EditCatalog, u as SessionBroadcaster, A as ApplyTaskOpsResult, w as SessionNotice, v as SessionMessage, K as TaskLogEvent, H as SurfacePlan, I as SurfacePlanState } from './plan-utils-Cv48fe7r.js';
+export { a as ApprovalBlock, b as ApprovalStatus, C as CHECKPOINT_TRUNCATE_LENGTH, c as ConversationInput, d as ConversationView, D as DiffRow, e as DiffRowKind, f as DiffStat, g as DisplayBlock, E as EMPTY_CONVERSATION, h as EMPTY_HOLD, i as EMPTY_TASK_LOG, G as GatedConversation, L as LocalEntry, k as MessageBlock, l as MessageRole, N as NOT_STARTED, m as NO_TURN, n as NewTaskFields, O as OutputPreview, P as PlanBlock, o as PlanMarkerStatus, p as PromptHold, S as SerializedConversationMessage, q as SerializedPlan, r as SerializedQueuedMessage, s as SerializedTask, t as SerializedTaskStatus, x as SkillLoadBlock, y as SkillToken, z as SubagentBlock, B as SubagentChild, F as SubagentStatus, J as SurfaceTask, T as TakenPrompt, Q as TaskLogView, U as TaskRef, V as TaskRowAction, W as TaskRowContext, X as TaskRowIsolation, Y as TaskRowKind, Z as TaskRowPlacement, _ as TaskRowSubject, $ as TaskRowView, a0 as TaskStatusKind, a1 as ThinkingDisplayBlock, a2 as ToolBlock, a3 as ToolHeadline, a4 as ToolStatus, a5 as TurnGate, a6 as UsageBlock, a7 as aheadOfDraft, a8 as applyTaskOps, a9 as approvalLabel, aa as awaitingLabel, ab as canMergeTasks, ac as canSetDependencies, ad as canSplitTask, ae as capConflictFiles, af as classifyOutcome, ag as coalesceTaskLog, ah as dependencyCandidates, ai as dependentsNotice, aj as dependentsOf, ak as diffRows, al as diffStat, am as diffSummary, an as digestTaskLog, ao as drainNext, ap as executionSummary, aq as followTurn, ar as fromTranscript, as as hasHiddenDetail, at as holdPrompt, au as isTaskRunning, av as loadedSkillTokens, aw as markAction, ax as markRequestFor, ay as namedRepos, az as newTaskFields, aA as opsEditable, aB as outputLines, aC as outputPreview, aD as parseTaskOpsJson, aE as pastGateConfirmation, aF as reduceConversation, aG as reduceTaskLog, aH as replayTaskLog, aI as runnerToolSubject, aJ as serializePlan, aK as serializeTask, aL as serializeTaskStatus, aM as skillTokens, aN as stopTurn, aO as summarizeToolCall, aP as surfacePlan, aQ as surfacePlanState, aR as taskLogForSurface, aS as taskRowActions, aT as taskRowView, aU as taskStartedNotice, aV as taskStatusKind, aW as textHasTaskOps, aX as titledRefs, aY as toTaskLogEvent, aZ as toolHeadline, a_ as trimToolOutput, a$ as truncateCheckpointSummary, b0 as unsendAll, b1 as unsendLatest } from './plan-utils-Cv48fe7r.js';
+import { I as IFileSystem, R as ReadFileOpts, T as ToolOutcome, b as GrepOptions, a as GlobOptions, F as FindSymbolOptions } from './IFileSystem-D96mT-bm.js';
+export { G as GREP_DEFAULT_HEAD_LIMIT, c as GrepOutputMode, S as SEARCH_EXCLUSIONS } from './IFileSystem-D96mT-bm.js';
+import { I as IApproval, m as ApprovalRequest, h as ApprovalDecision, g as ApprovalAnswer, s as IRunner, r as IConfig, e as AiProvider, W as ProviderModelLists, j as ApprovalMode, t as IRunnerSession, c as AgentProcessDeps, A as AgentAdapter, P as OrdewellMcpServer, U as PlannerToolHandler, a2 as RunnerRegistry, Y as QueuedTaskMessage, N as OrchestratorOption, aa as TaskModeAgentAdapter, d as AgentStartOptions, b as AgentEvent, k as ApprovalPolicy, a9 as TaskCompleteArgs, o as CheckpointAnswer, a5 as StructuredTurnEnd, a4 as StructuredEvent, af as TaskStartOptions, ag as TaskTokenScope, $ as RunnerManifest, ae as TaskRunnerFlags } from './IRunner-CGCihlGQ.js';
+export { a as AgentAdapterFactory, f as AllProviderModels, i as ApprovalKind, l as ApprovalPolicyOptions, n as ApprovalSource, C as CatalogModel, p as CheckpointArgs, D as DENY_ALL, q as DiscoveryCommand, E as EditPlanArgs, F as FetchAllProviderModelsOptions, L as LineBuffer, u as ListModelsArgs, v as ListRunnersArgs, w as LoadSkillArgs, M as McpClientConfig, x as McpCredential, y as McpTool, z as McpToolContext, B as McpToolReply, G as ModelCatalog, H as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, J as ORDEWELL_MCP_PATH, K as ORDEWELL_MCP_SERVER_NAME, Q as OwnerOnlyFile, R as PLANNER_TOOLS, S as PlannerStartOptions, T as PlannerTokenScope, V as ProviderCredentialSource, X as ProviderModelsResult, Z as RunnerEntry, _ as RunnerFeatures, a0 as RunnerMode, a1 as RunnerModelDiscovery, a3 as SpawnFn, a6 as SubmitPlanArgs, a7 as TASK_COMPLETE_TOOL, a8 as TASK_TOOLS, ab as TaskModeUnsupportedError, ac as TaskOutputArgs, ad as TaskQueryArgs, ah as TaskToolHandler, ai as approvalScopes, aj as collectProviderCredentials, ak as enabledRunners, al as fetchAllProviderModels, am as isGranted, an as isRunnerApproval, ao as knownModelId, ap as mcpClientConfig, aq as ownerOnlyConfigFile, ar as resolveModelShortcut, as as resolveProvider, at as sharedMcpServer, au as toApprovalDecision, av as toOrchestratorOptions } from './IRunner-CGCihlGQ.js';
+import { R as RunnerModeInfo } from './ModeResolver-EWlpmVAy.js';
+export { M as ManifestLookup, a as autonomyLevelLabel, b as buildModeGuide, f as filteredBuildModes, p as parseAutonomyLevel, r as resolveDefaultMode, c as resolveTaskMode, d as runnerModesFrom } from './ModeResolver-EWlpmVAy.js';
 import { ChildProcess } from 'child_process';
-import { b as PlanParseError } from './parsing-COFGUEWx.js';
-export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, c as PlanTaskError, d as PlanTasksResult, T as TASK_OPS_ENVELOPE_KEY, e as TASK_QUERY_ENVELOPE_KEY, f as checkDepsResolve, g as checkImmutableLog, h as checkInProgress, i as checkNoCycles, j as checkUniqueIds, k as escapeControlCharsInStrings, l as extractJsonObject, m as extractObjectWithBalance, n as extractObjectsWithKey, o as looksLikePlanAttempt, p as opensWithJsonObject, q as parsePartialPlan, r as parsePlanJson, s as stripModelNoise, t as stripTrailingCommas, v as validatePlanModification, u as validatePlanTasks } from './parsing-COFGUEWx.js';
+import { b as PlanParseError } from './parsing-CZdp2p_n.js';
+export { P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, c as PlanTaskError, d as PlanTasksResult, T as TASK_OPS_ENVELOPE_KEY, e as TASK_QUERY_ENVELOPE_KEY, f as checkDepsResolve, g as checkImmutableLog, h as checkInProgress, i as checkNoCycles, j as checkUniqueIds, k as escapeControlCharsInStrings, l as extractJsonObject, m as extractObjectWithBalance, n as extractObjectsWithKey, o as looksLikePlanAttempt, p as opensWithJsonObject, q as parsePartialPlan, r as parsePlanJson, s as requestedSkills, t as stripModelNoise, u as stripTrailingCommas, v as validatePlanModification, w as validatePlanTasks } from './parsing-CZdp2p_n.js';
+import { EventEmitter } from 'events';
 export { resolveOrderLabel, taskOrderLabel, taskRef, titledTaskRef } from './order-labels.js';
-import 'events';
 import 'zod/v4';
 
 interface SessionMeta {
@@ -410,7 +412,7 @@ declare class RunnerApprovals {
     /** The open request ids of each live structured session. */
     private readonly open;
     constructor(approvals: PendingApprovals);
-    wrap(runner: ITerminalRunner): ITerminalRunner;
+    wrap(runner: IRunner): IRunner;
     /** How many of a task's runner requests wait for an answer — what "waiting for approval" is derived from. */
     waiting(taskId: string): number;
     private watch;
@@ -700,86 +702,31 @@ declare class ConsoleLogger implements ILogger {
 }
 declare const defaultLogger: ILogger;
 
-interface UserSettings {
-    tdd: {
-        enabled: boolean;
-    };
-    verification: {
-        enabled: boolean;
-    };
-    modelAllowlist?: Record<string, string[]>;
-    /** Last model (and its thinking effort) the user chose for each planner backend, keyed by AiProvider id. */
-    plannerModels?: Record<string, {
-        model: string;
-        effort?: string;
-    }>;
-    /**
-     * Runners the user picked for planning. Absent — not empty — is what falls
-     * back to the environment's defaults; `[]` is a deliberate "none of them".
-     */
-    enabledRunners?: string[];
-    /**
-     * How tasks' runners are driven (ADR-0018). A run copies it onto its plan
-     * when it starts, so a change applies from the next run.
-     */
-    runnerTransport: RunnerTransport;
-}
 /**
- * Where the user's toggles live. `ORDEWELL_SETTINGS_PATH` overrides it so several
- * Ordewell processes on one machine can hold *different* settings at the same
- * time. Without it the file is a single shared mutable global: the benchmark
- * harness runs parallel lanes that each pin the mode toggles, and because
- * `getAll()` re-reads whenever the mtime moves, a lane needing a toggle
- * `true` would silently plan with `false` the moment another lane pinned its
- * own — turning an A/B of that toggle into a comparison of one condition
- * against itself.
+ * Task skills end to end (ADR-0024): a skill reaches a runner only by being
+ * attached to its task in the plan, and Ordewell puts its body in the task's
+ * prompt — so it works the same on every runner, and nothing is written to a
+ * harness's own skills directory.
  */
-declare function getSettingsPath(): string;
-declare class SettingsService {
-    private filePath;
-    private cache;
-    private cachedMtimeMs;
+/** Where a task's skill names are looked up: global first, then the workspace folders it reads. */
+interface SkillLookup extends Pick<SkillsService, 'findSkill' | 'searchedDirs'> {
     /**
-     * Whether the transport on disk (or just set) is the user's own choice.
-     * Writing the default back out would turn it into one, and a later change of
-     * default would then never reach this user.
+     * Set when tasks get worktrees: of `skills`, the workspace ones git will not
+     * carry into them, each SKILL.md path mapped to the folder to commit,
+     * relative to the workspace root.
      */
-    private transportChosen;
-    constructor(filePath?: string);
-    getAll(): UserSettings;
-    private fileMtimeMs;
-    getTdd(): boolean;
-    setTdd(enabled: boolean): void;
-    getVerification(): boolean;
-    setVerification(enabled: boolean): void;
-    getRunnerTransport(): RunnerTransport;
-    setRunnerTransport(transport: RunnerTransport): void;
-    getModelAllowlist(runner: string): string[] | undefined;
-    setModelAllowlist(runner: string, ids: string[] | undefined): void;
-    getPlannerModel(provider: string): {
-        model: string;
-        effort?: string;
-    } | undefined;
-    setPlannerModel(provider: string, entry: {
-        model: string;
-        effort?: string;
-    } | undefined): void;
-    getEnabledRunners(): string[] | undefined;
-    setEnabledRunners(ids: string[]): void;
-    private load;
-    private persist;
-}
-
-/** How the same toggle is named once a host has read it off disk. */
-interface PlannerRuntimeToggles {
-    tddEnabled: boolean;
-    verificationEnabled: boolean;
+    uncommitted?(skills: readonly SkillInfo[]): Promise<Map<string, string>>;
 }
 /**
- * The planner-facing mode set for one operation. Replaces the boolean tail that
- * every planner signature used to carry positionally — where a thirteenth
- * parameter was the only place left to put a new toggle.
+ * Where a workspace's skills are read, known without asking git: the repos
+ * of its group in layout order (`['.']` for one repository), and whether
+ * tasks will get worktrees, which only a committed skill reaches.
  */
+interface SkillLayout {
+    repos: readonly string[];
+    worktrees: boolean;
+}
+
 /**
  * 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,
@@ -788,47 +735,24 @@ interface PlannerRuntimeToggles {
 type IsolatedExecution = false | RepoGroupLayout;
 interface PlannerModes {
     autonomousDefault: boolean;
-    verification: boolean;
     /** Not a toggle: a fact about the run. */
     isolatedExecution: IsolatedExecution;
+    /**
+     * Where the run's tasks will look their skills up (ADR-0024), also a fact
+     * about the run. A plan attaching a planner skill is refused against it,
+     * and a coding agent's submit_plan call is refused in its turn rather than
+     * accepted and then failed. Absent: the plan is not checked.
+     */
+    taskSkills?: SkillLookup;
 }
 
-/** 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. */
+    /** Plain text, escapes and control characters removed. */
     text: string;
     /** Total output received so far; pass it back as `sinceOffset` to read only what follows. */
     nextOffset: number;
@@ -840,13 +764,13 @@ interface LiveTail {
  */
 interface TaskOutputSource {
     /** Start capturing a session; replaces any earlier capture of the task. */
-    attach(taskId: string, session: ITerminalSession): void;
+    attach(taskId: string, session: IRunnerSession): 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>;
+    /** The task's final answer: the summary its runner reported through `task_complete`, else what its last turn said. */
+    finalText(taskId: string): string;
     /** Recent output of the task's latest capture, or null if it never had one. */
     liveTail(taskId: string, opts: LiveTailOptions): LiveTail | null;
 }
@@ -866,7 +790,7 @@ interface TaskOutputSource {
  * 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", "output"];
+declare const TASK_QUERY_FIELDS: readonly ["description", "prompt", "userSteps", "verdict", "outputSummary", "userStoriesCovered", "skills", "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;
@@ -937,7 +861,7 @@ interface CliAgentAiServiceDeps extends Partial<AgentProcessDeps> {
     createAdapter?: (runner: string, deps: AgentProcessDeps) => AgentAdapter | null;
     /** Workspace root the agent explores. Defaults to the host process's cwd. */
     workspaceRoot?: () => string;
-    /** Where a conversation's planner tools are served (ADR-0022). Absent: every planner gets the envelopes. */
+    /** Where a conversation's planner tools are served (ADR-0022). Absent: no conversation can start. */
     mcpServer?: OrdewellMcpServer;
 }
 /**
@@ -947,8 +871,8 @@ interface CliAgentAiServiceDeps extends Partial<AgentProcessDeps> {
  * `GeminiService`. It deliberately does **not** extend {@link BaseAiService}:
  * that class's body is Ordewell executing research tools on a model's behalf,
  * which is precisely the part a coding agent replaces. What it reuses instead
- * is everything above the transport — `settleReply` (reply classification
- * and the bounded corrective retries), `parsePlanJson`, the `ResearchProgress` events the
+ * is everything above the transport — `settleReply` (the empty-reply nudge
+ * and the turn's settling), the plan validator, the `ResearchProgress` events the
  * four surfaces already render. That is why this backend reaches VS Code, the
  * web UI, the CLI and the TUI without any of them learning a coding agent is
  * on the other end.
@@ -970,8 +894,6 @@ declare class CliAgentAiService implements IAiService {
     private readonly mcpServer;
     /** The planner token the running process was spawned with; revoked with the process (ADR-0022, A3). */
     private plannerToken;
-    /** Whether the running planner was spawned with its tools and the CLI reported them connected. */
-    private toolsAttached;
     private activeAbort;
     /**
      * Every subagent this conversation has reported starting, and finishing.
@@ -990,7 +912,7 @@ declare class CliAgentAiService implements IAiService {
      * on the old model. No conversation yet is vacuously "current".
      */
     conversationMatchesConfig(): boolean;
-    /** Whether this conversation's planner submits through the Ordewell MCP server rather than the envelopes. */
+    /** Always: a conversation whose planner cannot reach the Ordewell MCP server fails to start rather than falling back to the envelopes. */
     plannerToolsAttached(): boolean;
     /** The agent's own session id, a resumption hint only — Ordewell's transcript is authoritative (T4). */
     nativeSessionId(): string | null;
@@ -1019,7 +941,8 @@ declare class CliAgentAiService implements IAiService {
      * mode from here without changing this signature.
      */
     private startAdapter;
-    /** Spawn with the Ordewell server injected. False, with nothing left running, when it did not connect. */
+    private newAdapter;
+    /** One spawn with the Ordewell server injected: the adapter once the runner reports it connected, otherwise why not, with nothing left running. */
     private startWithTools;
     /** Kill the planner process, and with it the token it was spawned with. */
     private disposeAdapter;
@@ -1031,12 +954,18 @@ declare class CliAgentAiService implements IAiService {
      */
     private ensureAdapter;
     private plannerModel;
+    /**
+     * A plan from one-shot agent sessions: only what a submit_plan call
+     * accepted, never the reply text, so a plan the tool refused cannot come
+     * back in as the JSON the agent echoed. A session that ends without an
+     * accepted call is followed by one corrective session, then fails.
+     */
+    private submittedPlan;
     /**
      * A single agent session that answers one prompt and exits. Used by every
-     * non-conversational entry point; the plan is parsed from the reply text by
-     * the same extractor the conversational path uses. Its envelope streams to
-     * the plan display, as a vendor planner's one-shot does, and the prose
-     * around it is not streamed at all, since no turn is open to show it in.
+     * non-conversational entry point. A plan-shaped envelope in its text
+     * streams to the plan display, as a vendor planner's one-shot does, and the
+     * prose around it is not streamed at all, since no turn is open to show it in.
      */
     private oneShot;
     researchAndPlan(userDescription: string, runners: RunnerId[], modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, fs: IFileSystem, onProgress: (progress: ResearchProgress) => void, _fetcher?: IWebFetcher, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, signal?: AbortSignal): Promise<{
@@ -1074,7 +1003,6 @@ interface ConversationRequest {
     fetcher?: IWebFetcher;
     runnerModes?: Record<RunnerId, RunnerModeInfo[]>;
     autonomousDefault?: boolean;
-    verificationEnabled?: boolean;
     /**
      * The planner model's context window when the catalog knows it. Threaded here
      * so a usage record can carry it (and the UI can show context fill); absent
@@ -1097,6 +1025,12 @@ interface ConversationRequest {
      */
     initialMessage?: string;
     plannerTools?: PlannerToolsOffer;
+    /**
+     * The workspace's skill catalog. Every planner is shown the task skills it
+     * may attach; only one with tools is shown the planner skills, which load
+     * through `load_skill` alone (ADR-0024).
+     */
+    skills?: readonly SkillInfo[];
 }
 /**
  * One planner turn's outcome. The planner talks to the user (`message`),
@@ -1195,6 +1129,11 @@ interface IAiService {
      * and cheap in every implementation, so callers never gate it.
      */
     reset(): void;
+    /**
+     * A one-shot plan from a prompt the caller built, so built for this
+     * planner's transport: one with {@link plannerToolsAttached} is asked for a
+     * submit_plan call, never JSON in its reply.
+     */
     sendPlanningPrompt(prompt: string, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Promise<Task[]>;
 }
 /**
@@ -1467,7 +1406,8 @@ declare class PlanStore {
     unblockDependents(id: string): void;
     setTaskVerdict(id: string, verdict: Task['verdict']): void;
     setTaskOutputSummary(id: string, summary: Task['outputSummary']): void;
-    setTaskTransport(id: string, transport: Task['transport']): void;
+    setTaskRunnerSessionId(id: string, runnerSessionId: string | undefined): void;
+    setTaskAttemptSkills(id: string, skills: Task['attemptSkills']): void;
     /**
      * Widen the plan's runner set. Retargeting a task onto a runner the plan has
      * not used before has to land here as well as on the plan state, or
@@ -1488,23 +1428,12 @@ type IsolationNoticeLevel = 'info' | 'warn' | 'error';
 interface IsolationRunListener {
     /** The run record changed and should be persisted with the plan. */
     changed(): void;
-    /**
-     * A run opened — the one moment shared by Execute, a manual task run and
-     * a force start, so whatever a run pins for its whole length is read here.
-     * Whether it isolates is decided later, at its first change task.
-     */
-    opened(): void;
     /** A run did not start: `repos` of the group have tracked changes. */
     blocked(repos: string[]): void;
     /** An isolated run closed and handed its integration branches over. */
     handoff(handoff: IsolationHandoff): void;
     /** Already said through the notifications; also for a surface that shows no toasts. */
     notice(level: IsolationNoticeLevel, message: string): void;
-    /**
-     * These tasks' worktrees are about to be removed. An agent left running in
-     * one would sit in a deleted directory, so it has to go first.
-     */
-    releasing(taskIds: string[]): void;
 }
 interface IsolationRunControllerDeps {
     isolation: IWorktreeIsolation;
@@ -1601,6 +1530,15 @@ declare class IsolationRunController {
      * the safe rule then.
      */
     plannerLayout(): Promise<IsolatedExecution>;
+    /**
+     * Where the workspace's skills are read, and whether tasks get worktrees.
+     * Read synchronously inside a planner turn or a chip edit, so it comes from
+     * the files, not git or the planner's last layout: a restored session is
+     * right from its first edit. The run's repos while it isolates; otherwise
+     * the group the workspace holds, in worktrees unless isolation is off or
+     * this run chose to share the root.
+     */
+    skillLayout(): SkillLayout;
     /**
      * Go on with 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
@@ -1932,8 +1870,8 @@ interface OrchestratorObserver {
     }): void;
 }
 /**
- * A message or interrupt a task cannot take: it is not running, it runs on the
- * terminal transport, or it is waiting on something a message does not answer.
+ * A message or interrupt a task cannot take: it is not running, or it is
+ * waiting on something a message does not answer.
  * The request is wrong, not the orchestrator, so a surface says why.
  */
 declare class TaskControlError extends Error {
@@ -1949,6 +1887,7 @@ interface TaskAttemptSnapshot {
     runner: string;
     cwd: string | null;
     startedAt: string;
+    skills: readonly TaskSkillSnapshot[];
 }
 /**
  * The wiring a {@link TaskOrchestrator} runs on, every collaborator resolved.
@@ -1959,7 +1898,7 @@ interface TaskAttemptSnapshot {
 interface TaskOrchestratorDeps {
     config: IConfig;
     notifications: INotification;
-    terminalRunner: ITerminalRunner;
+    runner: IRunner;
     store: PlanStore;
     output: TaskOutputSource;
     /** The plan's isolation run and the open run's lifecycle (ADR-0013). */
@@ -1971,10 +1910,8 @@ interface TaskOrchestratorDeps {
     workspaceRoot: () => string;
     /** The workspace's own variables for a task's cwd (ADR-0016). */
     workspaceEnv: (cwd: string) => Promise<WorkspaceEnv>;
-    /** Read live at each spawn, so a toggle takes effect on the next task. */
-    tddEnabled: () => boolean;
-    /** Read once as a run opens, never per spawn (ADR-0018, S1). */
-    runnerTransport: () => RunnerTransport;
+    /** The skill catalog over workspace roots, as {@link workspaceSkillRoots} orders them — read at each spawn. */
+    skillsAt: (roots: readonly string[]) => SkillLookup;
     /** What the task's last saved attempt did, or null when it left no log (ADR-0020). */
     previousAttemptFromLog: (taskId: string) => string | null;
 }
@@ -1986,15 +1923,14 @@ interface TaskOrchestratorDeps {
 interface TaskOrchestratorOptions {
     config: IConfig;
     notifications: INotification;
-    terminalRunner: ITerminalRunner;
+    runner: IRunner;
     store?: PlanStore;
     output?: TaskOutputSource;
     isolation?: IWorktreeIsolation;
     registry?: RunnerRegistry | null;
     workspaceRoot?: () => string;
     workspaceEnv?: (cwd: string) => Promise<WorkspaceEnv>;
-    tddEnabled?: () => boolean;
-    runnerTransport?: () => RunnerTransport;
+    skillsAt?: (roots: readonly string[]) => SkillLookup;
     previousAttemptFromLog?: (taskId: string) => string | null;
 }
 /**
@@ -2003,14 +1939,14 @@ interface TaskOrchestratorOptions {
  * 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
- * task state directly. A task completes only after the runner emits its
- * per-task completion marker; process exit without that evidence is a visible
- * failure and does not unblock dependent work.
+ * task state directly. A task completes only after the runner reports it done
+ * through `task_complete` on its attempt's token; process exit without that
+ * evidence is a visible failure and does not unblock dependent work.
  */
 declare class TaskOrchestrator {
     private config;
     private notifications;
-    private terminalRunner;
+    private runner;
     private store;
     private output;
     private attempts;
@@ -2021,8 +1957,6 @@ declare class TaskOrchestrator {
     private reviewApproved;
     private retryCounts;
     private spawnCounts;
-    /** The terminal a verdict left open, by task; see {@link LingeringRunners}. */
-    private lingering;
     /**
      * A full-plan run a failure paused. Retrying the failed task is the explicit
      * resume the pause waits for — without this a retry only reset the task to
@@ -2061,20 +1995,13 @@ declare class TaskOrchestrator {
     private registry;
     private workspaceRootFn;
     private observers;
-    private tddEnabled;
-    private readRunnerTransport;
+    private skillsAt;
     private previousAttemptFromLog;
-    /**
-     * The setting as the latest run copied it when it opened. Every spawn of
-     * that run uses this, so flipping the setting mid-run changes the next run
-     * only — the plan, not a live setting, says what runs (ADR-0001).
-     */
-    private planTransport;
     constructor(deps: TaskOrchestratorDeps);
     /**
      * The composition root: resolves every optional collaborator and wires the
      * isolation listener that the constructor cannot, because it needs the
-     * instance's own (private) emit and lingering seams. Nothing else in the
+     * instance's own (private) emit seam. Nothing else in the
      * codebase constructs an orchestrator, so this is the one place defaults
      * live — a host or test supplies what it cares about and gets the rest.
      */
@@ -2083,7 +2010,7 @@ declare class TaskOrchestrator {
     getIdleSince(taskId: string): string | null;
     /**
      * What an ops retry is told about the attempt before. The saved log is read
-     * whether or not the session was reloaded, so both behave alike; the terminal
+     * whether or not the session was reloaded, so both behave alike; the output
      * buffer is the fallback for a runner that has no log. A reload clears the
      * attempt count along with the buffer, so a retry made since is what says
      * there was an attempt to report on.
@@ -2120,13 +2047,13 @@ declare class TaskOrchestrator {
     forceSendQueuedTaskMessage(taskId: string, id: string): boolean;
     /** Take back a message still queued behind a turn; false once it was delivered. */
     removeQueuedTaskMessage(taskId: string, id: string): boolean;
-    /** Stop a structured task's running turn; it then waits for input like any turn that ends without its marker. */
+    /** Stop a structured task's running turn; it then waits for input like any turn that ends without a `task_complete` call. */
     interruptTask(taskId: string): Promise<void>;
     /** What is waiting for a structured task's turn to end; empty for any other task. */
     getQueuedTaskMessages(taskId: string): QueuedTaskMessage[];
-    private structuredSession;
+    private runnerSession;
     /**
-     * A structured turn that ended without the done marker (ADR-0018, W1). No
+     * A structured turn that ended without a `task_complete` call (ADR-0018, W1). No
      * verdict is guessed: the task waits for input, unless a checkpoint in the
      * same turn already has it waiting, or a queued message went straight out —
      * the session never passes through idle then, so nothing flickers.
@@ -2172,12 +2099,7 @@ declare class TaskOrchestrator {
      * the task has started, and for every other task.
      */
     getMergeGate(taskId: string): string[];
-    private watchBlockingPrompts;
-    /** The transport the plan's latest run copied from the setting; null before its first run. */
-    get runnerTransport(): RunnerTransport | null;
-    /** Take over a saved plan's copied transport. The next run copies the setting afresh. */
-    adoptRunnerTransport(transport: RunnerTransport | null): void;
-    queueMessage(text: string): void;
+    queueMessage(text: string, skills?: readonly SkillLoad[]): void;
     getQueuedMessages(): QueuedMessage[];
     /** Take one unsent message back out of the queue; false when it was never there (or already drained). */
     removeQueuedMessage(id: string): boolean;
@@ -2351,13 +2273,14 @@ declare class TaskOrchestrator {
      * unwound (both leave `startTask` with nothing further to announce).
      */
     private spawnAttempt;
+    /** For a skill the main checkout has, the folder a worktree only gets once it is committed. */
+    private uncommittedSkillFolder;
     /**
-     * Say on the task how this attempt is driven, when its plan asked for the
-     * structured transport; a terminal plan's tasks record nothing. A structured
-     * request that came back a terminal session is a fallback, and says why —
-     * a host without a router included — never a silent downgrade.
+     * The roots whose `.ordewell/skills/` an attempt at `cwd` reads: in a repo
+     * group, `cwd` holds each repo — a worktree of it when isolated, the
+     * workspace's own checkout when not — and no folder of its own (ADR-0014).
      */
-    private recordTransport;
+    private skillRoots;
     /**
      * A continue whose runner never announced the session it was told to
      * resume. Nothing was continued, and nothing fresh was started in its place.
@@ -2383,12 +2306,11 @@ declare class TaskOrchestrator {
      * 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
+     * the runner: a runner may 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 a terminal runner up so its screen stays readable (a structured one
-     * ends), and stop/load reset the whole verifier themselves.
+     * tick — long enough for the scheduler to start a dependent task. Stop and
+     * load reset the whole verifier themselves.
      */
     private endAttempt;
     /** Kept on the task once the attempt ends, so a continue can resume it after a reload (ADR-0018, K1). */
@@ -2411,9 +2333,13 @@ interface PlanRequest {
     autonomousDefault?: boolean;
     signal?: AbortSignal;
     perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
-    /** The mode toggles this run honours. `modesFor('one-shot', …)` decides which apply. */
     modes?: PlannerModes;
 }
+/** A generated plan, and what its skill check warned about. */
+interface GeneratedPlan extends LegacyPlanState {
+    /** Names not found yet, or no skill could have; the plan still lands. Absent means none, or not checked. */
+    skillWarnings?: string[];
+}
 interface ModifyPlanRequest {
     existingPlan: LegacyPlanState;
     userRequest: string;
@@ -2438,10 +2364,14 @@ interface ModifyDuringExecutionRequest {
     perRunnerAllowlist?: Partial<Record<RunnerId, string[]>>;
     /** Where the run in force puts each task (ADR-0013, ADR-0014). */
     isolatedExecution?: IsolatedExecution;
+    /** The workspace's skill catalog under its repo group's layout, which the rewritten tasks' skills are checked against. */
+    skills: SkillLookup;
 }
 interface ModifyDuringExecutionResult {
     pendingTasks: Task[];
     message: string;
+    /** Skill names not found yet; the edit still lands, as a submitted plan's does. Absent means none. */
+    skillWarnings?: string[];
 }
 /**
  * Owns one-shot plan generation and plan modification — the "planning is a
@@ -2460,8 +2390,12 @@ declare class Planner {
     private readonly resolveAiService;
     constructor(config: IConfig, aiService: IAiService | (() => IAiService));
     private get aiService();
-    /** One-shot plan generation for non-conversational surfaces. Never asks questions. */
-    generate(req: PlanRequest): Promise<LegacyPlanState>;
+    /**
+     * One-shot plan generation for non-conversational surfaces. Never asks
+     * questions. A plan attaching a planner skill to a task is refused, not
+     * returned: there is no conversation to send it back through.
+     */
+    generate(req: PlanRequest): Promise<GeneratedPlan>;
     modify(req: ModifyPlanRequest): Promise<{
         tasks: Task[];
     }>;
@@ -2557,9 +2491,7 @@ declare class RunnerInstallation {
      * typing a real goal is the failure this exists to prevent.
      *
      * "Usable" is deliberately shallow: the binary answers `--version`, and the
-     * runner has a connector to plan over. Plugin runners have none yet: a
-     * manifest-level planner capability, so a plugin can declare itself
-     * plannable, is a follow-up. Whether the user's subscription is
+     * runner has a connector to plan over. Whether the user's subscription is
      * live cannot be known without spending a turn on it, so an expired login
      * surfaces where it actually bites — as the agent's own error text on the
      * first turn.
@@ -2744,7 +2676,7 @@ interface EnvAdmission {
  */
 declare function admitSettingsEnv(env: Record<string, unknown>): EnvAdmission;
 
-/** Whether a runner's tasks can run on the structured transport (ADR-0018, S3). */
+/** Whether Ordewell can run a runner's tasks (ADR-0018, S3). */
 declare function supportsTaskMode(runner: string): boolean;
 /** The adapter that drives one task. Throws {@link TaskModeUnsupportedError} for a runner without a connector. */
 declare function createTaskAdapter(runner: string, deps: AgentProcessDeps): TaskModeAgentAdapter;
@@ -2869,7 +2801,7 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
      * A task's turn whose `result` arrived while background work was still open.
      * The CLI reports that result when the model stops talking, then opens a turn
      * of its own when the work finishes; a turn ended at the first result would
-     * lose everything said after it, the completion marker included.
+     * lose everything done after it, the `task_complete` call included.
      */
     private resultHeld;
     private followOnTimer;
@@ -2889,8 +2821,7 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     /**
      * A task's run: the manifest decides what its mode and effort mean
      * (ADR-0001), and this adds only the protocol around them. No tool list and
-     * no system prompt — the task's prompt is its first turn, as on the terminal
-     * transport. `--permission-prompt-tool stdio` routes the questions the mode
+     * no system prompt — the task's prompt is its first turn. `--permission-prompt-tool stdio` routes the questions the mode
      * leaves open to the control channel, where the adapter must answer them;
      * without it `-p` refuses them silently and nothing can ever surface one.
      */
@@ -3253,8 +3184,8 @@ declare class OpenCodeAdapter implements TaskModeAgentAdapter {
     /**
      * Whatever of the turn's own messages the stream missed. Each part is
      * emitted once, so a turn the stream saw whole adds nothing here; one that
-     * lost its last text part still reaches the plain-text channel, where the
-     * done marker is looked for.
+     * lost its last text part still reaches the plain-text channel, which a
+     * summary falls back to.
      */
     private readBack;
     /**
@@ -3398,8 +3329,7 @@ interface RunnerCatalog {
  * models by the manifest's `preferredPatterns`; the mode is the catalog's
  * `defaultMode`).
  *
- * An empty catalog means discovery failed or the runner is a plugin we have no
- * list for — not that the runner offers nothing. That field is left out of the
+ * An empty catalog means discovery failed — not that the runner offers nothing. That field is left out of the
  * patch and the runner validates last, matching `coerceAssignments`.
  */
 declare function runnerAssignment(catalog: RunnerCatalog, current?: Pick<Task, 'assignedModel' | 'taskMode'>): Partial<Task>;
@@ -3509,6 +3439,43 @@ interface ForkedDialogue {
     researchLog: ResearchLogEntry[];
 }
 
+/** A user's message as sent, and the skills its `/name` tokens load. */
+interface SkillInvocation {
+    text: string;
+    skills: SkillLoad[];
+}
+/**
+ * A path with the home directory written `~`, for a notice or listing. On
+ * Windows the drive letter's case is not significant and the separators are
+ * rendered `/`, so the same skill reads alike wherever the session reloads.
+ */
+declare function abbreviateHome(file: string, home?: string, platform?: NodeJS.Platform): string;
+/**
+ * Resolve the `/skill-name` tokens in a message to snapshots of the skills they
+ * name. Pure and exported so surfaces can resolve without a full Session. The text itself is never rewritten.
+ *
+ * Every distinct skill named loads, once, in the order first named. A token
+ * naming no skill is plain text, wherever it stands — a whole message of
+ * `/unknown` included: embedded in a sentence it is as likely to be incidental
+ * text (a path, an example command) as a typo'd invocation. So is one naming
+ * a skill with `user-invocable: false`, which only the model may invoke.
+ */
+declare function resolveSkillInvocation(text: string, skillsService: Pick<SkillsService, 'findSkill'>, home?: string): SkillInvocation;
+/**
+ * What the planner receives for a user message: the bodies of the skills it
+ * loaded, then the message as the user wrote it. The one composition for a
+ * live send and for a replay of the transcript, so a resumed conversation
+ * hands the planner what the live one did.
+ */
+declare function plannerMessage(text: string, loads: readonly SkillLoad[]): string;
+/**
+ * The transcript as the planner is to see it on a replay: each user message
+ * carries the skills loaded after it, composed by {@link plannerMessage}, and
+ * the load entries themselves are folded away. Sessions saved before skill
+ * loads existed hold the expanded text in the message and replay unchanged.
+ */
+declare function plannerTranscript(history: readonly ConversationMessage[]): ConversationMessage[];
+
 /**
  * The planner turn (see CONTEXT.md): the one piece of planner work that holds
  * the conversation, from its claim to its settled outcome. Its signal is what a
@@ -3571,11 +3538,15 @@ interface PlannerConversationHost {
     broadcastPlan(turnId?: string): void;
     /** Validate a batch against live state. Pure — nothing is applied. */
     validateOps(ops: TaskOp[]): ApplyTaskOpsResult;
+    /** The workspace's skill catalog under its repo group's layout, which the skills a plan or edit attaches are checked against. */
+    taskSkills(): SkillLookup;
+    /** Tell the user something the transcript does not carry. */
+    notice(level: SessionNotice['level'], message: string): void;
     /** Load planner-produced tasks: an edit keeps run state, a commit starts over. Returns how many landed. */
     adoptTasks(tasks: readonly Task[], how: 'edit' | 'commit'): number;
     capturePrd(text: string): void;
     /** Park a structural edit until the next batch boundary. Returns the queue length. */
-    queueEdit(userMessage: string): number;
+    queueEdit(message: SkillInvocation): number;
     /** Wake a scheduler an applied edit may have unblocked. */
     afterEdit(): Promise<void>;
     /** The planner turn was stopped or abandoned: whatever it is waiting on (a parked approval) will never be answered. */
@@ -3647,8 +3618,6 @@ interface TranscriptSnapshot {
 }
 interface ReplyOptions {
     signal?: AbortSignal;
-    /** The user's words before skill expansion — what a mid-run queue replays later. */
-    verbatim?: string;
 }
 /**
  * The planner conversation (ADR-0002), end to end: the persisted dialogue
@@ -3700,6 +3669,7 @@ declare class PlannerConversation {
     private claim;
     /** The user turn being answered, for what the host raises during it — an approval the turn's research asks for. */
     get currentTurnId(): string | undefined;
+    recordPlannerSkill(skill: SkillLoad): boolean;
     /**
      * Hand the open turn a plan (already validated) or a task edit. The turn
      * settles with it exactly as with the same plan or ops parsed out of its
@@ -3729,6 +3699,7 @@ declare class PlannerConversation {
         timestamp?: string;
         kind?: ConversationMessage['kind'];
     }): void;
+    private appendEntries;
     /** Swap the whole transcript. The live context no longer matches it, so pair with {@link reset}. */
     replace(messages: readonly ConversationMessage[]): void;
     snapshot(): TranscriptSnapshot | null;
@@ -3800,6 +3771,13 @@ declare class PlannerConversation {
      * Call inside the host's mutation ritual.
      */
     recordQueuedEdits(messages: string[], taskCount: number): void;
+    /**
+     * What the skill check of a landed plan or edit warned about, kept in the
+     * transcript so every surface shows it, on reload too, and not only the
+     * planner that may have read it in a tool result. Call inside the host's
+     * mutation ritual, so the broadcast plan carries it.
+     */
+    recordSkillWarnings(warnings: readonly string[], timestamp?: string): void;
     /**
      * Queued edits the between-batches drain could not apply. Recorded so the
      * transcript does not go on promising a change that never landed. Call
@@ -3810,13 +3788,13 @@ declare class PlannerConversation {
      * Open the conversation on the host's fresh plan: the goal is its first
      * message. `prepare` (discovery) runs inside the turn, so a stop reaches it.
      */
-    start(goal: string, prepare: () => Promise<ConversationOpening>, signal?: AbortSignal): Promise<LegacyPlanState>;
+    start(goal: SkillInvocation, prepare: () => Promise<ConversationOpening>, signal?: AbortSignal): Promise<LegacyPlanState>;
     /**
      * Every later user message, from the transcript append to a persisted
      * outcome. A turn that throws before anything was persisted takes its own
      * writes back out, so session memory never drifts from disk and the UI.
      */
-    reply(message: string, options?: ReplyOptions): Promise<LegacyPlanState>;
+    reply(message: string | SkillInvocation, options?: ReplyOptions): Promise<LegacyPlanState>;
     private replyTurn;
     /**
      * Whether a settled structural edit reaches work a runner is executing. Only
@@ -3834,6 +3812,14 @@ declare class PlannerConversation {
      * call hands back is a fragment of an answer to a dialogue that is gone.
      */
     private assertCurrent;
+    /**
+     * {@link assertCurrent} on the far side of an await that precedes a plan
+     * mutation: the skill check waits on git, and a stop, rewind or session
+     * switch in that window drops the edit instead of landing it on whatever
+     * plan is current by then. A stop counts here because nothing has landed
+     * yet — the user asked for the turn to end before it changed the plan.
+     */
+    private assertStillCurrent;
     /**
      * A live conversation is only safe to continue in-place when it also
      * matches the model/effort configured right now — a harness planner's
@@ -3848,6 +3834,7 @@ declare class PlannerConversation {
      */
     private userTurn;
     private requirePlan;
+    /** The message as typed, then one entry per skill it loaded, sharing its timestamp so a reload keeps them together. */
     private recordUser;
     private recordResearch;
     /**
@@ -3892,6 +3879,8 @@ declare class PlannerConversation {
      * one path, not two.
      */
     private settle;
+    /** A name not found at submit only warns: a task the attaching one depends on may create it. */
+    private warnSkills;
     /** Validate + commit a task_ops turn atomically. Returns the errors on rejection (plan untouched). */
     private applyTaskOps;
     /** Commit a settled (non-task_ops) turn through the host's mutation ritual. */
@@ -3920,42 +3909,48 @@ declare class PlannerConversation {
     private currentPlanLines;
 }
 
-declare const BUILTIN_SKILL_NAMES: readonly ["grilling", "to-spec", "improve-codebase-architecture"];
-interface SkillMetadata {
-    name: string;
-    description: string;
-    disableModelInvocation?: boolean;
+interface UserSettings {
+    modelAllowlist?: Record<string, string[]>;
+    /** Last model (and its thinking effort) the user chose for each planner backend, keyed by AiProvider id. */
+    plannerModels?: Record<string, {
+        model: string;
+        effort?: string;
+    }>;
+    /**
+     * Runners the user picked for planning. Absent — not empty — is what falls
+     * back to the environment's defaults; `[]` is a deliberate "none of them".
+     */
+    enabledRunners?: string[];
+}
+/**
+ * The model allowlist, remembered planner models and enabled runners are shared
+ * across processes by default. `ORDEWELL_SETTINGS_PATH` lets independent runs
+ * use separate files: otherwise a write in one run would change another's
+ * settings when `getAll()` detects the new mtime.
+ */
+declare function getSettingsPath(): string;
+declare class SettingsService {
+    private filePath;
+    private cache;
+    private cachedMtimeMs;
+    constructor(filePath?: string);
+    getAll(): UserSettings;
+    private fileMtimeMs;
+    getModelAllowlist(runner: string): string[] | undefined;
+    setModelAllowlist(runner: string, ids: string[] | undefined): void;
+    getPlannerModel(provider: string): {
+        model: string;
+        effort?: string;
+    } | undefined;
+    setPlannerModel(provider: string, entry: {
+        model: string;
+        effort?: string;
+    } | undefined): void;
+    getEnabledRunners(): string[] | undefined;
+    setEnabledRunners(ids: string[]): void;
+    private load;
+    private persist;
 }
-interface SkillInfo {
-    name: string;
-    description: string;
-    metadata: SkillMetadata;
-    /** Full content of SKILL.md with frontmatter stripped */
-    content: string;
-    /** Absolute path to the SKILL.md file */
-    path: string;
-    /** Whether this came from global (~/.ordewell/skills/) or local (.ordewell/skills/) */
-    source: 'global' | 'local';
-}
-declare class SkillsService {
-    private workspaceRoot?;
-    constructor(workspaceRoot?: string | undefined);
-    private localDir;
-    private globalDir;
-    private readSeedManifest;
-    private recordSeed;
-    /** A seed the user never edited: safe to replace with a newer built-in. */
-    private isUntouchedSeed;
-    private seed;
-    seedBuiltinSkill(name: string): boolean;
-    /** Removes a retired built-in's seed from the global dir, but only if it's untouched by the user. */
-    private isUnmodifiedRetiredSeed;
-    private pruneRetired;
-    findSkill(name: string): SkillInfo | undefined;
-    listSkills(): SkillInfo[];
-    getSkillContent(name: string): string | undefined;
-}
-declare function createSkillsService(workspaceRoot?: string): SkillsService;
 
 /** The `planner_usage` member of the session broadcast union. */
 type PlannerUsageMessage = Extract<SessionMessage, {
@@ -4098,31 +4093,11 @@ interface GeneratePlanOptions {
 type SessionPlanner = Pick<Planner, 'generate' | 'modifyDuringExecution'>;
 /** Runtime prefs read live — may toggle between operations. */
 interface SessionRuntimeSettings {
-    tddEnabled: boolean;
-    verificationEnabled?: boolean;
     modelAllowlist?: Record<string, string[]>;
-    /** Read once as a run starts, never per spawn (ADR-0018, S1). Absent means terminal. */
-    runnerTransport?: RunnerTransport;
     /** Absent means the user never chose, and `config.enabledRunners` (the host's defaults) decides. */
     enabledRunners?: RunnerId[];
 }
 declare function sessionRuntimeSettings(settings: UserSettings): SessionRuntimeSettings;
-/**
- * Resolve `/skill-name` invocations to their skill's markdown content. Pure
- * and exported so surfaces and verification can drive substitution without a
- * full Session.
- *
- * A message that is *only* `/skill-name` keeps the legacy whole-message
- * behaviour: an unknown skill becomes a notice naming what IS available,
- * instead of a bare slash token a runner would mis-resolve in its own skills
- * directory. Anywhere else in a message, a matching token is spliced in place
- * (surrounding text is untouched); a token that doesn't name a real skill is
- * left as plain text rather than raising a notice, since embedded in a
- * sentence it's as likely to be incidental text (a path, an example command)
- * as a typo'd invocation. The same skill name repeated only expands its first
- * occurrence — later repeats stay literal.
- */
-declare function resolveSkillInvocation(text: string, skillsService: Pick<SkillsService, 'findSkill' | 'listSkills'>): string;
 /** Where a fork landed: the new session's id, and what adopting it needs. */
 interface ConversationFork {
     sessionId: string;
@@ -4138,14 +4113,14 @@ type SaveSession = (plan: LegacyPlanState, goal: string, workspace: string, sess
 /**
  * Everything a delivery surface constructs to host a session. Structural config
  * (orchestratorModel, providerModelLists) is snapshotted inside `config` at
- * construction and never re-read from the environment. Runtime settings (tdd,
- * verification, enabled runners) are read live via the `settings` callback so a
+ * construction and never re-read from the environment. Runtime settings
+ * (enabled runners) are read live via the `settings` callback so a
  * toggle between operations takes effect.
  */
 interface SessionDeps {
     config: IConfig;
     notifications: INotification;
-    runner: ITerminalRunner;
+    runner: IRunner;
     registry: RunnerRegistry;
     /** Resolves the workspace root for the orchestrator (lazy — VS Code can change it). */
     workspaceRoot: () => string;
@@ -4157,7 +4132,7 @@ interface SessionDeps {
     onNotice?: (notice: SessionNotice) => void;
     /** Shared across sessions — sole producer of model catalogs and routing lists. */
     modelResolver: ModelResolver;
-    /** Live runtime settings (tdd, verification, enabled runners). Read at each operation that needs them. */
+    /** Live runtime settings (enabled runners). Read at each operation that needs them. */
     settings: () => SessionRuntimeSettings;
     /**
      * Host-assigned session id. When set, every persist writes under this id so
@@ -4178,11 +4153,7 @@ 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.
-     */
+    /** Where a task's output and final answer are read. */
     taskOutput?: TaskOutputSource;
     /**
      * Git worktree isolation (ADR-0013). Defaults to git itself, gated by
@@ -4209,6 +4180,7 @@ interface SessionParts {
     workspace: string;
     fsAdapter: IFileSystem;
     broadcast: SessionBroadcaster;
+    notifications: INotification;
     onNotice?: (notice: SessionNotice) => void;
     modelResolver: ModelResolver;
     settings: () => SessionRuntimeSettings;
@@ -4224,7 +4196,7 @@ interface SessionParts {
     approvals: PendingApprovals;
     approvalPolicy: ApprovalPolicy;
     fetcher: IWebFetcher;
-    skillsService: Pick<SkillsService, 'findSkill' | 'listSkills'>;
+    skillsService: Pick<SkillsService, 'findSkill' | 'listSkills' | 'searchedDirs' | 'forRoot'>;
     saveSession: SaveSession;
     /** The conversation's host is the Session itself, so only the Session can make it. */
     conversation: (host: PlannerConversationHost) => PlannerConversation;
@@ -4255,6 +4227,7 @@ declare class Session {
     private goal;
     private workspace;
     private readonly broadcast;
+    private readonly notifications;
     private readonly onNotice?;
     private readonly modelResolver;
     private readonly fsAdapter;
@@ -4424,14 +4397,20 @@ declare class Session {
     /** Whether the planner conversation is live (started and not yet committed to a plan). */
     get isConversationActive(): boolean;
     /**
-     * Intercept a skill invocation (/skill-name) and substitute the skill's
-     * markdown content BEFORE the message reaches the planner. Prevents runners
-     * (Claude Code, OpenCode) from trying to resolve the skill in their own
-     * directory instead of .ordewell/skills/. An unknown skill is surfaced to
-     * the planner as a notice naming what IS available, rather than passing a
-     * bare /unknown through to be mis-resolved.
+     * The skills a message's `/skill-name` tokens load, snapshotted here so the
+     * planner gets Ordewell's skill rather than a runner (Claude Code, OpenCode)
+     * resolving the token in its own skills directory. The message stays as
+     * typed.
      */
     private resolveSkillInvocation;
+    /**
+     * The one catalog every planner path reads — its skill catalogs, `/name`,
+     * and the check of what a plan or an edit attaches — over the folders the
+     * workspace's tasks will read at spawn.
+     */
+    private workspaceSkills;
+    /** The catalog over workspace `roots`; the workspace root alone is the session's own. */
+    private skillsAt;
     private conversationOpening;
     /**
      * Load planner-produced tasks, coerced to the allowlist read live — it may
@@ -4478,6 +4457,8 @@ declare class Session {
      */
     processQueuedMessages(): Promise<void>;
     private drainQueue;
+    /** Said through both channels: a host shows one or the other, never both (the daemon's toasts are no-ops). */
+    private notice;
     private applyQueuedEdits;
     /**
      * Every finished task as the log records it: this run's own entries, plus
@@ -4497,8 +4478,7 @@ declare class Session {
     sendTaskMessage(taskId: string, text: string): string;
     /**
      * Force send (ADR-0023, F1): interrupt the task's running turn and deliver
-     * this message next. Throws `TaskControlError` where a plain message would,
-     * and for a task on the terminal transport.
+     * this message next. Throws `TaskControlError` where a plain message would.
      */
     forceSendTaskMessage(taskId: string, text: string): string;
     forceSendQueuedTaskMessage(taskId: string, id: string): boolean;
@@ -4703,17 +4683,18 @@ interface OkResponse {
     ok: boolean;
 }
 /**
- * A plan as the planner routes return it: the session's plan state itself, not
- * the `SerializedPlan` a websocket `plan_generated` carries. The two differ —
+ * A plan as the planner routes return it: the session's plan state, not the
+ * `SerializedPlan` a websocket `plan_generated` carries. The two differ —
  * this one holds raw tasks and the dialogue's bookkeeping — and a client that
- * reads either reads only the fields it needs.
+ * reads either reads only the fields it needs. Skill bodies stay in the
+ * session: loads and attempt snapshots arrive as notices.
  */
 interface PlanResponse {
-    plan: LegacyPlanState;
+    plan: SurfacePlan;
 }
 /** `POST /plans/:id/resolve-conflict`: `null` when the session had no conflict to hand a resolver task. */
 interface ResolveConflictResponse {
-    plan: LegacyPlanState | null;
+    plan: SurfacePlan | null;
 }
 /** What `GET /api/models` returns, and what the pool's provider discovery produces. */
 interface ModelsResponse {
@@ -4730,7 +4711,9 @@ interface ModelsResponse {
 }
 /** One-shot planning answers in the phase-tagged shape a saved session is read back in. */
 interface GeneratePlanResponse extends Pick<ModelsResponse, 'models' | 'modelsByRunner'> {
-    plan: PlanState;
+    plan: SurfacePlanState;
+    /** The host notes the plan's transcript records, a skill check's warnings among them, which the phase-tagged plan does not carry. */
+    notes?: string[];
 }
 interface ExecuteResponse {
     status: 'running';
@@ -4767,7 +4750,7 @@ type IsolationMergeResponse = IsolationMergeResult;
 interface ConversationForkResponse {
     sessionId: string;
     goal: string;
-    plan: LegacyPlanState;
+    plan: SurfacePlan;
 }
 /** A fork made by a rewind, with the full text of the message it was made just before. */
 interface ConversationRewindResponse extends ConversationForkResponse {
@@ -4793,10 +4776,10 @@ interface RunnersResponse {
 /** Sessions: a saved one comes off its file, a live one from the pool's store. */
 interface SessionResponse {
     meta: SessionMeta;
-    plan: PlanState;
+    plan: SurfacePlanState;
 }
 interface AdoptSessionResponse extends OkResponse {
-    plan: LegacyPlanState;
+    plan: SurfacePlan;
     goal: string;
 }
 interface TaskLogAttemptsResponse {
@@ -4813,11 +4796,8 @@ interface SettingsResponse {
     aiProvider: AiProvider;
     plannerThinkingEffort: string;
     maxParallel: number;
-    tdd: UserSettings['tdd'];
-    verification: UserSettings['verification'];
     modelAllowlist: UserSettings['modelAllowlist'];
     plannerModels: UserSettings['plannerModels'];
-    runnerTransport: RunnerTransport;
 }
 /** What `PATCH /api/settings` answers: the settings as they now stand, plus what the write itself decided. */
 interface SettingsUpdateResponse extends SettingsResponse {
@@ -4837,9 +4817,6 @@ interface CommandDescriptor {
 interface CommandsResponse {
     commands: CommandDescriptor[];
 }
-interface CommandResponse extends OkResponse {
-    settings: SettingsResponse;
-}
 interface WorkspacesResponse {
     workspaces: string[];
 }
@@ -4873,7 +4850,7 @@ declare class AlreadyExecutingError extends Error {
 
 /**
  * Where Ordewell keeps machine-global data (settings, daemon tokens, caches,
- * user plugins). A single home for everything not tied to a project directory,
+ * credentials). A single home for everything not tied to a project directory,
  * so per-project state in `.ordewell/` and global state never collide.
  */
 declare function globalDataDir(): string;
@@ -4900,22 +4877,14 @@ type CheckpointWithdrawnListener = (taskId: 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 pendingVerdicts;
-    private structuredSessions;
-    private markerTails;
-    private checkpointCarry;
-    private pausedSessions;
+    private sessions;
     private listeners;
     private checkpointListeners;
     private withdrawnListeners;
-    /**
-     * The open `checkpoint` tool call per task (ADR-0022, V5): settling it is how
-     * an answer reaches a runner that asked through the tool, where the marker's
-     * answer is typed into the session instead.
-     */
+    /** The open `checkpoint` tool call per task (ADR-0022, V5): settling it is how an answer reaches the runner. */
     private toolCheckpoints;
-    /** The question a task's checkpoint asks, whole, for as long as it waits — by either route. */
+    /** The question a task's checkpoint asks, whole, for as long as it waits. */
     private checkpointQuestions;
     private idleListeners;
     /**
@@ -4957,32 +4926,22 @@ declare class VerdictEngine {
     private touchIdle;
     /** Tear down idle tracking for a task; broadcasts the null transition if it was idle. */
     private clearIdle;
-    /**
-     * Submit a synchronized resume token to the paused session. An interactive
-     * TUI only accepts the Enter keystroke (`\r`) — a `\n` types the token into
-     * its composer without sending it, leaving the agent paused until a human
-     * presses Enter. A line-oriented piped session has no composer; it reads a
-     * `\n`-terminated line, and the leading newline flushes a partial line.
-     */
-    private resumeToken;
     /** What a task's waiting checkpoint asks, untruncated; undefined when none waits. */
     getCheckpointQuestion(taskId: string): string | undefined;
     approveCheckpoint(taskId: string): void;
     rejectCheckpoint(taskId: string, reason: string): void;
     /**
-     * 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. A structured session's `task_complete`
-     * call is evidence too (ADR-0022, V2): whichever signal comes first decides.
+     * Attach to a spawned session. The runner's `task_complete` call on the
+     * attempt's token is the only completion evidence (ADR-0022, V2); a session
+     * that exits before one gets a failed verdict.
      *
      * Returns the attempt's generation, what {@link signalComplete} is checked against.
      */
-    watch(task: Task, session: ITerminalSession): number;
+    watch(task: Task, session: IRunnerSession): number;
     /**
      * The runner's own `task_complete` call (ADR-0022, V1/V3): settles the
-     * attempt exactly as the marker does, unless that attempt is no longer the
-     * task's current one or another signal already settled it.
+     * attempt, unless that attempt is no longer the task's current one or an
+     * earlier call already settled it.
      */
     signalComplete(taskId: string, generation: number, report: TaskCompleteArgs): void;
     /** The runner was told something after its evidence so far, so only what it reports from here counts. */
@@ -4990,9 +4949,8 @@ declare class VerdictEngine {
     private acceptVerdict;
     private publishVerdict;
     /**
-     * The runner's `checkpoint` call (ADR-0022, V5): raised through the same
-     * listeners as the marker, so the task waits on the user the same way, and
-     * settled by {@link approveCheckpoint} or {@link rejectCheckpoint}. It is
+     * The runner's `checkpoint` call (ADR-0022, V5): the task waits on the
+     * user until it is settled by {@link approveCheckpoint} or {@link rejectCheckpoint}. It is
      * withdrawn, never left hanging, once the attempt is over or the call goes.
      */
     raiseCheckpoint(taskId: string, generation: number, question: string, signal: AbortSignal): Promise<CheckpointAnswer>;
@@ -5001,8 +4959,6 @@ declare class VerdictEngine {
     private withdrawToolCheckpoint;
     private approvalOpened;
     private approvalClosed;
-    /** 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. */
@@ -5013,54 +4969,23 @@ declare class VerdictEngine {
     private ceaseTracking;
     /** Drop all tracking state (used on stop / loadPlan). */
     reset(): void;
-    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}.
- */
+/** Owns one bounded output buffer per task attempt, fed from the attempt's session. */
 declare class BufferedTaskOutputSource implements TaskOutputSource {
     private captures;
-    private transcripts;
     private maxBufferChars;
     constructor(opts?: {
-        transcripts?: TranscriptReader;
         maxBufferChars?: number;
     });
-    attach(taskId: string, session: ITerminalSession): void;
+    attach(taskId: string, session: IRunnerSession): void;
     detach(taskId: string): void;
     reset(): void;
-    finalText(attempt: TaskOutputAttempt, doneToken: string): Promise<string>;
+    finalText(taskId: string): 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;
-    private readonly claudeConfigDirs;
-    constructor(opts?: {
-        homeDir?: string;
-        workspaceEnv?: (cwd: string) => Promise<Record<string, 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
@@ -5070,7 +4995,7 @@ declare class HomeTranscriptReader implements TranscriptReader {
  * allowlisted for Claude Code does not limit it — it points it at something it
  * cannot spawn, and the plan only dies once a task is already running. But
  * "this runner didn't list it" is not enough to call an id wrong: discovery can
- * be stale, and a plugin runner may have no list at all. What settles it is
+ * be stale or return no list at all. What settles it is
  * whether *another* runner listed the id. So:
  *
  * - listed for this runner → keep;
@@ -5107,26 +5032,30 @@ declare function buildResearchToolsPrompt(): string;
 declare function buildSubagentSystemPrompt(): 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.
+ * choices: 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 planner (ADR-0009): the agent owns its own tools and research
+     * budget, and reads the catalog and submits the plan through Ordewell's MCP
+     * tools (ADR-0022). An API planner speaks the JSON envelopes instead.
+     */
     harness?: boolean;
-    /** The planner reads the catalog and submits the plan through Ordewell's MCP tools (ADR-0022), not the JSON envelope. */
-    plannerTools?: boolean;
+    /** The skill catalog: task skills it can attach on every path, planner skills it can load only with tools. */
+    skills?: readonly SkillInfo[];
     /** 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;
+declare function buildConversationSystemPrompt(goal: string, context: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: 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;
-declare function buildModifyPlanPrompt(existingPlan: LegacyPlanState, userRequest: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, aiflowContext?: string, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): string;
+declare function buildPlanWithResults(userGoal: string, context: string, researchResults: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, runners: RunnerId[], runnerModes?: Record<RunnerId, RunnerModeInfo[]>, modes?: PlannerModes, tools?: boolean): string;
+declare function buildModifyPlanPrompt(existingPlan: LegacyPlanState, userRequest: string, modelsByRunner: Partial<Record<RunnerId, DiscoveredModel[]>>, aiflowContext?: string, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean, tools?: boolean): string;
 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[]>, modes?: Pick<PlannerModes, 'autonomousDefault' | 'isolatedExecution'>): 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'>, tools?: boolean): 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
@@ -5230,6 +5159,14 @@ declare const JSON_REPAIR_INSTRUCTION: string;
 declare const TRUNCATED_PLAN_REPAIR_INSTRUCTION: string;
 /** A plan attempt was botched (invalid or truncated JSON): re-emit the whole plan. */
 declare function reEmitPlanPrompt(detail: string): string;
+/**
+ * A planner that submits through Ordewell's tools ended without an accepted
+ * plan, or one it submitted was refused: call the tool again. A plan written
+ * in its reply is never read (ADR-0025), so asking for JSON would be ignored.
+ */
+declare function resubmitPlanPrompt(errors: string[]): string;
+/** A tool planner's task edit was refused as its turn settled: correct it through edit_plan. */
+declare function resubmitEditPrompt(errors: string[]): string;
 /** A plan emission was truncated mid-JSON; the caller may also have compacted the history to free input context. */
 declare function truncatedPlanReEmitPrompt(historyCompacted: boolean): string;
 /** A task-ops attempt was botched (unparseable JSON): re-emit the ops object. */
@@ -5238,8 +5175,8 @@ declare function reEmitTaskOpsPrompt(detail: string): string;
 declare function reEmitTaskQueryPrompt(detail: string): string;
 /** Task ops parsed but failed semantic validation (cycles, unknown refs, locked tasks). */
 declare function taskOpsRejectedPrompt(errors: string[]): string;
-/** A modified plan failed validation during execution: full re-prompt feedback block. */
-declare function modifyValidationFeedback(errors: string[]): string;
+/** A modified plan failed validation during execution: full re-prompt feedback block, asking for the planner's own transport. */
+declare function modifyValidationFeedback(errors: string[], tools?: boolean): string;
 type PlannerReplyClassification = {
     kind: 'plan';
     tasks: Task[];
@@ -5289,23 +5226,6 @@ declare function classifyPlannerReply(text: string, opts: {
  */
 declare function generatePlanWithRepair(generate: (repairHint?: string) => Promise<string>, runners: RunnerId[], maxAttempts?: number, runnerModes?: Record<RunnerId, RunnerModeInfo[]>, autonomousDefault?: boolean): Promise<Task[]>;
 
-type RunnerMode = string;
-
-declare function buildRunnerInvocation(opts: {
-    runner: string;
-    prompt: string;
-    modelId?: string;
-    thinkingEffort?: string;
-    modelVariants?: string[];
-    mode?: RunnerMode;
-    headless?: boolean;
-    interactive?: boolean;
-    cwd?: string;
-    /** The installed runner's `--version`, for a manifest whose command line differs by major version. */
-    runnerVersion?: string;
-    registry: RunnerRegistry;
-}): RunnerInvocation;
-
 interface PriorOutput {
     order: number;
     title: string;
@@ -5318,18 +5238,6 @@ declare function summarizeOutput(reviewReason: string | undefined, output: strin
     capturedAt: string;
 };
 declare function collectDirectDependencyOutputs(task: Task, allTasks: readonly Task[]): PriorOutput[];
-/**
- * Break marker tokens carried in a predecessor's captured output. Interactive
- * runners echo the prompt they are given, and the watcher scans that terminal
- * output — a quoted marker would settle this task on the previous one's
- * evidence. Hyphenated rather than spaced: the scanner also reads a
- * whitespace-flattened view of the terminal, which would rejoin a space.
- *
- * A completion marker also loses its id: transcripts are bound to a task by
- * that id, and a dependent's transcript quoting it would answer for the
- * predecessor the next time the predecessor runs.
- */
-declare function defuseMarkers(text: string): string;
 declare function renderPriorOutputs(outputs: PriorOutput[]): string;
 declare function augmentPromptWithPriorOutputs(task: Task, allTasks: readonly Task[]): string;
 /**
@@ -5344,11 +5252,10 @@ declare function renderPlanMap(planTasks: readonly Task[], currentTaskId: string
 interface ComposeOptions {
     planMapEnabled?: boolean;
     planMapMaxEntries?: number;
-    tddEnabled?: boolean;
+    /** The task's skills as resolved where this attempt runs. */
+    skills?: readonly TaskSkillSnapshot[];
     /** An ops task's last attempt, as its output ended (ADR-0020); absent on a first attempt. */
     previousAttempt?: string;
-    /** The runner is given the `task_complete` and `checkpoint` tools (ADR-0022); the markers stay as their fallback. */
-    completionTool?: boolean;
 }
 declare function composeAugmentedPrompt(task: Task, allTasks: readonly Task[], opts?: ComposeOptions): string;
 /**
@@ -5359,143 +5266,44 @@ declare function composeAugmentedPrompt(task: Task, allTasks: readonly Task[], o
  */
 declare function composeContinuationPrompt(task: Task, message: string, opts?: {
     ops?: boolean;
-    completionTool?: boolean;
 }): string;
 
-type ExecFileFn = (command: string, args: string[]) => Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-/** Test seam: every OS touchpoint is injectable; production uses the defaults. */
-interface TmuxRunnerDeps {
-    port: number;
-    execFileImpl?: ExecFileFn;
-    resolvePath?: () => Promise<string>;
-    pollIntervalMs?: number;
-    logDir?: string;
-    clipboardCommand?: () => string | null;
-    /** Reads the runner's version, for a manifest whose command line differs by major version. */
-    runnerVersion?: RunnerVersionProbe;
-}
-declare class TmuxSession extends AbstractTerminalSession {
-    private tmuxSession;
-    private windowName;
-    private execFileImpl;
-    private pollIntervalMs;
-    private logPath;
-    private socket;
-    /** A tmux window is a real TTY running the agent's TUI, so it submits on Enter. */
-    readonly interactive = true;
-    private outputBuffer;
-    private offset;
-    private timer;
-    private quietPolls;
-    private misses;
-    private looking;
-    constructor(id: string, taskId: string, tmuxSession: string, windowName: string, execFileImpl: ExecFileFn, pollIntervalMs: number, logPath: string, socket: string);
-    private get target();
-    /** Every tmux call must name the daemon's own socket; an unprefixed one
-     * silently targets the shared default server (see `tmuxSocketName`). */
-    private tmux;
-    /**
-     * Runs the invocation in a fresh tmux window, tailed via `pipe-pane` into a
-     * log file rather than polling `capture-pane` snapshots — a byte-exact
-     * stream needs no diff/resync heuristics. The command is wrapped so the
-     * window survives its own exit (an `exec`'d login shell), which is what
-     * lets the user keep poking at a finished task's terminal.
-     */
-    start(command: string, args: string[], cwd: string, env?: Record<string, string>): Promise<void>;
-    private poll;
-    /** Emit what the log gained since the last read; false when it gained nothing. */
-    private readLog;
-    /**
-     * The sentinel is printed by the wrapper shell, so a window closed from
-     * outside — killed by the user, or with the whole tmux server — never prints
-     * it, and the session would count as running forever. A silent window is
-     * therefore looked up by exact name (a `-t` target falls back to another
-     * window once its own is gone), and once it is confirmed missing the session
-     * ends as a kill does. Whatever the log still held is read first, so a
-     * completion marker printed just before the close still counts.
-     */
-    private checkWindow;
-    /**
-     * A task finishing (or being killed) stops observation, but never the
-     * window itself on the sentinel path — only `kill()` closes the window.
-     * Piping is turned off and the log file removed either way, so a finished
-     * task doesn't leave a `cat` process appending to it for the rest of the
-     * daemon's life.
-     */
-    private finish;
-    kill(): void;
-    getOutput(): string;
-    write(text: string): void;
-}
-/**
- * Runs tasks in a real tmux window instead of a piped subprocess, so a user
- * can open a genuine, interactive terminal on any task (running or
- * finished) from outside Ordewell's own process. `ITerminalSession` hides the
- * transport from `VerdictEngine`/`PoolAwareRunner`, so orchestration is
- * unchanged — this is a drop-in replacement for `HeadlessRunner`.
- */
-declare class TmuxRunner extends AbstractRunner<TmuxSession> {
-    private sessionName;
-    private socket;
-    private execFileImpl;
-    private resolvePath;
-    private pollIntervalMs;
-    private logDir;
-    private clipboardCommand;
-    private runnerVersion;
-    /** Retries get a freshly named window so a failed attempt's output stays inspectable. */
-    private attempts;
-    private ready;
-    constructor(deps: TmuxRunnerDeps);
-    /**
-     * Reaps a session orphaned by a crashed prior daemon on the same port, then
-     * creates a fresh one. Memoized: `spawn` awaits it too, so a task spawned
-     * before startup's own call has settled never lands in a missing session —
-     * and a settled failure clears the memo so the next spawn can retry.
-     */
-    ensureSession(): Promise<void>;
-    /** Every tmux call must name this daemon's socket; see `tmuxSocketName`. */
-    private tmux;
-    private createFreshSession;
-    /**
-     * Gives an attached runner terminal wheel/PageUp scrolling over a deep
-     * scrollback, and a mouse selection that reaches the system clipboard — none
-     * of which a default tmux session does. Server-wide scoping is harmless: the
-     * daemon owns a private socket (`tmuxSocketName`).
-     *
-     * `mouse on` is what costs the emulator's own drag-select, so tmux must hand
-     * the selection back out itself: via a clipboard binary when there is one,
-     * and via OSC 52 (`set-clipboard`) for what that cannot cover, such as
-     * viewing over SSH. Naming the binary on the binding as well as in
-     * `copy-command` keeps drag-to-copy working on tmux older than 3.2, which has
-     * no `copy-command`.
-     */
-    private configureScrolling;
-    /**
-     * Called on daemon shutdown — the one guarantee against leaked tmux
-     * processes. Kills the whole server, not just the session: the socket
-     * belongs to this daemon alone, so nothing else can be on it, and a runner
-     * that somehow escaped its session would otherwise keep running (and keep
-     * billing) unattached for as long as the server lived.
-     */
-    killSession(): Promise<void>;
-    spawn(opts: {
-        taskId: string;
-        runner: string;
-        prompt: string;
-        modelId?: string;
-        thinkingEffort?: string;
-        modelVariants?: string[];
-        mode?: string;
-        headless?: boolean;
-        cwd: string;
-        registry?: RunnerRegistry;
-        planSessionId?: string;
-        env?: Record<string, string>;
-    }): Promise<ITerminalSession>;
+/** One source for the spawn options, so a runner built on this base cannot drift from the interface. */
+type RunnerSpawnOptions = Parameters<IRunner['spawn']>[0];
+declare abstract class AbstractRunnerSession implements IRunnerSession {
+    id: string;
+    taskId: string;
+    protected exited: boolean;
+    protected outputEmitter: EventEmitter<any>;
+    protected exitEmitter: EventEmitter<any>;
+    constructor(id: string, taskId: string);
+    protected baseHandleExit(code: number): void;
+    onOutput(callback: (text: string) => void): void;
+    onExit(callback: (code: number) => void): void;
+    abstract kill(): void;
+    abstract getOutput(): string;
+    abstract write(text: string): void;
+    abstract turnState(): 'working' | 'idle';
+    abstract onTurnEnd(listener: (reason: StructuredTurnEnd) => void): void;
+    abstract onEvent(listener: (event: StructuredEvent) => void): void;
+    abstract sendMessage(text: string): string;
+    abstract forceSend(text: string): string;
+    abstract forceSendQueued(id: string): boolean;
+    abstract removeQueued(id: string): boolean;
+    abstract queued(): QueuedTaskMessage[];
+    abstract interrupt(): Promise<void>;
+    abstract nativeSessionId(): string | null;
+    abstract answerPermission(id: string, decision: ApprovalDecision): boolean;
+    abstract onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
+    abstract onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
+}
+declare abstract class AbstractRunner<S extends IRunnerSession> implements IRunner {
+    protected sessions: Map<string, S>;
+    get activeCount(): number;
+    stop(sessionId: string): void;
+    stopAll(): void;
+    protected registerSession(id: string, session: S): void;
+    abstract spawn(opts: RunnerSpawnOptions): Promise<IRunnerSession>;
 }
 
 interface StructuredRunnerDeps {
@@ -5513,26 +5321,27 @@ interface SessionLaunch {
     createAdapter: (runner: string, deps: AgentProcessDeps) => TaskModeAgentAdapter;
     startOptions: TaskStartOptions;
     interruptGraceMs: number;
-    /** Where this attempt's task tools are served, when its runner takes them (ADR-0022). */
-    tools?: {
+    /** Where this attempt's task tools are served (ADR-0022). */
+    tools: {
         server: OrdewellMcpServer;
         scope: TaskTokenScope;
     };
+    onNotice?: (message: string) => void;
 }
 /**
  * One task driven over its runner's programmatic protocol (ADR-0018). It *is*
- * an `ITerminalSession`, so everything downstream of `onOutput` is unchanged;
- * what a terminal cannot do sits on {@link StructuredSessionCapability}.
+ * an `IRunnerSession`, with plain output and structured events.
  *
  * Ordewell owns the message queue (M1). A message sent mid-turn is handed to a
  * runner that can take one at its next step (ADR-0023); otherwise it waits for
  * the turn to end rather than being typed into a runner that is busy.
  */
-declare class StructuredSession extends AbstractTerminalSession implements StructuredSessionCapability {
+declare class StructuredSession extends AbstractRunnerSession {
     private readonly launch;
-    readonly transport: "structured";
     private adapter;
     private adapterStarted;
+    private adapterAttached;
+    private startupExit;
     /** Bumped whenever the adapter is replaced, so the old one's late events and exit are ignored. */
     private generation;
     private output;
@@ -5558,16 +5367,25 @@ declare class StructuredSession extends AbstractTerminalSession implements Struc
     private toolToken;
     private checkpointHandler;
     constructor(id: string, taskId: string, launch: SessionLaunch);
-    /** Start the runner and send the task's prompt as its first turn. */
+    /**
+     * Start the runner with the attempt's tools attached and send the task's
+     * prompt as its first turn. `task_complete` is the only way a task reports
+     * it is done, so a runner without the tools is never sent the task: it is
+     * killed and respawned once, and a second failure fails the start.
+     */
     start(prompt: string): Promise<void>;
     getOutput(): string;
     onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
     onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
     /**
-     * A server that cannot start costs the task its tools, not its run: the
-     * prompt still teaches the marker (ADR-0022, S2).
+     * One spawn of the runner on a fresh token. Null once the runner reports
+     * the server connected — or once the session ended meanwhile, which leaves
+     * nothing to start; otherwise why not, with the process killed and the
+     * token revoked. A runner that cannot be spawned at all throws instead:
+     * spawning it again would fail the same way.
      */
-    private issueTools;
+    private startAttached;
+    private startWithTools;
     private revokeTools;
     protected baseHandleExit(code: number): void;
     /**
@@ -5657,8 +5475,7 @@ declare class StructuredSession extends AbstractTerminalSession implements Struc
 /**
  * The structured transport (ADR-0018): a task's runner as a plain child
  * process speaking its protocol — no tmux, no `script` (W2). Only runners
- * with a task-mode connector can be spawned here; routing the rest to the
- * terminal transport is the caller's decision, not a silent downgrade here.
+ * with a task-mode connector can be spawned here.
  */
 declare class StructuredRunner extends AbstractRunner<StructuredSession> {
     private spawnCount;
@@ -5667,44 +5484,7 @@ declare class StructuredRunner extends AbstractRunner<StructuredSession> {
     private readonly interruptGraceMs;
     private readonly mcp;
     constructor(deps?: StructuredRunnerDeps);
-    spawn(opts: RunnerSpawnOptions): Promise<ITerminalSession>;
-}
-
-interface TransportRoute {
-    transport: RunnerTransport;
-    /** Why a structured request runs on the terminal instead, in words a surface shows as is. */
-    fallback?: string;
-}
-/**
- * Where one task runs (ADR-0018, S3): structured only when the plan asks for
- * it and the task's runner has a task-mode connector. Anything else runs on
- * the terminal, and a structured request says why.
- */
-declare function routeTransport(requested: RunnerTransport | undefined, runner: string, registry?: RunnerRegistry | null): TransportRoute;
-/**
- * The runner a host hands the orchestrator: its own terminal runner (tmux,
- * headless, the VS Code terminal) and the structured one behind a single
- * `ITerminalRunner`, picking per spawn by {@link routeTransport}.
- *
- * `stopAll` and `activeCount` reach both inner runners, so a host that shares
- * one across plans (the daemon's tmux) keeps its per-plan wrapper above this.
- */
-declare class TransportRouter implements ITerminalRunner {
-    private readonly runners;
-    /**
-     * Session ids the structured runner owns; every other id is the terminal's.
-     * Kept past exit, so a stop that arrives late never reaches the terminal
-     * runner with an id it does not know.
-     */
-    private readonly structuredIds;
-    constructor(runners: {
-        terminal: ITerminalRunner;
-        structured: ITerminalRunner;
-    });
-    get activeCount(): number;
-    spawn(opts: RunnerSpawnOptions): Promise<ITerminalSession>;
-    stop(sessionId: string): void;
-    stopAll(): void;
+    spawn(opts: RunnerSpawnOptions): Promise<IRunnerSession>;
 }
 
 /** Whether a task can be continued in its saved runner session (ADR-0018, K1), and in which. */
@@ -5717,9 +5497,8 @@ type Continuability = {
 };
 /**
  * The rule every surface offers Continue by and the orchestrator enforces: a
- * completed or failed task whose last attempt ran structured and left a
- * session id behind. A conflict is resolved by its repair, not a new turn, and
- * a terminal task has no session Ordewell can reach — Retry covers both.
+ * completed or failed task whose last attempt left a session id behind. A
+ * conflict is resolved by its repair, not a new turn — Retry covers it.
  */
 declare function continuability(task: Task): Continuability;
 declare function canContinue(task: Task): boolean;
@@ -5739,8 +5518,7 @@ interface TaskLogRecorderDeps {
  * batches, so what a surface saw live and what it reloads are one sequence.
  *
  * It sits around the runner rather than inside the orchestrator, which stays
- * unaware of logs; a terminal-transport session has no event stream and is
- * passed through untouched.
+ * unaware of logs.
  */
 declare class TaskLogRecorder {
     private readonly deps;
@@ -5748,10 +5526,130 @@ declare class TaskLogRecorder {
     private readonly flushMs;
     private readonly logger;
     constructor(deps: TaskLogRecorderDeps);
-    wrap(runner: ITerminalRunner): ITerminalRunner;
-    /** Start a new attempt's log for `session` and keep it until the session exits. */
-    record(taskId: string, session: ITerminalSession & StructuredSessionCapability): void;
+    wrap(runner: IRunner): IRunner;
+    /** Start a new attempt's log for `session`, opening with the skills it was given, and keep it until the session exits. */
+    record(taskId: string, session: IRunnerSession, skills?: readonly TaskSkillSnapshot[]): void;
+}
+
+declare function stripAnsi(text: string): string;
+
+/**
+ * cmd.exe's command-line buffer. A longer line is truncated rather than
+ * rejected, which would corrupt a planner's system prompt or a task's prompt
+ * mid-sentence and produce a confident answer to half a question — so the
+ * batch route refuses instead. See {@link CommandLineTooLongError}.
+ */
+declare const CMD_EXE_MAX_COMMAND_LINE = 8191;
+/**
+ * CreateProcess's own ceiling, which the native and PowerShell routes are
+ * bounded by instead. Windows truncates here too, so the same refusal applies —
+ * it is simply four times further away.
+ */
+declare const WINDOWS_MAX_COMMAND_LINE = 32767;
+interface LaunchPlan {
+    /** The executable handed to `spawn()`. */
+    file: string;
+    /** Arguments for `file`. Pass verbatim when {@link verbatim} is set. */
+    args: string[];
+    /**
+     * Windows batch route only: `args` is already a quoted command line and must
+     * not be re-quoted. Maps to `windowsVerbatimArguments` for `spawn`.
+     */
+    verbatim?: boolean;
+}
+/** Test seam: every OS touchpoint is injectable, and production uses the defaults. */
+interface LaunchDeps {
+    platform?: NodeJS.Platform;
+    /** The PATH executables are looked up on. Defaults to the augmented PATH. */
+    resolvePath?: () => Promise<string>;
+    /** True when `candidate` names an existing file. */
+    exists?: (candidate: string) => boolean;
+    /** Absolute path to the Windows command interpreter. */
+    comSpec?: () => string;
+    /** Absolute path to Windows PowerShell. */
+    powerShell?: () => string;
+    /** PATHEXT, as the environment reports it. */
+    pathExt?: () => string;
+}
+/**
+ * Thrown when a command's arguments do not fit the buffer of the only
+ * interpreter that can start it. Windows truncates rather than rejecting, and a
+ * system prompt cut off mid-sentence makes the planner answer half a question
+ * confidently — the silent success this repo refuses — so this is raised
+ * instead. `TaskOrchestrator.startTask` catches it and holds the task, so the
+ * message is what the user reads: it names the fix, because they cannot infer
+ * it from a truncated prompt.
+ */
+declare class CommandLineTooLongError extends Error {
+    readonly command: string;
+    readonly length: number;
+    readonly limit: number;
+    constructor(command: string, length: number, limit?: number);
+}
+/**
+ * Thrown when only a batch shim resolved for a multi-line argument. cmd.exe
+ * reads up to the first CR/LF and discards the rest with no error and exit code
+ * 0 — quoting does not help — so the agent would get the first paragraph of its
+ * prompt without the instruction to report through `task_complete`, then exit looking successful.
+ */
+declare class EmbeddedNewlineError extends Error {
+    readonly command: string;
+    constructor(command: string);
+}
+/**
+ * Thrown when `command` cannot be resolved to a real file. Kept distinguishable
+ * from `WorkspaceNotFoundError` (utils/workspace) even though both a missing
+ * cwd and a missing binary surface as the same `spawn` ENOENT to Node — the two
+ * are checked, and named, separately so the failure names the actual cause.
+ */
+declare class ExecutableNotFoundError extends Error {
+    readonly command: string;
+    readonly searchedPath: string;
+    constructor(command: string, searchedPath: string);
 }
+/**
+ * Whether `command` actually resolves to a file, given the plan
+ * {@link planDirectLaunch} produced for it and the PATH it was resolved
+ * against.
+ *
+ * POSIX is deliberately identity in `planDirectLaunch` (execvp does its own
+ * PATH search), so the search is repeated here instead. Windows already did
+ * the search inside `planDirectLaunch` — signalled by the returned file
+ * differing from the bare command name it was given; an unresolved command
+ * comes back unchanged.
+ */
+declare function isExecutableResolved(command: string, plan: LaunchPlan, PATH: string, deps?: LaunchDeps): boolean;
+/** The verbatim command line cmd.exe receives after `/d /s /c`, before wrapping. */
+declare function windowsCommandLine(file: string, args: string[]): string;
+/**
+ * How to start `command` with `args` through `spawn()`, with no shell.
+ *
+ * POSIX returns its input unchanged — execvp already searches PATH, and adding
+ * a resolution step there would be a new way for a working setup to break.
+ *
+ * Windows resolves the command against PATH × PATHEXT, preferring a native
+ * executable (spawned directly) over a batch shim (through cmd.exe) over a
+ * PowerShell script shim (through `powershell.exe -File`). A command that
+ * resolves to nothing is returned unchanged, so the caller's existing ENOENT —
+ * which names what the user typed — is what surfaces rather than a second,
+ * vaguer error from here.
+ *
+ * The tiers are tried in preference order and the first that *fits* wins, with
+ * one deliberate exception: an overflowing batch shim does not fall through to
+ * PowerShell. Overflow means a very large prompt, which is precisely where
+ * `-File` argument fidelity is least worth betting on, and where a clear held
+ * task beats a plausibly-mangled one. So capacity does not reorder the tiers —
+ * a `.ps1` beside a too-long `.cmd` still raises.
+ *
+ * A line break does reorder them: cmd.exe cannot carry one at any length, so a
+ * `.ps1` beside a `.cmd` wins, and a lone `.cmd` raises.
+ *
+ * @throws {CommandLineTooLongError} when the selected route's buffer cannot
+ * carry the arguments.
+ * @throws {EmbeddedNewlineError} when the arguments span lines and only the
+ * batch route resolved.
+ */
+declare function planDirectLaunch(command: string, args: string[], deps?: LaunchDeps): Promise<LaunchPlan>;
 
 /**
  * A workspace path that does not exist, or exists but is not a directory.
@@ -5918,137 +5816,42 @@ declare function clearAugmentedPathCache(): void;
  */
 declare function withPath(base: NodeJS.ProcessEnv, resolvedPath: string, overrides?: Record<string, string>): NodeJS.ProcessEnv;
 
-/** One shared tmux session per daemon, scoped by port so multiple daemons never collide. */
-declare function tmuxSessionName(port: number): string;
-/**
- * Each daemon gets its own tmux *server*, not just its own session name.
- *
- * A plain `tmux new-session` attaches to whatever server already owns the
- * default socket, and a session created on an existing server inherits that
- * **server's** environment — not the environment of the process that asked for
- * it (tmux only refreshes `update-environment` vars, and only on attach). So a
- * daemon started with, say, a particular provider API key would silently hand
- * its runners a stale key left behind by whoever started the server first,
- * possibly hours earlier under a different configuration entirely.
- *
- * A private socket makes the server a child of this daemon, so the runner
- * inherits the daemon's environment the way any child process would, and
- * `kill-server` at shutdown is authoritative — a runner cannot outlive the
- * daemon by hiding on a shared server. Users attaching by hand need the same
- * flag: `tmux -L ordewell-<port> attach -t ordewell-<port>`.
- */
-declare function tmuxSocketName(port: number): string;
-/**
- * tmux window targeting breaks on `:` and other punctuation, so ids are
- * slugged. Task ids are only unique within one plan ("task-1" is every
- * planner's favourite), so the window is also scoped by the plan session id —
- * without it, the second plan run in a daemon's lifetime would collide with
- * the first plan's still-open windows and pipe its output into the wrong one.
- */
-declare function tmuxWindowName(taskId: string, planSessionId?: string): string;
-type ProbeFn = () => void;
-/** Feature-detects tmux the same way `HeadlessRunner` detects `script`. */
-declare function hasTmux(probe?: ProbeFn): boolean;
 type HasBinFn = (bin: string) => boolean;
 /**
  * Shell command tmux should pipe a copy-mode selection into, so selecting text
- * in a task's terminal puts it on the *system* clipboard rather than in a tmux
+ * in a tmux pane puts it on the *system* clipboard rather than in a tmux
  * paste buffer no other application can read. Preferred over tmux's OSC 52
  * bridge, which plenty of emulators (VTE before 0.76, xterm without
  * `allowWindowOps`) drop on the floor.
  */
 declare function clipboardCopyCommand(hasBin?: HasBinFn, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string | null;
 
-declare class FsPluginStore implements IPluginStore {
-    getUserPluginsDir(): string;
-    listUserPluginDirs(): string[];
-    listDir(dir: string): string[];
-    loadManifest(pluginDir: string): RunnerPluginManifest | null;
-    copyDir(sourceDir: string, destDir: string): void;
-    removeDir(dir: string): void;
-    ensureDir(dir: string): void;
-    writeFile(filePath: string, content: string): void;
-    readFile(filePath: string): string | null;
-    dirExists(path: string): boolean;
-    exists(path: string): boolean;
-}
-
-/**
- * Shape check for a manifest read off disk or out of a cloned repository. The
- * name is constrained here rather than at each install route, so every store
- * implementation gets the same guarantee that a manifest name is a plain
- * segment and never a traversal sequence.
- */
-declare function isValidManifest(obj: unknown): obj is RunnerPluginManifest;
-
-/**
- * A plugin name is a single plain path segment: alphanumeric at both ends,
- * dots/dashes/underscores in between. This is what keeps a manifest name from
- * being a traversal sequence (`..`, `../../etc`), an absolute path, or a
- * dash-prefixed string that a downstream tool reads as a flag.
- */
-declare const PLUGIN_NAME_PATTERN: RegExp;
-declare function isPlainPluginName(name: unknown): name is string;
-declare function assertPlainPluginName(name: unknown): asserts name is string;
-/**
- * Resolve where a plugin of this name installs, and assert the result is still
- * a direct child of the plugins directory. Validation and use share this one
- * call so they cannot disagree about the path being checked.
- */
-declare function resolvePluginInstallDir(pluginsDir: string, name: unknown): string;
-
-/** Hosts a plugin may be cloned from. Exact hostname match, case-insensitive. */
-declare const ALLOWED_PLUGIN_HOSTS: readonly string[];
-type PluginSource = {
-    kind: 'git';
-    url: string;
-} | {
-    kind: 'path';
-    path: string;
-};
-/**
- * Validate a plugin repository URL. Requires an ordinary HTTPS repository on an
- * allowed host, which is also what rejects git's transport helpers (`ext::`,
- * `git://`, `ssh://`, `file://`) — they never reach the clone because they are
- * not the https scheme.
- *
- * Returns the parsed URL so callers clone the normalised form they validated.
- */
-declare function assertInstallablePluginUrl(url: unknown): URL;
-/**
- * Decide whether an install source names a remote repository or a local
- * directory. Anything that carries a scheme or looks like an scp-style remote
- * goes down the URL route so it is rejected as a bad URL rather than silently
- * retried as a (nonexistent) directory.
- */
-declare function classifyPluginSource(source: string): PluginSource;
+declare function removedPluginNotice(dataDir?: string): string | undefined;
 
-declare function resolveArgs(manifest: RunnerPluginManifest, ctx: ResolveContext): RunnerInvocation;
-/**
- * The manifest's meaning of a task's mode and effort, for a runner driven over
- * its programmatic protocol rather than a command line built from
- * `argsTemplate` (ADR-0018, C1). The effort stays a raw id behind the same
- * `{{if thinking}}` gate as the template path: how an effort reaches the
- * runner is protocol, which each adapter owns.
- */
-declare function resolveTaskRunnerFlags(manifest: RunnerPluginManifest, ctx: Pick<ResolveContext, 'mode' | 'model' | 'thinkingEffort'>): TaskRunnerFlags;
+declare function resolveTaskRunnerFlags(manifest: RunnerManifest, ctx: {
+    mode: string;
+    model?: string;
+    thinkingEffort?: string;
+}): TaskRunnerFlags;
 
-declare const CLAUDE_CODE_MANIFEST: RunnerPluginManifest;
+declare const CLAUDE_CODE_MANIFEST: RunnerManifest;
 
-declare const OPENCODE_MANIFEST: RunnerPluginManifest;
+declare const OPENCODE_MANIFEST: RunnerManifest;
 
 declare const STATE_DIR = ".ordewell";
 declare function ensureDir(dir: string): void;
 declare function getStateDir(baseDir?: string): string;
 /**
- * A match-everything ignore rule, written *inside* the state directory. A
- * `.gitignore` containing `*` inside a directory excludes that directory's
- * whole contents, itself included, so plans and sessions stop being
- * accidentally committable — without ever touching a file the developer wrote.
- * Editing their root `.gitignore` would be the intrusive version of this.
- *
- * Idempotent, and never overwrites an existing file: a developer who has
- * customised these rules (to commit their plans deliberately, say) keeps them.
+ * Ignores the state directory's contents except this file and `skills/`, so a
+ * project's skills are committed and reach every task worktree through git —
+ * the bootstrap never links `.ordewell/` (ADR-0013). Plans and sessions stay
+ * uncommittable without touching a file the developer wrote; editing their
+ * root `.gitignore` would be the intrusive version of this.
+ */
+declare const STATE_DIR_IGNORE = "*\n!.gitignore\n!skills/\n!skills/**\n";
+/**
+ * Idempotent, and never overwrites a file the developer customised (to commit
+ * their plans deliberately, say). Only the exact legacy rule is upgraded.
  */
 declare function ensureStateDirIgnored(baseDir?: string): void;
 
@@ -6102,7 +5905,7 @@ declare function sanitizeSlug(raw: string): string;
 declare function savePrdMarkdown(workspace: string, slug: string, markdown: string): string;
 
 /** How many AI tasks may run at once: `ORDEWELL_MAX_PARALLEL`, `/parallel`, `ordewell.maxParallelSessions`. */
-declare const DEFAULT_MAX_PARALLEL = 3;
+declare const DEFAULT_MAX_PARALLEL = 5;
 /**
  * A usable limit from what a user typed or a setting holds: any whole number
  * of at least 1 — there is no ceiling, the machine and the runners' own rate
@@ -6111,4 +5914,4 @@ declare const DEFAULT_MAX_PARALLEL = 3;
  */
 declare function parseMaxParallel(value: unknown): number | null;
 
-export { ALLOWED_PLUGIN_HOSTS, ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalMode, ApprovalPolicy, ApprovalRequest, type ApprovalsResponse, type AskOptions, AwaitingReason, BUILTIN_SKILL_NAMES, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CORE_PLANNER_PROMPT, type CancelPlanningResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, type CommandDescriptor, type CommandResponse, type CommandTier, type CommandsResponse, type ComposeOptions, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DaemonErrorCode, DiscoveredModel, type EnvAdmission, EnvConfig, type ErrorBody, type ExecFileFn, type ExecImpl, type ExecuteResponse, FindSymbolOptions, type ForceSendResponse, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, type HasBinFn, HomeTranscriptReader, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, IWorktreeIsolation, type IsolationDiffResponse, IsolationHandoff, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationOutcome, IsolationRun, IsolationTaskRecord, IsolationTaskStatus, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, LegacyPlanState, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, type MergeGateEntry, type MergeGateResponse, MergeGateView, ModelResolver, type ModelResolverDeps, type ModelsResponse, type ModifyPlanRequest, NoPlanError, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, 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, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PluginSource, type PrdBlock, type PrdResponse, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, QueuedTaskMessage, REFUSED_COMMANDS, ReadFileOpts, type RemoveMessageResponse, RepairEvidence, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, type ResolveConflictResponse, ResolveContext, type RewindTarget, type RewindTargetsResponse, RunnerApprovals, type RunnerCatalog, type RunnerEntry, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, RunnerSpawnOptions, RunnerTransport, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, SettingsService, type SettingsUpdateResponse, type ShellDialect, type SkillInfo, type SkillMetadata, SkillsService, type SpawnSpec, StdioAgentAdapter, type StopResponse, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredSessionCapability, StructuredTurnEnd, 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, TaskCompleteArgs, TaskControlError, TaskIsolation, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, type TaskOrchestratorDeps, type TaskOrchestratorOptions, type TaskOutputAttempt, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskSnapshot, TaskStartOptions, TaskTokenScope, TmuxRunner, type TmuxRunnerDeps, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, type TranscriptQuery, type TranscriptReader, type TransportRoute, TransportRouter, TreeSnapshot, UsageRecord, type UserSettings, Verdict, VerdictEngine, type VerdictListener, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertInstallablePluginUrl, assertPlainPluginName, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildSplitPrompt, buildSubagentSystemPrompt, canContinue, clampThinkingEffort, classifyCommand, classifyPlannerReply, classifyPluginSource, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, composeContinuationPrompt, configuredProviders, continuability, createAiService, createSession, createSkillsService, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, defuseMarkers, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensurePrivateDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, hasTmux, idSegment, includeGlobFor, isCliProvider, isOpenAiProvider, isPlainPluginName, isValidManifest, killTree, languageForId, listSessions, listTaskLogAttempts, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, plannerBackendEntries, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, readTaskLog, referencePattern, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolvePluginInstallDir, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, retargetTaskRunner, routeTransport, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionDataDir, sessionRuntimeSettings, stateExists, stripModelPrefix, summarizeOutput, supportsTaskMode, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tmuxSessionName, tmuxSocketName, tmuxWindowName, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, withPath, writePrivateFile };
+export { ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractRunnerSession, ActiveTaskSession, type AdoptSessionResponse, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApplyTaskOpsResult, ApprovalAnswer, type ApprovalAnswerResponse, ApprovalDecision, ApprovalMode, ApprovalPolicy, ApprovalRequest, type ApprovalsResponse, type AskOptions, AwaitingReason, BaseAiService, BaseConfig, BaseFileSystem, BufferedTaskOutputSource, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CancelPlanningResponse, type CappedRows, CheckpointAnswer, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, type CommandDescriptor, CommandLineTooLongError, type CommandTier, type CommandsResponse, type ComposeOptions, ConsoleLogger, ContextCollector, type Continuability, ConversationBusyError, type ConversationCompactResponse, type ConversationCompaction, ConversationEditError, type ConversationFork, type ConversationForkResponse, ConversationMessage, type ConversationRequest, type ConversationRewind, type ConversationRewindResponse, type ConversationTurn, type ConversationVariant, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DaemonErrorCode, DiscoveredModel, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ErrorBody, type ExecImpl, ExecutableNotFoundError, type ExecuteResponse, FindSymbolOptions, type ForceSendResponse, GIT_READONLY_SUBCOMMANDS, GREP_PCRE_PROBE_ARGS, GeminiService, type GeneratePlanResponse, type GitExecFn, GlobOptions, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, type HasBinFn, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IRunner, IRunnerSession, IWorktreeIsolation, type IsolationDiffResponse, IsolationHandoff, IsolationLandedTask, type IsolationMergeResponse, IsolationMergeResult, IsolationOutcome, IsolationRun, IsolationTaskRecord, IsolationTaskStatus, IsolationView, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, type LiveOutputLookup, type LiveTail, type LiveTailOptions, type MappedTool, type MergeGateEntry, type MergeGateResponse, MergeGateView, ModelResolver, type ModelResolverDeps, type ModelsResponse, type ModifyPlanRequest, NoPlanError, type NotificationAction, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OUTPUT_LINES_DEFAULT, OUTPUT_LINES_MAX, type OkResponse, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanIsolation, PlanParseError, type PlanRequest, type PlanResponse, PlanState, PlanStatus, PlanStore, Planner, type PlannerBackendEntry, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerSubmission, PlannerToolHandler, PlannerTurnDiscardedError, PlannerTurnStoppedError, type PlannerUsability, PlannerUsage, type PrdBlock, type PrdResponse, type PriorOutput, ProviderModelLists, type ProviderRegistration, QueuedMessage, QueuedTaskMessage, REFUSED_COMMANDS, ReadFileOpts, type RemoveMessageResponse, RepairEvidence, type RepairLoopOpts, type RepairVerdict, RepoGroupLayout, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchToolType, type ResearchTurn, type ResolveConflictResponse, type RewindTarget, type RewindTargetsResponse, RunnerApprovals, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerManifest, RunnerModeInfo, RunnerRegistry, type RunnerSpawnOptions, type RunnersResponse, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, Session, SessionBroadcaster, type SessionData, type SessionDeps, type SessionListResponse, SessionMessage, type SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionResponse, type SessionRuntimeSettings, type SettingsResponse, SettingsService, type SettingsUpdateResponse, type ShellDialect, SkillInfo, type SkillInvocation, SkillLoad, SkillsService, type SpawnSpec, StdioAgentAdapter, type StopResponse, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SurfacePlan, SurfacePlanState, 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, TaskCompleteArgs, TaskControlError, TaskIsolation, type TaskLogAttemptsResponse, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, type TaskLogResponse, type TaskMessageResponse, TaskModeAgentAdapter, TaskOp, TaskOrchestrator, type TaskOrchestratorDeps, type TaskOrchestratorOptions, type TaskOutputSource, type TaskQuery, type TaskQueryCatalog, type TaskQueryField, TaskRunnerFlags, TaskSkillSnapshot, TaskSnapshot, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, TreeSnapshot, UsageRecord, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorkspacesResponse, type WorktreeIsolationDeps, abbreviateHome, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentPromptWithPriorOutputs, augmentedPath, bearerHeaderValue, buildConflictRepairPrompt, buildConflictResolutionPrompt, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildSplitPrompt, buildSubagentSystemPrompt, canContinue, clampThinkingEffort, classifyCommand, classifyPlannerReply, clearAugmentedPathCache, clearDaemonToken, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, composeContinuationPrompt, configuredProviders, continuability, createAiService, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultLogger, definitionPattern, deleteSession, describeMergeResult, discoverGeminiModels, effectiveAllowlist, ensureDir, ensurePrivateDir, ensureStateDirIgnored, executionLogBlock, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, killTree, languageForId, listSessions, listTaskLogAttempts, loadSession, loadSessionPlanState, loadState, mapAgentTool, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, openTaskLog, parseMaxParallel, parseTaskQueryJson, pendingEditRulesBlock, planDirectLaunch, plannerBackendEntries, plannerMessage, plannerTranscript, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, reEmitTaskQueryPrompt, readDaemonToken, readTaskLog, referencePattern, removedPluginNotice, renderPlanMap, renderPriorOutputs, renderTaskQueryAnswer, repairLoop, researchShellWarning, researchToolsPath, resolveProviderFromPrefix, resolveResearchShell, resolveSkillInvocation, resolveTaskRunnerFlags, resolveWithin, resubmitEditPrompt, resubmitPlanPrompt, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, sessionDataDir, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, supportsTaskMode, taskOpsRejectedPrompt, taskQuerySignature, textHasTaskQuery, tokenSubprotocols, tokensMatch, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, writePrivateFile };