@ordewell/core 0.4.4 → 0.4.6

package/dist/index.mjs

@@ -329,6 +329,16 @@ function dialectFor(dialect) {
   const resolved = dialect ?? (process.platform === "win32" ? "cmd" : "posix");
   return resolved === "cmd" ? CMD_DIALECT : POSIX_DIALECT;
 }
+function isDevNullTarget(target) {
+  if (!target.startsWith("/")) return false;
+  const resolved = [];
+  for (const seg of target.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") resolved.pop();
+    else resolved.push(seg);
+  }
+  return `/${resolved.join("/")}` === "/dev/null";
+}
 function matchParen(s, open) {
   let depth = 0;
   for (let i = open; i < s.length; i++) {
@@ -339,7 +349,7 @@ function matchParen(s, open) {
 }
 function lex(command, nested, dialect) {
   const segments = [];
-  let redirect = false;
+  let unsafeRedirect;
   let processSubstitution = false;
   let unbalanced = false;
   let tokens = [];
@@ -348,7 +358,19 @@ function lex(command, nested, dialect) {
   let started = false;
   let piped = false;
   let quote = "";
-  const endToken = () => {
+  let redirectTargetMode = false;
+  let redirectOperator = "";
+  const endToken = (hardBoundary = true) => {
+    if (redirectTargetMode) {
+      if (!started && !hardBoundary) return;
+      if (!unsafeRedirect && !isDevNullTarget(current)) {
+        unsafeRedirect = { operator: redirectOperator, target: current };
+      }
+      redirectTargetMode = false;
+      current = "";
+      started = false;
+      return;
+    }
     if (started) tokens.push(current);
     current = "";
     started = false;
@@ -436,9 +458,34 @@ function lex(command, nested, dialect) {
         i += 2;
         continue;
       }
-      if (c === ">") redirect = true;
+      let fd = "";
+      if (started && /^[0-9]+$/.test(current)) {
+        fd = current;
+        current = "";
+        started = false;
+      } else {
+        endToken();
+      }
+      const doubled = command[i + 1] === c;
+      const opLen = doubled ? 2 : 1;
+      if (c === ">") {
+        const dup = /^&([0-9]+)(?![0-9])/.exec(command.slice(i + opLen));
+        if (dup) {
+          i += opLen + dup[0].length;
+          continue;
+        }
+        redirectTargetMode = true;
+        redirectOperator = fd + c.repeat(opLen);
+      }
+      i += opLen;
+      continue;
+    }
+    if (c === "&" && command[i + 1] === ">") {
       endToken();
-      i += command[i + 1] === c ? 2 : 1;
+      const doubled = command[i + 2] === ">";
+      redirectTargetMode = true;
+      redirectOperator = doubled ? "&>>" : "&>";
+      i += doubled ? 3 : 2;
       continue;
     }
     if (c === "(" || c === ")") {
@@ -458,7 +505,7 @@ function lex(command, nested, dialect) {
       continue;
     }
     if (/\s/.test(c)) {
-      endToken();
+      endToken(false);
       i++;
       continue;
     }
@@ -468,7 +515,7 @@ function lex(command, nested, dialect) {
   }
   if (quote !== "") unbalanced = true;
   endSegment(false);
-  return { segments, redirect, processSubstitution, unbalanced };
+  return { segments, unsafeRedirect, processSubstitution, unbalanced };
 }
 function binaryName(token, dialect) {
   const base = token.split(/[/\\]/).pop() ?? "";
@@ -488,7 +535,7 @@ function lexAll(command, dialect) {
   for (let depth = 0; depth < 32 && queue.length > 0; depth++) {
     const inner = lex(queue.shift(), queue, dialect);
     all.segments.push(...inner.segments.filter((s) => s.binary));
-    all.redirect ||= inner.redirect;
+    all.unsafeRedirect ??= inner.unsafeRedirect;
     all.processSubstitution ||= inner.processSubstitution;
     all.unbalanced ||= inner.unbalanced;
   }
@@ -537,8 +584,9 @@ function refusalFor(seg) {
   if (seg.binary === "git") {
     const sub = seg.args.find((a) => !a.startsWith("-"));
     if (sub === "branch" || sub === "tag") {
-      if (seg.args.some((a) => ["-D", "-d", "-m", "-M", "--delete", "--move"].includes(a))) {
-        return `"git ${sub}" with a delete/move flag mutates refs. You are a read-only planner \u2014 describe the change as a task instead.`;
+      const flag = seg.args.find((a) => ["-D", "-d", "-m", "-M", "--delete", "--move"].includes(a));
+      if (flag) {
+        return `"git ${sub} ${flag}" mutates refs. You are a read-only planner \u2014 describe the change as a task instead.`;
       }
     }
   }
@@ -548,8 +596,9 @@ function refusalFor(seg) {
       return `find with "${flag}" runs an inner command this classifier cannot inspect. Use the read-only research tools on find's output, or describe the change as a task.`;
     }
   }
-  if (seg.binary === "sed" && seg.args.some((a) => a === "-i" || a === "--in-place" || /^-i./.test(a))) {
-    return `"sed -i" edits files in place. You are a read-only planner \u2014 describe the change as a task instead.`;
+  const sedInPlace = seg.binary === "sed" ? seg.args.find((a) => a === "-i" || a === "--in-place" || /^-i./.test(a)) : void 0;
+  if (sedInPlace) {
+    return `"sed ${sedInPlace}" edits files in place. You are a read-only planner \u2014 describe the change as a task instead.`;
   }
   if (seg.binary === "awk" && seg.args.some((a) => a === "inplace")) {
     return `"awk -i inplace" edits files in place. You are a read-only planner \u2014 describe the change as a task instead.`;
@@ -568,7 +617,7 @@ function classifyCommand(command, opts = {}) {
   const trimmed = command.trim();
   if (!trimmed) return { tier: "refuse", scope: "", reason: "Empty command." };
   const dialect = dialectFor(opts.dialect);
-  const { segments, redirect, processSubstitution, unbalanced } = lexAll(trimmed, dialect);
+  const { segments, unsafeRedirect, processSubstitution, unbalanced } = lexAll(trimmed, dialect);
   if (unbalanced) {
     return {
       tier: "refuse",
@@ -583,11 +632,12 @@ function classifyCommand(command, opts = {}) {
       reason: "Process substitution runs another command this classifier cannot inspect. Run the command on its own and read its output, or describe it as a task."
     };
   }
-  if (redirect) {
+  if (unsafeRedirect) {
+    const written = unsafeRedirect.target ? `"${unsafeRedirect.operator} ${unsafeRedirect.target}"` : `"${unsafeRedirect.operator}"`;
     return {
       tier: "refuse",
       scope: "",
-      reason: "Output redirection writes files. You are a read-only planner \u2014 read the output instead, or describe the write as a task."
+      reason: `${written} writes to a file. You are a read-only planner \u2014 read the output instead, or describe the write as a task.`
     };
   }
   if (segments.length === 0) return { tier: "refuse", scope: "", reason: "No command found." };
@@ -907,7 +957,7 @@ ${refs.output.trim()}`);
    * anything else asks once and is remembered, and writes are refused outright
    * because a planner that mutates the workspace has stopped being a planner.
    */
-  async bash(command) {
+  async bash(command, signal) {
     const { tier, scope, reason } = classifyCommand(command, { dialect: this.researchShell.dialect });
     if (tier === "refuse") {
       return { success: false, output: `Command refused: ${reason}`, truncated: false };
@@ -930,7 +980,7 @@ It is outside the auto-allowed read-only set (${scope}). Continue with the read-
         };
       }
     }
-    const outcome = await this.execBashImpl(command);
+    const outcome = await this.execBashImpl(command, signal);
     if (outcome.success) return outcome;
     const warning = researchShellWarning(this.researchShell);
     return warning ? { ...outcome, output: `${outcome.output}
@@ -939,6 +989,82 @@ It is outside the auto-allowed read-only set (${scope}). Continue with the read-
   }
 };
 
+// src/services/executeTool.ts
+var GREP_OUTPUT_MODES = ["content", "files", "count"];
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function bool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function grepOptions(args) {
+  const mode = str(args.output_mode ?? args.outputMode);
+  return {
+    include: str(args.include),
+    path: str(args.path),
+    outputMode: GREP_OUTPUT_MODES.includes(mode) ? mode : void 0,
+    contextBefore: num(args.context_before ?? args.contextBefore),
+    contextAfter: num(args.context_after ?? args.contextAfter),
+    literal: bool(args.literal),
+    caseInsensitive: bool(args.case_insensitive ?? args.caseInsensitive),
+    headLimit: num(args.head_limit ?? args.headLimit)
+  };
+}
+var STOPPED_TOOL_RESULT = "Stopped by the user \u2014 this call was not executed, and no further tool calls will run this turn.";
+async function executeTool(name, args, fs10, fetcher, signal) {
+  if (signal?.aborted) return { success: false, output: STOPPED_TOOL_RESULT, truncated: false };
+  switch (name) {
+    case "read_file": {
+      const offset = num(args.offset);
+      const limit = num(args.limit);
+      const maxBytes = num(args.maxBytes);
+      return fs10.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
+    }
+    case "read_files": {
+      const paths = Array.isArray(args.paths) ? args.paths.map(String) : [];
+      return fs10.readFiles(paths);
+    }
+    case "glob":
+      return fs10.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
+    case "grep":
+      return fs10.grep(String(args.pattern ?? ""), grepOptions(args));
+    case "find_symbol":
+      return fs10.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
+    case "list_dir":
+      return fs10.listDir(String(args.path ?? ""), num(args.depth));
+    case "bash":
+      return fs10.bash(String(args.command ?? ""), signal);
+    case "fetch": {
+      if (!fetcher) return { success: false, output: "Web fetching is not available in this environment.", truncated: false };
+      const url = String(args.url ?? "");
+      const allowed = await fetcher.confirm(url);
+      if (!allowed) return { success: false, output: `URL fetch denied by user: ${url}`, truncated: false };
+      return fetcher.fetch(url);
+    }
+    case "web_search": {
+      if (!fetcher?.search) {
+        return { success: false, output: "Web search is not available in this environment. If you already know a documentation URL, use the fetch tool instead.", truncated: false };
+      }
+      const query = String(args.query ?? "").trim();
+      if (!query) return { success: false, output: 'web_search requires a non-empty "query".', truncated: false };
+      return fetcher.search(query);
+    }
+    // Budget models hallucinate two kinds of tools: plan-committing ones
+    // (create_task, submit_plan) and implementation ones (create_file,
+    // write_file). Steer both back: you are a planner, tasks run later,
+    // and the commit channel is raw JSON in the reply text.
+    default:
+      return {
+        success: false,
+        output: `Unknown tool: ${name}. You are a PLANNER \u2014 you never create or edit files yourself; the coding agents executing the plan will do that later. Your tools are read-only research tools: read_file, read_files, glob, grep, find_symbol, list_dir, bash, fetch, web_search. To commit the final plan, output it as a raw JSON object with a "tasks" array directly in your reply text (no tool call).`,
+        truncated: false
+      };
+  }
+}
+
 // src/services/ApprovalPolicy.ts
 function scopeMatches(pattern, scope) {
   if (pattern === scope) return true;
@@ -2959,8 +3085,8 @@ function savePrdMarkdown(workspace, slug2, markdown) {
 
 // src/services/ContextCollector.ts
 var ORDEWELL_CONTEXT_MAX = 8e3;
-async function collectResearchContext(fs9, runners) {
-  const collector = new ContextCollector(fs9);
+async function collectResearchContext(fs10, runners) {
+  const collector = new ContextCollector(fs10);
   let contextStr = "";
   let firstContext = null;
   for (const r of runners) {
@@ -2987,8 +3113,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs9, registry) {
-    this.fs = fs9;
+  constructor(fs10, registry) {
+    this.fs = fs10;
     this.registry = registry;
   }
   fs;
@@ -3024,80 +3150,6 @@ var ContextCollector = class {
   }
 };
 
-// src/services/executeTool.ts
-var GREP_OUTPUT_MODES = ["content", "files", "count"];
-function num(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function bool(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function str(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function grepOptions(args) {
-  const mode = str(args.output_mode ?? args.outputMode);
-  return {
-    include: str(args.include),
-    path: str(args.path),
-    outputMode: GREP_OUTPUT_MODES.includes(mode) ? mode : void 0,
-    contextBefore: num(args.context_before ?? args.contextBefore),
-    contextAfter: num(args.context_after ?? args.contextAfter),
-    literal: bool(args.literal),
-    caseInsensitive: bool(args.case_insensitive ?? args.caseInsensitive),
-    headLimit: num(args.head_limit ?? args.headLimit)
-  };
-}
-async function executeTool(name, args, fs9, fetcher) {
-  switch (name) {
-    case "read_file": {
-      const offset = num(args.offset);
-      const limit = num(args.limit);
-      const maxBytes = num(args.maxBytes);
-      return fs9.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
-    }
-    case "read_files": {
-      const paths = Array.isArray(args.paths) ? args.paths.map(String) : [];
-      return fs9.readFiles(paths);
-    }
-    case "glob":
-      return fs9.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
-    case "grep":
-      return fs9.grep(String(args.pattern ?? ""), grepOptions(args));
-    case "find_symbol":
-      return fs9.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
-    case "list_dir":
-      return fs9.listDir(String(args.path ?? ""), num(args.depth));
-    case "bash":
-      return fs9.bash(String(args.command ?? ""));
-    case "fetch": {
-      if (!fetcher) return { success: false, output: "Web fetching is not available in this environment.", truncated: false };
-      const url = String(args.url ?? "");
-      const allowed = await fetcher.confirm(url);
-      if (!allowed) return { success: false, output: `URL fetch denied by user: ${url}`, truncated: false };
-      return fetcher.fetch(url);
-    }
-    case "web_search": {
-      if (!fetcher?.search) {
-        return { success: false, output: "Web search is not available in this environment. If you already know a documentation URL, use the fetch tool instead.", truncated: false };
-      }
-      const query = String(args.query ?? "").trim();
-      if (!query) return { success: false, output: 'web_search requires a non-empty "query".', truncated: false };
-      return fetcher.search(query);
-    }
-    // Budget models hallucinate two kinds of tools: plan-committing ones
-    // (create_task, submit_plan) and implementation ones (create_file,
-    // write_file). Steer both back: you are a planner, tasks run later,
-    // and the commit channel is raw JSON in the reply text.
-    default:
-      return {
-        success: false,
-        output: `Unknown tool: ${name}. You are a PLANNER \u2014 you never create or edit files yourself; the coding agents executing the plan will do that later. Your tools are read-only research tools: read_file, read_files, glob, grep, find_symbol, list_dir, bash, fetch, web_search. To commit the final plan, output it as a raw JSON object with a "tasks" array directly in your reply text (no tool call).`,
-        truncated: false
-      };
-  }
-}
-
 // src/services/ResearchSubagents.ts
 var SUBAGENT_LIMITS = {
   /** Max spawn calls in flight at once; extra calls in the same turn wait for a slot. */
@@ -3110,23 +3162,23 @@ var ALLOWED_TOOL_NAMES = new Set(subagentToolSpecs().map((t) => t.name));
 function refused(output) {
   return { success: false, output, truncated: false };
 }
-function nonPromptingFs(fs9) {
-  const withinWorkspace = (p) => resolveWithin(fs9.getWorkspaceRoot(), p ?? ".").inside;
+function nonPromptingFs(fs10) {
+  const withinWorkspace = (p) => resolveWithin(fs10.getWorkspaceRoot(), p ?? ".").inside;
   const outsideRefusal = (p) => refused(
     `Path "${p}" is outside the workspace. Research agents are confined to the workspace root \u2014 note the gap in your digest and let the planner request it directly.`
   );
   return {
-    getWorkspaceRoot: () => fs9.getWorkspaceRoot(),
-    readFile: (p, opts) => withinWorkspace(p) ? fs9.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
+    getWorkspaceRoot: () => fs10.getWorkspaceRoot(),
+    readFile: (p, opts) => withinWorkspace(p) ? fs10.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
     readFiles: (paths) => {
       const escaping = paths.find((p) => !withinWorkspace(p));
-      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs9.readFiles(paths);
+      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs10.readFiles(paths);
     },
-    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs9.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs9.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs9.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    listDir: (p, depth) => withinWorkspace(p) ? fs9.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
-    bash: async (command) => {
+    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs10.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs10.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs10.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    listDir: (p, depth) => withinWorkspace(p) ? fs10.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
+    bash: async (command, signal) => {
       const dialect = resolveResearchShell().dialect;
       const { tier, reason } = classifyCommand(command, { dialect });
       if (tier !== "auto") {
@@ -3136,13 +3188,13 @@ function nonPromptingFs(fs9) {
       }
       const escaping = pathLikeArgs(command, { dialect }).find((p) => !withinWorkspace(p));
       if (escaping) return outsideRefusal(escaping);
-      return fs9.bash(command);
+      return fs10.bash(command, signal);
     }
   };
 }
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
-  const fs9 = nonPromptingFs(deps.fs);
+  const fs10 = nonPromptingFs(deps.fs);
   const chat = deps.createChat((delta) => deps.onProgress?.({ type: "thinking", text: delta }));
   let turn = await chat.sendMessage(prompt, deps.signal);
   for (let step = 0; turn.hasToolCalls && step < SUBAGENT_LIMITS.maxSteps; step++) {
@@ -3159,7 +3211,7 @@ ${turn.text}`;
       if (tc.name === "read_file" && !("maxBytes" in args) && !("limit" in args)) args.limit = 2e3;
       const toolArgs = JSON.stringify(tc.args);
       deps.onProgress?.({ type: "tool_call", tool: tc.name, toolArgs, toolCallId: tc.id });
-      const res = await executeTool(tc.name, args, fs9);
+      const res = await executeTool(tc.name, args, fs10, void 0, deps.signal);
       const output = res.output.length > SUBAGENT_LIMITS.toolOutputMaxChars ? res.output.slice(0, SUBAGENT_LIMITS.toolOutputMaxChars) + `
 [... truncated to ${SUBAGENT_LIMITS.toolOutputMaxChars} chars, total ${res.output.length}]` : res.output;
       const stepEntry = {
@@ -3274,7 +3326,7 @@ var BaseAiService = class _BaseAiService {
    * steering/failed result and the loop continues sequentially: a subagent can
    * never fail a plan or a turn.
    */
-  async executeSpawnAgent(args, fs9, onProgress, signal, subagentId) {
+  async executeSpawnAgent(args, fs10, onProgress, signal, subagentId) {
     if (!this.researchSubagentsEnabled) {
       return { success: false, output: "spawn_research_agent is not available in this session. Continue researching sequentially with your other tools (read_file, glob, grep, list_dir, bash).", truncated: false };
     }
@@ -3288,20 +3340,20 @@ var BaseAiService = class _BaseAiService {
         if (!chat) throw new Error("subagent chats are not available for this provider");
         return chat;
       },
-      fs: fs9,
+      fs: fs10,
       signal,
       onProgress: (progress) => onProgress({ ...progress, subagentId })
     });
   }
   /** Collect project context for the planning phase. Shared with the harness backend. */
-  static async collectResearchContext(fs9, runners) {
-    return collectResearchContext(fs9, runners);
+  static async collectResearchContext(fs10, runners) {
+    return collectResearchContext(fs10, runners);
   }
   /**
    * Execute one round of tool calls and report each through onProgress.
    * Returns the results to feed back plus the log entries produced.
    */
-  async executeToolCalls(toolCalls, fs9, onProgress, fetcher, stepIndex, thinking, signal) {
+  async executeToolCalls(toolCalls, fs10, onProgress, fetcher, stepIndex, thinking, signal) {
     const toolResults = [];
     const logEntries = [];
     let resultsText = "";
@@ -3320,18 +3372,18 @@ var BaseAiService = class _BaseAiService {
         const subagentId = uuidv4();
         spawnSubagentIds.set(i, subagentId);
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), subagentId, toolCallId: toolCalls[i].id });
-        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs9, onProgress, signal, subagentId));
+        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs10, onProgress, signal, subagentId));
       }) : Promise.resolve(),
       parallelIndexes.length > 1 ? mapWithConcurrency(parallelIndexes, TOOL_ROUND_CONCURRENCY, async (i) => {
         onProgress({ type: "tool_call", tool: toolCalls[i].name, toolArgs: JSON.stringify(toolCalls[i].args), toolCallId: toolCalls[i].id });
-        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs9, fetcher));
+        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs10, fetcher, signal));
       }) : Promise.resolve()
     ]);
     for (const [index, tc] of toolCalls.entries()) {
       const toolArgs = normalizedArgs[index];
       const preResult = precomputed.get(index);
       if (!preResult) onProgress({ type: "tool_call", tool: tc.name, toolArgs: JSON.stringify(tc.args), toolCallId: tc.id });
-      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs9, fetcher);
+      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs10, fetcher, signal);
       const MAX_RESPONSE_CHARS = 5e4;
       const truncatedResponse = toolResult.success && (toolResult.truncated || toolResult.output.length > MAX_RESPONSE_CHARS);
       const llmOutput = toolResult.output.length > MAX_RESPONSE_CHARS ? toolResult.output.slice(0, MAX_RESPONSE_CHARS) + `
@@ -3517,7 +3569,7 @@ ${llmOutput}
    * parsed tasks if a plan was emitted mid-loop, or null if the loop
    * exhausted without a valid plan.
    */
-  async runResearchLoop(chat, firstMessage, fs9, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
+  async runResearchLoop(chat, firstMessage, fs10, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
     const researchLog = initialLog ? [...initialLog] : [];
     if (!initialLog && userGoal) {
       researchLog.push({
@@ -3544,7 +3596,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs9,
+        fs10,
         onProgress,
         fetcher,
         step,
@@ -3782,11 +3834,11 @@ ${repairHint}` }] : parts;
     return this.consumePlanStream(result, onToken);
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs9, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     const genModel = this.getPlanningModel();
-    const contextStr = await BaseAiService.collectResearchContext(fs9, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs10, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const firstMessage = `${buildResearchToolsPrompt()}
 
@@ -3797,17 +3849,17 @@ Explore the workspace to understand the codebase, then generate the plan.`;
       generationConfig: { temperature: 0.3, topP: 0.95, maxOutputTokens: 16384 }
     });
     const researchChat = new GeminiResearchChat(chat);
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs9, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs10, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs9, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs9) {
-      const collected = await new ContextCollector(fs9).collect(runners[0] ?? "claude-code");
+    if (fs10) {
+      const collected = await new ContextCollector(fs10).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -3823,12 +3875,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs9, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs9) {
-      const collected = await new ContextCollector(fs9).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs10) {
+      const collected = await new ContextCollector(fs10).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -4068,12 +4120,12 @@ ${buildResearchToolsPrompt(this.researchSubagentsEnabled)}` }
     }
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs9, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const client = this.getClient();
     const { autonomousDefault, researchSubagents: researchSubagentsEnabled } = modes;
     this.researchSubagentsEnabled = researchSubagentsEnabled;
-    const contextStr = await BaseAiService.collectResearchContext(fs9, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs10, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const userText = `User goal: ${userDescription}`;
     const firstMessage = `${buildResearchToolsPrompt(researchSubagentsEnabled)}
@@ -4091,17 +4143,17 @@ ${userText}`;
       toOpenAiTools(researchSubagentsEnabled),
       (delta) => onProgress({ type: "thinking", text: delta })
     );
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs9, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs10, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
     if (result.tasks) return { tasks: result.tasks, researchLog: result.researchLog, researchResults: result.researchResults };
     const fallback = await this.generatePlanFallback(userDescription, contextStr, result.researchResults, modelsByRunner, runners, onProgress, result.researchLog, runnerModes, autonomousDefault, signal, modes);
     return { tasks: fallback.tasks, researchLog: fallback.researchLog, researchResults: result.researchResults };
   }
-  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs9, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs9) {
-      const collected = await new ContextCollector(fs9).collect(runners[0] ?? "claude-code");
+    if (fs10) {
+      const collected = await new ContextCollector(fs10).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -4117,12 +4169,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs9, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs10, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs9) {
-      const collected = await new ContextCollector(fs9).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs10) {
+      const collected = await new ContextCollector(fs10).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -4740,6 +4792,7 @@ var PlanStore = class {
   }
   remove(taskId) {
     if (!this._taskMap.has(taskId)) return;
+    this.unblockDependents(taskId);
     this._planTasks = removeTaskFromPlan(this._planTasks, taskId);
     this.rebuild();
     this.pruneTerminalSets();
@@ -4794,9 +4847,7 @@ ${taskB.description}`,
     const userIds = /* @__PURE__ */ new Set([taskIdA, taskIdB]);
     const sanitized = this._planTasks.filter((t) => !userIds.has(t.id)).map((t) => ({
       ...t,
-      dependencies: t.dependencies.map(
-        (depId) => depId === taskIdA || depId === taskIdB ? mergedId : depId
-      )
+      dependencies: [...new Set(t.dependencies.map((depId) => userIds.has(depId) ? mergedId : depId))]
     }));
     this._planTasks = renumberTasks([...sanitized, merged]);
     this.rebuild();
@@ -4808,11 +4859,12 @@ ${taskB.description}`,
     const original = this._taskMap.get(taskId);
     if (!original) throw new Error(`Task ${taskId} not found`);
     if (!newTaskSpecs.length) throw new Error("Must provide at least one new task spec");
-    const newTasks = newTaskSpecs.map(
-      (spec, i) => createTask({
+    const finalized = [];
+    newTaskSpecs.forEach((spec, i) => {
+      finalized.push(createTask({
         ...spec,
         order: original.order + i,
-        dependencies: i === 0 ? [...original.dependencies] : [newTaskSpecs[0].id ?? `split-${taskId}-0`],
+        dependencies: i === 0 ? [...original.dependencies] : [finalized[i - 1].id],
         type: spec.type ?? original.type,
         assignedRunner: spec.assignedRunner ?? original.assignedRunner,
         assignedModel: spec.assignedModel ?? original.assignedModel,
@@ -4820,17 +4872,7 @@ ${taskB.description}`,
         autonomy: spec.autonomy ?? original.autonomy,
         sliceType: spec.sliceType ?? original.sliceType,
         userStoriesCovered: spec.userStoriesCovered ?? original.userStoriesCovered
-      })
-    );
-    const newTaskIds = /* @__PURE__ */ new Map();
-    newTasks.forEach((t, i) => newTaskIds.set(i, t.id));
-    const finalized = newTasks.map((t) => {
-      const deps = t.dependencies.map((depId) => {
-        const idx = newTaskSpecs.findIndex((s) => (s.id ?? "") === depId);
-        if (idx >= 0) return newTaskIds.get(idx) ?? depId;
-        return depId;
-      });
-      return { ...t, dependencies: deps };
+      }));
     });
     const tailId = finalized[finalized.length - 1].id;
     const updatedOthers = this._planTasks.filter((t) => t.id !== taskId).map((t) => ({
@@ -5075,6 +5117,15 @@ var TaskOrchestrator = class {
   get isRunning() {
     return this.running || this.startingTaskIds.size > 0 || this.activeTaskSessions.size > 0;
   }
+  /**
+   * 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() {
+    return this.activeTaskSessions.size > 0 || this.startingTaskIds.size > 0;
+  }
   get isReviewApproved() {
     return this.reviewApproved;
   }
@@ -5121,18 +5172,31 @@ var TaskOrchestrator = class {
     this.retryCounts.clear();
     this.onHold.clear();
   }
+  /**
+   * 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, planRunners = ["claude-code"]) {
+    const adopted = [...newTasks];
     for (const taskId of this.activeTaskSessions.keys()) {
       const task = this.store.get(taskId);
       if (!task) continue;
-      const inNewPlan = newTasks.find((t) => t.id === taskId);
-      if (!inNewPlan) {
-        newTasks.push({ ...task });
-      } else if (inNewPlan.status !== "in_progress") {
-        console.warn(`[TaskOrchestrator] Running task "${task.title}" status changed to "${inNewPlan.status}" in modified plan, using orchestrator truth`);
+      const at = adopted.findIndex((t) => t.id === taskId);
+      if (at < 0) {
+        adopted.push({ ...task });
+      } else if (adopted[at].status !== "in_progress") {
+        console.warn(`[TaskOrchestrator] Running task "${task.title}" status changed to "${adopted[at].status}" in modified plan, using orchestrator truth`);
+        adopted[at] = { ...adopted[at], status: "in_progress" };
       }
     }
-    this.store.load(newTasks, planRunners);
+    this.store.load(adopted, planRunners);
     this.planStatus = "running";
   }
   async start() {
@@ -5253,6 +5317,21 @@ ${output.slice(-3e3)}`);
     this.emit("onTaskChanged");
     await this.tick();
   }
+  /**
+   * 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.
+   */
+  async releaseTask(taskId) {
+    this.startingTaskIds.delete(taskId);
+    if (this.activeTaskSessions.has(taskId)) await this.cancelTask(taskId);
+    this.onHold.delete(taskId);
+    this.retryCounts.delete(taskId);
+  }
   async markTaskComplete(taskId) {
     const task = this.store.get(taskId);
     if (!task || task.status === "completed") return;
@@ -5712,28 +5791,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join13 = (...parts) => path5.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join13(base, ...parts)] : [];
+  const join14 = (...parts) => path5.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join14(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join13(home, ".local", "bin"),
-    join13(home, ".opencode", "bin"),
-    join13(home, ".claude", "bin"),
-    join13(home, ".codex", "bin"),
+    join14(home, ".local", "bin"),
+    join14(home, ".opencode", "bin"),
+    join14(home, ".claude", "bin"),
+    join14(home, ".codex", "bin"),
     ...under(localAppData, "Programs", "claude"),
     // Node package managers. npm's global prefix is `%APPDATA%\npm`; the
     // literal spelling is kept as a fallback for a host that does not export
     // APPDATA (a service account, a stripped CI container).
     ...under(appData, "npm"),
-    join13(home, "AppData", "Roaming", "npm"),
+    join14(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join13(home, ".bun", "bin"),
+    join14(home, ".bun", "bin"),
     // Windows package managers.
-    join13(home, "scoop", "shims"),
+    join14(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -5743,7 +5822,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join13(home, ".volta", "bin")
+    join14(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -5866,6 +5945,26 @@ Install the native executable \u2014 Claude Code's Windows installer, Codex's re
 function hasLineBreak(parts) {
   return parts.some((part) => /[\r\n]/.test(part));
 }
+var ExecutableNotFoundError = class extends Error {
+  constructor(command, searchedPath) {
+    super(`Could not find "${command}" on PATH.
+
+Searched: ${searchedPath || "(empty PATH)"}`);
+    this.command = command;
+    this.searchedPath = searchedPath;
+    this.name = "ExecutableNotFoundError";
+  }
+  command;
+  searchedPath;
+};
+function isResolvableOnPosixPath(command, PATH, exists) {
+  if (command.includes("/")) return exists(command);
+  return PATH.split(path6.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path6.join(dir, command)));
+}
+function isExecutableResolved(command, plan, PATH, deps = {}) {
+  if ((deps.platform ?? process.platform) === "win32") return plan.file !== command;
+  return isResolvableOnPosixPath(command, PATH, deps.exists ?? defaultExists2);
+}
 function defaultExists2(candidate) {
   try {
     return fsSync2.statSync(candidate).isFile();
@@ -6625,6 +6724,10 @@ var ModelDiscovery = class {
   clear() {
     this.cache.clear();
   }
+  /** Whatever `discover()` has already cached for `runner` — never triggers discovery. */
+  getCached(runner) {
+    return this.cache.get(runner);
+  }
 };
 
 // src/services/ModelCatalog.ts
@@ -6943,6 +7046,17 @@ var ModelResolver = class {
   refreshRunnerModels() {
     this.discovery.clear();
   }
+  /**
+   * 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) {
+    return this.discovery.getCached(runner) ?? [];
+  }
+  getCachedPickerOptions() {
+    return this.cachedPickerOptions ?? [];
+  }
   invalidate() {
     this.discovery.clear();
     this.cachedPickerOptions = null;
@@ -7070,6 +7184,28 @@ var RunnerInstallation = class {
 // src/services/harness/CliAgentAiService.ts
 import { spawn as nodeSpawn } from "child_process";
 
+// src/utils/workspace.ts
+import * as fs3 from "fs";
+var WorkspaceNotFoundError = class extends Error {
+  constructor(workspace) {
+    super(`Workspace "${workspace}" does not exist.`);
+    this.workspace = workspace;
+    this.name = "WorkspaceNotFoundError";
+  }
+  workspace;
+};
+function defaultIsDirectory(candidate) {
+  try {
+    return fs3.statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function assertWorkspaceExists(workspace, deps = {}) {
+  const isDirectory = deps.isDirectory ?? defaultIsDirectory;
+  if (!isDirectory(workspace)) throw new WorkspaceNotFoundError(workspace);
+}
+
 // src/services/harness/AgentAdapter.ts
 var LineBuffer = class {
   buffer = "";
@@ -7123,6 +7259,7 @@ var StdioAgentAdapter = class {
   async handshake(_opts) {
   }
   async start(opts) {
+    assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
     this.processEnded = new Promise((resolve3) => {
       this.markEnded = resolve3;
     });
@@ -7134,6 +7271,9 @@ var StdioAgentAdapter = class {
       platform: this.deps.platform,
       resolvePath
     });
+    if (!isExecutableResolved(spec.command, launch, PATH, { platform: this.deps.platform, exists: this.deps.exists })) {
+      throw new ExecutableNotFoundError(spec.command, PATH);
+    }
     this.process = this.deps.spawn(launch.file, launch.args, {
       env: this.spawnEnv,
       stdio: ["pipe", "pipe", "pipe"],
@@ -7756,12 +7896,16 @@ var OpenCodeAdapter = class {
   opts = null;
   async start(opts) {
     this.opts = opts;
+    assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
     const resolvePath = this.deps.resolvePath ?? augmentedPath;
     const PATH = await resolvePath();
     const launch = await planDirectLaunch("opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
       platform: this.deps.platform,
       resolvePath
     });
+    if (!isExecutableResolved("opencode", launch, PATH, { platform: this.deps.platform, exists: this.deps.exists })) {
+      throw new ExecutableNotFoundError("opencode", PATH);
+    }
     this.process = this.deps.spawn(launch.file, launch.args, {
       env: withPath(process.env, PATH),
       stdio: ["pipe", "pipe", "pipe"],
@@ -8075,7 +8219,9 @@ var CliAgentAiService = class {
       spawn: deps.spawn ?? nodeSpawn,
       fetch: deps.fetch ?? globalThis.fetch,
       resolvePath: deps.resolvePath,
-      platform: deps.platform
+      platform: deps.platform,
+      isDirectory: deps.isDirectory,
+      exists: deps.exists
     };
     this.makeAdapter = deps.createAdapter ?? defaultAdapter;
     this.workspaceRoot = deps.workspaceRoot ?? (() => process.cwd());
@@ -8420,8 +8566,8 @@ var CliAgentAiService = class {
       this.lastNativeSessionId = previousSessionId;
     }
   }
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs9, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
-    const contextStr = await collectResearchContext(fs9, runners);
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs10, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+    const contextStr = await collectResearchContext(fs10, runners);
     const researchLog = [
       { id: `up-${Date.now()}`, type: "user_prompt", content: userDescription, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
     ];
@@ -8791,16 +8937,16 @@ function executionSummary(tasks) {
 }
 
 // src/utils/sessionStore.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path10 from "path";
 
 // src/utils/fsHelpers.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path9 from "path";
 var STATE_DIR = ".ordewell";
 function ensureDir(dir) {
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
 }
 function getStateDir(baseDir) {
@@ -8845,16 +8991,16 @@ function saveSession(plan, goal, baseDir, id) {
   };
   const filename = sessionFilename(meta);
   const filePath = path10.join(sessionsDir, filename);
-  fs4.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  fs5.writeFileSync(filePath, JSON.stringify(session, null, 2));
   return meta;
 }
 function listSessions(baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs4.existsSync(sessionsDir)) return [];
-  const files = fs4.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs5.existsSync(sessionsDir)) return [];
+  const files = fs5.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   return files.map((f) => {
     try {
-      const raw = fs4.readFileSync(path10.join(sessionsDir, f), "utf-8");
+      const raw = fs5.readFileSync(path10.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -8869,10 +9015,10 @@ function listSessions(baseDir, logger = defaultLogger) {
   }).filter((m) => m !== null).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
 function findSessionFile(sessionsDir, sessionId, logger) {
-  const files = fs4.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const files = fs5.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   for (const f of files) {
     try {
-      const raw = fs4.readFileSync(path10.join(sessionsDir, f), "utf-8");
+      const raw = fs5.readFileSync(path10.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -8883,11 +9029,11 @@ function findSessionFile(sessionsDir, sessionId, logger) {
 }
 function loadSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs4.existsSync(sessionsDir)) return null;
+  if (!fs5.existsSync(sessionsDir)) return null;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs4.readFileSync(path10.join(sessionsDir, file), "utf-8");
+      const raw = fs5.readFileSync(path10.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -8917,11 +9063,11 @@ function getLatestSession(baseDir, logger = defaultLogger) {
 }
 function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs4.existsSync(sessionsDir)) return false;
+  if (!fs5.existsSync(sessionsDir)) return false;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs4.unlinkSync(path10.join(sessionsDir, file));
+      fs5.unlinkSync(path10.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -8931,6 +9077,12 @@ function deleteSession(sessionId, baseDir, logger = defaultLogger) {
 }
 
 // src/services/createSession.ts
+var PlanEditError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanEditError";
+  }
+};
 function sessionRuntimeSettings(settings) {
   return { ...plannerRuntimeToggles(settings), modelAllowlist: settings.modelAllowlist };
 }
@@ -9203,12 +9355,41 @@ var Session = class {
   get isExecuting() {
     return this.orchestrator.isRunning;
   }
+  /** See {@link TaskOrchestrator.hasLiveWork} — a spawned runner, not merely an armed scheduler. */
+  get hasLiveWork() {
+    return this.orchestrator.hasLiveWork;
+  }
   get status() {
     return this.orchestrator.status;
   }
   get sessionConfig() {
     return this.config;
   }
+  /**
+   * 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.
+   */
+  denyApprovalsOnAbort(signal) {
+    if (!signal) return () => {
+    };
+    if (signal.aborted) {
+      this.approvals.clear();
+      return () => {
+      };
+    }
+    const onAbort = () => this.approvals.clear();
+    signal.addEventListener("abort", onAbort);
+    return () => signal.removeEventListener("abort", onAbort);
+  }
   async startExecution() {
     if (!this.plan || !this.store.planTasks.length) throw new Error("No plan to execute");
     this.store.clearLog();
@@ -9231,19 +9412,25 @@ var Session = class {
     const settings = this.settingsFn();
     const { modelAllowlist } = settings;
     const modes = plannerModesFrom(settings, this.config.autonomousMode);
-    const plan = await this.planner.generate({
-      goal,
-      runners: chosenRunners,
-      modelsByRunner,
-      runnerModes,
-      autonomousDefault: this.config.autonomousMode,
-      fs: this.fsAdapter,
-      fetcher: this.fetcher,
-      onProgress: (p) => this.translateProgress(p),
-      signal: options?.signal,
-      perRunnerAllowlist: modelAllowlist,
-      modes
-    });
+    const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
+    let plan;
+    try {
+      plan = await this.planner.generate({
+        goal,
+        runners: chosenRunners,
+        modelsByRunner,
+        runnerModes,
+        autonomousDefault: this.config.autonomousMode,
+        fs: this.fsAdapter,
+        fetcher: this.fetcher,
+        onProgress: (p) => this.translateProgress(p),
+        signal: options?.signal,
+        perRunnerAllowlist: modelAllowlist,
+        modes
+      });
+    } finally {
+      releaseAbort();
+    }
     this.plan = plan;
     this.orchestrator.loadPlan(plan.tasks, plan.runners);
     this.store.resetForRun({ preserveCompleted: false });
@@ -9280,23 +9467,28 @@ var Session = class {
       researchLog: [{ id: `up-${Date.now()}`, type: "user_prompt", content: goal, timestamp: now }],
       conversationHistory: [{ role: "user", content: goal, timestamp: now }]
     };
-    const turn = await this.aiService.startConversation({
-      goal,
-      runners: chosenRunners,
-      modelsByRunner: filteredModels,
-      runnerModes,
-      autonomousDefault: this.config.autonomousMode,
-      grillMeEnabled: grillMeEnabled ?? false,
-      prdEnabled: prdEnabled ?? false,
-      reviewEnabled: reviewEnabled ?? false,
-      verificationEnabled: verificationEnabled ?? false,
-      researchSubagentsEnabled: researchSubagentsEnabled ?? false,
-      fs: this.fsAdapter,
-      fetcher: this.fetcher,
-      onProgress: (p) => this.translateProgress(p),
-      signal: options?.signal
-    });
-    return this.settleTurn(turn, options);
+    const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
+    try {
+      const turn = await this.aiService.startConversation({
+        goal,
+        runners: chosenRunners,
+        modelsByRunner: filteredModels,
+        runnerModes,
+        autonomousDefault: this.config.autonomousMode,
+        grillMeEnabled: grillMeEnabled ?? false,
+        prdEnabled: prdEnabled ?? false,
+        reviewEnabled: reviewEnabled ?? false,
+        verificationEnabled: verificationEnabled ?? false,
+        researchSubagentsEnabled: researchSubagentsEnabled ?? false,
+        fs: this.fsAdapter,
+        fetcher: this.fetcher,
+        onProgress: (p) => this.translateProgress(p),
+        signal: options?.signal
+      });
+      return await this.settleTurn(turn, options);
+    } finally {
+      releaseAbort();
+    }
   }
   /**
    * Every subsequent user reply in the planning conversation — grill-me
@@ -9314,21 +9506,26 @@ var Session = class {
 ${userMessage}` : userMessage;
     const aiService = this.aiService;
     const canContinueLive = aiService.hasActiveConversation() && (aiService.conversationMatchesConfig?.() ?? true);
-    let turn = canContinueLive ? await aiService.continueConversation(
-      outgoing,
-      (p) => this.translateProgress(p),
-      options?.signal
-    ) : await this.resumeConversation(outgoing, priorHistory, options);
-    if ((turn.kind === "task_ops" || turn.kind === "plan") && this.isExecuting) {
-      this.queueMessage(userMessage);
-      this.plan.queuedMessages = this.getQueuedMessages();
-      turn = {
-        kind: "message",
-        text: `Execution is running, so I queued your change \u2014 it will be applied between task batches (${this.queuedCount} queued).`,
-        researchLog: turn.researchLog
-      };
+    const releaseAbort = this.denyApprovalsOnAbort(options?.signal);
+    try {
+      let turn = canContinueLive ? await aiService.continueConversation(
+        outgoing,
+        (p) => this.translateProgress(p),
+        options?.signal
+      ) : await this.resumeConversation(outgoing, priorHistory, options);
+      if ((turn.kind === "task_ops" || turn.kind === "plan") && this.hasLiveWork) {
+        this.queueMessage(userMessage);
+        this.plan.queuedMessages = this.getQueuedMessages();
+        turn = {
+          kind: "message",
+          text: `Execution is running, so I queued your change \u2014 it will be applied between task batches (${this.queuedCount} queued).`,
+          researchLog: turn.researchLog
+        };
+      }
+      return await this.settleTurn(turn, options);
+    } finally {
+      releaseAbort();
     }
-    return this.settleTurn(turn, options);
   }
   /**
    * Drive a planner turn to a persisted, broadcast outcome. Task edits apply
@@ -9367,7 +9564,10 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
       maxRepairs: 2,
       onExhausted: ({ reply, errors }) => invalidOps(errors, reply.researchLog)
     });
-    if ("plan" in settled) return settled.plan;
+    if ("plan" in settled) {
+      await this.orchestrator.tick();
+      return settled.plan;
+    }
     return this.applyConversationTurn(settled.turn);
   }
   /**
@@ -9382,9 +9582,9 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
     const lines = this.store.planTasks.map(
       (t) => `#${t.order} id=${t.id} "${t.title}" [${t.status}] runner:${t.assignedRunner}${t.assignedModel ? ` model:${t.assignedModel.modelId}` : ""} deps:[${t.dependencies.map((d) => orderOf.get(d) ?? d).join(", ")}]`
     );
-    const running = this.store.planTasks.filter((t) => t.status === "in_progress");
-    const execNote = this.isExecuting ? `
-Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${running.map((t) => `#${t.order}`).join(", ")}` : ""}. Any task edits you emit will be queued and applied between batches.` : "";
+    const locked = this.store.planTasks.filter((t) => t.status === "in_progress");
+    const execNote = this.hasLiveWork ? `
+Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.map((t) => `#${t.order}`).join(", ")}` : ""}. Any task edits you emit will be queued and applied between batches.` : "";
     const modelLines = [];
     for (const runner of this.plan.runners) {
       const models = this.modelsCache[runner] ?? [];
@@ -9426,8 +9626,12 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
         this.plan.researchLog = [...this.plan.researchLog ?? [], ...turn.researchLog];
         const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
         const coerced = coerceAssignments(result.tasks, allowlist, this.plan.runners, this.modelsCache);
-        this.orchestrator.loadPlan(coerced, this.plan.runners);
-        this.store.resetForRun();
+        if (this.orchestrator.isRunning) {
+          this.orchestrator.reconcilePlan(coerced, this.plan.runners);
+        } else {
+          this.orchestrator.loadPlan(coerced, this.plan.runners);
+          this.store.resetForRun();
+        }
         this.appendTranscript("assistant", content, now);
         return true;
       },
@@ -9663,8 +9867,33 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
     notify();
     return this.plan;
   }
-  updateTask(taskId, changes) {
-    return this.mutatePlan(
+  /**
+   * 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.
+   */
+  async editPlan(op, notify) {
+    const plan = this.mutatePlan(op, notify);
+    if (!plan) return null;
+    await this.orchestrator.tick();
+    return plan;
+  }
+  /**
+   * 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.
+   */
+  async updateTask(taskId, changes) {
+    if (changes.dependencies) {
+      const check = canSetDependencies(this.store.planTasks, taskId, changes.dependencies);
+      if (!check.ok) throw new PlanEditError(check.error ?? "Those dependencies are not valid");
+    }
+    return this.editPlan(
       () => Boolean(this.store.update(taskId, changes)),
       () => this.broadcast({ type: "task_updated", taskId, changes })
     );
@@ -9674,8 +9903,7 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
    * 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}.
    */
@@ -9687,7 +9915,7 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
     const catalog = await this.catalogFor(runner);
     const changes = retargetTaskRunner(task, runner, this.allowedCatalog(catalog, runner));
     if (Object.keys(changes).length === 0) return this.plan;
-    return this.mutatePlan(() => {
+    return this.editPlan(() => {
       if (!this.store.update(taskId, changes)) return false;
       this.admitRunner(runner, catalog.models);
       return true;
@@ -9734,24 +9962,29 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
     if (models.length > 0) this.modelsCache = { ...this.modelsCache, [runner]: models };
   }
   /**
-   * 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, dependencies) {
+  async setTaskDependencies(taskId, dependencies) {
     if (!this.plan) return null;
-    const check = canSetDependencies(this.store.planTasks, taskId, dependencies);
-    if (!check.ok) throw new Error(check.error ?? "Those dependencies are not valid");
     return this.updateTask(taskId, { dependencies });
   }
   async completeTask(taskId) {
     await this.markTaskComplete(taskId);
   }
-  removeTask(taskId) {
-    return this.mutatePlan(() => (this.store.remove(taskId), true));
+  /**
+   * 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.
+   */
+  async removeTask(taskId) {
+    if (!this.plan || !this.store.get(taskId)) return null;
+    await this.orchestrator.releaseTask(taskId);
+    return this.editPlan(() => (this.store.remove(taskId), true));
   }
   /**
    * Add one task, filling in whatever the caller left unset. A task with no
@@ -9771,20 +10004,20 @@ Execution is RUNNING${running.length ? ` \u2014 these tasks are locked: ${runnin
     const runner = draft.assignedRunner ?? this.plan.runners[0];
     const dependencies = (draft.dependencies ?? []).filter((id) => this.store.get(id));
     const catalog = draft.type === "user" ? null : await this.catalogFor(runner);
-    return this.mutatePlan(() => {
+    return this.editPlan(() => {
       this.store.add({ ...draft, ...catalog ? runnerAssignment(this.allowedCatalog(catalog, runner), draft) : {}, assignedRunner: runner, dependencies });
       if (catalog) this.admitRunner(runner, catalog.models);
       return true;
     });
   }
-  mergeTasks(taskIdA, taskIdB) {
-    return this.mutatePlan(() => (this.store.merge(taskIdA, taskIdB), true));
+  async mergeTasks(taskIdA, taskIdB) {
+    return this.editPlan(() => (this.store.merge(taskIdA, taskIdB), true));
   }
-  mergeMultipleTasks(taskIds) {
-    return this.mutatePlan(() => (this.store.mergeMultiple(taskIds), true));
+  async mergeMultipleTasks(taskIds) {
+    return this.editPlan(() => (this.store.mergeMultiple(taskIds), true));
   }
-  splitTask(taskId, newTasks) {
-    return this.mutatePlan(() => (this.store.split(taskId, newTasks), true));
+  async splitTask(taskId, newTasks) {
+    return this.editPlan(() => (this.store.split(taskId, newTasks), true));
   }
   /**
    * Planner-driven merge: validate compatibility up front, then ask the planner
@@ -10298,7 +10531,7 @@ var HeadlessRunner = class extends AbstractRunner {
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify4 } from "util";
 import { tmpdir } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
 
 // src/utils/tmux.ts
@@ -10325,6 +10558,28 @@ function hasTmux(probe = defaultProbe) {
     return false;
   }
 }
+var defaultHasBin = (bin) => {
+  try {
+    execSync2(`${process.platform === "win32" ? "where" : "which"} ${bin}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platform, env = process.env) {
+  const candidates = platform === "darwin" ? [["pbcopy", "pbcopy"]] : platform === "win32" ? [["clip.exe", "clip.exe"]] : [
+    // Only prefer wl-copy when there is a Wayland display to talk to —
+    // on X11 it is often installed but fails at copy time.
+    ...env.WAYLAND_DISPLAY ? [["wl-copy", "wl-copy"]] : [],
+    ["xclip", "xclip -selection clipboard"],
+    ["xsel", "xsel --clipboard --input"],
+    ["wl-copy", "wl-copy"]
+  ];
+  for (const [bin, command] of candidates) {
+    if (hasBin(bin)) return command;
+  }
+  return null;
+}
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
@@ -10434,6 +10689,7 @@ var TmuxRunner = class extends AbstractRunner {
   resolvePath;
   pollIntervalMs;
   logDir;
+  clipboardCommand;
   /** Retries get a freshly named window so a failed attempt's output stays inspectable. */
   attempts = /* @__PURE__ */ new Map();
   ready = null;
@@ -10445,6 +10701,7 @@ var TmuxRunner = class extends AbstractRunner {
     this.resolvePath = deps.resolvePath ?? augmentedPath;
     this.pollIntervalMs = deps.pollIntervalMs ?? 500;
     this.logDir = deps.logDir ?? tmpdir();
+    this.clipboardCommand = deps.clipboardCommand ?? (() => clipboardCopyCommand());
   }
   /**
    * Reaps a session orphaned by a crashed prior daemon on the same port, then
@@ -10473,25 +10730,44 @@ var TmuxRunner = class extends AbstractRunner {
     await this.configureScrolling();
   }
   /**
-   * 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`.
    */
   async configureScrolling() {
-    try {
-      await this.tmux(["set-option", "-g", "history-limit", "100000"]);
-      await this.tmux(["set-option", "-g", "mouse", "on"]);
-      await this.tmux(["bind-key", "-n", "PageUp", "copy-mode", "-u"]);
-      await this.tmux(["bind-key", "-T", "copy-mode", "PageUp", "send-keys", "-X", "page-up"]);
-      await this.tmux(["bind-key", "-T", "copy-mode", "PageDown", "send-keys", "-X", "page-down"]);
-      await this.tmux(["bind-key", "-T", "copy-mode-vi", "PageUp", "send-keys", "-X", "page-up"]);
-      await this.tmux(["bind-key", "-T", "copy-mode-vi", "PageDown", "send-keys", "-X", "page-down"]);
-    } catch {
+    const clip = this.clipboardCommand();
+    const copySelection = clip ? ["copy-pipe-and-cancel", clip] : ["copy-pipe-and-cancel"];
+    const commands = [
+      // `history-limit` only governs windows created after it is set, so it
+      // must run before any `new-window` — once, here at session creation.
+      ["set-option", "-g", "history-limit", "100000"],
+      ["set-option", "-g", "mouse", "on"],
+      ["set-option", "-g", "set-clipboard", "on"],
+      ...clip ? [["set-option", "-g", "copy-command", clip]] : [],
+      ["bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", ...copySelection],
+      ["bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", ...copySelection],
+      // Root-table PageUp; otherwise the key goes to the inner app and never
+      // reaches tmux's scrollback. Both mode tables, so `mode-keys` can't
+      // decide whether paging works.
+      ["bind-key", "-n", "PageUp", "copy-mode", "-u"],
+      ["bind-key", "-T", "copy-mode", "PageUp", "send-keys", "-X", "page-up"],
+      ["bind-key", "-T", "copy-mode", "PageDown", "send-keys", "-X", "page-down"],
+      ["bind-key", "-T", "copy-mode-vi", "PageUp", "send-keys", "-X", "page-up"],
+      ["bind-key", "-T", "copy-mode-vi", "PageDown", "send-keys", "-X", "page-down"]
+    ];
+    for (const args of commands) {
+      try {
+        await this.tmux(args);
+      } catch {
+      }
     }
   }
   /**
@@ -10540,7 +10816,7 @@ var TmuxRunner = class extends AbstractRunner {
       windowName,
       this.execFileImpl,
       this.pollIntervalMs,
-      join8(this.logDir, `${id}.log`),
+      join9(this.logDir, `${id}.log`),
       this.socket
     );
     invocation.env = { ...invocation.env, PATH: await this.resolvePath() };
@@ -10551,13 +10827,13 @@ var TmuxRunner = class extends AbstractRunner {
 };
 
 // src/plugins/RunnerRegistry.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path12 from "path";
 import * as os5 from "os";
 import { execSync as execSync3 } from "child_process";
 
 // src/plugins/FsPluginStore.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path11 from "path";
 import * as os4 from "os";
 function userPluginsDir() {
@@ -10570,9 +10846,9 @@ function isValidManifest(obj) {
 }
 function loadManifestFromDir(dir) {
   const manifestPath = path11.join(dir, "manifest.json");
-  if (!fs5.existsSync(manifestPath)) return null;
+  if (!fs6.existsSync(manifestPath)) return null;
   try {
-    const raw = fs5.readFileSync(manifestPath, "utf8");
+    const raw = fs6.readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isValidManifest(parsed)) return null;
     return parsed;
@@ -10582,29 +10858,29 @@ function loadManifestFromDir(dir) {
 }
 function copyDirSync(src, dest) {
   ensureDir(dest);
-  const entries = fs5.readdirSync(src, { withFileTypes: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path11.join(src, entry.name);
     const destPath = path11.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
 function rmDirSync(dir) {
-  if (!fs5.existsSync(dir)) return;
-  const entries = fs5.readdirSync(dir, { withFileTypes: true });
+  if (!fs6.existsSync(dir)) return;
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const p = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       rmDirSync(p);
     } else {
-      fs5.unlinkSync(p);
+      fs6.unlinkSync(p);
     }
   }
-  fs5.rmdirSync(dir);
+  fs6.rmdirSync(dir);
 }
 var FsPluginStore = class {
   getUserPluginsDir() {
@@ -10612,10 +10888,10 @@ var FsPluginStore = class {
   }
   listUserPluginDirs() {
     const dir = userPluginsDir();
-    if (!fs5.existsSync(dir)) return [];
+    if (!fs6.existsSync(dir)) return [];
     let entries;
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -10634,20 +10910,20 @@ var FsPluginStore = class {
     ensureDir(dir);
   }
   writeFile(filePath, content) {
-    fs5.writeFileSync(filePath, content);
+    fs6.writeFileSync(filePath, content);
   }
   readFile(filePath) {
     try {
-      return fs5.readFileSync(filePath, "utf8");
+      return fs6.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
   }
   dirExists(path15) {
-    return fs5.existsSync(path15) && fs5.statSync(path15).isDirectory();
+    return fs6.existsSync(path15) && fs6.statSync(path15).isDirectory();
   }
   exists(path15) {
-    return fs5.existsSync(path15);
+    return fs6.existsSync(path15);
   }
 };
 
@@ -11116,20 +11392,20 @@ echo "Running ${name} with prompt: $prompt"
 };
 function fsReaddirSync(dir) {
   try {
-    return fs6.readdirSync(dir);
+    return fs7.readdirSync(dir);
   } catch {
     return [];
   }
 }
 function fsChmodSync(fpath, mode) {
   try {
-    fs6.chmodSync(fpath, mode);
+    fs7.chmodSync(fpath, mode);
   } catch {
   }
 }
 
 // src/utils/stateStore.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path13 from "path";
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
@@ -11139,14 +11415,14 @@ function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
   ensureDir(path13.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs7.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  fs8.writeFileSync(statePath, JSON.stringify(plan, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (!fs7.existsSync(statePath)) return null;
+  if (!fs8.existsSync(statePath)) return null;
   try {
-    const raw = fs7.readFileSync(statePath, "utf-8");
+    const raw = fs8.readFileSync(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.runners)) {
       logger.warn("stateStore", `rejecting state from ${statePath}: old format (scalar "runner" instead of "runners" array). Please re-plan.`);
@@ -11161,15 +11437,15 @@ function loadState(baseDir, logger = defaultLogger) {
 function clearState(baseDir) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (fs7.existsSync(statePath)) fs7.unlinkSync(statePath);
+  if (fs8.existsSync(statePath)) fs8.unlinkSync(statePath);
 }
 function stateExists(baseDir) {
   const dir = baseDir ?? process.cwd();
-  return fs7.existsSync(getStatePath(dir));
+  return fs8.existsSync(getStatePath(dir));
 }
 
 // src/services/SettingsService.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path14 from "path";
 import * as os6 from "os";
 var DEFAULTS = {
@@ -11185,6 +11461,17 @@ function getSettingsPath() {
   if (override && override.trim()) return override.trim();
   return path14.join(os6.homedir(), ".config", "ordewell", "settings.json");
 }
+function readPlannerModels(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  for (const [provider, entry] of Object.entries(raw)) {
+    if (!entry || typeof entry !== "object") continue;
+    const { model, effort } = entry;
+    if (typeof model !== "string" || !model.trim()) continue;
+    out[provider] = typeof effort === "string" && effort.trim() ? { model, effort } : { model };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 var SettingsService = class {
   filePath;
   cache = null;
@@ -11205,7 +11492,7 @@ var SettingsService = class {
   }
   fileMtimeMs() {
     try {
-      return fs8.statSync(this.filePath).mtimeMs;
+      return fs9.statSync(this.filePath).mtimeMs;
     } catch {
       return null;
     }
@@ -11278,6 +11565,26 @@ var SettingsService = class {
     }
     this.persist();
   }
+  getPlannerModel(provider) {
+    return this.getAll().plannerModels?.[provider];
+  }
+  setPlannerModel(provider, entry) {
+    this.getAll();
+    if (entry === void 0) {
+      if (this.cache.plannerModels) {
+        delete this.cache.plannerModels[provider];
+        if (Object.keys(this.cache.plannerModels).length === 0) {
+          this.cache.plannerModels = void 0;
+        }
+      }
+    } else {
+      if (!this.cache.plannerModels) {
+        this.cache.plannerModels = {};
+      }
+      this.cache.plannerModels[provider] = entry.effort ? { model: entry.model, effort: entry.effort } : { model: entry.model };
+    }
+    this.persist();
+  }
   getEnabledRunners() {
     return this.getAll().enabledRunners;
   }
@@ -11288,8 +11595,8 @@ var SettingsService = class {
   }
   load() {
     try {
-      if (fs8.existsSync(this.filePath)) {
-        const raw = JSON.parse(fs8.readFileSync(this.filePath, "utf-8"));
+      if (fs9.existsSync(this.filePath)) {
+        const raw = JSON.parse(fs9.readFileSync(this.filePath, "utf-8"));
         const settings = {
           grillMe: { enabled: raw.grillMe?.enabled ?? DEFAULTS.grillMe.enabled },
           tdd: { enabled: raw.tdd?.enabled ?? DEFAULTS.tdd.enabled },
@@ -11303,6 +11610,10 @@ var SettingsService = class {
         if (raw.modelAllowlist !== void 0) {
           settings.modelAllowlist = raw.modelAllowlist;
         }
+        const plannerModels = readPlannerModels(raw.plannerModels);
+        if (plannerModels) {
+          settings.plannerModels = plannerModels;
+        }
         if (Array.isArray(raw.enabledRunners)) {
           settings.enabledRunners = raw.enabledRunners.map(String);
         }
@@ -11314,13 +11625,48 @@ var SettingsService = class {
   }
   persist() {
     const dir = path14.dirname(this.filePath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
-    fs8.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
+    fs9.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
     this.cachedMtimeMs = this.fileMtimeMs();
   }
 };
+
+// src/services/PlannerModelMemory.ts
+var PlannerModelMemory = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  /** Record what the user picked for `provider`; a blank model forgets it instead. */
+  remember(provider, model, effort) {
+    const id = model.trim();
+    if (!id) {
+      this.store.setPlannerModel(provider, void 0);
+      return;
+    }
+    const level = effort?.trim();
+    this.store.setPlannerModel(provider, level ? { model: id, effort: level } : { model: id });
+  }
+  /**
+   * 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, catalog) {
+    const remembered = this.store.getPlannerModel(provider);
+    const match = remembered && catalog.find((c) => c.id === remembered.model);
+    if (remembered && match) {
+      const level = remembered.effort ?? "";
+      const survives = (match.variants ?? []).some((v) => v.id === level);
+      return { model: match.id, effort: survives ? level : "", source: "remembered" };
+    }
+    const first = catalog[0];
+    if (first) return { model: first.id, effort: "", source: "catalog-default" };
+    return { model: "", effort: "", source: "none" };
+  }
+};
 export {
   ALL_PROVIDERS,
   AUTO_COMMANDS,
@@ -11343,6 +11689,7 @@ export {
   DENY_ALL,
   EmbeddedNewlineError,
   EnvConfig,
+  ExecutableNotFoundError,
   FsPluginStore,
   GIT_READONLY_SUBCOMMANDS,
   GREP_DEFAULT_HEAD_LIMIT,
@@ -11363,14 +11710,17 @@ export {
   PROVIDER_PRIORITY,
   PROVIDER_SHORT_LABEL,
   PendingApprovals,
+  PlanEditError,
   PlanParseError,
   PlanStore,
   Planner,
+  PlannerModelMemory,
   REFUSED_COMMANDS,
   RunnerInstallation,
   RunnerRegistry,
   SEARCH_EXCLUSIONS,
   STATE_DIR,
+  STOPPED_TOOL_RESULT,
   SYMBOL_LANGUAGES,
   Session,
   SettingsService,
@@ -11381,9 +11731,11 @@ export {
   TmuxRunner,
   VerdictEngine,
   WINDOWS_MAX_COMMAND_LINE,
+  WorkspaceNotFoundError,
   addTaskToPlan,
   applyHeadLimit,
   applyTaskOps,
+  assertWorkspaceExists,
   augmentPromptWithPriorOutputs,
   augmentedPath,
   buildConversationSystemPrompt,
@@ -11416,6 +11768,7 @@ export {
   clearAugmentedPathCache,
   clearResearchShellCache,
   clearState,
+  clipboardCopyCommand,
   coerceAssignments,
   collectDirectDependencyOutputs,
   collectProviderCredentials,
@@ -11456,6 +11809,7 @@ export {
   hasTmux,
   includeGlobFor,
   isCliProvider,
+  isExecutableResolved,
   isOpenAiProvider,
   killTree,
   knownModelId,