@ordewell/core 0.4.4 → 0.4.6

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { h as RunnerId, c as PlanStatus, L as LegacyPlanState, d as ResearchProgress, a as DiscoveredModel, T as Task, R as ResearchLogEntry, C as ConversationMessage, n as TaskSnapshot, Q as QueuedMessage, A as ActiveTaskSession, g as ResearchToolType, u as Verdict, e as ResearchStep, b as PlanState } from './Task-1NwmUImI.js';
 export { D as DiscoveredMode, M as Message, P as PlanModificationWarnings, f as ResearchStepOutcome, S as StreamEvent, i as StreamStepEvent, j as StreamThinkingEvent, k as TaskMode, l as TaskModelAssignment, m as TaskOutputSummary, o as TaskStatus, p as TaskType, q as ThinkingBlock, U as UserPromptEntry, r as UserStep, V as ValidationCheck, s as ValidationContext, t as ValidationResult, v as VerificationCheck, w as addTaskToPlan, x as createEmptyPlan, y as createTask, z as emptyWarnings, B as flattenTasks, E as migrateLegacyPlan, F as migratePlanState, G as migrateTask, H as removeTaskFromPlan, I as renumberTasks, J as updateTaskInPlan, K as validateModifiedPlan, N as warningsText } from './Task-1NwmUImI.js';
-import { n as IFileSystem, I as IApproval, R as ReadFileOpts, T as ToolOutcome, k as GrepOptions, j as GlobOptions, i as FindSymbolOptions, f as ApprovalRequest, m as IConfig, A as AiProvider, y as ProviderModelLists, c as ApprovalMode, q as ITerminalSession, p as ITerminalRunner, J as RunnerRegistry, s as OrchestratorOption, b as ApprovalKind, g as ApprovalSource, E as RunnerInvocation, o as IPluginStore, H as RunnerPluginManifest, B as ResolveContext } from './ITerminalRunner-D7DwHYSg.js';
-export { a as AllProviderModels, d as ApprovalPolicy, e as ApprovalPolicyOptions, C as CatalogModel, D as DENY_ALL, h as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, l as GrepOutputMode, M as ModelCatalog, r as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginEntry, t as PluginFeatures, u as PluginMode, v as PluginModelDiscovery, w as PluginRunnerDef, x as ProviderCredentialSource, z as ProviderModelsResult, S as SEARCH_EXCLUSIONS, K as collectProviderCredentials, L as enabledRunners, N as fetchAllProviderModels, Q as knownModelId, U as resolveModelShortcut, V as resolveProvider, W as toOrchestratorOptions } from './ITerminalRunner-D7DwHYSg.js';
+import { n as IFileSystem, I as IApproval, R as ReadFileOpts, T as ToolOutcome, k as GrepOptions, j as GlobOptions, i as FindSymbolOptions, f as ApprovalRequest, m as IConfig, A as AiProvider, y as ProviderModelLists, c as ApprovalMode, q as ITerminalSession, p as ITerminalRunner, J as RunnerRegistry, s as OrchestratorOption, b as ApprovalKind, g as ApprovalSource, E as RunnerInvocation, o as IPluginStore, H as RunnerPluginManifest, B as ResolveContext } from './ITerminalRunner-Cpyzyrnl.js';
+export { a as AllProviderModels, d as ApprovalPolicy, e as ApprovalPolicyOptions, C as CatalogModel, D as DENY_ALL, h as DiscoveryCommand, F as FetchAllProviderModelsOptions, G as GREP_DEFAULT_HEAD_LIMIT, l as GrepOutputMode, M as ModelCatalog, r as ModelShortcut, O as ORCHESTRATOR_SHORTCUTS, P as PluginEntry, t as PluginFeatures, u as PluginMode, v as PluginModelDiscovery, w as PluginRunnerDef, x as ProviderCredentialSource, z as ProviderModelsResult, S as SEARCH_EXCLUSIONS, K as collectProviderCredentials, L as enabledRunners, N as fetchAllProviderModels, Q as knownModelId, U as resolveModelShortcut, V as resolveProvider, W as toOrchestratorOptions } from './ITerminalRunner-Cpyzyrnl.js';
 import { R as RunnerModeInfo, b as PlanParseError } from './parsing-RjN9JbyG.js';
 export { M as ManifestLookup, P as PLAN_ENVELOPE_KEY, a as PartialPlanTask, T as TASK_OPS_ENVELOPE_KEY, c as buildModeGuide, d as checkDepsResolve, e as checkImmutableLog, f as checkInProgress, g as checkNoCycles, h as checkUniqueIds, i as escapeControlCharsInStrings, j as extractJsonObject, k as extractObjectWithBalance, l as extractObjectsWithKey, m as filteredBuildModes, n as looksLikePlanAttempt, p as parsePartialPlan, o as parsePlanJson, r as resolveDefaultMode, q as resolveTaskMode, s as runnerModesFrom, t as stripModelNoise, u as stripTrailingCommas, v as validatePlanModification } from './parsing-RjN9JbyG.js';
 import { T as TaskOp } from './plan-utils-Cgc0cCH1.js';
