@ordewell/core 0.11.3 → 0.12.1

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { az as RunnerId, au as ResearchProgress, b6 as UsageRecord, at as ResearchLogEntry, aS as Task, i as DiscoveredModel, I as IIsolationPreview, x as IWorktreeIsolation, $ as IsolationTaskStatus, a0 as IsolationView, a8 as PlanIsolation, a1 as LegacyPlanState, aA as RunnerSessionCost, as as ReportedWindow, ag as PlannerUsage, a$ as TaskSkillSnapshot, aO as SkillsService, E as ExecutionActor, b0 as TaskSnapshot, a9 as PlanState, b8 as Verdict, aP as StoredHandoff, p as HandoffCheck } from './Task-BL4Idm9r.js';
-export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, C as ContextCheckpoint, c as ContextFill, d as ConversationMessage, e as CostProvenance, D as DEFAULT_LOOP_ROUNDS, f as DEFAULT_RUNNERS, g as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as DIGEST_FINDINGS, j as ExecutionCommandName, k as ExecutionRecord, F as FindingSeverity, G as GuardTarget, l as GuardTrip, H as HANDOFF_LIMITS, m as HANDOFF_PUSH_CHARS, n as Handoff, o as HandoffArtifact, q as HandoffCommit, r as HandoffDigest, s as HandoffEvidence, t as HandoffFinding, u as HandoffPatch, v as HandoffPreviewOptions, w as HandoffTaskName, y as IntegrationDisposal, z as InvalidSkill, J as IsolationAvailability, K as IsolationHandoff, L as IsolationHandoffRepo, M as IsolationInactiveReason, N as IsolationLandedTask, O as IsolationLanding, P as IsolationMergeBlock, Q as IsolationMergeBlockReason, R as IsolationMergeResult, S as IsolationOutcome, T as IsolationPreview, U as IsolationPruneResult, V as IsolationRemoval, W as IsolationRepo, X as IsolationRun, Y as IsolationTaskRecord, Z as IsolationTaskRef, _ as IsolationTaskRepo, a2 as LoopSubject, a3 as MAX_LOOP_ROUNDS, a4 as ModelUsage, a5 as PatchFlag, a6 as PatchView, aa as PlanStatus, ab as PlanUsage, ac as PlannerCompaction, ad as PlannerCompactionOutcome, ae as PlannerContextPause, af as PlannerResendState, ah as PrepareIntent, ai as PreparedTask, aj as PreservedWork, ak as PreviewRepo, al as PreviousWork, am as REPORT_MAX_CHARS, an as RefusedRemoval, ao as RepairEvidence, ap as ReplyRun, aq as RepoGroupLayout, ar as RepoHead, av as ResearchStep, aw as ResearchStepOutcome, ay as RunSettings, aB as SEVERITY_LABEL, aC as ScriptConsent, aD as ScriptResult, aE as SessionBilling, aF as SetupFailure, aG as ShadowedSkill, aH as SkillAppliesTo, aI as SkillCatalog, aJ as SkillInfo, aK as SkillLoad, aL as SkillLoadNotice, aM as SkillMetadata, aN as SkillSource, aR as SupervisorLevel, aV as TaskIsolation, aW as TaskIsolationState, aX as TaskLoop, aY as TaskModelAssignment, b1 as TaskStatus, b2 as TaskType, b3 as TaskUsageSummary, b4 as TreeSnapshot, b5 as UsageLine, b7 as UsageTotals, b9 as VerificationCheck, ba as addAttemptUsage, bb as addModelUsage, bc as addPlannerUsage, bd as addUsage, be as addUsageTotals, bf as artifactLines, bg as betweenRounds, bh as boundedHandoffLines, bi as byteSize, bj as checkHandoff, bk as checkOf, bl as contextMeterText, bm as contextMeterTitle, bn as costText, bo as countedSessionCost, bp as createEmptyPlan, bq as createSkillsService, br as createTask, bs as endAttemptUsage, bt as findingLines, bu as flattenTasks, bv as flattenTasksWithParents, bw as formatCost, bx as formatTokenCount, by as handoffDigest, bz as handoffLines, bA as handoffPreviewLines, bB as handoffReferenceText, bC as handoffWakeLines, bD as inLoop, bE as isAwaitingReason, bF as isMeasured, bG as isSupervisorLevel, bH as isUserMessage, bI as loopRemovalRefusal, bJ as loopRoundOf, bK as migratePlanState, bL as modelCostTitle, bM as namedHandoff, bN as openingLines, bO as outOfRounds, bP as partedPromptUsage, bQ as patchChangesText, bR as patchFlagText, bS as patchLines, bT as patchLinesText, bU as patchText, bV as patchView, bW as pausedOnLimit, bX as planUsage, bY as plannerContextFill, bZ as readableTaskIds, b_ as rejoinPlanTree, b$ as resumedSessionWindow, c0 as savedPatchOf, c1 as savedPatchView, c2 as savedPatchViews, c3 as severityLabel, c4 as startAttemptUsage, c5 as storedHandoff, c6 as subagentCostTitle, c7 as taskUsageSummary, c8 as tasksTotalText, c9 as usageLine, ca as usageText, cb as waitsForApproval, cc as withPatch, cd as worstSeverity } from './Task-BL4Idm9r.js';
-import { da as TurnBudgets, b4 as PlanIntake, ao as IWebFetcher, V as ConversationTurn, bj as PlannerModes, by as ResolveAll, dj as WebReadPolicy, dg as WebRead, dh as WebReadDecision, di as WebReadOptions, b0 as PendingApprovals, al as IAiService, ba as PlannerContextDeps, bb as PlannerContextStatus, M as ContextCondenseRequest, T as ConversationRequest, be as PlannerModelCandidate, bL as RunnerAuthExec, bK as RunnerAuth, b as AccountLimitBucket, c as AccountLimitSnapshot, t as AssignmentWriter, s as AssignmentScope, cS as TaskQueryCatalog, q as AssignmentCatalog, bO as RunnerCatalog, c6 as SessionMessage, b_ as SessionBroadcaster, c8 as SessionNotice, b8 as PlanStore, cM as TaskOrchestrator, at as IsolationRunController, aX as OrchestratorObserver, cB as TaskLogEvent, bx as ResearchTasks, an as INotification, ag as GlobalRunSettings, c1 as SessionHeld, c3 as SessionLease, bd as PlannerConversationHost, bc as PlannerConversation, aa as ExecutionCommand, F as CommandOutcome, a$ as PendingApproval, P as ConversationCompaction, bA as RewindTarget, bJ as RunView, bE as RunMergeView, bC as RunActivity, cP as TaskOutputSource, aw as LeaseHost, dd as UserSettings, aB as LiveTailOptions, aA as LiveTail, c7 as SessionMeta, bi as PlannerModelStore, bh as PlannerModelRecall } from './runSettingsText-DVOd7vKC.js';
-export { A as ACT_RISK, a as AUTORUN_RISK, d as AccountLimitStatus, e as AccountLimitWindow, f as AccountLimitsFrame, g as AccountLimitsMessage, h as AdoptSessionResponse, i as ApplyTaskOpsResult, j as ApprovalAnswerResponse, k as ApprovalBlock, l as ApprovalRequestMessage, m as ApprovalStatus, n as ApprovalsResponse, o as ApproveReviewResponse, p as AskOptions, r as AssignmentIssue, u as AutoMergeTrigger, B as BlockingSubject, C as CHAT_COMMANDS, v as CHECKPOINT_TRUNCATE_LENGTH, w as CancelPlanningResponse, x as CancelResumeResponse, y as CliAgentAiService, z as CliAgentAiServiceDeps, D as CommandBlock, E as CommandDescriptor, G as CommandPayload, H as CommandStatus, I as CommandsResponse, J as CompactionBlock, K as CompactionStatus, L as Consent, N as ConversationBusyError, O as ConversationCompactResponse, Q as ConversationEditError, R as ConversationForkResponse, S as ConversationInput, U as ConversationRewindResponse, W as ConversationView, X as DEFAULT_WEB_READ_BUDGET, Y as DaemonErrorCode, Z as DecideOptions, _ as DiffRow, $ as DiffRowKind, a0 as DiffStat, a1 as DisplayBlock, a2 as EMPTY_CONVERSATION, a3 as EMPTY_HOLD, a4 as EMPTY_RUN, a5 as EMPTY_TASK_LOG, a6 as EMPTY_TASK_LOG_FOLLOW, a7 as ErrorBody, a8 as ExecuteCommandResponse, a9 as ExecuteResponse, ab as ExecutionCommands, ac as ExecutionHost, ad as ExecutionSummary, ae as GatedConversation, af as GeneratePlanResponse, ah as HEADLESS_CLI_COMMANDS, ai as HandoffBlock, aj as HandoffForkRepo, ak as HandoffPeekSubject, am as IDLE_ACTIVITY, ap as IsolationDiffResponse, aq as IsolationMergeResponse, ar as IsolationPreviewNotice, as as IsolationPreviewResponse, au as LEASE_HEARTBEAT_MS, av as LEASE_STALE_MS, ax as LeaseHostKind, ay as LeaseHostOptions, az as LiveOutputLookup, aC as LocalEntry, aD as LoopCheckFacts, aE as LoopCheckState, aF as LoopGuard, aG as MappedTool, aH as MarkdownToken, aI as MergeGateEntry, aJ as MergeGateResponse, aK as MergeWordingHandoff, aL as MessageBlock, aM as MessageRole, aN as ModelsResponse, aO as NOT_STARTED, aP as NO_TURN, aQ as NewTaskFields, aR as NotificationAction, aS as OUTPUT_LINES_DEFAULT, aT as OUTPUT_LINES_MAX, aU as OkResponse, aV as OpRef, aW as OpRefusal, aY as OutputPreview, aZ as OverrideDirection, a_ as PLANNED_WITH_LABEL, b1 as PendingApprovalsOptions, b2 as PlanBlock, b3 as PlanBlocks, b5 as PlanMarkerStatus, b6 as PlanResponse, b7 as PlanSnapshot, b9 as PlannerCommandSyntax, bf as PlannerModelChoice, bg as PlannerModelMemory, bk as PlannerNotReady, bl as PlannerNotReadyError, bm as PlannerReadinessConfig, bn as PlannerSubmission, bo as PlannerTurnDiscardedError, bp as PlannerTurnStoppedError, bq as PlannerUsageLimitError, br as PrdResponse, bs as PromptHold, bt as REPORT_PREVIEW_LINES, bu as RUN_SETTINGS_DEFAULTS, bv as ReadRunnerAuthOptions, bz as ResolveConflictResponse, bB as RewindTargetsResponse, bD as RunInput, bF as RunSettingsError, bG as RunSnapshotFrame, bH as RunTask, bI as RunTaskStatus, bM as RunnerAuthExecOptions, bN as RunnerAuthExecResult, bP as RunnerLoadedBlock, bQ as RunnersResponse, bR as STOPPED_BEFORE_START, bS as SUPERVISOR_LEVELS, bT as SUPERVISOR_LEVEL_LABEL, bU as SerializedConversationMessage, bV as SerializedPendingTurn, bW as SerializedPlan, bX as SerializedTask, bY as SerializedTaskStatus, bZ as ServerInfoResponse, b$ as SessionData, c0 as SessionFrame, c2 as SessionHeldError, c4 as SessionLeaseRecord, c5 as SessionListResponse, c9 as SessionResponse, ca as SettingsResponse, cb as SettingsService, cc as SettingsUpdateResponse, cd as SkillInvocation, ce as SkillLoadBlock, cf as SkillToken, cg as StartAdmission, ch as StopResponse, ci as StreamStamp, cj as SubagentBlock, ck as SubagentChild, cl as SubagentStatus, cm as SupervisorPolicy, cn as SurfacePlan, co as SurfacePlanState, cp as SurfaceTask, cq as TASK_QUERY_ANSWER_MAX_CHARS, cr as TASK_QUERY_ANSWER_OR_OPS, cs as TASK_QUERY_FIELDS, ct as TASK_QUERY_PROTOCOL, cu as TASK_QUERY_REMINDER, cv as TERMINAL_UI_COMMANDS, cw as TakenPrompt, cx as TaskAction, cy as TaskAttemptSnapshot, cz as TaskLogAttemptsResponse, cA as TaskLogBatch, cC as TaskLogFollow, cD as TaskLogFollowInput, cE as TaskLogHeaderKind, cF as TaskLogHeaderTask, cG as TaskLogHeaderUsage, cH as TaskLogHeaderView, cI as TaskLogResponse, cJ as TaskLogView, cK as TaskMessageResponse, cL as TaskOp, cN as TaskOrchestratorDeps, cO as TaskOrchestratorOptions, cQ as TaskPlacement, cR as TaskQuery, cT as TaskQueryField, cU as TaskRef, cV as TaskRowAction, cW as TaskRowContext, cX as TaskRowHandoff, cY as TaskRowIsolation, cZ as TaskRowKind, c_ as TaskRowLoop, c$ as TaskRowPlacement, d0 as TaskRowSubject, d1 as TaskRowUsage, d2 as TaskRowView, d3 as TaskRunFacts, d4 as TaskStatusKind, d5 as ThinkingDisplayBlock, d6 as ToolBlock, d7 as ToolHeadline, d8 as ToolStatus, d9 as TreeTask, db as TurnGate, dc as UsageBlock, de as WAITS_FOR_APPROVAL_LABEL, df as WakeUpItem, dk as Worded, dl as WorkspacesResponse, dm as abbreviateHome, dn as accountLimitPercentText, dp as accountLimitWindowLabel, dq as accountLimitsOf, dr as accountLimitsText, ds as accountLimitsTitle, dt as aheadOfDraft, du as applyTaskOps, dv as approvalKindText, dw as approvalLabel, dx as approvalStatusText, dy as assignedRunnerOf, dz as assignmentIssue, dA as assignmentIssueText, dB as attachingLabel, dC as automergeSummary, dD as autorunSummary, dE as awaitingLabel, dF as blockNotice, dG as blockNotices, dH as blockedByLabel, dI as blockingFailures, dJ as canMergeTasks, dK as canSetDependencies, dL as canSplitTask, dM as capConflictFiles, dN as cardEditNeedsUnstarted, dO as cardEditable, dP as checkoutRule, dQ as classifyOutcome, dR as coalesceTaskLog, dS as compactionText, dT as confirmedOverride, dU as createAiService, dV as dependencyCandidates, dW as dependentsNotice, dX as dependentsOf, dY as describeHeld, dZ as describeHolder, d_ as describeIsolationPreview, d$ as describeMergeResult, e0 as describePlannerNotReady, e1 as diffRows, e2 as diffStat, e3 as diffSummary, e4 as digestTaskLog, e5 as drainNext, e6 as editableWhileRunning, e7 as executionSummary, e8 as followTaskLog, e9 as followTurn, ea as fromTranscript, eb as getSettingsPath, ec as handoffBaseLine, ed as handoffBranchName, ee as handoffFindingsText, ef as handoffPeekParts, eg as hasAccountLimits, eh as hasHiddenDetail, ei as hasLongReport, ej as holdLabel, ek as holdPrompt, em as isRepoGroup, en as isTaskRunning, eo as lastServedModel, ep as loadedSkillTokens, eq as logContinues, er as logResumes, es as loopBodyLabel, et as loopBodyRound, eu as loopCheckLabel, ev as loopCheckState, ew as loopLeaveNotice, ex as loopRowParts, ey as manualOverrideConfirmation, ez as manualOverrideStopFirst, eA as mapAgentTool, eB as markAction, eC as markdownHtml, eD as markdownTokens, eE as mergeOutcome, eF as mergeTarget, eG as namedRepos, eH as newTaskFields, eI as noExecutorRefusal, eJ as normalizeAgentArgs, eK as opRefusalText, eL as opsEditable, eM as outputLines, eN as outputPreview, eO as overrideNeedsConfirmation, eP as parseCount, eQ as parseSwitch, eR as parseTaskOpsJson, eS as parseTaskQueryJson, eT as pastGateConfirmation, eU as planBlocks, eV as planMarkerParts, eW as plannerMessage, eX as plannerNotReady, eY as plannerNotReadyFor, eZ as plannerTranscript, e_ as processLeaseHost, e$ as ranSealed, f0 as readRunnerAuth, f1 as receiptLabel, f2 as reconcileApprovals, f3 as recordRunnerAuth, f4 as recordedRunnerAuth, f5 as reduceConversation, f6 as reduceRun, f7 as reduceTaskLog, f8 as renderTaskQueryAnswer, f9 as repairedLanded, fa as repairedNotice, fb as repeatingChecks, fc as replayTaskLog, fd as repoBaseLine, fe as repoResultLines, ff as reposWithWork, fg as resetRunnerAuth, fh as resolveSkillInvocation, fi as resolveTaskRef, fj as resolveUserTaskRef, fk as resumeLabel, fl as resumeTime, fm as runHoldsEditors, fn as runSettingsOf, fo as runnerToolSubject, fp as scriptExitText, fq as scriptRunText, fr as secondsText, fs as serializePlan, ft as serializeTask, fu as serializeTaskStatus, fv as skillTokens, fw as skippedLabel, fx as stopTurn, fy as subtreeIds, fz as summarizeToolCall, fA as supervisorSummary, fB as surfacePlan, fC as surfacePlanState, fD as takeAt, fE as taskActionCommand, fF as taskChatAvailable, fG as taskLogCommands, fH as taskLogForSurface, fI as taskLogHeaderView, fJ as taskOrderLabel, fK as taskPlacement, fL as taskQuerySignature, fM as taskRef, fN as taskRefOf, fO as taskRowActions, fP as taskRowView, fQ as taskStartedNotice, fR as taskStatusKind, fS as textHasTaskOps, fT as textHasTaskQuery, fU as titledRefs, fV as titledTaskRef, fW as titledTaskRefOf, fX as toTaskLogEvent, fY as toolHeadline, fZ as trailerSummary, f_ as trimToolOutput, f$ as truncateCheckpointSummary, g0 as unsendAll, g1 as unsendLatest, g2 as wakeUpItems, g3 as walkPlan, g4 as withoutSealedMark, g5 as workspaceEnvOf } from './runSettingsText-DVOd7vKC.js';
-import { O as IConfig, P as IFileSystem, am as PlannerToolHandler, aj as PlannerShellSandbox, aw as ResearchShell, N as IApproval, au as ReadFileOpts, br as ToolOutcome, L as GrepOptions, b2 as ShellLaunch, K as GlobOptions, H as FindSymbolOptions, B as BashOptions, bm as TaskShellSite, bl as TaskShell, az as RuleWord, af as PlannerAllowlist, aW as ScriptBody, Q as IRunner, ag as PlannerBackendId, ap as ProviderModelLists, f as AiProvider, n as ApprovalModeSetting, aO as RunnerRegistry, aH as RunnerEnv, a8 as OrchestratorOption, d as AgentProcessDeps, bf as TaskModeAgentAdapter, e as AgentStartOptions, a as AgentAdapter, c as AgentEvent, aE as RunnerCommand$1, s as AttachState, k as ApprovalDecision, an as ProjectMcpServer, R as IRunnerSession, o as ApprovalPolicy, j as ApprovalAnswer, a9 as OrdewellMcpServer, bc as TaskCompleteArgs, aX as ScriptExit, t as CheckpointAnswer, b6 as StructuredTurnEnd, b5 as StructuredEvent, be as TaskMessageFrom, ar as QueuedTaskMessage, bn as TaskStartOptions, bo as TaskTokenScope, a0 as McpToolReply, bq as TaskWebReads, av as ReadTaskArgs, i as ApplyPatchArgs, aJ as RunnerManifest, bk as TaskRunnerFlags } from './IRunner-DOMtDTVt.js';
-export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, l as ApprovalKind, m as ApprovalMode, p as ApprovalPolicyOptions, q as ApprovalRequest, r as ApprovalSource, C as CatalogModel, u as CheckpointArgs, v as CommandClassification, w as CommandTier, x as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, y as DEFAULT_SCRIPT_TIMEOUT_MS, z as DENY_ALL, E as DiscoveryCommand, F as EditPlanArgs, G as FetchAllProviderModelsOptions, I as GIT_READONLY_SUBCOMMANDS, J as GREP_DEFAULT_HEAD_LIMIT, M as GrepOutputMode, S as InvokedCommand, T as LineBuffer, U as ListModelsArgs, V as ListRunnersArgs, W as LoadSkillArgs, X as McpClientConfig, Y as McpCredential, Z as McpRefusal, _ as McpTool, $ as McpToolContext, a1 as MessageTaskArgs, a2 as ModelCatalog, a3 as ModelShortcut, a4 as ORCHESTRATOR_SHORTCUTS, a5 as ORDEWELL_MCP_PATH, a6 as ORDEWELL_MCP_SERVER_NAME, a7 as OneTaskArgs, aa as OwnSealedRuns, ab as OwnerOnlyFile, ac as PLANNER_EXECUTION_TOOLS, ad as PLANNER_SANDBOX_DOCS, ae as PLANNER_TOOLS, ah as PlannerSandboxAvailability, ai as PlannerSandboxDeps, ak as PlannerStartOptions, al as PlannerTokenScope, ao as ProviderCredentialSource, aq as ProviderModelsResult, as as READ_ONLY_TASK_TOOLS, at as REFUSED_COMMANDS, ax as ResearchShellDeps, ay as RetryTaskArgs, aA as RunCommandArgs, aB as RunPlanArgs, aC as RunnerAuthSpec, aD as RunnerAuthStatus, aF as RunnerCommandKind, aG as RunnerEntry, aI as RunnerFeatures, aK as RunnerMcpServer, aL as RunnerMode, aM as RunnerModelDiscovery, aN as RunnerModelRef, aP as SEALED_LIMITS, aQ as SEARCH_EXCLUSIONS, aR as SandboxBackend, aS as SandboxInvocation, aT as SandboxLaunch, aU as SandboxLimits, aV as SandboxProfile, aY as ScriptFullOutput, aZ as ScriptRun, a_ as ScriptStatus, a$ as SealedAvailability, b0 as SealedRunOptions, b1 as ShellDialect, b3 as SpawnFn, b4 as StandingDecision, b7 as SubmitPlanArgs, b8 as TASK_COMPLETE_TOOL, b9 as TASK_COMPLETION_CONTRACT, ba as TASK_SEALED_LIMITS, bb as TASK_TOOLS, bd as TaskDiffArgs, bg as TaskModeUnsupportedError, bh as TaskOutputArgs, bi as TaskQueryArgs, bj as TaskRunCommandArgs, bp as TaskToolHandler, bt as approvalScopes, bu as classifyCommand, bv as clearPlannerSandboxCache, bw as clearResearchShellCache, bx as collectProviderCredentials, by as commandAllowedBy, bz as commandLine, bA as effectiveApprovalMode, bB as enabledRunners, bC as fetchAllProviderModels, bD as findRunnerCommand, bE as isGranted, bF as isRunnerApproval, bG as knownModelId, bH as mcpClientConfig, bI as ownerOnlyConfigFile, bJ as parseAllowlist, bK as parseApprovalModeSetting, bL as researchShellWarning, bM as researchToolsPath, bN as resolveModelShortcut, bO as resolvePlannerSandbox, bP as resolveProvider, bQ as resolveResearchShell, bR as scopeAllowed, bS as scriptBodyOf, bT as scriptBodyText, bU as scriptTaskText, bV as sharedMcpServer, bW as taskCompletionContract, bX as timeLimitText, bY as toApprovalDecision, bZ as toOrchestratorOptions, b_ as toolAllowed } from './IRunner-DOMtDTVt.js';
-import { R as RunnerModeInfo } from './ModeResolver-DyXeZ9ib.js';
-export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-DyXeZ9ib.js';
+import { b3 as RunnerId, aX as ResearchProgress, bG as UsageRecord, aW as ResearchLogEntry, bp as Task, p as DiscoveredModel, S as IIsolationPreview, T as IWorktreeIsolation, a6 as IsolationRemoval, af as IsolationTaskStatus, ag as IsolationView, ax as PlanIsolation, aj as LegacyPlanState, b4 as RunnerSessionCost, I as HandoffCheck, bn as SubtreeReport, d as ChildTaskCounts, bJ as VerificationCheck, aV as ReportedWindow, aG as PlannerUsage, o as DelegatedRow, bz as TaskSkillSnapshot, bk as SkillsService, at as NodeAuthority, q as ExecutionActor, am as Mandate, aq as MandateRequest, bA as TaskSnapshot, ay as PlanState, bI as Verdict, bl as StoredHandoff, b7 as ScriptBody } from './Task-CxGgN6I0.js';
+export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, c as BelowPlan, e as CommandWords, f as ContextCheckpoint, g as ContextFill, h as ConversationMessage, i as CostProvenance, D as DEFAULT_LOOP_ROUNDS, j as DEFAULT_PLANNER_ALLOWLIST, k as DEFAULT_RUNNERS, l as DEFAULT_SCRIPT_TIMEOUT_MS, m as DEFAULT_SUPERVISOR_RETRY_LIMIT, n as DIGEST_FINDINGS, E as EffectRules, r as ExecutionCommandName, s as ExecutionRecord, F as FLOOR_GRANTS, t as FindingSeverity, G as GRANTS, u as Grant, v as GuardTarget, w as GuardTrip, H as HANDOFF_LIMITS, x as HANDOFF_PUSH_CHARS, y as Handoff, z as HandoffArtifact, J as HandoffCommit, K as HandoffDigest, L as HandoffEvidence, M as HandoffFinding, N as HandoffLogs, O as HandoffPatch, P as HandoffPins, Q as HandoffPreviewOptions, R as HandoffTaskName, U as IntegrationDisposal, V as InvalidSkill, W as IsolationAvailability, X as IsolationHandoff, Y as IsolationHandoffRepo, Z as IsolationInactiveReason, _ as IsolationLandedTask, $ as IsolationLanding, a0 as IsolationMergeBlock, a1 as IsolationMergeBlockReason, a2 as IsolationMergeResult, a3 as IsolationOutcome, a4 as IsolationPreview, a5 as IsolationPruneResult, a7 as IsolationRepo, a8 as IsolationRepoRevert, a9 as IsolationRevertResult, aa as IsolationRevertTask, ab as IsolationRun, ac as IsolationTaskRecord, ad as IsolationTaskRef, ae as IsolationTaskRepo, ah as LandedTask, ai as LandedWork, ak as LoopSubject, al as MAX_LOOP_ROUNDS, an as MandateExclusions, ao as MandateLimits, ap as MandateRefusal, ar as ModelUsage, as as Narrowed, au as PatchFlag, av as PatchView, az as PlanStatus, aA as PlanUsage, aB as PlannerAllowlist, aC as PlannerCompaction, aD as PlannerCompactionOutcome, aE as PlannerContextPause, aF as PlannerResendState, aH as PrepareIntent, aI as PreparedTask, aJ as PreservedWork, aK as PreviewRepo, aL as PreviousWork, aM as REPORT_MAX_CHARS, aN as ROOT_NODE, aO as RefusedRemoval, aP as RepairEvidence, aQ as RepairWait, aR as ReplyRun, aS as RepoGroupLayout, aT as RepoHead, aU as ReportItem, aY as ResearchStep, aZ as ResearchStepOutcome, a$ as RevertCommand, b0 as RevertWatch, b1 as RootSettings, b2 as RunSettings, b5 as SEVERITY_LABEL, b6 as SHAPE_LIMITS, b8 as ScriptConsent, b9 as ScriptResult, ba as SessionBilling, bb as SetupFailure, bc as ShadowedSkill, bd as SkillAppliesTo, be as SkillCatalog, bf as SkillInfo, bg as SkillLoad, bh as SkillLoadNotice, bi as SkillMetadata, bj as SkillSource, bo as SupervisorLevel, bs as TaskEvidence, bt as TaskIsolation, bu as TaskIsolationState, bv as TaskLoop, bw as TaskModelAssignment, bB as TaskStatus, bC as TaskType, bD as TaskUsageSummary, bE as TreeSnapshot, bF as UsageLine, bH as UsageTotals, bK as WrittenTaskRef, bL as actorAuthority, bM as addAttemptUsage, bN as addModelUsage, bO as addPlannerUsage, bP as addUsage, bQ as addUsageTotals, bR as artifactLines, bS as betweenRounds, bT as boundedHandoffLines, bU as byteSize, bV as checkHandoff, bW as checkOf, bX as commandAllowedBy, bY as commandLine, bZ as contextMeterText, b_ as contextMeterTitle, b$ as costText, c0 as countedSessionCost, c1 as createEmptyPlan, c2 as createSkillsService, c3 as createTask, c4 as effectRuleFor, c5 as endAttemptUsage, c6 as findingLines, c7 as findingRefText, c8 as flattenTasks, c9 as flattenTasksWithParents, ca as formatCost, cb as formatTokenCount, cc as handoffDigest, cd as handoffLines, ce as handoffPreviewLines, cf as handoffReferenceText, cg as handoffWakeLines, ch as heldHandoff, ci as heldMandate, cj as heldWords, ck as inLoop, cl as isAwaitingReason, cm as isMeasured, cn as isSupervisorLevel, co as isUserMessage, cp as loopRemovalRefusal, cq as loopRoundOf, cr as mandateRefusalText, cs as migratePlanState, ct as modelCostTitle, cu as namedHandoff, cv as narrow, cw as nodeText, cx as openingLines, cy as outOfRounds, cz as parseAllowlist, cA as parseEffectAllowlist, cB as parseFindingRef, cC as parsePlanPath, cD as partedPromptUsage, cE as patchChangesText, cF as patchFlagText, cG as patchLines, cH as patchLinesText, cI as patchText, cJ as patchView, cK as pausedOnLimit, cL as pinReference, cM as planUsage, cN as plannerContextFill, cO as readableTaskIds, cP as rejoinPlanTree, cQ as removedAttempt, cR as resolveWrittenRef, cS as resumedSessionWindow, cT as rootAuthority, cU as rootMandate, cV as savedPatchOf, cW as savedPatchView, cX as savedPatchViews, cY as scopeAllowed, cZ as scriptBodyOf, c_ as scriptBodyText, c$ as scriptTaskText, d0 as severityLabel, d1 as spentTokens, d2 as startAttemptUsage, d3 as storedHandoff, d4 as subagentCostTitle, d5 as taskUsageSummary, d6 as tasksTotalText, d7 as timeLimitText, d8 as toolAllowed, d9 as usageLine, da as usageText, db as waitsForApproval, dc as withPatch, dd as wordsFrom, de as worstSeverity } from './Task-CxGgN6I0.js';
+import { V as IConfig, W as IFileSystem, aE as PlannerToolHandler, ay as PlannerModes, aB as PlannerShellSandbox, aP as ResearchShell, U as IApproval, aN as ReadFileOpts, bO as ToolOutcome, Q as GrepOptions, bn as ShellLaunch, P as GlobOptions, M as FindSymbolOptions, B as BashOptions, bJ as TaskShellSite, bI as TaskShell, Z as IRunner, ax as PlannerBackendId, aI as ProviderModelLists, f as AiProvider, n as ApprovalModeSetting, b6 as RunnerRegistry, a_ as RunnerEnv, aq as OrchestratorOption, d as AgentProcessDeps, bB as TaskModeAgentAdapter, e as AgentStartOptions, a as AgentAdapter, c as AgentEvent, aX as RunnerCommand$1, s as AttachState, k as ApprovalDecision, aG as ProjectMcpServer, _ as IRunnerSession, bs as StructuredTurnEnd, br as StructuredEvent, bA as TaskMessageFrom, aK as QueuedTaskMessage, by as TaskCompleteArgs, x as CheckpointAnswer, be as ScriptExit, af as McpToolReply, X as ILogger, Y as INotification, bG as TaskRunnerConfig, a1 as IsolationRunController, o as ApprovalPolicy, J as EventStore, j as ApprovalAnswer, ap as OpenLease, aF as PostArgs, aO as ReadTaskArgs, ar as OrdewellMcpServer, bK as TaskStartOptions, bL as TaskTokenScope, bN as TaskWebReads, i as ApplyPatchArgs, b5 as RunnerPlacement, b0 as RunnerManifest, bH as TaskRunnerFlags } from './eventStore-CTCSKS9E.js';
+export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, l as ApprovalKind, m as ApprovalMode, p as ApprovalPolicyOptions, q as ApprovalRequest, r as ApprovalSource, C as CatalogModel, y as CheckpointArgs, z as ChildSessionPlace, D as CommandClassification, E as CommandTier, F as ConsoleLogger, G as DENY_ALL, H as DiscoveryCommand, I as EditPlanArgs, L as FetchAllProviderModelsOptions, N as GIT_READONLY_SUBCOMMANDS, O as GREP_DEFAULT_HEAD_LIMIT, R as GrepOutputMode, $ as InvokedCommand, a6 as LineBuffer, a7 as ListModelsArgs, a8 as ListRunnersArgs, a9 as LoadSkillArgs, aa as McpClientConfig, ab as McpCredential, ac as McpRefusal, ad as McpTool, ae as McpToolContext, ag as MessageTaskArgs, ah as ModelCatalog, ai as ModelShortcut, ak as NotificationAction, al as ORCHESTRATOR_SHORTCUTS, am as ORDEWELL_MCP_PATH, an as ORDEWELL_MCP_SERVER_NAME, ao as OneTaskArgs, as as OwnSealedRuns, at as OwnerOnlyFile, au as PLANNER_EXECUTION_TOOLS, av as PLANNER_SANDBOX_DOCS, aw as PLANNER_TOOLS, az as PlannerSandboxAvailability, aA as PlannerSandboxDeps, aC as PlannerStartOptions, aD as PlannerTokenScope, aH as ProviderCredentialSource, aJ as ProviderModelsResult, aL as READ_ONLY_TASK_TOOLS, aM as REFUSED_COMMANDS, aQ as ResearchShellDeps, aS as RetryTaskArgs, aT as RunCommandArgs, aU as RunPlanArgs, aV as RunnerAuthSpec, aW as RunnerAuthStatus, aY as RunnerCommandKind, aZ as RunnerEntry, a$ as RunnerFeatures, b1 as RunnerMcpServer, b2 as RunnerMode, b3 as RunnerModelDiscovery, b4 as RunnerModelRef, b7 as SEALED_LIMITS, b8 as SEARCH_EXCLUSIONS, b9 as SandboxBackend, ba as SandboxInvocation, bb as SandboxLaunch, bc as SandboxLimits, bd as SandboxProfile, bf as ScriptFullOutput, bg as ScriptRun, bh as ScriptStatus, bi as SealedAvailability, bj as SealedRunOptions, bk as SessionData, bl as SessionMeta, bm as ShellDialect, bp as SpawnFn, bq as StandingDecision, bt as SubmitPlanArgs, bu as TASK_COMPLETE_TOOL, bv as TASK_COMPLETION_CONTRACT, bw as TASK_SEALED_LIMITS, bx as TASK_TOOLS, bz as TaskDiffArgs, bC as TaskModeUnsupportedError, bD as TaskOutputArgs, bE as TaskQueryArgs, bF as TaskRunCommandArgs, bM as TaskToolHandler, bS as approvalScopes, bT as classifyCommand, bU as clearPlannerSandboxCache, bV as clearResearchShellCache, bW as collectProviderCredentials, bX as defaultLogger, bY as deleteSession, bZ as effectiveApprovalMode, b_ as enabledRunners, b$ as fetchAllProviderModels, c0 as findRunnerCommand, c1 as getLatestSession, c2 as idSegment, c3 as isGranted, c4 as isRunnerApproval, c5 as knownModelId, c6 as listChildSessions, c7 as listSessions, c8 as loadChildSession, c9 as loadSession, ca as loadSessionPlanState, cb as mcpClientConfig, cc as ownerOnlyConfigFile, cd as parseApprovalModeSetting, ce as plannerToolSet, cf as researchShellWarning, cg as researchToolsPath, ch as resolveModelShortcut, ci as resolvePlannerSandbox, cj as resolveProvider, ck as resolveResearchShell, cl as saveChildSession, cm as saveSession, cn as sessionDataDir, co as sharedMcpServer, cp as taskCompletionContract, cq as taskToolSet, cr as toApprovalDecision, cs as toOrchestratorOptions, ct as toolListing } from './eventStore-CTCSKS9E.js';
+import { dw as TurnBudgets, be as PlanIntake, ay as IWebFetcher, X as ConversationTurn, bH as ResolveAll, dF as WebReadPolicy, dC as WebRead, dD as WebReadDecision, dE as WebReadOptions, ba as PendingApprovals, aw as IAiService, bk as PlannerContextDeps, bl as PlannerContextStatus, O as ContextCondenseRequest, V as ConversationRequest, bo as PlannerModelCandidate, bY as RunnerAuthExec, bX as RunnerAuth, b as AccountLimitBucket, c as AccountLimitSnapshot, u as AssignmentWriter, t as AssignmentScope, d7 as TaskQueryCatalog, r as AssignmentCatalog, b$ as RunnerCatalog, cj as SessionMessage, cc as SessionBroadcaster, ck as SessionNotice, bi as PlanStore, d1 as TaskOrchestrator, ac as Escalation, b5 as OrchestratorObserver, cS as TaskLogEvent, ce as SessionHeld, cs as SlotPool, a$ as NodeBudget, bG as ResearchTasks, ar as GlobalRunSettings, cg as SessionLease, bn as PlannerConversationHost, bm as PlannerConversation, cz as SubplannerBrief, al as ExecutionCommand, H as CommandOutcome, b9 as PendingApproval, du as TreeLedger, z as Carved, a_ as NodeBoard, cA as Subtree, R as ConversationCompaction, bN as RewindTarget, bW as RunView, da as TaskRevertPreview, bR as RunMergeView, bP as RunActivity, d4 as TaskOutputSource, aF as LeaseHost, d3 as TaskOrchestratorOptions, dz as UserSettings, aK as LiveTailOptions, aJ as LiveTail, bs as PlannerModelStore, br as PlannerModelRecall } from './runSettingsText-lKLDsyli.js';
+export { A as ACT_RISK, a as AUTORUN_RISK, d as AccountLimitStatus, e as AccountLimitWindow, f as AccountLimitsFrame, g as AccountLimitsMessage, h as AdoptSessionResponse, i as AnswerEscalationRequest, j as ApplyTaskOpsResult, k as ApprovalAnswerResponse, l as ApprovalBlock, m as ApprovalRequestMessage, n as ApprovalStatus, o as ApprovalsResponse, p as ApproveReviewResponse, q as AskOptions, s as AssignmentIssue, v as AutoMergeTrigger, B as BlockingSubject, C as CHAT_COMMANDS, w as CHECKPOINT_TRUNCATE_LENGTH, x as CancelPlanningResponse, y as CancelResumeResponse, D as CliAgentAiService, E as CliAgentAiServiceDeps, F as CommandBlock, G as CommandDescriptor, I as CommandPayload, J as CommandStatus, K as CommandsResponse, L as CompactionBlock, M as CompactionStatus, N as Consent, P as ConversationBusyError, Q as ConversationCompactResponse, S as ConversationEditError, T as ConversationForkResponse, U as ConversationInput, W as ConversationRewindResponse, Y as ConversationView, Z as DEFAULT_WEB_READ_BUDGET, _ as DELEGATION_OFFERED, $ as DELEGATION_RISK, a0 as DaemonErrorCode, a1 as DecideOptions, a2 as DiffRow, a3 as DiffRowKind, a4 as DiffStat, a5 as DisplayBlock, a6 as EMPTY_CONVERSATION, a7 as EMPTY_HOLD, a8 as EMPTY_RUN, a9 as EMPTY_TASK_LOG, aa as EMPTY_TASK_LOG_FOLLOW, ab as ErrorBody, ad as EscalationInput, ae as EscalationKind, af as EscalationOption, ag as EscalationOptionId, ah as EscalationRun, ai as EscalationsResponse, aj as ExecuteCommandResponse, ak as ExecuteResponse, am as ExecutionCommands, an as ExecutionHost, ao as ExecutionSummary, ap as GatedConversation, aq as GeneratePlanResponse, as as HEADLESS_CLI_COMMANDS, at as HandoffBlock, au as HandoffForkRepo, av as HandoffPeekSubject, ax as IDLE_ACTIVITY, az as IsolationDiffResponse, aA as IsolationMergeResponse, aB as IsolationPreviewNotice, aC as IsolationPreviewResponse, aD as LEASE_HEARTBEAT_MS, aE as LEASE_STALE_MS, aG as LeaseHostKind, aH as LeaseHostOptions, aI as LiveOutputLookup, aL as LocalEntry, aM as LoopCheckFacts, aN as LoopCheckState, aO as LoopGuard, aP as MappedTool, aQ as MarkdownToken, aR as MergeGateEntry, aS as MergeGateResponse, aT as MergeWordingHandoff, aU as MessageBlock, aV as MessageRole, aW as ModelsResponse, aX as NOT_STARTED, aY as NO_TURN, aZ as NewTaskFields, b0 as OUTPUT_LINES_DEFAULT, b1 as OUTPUT_LINES_MAX, b2 as OkResponse, b3 as OpRef, b4 as OpRefusal, b6 as OutputPreview, b7 as OverrideDirection, b8 as PLANNED_WITH_LABEL, bb as PendingApprovalsOptions, bc as PlanBlock, bd as PlanBlocks, bf as PlanMarkerStatus, bg as PlanResponse, bh as PlanSnapshot, bj as PlannerCommandSyntax, bp as PlannerModelChoice, bq as PlannerModelMemory, bt as PlannerNotReady, bu as PlannerNotReadyError, bv as PlannerReadinessConfig, bw as PlannerSubmission, bx as PlannerTurnDiscardedError, by as PlannerTurnStoppedError, bz as PlannerUsageLimitError, bA as PrdResponse, bB as PromptHold, bC as REPORT_PREVIEW_LINES, bD as RUN_SETTINGS_DEFAULTS, bE as ReadRunnerAuthOptions, bI as ResolveConflictResponse, bJ as RevertPreviewTask, bK as RevertRefusal, bL as RevertRefusalReason, bM as RevertScope, bO as RewindTargetsResponse, bQ as RunInput, bS as RunSettingsError, bT as RunSnapshotFrame, bU as RunTask, bV as RunTaskStatus, bZ as RunnerAuthExecOptions, b_ as RunnerAuthExecResult, c0 as RunnerLoadedBlock, c1 as RunnersResponse, c2 as STALLED_LABEL, c3 as STOPPED_BEFORE_START, c4 as STOPPING_LABEL, c5 as SUPERVISOR_LEVEL_LABEL, c6 as SerializedConversationMessage, c7 as SerializedPendingTurn, c8 as SerializedPlan, c9 as SerializedTask, ca as SerializedTaskStatus, cb as ServerInfoResponse, cd as SessionFrame, cf as SessionHeldError, ch as SessionLeaseRecord, ci as SessionListResponse, cl as SessionResponse, cm as SettingsResponse, cn as SettingsService, co as SettingsUpdateResponse, cp as SkillInvocation, cq as SkillLoadBlock, cr as SkillToken, ct as StartAdmission, cu as StopResponse, cv as StreamStamp, cw as SubagentBlock, cx as SubagentChild, cy as SubagentStatus, cB as SubtreeItemView, cC as SubtreeView, cD as SurfacePlan, cE as SurfacePlanState, cF as SurfaceTask, cG as TASK_QUERY_ANSWER_MAX_CHARS, cH as TASK_QUERY_ANSWER_OR_OPS, cI as TASK_QUERY_FIELDS, cJ as TASK_QUERY_PROTOCOL, cK as TASK_QUERY_REMINDER, cL as TERMINAL_UI_COMMANDS, cM as TakenPrompt, cN as TaskAction, cO as TaskActivity, cP as TaskAttemptSnapshot, cQ as TaskLogAttemptsResponse, cR as TaskLogBatch, cT as TaskLogFollow, cU as TaskLogFollowInput, cV as TaskLogHeaderKind, cW as TaskLogHeaderTask, cX as TaskLogHeaderUsage, cY as TaskLogHeaderView, cZ as TaskLogResponse, c_ as TaskLogView, c$ as TaskMessageResponse, d0 as TaskOp, d2 as TaskOrchestratorDeps, d5 as TaskPlacement, d6 as TaskQuery, d8 as TaskQueryField, d9 as TaskRef, db as TaskRevertPreviewResponse, dc as TaskRowAction, dd as TaskRowContext, de as TaskRowDelegated, df as TaskRowHandoff, dg as TaskRowIsolation, dh as TaskRowKind, di as TaskRowLoop, dj as TaskRowPlacement, dk as TaskRowSubject, dl as TaskRowUsage, dm as TaskRowView, dn as TaskRunFacts, dp as TaskStatusKind, dq as ThinkingDisplayBlock, dr as ToolBlock, ds as ToolHeadline, dt as ToolStatus, dv as TreeTask, dx as TurnGate, dy as UsageBlock, dA as WAITS_FOR_APPROVAL_LABEL, dB as WakeUpItem, dG as Worded, dH as WorkspacesResponse, dI as abbreviateHome, dJ as accountLimitPercentText, dK as accountLimitWindowLabel, dL as accountLimitsOf, dM as accountLimitsText, dN as accountLimitsTitle, dO as activityLabel, dP as aheadOfDraft, dQ as applyTaskOps, dR as approvalKindText, dS as approvalLabel, dT as approvalStatusText, dU as assignedRunnerOf, dV as assignmentIssue, dW as assignmentIssueText, dX as attachingLabel, dY as automergeSummary, dZ as autorunSummary, d_ as awaitingLabel, d$ as blockNotice, e0 as blockNotices, e1 as blockedByLabel, e2 as blockingFailures, e3 as canMergeTasks, e4 as canSetDependencies, e5 as canSplitTask, e6 as capConflictFiles, e7 as cardEditNeedsUnstarted, e8 as cardEditable, e9 as checkoutRule, ea as classifyOutcome, eb as closeTurn, ec as coalesceTaskLog, ed as compactionText, ee as confirmedOverride, ef as createAiService, eg as delegatedRowView, eh as delegationSummary, ei as dependencyCandidates, ej as dependentsNotice, ek as dependentsOf, el as describeHeld, em as describeHolder, en as describeIsolationPreview, eo as describeMergeResult, ep as describePlannerNotReady, eq as diffRows, er as diffStat, es as diffSummary, et as digestTaskLog, eu as drainNext, ev as editableWhileRunning, ew as elapsedSince, ex as escalations, ey as executionSummary, ez as followTaskLog, eA as followTurn, eB as formatElapsed, eC as fromTranscript, eD as getSettingsPath, eE as handoffBaseLine, eF as handoffBranchName, eG as handoffFindingsText, eH as handoffPeekParts, eI as hasAccountLimits, eJ as hasHiddenDetail, eK as hasLongReport, eL as holdLabel, eM as holdPrompt, eO as isRepoGroup, eP as isTaskRunning, eQ as lastServedModel, eR as loadedSkillTokens, eS as logContinues, eT as logResumes, eU as loopBodyLabel, eV as loopBodyRound, eW as loopCheckLabel, eX as loopCheckState, eY as loopLeaveNotice, eZ as loopRowParts, e_ as manualOverrideConfirmation, e$ as manualOverrideStopFirst, f0 as mapAgentTool, f1 as markAction, f2 as markdownHtml, f3 as markdownTokens, f4 as mergeOutcome, f5 as mergePastChecksConfirmation, f6 as mergeTarget, f7 as namedRepos, f8 as newTaskFields, f9 as noExecutorRefusal, fa as normalizeAgentArgs, fb as opRefusalText, fc as opsEditable, fd as outputLines, fe as outputPreview, ff as overrideNeedsConfirmation, fg as parseCount, fh as parseDelegation, fi as parseSwitch, fj as parseTaskOpsJson, fk as parseTaskQueryJson, fl as pastGateConfirmation, fm as planBlocks, fn as planMarkerParts, fo as plannerMessage, fp as plannerNotReady, fq as plannerNotReadyFor, fr as plannerTranscript, fs as processLeaseHost, ft as ranSealed, fu as readRunnerAuth, fv as receiptLabel, fw as reconcileApprovals, fx as recordRunnerAuth, fy as recordedRunnerAuth, fz as reduceConversation, fA as reduceRun, fB as reduceTaskLog, fC as renderTaskQueryAnswer, fD as repairWaitLabel, fE as repairedLanded, fF as repairedNotice, fG as repeatingChecks, fH as replayTaskLog, fI as repoBaseLine, fJ as repoResultLines, fK as reposWithWork, fL as resetRunnerAuth, fM as resolveSkillInvocation, fN as resolveTaskRef, fO as resolveUserTaskRef, fP as resumeLabel, fQ as resumeTime, fR as revertEffect, fS as revertListLine, fT as revertTaskRef, fU as runHoldsEditors, fV as runSettingsOf, fW as runnerToolSubject, fX as scriptExitText, fY as scriptRunText, fZ as secondsText, f_ as serializePlan, f$ as serializeTask, g0 as serializeTaskStatus, g1 as skillTokens, g2 as skippedLabel, g3 as stopTurn, g4 as subtreeIds, g5 as subtreeView, g6 as summarizeToolCall, g7 as supervisorSummary, g8 as surfacePlan, g9 as surfacePlanState, ga as takeAt, gb as taskActionCommand, gc as taskActivity, gd as taskChatAvailable, ge as taskLogCommands, gf as taskLogForSurface, gg as taskLogHeaderView, gh as taskOrderLabel, gi as taskPlacement, gj as taskQuerySignature, gk as taskRef, gl as taskRefOf, gm as taskRowActions, gn as taskRowView, go as taskStartedNotice, gp as taskStatusKind, gq as textHasTaskOps, gr as textHasTaskQuery, gs as titledRefs, gt as titledTaskRef, gu as titledTaskRefOf, gv as toTaskLogEvent, gw as toolHeadline, gx as trailerSummary, gy as trimToolOutput, gz as truncateCheckpointSummary, gA as unsendAll, gB as unsendLatest, gC as wakeUpItems, gD as walkPlan, gE as withoutSealedMark, gF as workspaceEnvOf } from './runSettingsText-lKLDsyli.js';
+import { R as RunnerModeInfo } from './ModeResolver-B64aUZXJ.js';
+export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-B64aUZXJ.js';
 import { WorkerOptions, Worker } from 'worker_threads';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
