@ordewell/core 0.11.3 → 0.12.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { az as RunnerId, au as ResearchProgress, b6 as UsageRecord, at as ResearchLogEntry, aS as Task, i as DiscoveredModel, I as IIsolationPreview, x as IWorktreeIsolation, $ as IsolationTaskStatus, a0 as IsolationView, a8 as PlanIsolation, a1 as LegacyPlanState, aA as RunnerSessionCost, as as ReportedWindow, ag as PlannerUsage, a$ as TaskSkillSnapshot, aO as SkillsService, E as ExecutionActor, b0 as TaskSnapshot, a9 as PlanState, b8 as Verdict, aP as StoredHandoff, p as HandoffCheck } from './Task-BL4Idm9r.js';
-export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, C as ContextCheckpoint, c as ContextFill, d as ConversationMessage, e as CostProvenance, D as DEFAULT_LOOP_ROUNDS, f as DEFAULT_RUNNERS, g as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as DIGEST_FINDINGS, j as ExecutionCommandName, k as ExecutionRecord, F as FindingSeverity, G as GuardTarget, l as GuardTrip, H as HANDOFF_LIMITS, m as HANDOFF_PUSH_CHARS, n as Handoff, o as HandoffArtifact, q as HandoffCommit, r as HandoffDigest, s as HandoffEvidence, t as HandoffFinding, u as HandoffPatch, v as HandoffPreviewOptions, w as HandoffTaskName, y as IntegrationDisposal, z as InvalidSkill, J as IsolationAvailability, K as IsolationHandoff, L as IsolationHandoffRepo, M as IsolationInactiveReason, N as IsolationLandedTask, O as IsolationLanding, P as IsolationMergeBlock, Q as IsolationMergeBlockReason, R as IsolationMergeResult, S as IsolationOutcome, T as IsolationPreview, U as IsolationPruneResult, V as IsolationRemoval, W as IsolationRepo, X as IsolationRun, Y as IsolationTaskRecord, Z as IsolationTaskRef, _ as IsolationTaskRepo, a2 as LoopSubject, a3 as MAX_LOOP_ROUNDS, a4 as ModelUsage, a5 as PatchFlag, a6 as PatchView, aa as PlanStatus, ab as PlanUsage, ac as PlannerCompaction, ad as PlannerCompactionOutcome, ae as PlannerContextPause, af as PlannerResendState, ah as PrepareIntent, ai as PreparedTask, aj as PreservedWork, ak as PreviewRepo, al as PreviousWork, am as REPORT_MAX_CHARS, an as RefusedRemoval, ao as RepairEvidence, ap as ReplyRun, aq as RepoGroupLayout, ar as RepoHead, av as ResearchStep, aw as ResearchStepOutcome, ay as RunSettings, aB as SEVERITY_LABEL, aC as ScriptConsent, aD as ScriptResult, aE as SessionBilling, aF as SetupFailure, aG as ShadowedSkill, aH as SkillAppliesTo, aI as SkillCatalog, aJ as SkillInfo, aK as SkillLoad, aL as SkillLoadNotice, aM as SkillMetadata, aN as SkillSource, aR as SupervisorLevel, aV as TaskIsolation, aW as TaskIsolationState, aX as TaskLoop, aY as TaskModelAssignment, b1 as TaskStatus, b2 as TaskType, b3 as TaskUsageSummary, b4 as TreeSnapshot, b5 as UsageLine, b7 as UsageTotals, b9 as VerificationCheck, ba as addAttemptUsage, bb as addModelUsage, bc as addPlannerUsage, bd as addUsage, be as addUsageTotals, bf as artifactLines, bg as betweenRounds, bh as boundedHandoffLines, bi as byteSize, bj as checkHandoff, bk as checkOf, bl as contextMeterText, bm as contextMeterTitle, bn as costText, bo as countedSessionCost, bp as createEmptyPlan, bq as createSkillsService, br as createTask, bs as endAttemptUsage, bt as findingLines, bu as flattenTasks, bv as flattenTasksWithParents, bw as formatCost, bx as formatTokenCount, by as handoffDigest, bz as handoffLines, bA as handoffPreviewLines, bB as handoffReferenceText, bC as handoffWakeLines, bD as inLoop, bE as isAwaitingReason, bF as isMeasured, bG as isSupervisorLevel, bH as isUserMessage, bI as loopRemovalRefusal, bJ as loopRoundOf, bK as migratePlanState, bL as modelCostTitle, bM as namedHandoff, bN as openingLines, bO as outOfRounds, bP as partedPromptUsage, bQ as patchChangesText, bR as patchFlagText, bS as patchLines, bT as patchLinesText, bU as patchText, bV as patchView, bW as pausedOnLimit, bX as planUsage, bY as plannerContextFill, bZ as readableTaskIds, b_ as rejoinPlanTree, b$ as resumedSessionWindow, c0 as savedPatchOf, c1 as savedPatchView, c2 as savedPatchViews, c3 as severityLabel, c4 as startAttemptUsage, c5 as storedHandoff, c6 as subagentCostTitle, c7 as taskUsageSummary, c8 as tasksTotalText, c9 as usageLine, ca as usageText, cb as waitsForApproval, cc as withPatch, cd as worstSeverity } from './Task-BL4Idm9r.js';
-import { da as TurnBudgets, b4 as PlanIntake, ao as IWebFetcher, V as ConversationTurn, bj as PlannerModes, by as ResolveAll, dj as WebReadPolicy, dg as WebRead, dh as WebReadDecision, di as WebReadOptions, b0 as PendingApprovals, al as IAiService, ba as PlannerContextDeps, bb as PlannerContextStatus, M as ContextCondenseRequest, T as ConversationRequest, be as PlannerModelCandidate, bL as RunnerAuthExec, bK as RunnerAuth, b as AccountLimitBucket, c as AccountLimitSnapshot, t as AssignmentWriter, s as AssignmentScope, cS as TaskQueryCatalog, q as AssignmentCatalog, bO as RunnerCatalog, c6 as SessionMessage, b_ as SessionBroadcaster, c8 as SessionNotice, b8 as PlanStore, cM as TaskOrchestrator, at as IsolationRunController, aX as OrchestratorObserver, cB as TaskLogEvent, bx as ResearchTasks, an as INotification, ag as GlobalRunSettings, c1 as SessionHeld, c3 as SessionLease, bd as PlannerConversationHost, bc as PlannerConversation, aa as ExecutionCommand, F as CommandOutcome, a$ as PendingApproval, P as ConversationCompaction, bA as RewindTarget, bJ as RunView, bE as RunMergeView, bC as RunActivity, cP as TaskOutputSource, aw as LeaseHost, dd as UserSettings, aB as LiveTailOptions, aA as LiveTail, c7 as SessionMeta, bi as PlannerModelStore, bh as PlannerModelRecall } from './runSettingsText-DVOd7vKC.js';
-export { A as ACT_RISK, a as AUTORUN_RISK, d as AccountLimitStatus, e as AccountLimitWindow, f as AccountLimitsFrame, g as AccountLimitsMessage, h as AdoptSessionResponse, i as ApplyTaskOpsResult, j as ApprovalAnswerResponse, k as ApprovalBlock, l as ApprovalRequestMessage, m as ApprovalStatus, n as ApprovalsResponse, o as ApproveReviewResponse, p as AskOptions, r as AssignmentIssue, u as AutoMergeTrigger, B as BlockingSubject, C as CHAT_COMMANDS, v as CHECKPOINT_TRUNCATE_LENGTH, w as CancelPlanningResponse, x as CancelResumeResponse, y as CliAgentAiService, z as CliAgentAiServiceDeps, D as CommandBlock, E as CommandDescriptor, G as CommandPayload, H as CommandStatus, I as CommandsResponse, J as CompactionBlock, K as CompactionStatus, L as Consent, N as ConversationBusyError, O as ConversationCompactResponse, Q as ConversationEditError, R as ConversationForkResponse, S as ConversationInput, U as ConversationRewindResponse, W as ConversationView, X as DEFAULT_WEB_READ_BUDGET, Y as DaemonErrorCode, Z as DecideOptions, _ as DiffRow, $ as DiffRowKind, a0 as DiffStat, a1 as DisplayBlock, a2 as EMPTY_CONVERSATION, a3 as EMPTY_HOLD, a4 as EMPTY_RUN, a5 as EMPTY_TASK_LOG, a6 as EMPTY_TASK_LOG_FOLLOW, a7 as ErrorBody, a8 as ExecuteCommandResponse, a9 as ExecuteResponse, ab as ExecutionCommands, ac as ExecutionHost, ad as ExecutionSummary, ae as GatedConversation, af as GeneratePlanResponse, ah as HEADLESS_CLI_COMMANDS, ai as HandoffBlock, aj as HandoffForkRepo, ak as HandoffPeekSubject, am as IDLE_ACTIVITY, ap as IsolationDiffResponse, aq as IsolationMergeResponse, ar as IsolationPreviewNotice, as as IsolationPreviewResponse, au as LEASE_HEARTBEAT_MS, av as LEASE_STALE_MS, ax as LeaseHostKind, ay as LeaseHostOptions, az as LiveOutputLookup, aC as LocalEntry, aD as LoopCheckFacts, aE as LoopCheckState, aF as LoopGuard, aG as MappedTool, aH as MarkdownToken, aI as MergeGateEntry, aJ as MergeGateResponse, aK as MergeWordingHandoff, aL as MessageBlock, aM as MessageRole, aN as ModelsResponse, aO as NOT_STARTED, aP as NO_TURN, aQ as NewTaskFields, aR as NotificationAction, aS as OUTPUT_LINES_DEFAULT, aT as OUTPUT_LINES_MAX, aU as OkResponse, aV as OpRef, aW as OpRefusal, aY as OutputPreview, aZ as OverrideDirection, a_ as PLANNED_WITH_LABEL, b1 as PendingApprovalsOptions, b2 as PlanBlock, b3 as PlanBlocks, b5 as PlanMarkerStatus, b6 as PlanResponse, b7 as PlanSnapshot, b9 as PlannerCommandSyntax, bf as PlannerModelChoice, bg as PlannerModelMemory, bk as PlannerNotReady, bl as PlannerNotReadyError, bm as PlannerReadinessConfig, bn as PlannerSubmission, bo as PlannerTurnDiscardedError, bp as PlannerTurnStoppedError, bq as PlannerUsageLimitError, br as PrdResponse, bs as PromptHold, bt as REPORT_PREVIEW_LINES, bu as RUN_SETTINGS_DEFAULTS, bv as ReadRunnerAuthOptions, bz as ResolveConflictResponse, bB as RewindTargetsResponse, bD as RunInput, bF as RunSettingsError, bG as RunSnapshotFrame, bH as RunTask, bI as RunTaskStatus, bM as RunnerAuthExecOptions, bN as RunnerAuthExecResult, bP as RunnerLoadedBlock, bQ as RunnersResponse, bR as STOPPED_BEFORE_START, bS as SUPERVISOR_LEVELS, bT as SUPERVISOR_LEVEL_LABEL, bU as SerializedConversationMessage, bV as SerializedPendingTurn, bW as SerializedPlan, bX as SerializedTask, bY as SerializedTaskStatus, bZ as ServerInfoResponse, b$ as SessionData, c0 as SessionFrame, c2 as SessionHeldError, c4 as SessionLeaseRecord, c5 as SessionListResponse, c9 as SessionResponse, ca as SettingsResponse, cb as SettingsService, cc as SettingsUpdateResponse, cd as SkillInvocation, ce as SkillLoadBlock, cf as SkillToken, cg as StartAdmission, ch as StopResponse, ci as StreamStamp, cj as SubagentBlock, ck as SubagentChild, cl as SubagentStatus, cm as SupervisorPolicy, cn as SurfacePlan, co as SurfacePlanState, cp as SurfaceTask, cq as TASK_QUERY_ANSWER_MAX_CHARS, cr as TASK_QUERY_ANSWER_OR_OPS, cs as TASK_QUERY_FIELDS, ct as TASK_QUERY_PROTOCOL, cu as TASK_QUERY_REMINDER, cv as TERMINAL_UI_COMMANDS, cw as TakenPrompt, cx as TaskAction, cy as TaskAttemptSnapshot, cz as TaskLogAttemptsResponse, cA as TaskLogBatch, cC as TaskLogFollow, cD as TaskLogFollowInput, cE as TaskLogHeaderKind, cF as TaskLogHeaderTask, cG as TaskLogHeaderUsage, cH as TaskLogHeaderView, cI as TaskLogResponse, cJ as TaskLogView, cK as TaskMessageResponse, cL as TaskOp, cN as TaskOrchestratorDeps, cO as TaskOrchestratorOptions, cQ as TaskPlacement, cR as TaskQuery, cT as TaskQueryField, cU as TaskRef, cV as TaskRowAction, cW as TaskRowContext, cX as TaskRowHandoff, cY as TaskRowIsolation, cZ as TaskRowKind, c_ as TaskRowLoop, c$ as TaskRowPlacement, d0 as TaskRowSubject, d1 as TaskRowUsage, d2 as TaskRowView, d3 as TaskRunFacts, d4 as TaskStatusKind, d5 as ThinkingDisplayBlock, d6 as ToolBlock, d7 as ToolHeadline, d8 as ToolStatus, d9 as TreeTask, db as TurnGate, dc as UsageBlock, de as WAITS_FOR_APPROVAL_LABEL, df as WakeUpItem, dk as Worded, dl as WorkspacesResponse, dm as abbreviateHome, dn as accountLimitPercentText, dp as accountLimitWindowLabel, dq as accountLimitsOf, dr as accountLimitsText, ds as accountLimitsTitle, dt as aheadOfDraft, du as applyTaskOps, dv as approvalKindText, dw as approvalLabel, dx as approvalStatusText, dy as assignedRunnerOf, dz as assignmentIssue, dA as assignmentIssueText, dB as attachingLabel, dC as automergeSummary, dD as autorunSummary, dE as awaitingLabel, dF as blockNotice, dG as blockNotices, dH as blockedByLabel, dI as blockingFailures, dJ as canMergeTasks, dK as canSetDependencies, dL as canSplitTask, dM as capConflictFiles, dN as cardEditNeedsUnstarted, dO as cardEditable, dP as checkoutRule, dQ as classifyOutcome, dR as coalesceTaskLog, dS as compactionText, dT as confirmedOverride, dU as createAiService, dV as dependencyCandidates, dW as dependentsNotice, dX as dependentsOf, dY as describeHeld, dZ as describeHolder, d_ as describeIsolationPreview, d$ as describeMergeResult, e0 as describePlannerNotReady, e1 as diffRows, e2 as diffStat, e3 as diffSummary, e4 as digestTaskLog, e5 as drainNext, e6 as editableWhileRunning, e7 as executionSummary, e8 as followTaskLog, e9 as followTurn, ea as fromTranscript, eb as getSettingsPath, ec as handoffBaseLine, ed as handoffBranchName, ee as handoffFindingsText, ef as handoffPeekParts, eg as hasAccountLimits, eh as hasHiddenDetail, ei as hasLongReport, ej as holdLabel, ek as holdPrompt, em as isRepoGroup, en as isTaskRunning, eo as lastServedModel, ep as loadedSkillTokens, eq as logContinues, er as logResumes, es as loopBodyLabel, et as loopBodyRound, eu as loopCheckLabel, ev as loopCheckState, ew as loopLeaveNotice, ex as loopRowParts, ey as manualOverrideConfirmation, ez as manualOverrideStopFirst, eA as mapAgentTool, eB as markAction, eC as markdownHtml, eD as markdownTokens, eE as mergeOutcome, eF as mergeTarget, eG as namedRepos, eH as newTaskFields, eI as noExecutorRefusal, eJ as normalizeAgentArgs, eK as opRefusalText, eL as opsEditable, eM as outputLines, eN as outputPreview, eO as overrideNeedsConfirmation, eP as parseCount, eQ as parseSwitch, eR as parseTaskOpsJson, eS as parseTaskQueryJson, eT as pastGateConfirmation, eU as planBlocks, eV as planMarkerParts, eW as plannerMessage, eX as plannerNotReady, eY as plannerNotReadyFor, eZ as plannerTranscript, e_ as processLeaseHost, e$ as ranSealed, f0 as readRunnerAuth, f1 as receiptLabel, f2 as reconcileApprovals, f3 as recordRunnerAuth, f4 as recordedRunnerAuth, f5 as reduceConversation, f6 as reduceRun, f7 as reduceTaskLog, f8 as renderTaskQueryAnswer, f9 as repairedLanded, fa as repairedNotice, fb as repeatingChecks, fc as replayTaskLog, fd as repoBaseLine, fe as repoResultLines, ff as reposWithWork, fg as resetRunnerAuth, fh as resolveSkillInvocation, fi as resolveTaskRef, fj as resolveUserTaskRef, fk as resumeLabel, fl as resumeTime, fm as runHoldsEditors, fn as runSettingsOf, fo as runnerToolSubject, fp as scriptExitText, fq as scriptRunText, fr as secondsText, fs as serializePlan, ft as serializeTask, fu as serializeTaskStatus, fv as skillTokens, fw as skippedLabel, fx as stopTurn, fy as subtreeIds, fz as summarizeToolCall, fA as supervisorSummary, fB as surfacePlan, fC as surfacePlanState, fD as takeAt, fE as taskActionCommand, fF as taskChatAvailable, fG as taskLogCommands, fH as taskLogForSurface, fI as taskLogHeaderView, fJ as taskOrderLabel, fK as taskPlacement, fL as taskQuerySignature, fM as taskRef, fN as taskRefOf, fO as taskRowActions, fP as taskRowView, fQ as taskStartedNotice, fR as taskStatusKind, fS as textHasTaskOps, fT as textHasTaskQuery, fU as titledRefs, fV as titledTaskRef, fW as titledTaskRefOf, fX as toTaskLogEvent, fY as toolHeadline, fZ as trailerSummary, f_ as trimToolOutput, f$ as truncateCheckpointSummary, g0 as unsendAll, g1 as unsendLatest, g2 as wakeUpItems, g3 as walkPlan, g4 as withoutSealedMark, g5 as workspaceEnvOf } from './runSettingsText-DVOd7vKC.js';
-import { O as IConfig, P as IFileSystem, am as PlannerToolHandler, aj as PlannerShellSandbox, aw as ResearchShell, N as IApproval, au as ReadFileOpts, br as ToolOutcome, L as GrepOptions, b2 as ShellLaunch, K as GlobOptions, H as FindSymbolOptions, B as BashOptions, bm as TaskShellSite, bl as TaskShell, az as RuleWord, af as PlannerAllowlist, aW as ScriptBody, Q as IRunner, ag as PlannerBackendId, ap as ProviderModelLists, f as AiProvider, n as ApprovalModeSetting, aO as RunnerRegistry, aH as RunnerEnv, a8 as OrchestratorOption, d as AgentProcessDeps, bf as TaskModeAgentAdapter, e as AgentStartOptions, a as AgentAdapter, c as AgentEvent, aE as RunnerCommand$1, s as AttachState, k as ApprovalDecision, an as ProjectMcpServer, R as IRunnerSession, o as ApprovalPolicy, j as ApprovalAnswer, a9 as OrdewellMcpServer, bc as TaskCompleteArgs, aX as ScriptExit, t as CheckpointAnswer, b6 as StructuredTurnEnd, b5 as StructuredEvent, be as TaskMessageFrom, ar as QueuedTaskMessage, bn as TaskStartOptions, bo as TaskTokenScope, a0 as McpToolReply, bq as TaskWebReads, av as ReadTaskArgs, i as ApplyPatchArgs, aJ as RunnerManifest, bk as TaskRunnerFlags } from './IRunner-DOMtDTVt.js';
-export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, l as ApprovalKind, m as ApprovalMode, p as ApprovalPolicyOptions, q as ApprovalRequest, r as ApprovalSource, C as CatalogModel, u as CheckpointArgs, v as CommandClassification, w as CommandTier, x as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, y as DEFAULT_SCRIPT_TIMEOUT_MS, z as DENY_ALL, E as DiscoveryCommand, F as EditPlanArgs, G as FetchAllProviderModelsOptions, I as GIT_READONLY_SUBCOMMANDS, J as GREP_DEFAULT_HEAD_LIMIT, M as GrepOutputMode, S as InvokedCommand, T as LineBuffer, U as ListModelsArgs, V as ListRunnersArgs, W as LoadSkillArgs, X as McpClientConfig, Y as McpCredential, Z as McpRefusal, _ as McpTool, $ as McpToolContext, a1 as MessageTaskArgs, a2 as ModelCatalog, a3 as ModelShortcut, a4 as ORCHESTRATOR_SHORTCUTS, a5 as ORDEWELL_MCP_PATH, a6 as ORDEWELL_MCP_SERVER_NAME, a7 as OneTaskArgs, aa as OwnSealedRuns, ab as OwnerOnlyFile, ac as PLANNER_EXECUTION_TOOLS, ad as PLANNER_SANDBOX_DOCS, ae as PLANNER_TOOLS, ah as PlannerSandboxAvailability, ai as PlannerSandboxDeps, ak as PlannerStartOptions, al as PlannerTokenScope, ao as ProviderCredentialSource, aq as ProviderModelsResult, as as READ_ONLY_TASK_TOOLS, at as REFUSED_COMMANDS, ax as ResearchShellDeps, ay as RetryTaskArgs, aA as RunCommandArgs, aB as RunPlanArgs, aC as RunnerAuthSpec, aD as RunnerAuthStatus, aF as RunnerCommandKind, aG as RunnerEntry, aI as RunnerFeatures, aK as RunnerMcpServer, aL as RunnerMode, aM as RunnerModelDiscovery, aN as RunnerModelRef, aP as SEALED_LIMITS, aQ as SEARCH_EXCLUSIONS, aR as SandboxBackend, aS as SandboxInvocation, aT as SandboxLaunch, aU as SandboxLimits, aV as SandboxProfile, aY as ScriptFullOutput, aZ as ScriptRun, a_ as ScriptStatus, a$ as SealedAvailability, b0 as SealedRunOptions, b1 as ShellDialect, b3 as SpawnFn, b4 as StandingDecision, b7 as SubmitPlanArgs, b8 as TASK_COMPLETE_TOOL, b9 as TASK_COMPLETION_CONTRACT, ba as TASK_SEALED_LIMITS, bb as TASK_TOOLS, bd as TaskDiffArgs, bg as TaskModeUnsupportedError, bh as TaskOutputArgs, bi as TaskQueryArgs, bj as TaskRunCommandArgs, bp as TaskToolHandler, bt as approvalScopes, bu as classifyCommand, bv as clearPlannerSandboxCache, bw as clearResearchShellCache, bx as collectProviderCredentials, by as commandAllowedBy, bz as commandLine, bA as effectiveApprovalMode, bB as enabledRunners, bC as fetchAllProviderModels, bD as findRunnerCommand, bE as isGranted, bF as isRunnerApproval, bG as knownModelId, bH as mcpClientConfig, bI as ownerOnlyConfigFile, bJ as parseAllowlist, bK as parseApprovalModeSetting, bL as researchShellWarning, bM as researchToolsPath, bN as resolveModelShortcut, bO as resolvePlannerSandbox, bP as resolveProvider, bQ as resolveResearchShell, bR as scopeAllowed, bS as scriptBodyOf, bT as scriptBodyText, bU as scriptTaskText, bV as sharedMcpServer, bW as taskCompletionContract, bX as timeLimitText, bY as toApprovalDecision, bZ as toOrchestratorOptions, b_ as toolAllowed } from './IRunner-DOMtDTVt.js';
-import { R as RunnerModeInfo } from './ModeResolver-DyXeZ9ib.js';
-export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-DyXeZ9ib.js';
+import { 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.js';
+export { A as ApprovalRecord, a as AttemptUsage, b as AwaitingReason, B as BUILTIN_SKILL_NAMES, C as ContextCheckpoint, c as ContextFill, d as ConversationMessage, e as CostProvenance, D as DEFAULT_LOOP_ROUNDS, f as DEFAULT_RUNNERS, g as DEFAULT_SUPERVISOR_RETRY_LIMIT, h as DIGEST_FINDINGS, j as ExecutionCommandName, k as ExecutionRecord, F as FindingSeverity, G as GuardTarget, l as GuardTrip, H as HANDOFF_LIMITS, m as HANDOFF_PUSH_CHARS, n as Handoff, o as HandoffArtifact, q as HandoffCommit, r as HandoffDigest, s as HandoffEvidence, t as HandoffFinding, u as 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.js';
+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-CvZ40IPv.js';
+export { A as ACT_RISK, a as AUTORUN_RISK, d as AccountLimitStatus, e as AccountLimitWindow, f as AccountLimitsFrame, g as AccountLimitsMessage, h as AdoptSessionResponse, i as AnswerEscalationRequest, j as ApplyTaskOpsResult, k as ApprovalAnswerResponse, l as ApprovalBlock, m as ApprovalRequestMessage, n as ApprovalStatus, o as ApprovalsResponse, p as ApproveReviewResponse, q as AskOptions, s as AssignmentIssue, v as AutoMergeTrigger, B as BlockingSubject, C as CHAT_COMMANDS, w as CHECKPOINT_TRUNCATE_LENGTH, x as CancelPlanningResponse, y as CancelResumeResponse, 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-CvZ40IPv.js';
+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-DjJkYwko.js';
+export { A as AUTO_COMMANDS, b as AgentAdapterFactory, g as AllProviderModels, h as AnswerApprovalArgs, l as ApprovalKind, m as ApprovalMode, p as ApprovalPolicyOptions, q as ApprovalRequest, r as ApprovalSource, C as CatalogModel, u as CheckpointArgs, v as CommandClassification, w as CommandTier, x as CommandWords, D as DEFAULT_PLANNER_ALLOWLIST, y as DEFAULT_SCRIPT_TIMEOUT_MS, z as DENY_ALL, E as DiscoveryCommand, F as EditPlanArgs, G as FetchAllProviderModelsOptions, I as GIT_READONLY_SUBCOMMANDS, J as GREP_DEFAULT_HEAD_LIMIT, M as GrepOutputMode, S as InvokedCommand, T as LineBuffer, U as ListModelsArgs, V as ListRunnersArgs, W as LoadSkillArgs, X as McpClientConfig, Y as McpCredential, Z as McpRefusal, _ as McpTool, $ as McpToolContext, a1 as MessageTaskArgs, a2 as ModelCatalog, a3 as ModelShortcut, a4 as ORCHESTRATOR_SHORTCUTS, a5 as ORDEWELL_MCP_PATH, a6 as ORDEWELL_MCP_SERVER_NAME, a7 as OneTaskArgs, aa as OwnSealedRuns, ab as OwnerOnlyFile, ac as PLANNER_EXECUTION_TOOLS, ad as PLANNER_SANDBOX_DOCS, ae as PLANNER_TOOLS, 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-DjJkYwko.js';
+import { R as RunnerModeInfo } from './ModeResolver-CHsaoV7M.js';
+export { a as autonomyLevelLabel, p as parseAutonomyFlag, b as parseAutonomyLevel, r as runnerModesFrom } from './ModeResolver-CHsaoV7M.js';
 import { WorkerOptions, Worker } from 'worker_threads';
 import { ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
@@ -635,61 +635,6 @@ interface VersionCheck {
  */
 declare function startVersionCheck(options: VersionCheckOptions): VersionCheck;
 
-/**
- * The effect allowlist (ADR-0035): the user's standing approval for named
- * effects, beside the planner allowlist, which names reads. It pre-approves a
- * script task whose `commands` are all covered; it never covers a `script`
- * body, whose shell text no rule can be matched against.
- *
- * A rule is matched against the whole command, every word in order and flags
- * included, because an effect's flags change what it does: `git push origin
- * feature/*` covers `git push origin feature/login`, never the same push with
- * `--force`. `*` stands for one word, or inside a word for any run of
- * characters, as in the planner allowlist, except that it never stands for
- * what changes the effect: a flag (`--force`, and `/force` on Windows), a
- * refspec's force or delete (`+main`, `:main`), or a `:` outside a URL
- * (`feature/x:main`, which pushes to `main`). The rule writes any of those
- * itself. A rule spells out its operation before any `*`, so
- * `az webapp config * set` is no rule at all.
- *
- * Exclusions are the planner allowlist's `!` entries, with any `!` entry
- * written here; an exclusion wins. A command exclusion is matched as the
- * planner allowlist matches it; a path or URL exclusion holds for an argument
- * that names an absolute path or URL it covers, whole or after a `=`, `@`,
- * `:` or `,` or a short flag (`--url=…`, `-d @…`). A relative path is not
- * resolved, since the body does not say where it runs. A program named by its
- * path is a file the repository ships (ADR-0026), so it is never covered.
- * There are no built-in rules: a default would pre-approve an effect the user
- * never chose.
- */
-interface EffectRule {
-    text: string;
-    binary: string;
-    words: RuleWord[];
-}
-interface EffectRules {
-    rules: EffectRule[];
-    exclusions: PlannerAllowlist;
-    platform: NodeJS.Platform;
-    /** The entries that are no rule, each with the warning that says why it is ignored. */
-    ignored: {
-        rule: string;
-        warning: string;
-    }[];
-}
-/**
- * `entries` are the effect allowlist's; `plannerEntries` the planner allowlist
- * in force, whose `!` entries hold here too; `platform` the one the commands
- * run on, which decides how a flag is spelled and how a path resolves.
- */
-declare function parseEffectAllowlist(entries: readonly string[], plannerEntries?: readonly string[], platform?: NodeJS.Platform): EffectRules;
-/**
- * The rules, by name, that cover every command of a `commands` body, or null
- * when one command is not covered, an exclusion holds for one, or the body is
- * a `script`.
- */
-declare function effectRuleFor(list: EffectRules, body: ScriptBody): string | null;
-
 /**
  * Carries a structured task's tool requests to the session's one approval
  * seam (ADR-0018, A1), so a runner's request is answered through
@@ -946,6 +891,7 @@ declare abstract class BaseConfig implements IConfig {
     get approvalDefaults(): boolean;
     get approvalPreApproved(): string[];
     get effectAllowlist(): string[];
+    get notifyCommand(): string[];
     /**
      * Who plans when no surface setting names a planner: an explicit
      * AI_PROVIDER, then a vendor whose key is in the environment,
@@ -1820,6 +1766,8 @@ declare const ORDEWELL_SETTABLE_ENV: readonly string[];
  *   off, so every later command runs unprompted; the web-read budget bounds
  *   how much a planner may send out unasked in Full; the effect allowlist
  *   pre-approves script tasks that change real systems (ADR-0035).
+ * - The notify command is a program Ordewell starts as the user, with no
+ *   approval, on every new escalation (ADR-0053).
  * - The settings-path override is honoured by the settings service, which
  *   creates directories recursively when persisting — admitting it turns the
  *   same write into an arbitrary-path file write.
@@ -3044,6 +2992,8 @@ declare class PlannerBackend {
 type ModelsByRunner = Partial<Record<RunnerId, DiscoveredModel[]>>;
 interface SessionCatalogDeps {
     config: Pick<IConfig, 'enabledRunners' | 'autonomousMode' | 'aiProvider'>;
+    /** Whether a task's mode defaults to its runner's autonomous one: a child's mandate says, the config's level unless set (ADR-0056 M6). */
+    autonomous?: () => boolean;
     registry: Pick<RunnerRegistry, 'getManifest'>;
     modelResolver: Pick<ModelResolver, 'modelsForRunners' | 'getCachedRunnerModels'>;
     /** Read at each call: a toggle or allowlist edit made since the session was built counts (#69). */
@@ -3070,6 +3020,7 @@ declare class SessionCatalog {
     private readonly deps;
     private discovered;
     constructor(deps: SessionCatalogDeps);
+    private autonomous;
     /** The runners enabled right now. */
     enabledRunners(): RunnerId[];
     /** The runners `writer` may put a task on now ({@link assignableRunners}); undefined means any. */
@@ -3219,9 +3170,8 @@ interface SessionEventRelayDeps {
     broadcast: SessionBroadcaster;
     /** Where isolation notices go, for a host whose notifications are not seen by the user. */
     onNotice?: (notice: SessionNotice) => void;
-    store: Pick<PlanStore, 'allTasks' | 'snapshot'>;
-    orchestrator: Pick<TaskOrchestrator, 'getIdleSince' | 'getCompletionReceipt' | 'getToolsAttaching' | 'getQueuedTaskMessages' | 'getMergeGate' | 'holdReason' | 'runMergeView' | 'activity'>;
-    runs: Pick<IsolationRunController, 'taskIsolation'>;
+    store: Pick<PlanStore, 'allTasks' | 'planTasks' | 'snapshot' | 'statusMark'>;
+    orchestrator: Pick<TaskOrchestrator, 'judgingOnce' | 'getIdleSince' | 'getCompletionReceipt' | 'getToolsAttaching' | 'getQueuedTaskMessages' | 'getMergeGate' | 'holdReason' | 'loopStranded' | 'runMergeView' | 'activity' | 'taskIsolation'>;
     /** Shared with the Session, which snapshots, restores and clears it. */
     usage: PlannerUsageLedger;
     /** How many of a task's runner requests wait for an answer (ADR-0018, A1). */
@@ -3230,6 +3180,10 @@ interface SessionEventRelayDeps {
     checkpointQuestion?: (taskId: string) => string | undefined;
     /** The task waits for the user's approval to start (ADR-0035). */
     waitsForApproval?: (taskId: string) => boolean;
+    /** What waits on a person now (ADR-0053). */
+    escalations?: () => Escalation[];
+    /** The list as a status update carried it, for what must see each one with no surface attached. */
+    escalationsSent?: (list: readonly Escalation[]) => void;
 }
 /**
  * Every orchestrator event the relay announces. `onTaskSettled` is persistence
@@ -3255,13 +3209,29 @@ declare class SessionEventRelay {
     private readonly onNotice?;
     private readonly store;
     private readonly orchestrator;
-    private readonly runs;
     private readonly usage;
     private readonly awaitingApproval;
     private readonly checkpointQuestion;
     private readonly waitsForApproval;
+    private readonly escalations;
+    private readonly escalationsSent;
     private statusHeld;
     private statusOwed;
+    /** The second a status update opened: until it ends, one that can wait does. */
+    private statusWindow;
+    /** Something changed that the last status update did not carry, and it can wait for {@link statusWindow} to end. */
+    private statusDue;
+    /** The ids of what waits on a person, as the last status update carried it. */
+    private sentWaits;
+    /** {@link statusWindow} has sent a change to what waits on a person: the next change waits for it to end. */
+    private waitsSent;
+    /** The ids of the work a merge is offered on, as the last status update carried it. */
+    private sentLanded;
+    /** {@link statusWindow} has sent a change to that work: the next change waits for it to end. */
+    private landedSent;
+    /** The run as {@link statusChanged} last read it. */
+    private lastMoved;
+    private livePlan;
     /** The planner's requests announced and not yet settled, as they were announced: a surface joining now is owed them. */
     private readonly announced;
     /** The planner compaction started and not yet ended, as it was announced: a surface joining now is owed it too. */
@@ -3269,11 +3239,50 @@ 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;
+    /** Send every task's status now, whatever was sent a moment ago: for what a surface must not wait for. */
     status(plan: LegacyPlanState | null): void;
+    /**
+     * Send what is owed before something that assumes it arrived: a surface
+     * treats `execution_complete` as the end of the stream, for one, and a
+     * status update coming after it is one it may never read. Called from
+     * outside any observer too, and a surface that failed fails nothing else.
+     */
+    flushStatus(plan: LegacyPlanState | null): void;
+    /** Nothing goes out for this Session again: what was held back goes now. */
+    closeStatus(plan: LegacyPlanState | null): void;
+    /** A run's progress is at most a second late, so a thousand runners reporting cost a surface one update. */
+    private statusCanWait;
+    /**
+     * The list of what waits on a person (ADR-0053) is a judgement of the plan,
+     * so it is read only when something it reads has moved: a task's status, or
+     * whether the run is moving. An ending that leaves nobody anything to do, or
+     * a start, moves nothing in it, and a fan-out or a wave of verdicts stays
+     * one update a second.
+     */
+    private statusChanged;
+    /**
+     * The first change to what waits on a person goes out at once, and the rest
+     * wait for the second to end: every update carries every wait, so a hundred
+     * tasks failing together must not each send the plan with all those before
+     * them. The notifier reads the list as it goes out, so it is told of them
+     * then, each once.
+     */
+    private waitsMayHaveChanged;
+    /**
+     * A task in a worktree reports its landing twice and its release once, and
+     * every update carries every task, so a wide run must not send the plan per
+     * report. What a person acts on still goes first: new work to merge, like a
+     * new wait, goes at once, and the rest waits for the second to end.
+     */
+    private isolationChanged;
+    private openStatusWindow;
     /** Every task's status as it stands, in the message a status update carries. */
     statusMessage(): Extract<SessionMessage, {
         type: 'status_update';
     }>;
+    private judgedStatus;
+    /** A {@link holdStatus} is running: whoever runs it saves as it ends. */
+    get holdingStatus(): boolean;
     /**
      * Run `op` with status broadcasts held back. Store ops signal the observer
      * as they go, which would put a status_update on the wire before the
@@ -3391,6 +3400,52 @@ interface TaskEditOptions {
     requireUnstarted?: boolean;
 }
 
+/** Runs the command with `env` added to its environment; rejects when it fails. */
+type NotifyRun = (command: readonly string[], env: Record<string, string>) => Promise<void>;
+interface EscalationNotifierDeps {
+    /** The user's command, read as each new escalation appears; empty when there is none. */
+    command: () => readonly string[];
+    run: NotifyRun;
+    log: (message: string) => void;
+}
+/**
+ * Tells the user's notify command of each new escalation, once (ADR-0053). It
+ * sees the list as it goes out, so nothing here is a second reading of the run,
+ * and it remembers only ids, in memory: what a run waits on stays derived.
+ * Nothing it does reaches the run: the command is started and left, and a
+ * failure ends here. A few run at a time and the rest wait in a bounded queue,
+ * so an id dropped from a full queue still counts as told: it stays on the list.
+ */
+declare class EscalationNotifier {
+    private readonly deps;
+    /** The ids told of in this plan; null while a plan changes hands. */
+    private told;
+    private failureLogged;
+    private dropLogged;
+    private running;
+    private readonly queue;
+    constructor(deps: EscalationNotifierDeps);
+    /** The list as a status update carries it. */
+    changed(list: readonly Escalation[]): void;
+    /**
+     * A plan is on its way out, and nothing it says now is news: a run stopped
+     * by leaving its session raises waits nobody is there for. Lasts until the
+     * next {@link baseline}, so a plan on its way in says nothing either.
+     */
+    hush(): void;
+    /** What waits as a plan is adopted counts as told, so a restart does not send what was sent before it. */
+    baseline(list: readonly Escalation[]): void;
+    private tell;
+    private send;
+    private failed;
+    private dropped;
+}
+/**
+ * A command as the user wrote it: a whole argument vector, or none. A string is
+ * refused, not split, because splitting one is a shell's job and there is none.
+ */
+declare function notifyCommandOf(value: unknown): string[];
+
 /**
  * Options for plan generation. Progress is not overridable: every planner
  * progress event is translated to a SessionMessage inside the Session and
@@ -3410,6 +3465,8 @@ interface SessionRuntimeSettings {
     run?: GlobalRunSettings;
     /** Whether an API planner compacts its own context before a call that would not fit; absent means on. */
     plannerAutoCompaction?: boolean;
+    /** What a task runner loads of the user's own setup; absent means all of it. */
+    taskRunnerConfig?: TaskRunnerConfig;
 }
 declare function sessionRuntimeSettings(settings: UserSettings): SessionRuntimeSettings;
 /** Where a fork landed: the new session's id, and what adopting it needs. */
@@ -3503,6 +3560,10 @@ interface SessionDeps {
         cache?: WebResponseCache;
         searchProvider?: ISearchProvider;
     };
+    /** What runs the user's notify command (ADR-0053); the real process unless a test supplies one. */
+    runNotifyCommand?: NotifyRun;
+    /** The node this session is, below the root (ADR-0056); absent, it is the root, whose mandate its settings hold. */
+    child?: NodeAuthority;
 }
 /**
  * The composition root: builds every collaborator a Session drives and wires
@@ -3529,6 +3590,8 @@ interface SessionParts {
     /** The orchestrator's own: Session reads the run and acts on it there, Merge all aside. */
     runs: IsolationRunController;
     events: SessionEventRelay;
+    /** Told by the Session when a plan changes hands; what it sees comes from the relay. */
+    escalationNotifier: Pick<EscalationNotifier, 'hush' | 'baseline'>;
     usage: PlannerUsageLedger;
     /** The windows every stream of the session reports, saved with the plan. */
     windows: SessionWindows;
@@ -3543,6 +3606,8 @@ interface SessionParts {
     lease: (onLost: (held: SessionHeld) => void) => SessionLease;
     /** The conversation's host is the Session itself, so only the Session can make it. */
     conversation: (host: PlannerConversationHost) => PlannerConversation;
+    /** The node this session is, below the root. */
+    child?: NodeAuthority;
 }
 /**
  * The per-session execution stack — the lifecycle owner. Owns plan
@@ -3562,6 +3627,7 @@ declare class Session {
     private readonly usage;
     private readonly windows;
     private readonly events;
+    private readonly escalationNotifier;
     private readonly planner;
     private readonly orchestrator;
     private readonly runs;
@@ -3608,9 +3674,18 @@ declare class Session {
     private saveRefusedFor;
     /** User controls in flight; see {@link withSave}. */
     private controlsInFlight;
+    /** A save is owed, for the end of {@link SAVE_INTERVAL_MS}; see {@link saveSoon}. */
+    private saveTimer;
+    /** The store's status mark as last saved, or as loaded. */
+    private savedStatuses;
+    /** The user was told the disk is refusing this session's saves, and none has landed since. */
+    private saveFailureSaid;
     /** A whole-plan start opening; a second Execute joins it rather than resetting the run under it. */
     private runOpening;
     private unsubObserver;
+    /** This session's node below the root; undefined at the root, where a person remains. */
+    private readonly child;
+    private readonly authority;
     private readonly hostSessionId?;
     private currentSessionId;
     private readonly skillsService;
@@ -3625,6 +3700,8 @@ declare class Session {
      * with why it must not open: a Stop, a newer goal, or its plan scope ending.
      */
     private readonly openingsWaiting;
+    /** The installed-planner probe a turn was parked on and the surfaces were told of; null once it answered. */
+    private detection;
     /** The conversation's opening, from admission until its turn settles; see {@link behindOpening}. */
     private opening;
     private readonly editor;
@@ -3643,13 +3720,36 @@ declare class Session {
      * tools come here; see {@link ExecutionCommands}.
      */
     execute(command: ExecutionCommand, actor: ExecutionActor): Promise<CommandOutcome>;
+    /** What will not move without a person, derived afresh from the plan, the run and the pending approvals (ADR-0053). */
+    escalations(): Escalation[];
+    private judgedEscalations;
+    /** The user's answer to an escalation; see {@link ExecutionCommands.answerEscalation}. */
+    answerEscalation(id: string, option: string, note?: string, confirmed?: boolean): Promise<CommandOutcome>;
     /** Run one planner turn with its own {@link TurnEffects}, which only a turn that lands hands back. */
     private openTurn;
+    /** Each failed task, with the attempt that failed. */
+    private failedTasks;
+    /**
+     * What a run this actor begins leaves failed. The fresh chance is the user's
+     * to ask for (ADR-0053), and a supervisor's `run_plan` is a retry its guards
+     * count (ADR-0029), so only autorun and a planner leave any; autorun only what
+     * failed in the reply it follows (ADR-0030).
+     */
+    private failuresLeftBy;
     /**
      * Autorun (ADR-0030): a plan the planner submitted in the turn that just
      * ended starts as if the user had pressed Execute, through the seam, so the
      * timeline says autorun started it. Read now, not when the turn opened: the
-     * switch is the user's to flip at any time.
+     * switch is the user's to flip at any time. Work already live, a task the
+     * planner started with `run_task` in that turn, joins it as one scheduled
+     * run, in Full; the seam keeps it out of live work in Guarded. A scheduled
+     * run has the plan's tasks, waiting on a person or a reset or not, so autorun
+     * skips it, and starts nothing over what a usage limit holds: a restart
+     * would take back that run's pause and failures (ADR-0053).
+     * A plan it could not start says why, and a Stop since the plan was submitted
+     * withdraws the start as it withdraws any (ADR-0029), unless a run opened
+     * after that Stop has the plan already. What failed in that turn stays
+     * failed: the fresh chance is the user's to ask for (ADR-0053).
      */
     private autorunSubmitted;
     /**
@@ -3701,7 +3801,18 @@ declare class Session {
     runSettings(): GlobalRunSettings;
     /** The user's run settings as they stand for this session (ADR-0030). */
     private userRunSettings;
-    /** A call at the seam, in the transcript where it happened and on every surface at once. */
+    /** What this node may do without a person, as it stands now (ADR-0056 M1): derived at the root, and never saved. */
+    mandate(): Mandate;
+    /** Each value where it lives today; the level is the caller's to name (ADR-0056 M1). */
+    private rootSettings;
+    private effectRules;
+    /** Whether this node's tasks default to their runner's autonomous mode. */
+    private autonomous;
+    /**
+     * A call at the seam, in the transcript where it happened and on every
+     * surface at once. The call has happened by now, so a failed save is said
+     * rather than thrown: a Stop that took must not answer as refused.
+     */
     private recordExecution;
     /** Whether the user approved this task to run; see {@link ApprovalRecord.isApproved}. */
     isApproved(taskId: string): boolean;
@@ -3726,6 +3837,10 @@ declare class Session {
     plannerCompaction(): Extract<SessionMessage, {
         type: 'planner_compaction';
     }> | undefined;
+    /** Whether a planner turn waits on the installed-planner probe, for a surface that joins or reconnects meanwhile. */
+    plannerDetection(): Extract<SessionMessage, {
+        type: 'planner_detection';
+    }>;
     /** Scopes the user granted this session — surfaced so a UI can show what is already allowed. */
     approvedScopes(): string[];
     /** The stable id this session persists under — matches the host's id when one was provided. */
@@ -3772,6 +3887,23 @@ declare class Session {
      * write: a turn holds what it writes until the mutation that lands it.
      */
     private persist;
+    /**
+     * What a change to the plan owes the disk. A task's status is what a
+     * decision and a reload read, so a changed one is saved at once, and what
+     * changed beside it goes with it; anything else can wait for the timer.
+     */
+    private saveChange;
+    /** Owe a save, made once however often this is called before it comes. */
+    private saveSoon;
+    /**
+     * A save nothing that follows may depend on: a full disk must not take the
+     * daemon down, nor leave a stop or a close half done, its run live and its
+     * lease held. Said once a failing stretch, since the timer tries again for
+     * as long as the disk refuses.
+     */
+    private tryPersist;
+    /** Make the save owed, before the plan it is owed for goes. */
+    private settleSaves;
     /** A new plan on a long-lived Session gets its own persisted identity (unless the host fixed one). */
     private remintSessionId;
     /**
@@ -3793,6 +3925,8 @@ declare class Session {
      * now prepares, so the run here stops.
      */
     private leaseLost;
+    /** Something of the run would go on if left: work, a resume, a start on its way, or a loop a retry would carry on (ADR-0045 L5). */
+    private get stopOwed();
     /**
      * The plan scope ends: everything that belongs to the plan this Session
      * holds goes, so nothing of it reaches the next one — a new plan, another
@@ -3826,9 +3960,9 @@ declare class Session {
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
-     * boundary rewrites `in_progress` to `pending` — nothing is running when a
-     * session comes off a file — so a surface that re-reads the plan mid-run must
-     * come here instead, or every task it is watching reads as never started.
+     * boundary fails an `in_progress` task — nothing is running when a session
+     * comes off a file — so a surface that re-reads the plan mid-run must come
+     * here instead, or every task it is watching reads as interrupted.
      * An archived snapshot carries the task as it is now: a retry or continue
      * keeps the archive while the live task runs on and spends more.
      */
@@ -3864,6 +3998,12 @@ declare class Session {
      * no longer be refused as one sent during it.
      */
     private plannerTurnMayOpen;
+    /**
+     * The installed-planner probe, for a turn at the gate to wait on. No planner
+     * has heard of that turn, so the surfaces are told what it waits for, once
+     * however many wait.
+     */
+    private plannerDetected;
     /** End every turn waiting at the planner gate before it opens; false when none was. */
     private endWaiting;
     /**
@@ -4021,7 +4161,9 @@ declare class Session {
      * as executing does, and the run takes them in. A run the scheduler was not
      * driving, one task started on its own, becomes the plan's run, as Execute
      * would make it. The planner's run_plan joins with `approved` 0: the
-     * scheduler starts only approved tasks, so `left` tasks still wait.
+     * scheduler starts only approved tasks, so `left` tasks still wait. A run a
+     * usage limit holds stays held, and the line says so, since nothing it names
+     * starts before the reset.
      */
     private joinRun;
     private startOneTask;
@@ -4105,6 +4247,8 @@ declare class Session {
     runSnapshot(): RunView;
     /** The ancestors a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
     mergeGate(taskId: string): string[];
+    /** What reverting the task would do now, for a surface to confirm before `revert_task` (ADR-0054). Reads only. */
+    revertPreview(taskId: string): Promise<TaskRevertPreview>;
     /** What Merge all would merge now; null once everything landed is merged. */
     runMergeView(): RunMergeView | null;
     /** The run's integration branch against its base ref, as a unified diff. */
@@ -4134,6 +4278,11 @@ declare class Session {
      * otherwise (Mark not done), because only they know whether they kept the work.
      */
     discardRun(): Promise<void>;
+    /**
+     * Narrower than {@link stopOwed}: a run that ended on a failure, or whose
+     * loop a body task stopped, is what these are for. Such a loop ends with the
+     * run, once git has let it go, so a refused discard leaves it standing.
+     */
     private requireSettledRun;
     /** Add the task that merges a conflicted task's branch by hand; see {@link PlanEditor.addConflictResolver}. */
     resolveConflictAsTask(taskId: string): Promise<LegacyPlanState | null>;
@@ -4142,8 +4291,11 @@ declare class Session {
      * one queued behind a planner turn's edit, one waiting on its card, one
      * still opening its run. A card still asking is cleared, so its start
      * answers as stopped rather than waiting on a question that no longer stands.
+     * The user's stands the supervisor down too; a supervisor's own, for a change
+     * it means to run, does not.
      */
-    stopExecution(): void;
+    stopExecution(actor?: ExecutionActor): void;
+    private stopRun;
     /** Something will start without being asked again; see {@link TaskOrchestrator.startsPending}. */
     get startsPending(): boolean;
     /**
@@ -4159,11 +4311,16 @@ declare class Session {
      * a hold would stall every task's status for as long, and an
      * `execution_complete` the control triggers would overtake the status held
      * back — which a surface treats as the end of the stream. Instead each status
-     * announced while one runs is saved first (see {@link observer}).
+     * announced while one runs is saved first (see {@link observer}). The save
+     * that ends it fails as {@link saved}'s does.
      */
     private withSave;
-    private saveForControl;
-    /** A control that finishes synchronously: its status is held until it is saved. */
+    /**
+     * A control that finishes synchronously: its status is held until it is
+     * saved. Its effect has landed by then, so a failed save is said rather than
+     * thrown: the caller would report a control that took as one that failed,
+     * and a surface would keep showing what it answered.
+     */
     private saved;
     /**
      * The one mutation seam: every structural plan mutation runs the same
@@ -4200,6 +4357,8 @@ declare class Session {
         sessionId?: string;
         persist?: boolean;
     }): void;
+    /** The plan a load adopts goes to disk first; whoever asked hears that nothing here changed if it cannot. */
+    private writeLoaded;
     /**
      * Take the loaded plan's run over, then correct what the surfaces were told
      * by what git found: the saved record cannot know what the user merged
@@ -4993,6 +5152,8 @@ declare function continuability(task: Task): Continuability;
 declare function canContinue(task: Task): boolean;
 
 declare function stripAnsi(text: string): string;
+/** `text` as one word of a POSIX shell, whatever it holds. */
+declare function shellQuoted(text: string): string;
 
 /**
  * A workspace path that does not exist, or exists but is not a directory.
@@ -5313,4 +5474,4 @@ declare function parseVersion(version: string): number[] | null;
 /** Negative, zero or positive as `a` is older than, the same as, or newer than `b`; an unreadable version sorts oldest. */
 declare function compareVersions(a: string, b: string): number;
 
-export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, AccountLimitBucket, type AccountLimitCollector, type AccountLimitListener, AccountLimitMonitor, type AccountLimitMonitorOptions, type AccountLimitReading, AccountLimitSnapshot, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApprovalAnswer, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, AssignmentScope, BaseAiService, BaseConfig, BaseFileSystem, BashOptions, BatchQuoteError, BufferedTaskOutputSource, type ByPlannerBackend, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CappedRows, CheckpointAnswer, type CheckpointListener, type ClaudeAccountLimitOptions, ClaudeCodeAdapter, type CodexAccountLimitOptions, CodexAdapter, CodexSandboxAvailability, CommandLineTooLongError, CommandOutcome, type ConfiguredPlanner, ConsoleLogger, ContextCollector, type Continuability, ConversationCompaction, type ConversationFork, ConversationRequest, type ConversationRewind, ConversationTurn, DAEMON_SUBPROTOCOL, DAEMON_TOKEN_SUBPROTOCOL_PREFIX, DEFAULT_MAX_PARALLEL, type DirEntry, DiscoveredModel, DuckDuckGoSearchProvider, type EffectRules, EmbeddedNewlineError, type EnvAdmission, EnvConfig, type ExecImpl, ExecutableNotFoundError, ExecutionActor, ExecutionCommand, FindSymbolOptions, GREP_PCRE_PROBE_ARGS, GeminiService, type GitExecFn, GlobOptions, GlobalRunSettings, type GrepInvocation, GrepOptions, type GrepRegex, HARNESS_PLANNER_REASON, HandoffCheck, type HasBinFn, HttpWebFetcher, type HttpWebFetcherOptions, IAiService, IApproval, IConfig, IFileSystem, IIsolationPreview, type ILogger, INotification, IRunner, IRunnerSession, type ISearchProvider, IWorktreeIsolation, IsolationTaskStatus, IsolationView, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LeaseHost, LegacyPlanState, LiveTail, LiveTailOptions, McpToolReply, ModelResolver, type ModelResolverDeps, type NativeShellLauncher, type NativeShellOffer, NoPlanError, OPENCODE_MANIFEST, ORDEWELL_SETTABLE_ENV, OpenAiService, OpenCodeAdapter, type OpenCodeGoAccountLimitOptions, OrchestratorObserver, OrchestratorOption, OrdewellMcpServer, PROVIDER_CREDENTIAL_ENV, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type ParsedCommand, PendingApproval, PendingApprovals, type PingFetch, PlanEditError, PlanIsolation, type PlanRequest, PlanState, PlanStore, Planner, PlannerAllowlist, type PlannerBackendEntry, PlannerBackendId, type PlannerChoice, PlannerModelCandidate, type PlannerModelLookup, PlannerModelRecall, type PlannerModelSource, PlannerModelStore, type PlannerSelectionChange, type PlannerSelectionCurrent, type PlannerSelectionResult, type PlannerSelectionState, PlannerShellSandbox, PlannerToolHandler, type PlannerUsability, PlannerUsage, type PrdBlock, ProviderModelLists, type ProviderRegistration, QueuedTaskMessage, ReadFileOpts, ReadTaskArgs, ReportedWindow, type ResearchChat, ResearchLogEntry, ResearchShell, type ResearchTurn, type ResolvedChoice, type ResolvedPlanner, RewindTarget, RunActivity, RunMergeView, RunView, RunnerApprovals, RunnerAuth, RunnerAuthExec, RunnerCommand$1 as RunnerCommand, RunnerId, RunnerInstallation, type RunnerInstallationOptions, RunnerManifest, RunnerModeInfo, RunnerRegistry, RunnerSessionCost, type RunnerSpawnOptions, SCRIPT_RUNNER, SETTINGS_ENV_ALLOWLIST, SETTINGS_ENV_REFUSED, STATE_DIR, STATE_DIR_IGNORE, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SaveSession, type SavedState, ScriptBody, ScriptExit, ScriptRunner, ScriptSession, type SearchHit, type SearchOutcome, type SearchPage, type SearchTransport, Session, SessionBroadcaster, type SessionDeps, SessionHeld, SessionLease, SessionMessage, SessionMeta, SessionNotFoundError, SessionNotice, type SessionPlanner, type SessionRuntimeSettings, ShellLaunch, SkillsService, type SpawnSpec, StdioAgentAdapter, StoredHandoff, StructuredEvent, StructuredRunner, type StructuredRunnerDeps, StructuredSession, StructuredTurnEnd, Task, TaskCompleteArgs, TaskControlError, type TaskEditOptions, TaskLogEvent, type TaskLogFile, type TaskLogLocation, TaskLogRecorder, type TaskLogRecorderDeps, TaskMessageFrom, TaskModeAgentAdapter, TaskOrchestrator, TaskOutputSource, TaskQueryCatalog, TaskRunnerFlags, TaskShell, TaskShellSite, TaskStartOptions, TaskTokenScope, type TokenCarriers, type ToolCall, ToolOutcome, type ToolResult, UsageRecord, UserSettings, VERSION_CHECK_NOTICE, VERSION_CHECK_URL, VerdictEngine, type VerdictListener, type VersionCheck, type VersionCheckOptions, WINDOWS_MAX_COMMAND_LINE, WebRead, WebReadDecision, type WebResponse, WebResponseCache, type WebResponseCacheOptions, type WebTransport, type WorkspaceCheckDeps, WorkspaceNotAProjectError, WorkspaceNotFoundError, type WorkspaceProjectCheckDeps, type WorktreeIsolationDeps, admitSettingsEnv, applyHeadLimit, assertWorkspaceExists, assertWorkspaceIsProject, augmentedPath, bearerHeaderValue, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, canContinue, claudeAccountLimitCollector, clearAugmentedPathCache, clearDaemonToken, clearState, clipboardCopyCommand, codexAccountLimitCollector, codexSandboxNotice, compareVersions, configuredProviders, continuability, createIsolationPreview, createNativeShellLauncher, createSession, createTaskAdapter, createWorktreeIsolation, daemonTokenPath, defaultEnabledRunners, defaultLogger, definitionPattern, deleteSession, detectInstalledPlanner, discoverGeminiModels, effectRuleFor, ensureDir, ensurePrivateDir, ensureStateDirIgnored, extractPrdBlock, extractPresentedToken, filterFallbackByAnchoredInclude, findInstalledPlanner, formatSearchOutput, getLatestSession, getProviderMeta, getStateDir, globalDataDir, grantScopeFor, grepRegexFromProbe, idSegment, includeGlobFor, installedPlannerAnswered, installedPlannerDetected, isApiProvider, isCliProvider, isExecutableResolved, isOpenAiProvider, isPlannerBackend, isVendorModelFor, isolationViewOfPlan, killTree, languageForId, listSessions, listTaskLogAttempts, listTree, loadSession, loadSessionPlanState, loadState, looksLikeChallenge, migrateOldConfigDir, migratePlanIsolation, mintDaemonToken, mintSessionId, nativeShellInvocation, nativeShellOffer, normalizeGeminiModel, openCodeGoAccountLimitCollector, openTaskLog, parseEffectAllowlist, parseExecutionCommand, parseMaxParallel, parseSearchHits, parseVersion, planDirectLaunch, plannerBackendEntries, prefixModelId, prepareTaskOutputFile, providerForRunner, readDaemonToken, readTaskLog, readTaskPatch, recordInstalledPlanner, recordedInstalledPlanner, referencePattern, removedPluginNotice, repositoryRunnerConfigPaths, resetInstalledPlanner, resolveProviderFromPrefix, resolveTaskRunnerFlags, resolveWithin, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, saveTaskPatch, selectPlanner, sessionDataDir, sessionRuntimeSettings, sharedSearchProvider, sharedWebResponseCache, startVersionCheck, stateExists, stripAnsi, stripModelPrefix, supportsTaskMode, taskPatchFile, tokenSubprotocols, tokensMatch, wellKnownBinDirs, windowsCommandLine, withPath, writeFileAtomic, writePrivateFile };
+export { ALL_PROVIDERS, AbstractRunner, AbstractRunnerSession, AccountLimitBucket, type AccountLimitCollector, type AccountLimitListener, AccountLimitMonitor, type AccountLimitMonitorOptions, type AccountLimitReading, AccountLimitSnapshot, type Adr0013IsolationRun, type Adr0013PlanIsolation, type Adr0013TaskRecord, AgentAdapter, AgentEvent, AgentProcessDeps, AgentStartOptions, AiProvider, AlreadyExecutingError, ApprovalAnswer, ApprovalDecision, ApprovalModeSetting, ApprovalPolicy, AssignmentScope, BaseAiService, BaseConfig, BaseFileSystem, BashOptions, BatchQuoteError, BufferedTaskOutputSource, type ByPlannerBackend, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CODEX_SANDBOX_DOCS, CODEX_SANDBOX_OFF_LINE, type CachedPage, type CappedRows, CheckpointAnswer, type CheckpointListener, type 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 };