@@ -162,8 +162,9 @@ interface CommandClassification {
     reason?: string;
 }
 /**
- * Classify one command line. Output redirection is refused outright: a planner
- * that writes files has stopped being a planner.
+ * Classify one command line. Output redirection is refused outright unless the
+ * target provably writes nothing — `/dev/null`, or an fd duplication like
+ * `2>&1` — since a planner that writes files has stopped being a planner.
  */
 declare function classifyCommand(command: string, opts?: CommandPolicyOptions): CommandClassification;
 
@@ -195,7 +196,7 @@ declare abstract class BaseFileSystem implements IFileSystem {
     protected abstract globImpl(pattern: string, absRoot: string, headLimit: number): Promise<ToolOutcome>;
     protected abstract grepImpl(pattern: string, absRoot: string, opts: GrepOptions): Promise<ToolOutcome>;
     protected abstract listDirImpl(absPath: string, depth: number): Promise<ToolOutcome>;
-    protected abstract execBashImpl(command: string): Promise<ToolOutcome>;
+    protected abstract execBashImpl(command: string, signal?: AbortSignal): Promise<ToolOutcome>;
     /**
      * Resolve `p` and confirm the planner may touch it. In-workspace paths pass
      * silently; anything else needs one approval, remembered per containing
@@ -234,9 +235,27 @@ declare abstract class BaseFileSystem implements IFileSystem {
      * anything else asks once and is remembered, and writes are refused outright
      * because a planner that mutates the workspace has stopped being a planner.
      */
-    bash(command: string): Promise<ToolOutcome>;
+    bash(command: string, signal?: AbortSignal): Promise<ToolOutcome>;
+}
+
+interface IWebFetcher {
+    confirm(url: string): Promise<boolean>;
+    fetch(url: string): Promise<ToolOutcome>;
+    /**
+     * Optional web search. A fetcher without it makes the `web_search` tool
+     * report itself unavailable rather than failing the turn — the same
+     * degradation `fetch` already uses when no fetcher is wired at all.
+     */
+    search?(query: string): Promise<ToolOutcome>;
 }
 