@@ -14,6 +14,7 @@ import 'zod/v4';
 type GitExecFn = (file: string, args: string[], opts: {
     cwd?: string;
     env: NodeJS.ProcessEnv;
+    input?: string;
 }) => Promise<{
     stdout: string;
     stderr: string;
@@ -635,61 +636,6 @@ interface VersionCheck {
  */
 declare function startVersionCheck(options: VersionCheckOptions): VersionCheck;
 
-/**
- * The effect allowlist (ADR-0035): the user's standing approval for named
- * effects, beside the planner allowlist, which names reads. It pre-approves a
- * script task whose `commands` are all covered; it never covers a `script`
- * body, whose shell text no rule can be matched against.
- *
- * A rule is matched against the whole command, every word in order and flags
- * included, because an effect's flags change what it does: `git push origin
- * feature/*` covers `git push origin feature/login`, never the same push with
- * `--force`. `*` stands for one word, or inside a word for any run of
- * characters, as in the planner allowlist, except that it never stands for
- * what changes the effect: a flag (`--force`, and `/force` on Windows), a
- * refspec's force or delete (`+main`, `:main`), or a `:` outside a URL
- * (`feature/x:main`, which pushes to `main`). The rule writes any of those
- * itself. A rule spells out its operation before any `*`, so
- * `az webapp config * set` is no rule at all.
- *
- * Exclusions are the planner allowlist's `!` entries, with any `!` entry
- * written here; an exclusion wins. A command exclusion is matched as the
- * planner allowlist matches it; a path or URL exclusion holds for an argument
- * that names an absolute path or URL it covers, whole or after a `=`, `@`,
- * `:` or `,` or a short flag (`--url=…`, `-d @…`). A relative path is not
- * resolved, since the body does not say where it runs. A program named by its
- * path is a file the repository ships (ADR-0026), so it is never covered.
- * There are no built-in rules: a default would pre-approve an effect the user
- * never chose.
- */
-interface EffectRule {
-    text: string;
-    binary: string;
-    words: RuleWord[];
-}
-interface EffectRules {
-    rules: EffectRule[];
-    exclusions: PlannerAllowlist;
-    platform: NodeJS.Platform;
-    /** The entries that are no rule, each with the warning that says why it is ignored. */
-    ignored: {
-        rule: string;
-        warning: string;
-    }[];
-}
-/**
- * `entries` are the effect allowlist's; `plannerEntries` the planner allowlist
- * in force, whose `!` entries hold here too; `platform` the one the commands
- * run on, which decides how a flag is spelled and how a path resolves.
- */
-declare function parseEffectAllowlist(entries: readonly string[], plannerEntries?: readonly string[], platform?: NodeJS.Platform): EffectRules;
-/**
- * The rules, by name, that cover every command of a `commands` body, or null
- * when one command is not covered, an exclusion holds for one, or the body is
- * a `script`.
- */
-declare function effectRuleFor(list: EffectRules, body: ScriptBody): string | null;
-
 /**
  * Carries a structured task's tool requests to the session's one approval
  * seam (ADR-0018, A1), so a runner's request is answered through
@@ -946,6 +892,7 @@ declare abstract class BaseConfig implements IConfig {
     get approvalDefaults(): boolean;
     get approvalPreApproved(): string[];
     get effectAllowlist(): string[];
+    get notifyCommand(): string[];
     /**
      * Who plans when no surface setting names a planner: an explicit
      * AI_PROVIDER, then a vendor whose key is in the environment,
@@ -1029,6 +976,8 @@ interface WorktreeIsolationDeps {
     config: Pick<IConfig, 'worktreeIsolation' | 'worktreeSetupCommand' | 'workspaceRepos' | 'worktreeLinks'>;
     /** Test seam: every git invocation goes through this. */
     execFileImpl?: GitExecFn;
+    /** Every git call of this isolation runs with hooks off: what it lands came from a container (ADR-0059 L6). */
+    noHooks?: boolean;
     resolvePath?: () => Promise<string>;
     platform?: NodeJS.Platform;
     mintRunId?: () => string;
@@ -1039,6 +988,15 @@ interface WorktreeIsolationDeps {
 declare function createIsolationPreview(deps: Pick<WorktreeIsolationDeps, 'config' | 'execFileImpl' | 'resolvePath'>): IIsolationPreview;
 declare function createWorktreeIsolation(deps: WorktreeIsolationDeps): IWorktreeIsolation;
 
+/**
+ * What deleting a root owes its children (ADR-0055 D11): `deleteSession` removes
+ * files and no worktree, and a child's run is named only by a file that goes
+ * with the root's, so each is discarded first as Session's `discardRun` does.
+ * Unlanded work is kept on a branch; what git could not let go is in `refused`,
+ * for the caller to stop on while the records still name it.
+ */
+declare function discardChildRuns(rootSessionId: string, baseDir: string, isolation: Pick<IWorktreeIsolation, 'discard'>): Promise<IsolationRemoval>;
+
 /** A task record as ADR-0013 persisted it, for one repository. */
 interface Adr0013TaskRecord {
     taskId: string;
@@ -1084,14 +1042,6 @@ declare function isolationViewOfPlan(plan: unknown, repairLimit?: number): Isola
 /** Select runner configuration that can run code or redirect a launch from paths relative to the directory the runner starts in. */
 declare function repositoryRunnerConfigPaths(paths: readonly string[]): string[];
 
-interface ILogger {
-    warn(scope: string, message: string, err?: unknown): void;
-}
-declare class ConsoleLogger implements ILogger {
-    warn(scope: string, message: string, err?: unknown): void;
-}
-declare const defaultLogger: ILogger;
-
 /** What a Gemini planner is built with beyond its config. */
 interface GeminiServiceDeps extends PlannerContextDeps {
     turnBudgets?: TurnBudgets;
@@ -1820,6 +1770,8 @@ declare const ORDEWELL_SETTABLE_ENV: readonly string[];
  *   off, so every later command runs unprompted; the web-read budget bounds
  *   how much a planner may send out unasked in Full; the effect allowlist
  *   pre-approves script tasks that change real systems (ADR-0035).
+ * - The notify command is a program Ordewell starts as the user, with no
+ *   approval, on every new escalation (ADR-0053).
  * - The settings-path override is honoured by the settings service, which
  *   creates directories recursively when persisting — admitting it turns the
  *   same write into an arbitrary-path file write.
@@ -1866,6 +1818,8 @@ interface RunnerCommand {
      * workspace's, for a runner whose value merges into one of them.
      */
     env?: (workspace: Record<string, string>) => Record<string, string>;
+    /** Paths on this host, named in `args`, that the process reads, for a placement to bring along (ADR-0059 L5). */
+    files?: readonly string[];
     /**
      * Names this launch must not inherit from the host or the workspace — the
      * credentials a native-shell planner keeps out of its process (ADR-0036 N2.2).
@@ -1898,6 +1852,8 @@ declare class RunnerProcess {
     private exitReported;
     private stderrTail;
     private spawnEnv;
+    /** What a lease launched in this process's place, where one did (ADR-0059 L5). */
+    private placed;
     /** Stdout readers' end-of-stream flushes, for an end the pipe itself never reports. */
     private readonly stdoutEnds;
     constructor(deps: AgentProcessDeps);
@@ -1949,6 +1905,7 @@ declare class RunnerProcess {
      */
     dispose(): void;
     private end;
+    private placedEnded;
     private appendStderr;
 }
 
@@ -2057,6 +2014,8 @@ interface SpawnSpec {
     env?: Record<string, string>;
     /** Names the launch must not inherit from the host or the workspace (ADR-0036 N2.2). */
     envDrop?: (name: string) => boolean;
+    /** Paths on this host, named in `args`, that the process reads. */
+    files?: readonly string[];
 }
 /**
  * Shared plumbing for the agents that speak newline-delimited JSON over stdio.
@@ -2239,6 +2198,8 @@ declare class ClaudeCodeAdapter extends StdioAgentAdapter implements TaskModeAge
     private mainModel;
     /** What the plan should say the task runs: its spawn's model, then each switch followed. */
     private followedModel;
+    /** The MCP configuration this process reads, on this host. */
+    private configFile;
     /**
      * Model commands sent through the chat whose switch has not been seen yet,
      * oldest first, each with the turns still to end before its own has. Several
@@ -3044,6 +3005,8 @@ declare class PlannerBackend {
 type ModelsByRunner = Partial<Record<RunnerId, DiscoveredModel[]>>;
 interface SessionCatalogDeps {
     config: Pick<IConfig, 'enabledRunners' | 'autonomousMode' | 'aiProvider'>;
+    /** Whether a task's mode defaults to its runner's autonomous one: a child's mandate says, the config's level unless set (ADR-0056 M6). */
+    autonomous?: () => boolean;
     registry: Pick<RunnerRegistry, 'getManifest'>;
     modelResolver: Pick<ModelResolver, 'modelsForRunners' | 'getCachedRunnerModels'>;
     /** Read at each call: a toggle or allowlist edit made since the session was built counts (#69). */
@@ -3070,6 +3033,7 @@ declare class SessionCatalog {
     private readonly deps;
     private discovered;
     constructor(deps: SessionCatalogDeps);
+    private autonomous;
     /** The runners enabled right now. */
     enabledRunners(): RunnerId[];
     /** The runners `writer` may put a task on now ({@link assignableRunners}); undefined means any. */
@@ -3146,6 +3110,291 @@ declare class SessionCatalog {
     }>;
 }
 
+/** 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 stop(): Promise<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, from?: TaskMessageFrom): 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 commands(): RunnerCommand$1[];
+    abstract invokeCommand(name: string, args?: string): string;
+    abstract answerPermission(id: string, decision: ApprovalDecision): boolean | Promise<boolean>;
+    abstract onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
+    abstract onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
+    abstract onScriptExit(listener: (exit: ScriptExit) => void): void;
+}
+declare abstract class AbstractRunner<S extends IRunnerSession> implements IRunner {
+    protected sessions: Map<string, S>;
+    get activeCount(): number;
+    /** A session winding down stays registered until it exits, so a second stop gets the same wind-down. */
+    stop(sessionId: string): Promise<void>;
+    stopAll(): void;
+    protected registerSession(id: string, session: S): void;
+    abstract spawn(opts: RunnerSpawnOptions): Promise<IRunnerSession>;
+}
+
+/** Why a node may do nothing more, and the status that ends it with (ADR-0056 M5, M8). */
+interface NodeEnd {
+    why: string;
+    ends: 'blocked' | 'failed';
+}
+/** What a parent reads of a child (ADR-0055 D6), all of it read afresh from the child's plan and run. */
+interface NodeState {
+    /** What keeps a `done` from being taken, in the words of a refusal; empty once the run has settled and landed. */
+    unfinished: readonly string[];
+    /** Tasks that finished with a pass. */
+    completed: number;
+    /** An attempt is live, or a run is opening or merging. */
+    live: boolean;
+    /** A planner turn holds the conversation, or waits for it. */
+    plannerBusy: boolean;
+    /** Something gathered for the subplanner will open a turn by itself. */
+    wakeOwed: boolean;
+    /** Why this node stops now, or null: what ends it with no call of its own. */
+    stoppedFor: NodeEnd | null;
+    /** Why nothing may start here though what is in flight may finish, or null (ADR-0056 M10). */
+    withdrawn: string | null;
+    /** Why what is ready cannot start, with nothing live to free room: its subplanner is told first, and it ends `blocked` if nothing comes of that (ADR-0056 M5). */
+    startRefused: string | null;
+    /** One line per task, as a derived report lists them. */
+    tasks: readonly {
+        label: string;
+        status: Task['status'];
+    }[];
+}
+/** A subplanner's report once Ordewell has read what it names (ADR-0057 R2). */
+type TakenReport = TaskCompleteArgs & {
+    subtree?: SubtreeReport;
+};
+/** The child, as its attempt drives it: nothing of the Session it is, or of a surface. */
+interface ChildNode {
+    readonly sessionId: string;
+    /** Its protected paths, its ancestors' with them (ADR-0056 M4). */
+    readonly protectedPaths: readonly string[];
+    /** The time it has to run in (ADR-0056 M3). */
+    readonly wallClockMs: number | null;
+    /** How much of the time since `since` its tree is held on a usage limit, which is not on its clock (M3). */
+    heldSince(since: number): number;
+    startPlanning(goal: string): Promise<unknown>;
+    continueConversation(text: string): Promise<unknown>;
+    /** Reopened (ADR-0055 D17): acts as Execute there, and its subplanner goes on with `text`; one that never wrote a plan plans `goal`. */
+    goOn(text: string, goal: string): Promise<unknown>;
+    /** A line for the subplanner's next turn, which opens none (ADR-0057 R6): a landing is no reason to wake it. */
+    hear(line: string): void;
+    state(): NodeState;
+    /** A report held to its plan and subtree, its references pinned and what crosses a level read verbatim (ADR-0057 R1, R2). */
+    takeReport(report: TaskCompleteArgs): HandoffCheck<TakenReport>;
+    /** End its subtree (D16). Resolves once nothing of it is left, however long that takes. */
+    halt(): Promise<void>;
+    /** Let its Session go, and what it did not spend return (ADR-0056 M5). */
+    close(): Promise<void>;
+}
+/** What a subplanner's token calls and what its Session tells of itself, bound to one attempt (ADR-0055 D5). */
+interface SubplannerLink {
+    taskComplete(report: TaskCompleteArgs): Promise<McpToolReply>;
+    checkpoint(question: string): McpToolReply;
+    /** Something changed that a verdict or the completion reminder may read. */
+    changed(): void;
+    /** A Stop stands over this node, its own or an ancestor's (ADR-0055 D16). */
+    stopped(): boolean;
+    /** What its planner or a task spent, as it arrives: charged where it was spent, and rolled up to each level for its row (ADR-0055 D20). */
+    usage(record: UsageRecord): void;
+}
+/** The parent, as a child's attempt needs it. */
+interface ChildHost {
+    /**
+     * Carve the child's mandate and budget, and build it in `cwd` (ADR-0056 M4,
+     * M5), or the child `reopening` from its saved file (ADR-0055 D17). Rejects,
+     * naming the level, for what cannot be carved.
+     */
+    openChild(task: Task, cwd: string, link: SubplannerLink, reopening?: string): Promise<ChildNode>;
+    /** What the delegated task's branch changed since its base, relative to the workspace root. */
+    changedPaths(taskId: string): Promise<string[]>;
+    /** A Stop stands over this node: what its children read of their ancestors (D16). */
+    stopped(): boolean;
+    /** Usage on its way up the tree, past this level's row. */
+    passUp(record: UsageRecord): void;
+    /** A child's tasks moved, so the row of its delegated task is stale (ADR-0055 D20). */
+    moved(): void;
+}
+interface ChildPlanSetup {
+    task: Task;
+    cwd: string;
+    host: ChildHost;
+    /** A Continue (ADR-0055 D17): the child it reopens, and what its parent says to it. */
+    resume?: {
+        sessionId: string;
+        message: string;
+    };
+}
+/**
+ * One attempt of a delegated task (ADR-0055 D3): a child Session in its
+ * worktree, behind the runner seam, so to its parent a subplanner is a runner.
+ * The attempt has one turn, from its start to its verdict, whatever the
+ * subplanner's own turns: `onTurnEnd` fires when the child ends, so ADR-0018's
+ * waiting for input and completion reminder are not read off them. This reads
+ * those turns itself, since nobody below the root waits for input (ADR-0056 M8).
+ *
+ * `task_complete` is the only way to a pass, and a subplanner saying done is
+ * necessary and never sufficient: this holds it to D6 at the call.
+ */
+declare class ChildPlanSession extends AbstractRunnerSession {
+    private readonly setup;
+    private readonly events;
+    private readonly turnEnds;
+    private readonly completes;
+    private node;
+    private output;
+    /** Turns this opened and has not seen end: until they do, a quiet child is one still opening. */
+    private opening;
+    private reminded;
+    /** The accepted call, until it is published. */
+    private accepted;
+    /** How the attempt raises a question: as a runner's `checkpoint` does, so the parent's task waits as any task at one. */
+    private ask;
+    /** A question went up and has no answer: nothing is stuck, and only the wall clock ends the wait (ADR-0056 M8). */
+    private asking;
+    /** The attempt has its end: nothing after it counts. */
+    private ended;
+    private halting;
+    /** The Stop, recorded before anything is ended (D16): it is this attempt's, so a later attempt starts clear of it. */
+    private tombstone;
+    /** The child opening, which a Stop waits for: it cannot end what it has not got. */
+    private seating;
+    private checkQueued;
+    private graceTimer;
+    private wallClock;
+    private printed;
+    /** Where the child's tasks stood when its row last heard of them. */
+    private counts;
+    private stopping;
+    private markGone;
+    private readonly gone;
+    constructor(id: string, taskId: string, setup: ChildPlanSetup);
+    /** Whoever spawned it attaches its listeners when the spawn resolves, so the child starts a macrotask later. */
+    begin(): void;
+    private run;
+    /** Read again as it runs out, so a hold found meanwhile moves it on (ADR-0056 M3). */
+    private watchClock;
+    /** A turn this opened: its end is one a check reads, and a failure in it ends the attempt, since no person reads it (ADR-0056 M8). */
+    private opened;
+    private turnSettled;
+    private queueCheck;
+    /**
+     * What the child's state owes its attempt. Read after every change, so no
+     * state of a child can sit with nothing to end it (ADR-0056 M8).
+     */
+    private check;
+    /** The node stops as a Stop does, and the attempt ends once it has (ADR-0056 M3, M5). */
+    private haltFor;
+    /** A report nobody wrote, since no one is left to: only what the plan and run show, for the plan above to decide on. */
+    private derived;
+    /** The child's activity, as this attempt's log shows it (ADR-0055 D20): what a task became, not what its runner said. */
+    private say;
+    /** In its output and its log alike: what a person opens the task to read is this. */
+    private print;
+    /**
+     * The subplanner's `task_complete`, on the token bound to this attempt. D6's
+     * first two tests refuse at the call and leave the attempt open; a protected
+     * path fails the verdict instead, since that work cannot be taken back here.
+     * `blocked` and `failed` are taken at any time: that is how a subtree gives up.
+     */
+    private taskComplete;
+    /**
+     * The subplanner's question: it goes up as a checkpoint of this attempt, and
+     * the call answers at once. Its answer opens the next turn, and a question
+     * withdrawn with the attempt opens none.
+     */
+    private checkpoint;
+    /** Why a `done` cannot be taken now, naming what is unfinished (D6: 1, 2). */
+    private doneRefusal;
+    /** The changes on the branch since its base, against every level's paths (D3, ADR-0056 M4): the one check of the work itself. */
+    private protectedPathsTouched;
+    /**
+     * What its branch changed past the scope its parent declared (ADR-0056 M7),
+     * for the parent to decide: scopes are advisory, so this goes in the report
+     * and refuses nothing. A read-only task lands nothing to say this of.
+     */
+    private outsideScope;
+    private publish;
+    /** An end no subplanner reported: its handoff is what the plan and run show, and the verdict comes from there. */
+    private end;
+    private emitEvent;
+    /**
+     * A tombstone first (ADR-0055 D16): every start under it reads this at once,
+     * before anything has stopped. Then the child goes as an attempt's runner
+     * does: its subtree ended, leaves first, then its Session let go, while its
+     * parent can still read the lease it depends on (D13), and what it did not
+     * spend returned (ADR-0056 M5). Resolves when all of that is done, with no
+     * timeout of its own: a runner's grace is the runner's (ADR-0018).
+     */
+    stop(): Promise<void>;
+    private wind;
+    kill(): void;
+    /** Where its child's tasks stand, as last read; absent before the first read and once the child has gone. */
+    progress(): ChildTaskCounts | undefined;
+    getOutput(): string;
+    /** Nothing reads a child's input but a message. */
+    write(): void;
+    /** One turn from its start to its verdict (D3). */
+    turnState(): 'working' | 'idle';
+    onTurnEnd(listener: (reason: StructuredTurnEnd) => void): void;
+    onEvent(listener: (event: StructuredEvent) => void): void;
+    /** A parent's message opens the subplanner's next turn (D3); Ordewell's own line waits for one. */
+    sendMessage(text: string, from?: TaskMessageFrom): string;
+    forceSend(text: string): string;
+    forceSendQueued(): boolean;
+    removeQueued(): boolean;
+    queued(): QueuedTaskMessage[];
+    /** A child has no one turn to interrupt: Stop ends it. */
+    interrupt(): Promise<void>;
+    /** What a restart names (D3): the child session, not a runner's. */
+    nativeSessionId(): string | null;
+    commands(): RunnerCommand$1[];
+    invokeCommand(): string;
+    answerPermission(): boolean;
+    onTaskComplete(listener: (report: TaskCompleteArgs, refuted?: VerificationCheck) => void): void;
+    /** A subplanner asks by its own token, not its attempt's, and this is how that question reaches the attempt. */
+    onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
+    onScriptExit(): void;
+}
+/**
+ * Starts delegated tasks' attempts (ADR-0055 D3), as a runner starts a coding
+ * agent's and the script runner a body, so the claim, the log, the verdict and
+ * the landing meet one the way they meet any task. A separate process later is
+ * a second `IRunner`, not a redesign.
+ */
+declare class ChildPlanRunner extends AbstractRunner<ChildPlanSession> {
+    private readonly host;
+    private spawned;
+    constructor(host: ChildHost);
+    /** Every child's stop, for a node that waits on its subtree. */
+    stopEvery(): Promise<void>;
+    /** Where the tasks of the child `taskId` runs stand, or nothing with no child live. */
+    progressOf(taskId: string): ChildTaskCounts | undefined;
+    spawn(opts: RunnerSpawnOptions): Promise<IRunnerSession>;
+}
+
 /**
  * A model's context window from a catalog Ordewell already holds — a runner's
  * own model listing or a provider's own models endpoint, never a table kept in
@@ -3219,17 +3468,24 @@ interface SessionEventRelayDeps {
     broadcast: SessionBroadcaster;
     /** Where isolation notices go, for a host whose notifications are not seen by the user. */
     onNotice?: (notice: SessionNotice) => void;
-    store: Pick<PlanStore, 'allTasks' | 'snapshot'>;
-    orchestrator: Pick<TaskOrchestrator, 'getIdleSince' | 'getCompletionReceipt' | 'getToolsAttaching' | 'getQueuedTaskMessages' | 'getMergeGate' | 'holdReason' | 'runMergeView' | 'activity'>;
-    runs: Pick<IsolationRunController, 'taskIsolation'>;
+    store: Pick<PlanStore, 'allTasks' | 'planTasks' | 'snapshot' | 'statusMark'>;
+    orchestrator: Pick<TaskOrchestrator, 'judgingOnce' | 'getIdleSince' | 'getCompletionReceipt' | 'getToolsAttaching' | 'getQueuedTaskMessages' | 'getMergeGate' | 'holdReason' | 'loopStranded' | 'runMergeView' | 'activity' | 'taskIsolation'>;
     /** Shared with the Session, which snapshots, restores and clears it. */
     usage: PlannerUsageLedger;
+    /** What a subplanner's budget hears of each planner call (ADR-0056 M5); absent at the root, which is charged nothing. */
+    spent?: (record: UsageRecord) => void;
     /** How many of a task's runner requests wait for an answer (ADR-0018, A1). */
     awaitingApproval?: (taskId: string) => number;
     /** What a task's waiting checkpoint asks, whole. */
     checkpointQuestion?: (taskId: string) => string | undefined;
+    /** A delegated task's row (ADR-0055 D20). */
+    delegation?: (taskId: string) => DelegatedRow | undefined;
     /** The task waits for the user's approval to start (ADR-0035). */
     waitsForApproval?: (taskId: string) => boolean;
+    /** What waits on a person now (ADR-0053). */
+    escalations?: () => Escalation[];
+    /** The list as a status update carried it, for what must see each one with no surface attached. */
+    escalationsSent?: (list: readonly Escalation[]) => void;
 }
 /**
  * Every orchestrator event the relay announces. `onTaskSettled` is persistence
@@ -3255,13 +3511,31 @@ declare class SessionEventRelay {
     private readonly onNotice?;
     private readonly store;
     private readonly orchestrator;
-    private readonly runs;
     private readonly usage;
+    private readonly spent;
     private readonly awaitingApproval;
     private readonly checkpointQuestion;
     private readonly waitsForApproval;
+    private readonly delegation;
+    private readonly escalations;
+    private readonly escalationsSent;
     private statusHeld;
     private statusOwed;
+    /** The second a status update opened: until it ends, one that can wait does. */
+    private statusWindow;
+    /** Something changed that the last status update did not carry, and it can wait for {@link statusWindow} to end. */
+    private statusDue;
+    /** The ids of what waits on a person, as the last status update carried it. */
+    private sentWaits;
+    /** {@link statusWindow} has sent a change to what waits on a person: the next change waits for it to end. */
+    private waitsSent;
+    /** The ids of the work a merge is offered on, as the last status update carried it. */
+    private sentLanded;
+    /** {@link statusWindow} has sent a change to that work: the next change waits for it to end. */
+    private landedSent;
+    /** The run as {@link statusChanged} last read it. */
+    private lastMoved;
+    private livePlan;
     /** The planner's requests announced and not yet settled, as they were announced: a surface joining now is owed them. */
     private readonly announced;
     /** The planner compaction started and not yet ended, as it was announced: a surface joining now is owed it too. */
@@ -3269,11 +3543,52 @@ declare class SessionEventRelay {
     constructor(deps: SessionEventRelayDeps);
     /** `plan` is read per event: a Session with no plan (or mid-reset) announces nothing about tasks. */
     observer(plan: () => LegacyPlanState | null): RelayObserver;
+    /** A delegated task's row moved: it can wait for the window, as usage does. */
+    rowsMoved(plan: LegacyPlanState | null): void;
+    /** Send every task's status now, whatever was sent a moment ago: for what a surface must not wait for. */
     status(plan: LegacyPlanState | null): void;
+    /**
+     * Send what is owed before something that assumes it arrived: a surface
+     * treats `execution_complete` as the end of the stream, for one, and a
+     * status update coming after it is one it may never read. Called from
+     * outside any observer too, and a surface that failed fails nothing else.
+     */
+    flushStatus(plan: LegacyPlanState | null): void;
+    /** Nothing goes out for this Session again: what was held back goes now. */
+    closeStatus(plan: LegacyPlanState | null): void;
+    /** A run's progress is at most a second late, so a thousand runners reporting cost a surface one update. */
+    private statusCanWait;
+    /**
+     * The list of what waits on a person (ADR-0053) is a judgement of the plan,
+     * so it is read only when something it reads has moved: a task's status, or
+     * whether the run is moving. An ending that leaves nobody anything to do, or
+     * a start, moves nothing in it, and a fan-out or a wave of verdicts stays
+     * one update a second.
+     */
+    private statusChanged;
+    /**
+     * The first change to what waits on a person goes out at once, and the rest
+     * wait for the second to end: every update carries every wait, so a hundred
+     * tasks failing together must not each send the plan with all those before
+     * them. The notifier reads the list as it goes out, so it is told of them
+     * then, each once.
+     */
+    private waitsMayHaveChanged;
+    /**
+     * A task in a worktree reports its landing twice and its release once, and
+     * every update carries every task, so a wide run must not send the plan per
+     * report. What a person acts on still goes first: new work to merge, like a
+     * new wait, goes at once, and the rest waits for the second to end.
+     */
+    private isolationChanged;
+    private openStatusWindow;
     /** Every task's status as it stands, in the message a status update carries. */
     statusMessage(): Extract<SessionMessage, {
         type: 'status_update';
     }>;
+    private judgedStatus;
+    /** A {@link holdStatus} is running: whoever runs it saves as it ends. */
+    get holdingStatus(): boolean;
     /**
      * Run `op` with status broadcasts held back. Store ops signal the observer
      * as they go, which would put a status_update on the wire before the
@@ -3298,10 +3613,14 @@ declare class SessionEventRelay {
     progress(progress: ResearchProgress): void;
 }
 
-/** Which session's logs, in which workspace. */
+/**
+ * Which session's logs, under which state root. A child's says which root it
+ * sits under: a session id alone finds a root's (ADR-0055 D11).
+ */
 interface TaskLogLocation {
     baseDir: string;
     sessionId: string;
+    rootSessionId?: string;
 }
 /** One attempt's file, open for appending. */
 interface TaskLogFile {
@@ -3391,6 +3710,52 @@ interface TaskEditOptions {
     requireUnstarted?: boolean;
 }
 
+/** Runs the command with `env` added to its environment; rejects when it fails. */
+type NotifyRun = (command: readonly string[], env: Record<string, string>) => Promise<void>;
+interface EscalationNotifierDeps {
+    /** The user's command, read as each new escalation appears; empty when there is none. */
+    command: () => readonly string[];
+    run: NotifyRun;
+    log: (message: string) => void;
+}
+/**
+ * Tells the user's notify command of each new escalation, once (ADR-0053). It
+ * sees the list as it goes out, so nothing here is a second reading of the run,
+ * and it remembers only ids, in memory: what a run waits on stays derived.
+ * Nothing it does reaches the run: the command is started and left, and a
+ * failure ends here. A few run at a time and the rest wait in a bounded queue,
+ * so an id dropped from a full queue still counts as told: it stays on the list.
+ */
+declare class EscalationNotifier {
+    private readonly deps;
+    /** The ids told of in this plan; null while a plan changes hands. */
+    private told;
+    private failureLogged;
+    private dropLogged;
+    private running;
+    private readonly queue;
+    constructor(deps: EscalationNotifierDeps);
+    /** The list as a status update carries it. */
+    changed(list: readonly Escalation[]): void;
+    /**
+     * A plan is on its way out, and nothing it says now is news: a run stopped
+     * by leaving its session raises waits nobody is there for. Lasts until the
+     * next {@link baseline}, so a plan on its way in says nothing either.
+     */
+    hush(): void;
+    /** What waits as a plan is adopted counts as told, so a restart does not send what was sent before it. */
+    baseline(list: readonly Escalation[]): void;
+    private tell;
+    private send;
+    private failed;
+    private dropped;
+}
+/**
+ * A command as the user wrote it: a whole argument vector, or none. A string is
+ * refused, not split, because splitting one is a shell's job and there is none.
+ */
+declare function notifyCommandOf(value: unknown): string[];
+
 /**
  * Options for plan generation. Progress is not overridable: every planner
  * progress event is translated to a SessionMessage inside the Session and
@@ -3410,6 +3775,10 @@ interface SessionRuntimeSettings {
     run?: GlobalRunSettings;
     /** Whether an API planner compacts its own context before a call that would not fit; absent means on. */
     plannerAutoCompaction?: boolean;
+    /** What a task runner loads of the user's own setup; absent means all of it. */
+    taskRunnerConfig?: TaskRunnerConfig;
+    /** The `containers` setting, as written; absent means local worktrees (ADR-0059 L4). */
+    containers?: unknown;
 }
 declare function sessionRuntimeSettings(settings: UserSettings): SessionRuntimeSettings;
 /** Where a fork landed: the new session's id, and what adopting it needs. */
@@ -3422,8 +3791,29 @@ interface ConversationFork {
 interface ConversationRewind extends ConversationFork {
     rewoundMessage: string;
 }
-/** Writes one plan to the saved-session store: {@link saveSession}'s shape, injected so tests never touch disk. */
+/** Writes one plan to the saved-session store: {@link saveSession}'s shape, injected so tests never touch disk. `workspace` is the state root. */
 type SaveSession = (plan: LegacyPlanState, goal: string, workspace: string, sessionId: string) => void;
+/**
+ * Where a child session sits in its tree, handed out by the parent's
+ * {@link Session.hostChild}. Its code root is its `workspaceRoot`, a delegated
+ * task's worktree, which goes with that task; what must outlive that goes here.
+ */
+interface ChildPlacement {
+    /** The id it saves under, which the parent's run record names. */
+    sessionId: string;
+    /** The root Session's workspace, at every depth (ADR-0055 D11). */
+    stateRoot: string;
+    /** The root Session's id: a child's state sits under that session's. */
+    rootSessionId: string;
+    /** Who holds the tree, as the root's lease says (D13). */
+    held: () => SessionHeld | null;
+    /** Its parent's, so one repository's worktree bookkeeping takes one lock across the tree (D11). */
+    isolation: IWorktreeIsolation;
+    /** The root's, so the tree shares one Parallel limit (D18). */
+    pool: SlotPool;
+    /** Its side of the tree's ledger, once a carve gave it one (ADR-0056 M5). */
+    budget?: NodeBudget;
+}
 /**
  * Everything a delivery surface constructs to host a session. Structural config
  * (orchestratorModel, providerModelLists) is snapshotted inside `config` at
@@ -3503,6 +3893,33 @@ interface SessionDeps {
         cache?: WebResponseCache;
         searchProvider?: ISearchProvider;
     };
+    /** What runs the user's notify command (ADR-0053); the real process unless a test supplies one. */
+    runNotifyCommand?: NotifyRun;
+    /** Where its sessions run (ADR-0059), given the local worktrees: those, unless a test supplies another. */
+    execution?: TaskOrchestratorOptions['execution'];
+    /** The node this session is, below the root (ADR-0056); absent, it is the root, whose mandate its settings hold. */
+    child?: NodeAuthority;
+    /** Where this session sits below the root (ADR-0055 D11, D13); absent, its workspace is both its code root and its state root. */
+    placement?: ChildPlacement;
+    /** Where a root's tree keeps its log (ADR-0058 S3): a file in that root's directory, unless a test supplies another. */
+    eventLog?: (rootSessionId: string, stateRoot: string) => EventStore;
+    /** How this session answers to its parent's attempt, as a subplanner (ADR-0055 D5); absent at the root. */
+    subplanner?: SubplannerLink;
+    /** What this child was given to do, for its prompt. */
+    brief?: SubplannerBrief;
+    /** Whether a planner may write a delegated task here; the build's own switch (ADR-0055 D21) unless a test sets it. */
+    delegationOffered?: boolean;
+    /** What a test puts in a child's deps, in place of what a real child is built with. */
+    childDeps?: (task: Task) => Partial<SessionDeps>;
+}
+/** A session built under a parent's attempt: what {@link Session.openChild} seats and carves, and what the parent hands it. */
+interface ChildSpec {
+    task: Task;
+    cwd: string;
+    placement: ChildPlacement;
+    authority: NodeAuthority;
+    brief: SubplannerBrief;
+    link: SubplannerLink;
 }
 /**
  * The composition root: builds every collaborator a Session drives and wires
@@ -3529,6 +3946,8 @@ interface SessionParts {
     /** The orchestrator's own: Session reads the run and acts on it there, Merge all aside. */
     runs: IsolationRunController;
     events: SessionEventRelay;
+    /** Told by the Session when a plan changes hands; what it sees comes from the relay. */
+    escalationNotifier: Pick<EscalationNotifier, 'hush' | 'baseline'>;
     usage: PlannerUsageLedger;
     /** The windows every stream of the session reports, saved with the plan. */
     windows: SessionWindows;
@@ -3543,6 +3962,17 @@ interface SessionParts {
     lease: (onLost: (held: SessionHeld) => void) => SessionLease;
     /** The conversation's host is the Session itself, so only the Session can make it. */
     conversation: (host: PlannerConversationHost) => PlannerConversation;
+    /** The node this session is, below the root. */
+    child?: NodeAuthority;
+    /** Where it sits below the root. */
+    placement?: ChildPlacement;
+    eventLog: (rootSessionId: string, stateRoot: string) => EventStore;
+    subplanner?: SubplannerLink;
+    brief?: SubplannerBrief;
+    runnerConfig: () => TaskRunnerConfig | undefined;
+    delegationOffered: boolean;
+    childPlans: Pick<ChildPlanRunner, 'stopEvery' | 'activeCount' | 'progressOf'>;
+    childSession: (spec: ChildSpec) => Session;
 }
 /**
  * The per-session execution stack — the lifecycle owner. Owns plan
@@ -3562,6 +3992,7 @@ declare class Session {
     private readonly usage;
     private readonly windows;
     private readonly events;
+    private readonly escalationNotifier;
     private readonly planner;
     private readonly orchestrator;
     private readonly runs;
@@ -3570,6 +4001,7 @@ declare class Session {
     private readonly catalog;
     private plan;
     private goal;
+    /** The code root: what its planner and runners read and git works in. See {@link stateRoot} for Ordewell's own files. */
     private workspace;
     private readonly broadcast;
     /**
@@ -3608,23 +4040,62 @@ declare class Session {
     private saveRefusedFor;
     /** User controls in flight; see {@link withSave}. */
     private controlsInFlight;
+    /** A save is owed, for the end of {@link SAVE_INTERVAL_MS}; see {@link saveSoon}. */
+    private saveTimer;
+    /** The store's status mark as last saved, or as loaded. */
+    private savedStatuses;
+    /** The user was told the disk is refusing this session's saves, and none has landed since. */
+    private saveFailureSaid;
     /** A whole-plan start opening; a second Execute joins it rather than resetting the run under it. */
     private runOpening;
     private unsubObserver;
+    /** This session's node below the root; undefined at the root, where a person remains. */
+    private readonly child;
+    private readonly placement;
+    private readonly authority;
+    /** Opens the root's log; only a first carve, or a reopen of a tree, asks. */
+    private readonly eventLog;
+    /** How this session answers to its parent's attempt; undefined at the root (ADR-0055 D5). */
+    private readonly subplanner;
+    private readonly brief;
+    private readonly runnerConfig;
+    private readonly delegationOffered;
+    private readonly childPlans;
+    private readonly childSession;
+    /** This node's side of the tree's ledger; undefined at the root, which is charged nothing (ADR-0056 M5). */
+    private readonly budget;
+    /** The tree's ledger, once something asked: a flat run never does, so it has none and writes no log (ADR-0058 S3). */
+    private tree;
+    /** The lines this plan's landings owe its running tasks (ADR-0057 R6). */
+    private readonly scopeLines;
+    /** The subplanner was told a start was refused; a raise makes it news again (ADR-0056 M5). */
+    private toldStartRefused;
+    /** The opening behind {@link tree}, and the session it opened for. */
+    private treeOpening;
+    /** The ledger let go, which the next opening reads after. */
+    private treeClosing;
     private readonly hostSessionId?;
     private currentSessionId;
     private readonly skillsService;
     private readonly conversation;
     private readonly turns;
+    /** The planner turn's execution lease, while one runs. */
+    private turnLease;
+    /** An opening waiting for a slot: it takes one when the pool has it. True when there was one to tell. */
+    private roomWaiter;
     /** Destroyed: a turn that waited for the planner to be found must not open on it. */
     private closed;
     /** Destroyed and let go of its lease for good: whatever settles later neither saves nor holds the session. */
     private leaseReleased;
+    /** Settles once a destroyed Session's lease has gone. */
+    private departed;
     /**
      * Turns PlanTurns does not open, waiting at the planner gate, each ended
      * with why it must not open: a Stop, a newer goal, or its plan scope ending.
      */
     private readonly openingsWaiting;
+    /** The installed-planner probe a turn was parked on and the surfaces were told of; null once it answered. */
+    private detection;
     /** The conversation's opening, from admission until its turn settles; see {@link behindOpening}. */
     private opening;
     private readonly editor;
@@ -3643,13 +4114,38 @@ declare class Session {
      * tools come here; see {@link ExecutionCommands}.
      */
     execute(command: ExecutionCommand, actor: ExecutionActor): Promise<CommandOutcome>;
+    /** What will not move without a person, derived afresh from the plan, the run and the pending approvals (ADR-0053). */
+    escalations(): Escalation[];
+    private judgedEscalations;
+    /** What holds a merge nobody asked for here, as a list or a refusal names it (ADR-0055 D9). */
+    private mergeHold;
+    /** The user's answer to an escalation; see {@link ExecutionCommands.answerEscalation}. `raiseTokens` goes with an Approve of a delegated task (ADR-0056 M5). */
+    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean, raiseTokens?: number): Promise<CommandOutcome>;
     /** Run one planner turn with its own {@link TurnEffects}, which only a turn that lands hands back. */
     private openTurn;
+    /** Each failed task, with the attempt that failed. */
+    private failedTasks;
+    /**
+     * What a run this actor begins leaves failed. The fresh chance is the user's
+     * to ask for (ADR-0053), and a supervisor's `run_plan` is a retry its guards
+     * count (ADR-0029), so only autorun and a planner leave any; autorun only what
+     * failed in the reply it follows (ADR-0030).
+     */
+    private failuresLeftBy;
     /**
      * Autorun (ADR-0030): a plan the planner submitted in the turn that just
      * ended starts as if the user had pressed Execute, through the seam, so the
      * timeline says autorun started it. Read now, not when the turn opened: the
-     * switch is the user's to flip at any time.
+     * switch is the user's to flip at any time. Work already live, a task the
+     * planner started with `run_task` in that turn, joins it as one scheduled
+     * run, in Full; the seam keeps it out of live work in Guarded. A scheduled
+     * run has the plan's tasks, waiting on a person or a reset or not, so autorun
+     * skips it, and starts nothing over what a usage limit holds: a restart
+     * would take back that run's pause and failures (ADR-0053).
+     * A plan it could not start says why, and a Stop since the plan was submitted
+     * withdraws the start as it withdraws any (ADR-0029), unless a run opened
+     * after that Stop has the plan already. What failed in that turn stays
+     * failed: the fresh chance is the user's to ask for (ADR-0053).
      */
     private autorunSubmitted;
     /**
@@ -3685,6 +4181,7 @@ declare class Session {
      * oscillation guard.
      */
     private changeScope;
+    private get delegates();
     /** A line from Ordewell itself, kept in the transcript where it happened. */
     private systemNote;
     /** A message to the user in the supervisor's voice, kept in the transcript where it happened. */
@@ -3701,7 +4198,20 @@ declare class Session {
     runSettings(): GlobalRunSettings;
     /** The user's run settings as they stand for this session (ADR-0030). */
     private userRunSettings;
-    /** A call at the seam, in the transcript where it happened and on every surface at once. */
+    /** What this node may do without a person, as it stands now (ADR-0056 M1): derived at the root, and never saved. */
+    mandate(): Mandate;
+    /** Why this child's script may not land what it does unsealed, as the rules stand now: an effect withdrawn since it landed goes with them (ADR-0056 M9). */
+    unsealedRefusal(task: Readonly<Task>): string | null;
+    /** Each value where it lives today; the level is the caller's to name (ADR-0056 M1). */
+    private rootSettings;
+    private effectRules;
+    /** Whether this node's tasks default to their runner's autonomous mode. */
+    private autonomous;
+    /**
+     * A call at the seam, in the transcript where it happened and on every
+     * surface at once. The call has happened by now, so a failed save is said
+     * rather than thrown: a Stop that took must not answer as refused.
+     */
     private recordExecution;
     /** Whether the user approved this task to run; see {@link ApprovalRecord.isApproved}. */
     isApproved(taskId: string): boolean;
@@ -3726,6 +4236,10 @@ declare class Session {
     plannerCompaction(): Extract<SessionMessage, {
         type: 'planner_compaction';
     }> | undefined;
+    /** Whether a planner turn waits on the installed-planner probe, for a surface that joins or reconnects meanwhile. */
+    plannerDetection(): Extract<SessionMessage, {
+        type: 'planner_detection';
+    }>;
     /** Scopes the user granted this session — surfaced so a UI can show what is already allowed. */
     approvedScopes(): string[];
     /** The stable id this session persists under — matches the host's id when one was provided. */
@@ -3735,10 +4249,160 @@ declare class Session {
      * can re-probe it before a turn without keeping a second copy.
      */
     get workspaceRoot(): string;
+    /**
+     * Where this session's own files live: its workspace, unless it is a child,
+     * whose code root goes with a worktree (ADR-0055 D11). Git and the planner
+     * read {@link workspaceRoot}; a save, a log and the lease read this.
+     */
+    private get stateRoot();
     /** The planner this session's own gate reads — not whatever the host's config says now. */
     get plannerProvider(): PlannerBackendId;
     /** Where this session's structured task logs are saved (ADR-0018, P1). */
     get taskLogLocation(): TaskLogLocation;
+    /**
+     * Seat a child session in a task's worktree: what `createSession` builds it
+     * with, its code root being that worktree. The task's record names it, so a
+     * reopen does not prune the worktree from under it (ADR-0055 D17), and asking
+     * again finds the same child. Every depth shares the root's state root,
+     * lease and isolation (D11, D13). Throws for a task with no worktree (D12).
+     */
+    hostChild(taskId: string): ChildPlacement;
+    /** The root Session's id, under which a tree's state sits (ADR-0055 D11). */
+    get rootSessionId(): string;
+    /**
+     * Take the planner turn's lease (ADR-0059 L1), kept from its admission to
+     * its end, however many times it takes the conversation. False when the pool
+     * has no slot for a subplanner's turn: it keeps this Session, and calls
+     * {@link turnRoomFreed}.
+     */
+    private turnRoom;
+    private turnRefusal;
+    /** The pool has a slot for the turn it refused: the opening waiting for one, or else the next of the queue. */
+    turnRoomFreed(): void;
+    /** Where a planner's process starts, opened around its adapter (ADR-0059 L1). No lease: nothing has a turn to start it for. */
+    openTurnLease(signal: AbortSignal): Promise<OpenLease> | undefined;
+    /**
+     * The turn is over. A subplanner between turns holds no process: it is a
+     * parked row, its adapter gone and its session id kept, so the next turn
+     * resumes it (ADR-0055 D18). A turn's own corrective retries come before
+     * this, in the one process, and its slot goes only once that process has.
+     */
+    private endTurnLease;
+    /**
+     * A goal or a compaction refused after {@link plannerTurnMayOpen} let it in:
+     * no turn opened, so nothing else would end it, and the slot it took would
+     * stay out of the tree's pool (ADR-0055 D18). A turn holding the lease by
+     * then is its own to end.
+     */
+    private dropUnopenedTurn;
+    /**
+     * The tree's ledger, opened from the log if nothing has yet. A Continue asks
+     * before {@link hostChild}, whose placement names a child's node only once
+     * this has answered. A flat run has no reason to ask.
+     */
+    ledger(): Promise<TreeLedger>;
+    /** The root's ledger is let go with its session; a child's stays its root's. */
+    private closeTree;
+    /**
+     * The tree as it stands, with the root's limit where the user keeps it. Read
+     * as a carve or a raise is asked for, so a raised setting reaches them.
+     */
+    private currentTree;
+    /**
+     * A child's mandate and budget, carved from what this node has left
+     * (ADR-0056 M4, M5). At the root, what can never pass is refused before a
+     * log is opened: the first carve is what makes a run a tree. A child's limit
+     * is the ledger's, which a raise has moved past its saved mandate. The task's
+     * record names the child only once the carve took, so a refused one leaves
+     * no name of a child that never existed.
+     */
+    carveChild(taskId: string, request: Omit<MandateRequest, 'level'>, reopening?: string): Promise<Carved>;
+    /** This node's place in the tree's ledger. */
+    private get nodePath();
+    /** A raise for the child in `taskId`, applied from what this node has left (M5). Null when it took; otherwise why not. */
+    raiseChild(taskId: string, tokens: number): Promise<string | null>;
+    /** A delegated task's row (ADR-0055 D20), read afresh each time a status goes out: nothing of it is kept. */
+    delegatedRow(taskId: string): DelegatedRow | undefined;
+    /** The child in `taskId` confirmed closed: what it did not spend comes back here (M5). */
+    closeChild(taskId: string): Promise<void>;
+    /**
+     * A child plan's start (ADR-0055 D3): its mandate and budget carved from what
+     * its delegated task has left, then a Session built in `cwd`, the task's
+     * worktree, that holds both. A Continue (D17) is the same carve for the child
+     * it names, whose plan loads: nothing of that child's file is read before
+     * this. Its node closed as it ended, or a crash left it open and this closes
+     * it: either way it stays charged what it spent, so no attempt mints budget
+     * (ADR-0056 M10). Rejects with the level that refused.
+     */
+    openChild(task: Task, cwd: string, link: SubplannerLink, reopening?: string): Promise<ChildNode>;
+    /** What is left of what the tree granted a delegated task, its budget and every raise, across every child it has had (ADR-0055 D15, ADR-0056 M5, M10). Throws once nothing is. */
+    private budgetLeft;
+    /** The child `sessionId` is gone: what it did not spend comes back here (ADR-0056 M5). */
+    closeNode(sessionId: string): Promise<void>;
+    /** A delegated task's next attempt is fresh: the child its last one left goes, whatever became of it (ADR-0055 D15). Its state stays under the root; what git could not let go throws, naming it, and the task still names the child. */
+    discardChild({ id, runnerSessionId }: Readonly<Task>): Promise<void>;
+    /** The run's own discard reaches no child: each is named only by what this run forgets (ADR-0055 D11). */
+    private discardChildren;
+    /** This session as its parent's attempt drives it, `pins` what it is told as it starts (ADR-0057 R10). */
+    private asNode;
+    /**
+     * Reopened (ADR-0055 D17): as Execute, so what failed is retried, and then its
+     * subplanner goes on. One whose plan never reached the disk plans its goal, and
+     * one with nothing left to run goes straight to its turn: it may owe only its report.
+     */
+    private goOn;
+    private get taskLogReader();
+    /** The plans below this one on `tree`, each read when asked for (ADR-0055 D17, ADR-0057 R1). */
+    private subtreeOn;
+    /** Whether this node has a board (ADR-0057 R8): a child always, and a root from its first delegated task. A flat plan never does, and never opens a ledger for one. */
+    private get holdsBoard();
+    /** This node's board, read through what its tree's log holds; null where it has none. */
+    board(): Promise<NodeBoard | null>;
+    /** A planner's `post`, in its own workspace. */
+    postOnBoard(args: PostArgs): Promise<McpToolReply>;
+    /**
+     * What a landing owes the plan it landed in (ADR-0057 R6): a delegated task's
+     * contracts rise to this board, then each running task that declared what it
+     * touched gets its line. Undefined with no board, so a flat landing waits on
+     * nothing. A failure here costs a line, and never the landing.
+     */
+    taskLanded(task: Readonly<Task>): Promise<void> | undefined;
+    private raiseAndAddress;
+    /** What is below this plan; null with nothing delegated, so a flat run opens no ledger. */
+    subtree(): Promise<Subtree | null>;
+    /** A subplanner's report, read against its own plan and what is below it; a child's ledger is its root's, so nothing here waits. */
+    private takeReport;
+    /** A planner's `read`: its whole plan, and what is below it (ADR-0057 R11). */
+    readBelow(args: ReadTaskArgs): Promise<McpToolReply>;
+    /** What its parent reads of it, afresh (ADR-0055 D6). */
+    private nodeState;
+    /** Why this node stops now: a child has nobody else to wait for (ADR-0056 M5, M8). */
+    private stoppedFor;
+    /** Why nothing may start here, what is in flight finishing first (ADR-0056 M10). */
+    private withdrawn;
+    /** A Stop stands at this node or above it, or its budget has stopped it (ADR-0055 D16, ADR-0056 M5). */
+    get underStop(): boolean;
+    /** Why no claim and no planner turn may start at this node, read at every start as its own Stop generation is (ADR-0055 D16). */
+    nodeRefusal(): string | null;
+    /**
+     * Everything under this node stops, leaves first, its planner turn and any
+     * turn waiting included, and this resolves once it has all gone: with no
+     * timeout of its own, since a runner's grace is the runner's (ADR-0055 D16).
+     */
+    stopSubtree(): Promise<void>;
+    /**
+     * What is ready cannot start and nothing live will free room for it, so
+     * nothing ticks this again (ADR-0056 M5). A subplanner is woken, once, so it
+     * can ask; {@link ChildPlanSession} ends it if nothing comes of that. A node
+     * with no planner to wake stops.
+     */
+    startRefused(why: string): void;
+    /** A raise only moves numbers: what its room lets start is this run's to start (ADR-0056 M5). */
+    private budgetRaised;
+    /** What a delegated task's branch changed since its base. */
+    changedPaths(taskId: string): Promise<string[]>;
+    /** Why this node stopped for its budget, or null: a parent's reason for ending it `blocked`. */
+    get outOfBudget(): string | null;
     /** The attempts of a task that have a saved log, oldest first. */
     taskLogAttempts(taskId: string): number[];
     /**
@@ -3772,6 +4436,23 @@ declare class Session {
      * write: a turn holds what it writes until the mutation that lands it.
      */
     private persist;
+    /**
+     * What a change to the plan owes the disk. A task's status is what a
+     * decision and a reload read, so a changed one is saved at once, and what
+     * changed beside it goes with it; anything else can wait for the timer.
+     */
+    private saveChange;
+    /** Owe a save, made once however often this is called before it comes. */
+    private saveSoon;
+    /**
+     * A save nothing that follows may depend on: a full disk must not take the
+     * daemon down, nor leave a stop or a close half done, its run live and its
+     * lease held. Said once a failing stretch, since the timer tries again for
+     * as long as the disk refuses.
+     */
+    private tryPersist;
+    /** Make the save owed, before the plan it is owed for goes. */
+    private settleSaves;
     /** A new plan on a long-lived Session gets its own persisted identity (unless the host fixed one). */
     private remintSessionId;
     /**
@@ -3780,6 +4461,8 @@ declare class Session {
      * no live host holds it, as a new session's first save does.
      */
     heldElsewhere(): SessionHeld | null;
+    /** Work on the session this Session has open is refused while another host holds it (ADR-0049 L5). */
+    private refuseHeld;
     /**
      * A new plan under the host's fixed id writes that session's file: refused
      * before any planner turn while another host has it open (ADR-0049). A
@@ -3790,9 +4473,14 @@ declare class Session {
     /**
      * Another host took the session over, judging this one gone (ADR-0049). Its
      * runners must not work on beside that host's, in the worktrees that host
-     * now prepares, so the run here stops.
+     * now prepares, so the run here stops. The planner turn is abandoned, not
+     * only stopped: a backend can still answer past a stop, and that reply would
+     * write a PRD into the checkout that host now holds. What waits behind it
+     * stays, for the gate to refuse with the hold's own reason (L5).
      */
     private leaseLost;
+    /** Something of the run would go on if left: work, a resume, a start on its way, or a loop a retry would carry on (ADR-0045 L5). */
+    private get stopOwed();
     /**
      * The plan scope ends: everything that belongs to the plan this Session
      * holds goes, so nothing of it reaches the next one — a new plan, another
@@ -3813,6 +4501,13 @@ declare class Session {
      * them as its draft.
      */
     private beginFreshPlan;
+    /**
+     * The fresh plan of a goal its gate let in. The slot that gate took stays
+     * through the old scope's end: given back, the pool offers it on at once, and
+     * a sibling's kept turn leaves this one none (ADR-0055 D18). That end takes
+     * the process of any turn this one replaces, as {@link endTurnLease} would.
+     */
+    private beginFreshPlanForTurn;
     /**
      * Return the Session to a blank slate — hosts call this on "new session".
      * Everything scoped to the old session goes: the live AI conversation, plan,
@@ -3826,9 +4521,9 @@ declare class Session {
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
-     * boundary rewrites `in_progress` to `pending` — nothing is running when a
-     * session comes off a file — so a surface that re-reads the plan mid-run must
-     * come here instead, or every task it is watching reads as never started.
+     * boundary fails an `in_progress` task — nothing is running when a session
+     * comes off a file — so a surface that re-reads the plan mid-run must come
+     * here instead, or every task it is watching reads as interrupted.
      * An archived snapshot carries the task as it is now: a retry or continue
      * keeps the archive while the live task runs on and spends more.
      */
@@ -3851,6 +4546,13 @@ declare class Session {
      * the session.
      */
     assertPlannerReady(): void;
+    /**
+     * What a turn on the session this Session has open passes. Not part of
+     * {@link assertPlannerReady}, which a new goal passes too: under a minted id
+     * that goal leaves a held session behind, and {@link claimHostSession} judges
+     * a fixed one.
+     */
+    private assertTurnMayRun;
     /**
      * The planner gate for a turn {@link PlanTurns} does not open — an opening,
      * plan generation, a compaction — the same one its turns pass: wait for the
@@ -3864,6 +4566,15 @@ declare class Session {
      * no longer be refused as one sent during it.
      */
     private plannerTurnMayOpen;
+    /** A subplanner's turn that {@link PlanTurns} does not open waits for a slot like one it does (ADR-0055 D18), ended as the gate's wait is. Null with one in hand. */
+    private slotForTurn;
+    private plannerGate;
+    /**
+     * The installed-planner probe, for a turn at the gate to wait on. No planner
+     * has heard of that turn, so the surfaces are told what it waits for, once
+     * however many wait.
+     */
+    private plannerDetected;
     /** End every turn waiting at the planner gate before it opens; false when none was. */
     private endWaiting;
     /**
@@ -3985,6 +4696,10 @@ declare class Session {
     /** The catalog over workspace `roots`; the workspace root alone is the session's own. */
     private skillsAt;
     private conversationOpening;
+    /** A planner's tools, and for a subplanner the two its parent's attempt answers (ADR-0055 D5). */
+    private offeredTools;
+    /** What the prompt says of this node's limits, as it stands when the planner starts (ADR-0055 D19). */
+    private delegationBrief;
     /**
      * Load planner-produced tasks, as the check they landed through resolved
      * them against the catalog read live: it may have changed since planning
@@ -4021,7 +4736,9 @@ declare class Session {
      * as executing does, and the run takes them in. A run the scheduler was not
      * driving, one task started on its own, becomes the plan's run, as Execute
      * would make it. The planner's run_plan joins with `approved` 0: the
-     * scheduler starts only approved tasks, so `left` tasks still wait.
+     * scheduler starts only approved tasks, so `left` tasks still wait. A run a
+     * usage limit holds stays held, and the line says so, since nothing it names
+     * starts before the reset.
      */
     private joinRun;
     private startOneTask;
@@ -4105,6 +4822,8 @@ declare class Session {
     runSnapshot(): RunView;
     /** The ancestors a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
     mergeGate(taskId: string): string[];
+    /** What reverting the task would do now, for a surface to confirm before `revert_task` (ADR-0054). Reads only. */
+    revertPreview(taskId: string): Promise<TaskRevertPreview>;
     /** What Merge all would merge now; null once everything landed is merged. */
     runMergeView(): RunMergeView | null;
     /** The run's integration branch against its base ref, as a unified diff. */
@@ -4134,6 +4853,11 @@ declare class Session {
      * otherwise (Mark not done), because only they know whether they kept the work.
      */
     discardRun(): Promise<void>;
+    /**
+     * Narrower than {@link stopOwed}: a run that ended on a failure, or whose
+     * loop a body task stopped, is what these are for. Such a loop ends with the
+     * run, once git has let it go, so a refused discard leaves it standing.
+     */
     private requireSettledRun;
     /** Add the task that merges a conflicted task's branch by hand; see {@link PlanEditor.addConflictResolver}. */
     resolveConflictAsTask(taskId: string): Promise<LegacyPlanState | null>;
@@ -4142,8 +4866,11 @@ declare class Session {
      * one queued behind a planner turn's edit, one waiting on its card, one
      * still opening its run. A card still asking is cleared, so its start
      * answers as stopped rather than waiting on a question that no longer stands.
+     * The user's stands the supervisor down too; a supervisor's own, for a change
+     * it means to run, does not.
      */
-    stopExecution(): void;
+    stopExecution(actor?: ExecutionActor): void;
+    private stopRun;
     /** Something will start without being asked again; see {@link TaskOrchestrator.startsPending}. */
     get startsPending(): boolean;
     /**
@@ -4159,11 +4886,16 @@ declare class Session {
      * a hold would stall every task's status for as long, and an
      * `execution_complete` the control triggers would overtake the status held
      * back — which a surface treats as the end of the stream. Instead each status
-     * announced while one runs is saved first (see {@link observer}).
+     * announced while one runs is saved first (see {@link observer}). The save
+     * that ends it fails as {@link saved}'s does.
      */
     private withSave;
-    private saveForControl;
-    /** A control that finishes synchronously: its status is held until it is saved. */
+    /**
+     * A control that finishes synchronously: its status is held until it is
+     * saved. Its effect has landed by then, so a failed save is said rather than
+     * thrown: the caller would report a control that took as one that failed,
+     * and a surface would keep showing what it answered.
+     */
     private saved;
     /**
      * The one mutation seam: every structural plan mutation runs the same
@@ -4200,6 +4932,8 @@ declare class Session {
         sessionId?: string;
         persist?: boolean;
     }): void;
+    /** The plan a load adopts goes to disk first; whoever asked hears that nothing here changed if it cannot. */
+    private writeLoaded;
     /**
      * Take the loaded plan's run over, then correct what the surfaces were told
      * by what git found: the saved record cannot know what the user merged
@@ -4213,6 +4947,9 @@ declare class Session {
      */
     private adoptRun;
     destroy(): void;
+    private letLeaseGo;
+    /** Destroyed, with everything under it gone and its lease let go. */
+    get gone(): Promise<void>;
     /**
      * The planner's settings or credentials changed: its backend is let go and
      * built afresh from them, once no planner turn is running on it (see
@@ -4221,6 +4958,46 @@ declare class Session {
     plannerSettingsChanged(): void;
 }
 
+/** How one `docker` command ended; `code` is -1 for a CLI that could not start. */
+interface DockerResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+    /** Its stdout passed {@link DockerCall.stdoutTo}'s limit, and it was killed for it. */
+    overflowed?: true;
+}
+interface DockerCall {
+    input?: string | Buffer;
+    /** Over this host's, for the CLI: what `-e NAME` hands over, so a secret never sits in an argument (ADR-0022 A5). */
+    env?: Readonly<Record<string, string>>;
+    timeoutMs?: number;
+    /** Stdout to a file rather than to memory, for a bundle of any size up to `maxBytes`. */
+    stdoutTo?: {
+        file: string;
+        maxBytes: number;
+    };
+}
+/**
+ * The Docker API through the docker CLI (ADR-0059 L5): one code path for any
+ * engine that speaks it, which keeps whatever context the user chose.
+ */
+interface DockerCli {
+    call(args: readonly string[], opts?: DockerCall): Promise<DockerResult>;
+    /** A command that runs for as long as a container does, with its stdio left open. */
+    entry(args: readonly string[]): Promise<ChildProcess>;
+}
+
+/**
+ * A session delete's half of it, which has no Session or backend to ask. Without
+ * the setting nothing has been put in an engine, and Docker is not asked: a user
+ * of local worktrees may have none (ADR-0059 L4). Under a setting it cannot use
+ * it clears what it can find by label, and the pins wait for one it can.
+ */
+declare function reclaimContainers(tree: string, raw: unknown, { cli, tell }?: {
+    cli?: DockerCli;
+    tell?: (text: string) => void;
+}): Promise<void>;
+
 /**
  * A request on the plan the session refused: a direct (non-planner) edit that
  * is not valid, or an isolation action on a plan with no isolated run to act
@@ -4350,7 +5127,7 @@ declare class VerdictEngine {
     private clearIdle;
     /** What a task's waiting checkpoint asks, untruncated; undefined when none waits. */
     getCheckpointQuestion(taskId: string): string | undefined;
-    approveCheckpoint(taskId: string): void;
+    approveCheckpoint(taskId: string, note?: string): void;
     rejectCheckpoint(taskId: string, reason: string): void;
     /**
      * An attempt's runner is being started, with no session to watch yet. Its
@@ -4373,7 +5150,7 @@ declare class VerdictEngine {
      * 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;
+    signalComplete(taskId: string, generation: number, report: TaskCompleteArgs, refuted?: VerificationCheck): void;
     /**
      * A script task's exit status (ADR-0035): its one evidence, as a runner's
      * `task_complete` call is a runner's. It settles the attempt unless that
@@ -4424,49 +5201,6 @@ declare class BufferedTaskOutputSource implements TaskOutputSource {
     private append;
 }
 
-/** 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 stop(): Promise<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, from?: TaskMessageFrom): 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 commands(): RunnerCommand$1[];
-    abstract invokeCommand(name: string, args?: string): string;
-    abstract answerPermission(id: string, decision: ApprovalDecision): boolean | Promise<boolean>;
-    abstract onTaskComplete(listener: (report: TaskCompleteArgs) => void): void;
-    abstract onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
-    abstract onScriptExit(listener: (exit: ScriptExit) => void): void;
-}
-declare abstract class AbstractRunner<S extends IRunnerSession> implements IRunner {
-    protected sessions: Map<string, S>;
-    get activeCount(): number;
-    /** A session winding down stays registered until it exits, so a second stop gets the same wind-down. */
-    stop(sessionId: string): Promise<void>;
-    stopAll(): void;
-    protected registerSession(id: string, session: S): void;
-    abstract spawn(opts: RunnerSpawnOptions): Promise<IRunnerSession>;
-}
-
 interface StructuredRunnerDeps {
     /** The OS boundary the adapters spawn through. `workspaceEnv` is always the spawn's own `env`. */
     process?: Partial<Omit<AgentProcessDeps, 'workspaceEnv'>>;
@@ -4490,8 +5224,9 @@ interface SessionLaunch {
         savePatch?: (signal: AbortSignal) => Promise<McpToolReply>;
         webReads?: TaskWebReads;
     };
-    checkHandoff: (completion: TaskCompleteArgs) => HandoffCheck<TaskCompleteArgs>;
-    readTask?: (args: ReadTaskArgs) => McpToolReply;
+    checkHandoff: (completion: TaskCompleteArgs) => HandoffCheck<TaskCompleteArgs> | Promise<HandoffCheck<TaskCompleteArgs>>;
+    readTask?: (args: ReadTaskArgs) => McpToolReply | Promise<McpToolReply>;
+    post?: (args: PostArgs) => McpToolReply | Promise<McpToolReply>;
     applyPatch?: (args: ApplyPatchArgs) => Promise<McpToolReply>;
     onNotice?: (message: string) => void;
     onAttaching?: (spawn: 1 | 2) => void;
@@ -4874,6 +5609,10 @@ interface ScriptSessionSetup {
         file: string;
         maxChars: number;
     };
+    /** A read-only script runs here, or not at all (ADR-0055 D8). */
+    sealed?: TaskShell;
+    /** The lease's container, which every step runs in (ADR-0059 L5). */
+    placement?: RunnerPlacement;
 }
 /**
  * One attempt of a script task (ADR-0035): its body run at the workspace root
@@ -4889,6 +5628,14 @@ interface ScriptSessionSetup {
  * the group (`setsid`, `setpgrp`) is out of reach of a group signal, and once
  * its parent exits nothing ties it to the step: holding it is the work of a
  * boundary around the task, a container or a lease (#97, #99), not of a signal.
+ *
+ * A read-only script's steps run sealed instead (ADR-0055 D8), in the shell a
+ * read-only task's commands use and in its throwaway worktree: Stop and the time
+ * limit reach them through its signal, and what they print comes as each ends.
+ *
+ * Under a container lease every step runs there, by the lease's placement, in
+ * place of all of that: the group this host signals is a client, and the
+ * container is the boundary, whatever leaves a process group inside it.
  */
 declare class ScriptSession extends AbstractRunnerSession {
     private readonly setup;
@@ -4897,6 +5644,8 @@ declare class ScriptSession extends AbstractRunnerSession {
     private readonly steps;
     private readonly children;
     private child;
+    /** The step under way, where a lease runs it. */
+    private placed;
     private output;
     private running;
     private stopped;
@@ -4906,6 +5655,8 @@ declare class ScriptSession extends AbstractRunnerSession {
     private logTail;
     private omitted;
     private full;
+    /** Aborted to end a sealed step, which has no process of its own here to signal. */
+    private readonly sealedEnd;
     private markGone;
     private readonly gone;
     constructor(id: string, taskId: string, setup: ScriptSessionSetup);
@@ -4913,6 +5664,18 @@ declare class ScriptSession extends AbstractRunnerSession {
     begin(): void;
     private run;
     private runStep;
+    /**
+     * A step through the sealed shell: from the worktree root it was cut at, the
+     * only place a sealed run may start, and on into the task's folder. A refusal
+     * ran nothing, so it says it could not start rather than that it failed.
+     */
+    private sealedStep;
+    /**
+     * What a lease launches for a step. Nothing of this host's goes with it: a
+     * script is the container's own `sh`, whatever shell this host would have
+     * picked, and only what the lease hands over crosses.
+     */
+    private placedLaunch;
     /**
      * An argument vector is never joined into a shell string: on POSIX it is
      * exec'd as written, and on Windows the launch seam finds the program the
@@ -4922,6 +5685,8 @@ declare class ScriptSession extends AbstractRunnerSession {
     private launchOf;
     private spawnStep;
     private expire;
+    /** Ends the step under way, at each place it may be: a client killed here leaves what it started in a container running. */
+    private endStep;
     private print;
     private printError;
     private openFullOutput;
@@ -4987,12 +5752,15 @@ type Continuability = {
  * The rule every surface offers Continue by and the orchestrator enforces: a
  * completed, failed or skipped task, or one paused on a usage limit, whose last
  * attempt left a session id behind. A conflict is resolved by its repair, not a
- * new turn — Retry covers it.
+ * new turn — Retry covers it. A delegated task whose question a restart lost
+ * still has its child, so Continue is what keeps that work (ADR-0055 D17).
  */
 declare function continuability(task: Task): Continuability;
 declare function canContinue(task: Task): boolean;
 
 declare function stripAnsi(text: string): string;
+/** `text` as one word of a POSIX shell, whatever it holds. */
+declare function shellQuoted(text: string): string;
 
 /**
  * A workspace path that does not exist, or exists but is not a directory.
@@ -5222,33 +5990,6 @@ declare function loadState(baseDir?: string, logger?: ILogger): SavedState | nul
 declare function clearState(baseDir?: string): void;
 declare function stateExists(baseDir?: string): boolean;
 
-/**
- * A path segment for an id that came from outside — a session id from a URL,
- * a task id a planner wrote. A plain id is used as is; anything that could
- * climb out of its directory, or is not portable as a file name, is hex-encoded.
- */
-declare function idSegment(id: string): string;
-/**
- * The directory beside a session's file for what it keeps outside that file —
- * its task logs (ADR-0018, P1). It goes when the session does.
- */
-declare function sessionDataDir(sessionId: string, baseDir?: string): string;
-declare function saveSession(plan: LegacyPlanState, goal: string, baseDir?: string, id?: string): SessionMeta;
-declare function listSessions(baseDir?: string, logger?: ILogger): SessionMeta[];
-declare function loadSession(sessionId: string, baseDir?: string, logger?: ILogger): {
-    meta: SessionMeta;
-    plan: LegacyPlanState;
-} | null;
-declare function loadSessionPlanState(sessionId: string, baseDir?: string, logger?: ILogger): {
-    meta: SessionMeta;
-    plan: PlanState;
-} | null;
-declare function getLatestSession(baseDir?: string, logger?: ILogger): {
-    meta: SessionMeta;
-    plan: LegacyPlanState;
-} | null;
-declare function deleteSession(sessionId: string, baseDir?: string, logger?: ILogger): boolean;
-
 declare function mintSessionId(): string;
 
 interface PrdBlock {
@@ -5313,4 +6054,4 @@ declare function parseVersion(version: string): number[] | null;
 /** Negative, zero or positive as `a` is older than, the same as, or newer than `b`; an unreadable version sorts oldest. */
 declare function compareVersions(a: string, b: string): number;
 
-export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, AccountLimitBucket, type AccountLimitCollector, type AccountLimitListener, AccountLimitMonitor, type AccountLimitMonitorOptions, type AccountLimitReading, AccountLimitSnapshot, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApprovalAnswer, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, AssignmentScope, BaseAiService, BaseConfig, BaseFileSystem, BashOptions, BatchQuoteError, BufferedTaskOutputSource, type ByPlannerBackend, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CappedRows, CheckpointAnswer, type CheckpointListener, type ClaudeAccountLimitOptions, ClaudeCodeAdapter, type CodexAccountLimitOptions, CodexAdapter, CodexSandboxAvailability, CommandLineTooLongError, CommandOutcome, type ConfiguredPlanner, ConsoleLogger, ContextCollector, type Continuability, ConversationCompaction, type ConversationFork, ConversationRequest, type ConversationRewind, ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, type EffectRules, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecImpl, ExecutableNotFoundError, ExecutionActor, ExecutionCommand, FindSymbolOptions, GREP_PCRE_PROBE_ARGS, GeminiService, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, HandoffCheck, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, IAiService, IApproval, IConfig, IFileSystem, IIsolationPreview, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LeaseHost, LegacyPlanState, LiveTail, LiveTailOptions, McpToolReply, ModelResolver, type ModelResolverDeps, type NativeShellLauncher, type NativeShellOffer, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OpenCodeGoAccountLimitOptions, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type ParsedCommand, PendingApproval, PendingApprovals, type PingFetch, PlanEditError, PlanIsolation, type PlanRequest, PlanState, PlanStore, Planner, PlannerAllowlist, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, PlannerModelCandidate, type PlannerModelLookup, PlannerModelRecall, type PlannerModelSource, PlannerModelStore, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, PlannerShellSandbox, PlannerToolHandler, type PlannerUsability, PlannerUsage, type PrdBlock, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, ReadTaskArgs, ReportedWindow, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolvedChoice, type ResolvedPlanner, RewindTarget, RunActivity, RunMergeView, RunView, RunnerApprovals, RunnerAuth, RunnerAuthExec, RunnerCommand$1 as RunnerCommand, RunnerId, RunnerInstallation, type RunnerInstallationOptions, RunnerManifest, RunnerModeInfo, RunnerRegistry, RunnerSessionCost, type RunnerSpawnOptions, SCRIPT_RUNNER, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, type SavedState, ScriptBody, ScriptExit, ScriptRunner, ScriptSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionDeps, SessionHeld, SessionLease, SessionMessage, SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, ShellLaunch, SkillsService, type SpawnSpec, StdioAgentAdapter, StoredHandoff, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, Task, TaskCompleteArgs, TaskControlError, type TaskEditOptions, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, TaskMessageFrom, TaskModeAgentAdapter, TaskOrchestrator, TaskOutputSource, TaskQueryCatalog, TaskRunnerFlags, TaskShell, TaskShellSite, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VERSION_CHECK_NOTICE, VERSION_CHECK_URL, VerdictEngine, type VerdictListener, type VersionCheck, type VersionCheckOptions, WINDOWS_MAX_COMMAND_LINE, WebRead, WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, claudeAccountLimitCollector, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexAccountLimitCollector, codexSandboxNotice, compareVersions, configuredProviders, continuability, createIsolationPreview, createNativeShellLauncher, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, detectInstalledPlanner, discoverGeminiModels, effectRuleFor, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, isolationViewOfPlan, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, nativeShellInvocation, nativeShellOffer, normalizeGeminiModel, openCodeGoAccountLimitCollector, openTaskLog, parseEffectAllowlist, parseExecutionCommand, parseMaxParallel, parseSearchHits, parseVersion, planDirectLaunch, plannerBackendEntries, prefixModelId, prepareTaskOutputFile, providerForRunner, readDaemonToken, readTaskLog, readTaskPatch, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, repositoryRunnerConfigPaths, resetInstalledPlanner, resolveProviderFromPrefix, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, saveTaskPatch, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, startVersionCheck, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskPatchFile, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writeFileAtomic, writePrivateFile };
+export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, AccountLimitBucket, type AccountLimitCollector, type AccountLimitListener, AccountLimitMonitor, type AccountLimitMonitorOptions, type AccountLimitReading, AccountLimitSnapshot, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApprovalAnswer, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, AssignmentScope, BaseAiService, BaseConfig, BaseFileSystem, BashOptions, BatchQuoteError, BufferedTaskOutputSource, type ByPlannerBackend, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CappedRows, CheckpointAnswer, type CheckpointListener, type ChildPlacement, type ClaudeAccountLimitOptions, ClaudeCodeAdapter, type CodexAccountLimitOptions, CodexAdapter, CodexSandboxAvailability, CommandLineTooLongError, CommandOutcome, type ConfiguredPlanner, ContextCollector, type Continuability, ConversationCompaction, type ConversationFork, ConversationRequest, type ConversationRewind, ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, EmbeddedNewlineError, type EnvAdmission, EnvConfig, Escalation, type ExecImpl, ExecutableNotFoundError, ExecutionActor, ExecutionCommand, FindSymbolOptions, GREP_PCRE_PROBE_ARGS, GeminiService, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, HandoffCheck, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, IAiService, IApproval, IConfig, IFileSystem, IIsolationPreview, ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, IsolationRemoval, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LeaseHost, LegacyPlanState, LiveTail, LiveTailOptions, Mandate, MandateRequest, McpToolReply, ModelResolver, type ModelResolverDeps, type NativeShellLauncher, type NativeShellOffer, NoPlanError, NodeAuthority, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OpenCodeGoAccountLimitOptions, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type ParsedCommand, PendingApproval, PendingApprovals, type PingFetch, PlanEditError, PlanIsolation, type PlanRequest, PlanState, PlanStore, Planner, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, PlannerModelCandidate, type PlannerModelLookup, PlannerModelRecall, type PlannerModelSource, PlannerModelStore, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, PlannerShellSandbox, PlannerToolHandler, type PlannerUsability, PlannerUsage, PostArgs, type PrdBlock, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, ReadTaskArgs, ReportedWindow, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolvedChoice, type ResolvedPlanner, RewindTarget, RunActivity, RunMergeView, RunView, RunnerApprovals, RunnerAuth, RunnerAuthExec, RunnerCommand$1 as RunnerCommand, RunnerId, RunnerInstallation, type RunnerInstallationOptions, RunnerManifest, RunnerModeInfo, RunnerRegistry, RunnerSessionCost, type RunnerSpawnOptions, SCRIPT_RUNNER, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, type SavedState, ScriptBody, ScriptExit, ScriptRunner, ScriptSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionDeps, SessionHeld, SessionLease, SessionMessage, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, ShellLaunch, SkillsService, type SpawnSpec, StdioAgentAdapter, StoredHandoff, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, SubtreeReport, Task, TaskCompleteArgs, TaskControlError, type TaskEditOptions, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, TaskMessageFrom, TaskModeAgentAdapter, TaskOrchestrator, TaskOrchestratorOptions, TaskOutputSource, TaskQueryCatalog, TaskRevertPreview, TaskRunnerConfig, TaskRunnerFlags, TaskShell, TaskShellSite, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VERSION_CHECK_NOTICE, VERSION_CHECK_URL, VerdictEngine, type VerdictListener, VerificationCheck, type VersionCheck, type VersionCheckOptions, WINDOWS_MAX_COMMAND_LINE, WebRead, WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, claudeAccountLimitCollector, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexAccountLimitCollector, codexSandboxNotice, compareVersions, configuredProviders, continuability, createIsolationPreview, createNativeShellLauncher, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, definitionPattern, detectInstalledPlanner, discardChildRuns, discoverGeminiModels, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, isolationViewOfPlan, killTree, languageForId, listTaskLogAttempts, listTree, loadState, looksLikeChallenge, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, nativeShellInvocation, nativeShellOffer, normalizeGeminiModel, notifyCommandOf, openCodeGoAccountLimitCollector, openTaskLog, parseExecutionCommand, parseMaxParallel, parseSearchHits, parseVersion, planDirectLaunch, plannerBackendEntries, prefixModelId, prepareTaskOutputFile, providerForRunner, readDaemonToken, readTaskLog, readTaskPatch, reclaimContainers, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, repositoryRunnerConfigPaths, resetInstalledPlanner, resolveProviderFromPrefix, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveState, saveTaskPatch, selectPlanner, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, shellQuoted, startVersionCheck, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskPatchFile, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writeFileAtomic, writePrivateFile };