@ordewell/core 0.12.0 → 0.12.1

package/dist/index.d.mts

@@ -1,11 +1,11 @@
-import { aK as RunnerId, aD as ResearchProgress, bh as UsageRecord, aC as ResearchLogEntry, b1 as Task, i as DiscoveredModel, I as IIsolationPreview, z as IWorktreeIsolation, a4 as IsolationTaskStatus, a5 as IsolationView, af as PlanIsolation, a8 as LegacyPlanState, aL as RunnerSessionCost, aB as ReportedWindow, an as PlannerUsage, ba as TaskSkillSnapshot, aZ as SkillsService, E as ExecutionActor, bb as TaskSnapshot, ag as PlanState, bj as Verdict, a_ as StoredHandoff, p as HandoffCheck } from './Task-BTEH-ztX.mjs';
-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 HandoffLogs, v as HandoffPatch, w as HandoffPins, x as HandoffPreviewOptions, y as HandoffTaskName, J as IntegrationDisposal, K as InvalidSkill, L as IsolationAvailability, M as IsolationHandoff, N as IsolationHandoffRepo, O as IsolationInactiveReason, P as IsolationLandedTask, Q as IsolationLanding, R as IsolationMergeBlock, S as IsolationMergeBlockReason, T as IsolationMergeResult, U as IsolationOutcome, V as IsolationPreview, W as IsolationPruneResult, X as IsolationRemoval, Y as IsolationRepo, Z as IsolationRepoRevert, _ as IsolationRevertResult, $ as IsolationRevertTask, a0 as IsolationRun, a1 as IsolationTaskRecord, a2 as IsolationTaskRef, a3 as IsolationTaskRepo, a6 as LandedTask, a7 as LandedWork, a9 as LoopSubject, aa as MAX_LOOP_ROUNDS, ab as ModelUsage, ac as PatchFlag, ad as PatchView, ah as PlanStatus, ai as PlanUsage, aj as PlannerCompaction, ak as PlannerCompactionOutcome, al as PlannerContextPause, am as PlannerResendState, ao as PrepareIntent, ap as PreparedTask, aq as PreservedWork, ar as PreviewRepo, as as PreviousWork, at as REPORT_MAX_CHARS, au as ROOT_NODE, av as RefusedRemoval, aw as RepairEvidence, ax as RepairWait, ay as ReplyRun, az as RepoGroupLayout, aA as RepoHead, aE as ResearchStep, aF as ResearchStepOutcome, aH as RevertCommand, aI as RevertWatch, aJ as RunSettings, aM as SEVERITY_LABEL, aN as ScriptConsent, aO as ScriptResult, aP as SessionBilling, aQ as SetupFailure, aR as ShadowedSkill, aS as SkillAppliesTo, aT as SkillCatalog, aU as SkillInfo, aV as SkillLoad, aW as SkillLoadNotice, aX as SkillMetadata, aY as SkillSource, b0 as SupervisorLevel, b4 as TaskIsolation, b5 as TaskIsolationState, b6 as TaskLoop, b7 as TaskModelAssignment, bc as TaskStatus, bd as TaskType, be as TaskUsageSummary, bf as TreeSnapshot, bg as UsageLine, bi as UsageTotals, bk as VerificationCheck, bl as WrittenTaskRef, bm as actorAuthority, bn as addAttemptUsage, bo as addModelUsage, bp as addPlannerUsage, bq as addUsage, br as addUsageTotals, bs as artifactLines, bt as betweenRounds, bu as boundedHandoffLines, bv as byteSize, bw as checkHandoff, bx as checkOf, by as contextMeterText, bz as contextMeterTitle, bA as costText, bB as countedSessionCost, bC as createEmptyPlan, bD as createSkillsService, bE as createTask, bF as endAttemptUsage, bG as findingLines, bH as findingRefText, bI as flattenTasks, bJ as flattenTasksWithParents, bK as formatCost, bL as formatTokenCount, bM as handoffDigest, bN as handoffLines, bO as handoffPreviewLines, bP as handoffReferenceText, bQ as handoffWakeLines, bR as inLoop, bS as isAwaitingReason, bT as isMeasured, bU as isSupervisorLevel, bV as isUserMessage, bW as loopRemovalRefusal, bX as loopRoundOf, bY as migratePlanState, bZ as modelCostTitle, b_ as namedHandoff, b$ as openingLines, c0 as outOfRounds, c1 as parseFindingRef, c2 as partedPromptUsage, c3 as patchChangesText, c4 as patchFlagText, c5 as patchLines, c6 as patchLinesText, c7 as patchText, c8 as patchView, c9 as pausedOnLimit, ca as planUsage, cb as plannerContextFill, cc as readableTaskIds, cd as rejoinPlanTree, ce as removedAttempt, cf as resolveWrittenRef, cg as resumedSessionWindow, ch as savedPatchOf, ci as savedPatchView, cj as savedPatchViews, ck as severityLabel, cl as startAttemptUsage, cm as storedHandoff, cn as subagentCostTitle, co as taskUsageSummary, cp as tasksTotalText, cq as usageLine, cr as usageText, cs as waitsForApproval, ct as withPatch, cu as wordsFrom, cv as worstSeverity } from './Task-BTEH-ztX.mjs';
-import { dE as TurnBudgets, bp as PlanIntake, aC as IWebFetcher, W as ConversationTurn, bE as PlannerModes, bT as ResolveAll, dN as WebReadPolicy, dK as WebRead, dL as WebReadDecision, dM as WebReadOptions, bl as PendingApprovals, az as IAiService, bv as PlannerContextDeps, bw as PlannerContextStatus, N as ContextCondenseRequest, U as ConversationRequest, bz as PlannerModelCandidate, c9 as RunnerAuthExec, c8 as RunnerAuth, b as AccountLimitBucket, c as AccountLimitSnapshot, u as AssignmentWriter, t as AssignmentScope, dh as TaskQueryCatalog, r as AssignmentCatalog, cc as RunnerCatalog, cx as SessionMessage, cp as SessionBroadcaster, cz as SessionNotice, bt as PlanStore, db as TaskOrchestrator, ac as Escalation, bg as OrchestratorObserver, d0 as TaskLogEvent, bS as ResearchTasks, aB as INotification, at as GlobalRunSettings, aH as IsolationRunController, cs as SessionHeld, cu as SessionLease, by as PlannerConversationHost, bx as PlannerConversation, b9 as NodeAuthority, al as ExecutionCommand, G as CommandOutcome, aU as Mandate, bk as PendingApproval, Q as ConversationCompaction, bZ as RewindTarget, c7 as RunView, dk as TaskRevertPreview, c2 as RunMergeView, c0 as RunActivity, de as TaskOutputSource, aK as LeaseHost, dH as UserSettings, aP as LiveTailOptions, aO as LiveTail, cy as SessionMeta, bD as PlannerModelStore, bC as PlannerModelRecall } from './runSettingsText-x-YML2ay.mjs';
-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, z as CliAgentAiService, D as CliAgentAiServiceDeps, E as CommandBlock, F as CommandDescriptor, H as CommandPayload, I as CommandStatus, J as CommandsResponse, K as CompactionBlock, L as CompactionStatus, M as Consent, O as ConversationBusyError, P as ConversationCompactResponse, R as ConversationEditError, S as ConversationForkResponse, T as ConversationInput, V as ConversationRewindResponse, X as ConversationView, Y as DEFAULT_WEB_READ_BUDGET, Z as DELEGATION_OFFERED, _ as DELEGATION_RISK, $ as DaemonErrorCode, a0 as DecideOptions, a1 as DiffRow, a2 as DiffRowKind, a3 as DiffStat, a4 as DisplayBlock, a5 as EMPTY_CONVERSATION, a6 as EMPTY_HOLD, a7 as EMPTY_RUN, a8 as EMPTY_TASK_LOG, a9 as EMPTY_TASK_LOG_FOLLOW, aa as EffectRules, 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 FLOOR_GRANTS, aq as GRANTS, ar as GatedConversation, as as GeneratePlanResponse, au as Grant, av as HEADLESS_CLI_COMMANDS, aw as HandoffBlock, ax as HandoffForkRepo, ay as HandoffPeekSubject, aA as IDLE_ACTIVITY, aD as IsolationDiffResponse, aE as IsolationMergeResponse, aF as IsolationPreviewNotice, aG as IsolationPreviewResponse, aI as LEASE_HEARTBEAT_MS, aJ as LEASE_STALE_MS, aL as LeaseHostKind, aM as LeaseHostOptions, aN as LiveOutputLookup, aQ as LocalEntry, aR as LoopCheckFacts, aS as LoopCheckState, aT as LoopGuard, aV as MandateExclusions, aW as MandateLimits, aX as MandateRefusal, aY as MandateRequest, aZ as MappedTool, a_ as MarkdownToken, a$ as MergeGateEntry, b0 as MergeGateResponse, b1 as MergeWordingHandoff, b2 as MessageBlock, b3 as MessageRole, b4 as ModelsResponse, b5 as NOT_STARTED, b6 as NO_TURN, b7 as Narrowed, b8 as NewTaskFields, ba as NotificationAction, bb as OUTPUT_LINES_DEFAULT, bc as OUTPUT_LINES_MAX, bd as OkResponse, be as OpRef, bf as OpRefusal, bh as OutputPreview, bi as OverrideDirection, bj as PLANNED_WITH_LABEL, bm as PendingApprovalsOptions, bn as PlanBlock, bo as PlanBlocks, bq as PlanMarkerStatus, br as PlanResponse, bs as PlanSnapshot, bu as PlannerCommandSyntax, bA as PlannerModelChoice, bB as PlannerModelMemory, bF as PlannerNotReady, bG as PlannerNotReadyError, bH as PlannerReadinessConfig, bI as PlannerSubmission, bJ as PlannerTurnDiscardedError, bK as PlannerTurnStoppedError, bL as PlannerUsageLimitError, bM as PrdResponse, bN as PromptHold, bO as REPORT_PREVIEW_LINES, bP as RUN_SETTINGS_DEFAULTS, bQ as ReadRunnerAuthOptions, bU as ResolveConflictResponse, bV as RevertPreviewTask, bW as RevertRefusal, bX as RevertRefusalReason, bY as RevertScope, b_ as RewindTargetsResponse, b$ as RootSettings, c1 as RunInput, c3 as RunSettingsError, c4 as RunSnapshotFrame, c5 as RunTask, c6 as RunTaskStatus, ca as RunnerAuthExecOptions, cb as RunnerAuthExecResult, cd as RunnerLoadedBlock, ce as RunnersResponse, cf as SHAPE_LIMITS, cg as STALLED_LABEL, ch as STOPPED_BEFORE_START, ci as SUPERVISOR_LEVEL_LABEL, cj as SerializedConversationMessage, ck as SerializedPendingTurn, cl as SerializedPlan, cm as SerializedTask, cn as SerializedTaskStatus, co as ServerInfoResponse, cq as SessionData, cr as SessionFrame, ct as SessionHeldError, cv as SessionLeaseRecord, cw as SessionListResponse, cA as SessionResponse, cB as SettingsResponse, cC as SettingsService, cD as SettingsUpdateResponse, cE as SkillInvocation, cF as SkillLoadBlock, cG as SkillToken, cH as StartAdmission, cI as StopResponse, cJ as StreamStamp, cK as SubagentBlock, cL as SubagentChild, cM as SubagentStatus, 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 TaskActivity, cZ as TaskAttemptSnapshot, c_ as TaskLogAttemptsResponse, c$ as TaskLogBatch, d1 as TaskLogFollow, d2 as TaskLogFollowInput, d3 as TaskLogHeaderKind, d4 as TaskLogHeaderTask, d5 as TaskLogHeaderUsage, d6 as TaskLogHeaderView, d7 as TaskLogResponse, d8 as TaskLogView, d9 as TaskMessageResponse, da as TaskOp, dc as TaskOrchestratorDeps, dd as TaskOrchestratorOptions, df as TaskPlacement, dg as TaskQuery, di as TaskQueryField, dj as TaskRef, dl as TaskRevertPreviewResponse, dm as TaskRowAction, dn as TaskRowContext, dp as TaskRowHandoff, dq as TaskRowIsolation, dr as TaskRowKind, ds as TaskRowLoop, dt as TaskRowPlacement, du as TaskRowSubject, dv as TaskRowUsage, dw as TaskRowView, dx as TaskRunFacts, dy as TaskStatusKind, dz as ThinkingDisplayBlock, dA as ToolBlock, dB as ToolHeadline, dC as ToolStatus, dD as TreeTask, dF as TurnGate, dG as UsageBlock, dI as WAITS_FOR_APPROVAL_LABEL, dJ as WakeUpItem, dO as Worded, dP as WorkspacesResponse, dQ as abbreviateHome, dR as accountLimitPercentText, dS as accountLimitWindowLabel, dT as accountLimitsOf, dU as accountLimitsText, dV as accountLimitsTitle, dW as activityLabel, dX as aheadOfDraft, dY as applyTaskOps, dZ as approvalKindText, d_ as approvalLabel, d$ as approvalStatusText, e0 as assignedRunnerOf, e1 as assignmentIssue, e2 as assignmentIssueText, e3 as attachingLabel, e4 as automergeSummary, e5 as autorunSummary, e6 as awaitingLabel, e7 as blockNotice, e8 as blockNotices, e9 as blockedByLabel, ea as blockingFailures, eb as canMergeTasks, ec as canSetDependencies, ed as canSplitTask, ee as capConflictFiles, ef as cardEditNeedsUnstarted, eg as cardEditable, eh as checkoutRule, ei as classifyOutcome, ej as closeTurn, ek as coalesceTaskLog, el as compactionText, em as confirmedOverride, en as createAiService, eo as delegationSummary, ep as dependencyCandidates, eq as dependentsNotice, er as dependentsOf, es as describeHeld, et as describeHolder, eu as describeIsolationPreview, ev as describeMergeResult, ew as describePlannerNotReady, ex as diffRows, ey as diffStat, ez as diffSummary, eA as digestTaskLog, eB as drainNext, eC as editableWhileRunning, eD as effectRuleFor, eE as elapsedSince, eF as escalations, eG as executionSummary, eH as followTaskLog, eI as followTurn, eJ as formatElapsed, eK as fromTranscript, eL as getSettingsPath, eM as handoffBaseLine, eN as handoffBranchName, eO as handoffFindingsText, eP as handoffPeekParts, eQ as hasAccountLimits, eR as hasHiddenDetail, eS as hasLongReport, eT as heldMandate, eU as holdLabel, eV as holdPrompt, eX as isRepoGroup, eY as isTaskRunning, eZ as lastServedModel, e_ as loadedSkillTokens, e$ as logContinues, f0 as logResumes, f1 as loopBodyLabel, f2 as loopBodyRound, f3 as loopCheckLabel, f4 as loopCheckState, f5 as loopLeaveNotice, f6 as loopRowParts, f7 as mandateRefusalText, f8 as manualOverrideConfirmation, f9 as manualOverrideStopFirst, fa as mapAgentTool, fb as markAction, fc as markdownHtml, fd as markdownTokens, fe as mergeOutcome, ff as mergeTarget, fg as namedRepos, fh as narrow, fi as newTaskFields, fj as noExecutorRefusal, fk as normalizeAgentArgs, fl as opRefusalText, fm as opsEditable, fn as outputLines, fo as outputPreview, fp as overrideNeedsConfirmation, fq as parseCount, fr as parseDelegation, fs as parseEffectAllowlist, ft as parseSwitch, fu as parseTaskOpsJson, fv as parseTaskQueryJson, fw as pastGateConfirmation, fx as planBlocks, fy as planMarkerParts, fz as plannerMessage, fA as plannerNotReady, fB as plannerNotReadyFor, fC as plannerTranscript, fD as processLeaseHost, fE as ranSealed, fF as readRunnerAuth, fG as receiptLabel, fH as reconcileApprovals, fI as recordRunnerAuth, fJ as recordedRunnerAuth, fK as reduceConversation, fL as reduceRun, fM as reduceTaskLog, fN as renderTaskQueryAnswer, fO as repairWaitLabel, fP as repairedLanded, fQ as repairedNotice, fR as repeatingChecks, fS as replayTaskLog, fT as repoBaseLine, fU as repoResultLines, fV as reposWithWork, fW as resetRunnerAuth, fX as resolveSkillInvocation, fY as resolveTaskRef, fZ as resolveUserTaskRef, f_ as resumeLabel, f$ as resumeTime, g0 as revertEffect, g1 as revertListLine, g2 as revertTaskRef, g3 as rootAuthority, g4 as rootMandate, g5 as runHoldsEditors, g6 as runSettingsOf, g7 as runnerToolSubject, g8 as scriptExitText, g9 as scriptRunText, ga as secondsText, gb as serializePlan, gc as serializeTask, gd as serializeTaskStatus, ge as skillTokens, gf as skippedLabel, gg as stopTurn, gh as subtreeIds, gi as summarizeToolCall, gj as supervisorSummary, gk as surfacePlan, gl as surfacePlanState, gm as takeAt, gn as taskActionCommand, go as taskActivity, gp as taskChatAvailable, gq as taskLogCommands, gr as taskLogForSurface, gs as taskLogHeaderView, gt as taskOrderLabel, gu as taskPlacement, gv as taskQuerySignature, gw as taskRef, gx as taskRefOf, gy as taskRowActions, gz as taskRowView, gA as taskStartedNotice, gB as taskStatusKind, gC as textHasTaskOps, gD as textHasTaskQuery, gE as titledRefs, gF as titledTaskRef, gG as titledTaskRefOf, gH as toTaskLogEvent, gI as toolHeadline, gJ as trailerSummary, gK as trimToolOutput, gL as truncateCheckpointSummary, gM as unsendAll, gN as unsendLatest, gO as wakeUpItems, gP as walkPlan, gQ as withoutSealedMark, gR as workspaceEnvOf } from './runSettingsText-x-YML2ay.mjs';
-import { O as IConfig, P as IFileSystem, am as PlannerToolHandler, aj as PlannerShellSandbox, aw as ResearchShell, N as IApproval, au as ReadFileOpts, bs as ToolOutcome, L as GrepOptions, b2 as ShellLaunch, K as GlobOptions, H as FindSymbolOptions, B as BashOptions, bn as TaskShellSite, bm as TaskShell, 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, bk as TaskRunnerConfig, 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, bo as TaskStartOptions, bp as TaskTokenScope, a0 as McpToolReply, br as TaskWebReads, av as ReadTaskArgs, i as ApplyPatchArgs, aW as ScriptBody, aJ as RunnerManifest, bl as TaskRunnerFlags } from './IRunner-BwzyUVIL.mjs';
-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, af as PlannerAllowlist, 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, bq as TaskToolHandler, bu as approvalScopes, bv as classifyCommand, bw as clearPlannerSandboxCache, bx as clearResearchShellCache, by as collectProviderCredentials, bz as commandAllowedBy, bA as commandLine, bB as effectiveApprovalMode, bC as enabledRunners, bD as fetchAllProviderModels, bE as findRunnerCommand, bF as isGranted, bG as isRunnerApproval, bH as knownModelId, bI as mcpClientConfig, bJ as ownerOnlyConfigFile, bK as parseAllowlist, bL as parseApprovalModeSetting, bM as researchShellWarning, bN as researchToolsPath, bO as resolveModelShortcut, bP as resolvePlannerSandbox, bQ as resolveProvider, bR as resolveResearchShell, bS as scopeAllowed, bT as scriptBodyOf, bU as scriptBodyText, bV as scriptTaskText, bW as sharedMcpServer, bX as taskCompletionContract, bY as timeLimitText, bZ as toApprovalDecision, b_ as toOrchestratorOptions, b$ as toolAllowed } from './IRunner-BwzyUVIL.mjs';
-import { R as RunnerModeInfo } from './ModeResolver-b_7bPlBS.mjs';
-export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-b_7bPlBS.mjs';
+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.mjs';
+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.mjs';
+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-CcB8yELZ.mjs';
+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-CcB8yELZ.mjs';
+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-DFVpe6aU.mjs';
+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-DFVpe6aU.mjs';
+import { R as RunnerModeInfo } from './ModeResolver-CA2fUU9h.mjs';
+export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-CA2fUU9h.mjs';
 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;