+/**
+ * Short, non-alarming answer for a call the turn was stopped before running.
+ * The call still needs *an* answer — a dangling tool_call leaves the provider's
+ * message history invalid for whatever the user does next.
+ */
+declare const STOPPED_TOOL_RESULT = "Stopped by the user \u2014 this call was not executed, and no further tool calls will run this turn.";
+
 /**
  * Workspace containment, in one place. Both the filesystem policy layer
  * (which may ask the user to approve an escape) and the research-subagent
@@ -506,17 +525,6 @@ declare class ConsoleLogger implements ILogger {
 }
 declare const defaultLogger: ILogger;
 
-interface IWebFetcher {
-    confirm(url: string): Promise<boolean>;
-    fetch(url: string): Promise<ToolOutcome>;
-    /**
-     * Optional web search. A fetcher without it makes the `web_search` tool
-     * report itself unavailable rather than failing the turn — the same
-     * degradation `fetch` already uses when no fetcher is wired at all.
-     */
-    search?(query: string): Promise<ToolOutcome>;
-}
-
 interface UserSettings {
     grillMe: {
         enabled: boolean;
@@ -537,6 +545,11 @@ interface UserSettings {
         enabled: boolean;
     };
     modelAllowlist?: Record<string, string[]>;
+    /** Last model (and its thinking effort) the user chose for each planner backend, keyed by AiProvider id. */
+    plannerModels?: Record<string, {
+        model: string;
+        effort?: string;
+    }>;
     /**
      * Runners the user picked for planning. Absent — not empty — is what falls
      * back to the environment's defaults; `[]` is a deliberate "none of them".
@@ -575,6 +588,14 @@ declare class SettingsService {
     setResearchSubagents(enabled: boolean): void;
     getModelAllowlist(runner: string): string[] | undefined;
     setModelAllowlist(runner: string, ids: string[] | undefined): void;
+    getPlannerModel(provider: string): {
+        model: string;
+        effort?: string;
+    } | undefined;
+    setPlannerModel(provider: string, entry: {
+        model: string;
+        effort?: string;
+    } | undefined): void;
     getEnabledRunners(): string[] | undefined;
     setEnabledRunners(ids: string[]): void;
     private load;
@@ -701,6 +722,29 @@ declare class EmbeddedNewlineError extends Error {
     readonly command: string;
     constructor(command: string);
 }
+/**
+ * Thrown when `command` cannot be resolved to a real file. Kept distinguishable
+ * from `WorkspaceNotFoundError` (utils/workspace) even though both a missing
+ * cwd and a missing binary surface as the same `spawn` ENOENT to Node — the two
+ * are checked, and named, separately so the failure names the actual cause.
+ */
+declare class ExecutableNotFoundError extends Error {
+    readonly command: string;
+    readonly searchedPath: string;
+    constructor(command: string, searchedPath: string);
+}
+/**
+ * Whether `command` actually resolves to a file, given the plan
+ * {@link planDirectLaunch} produced for it and the PATH it was resolved
+ * against.
+ *
+ * POSIX is deliberately identity in `planDirectLaunch` (execvp does its own
+ * PATH search), so the search is repeated here instead. Windows already did
+ * the search inside `planDirectLaunch` — signalled by the returned file
+ * differing from the bare command name it was given; an unresolved command
+ * comes back unchanged.
+ */
+declare function isExecutableResolved(command: string, plan: LaunchPlan, PATH: string, deps?: LaunchDeps): boolean;
 /** The verbatim command line cmd.exe receives after `/d /s /c`, before wrapping. */
 declare function windowsCommandLine(file: string, args: string[]): string;
 /**
@@ -908,6 +952,10 @@ interface AgentProcessDeps {
     resolvePath?: () => Promise<string>;
     /** Host platform. Defaults to the real one; injected so OS-specific behavior is testable anywhere. */
     platform?: NodeJS.Platform;
+    /** True when `workspace` names an existing directory. Defaults to a real filesystem check. */
+    isDirectory?: (workspace: string) => boolean;
+    /** True when `candidate` names an existing, spawnable file. Defaults to a real filesystem check. */
+    exists?: (candidate: string) => boolean;
 }
 /** Builds the adapter for one runner id, or null when that runner cannot plan. */
 type AgentAdapterFactory = (runner: string, deps: AgentProcessDeps) => AgentAdapter | null;
@@ -1482,6 +1530,13 @@ declare class TaskOrchestrator {
     subscribe(observer: OrchestratorObserver): () => void;
     private emit;
     get isRunning(): boolean;
+    /**
+     * A runner is executing *right now*. Narrower than {@link isRunning}, which
+     * also covers the armed-but-idle scheduler `tick()` deliberately leaves
+     * behind when a plan is paused on a user task, a checkpoint or a hold —
+     * nothing is executing then, so nothing is reading the plan mid-mutation.
+     */
+    get hasLiveWork(): boolean;
     get isReviewApproved(): boolean;
     get status(): 'approved' | 'running' | 'completed';
     get activeTaskIds(): string[];
@@ -1493,6 +1548,17 @@ declare class TaskOrchestrator {
     clearQueuedMessages(): void;
     processNextQueuedMessage(): QueuedMessage | null;
     loadPlan(tasks: Task[], planRunners?: RunnerId[]): void;
+    /**
+     * Adopt an edited plan without letting go of the run in progress. Everything
+     * the scheduler owns — live sessions, holds, retry counts, the verifier and
+     * the review approval — survives, because `loadPlan` clears all of it and a
+     * mid-run edit is not a new run. Only the tasks change.
+     *
+     * The ids with live sessions are defended: one dropped from the edited plan is
+     * carried over (its verdict still has to land somewhere), and one whose status
+     * the snapshot predates is put back to `in_progress` — adopting the snapshot's
+     * "pending" would offer the scheduler work a runner is already doing.
+     */
     reconcilePlan(newTasks: Task[], planRunners?: RunnerId[]): void;
     start(): Promise<void>;
     stop(): void;
@@ -1506,6 +1572,16 @@ declare class TaskOrchestrator {
      * doesn't immediately restart it; Retry / Force Start release the hold.
      */
     cancelTask(taskId: string): Promise<void>;
+    /**
+     * Let go of a task that is leaving the plan. A live runner is cancelled
+     * through {@link cancelTask} so the verifier generation is bumped before the
+     * process dies; a spawn still in flight is dropped from `startingTaskIds`,
+     * which is what makes {@link startTask} kill the session it is about to
+     * receive. The id's remaining bookkeeping goes too — a hold or retry count
+     * kept for a task that no longer exists would be inherited by nothing and
+     * leaves `isRunning` reading true forever.
+     */
+    releaseTask(taskId: string): Promise<void>;
     markTaskComplete(taskId: string): Promise<void>;
     markAiTaskComplete(taskId: string): Promise<void>;
     /**
@@ -1671,6 +1747,13 @@ declare class ModelResolver {
     getDiscoveryErrors(): Record<string, string>;
     refresh(): Promise<ProviderModelLists>;
     refreshRunnerModels(): void;
+    /**
+     * Synchronous reads of whatever the last `modelsForRunners`/`pickerOptions`
+     * call already cached — never trigger discovery or a fetch. For callers
+     * (e.g. a settings write) that need a catalog without going async.
+     */
+    getCachedRunnerModels(runner: string): DiscoveredModel[];
+    getCachedPickerOptions(): OrchestratorOption[];
     invalidate(): void;
 }
 
@@ -2124,6 +2207,16 @@ declare function executionSummary(tasks: Task[]): {
     failed: number;
 };
 
+/**
+ * A direct (non-planner) plan edit the session refused. Distinct from a plain
+ * Error so a surface can tell "you asked for something invalid" from "something
+ * broke" and say which — the HTTP routes used to collapse both into 404/500,
+ * which read to the TUI and VS Code as the edit silently doing nothing. Carries
+ * no status code: core is transport-agnostic, the route maps it.
+ */
+declare class PlanEditError extends Error {
+    constructor(message: string);
+}
 /**
  * Options for plan generation. Progress is not overridable: every planner
  * progress event is translated to a SessionMessage inside the Session and
@@ -2296,8 +2389,24 @@ declare class Session {
     get currentGoal(): string;
     get isPlanning(): boolean;
     get isExecuting(): boolean;
+    /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
+    get hasLiveWork(): boolean;
     get status(): 'approved' | 'running' | 'completed';
     get sessionConfig(): IConfig;
+    /**
+     * Deny every parked approval as soon as a planning turn is aborted, for the
+     * same reason `beginFreshPlan` does it: a prompt raised by a turn nobody is
+     * waiting on has no one left to serve, and denying it unblocks the research
+     * loop instead of stranding it. Without this the request sat out its
+     * five-minute timeout and the loop then carried on as if nothing had
+     * happened — the abort was real, but invisible until long after the user
+     * pressed stop.
+     *
+     * The listener is returned as a disposer rather than left attached: callers
+     * own the signal and may reuse it, and a leaked listener would deny the
+     * *next* turn's prompts the moment that stale signal aborted.
+     */
+    private denyApprovalsOnAbort;
     startExecution(): Promise<void>;
     generatePlan(goal: string, runners: RunnerId[], options?: GeneratePlanOptions): Promise<LegacyPlanState>;
     /**
@@ -2377,14 +2486,29 @@ declare class Session {
      * task state; LegacyPlanState.tasks is populated only at persist time.
      */
     private mutatePlan;
-    updateTask(taskId: string, changes: Partial<Task>): LegacyPlanState | null;
+    /**
+     * The direct-edit seam: {@link mutatePlan} plus the reschedule every
+     * structural edit owes an armed scheduler. Nothing else wakes one after a
+     * hand edit — the queue-drain path never runs, because a direct edit never
+     * queues — so a task the edit just unblocked would sit ready and never
+     * start. `tick()` no-ops while the scheduler is idle, so this costs nothing
+     * during plain planning. The planner-driven path re-ticks in
+     * {@link settleTurn} instead; it must not tick twice.
+     */
+    private editPlan;
+    /**
+     * Patch one task's fields. A hand-set dependency list is the one patch that
+     * can leave the plan unschedulable, so it goes through the same
+     * {@link canSetDependencies} guard the planner's pickers use rather than a
+     * second copy of the rule — and throws, so the surface can say why.
+     */
+    updateTask(taskId: string, changes: Partial<Task>): Promise<LegacyPlanState | null>;
     /**
      * Move one task onto a different runner. Distinct from {@link updateTask}
      * because a runner change is never a single-field edit: the task's model,
      * thinking effort and mode are all scoped to its runner, so they are
      * re-derived from the new runner's catalog (see {@link retargetTaskRunner}).
-     * That needs discovery, which is async — hence a method of its own rather
-     * than a branch inside the sync `updateTask`.
+     * That needs discovery, which is why it is not a branch inside `updateTask`.
      *
      * The runner is also admitted into `plan.runners` — see {@link admitRunner}.
      */
@@ -2411,16 +2535,21 @@ declare class Session {
      */
     private admitRunner;
     /**
-     * Replace one task's dependency list. Separate from {@link updateTask}
-     * because a hand-edited graph is the one task edit that can leave a plan
-     * unschedulable: `canSetDependencies` is the guard, and it lives behind this
-     * one method so the API and both surfaces' pickers reject the same edits
-     * rather than each carrying a copy of the rule. Throws so a surface can say
-     * why the edit was refused.
+     * Replace one task's dependency list — the named entry point the surfaces'
+     * dependency pickers call. The guard itself lives in {@link updateTask}, so
+     * a dependency list arriving as a plain field patch is rejected by the same
+     * rule instead of slipping past it.
      */
-    setTaskDependencies(taskId: string, dependencies: string[]): LegacyPlanState | null;
+    setTaskDependencies(taskId: string, dependencies: string[]): Promise<LegacyPlanState | null>;
     completeTask(taskId: string): Promise<void>;
-    removeTask(taskId: string): LegacyPlanState | null;
+    /**
+     * Delete one task. A running task is cancelled first: the plan can drop it
+     * either way, but nothing can reach its runner afterwards — the tmux session
+     * outlives the plan and the orchestrator keeps counting it as active. The
+     * planner-driven path refuses instead (see {@link applyTaskOps}); a user
+     * deleting their own task means it.
+     */
+    removeTask(taskId: string): Promise<LegacyPlanState | null>;
     /**
      * Add one task, filling in whatever the caller left unset. A task with no
      * runnable assignment is not a lighter task but an unspawnable one, so the
@@ -2435,9 +2564,9 @@ declare class Session {
      * moved on, not that the whole task should be refused.
      */
     addTask(draft: Partial<Task>): Promise<LegacyPlanState | null>;
-    mergeTasks(taskIdA: string, taskIdB: string): LegacyPlanState | null;
-    mergeMultipleTasks(taskIds: string[]): LegacyPlanState | null;
-    splitTask(taskId: string, newTasks: Partial<Task>[]): LegacyPlanState | null;
+    mergeTasks(taskIdA: string, taskIdB: string): Promise<LegacyPlanState | null>;
+    mergeMultipleTasks(taskIds: string[]): Promise<LegacyPlanState | null>;
+    splitTask(taskId: string, newTasks: Partial<Task>[]): Promise<LegacyPlanState | null>;
     /**
      * Planner-driven merge: validate compatibility up front, then ask the planner
      * LLM to produce a single "merge" taskOps op combining the selected tasks.
@@ -2752,6 +2881,7 @@ interface TmuxRunnerDeps {
     resolvePath?: () => Promise<string>;
     pollIntervalMs?: number;
     logDir?: string;
+    clipboardCommand?: () => string | null;
 }
 declare class TmuxSession extends AbstractTerminalSession {
     private tmuxSession;
@@ -2803,6 +2933,7 @@ declare class TmuxRunner extends AbstractRunner<TmuxSession> {
     private resolvePath;
     private pollIntervalMs;
     private logDir;
+    private clipboardCommand;
     /** Retries get a freshly named window so a failed attempt's output stays inspectable. */
     private attempts;
     private ready;
@@ -2818,14 +2949,17 @@ declare class TmuxRunner extends AbstractRunner<TmuxSession> {
     private tmux;
     private createFreshSession;
     /**
-     * Makes an attached runner terminal scrollable with the mouse wheel and
-     * Page Up/Down. A fresh tmux session ships with `mouse off`, a 2000-line
-     * scrollback, and no PageUp binding — none of which lets a user page back
-     * through a finished task's output, which is the whole point of opening its
-     * window. Scoping is harmless: the daemon owns a private socket
-     * (`tmuxSocketName`), so these server-wide options touch nothing but its
-     * own session. Best-effort so an ancient or stripped tmux cannot stop tasks
-     * from spawning — the session still works without the scroll comforts.
+     * Gives an attached runner terminal wheel/PageUp scrolling over a deep
+     * scrollback, and a mouse selection that reaches the system clipboard — none
+     * of which a default tmux session does. Server-wide scoping is harmless: the
+     * daemon owns a private socket (`tmuxSocketName`).
+     *
+     * `mouse on` is what costs the emulator's own drag-select, so tmux must hand
+     * the selection back out itself: via a clipboard binary when there is one,
+     * and via OSC 52 (`set-clipboard`) for what that cannot cover, such as
+     * viewing over SSH. Naming the binary on the binding as well as in
+     * `copy-command` keeps drag-to-copy working on tmux older than 3.2, which has
+     * no `copy-command`.
      */
     private configureScrolling;
     /**
@@ -2884,6 +3018,26 @@ declare function wrapWithPty(command: string, args: string[]): {
     args: string[];
 };
 
+/**
+ * A workspace path that does not exist, or exists but is not a directory.
+ * Checked at every surface that starts a planner or spawns an agent inside
+ * one: a shell whose own cwd was deleted still reports the stale path from
+ * `process.cwd()`, so a stat is the only reliable signal, never the string
+ * itself. Left unchecked, the underlying failure is `spawn`'s ENOENT — which
+ * reads as a missing binary, not a missing directory. No status code: this is
+ * transport-agnostic, and each surface maps it to its own response shape.
+ */
+declare class WorkspaceNotFoundError extends Error {
+    readonly workspace: string;
+    constructor(workspace: string);
+}
+interface WorkspaceCheckDeps {
+    /** True when `candidate` names an existing directory. Defaults to a real `fs.statSync`. */
+    isDirectory?: (candidate: string) => boolean;
+}
+/** Throws {@link WorkspaceNotFoundError} unless `workspace` names an existing directory. */
+declare function assertWorkspaceExists(workspace: string, deps?: WorkspaceCheckDeps): void;
+
 interface KillTreeDeps {
     platform?: NodeJS.Platform;
     /** Runs `taskkill`. Injected so the Windows path is testable off Windows. */
@@ -2970,6 +3124,15 @@ declare function tmuxWindowName(taskId: string, planSessionId?: string): string;
 type ProbeFn = () => void;
 /** Feature-detects tmux the same way `HeadlessRunner` detects `script`. */
 declare function hasTmux(probe?: ProbeFn): boolean;
+type HasBinFn = (bin: string) => boolean;
+/**
+ * Shell command tmux should pipe a copy-mode selection into, so selecting text
+ * in a task's terminal puts it on the *system* clipboard rather than in a tmux
+ * paste buffer no other application can read. Preferred over tmux's OSC 52
+ * bridge, which plenty of emulators (VTE before 0.76, xterm without
+ * `allowWindowOps`) drop on the floor.
+ */
+declare function clipboardCopyCommand(hasBin?: HasBinFn, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string | null;
 
 declare class FsPluginStore implements IPluginStore {
     getUserPluginsDir(): string;
@@ -3030,4 +3193,55 @@ declare function sanitizeSlug(raw: string): string;
 /** Save the PRD to `<workspace>/.scratch/<slug>/PRD.md` (to-prd native convention). */
 declare function savePrdMarkdown(workspace: string, slug: string, markdown: string): string;
 
-export { ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalKind, ApprovalMode, ApprovalRequest, ApprovalSource, BaseAiService, BaseConfig, BaseFileSystem, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationMessage, type ConversationRequest, type ConversationTurn, DiscoveredModel, EmbeddedNewlineError, EnvConfig, type ExecFileFn, type ExecImpl, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, GlobOptions, type GrepInvocation, GrepOptions, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerReplyClassification, type PlannerRuntimeToggles, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchStep, ResearchToolType, type ResearchTurn, ResolveContext, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, STATE_DIR, SYMBOL_LANGUAGES, type SerializedPlan, type SerializedTask, type SerializedTaskStatus, Session, type SessionBroadcaster, type SessionData, type SessionDeps, type SessionMessage, type SessionMeta, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SpawnSpec, StdioAgentAdapter, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, TaskOp, TaskOrchestrator, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type ToolCall, ToolOutcome, type ToolResult, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, applyHeadLimit, augmentPromptWithPriorOutputs, augmentedPath, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, clearAugmentedPathCache, clearResearchShellCache, clearState, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, defaultLogger, definitionPattern, deleteSession, discoverGeminiModels, effectiveAllowlist, ensureDir, executionLogBlock, executionSummary, extractPrdBlock, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isOpenAiProvider, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, referencePattern, renderPlanMap, renderPriorOutputs, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolveProviderFromPrefix, resolveResearchShell, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, serializePlan, serializeTask, serializeTaskStatus, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, tmuxSessionName, tmuxSocketName, tmuxWindowName, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };
+/** What the user last picked for one planner backend. */
+interface PlannerModelChoice {
+    model: string;
+    effort?: string;
+}
+/**
+ * A candidate model as this planner's catalog lists it. Deliberately plain
+ * data: a harness planner's catalog is its runner's own model list and a
+ * vendor's is a picker list (ADR-0009), and the rule below is the same for
+ * both — so the caller normalizes, and this module never reaches for a
+ * ModelResolver, a config or the network.
+ */
+interface PlannerModelCandidate {
+    id: string;
+    variants?: {
+        id: string;
+    }[];
+}
+interface PlannerModelRecall {
+    model: string;
+    effort: string;
+    source: 'remembered' | 'catalog-default' | 'none';
+}
+/** The slice of `SettingsService` this needs, so tests can pass a plain object. */
+interface PlannerModelStore {
+    getPlannerModel(provider: string): PlannerModelChoice | undefined;
+    setPlannerModel(provider: string, entry: PlannerModelChoice | undefined): void;
+}
+/**
+ * Remembers, per planner backend, the model the user last chose for it.
+ *
+ * Switching the planner has to clear the model — an id is scoped to the agent
+ * that listed it, so an OpenRouter slug handed to Claude Code points it at
+ * something it cannot spawn. That clear is correct and stays; what was missing
+ * is that switching *back* then forced a re-pick of a model the user had
+ * already chosen. Both surfaces' clears and the restore now read one rule from
+ * here rather than three copies drifting apart.
+ */
+declare class PlannerModelMemory {
+    private store;
+    constructor(store: PlannerModelStore);
+    /** Record what the user picked for `provider`; a blank model forgets it instead. */
+    remember(provider: string, model: string, effort?: string): void;
+    /**
+     * What the model and effort should become when `provider` takes over the
+     * planner, given the models it actually serves. The `source` is what the
+     * three surfaces word their notice from — restored, defaulted, or nothing.
+     */
+    recall(provider: string, catalog: PlannerModelCandidate[]): PlannerModelRecall;
+}
+
+export { ALL_PROVIDERS, AUTO_COMMANDS, AbstractRunner, AbstractTerminalSession, ActiveTaskSession, type AgentAdapter, type AgentAdapterFactory, type AgentEvent, type AgentProcessDeps, type AgentStartOptions, AiProvider, ApprovalKind, ApprovalMode, ApprovalRequest, ApprovalSource, BaseAiService, BaseConfig, BaseFileSystem, CLAUDE_CODE_MANIFEST, CLI_PROVIDERS, CMD_EXE_MAX_COMMAND_LINE, CORE_PLANNER_PROMPT, type CappedRows, type CheckpointListener, ClaudeCodeAdapter, CliAgentAiService, type CliAgentAiServiceDeps, CodexAdapter, type CommandClassification, CommandLineTooLongError, type CommandTier, type ComposeOptions, ConsoleLogger, ContextCollector, ConversationMessage, type ConversationRequest, type ConversationTurn, DiscoveredModel, EmbeddedNewlineError, EnvConfig, type ExecFileFn, type ExecImpl, ExecutableNotFoundError, FindSymbolOptions, FsPluginStore, GIT_READONLY_SUBCOMMANDS, GeminiService, GlobOptions, type GrepInvocation, GrepOptions, type HasBinFn, HeadlessRunner, type HeadlessRunnerDeps, HeadlessSession, type IAiService, IApproval, IConfig, IFileSystem, type ILogger, type INotification, IPluginStore, ITerminalRunner, ITerminalSession, JSON_REPAIR_INSTRUCTION, type KillTreeDeps, type LaunchDeps, type LaunchPlan, LegacyPlanState, LineBuffer, type MappedTool, ModelResolver, type ModelResolverDeps, type ModifyPlanRequest, type NotificationAction, OPENCODE_MANIFEST, OpenAiService, OpenCodeAdapter, type OrchestratorObserver, OrchestratorOption, PROVIDER_DETECT_PRIORITY, PROVIDER_LABEL, PROVIDER_PRIORITY, PROVIDER_SHORT_LABEL, type PendingApproval, PendingApprovals, type PendingApprovalsOptions, PlanEditError, PlanParseError, type PlanRequest, PlanState, PlanStatus, PlanStore, Planner, type PlannerModelCandidate, type PlannerModelChoice, PlannerModelMemory, type PlannerModelRecall, type PlannerModelStore, type PlannerReplyClassification, type PlannerRuntimeToggles, type PrdBlock, type PreparedLaunch, type PriorOutput, type ProbeFn, ProviderModelLists, type ProviderRegistration, QueuedMessage, REFUSED_COMMANDS, ReadFileOpts, type RepairLoopOpts, type RepairVerdict, type ResearchChat, ResearchLogEntry, ResearchProgress, type ResearchShell, type ResearchShellDeps, ResearchStep, ResearchToolType, type ResearchTurn, ResolveContext, type RunnerCatalog, RunnerId, RunnerInstallation, RunnerInvocation, type RunnerMode, RunnerModeInfo, RunnerPluginManifest, RunnerRegistry, type RunnerSpawnOptions, STATE_DIR, STOPPED_TOOL_RESULT, SYMBOL_LANGUAGES, type SerializedPlan, type SerializedTask, type SerializedTaskStatus, Session, type SessionBroadcaster, type SessionData, type SessionDeps, type SessionMessage, type SessionMeta, type SessionPlanner, type SessionRuntimeSettings, SettingsService, type ShellDialect, type SpawnSpec, StdioAgentAdapter, TRUNCATED_PLAN_REPAIR_INSTRUCTION, Task, TaskOp, TaskOrchestrator, TaskSnapshot, TmuxRunner, type TmuxRunnerDeps, type ToolCall, ToolOutcome, type ToolResult, type UserSettings, Verdict, VerdictEngine, type VerdictListener, WINDOWS_MAX_COMMAND_LINE, type WorkspaceCheckDeps, WorkspaceNotFoundError, applyHeadLimit, assertWorkspaceExists, augmentPromptWithPriorOutputs, augmentedPath, buildConversationSystemPrompt, buildFallbackGrepArgs, buildGlobArgs, buildGrepArgs, buildMergePrompt, buildModifyDuringExecutionPrompt, buildModifyPlanPrompt, buildPlanWithResults, buildResearchPrompt, buildResearchToolsPrompt, buildRunnerInvocation, buildShellInvocation, buildSplitPrompt, buildSubagentSystemPrompt, clampThinkingEffort, classifyCommand, classifyPlannerReply, clearAugmentedPathCache, clearResearchShellCache, clearState, clipboardCopyCommand, coerceAssignments, collectDirectDependencyOutputs, composeAugmentedPrompt, configuredProviders, createAiService, defaultLogger, definitionPattern, deleteSession, discoverGeminiModels, effectiveAllowlist, ensureDir, executionLogBlock, executionSummary, extractPrdBlock, filterFallbackByAnchoredInclude, filterModelsForPrompt, formatSearchOutput, generatePlanWithRepair, getLatestSession, getProviderMeta, getSettingsPath, getStateDir, grantScopeFor, hasTmux, includeGlobFor, isCliProvider, isExecutableResolved, isOpenAiProvider, killTree, languageForId, listSessions, loadSession, loadSessionPlanState, loadState, mapAgentTool, modelContextBlock, modifyValidationFeedback, normalizeAgentArgs, normalizeGeminiModel, pendingEditRulesBlock, planDirectLaunch, planShellLaunch, posixShellQuote, prefixModelId, providerForRunner, reEmitPlanPrompt, reEmitTaskOpsPrompt, referencePattern, renderPlanMap, renderPriorOutputs, repairLoop, researchShellWarning, researchToolsPath, resolveArgs, resolveProviderFromPrefix, resolveResearchShell, resolveWithin, retargetTaskRunner, runnerAssignment, runnerForProvider, sanitizeSlug, savePrdMarkdown, saveSession, saveState, serializePlan, serializeTask, serializeTaskStatus, sessionRuntimeSettings, stateExists, stripAnsi, stripModelPrefix, summarizeOutput, taskOpsRejectedPrompt, tmuxSessionName, tmuxSocketName, tmuxWindowName, truncatedPlanReEmitPrompt, wellKnownBinDirs, windowsCommandLine, withPath, wrapWithPty };