@@ -975,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;
@@ -985,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;
@@ -1030,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;
@@ -1814,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).
@@ -1846,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);
@@ -1897,6 +1905,7 @@ declare class RunnerProcess {
      */
     dispose(): void;
     private end;
+    private placedEnded;
     private appendStderr;
 }
 
@@ -2005,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.
@@ -2187,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
@@ -3097,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
@@ -3174,10 +3472,14 @@ interface SessionEventRelayDeps {
     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). */
@@ -3210,9 +3512,11 @@ declare class SessionEventRelay {
     private readonly store;
     private readonly orchestrator;
     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;
@@ -3239,6 +3543,8 @@ 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;
     /**
@@ -3307,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 {
@@ -3467,6 +3777,8 @@ interface SessionRuntimeSettings {
     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. */
@@ -3479,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
@@ -3562,8 +3895,31 @@ interface SessionDeps {
     };
     /** 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
@@ -3608,6 +3964,15 @@ interface SessionParts {
     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
@@ -3636,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;
     /**
@@ -3685,16 +4051,44 @@ declare class Session {
     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.
@@ -3723,8 +4117,10 @@ declare class Session {
     /** What will not move without a person, derived afresh from the plan, the run and the pending approvals (ADR-0053). */
     escalations(): Escalation[];
     private judgedEscalations;
-    /** The user's answer to an escalation; see {@link ExecutionCommands.answerEscalation}. */
-    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean): Promise<CommandOutcome>;
+    /** 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. */
@@ -3785,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. */
@@ -3803,6 +4200,8 @@ declare class Session {
     private userRunSettings;
     /** 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;
@@ -3850,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[];
     /**
@@ -3912,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
@@ -3922,7 +4473,10 @@ 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). */
@@ -3947,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,
@@ -3985,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
@@ -3998,6 +4566,9 @@ 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
@@ -4125,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
@@ -4372,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
@@ -4380,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
@@ -4509,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
@@ -4532,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
@@ -4583,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'>>;
@@ -4649,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;
@@ -5033,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
@@ -5048,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;
@@ -5056,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;
@@ -5065,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);
@@ -5072,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
@@ -5081,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;
@@ -5146,7 +5752,8 @@ 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;
@@ -5383,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 {
@@ -5474,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, 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, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LeaseHost, LegacyPlanState, LiveTail, LiveTailOptions, Mandate, 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, 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, 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, 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, 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, notifyCommandOf, openCodeGoAccountLimitCollector, openTaskLog, 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, shellQuoted, 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 };