@ordewell/core 0.5.1 → 0.5.2

package/dist/index.mjs

@@ -2637,33 +2637,33 @@ function grepOptions(args) {
   };
 }
 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, fs14, fetcher, signal) {
-  const outcome = await runTool(name, args, fs14, fetcher, signal);
+async function executeTool(name, args, fs15, fetcher, signal) {
+  const outcome = await runTool(name, args, fs15, fetcher, signal);
   return { ...outcome, output: redactSecrets(outcome.output) };
 }
-async function runTool(name, args, fs14, fetcher, signal) {
+async function runTool(name, args, fs15, 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 fs14.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
+      return fs15.readFile(String(args.path ?? ""), { offset, limit, maxBytes });
     }
     case "read_files": {
       const paths = Array.isArray(args.paths) ? args.paths.map(String) : [];
-      return fs14.readFiles(paths);
+      return fs15.readFiles(paths);
     }
     case "glob":
-      return fs14.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
+      return fs15.glob(String(args.pattern ?? ""), { path: str(args.path), headLimit: num(args.head_limit ?? args.headLimit) });
     case "grep":
-      return fs14.grep(String(args.pattern ?? ""), grepOptions(args));
+      return fs15.grep(String(args.pattern ?? ""), grepOptions(args));
     case "find_symbol":
-      return fs14.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
+      return fs15.findSymbol(String(args.symbol ?? ""), { language: str(args.language), path: str(args.path) });
     case "list_dir":
-      return fs14.listDir(String(args.path ?? ""), num(args.depth));
+      return fs15.listDir(String(args.path ?? ""), num(args.depth));
     case "bash":
-      return fs14.bash(String(args.command ?? ""), signal);
+      return fs15.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 ?? "");
@@ -2771,14 +2771,14 @@ var PendingApprovals = class {
   ask(request) {
     const id = `ap-${Date.now()}-${counter++}`;
     const pending = { id, request, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const settle = (granted) => {
         const entry = this.entries.get(id);
         if (!entry) return;
         clearTimeout(entry.timer);
         this.entries.delete(id);
         this.opts.onSettled?.(id, granted);
-        resolve6(granted);
+        resolve7(granted);
       };
       const timer = setTimeout(() => settle(false), this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
       timer.unref?.();
@@ -2876,9 +2876,9 @@ function applyHeadLimit(stdout, headLimit) {
 }
 function formatSearchOutput(capped, root, opts) {
   if (capped.rows.length === 0) return opts.emptyMessage;
-  const sep = opts.sep ?? path3.sep;
-  const prefix = root === sep || root.endsWith(sep) ? root : `${root}${sep}`;
-  const body = prefix === sep ? capped.rows.join("\n") : capped.rows.map((row) => row.startsWith(prefix) ? row.slice(prefix.length) : row).join("\n");
+  const sep2 = opts.sep ?? path3.sep;
+  const prefix = root === sep2 || root.endsWith(sep2) ? root : `${root}${sep2}`;
+  const body = prefix === sep2 ? capped.rows.join("\n") : capped.rows.map((row) => row.startsWith(prefix) ? row.slice(prefix.length) : row).join("\n");
   if (!capped.truncated) return body;
   const hint = opts.hint ? ` ${opts.hint}` : "";
   return `${body}
@@ -3469,6 +3469,15 @@ function configuredProviders(config) {
   return out;
 }
 
+// src/utils/maxParallel.ts
+var DEFAULT_MAX_PARALLEL = 3;
+function parseMaxParallel(value) {
+  const text = String(value ?? "").trim();
+  const n = typeof value === "number" ? value : Number(text);
+  if (text === "" || !Number.isInteger(n) || n < 1) return null;
+  return n;
+}
+
 // src/interfaces/BaseConfig.ts
 function normalizeGeminiModel(id) {
   return id.replace(/^gemini:/, "").replace(/^google\//, "");
@@ -3673,7 +3682,7 @@ var BaseConfig = class {
     return "";
   }
   get maxParallelSessions() {
-    return parseInt(process.env.ORDEWELL_MAX_PARALLEL || "3", 10);
+    return parseMaxParallel(process.env.ORDEWELL_MAX_PARALLEL) ?? DEFAULT_MAX_PARALLEL;
   }
   get researchEnabled() {
     return process.env.ORDEWELL_RESEARCH_ENABLED !== "false";
@@ -3824,28 +3833,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join22 = (...parts) => path4.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join22(base, ...parts)] : [];
+  const join23 = (...parts) => path4.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join23(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join22(home, ".local", "bin"),
-    join22(home, ".opencode", "bin"),
-    join22(home, ".claude", "bin"),
-    join22(home, ".codex", "bin"),
+    join23(home, ".local", "bin"),
+    join23(home, ".opencode", "bin"),
+    join23(home, ".claude", "bin"),
+    join23(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"),
-    join22(home, "AppData", "Roaming", "npm"),
+    join23(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join22(home, ".bun", "bin"),
+    join23(home, ".bun", "bin"),
     // Windows package managers.
-    join22(home, "scoop", "shims"),
+    join23(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -3855,7 +3864,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join22(home, ".volta", "bin")
+    join23(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -5836,12 +5845,12 @@ function buildConflictRepairPrompt(task, conflict, integrationBranch) {
   const files = conflict.conflictFiles ?? [];
   const asked = `What the task was asked to do:
 ${task.prompt ?? task.description}`;
-  const resolve6 = "resolve every conflict so that both sides' intent survives: keep the work already integrated and add what the task contributed.";
+  const resolve7 = "resolve every conflict so that both sides' intent survives: keep the work already integrated and add what the task contributed.";
   const repos = conflict.repos.filter((repo) => repo !== SELF_REPO);
   if (repos.length === 0) {
     return [
       `Task #${task.order} "${task.title}" passed, but merging its branch \`${branch}\` into \`${integrationBranch}\` conflicted${files.length > 0 ? ` in ${files.join(", ")}` : ""}. None of its work has landed yet.`,
-      `This is the task's own worktree, on \`${branch}\`, with its work committed. Run \`git merge --no-edit ${integrationBranch}\` here and ${resolve6} Never drop either side wholesale, and never abort the merge or reset it away.`,
+      `This is the task's own worktree, on \`${branch}\`, with its work committed. Run \`git merge --no-edit ${integrationBranch}\` here and ${resolve7} Never drop either side wholesale, and never abort the merge or reset it away.`,
       "Build and test the result the way this project does, commit the merge, and only then print the completion marker.",
       "",
       asked
@@ -5850,7 +5859,7 @@ ${task.prompt ?? task.description}`;
   const stoppedIn = conflict.conflictRepo ?? repos[0];
   return [
     `Task #${task.order} "${task.title}" passed, but landing its branch \`${branch}\` on \`${integrationBranch}\` conflicted in ${stoppedIn}${files.length > 0 ? ` (${files.join(", ")})` : ""}. A task lands in every repository it changed or in none, so none of its work has landed yet.`,
-    `This is the task's own workspace, with each repository at its usual path on \`${branch}\` and the task's work committed. In each repository the task changed \u2014 ${repos.join(", ")} \u2014 run \`git merge --no-edit ${integrationBranch}\` inside that repository's directory, and ${resolve6} Never drop either side wholesale, and never abort a merge or reset it away.`,
+    `This is the task's own workspace, with each repository at its usual path on \`${branch}\` and the task's work committed. In each repository the task changed \u2014 ${repos.join(", ")} \u2014 run \`git merge --no-edit ${integrationBranch}\` inside that repository's directory, and ${resolve7} Never drop either side wholesale, and never abort a merge or reset it away.`,
     "Build and test the result the way this project does, commit the merge in each repository, and only then print the completion marker.",
     "",
     asked
@@ -6186,8 +6195,8 @@ function compactResearchResults(resultsText, maxChars = COMPACTION_LIMITS.resear
 
 // src/services/ContextCollector.ts
 var ORDEWELL_CONTEXT_MAX = 8e3;
-async function collectResearchContext(fs14, runners) {
-  const collector = new ContextCollector(fs14);
+async function collectResearchContext(fs15, runners) {
+  const collector = new ContextCollector(fs15);
   let contextStr = "";
   let firstContext = null;
   for (const r of runners) {
@@ -6214,8 +6223,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs14, registry) {
-    this.fs = fs14;
+  constructor(fs15, registry) {
+    this.fs = fs15;
     this.registry = registry;
   }
   fs;
@@ -6263,22 +6272,22 @@ var ALLOWED_TOOL_NAMES = new Set(subagentToolSpecs().map((t) => t.name));
 function refused(output) {
   return { success: false, output, truncated: false };
 }
-function nonPromptingFs(fs14) {
-  const withinWorkspace = (p) => resolveWithin(fs14.getWorkspaceRoot(), p ?? ".").inside;
+function nonPromptingFs(fs15) {
+  const withinWorkspace = (p) => resolveWithin(fs15.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: () => fs14.getWorkspaceRoot(),
-    readFile: (p, opts) => withinWorkspace(p) ? fs14.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
+    getWorkspaceRoot: () => fs15.getWorkspaceRoot(),
+    readFile: (p, opts) => withinWorkspace(p) ? fs15.readFile(p, opts) : Promise.resolve(outsideRefusal(p)),
     readFiles: (paths) => {
       const escaping = paths.find((p) => !withinWorkspace(p));
-      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs14.readFiles(paths);
+      return escaping ? Promise.resolve(outsideRefusal(escaping)) : fs15.readFiles(paths);
     },
-    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs14.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs14.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs14.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
-    listDir: (p, depth) => withinWorkspace(p) ? fs14.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
+    glob: (pattern, opts) => withinWorkspace(opts?.path) ? fs15.glob(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    grep: (pattern, opts) => withinWorkspace(opts?.path) ? fs15.grep(pattern, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    findSymbol: (symbol, opts) => withinWorkspace(opts?.path) ? fs15.findSymbol(symbol, opts) : Promise.resolve(outsideRefusal(opts.path)),
+    listDir: (p, depth) => withinWorkspace(p) ? fs15.listDir(p, depth) : Promise.resolve(outsideRefusal(p)),
     bash: async (command, signal) => {
       const dialect = resolveResearchShell().dialect;
       const { tier, reason } = classifyCommand(command, { dialect });
@@ -6289,13 +6298,13 @@ function nonPromptingFs(fs14) {
       }
       const escaping = pathLikeArgs(command, { dialect }).find((p) => !withinWorkspace(p));
       if (escaping) return outsideRefusal(escaping);
-      return fs14.bash(command, signal);
+      return fs15.bash(command, signal);
     }
   };
 }
 async function runLoop(prompt, deps) {
   if (deps.signal?.aborted) return "[research agent aborted before starting]";
-  const fs14 = nonPromptingFs(deps.fs);
+  const fs15 = 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++) {
@@ -6312,7 +6321,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, fs14, void 0, deps.signal);
+      const res = await executeTool(tc.name, args, fs15, 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 = {
@@ -6428,7 +6437,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, fs14, onProgress, signal, subagentId) {
+  async executeSpawnAgent(args, fs15, onProgress, signal, subagentId) {
     const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
     if (!prompt) {
       return { success: false, output: 'spawn_research_agent requires a non-empty "prompt" string: a self-contained task for the agent, including what its digest must report back.', truncated: false };
@@ -6439,20 +6448,20 @@ var BaseAiService = class _BaseAiService {
         if (!chat) throw new Error("subagent chats are not available for this provider");
         return chat;
       },
-      fs: fs14,
+      fs: fs15,
       signal,
       onProgress: (progress) => onProgress({ ...progress, subagentId })
     });
   }
   /** Collect project context for the planning phase. Shared with the harness backend. */
-  static async collectResearchContext(fs14, runners) {
-    return collectResearchContext(fs14, runners);
+  static async collectResearchContext(fs15, runners) {
+    return collectResearchContext(fs15, 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, fs14, onProgress, fetcher, stepIndex, thinking, signal) {
+  async executeToolCalls(toolCalls, fs15, onProgress, fetcher, stepIndex, thinking, signal) {
     const toolResults = [];
     const logEntries = [];
     let resultsText = "";
@@ -6471,18 +6480,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 }, fs14, onProgress, signal, subagentId));
+        precomputed.set(i, await this.executeSpawnAgent({ ...toolCalls[i].args }, fs15, 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], fs14, fetcher, signal));
+        precomputed.set(i, await executeTool(toolCalls[i].name, normalizedArgs[i], fs15, 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, fs14, fetcher, signal);
+      const toolResult = preResult ?? await executeTool(tc.name, toolArgs, fs15, 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) + `
@@ -6668,7 +6677,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, fs14, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
+  async runResearchLoop(chat, firstMessage, fs15, onProgress, runners, initialLog, fetcher, userGoal, runnerModes, autonomousDefault, signal) {
     const researchLog = initialLog ? [...initialLog] : [];
     if (!initialLog && userGoal) {
       researchLog.push({
@@ -6695,7 +6704,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs14,
+        fs15,
         onProgress,
         fetcher,
         step,
@@ -6930,11 +6939,11 @@ ${repairHint}` }] : parts;
     return this.consumePlanStream(result, onToken);
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     const genModel = this.getPlanningModel();
-    const contextStr = await BaseAiService.collectResearchContext(fs14, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs15, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const firstMessage = `${buildResearchToolsPrompt()}
 
@@ -6945,17 +6954,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, fs14, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs15, 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, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -6971,12 +6980,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, _signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -7212,11 +7221,11 @@ ${buildResearchToolsPrompt()}` }
     }
   }
   // --- IAiService implementation ---
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const client = this.getClient();
     const { autonomousDefault } = modes;
-    const contextStr = await BaseAiService.collectResearchContext(fs14, runners);
+    const contextStr = await BaseAiService.collectResearchContext(fs15, runners);
     const systemPrompt = buildResearchPrompt(userDescription, contextStr, modelsByRunner, runners, runnerModes, modes);
     const userText = `User goal: ${userDescription}`;
     const firstMessage = `${buildResearchToolsPrompt()}
@@ -7234,17 +7243,17 @@ ${userText}`;
       toOpenAiTools(),
       (delta) => onProgress({ type: "thinking", text: delta })
     );
-    const result = await this.runResearchLoop(researchChat, firstMessage, fs14, onProgress, runners, void 0, fetcher, userDescription, runnerModes, autonomousDefault, signal);
+    const result = await this.runResearchLoop(researchChat, firstMessage, fs15, 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, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async generatePlanDirect(userDescription, runners = ["claude-code"], modelsByRunner = {}, onToken, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let ctx = "";
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(runners[0] ?? "claude-code");
       if (collected.aiflowContext) ctx = `
 <aiflow_context>
 ${collected.aiflowContext}
@@ -7260,12 +7269,12 @@ ${collected.aiflowContext}
       autonomousDefault
     );
   }
-  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs14, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+  async modifyPlan(existingPlan, userRequest, modelsByRunner, onProgress, fs15, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
     this.ensureInit();
     const { autonomousDefault } = modes;
     let aiflowContext;
-    if (fs14) {
-      const collected = await new ContextCollector(fs14).collect(existingPlan.runners[0] ?? "claude-code");
+    if (fs15) {
+      const collected = await new ContextCollector(fs15).collect(existingPlan.runners[0] ?? "claude-code");
       if (collected.aiflowContext) aiflowContext = collected.aiflowContext;
     }
     const prompt = buildModifyPlanPrompt(existingPlan, userRequest, modelsByRunner, aiflowContext, runnerModes, autonomousDefault);
@@ -7284,6 +7293,9 @@ ${collected.aiflowContext}
   }
 };
 
+// src/services/TaskOrchestrator.ts
+import * as path11 from "path";
+
 // src/services/promptAugment.ts
 var MAX_TAIL_CHARS = 500;
 var DEFAULT_PLAN_MAP_MAX_ENTRIES = 30;
@@ -7869,18 +7881,230 @@ ${line}
 };
 
 // src/services/transcriptCapture.ts
-import { readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync4, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync5, existsSync as existsSync4 } from "fs";
+import * as os4 from "os";
+import * as path10 from "path";
+
+// src/services/workspaceEnv.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs5 from "fs";
 import * as os3 from "os";
 import * as path9 from "path";
+
+// src/services/settingsEnvAllowlist.ts
+var ORDEWELL_SETTABLE_ENV = [
+  "AI_PROVIDER",
+  "ORCHESTRATOR_MODEL",
+  "ORDEWELL_SUBAGENT_MODEL",
+  "ORDEWELL_PLANNER_EFFORT",
+  "ORDEWELL_RESEARCH_ENABLED",
+  "ORDEWELL_MAX_PARALLEL",
+  "ORDEWELL_CONFLICT_REPAIR_ATTEMPTS"
+];
+var SETTINGS_ENV_REFUSED = [
+  // Approval posture and pre-approved scope.
+  "ORDEWELL_AUTONOMOUS_MODE",
+  "ORDEWELL_APPROVAL_MODE",
+  "ORDEWELL_APPROVAL_ALLOW",
+  // Where settings are persisted.
+  "ORDEWELL_SETTINGS_PATH",
+  // Runtime options and dynamic loaders.
+  "NODE_OPTIONS",
+  "NODE_REPL_EXTERNAL_MODULE",
+  "NODE_PATH",
+  "ELECTRON_RUN_AS_NODE",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "LD_AUDIT",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "DYLD_FRAMEWORK_PATH",
+  // Executable resolution.
+  "PATH",
+  "PATHEXT",
+  "NODE"
+];
+var REFUSED = new Set(SETTINGS_ENV_REFUSED);
+function providerEnvKeys() {
+  const keys = [];
+  for (const meta of Object.values(ALL_PROVIDERS)) {
+    if (meta.apiKeyEnvVar) keys.push(meta.apiKeyEnvVar);
+    if (meta.baseUrlEnvVar) keys.push(meta.baseUrlEnvVar);
+    for (const detect of meta.detectEnvVars) keys.push(detect);
+  }
+  return keys;
+}
+var PROVIDER_CREDENTIAL_ENV = new Set(providerEnvKeys());
+var SETTINGS_ENV_ALLOWLIST = new Set(
+  [...providerEnvKeys(), ...ORDEWELL_SETTABLE_ENV].filter((key) => !REFUSED.has(key))
+);
+function admitSettingsEnv(env) {
+  const accepted = {};
+  const rejected = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (REFUSED.has(key) || !SETTINGS_ENV_ALLOWLIST.has(key) || typeof value !== "string") {
+      rejected.push(key);
+      continue;
+    }
+    accepted[key] = value;
+  }
+  return { accepted, rejected };
+}
+
+// src/services/workspaceEnv.ts
+var WORKSPACE_ENV_FILE = "env";
+var DIRENV_TIMEOUT_MS = 5e3;
+var KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function defaultDeps() {
+  return {
+    run: (command, args, opts) => new Promise((resolve7) => {
+      execFile2(command, args, { ...opts, timeout: DIRENV_TIMEOUT_MS, encoding: "utf8" }, (err, stdout, stderr) => {
+        const code = err ? typeof err.code === "number" ? Number(err.code) : -1 : 0;
+        resolve7({ code, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+      });
+    }),
+    readFile: (file) => {
+      try {
+        return fs5.readFileSync(file, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    isDirectory: (dir) => {
+      try {
+        return fs5.statSync(dir).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    baseEnv: process.env,
+    home: os3.homedir()
+  };
+}
+var REFUSED2 = new Set(SETTINGS_ENV_REFUSED);
+async function resolveWorkspaceEnv(cwd, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  const result = { env: {}, blockedEnvrc: null, refused: [], trackedEnvFile: null };
+  if (!deps.isDirectory(cwd)) return result;
+  const collected = {};
+  const direnv = await fromDirenv(checkoutDirOf(cwd, deps), deps);
+  result.blockedEnvrc = direnv.blocked;
+  Object.assign(collected, direnv.env);
+  const file = findUp(cwd, path9.join(STATE_DIR, WORKSPACE_ENV_FILE), deps);
+  if (file) {
+    const content = deps.readFile(file);
+    if (content !== null) {
+      if (await isTracked(file, deps)) result.trackedEnvFile = file;
+      else Object.assign(collected, parseEnvFile(content, { ...deps.baseEnv, ...collected }, deps.home));
+    }
+  }
+  for (const [key, value] of Object.entries(collected)) {
+    if (!KEY.test(key)) continue;
+    if (REFUSED2.has(key) || key.toUpperCase() === "PATH") result.refused.push(key);
+    else result.env[key] = value;
+  }
+  return result;
+}
+async function workspaceEnvOf(cwd) {
+  return (await resolveWorkspaceEnv(cwd)).env;
+}
+function checkoutDirOf(cwd, deps) {
+  const parts = path9.resolve(cwd).split(path9.sep);
+  const at = parts.findIndex((part, i) => part === STATE_DIR && parts[i + 1] === "worktrees");
+  if (at < 0 || parts.length < at + 4) return cwd;
+  const root = parts.slice(0, at).join(path9.sep) || path9.sep;
+  const mapped = path9.join(root, ...parts.slice(at + 4));
+  return deps.isDirectory(mapped) ? mapped : root;
+}
+async function fromDirenv(cwd, deps) {
+  const setting = deps.baseEnv.ORDEWELL_DIRENV;
+  if (setting === "false" || setting === "0") return { env: {}, blocked: null };
+  const baseEnv = Object.fromEntries(Object.entries(deps.baseEnv).filter(([key]) => !key.startsWith("DIRENV_")));
+  let out;
+  try {
+    out = await deps.run("direnv", ["export", "json"], { cwd, env: baseEnv });
+  } catch {
+    return { env: {}, blocked: null };
+  }
+  const blocked = out.stderr.match(/error (\S*\.envrc) is blocked/);
+  if (blocked) return { env: {}, blocked: blocked[1] };
+  if (out.code !== 0 || !out.stdout.trim()) return { env: {}, blocked: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(out.stdout);
+  } catch {
+    return { env: {}, blocked: null };
+  }
+  if (!parsed || typeof parsed !== "object") return { env: {}, blocked: null };
+  const env = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string" && !key.startsWith("DIRENV_")) env[key] = value;
+  }
+  return { env, blocked: null };
+}
+function findUp(start, relative5, deps) {
+  let dir = path9.resolve(start);
+  for (; ; ) {
+    const candidate = path9.join(dir, relative5);
+    if (deps.readFile(candidate) !== null) return candidate;
+    const parent = path9.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function isTracked(file, deps) {
+  try {
+    const out = await deps.run("git", ["ls-files", "--error-unmatch", path9.basename(file)], { cwd: path9.dirname(file), env: deps.baseEnv });
+    return out.code === 0;
+  } catch {
+    return false;
+  }
+}
+function parseEnvFile(content, context, home) {
+  const env = {};
+  const lookup2 = (name) => env[name] ?? context[name] ?? "";
+  const expand = (value) => {
+    const tilde = value.startsWith("~/") ? path9.join(home, value.slice(2)) : value;
+    return tilde.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, braced, bare) => lookup2(braced ?? bare));
+  };
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim().replace(/^export\s+/, "");
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEY.test(key)) continue;
+    const rest = line.slice(eq + 1).trim();
+    if (rest.startsWith("'")) {
+      const end = rest.indexOf("'", 1);
+      env[key] = end > 0 ? rest.slice(1, end) : rest.slice(1);
+    } else if (rest.startsWith('"')) {
+      const end = rest.lastIndexOf('"');
+      env[key] = expand((end > 0 ? rest.slice(1, end) : rest.slice(1)).replace(/\\n/g, "\n").replace(/\\"/g, '"'));
+    } else {
+      env[key] = expand(rest.replace(/\s+#.*$/, ""));
+    }
+  }
+  return env;
+}
+
+// src/services/transcriptCapture.ts
 var HomeTranscriptReader = class {
   home;
+  claudeConfigDirs;
   constructor(opts = {}) {
     const { homeDir } = opts;
-    this.home = homeDir ? () => homeDir : () => process.env.HOME || os3.homedir();
+    this.home = homeDir ? () => homeDir : () => process.env.HOME || os4.homedir();
+    const workspaceEnv = opts.workspaceEnv ?? workspaceEnvOf;
+    this.claudeConfigDirs = async (cwd) => [...new Set([
+      (await workspaceEnv(cwd)).CLAUDE_CONFIG_DIR,
+      homeDir ? void 0 : process.env.CLAUDE_CONFIG_DIR,
+      path10.join(this.home(), ".claude")
+    ].filter((dir) => Boolean(dir)))];
   }
   async finalAssistantText(query, maxChars = 4e3) {
     try {
-      if (query.runner === "claude-code") return claudeFinal(this.home(), query, maxChars);
+      if (query.runner === "claude-code") return claudeFinal(await this.claudeConfigDirs(query.cwd), query, maxChars);
       if (query.runner === "opencode") return await opencodeFinal(this.home(), query, maxChars);
       if (query.runner === "codex") return codexFinal(this.home(), query, maxChars);
     } catch {
@@ -7889,22 +8113,22 @@ var HomeTranscriptReader = class {
   }
 };
 var CLAUDE_PROJECT_NAME_MAX = 200;
-function claudeProjectDirs(home, cwd) {
-  const projects = path9.join(home, ".claude", "projects");
+function claudeProjectDirs(configDir2, cwd) {
+  const projects = path10.join(configDir2, "projects");
   const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
   if (munged.length <= CLAUDE_PROJECT_NAME_MAX) {
-    const dir = path9.join(projects, munged);
+    const dir = path10.join(projects, munged);
     return existsSync4(dir) ? [dir] : [];
   }
   if (!existsSync4(projects)) return [];
   const prefix = `${munged.slice(0, CLAUDE_PROJECT_NAME_MAX)}-`;
-  return readdirSync3(projects).filter((name) => name.startsWith(prefix)).map((name) => path9.join(projects, name));
+  return readdirSync3(projects).filter((name) => name.startsWith(prefix)).map((name) => path10.join(projects, name));
 }
-function claudeFinal(home, query, maxChars) {
+function claudeFinal(configDirs, query, maxChars) {
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
-  const candidates = claudeProjectDirs(home, query.cwd).flatMap((dir) => readdirSync3(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path9.join(dir, f))).filter((f) => cutoff ? statSync4(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs);
+  const candidates = configDirs.flatMap((dir) => claudeProjectDirs(dir, query.cwd)).flatMap((dir) => readdirSync3(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(dir, f))).filter((f) => cutoff ? statSync5(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
   for (const file of candidates) {
-    const raw = readFileSync2(file, "utf8");
+    const raw = readFileSync3(file, "utf8");
     if (!raw.includes(query.marker)) continue;
     const text = claudeLastAssistant(raw);
     if (text) return clamp(text, maxChars);
@@ -7938,7 +8162,7 @@ async function opencodeFinal(home, query, maxChars) {
   } catch {
     return null;
   }
-  const dbPath = path9.join(home, ".local", "share", "opencode", "opencode.db");
+  const dbPath = path10.join(home, ".local", "share", "opencode", "opencode.db");
   if (!existsSync4(dbPath)) return null;
   let db;
   try {
@@ -7991,7 +8215,7 @@ async function opencodeFinal(home, query, maxChars) {
   }
 }
 function codexFinal(home, query, maxChars) {
-  const root = path9.join(home, ".codex", "sessions");
+  const root = path10.join(home, ".codex", "sessions");
   if (!existsSync4(root)) return null;
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
   const files = [];
@@ -8005,10 +8229,10 @@ function codexFinal(home, query, maxChars) {
       continue;
     }
     for (const e of entries) {
-      const full = path9.join(dir, e);
+      const full = path10.join(dir, e);
       let st;
       try {
-        st = statSync4(full);
+        st = statSync5(full);
       } catch {
         continue;
       }
@@ -8016,7 +8240,7 @@ function codexFinal(home, query, maxChars) {
       else if (e.startsWith("rollout-") && e.endsWith(".jsonl") && (!cutoff || st.mtimeMs >= cutoff - 5e3)) files.push(full);
     }
   }
-  files.sort((a, b) => statSync4(b).mtimeMs - statSync4(a).mtimeMs);
+  files.sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
   for (const file of cutoff ? files : files.slice(0, 10)) {
     const text = codexLastAssistant(file, query);
     if (text) return clamp(text, maxChars);
@@ -8024,7 +8248,7 @@ function codexFinal(home, query, maxChars) {
   return null;
 }
 function codexLastAssistant(file, query) {
-  const raw = readFileSync2(file, "utf8");
+  const raw = readFileSync3(file, "utf8");
   if (!raw.includes(query.marker)) return null;
   const lines = raw.split("\n").filter((l) => l.trim());
   let sawCwd = false;
@@ -8456,6 +8680,43 @@ ${taskB.description}`,
   }
 };
 
+// src/utils/shell.ts
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\r/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+function posixShellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function buildShellInvocation(command, args) {
+  const inner = [command, ...args].map(posixShellQuote).join(" ");
+  return { shellPath: "/bin/bash", shellArgs: ["-lc", inner] };
+}
+function wrapWithPty(command, args, opts = {}) {
+  const inner = [command, ...args].map(posixShellQuote).join(" ");
+  const watcher = opts.controlChannel ? 'exec 4<&0; ( while read -r C R <&3; do stty cols "$C" rows "$R" <&4; done ) & ' : "";
+  const setup = opts.size ? `stty cols ${opts.size.cols} rows ${opts.size.rows}; ` : "";
+  return { command: "script", args: ["-q", "-e", "-f", "-c", `${watcher}${setup}${inner}`, "/dev/null"] };
+}
+
+// src/services/blockingPrompts.ts
+var TAIL = 4096;
+var squash = (text) => stripAnsi(text).replace(/\s+/g, "").toLowerCase();
+function watchBlockingPrompts(session, prompts, onPrompt) {
+  if (prompts.length === 0) return;
+  const pending = prompts.map((prompt) => ({ prompt, phrase: squash(prompt.phrase) }));
+  let tail = "";
+  session.onOutput((text) => {
+    if (pending.length === 0) return;
+    tail = (tail + squash(text)).slice(-TAIL);
+    for (let i = pending.length - 1; i >= 0; i--) {
+      if (!tail.includes(pending[i].phrase)) continue;
+      onPrompt(pending[i].prompt);
+      pending.splice(i, 1);
+    }
+  });
+}
+
 // src/services/TaskOrchestrator.ts
 var SHARED_ROOT_TAIL = "tasks run in the workspace root without worktree isolation.";
 function sharedRootNotice(reason, repos) {
@@ -8519,6 +8780,25 @@ var TaskOrchestrator = class {
    */
   retryCounts = /* @__PURE__ */ new Map();
   spawnCounts = /* @__PURE__ */ new Map();
+  /**
+   * The terminal a verdict left open, by task. It stays so the user can read
+   * the agent's output or keep talking to it — but only while its worktree
+   * does: once that is removed the agent sits in a deleted directory, and a
+   * newer attempt in the same worktree would share it with a second agent.
+   * Without this, every task of every run left one agent process running
+   * until the daemon stopped.
+   */
+  lingering = /* @__PURE__ */ new Map();
+  /**
+   * A full-plan run a failure paused. Retrying the failed task is the explicit
+   * resume the pause waits for — without this a retry only reset the task to
+   * pending and nothing ran until the user also re-ran the whole plan.
+   */
+  haltedByFailure = false;
+  /** The workspace's own variables for a task's cwd (ADR-0016); swapped out in tests. */
+  workspaceEnv = (cwd) => resolveWorkspaceEnv(cwd);
+  /** What the workspace env has already warned about, so a run says it once, not per task. */
+  envWarnings = /* @__PURE__ */ new Set();
   /**
    * Tasks pulled out of auto-scheduling (user-cancelled or failed to spawn).
    * They stay 'pending' — "not executed" — but the scheduler skips them until
@@ -8562,6 +8842,32 @@ var TaskOrchestrator = class {
   setWorkspaceRoot(fn) {
     this.workspaceRootFn = fn;
   }
+  setWorkspaceEnvResolver(resolve7) {
+    this.workspaceEnv = resolve7;
+  }
+  /**
+   * The variables a task's agent gets from its workspace. What cannot be
+   * applied is said once — silently starting without them is how agents ran
+   * under the wrong account when an edited `.envrc` was left unallowed.
+   */
+  async envForTask(cwd) {
+    const resolved = await this.workspaceEnv(cwd);
+    const warn = (key, message) => {
+      if (this.envWarnings.has(key)) return;
+      this.envWarnings.add(key);
+      this.notifications.warn(message);
+    };
+    if (resolved.blockedEnvrc) {
+      warn(`blocked:${resolved.blockedEnvrc}`, `direnv has blocked ${resolved.blockedEnvrc}, so tasks start without its variables. Run \`direnv allow\` in ${path11.dirname(resolved.blockedEnvrc)} to use them.`);
+    }
+    if (resolved.trackedEnvFile) {
+      warn(`tracked:${resolved.trackedEnvFile}`, `Ignored ${resolved.trackedEnvFile}: git tracks it, and a committed file must not choose the environment agents run in. Untrack it to use it.`);
+    }
+    if (resolved.refused.length > 0) {
+      warn(`refused:${resolved.refused.join(",")}`, `Ignored ${resolved.refused.join(", ")} from the workspace environment: Ordewell never passes these to agents.`);
+    }
+    return resolved.env;
+  }
   setRegistry(registry) {
     this.registry = registry;
   }
@@ -8706,6 +9012,7 @@ var TaskOrchestrator = class {
     return result;
   }
   async clearMergedRun(run) {
+    this.closeLingeringOf(run);
     try {
       await this.isolation.discard(run, { integration: "delete-merged" });
     } catch (err) {
@@ -8716,14 +9023,32 @@ var TaskOrchestrator = class {
   }
   /** Worktrees and task branches go; the integration branch and the record stay for review and merge. */
   async cleanupRun() {
+    this.closeLingeringOf(this.requireRun());
     await this.isolation.discard(this.requireRun(), { integration: "keep" });
     this.emit("onIsolationChanged");
   }
   /** The run and everything it made go, and the plan forgets it; the next run starts afresh. */
   async discardRun() {
+    this.closeLingeringOf(this.requireRun());
     await this.isolation.discard(this.requireRun(), { integration: "delete" });
     this.forgetRun();
   }
+  watchBlockingPrompts(task, attempt, session) {
+    const manifest = this.registry?.get(attempt.runner)?.manifest;
+    watchBlockingPrompts(session, manifest?.runner.blockingPrompts ?? [], (prompt) => {
+      if (this.attempts.get(task.id) !== attempt) return;
+      this.notifications.warn(`Task "${task.title}" is waiting for you: ${manifest?.displayName ?? attempt.runner} is asking ${prompt.asks}. Answer it in the task's terminal.`);
+    });
+  }
+  closeLingering(taskId) {
+    const sessionId = this.lingering.get(taskId);
+    if (sessionId === void 0) return;
+    this.lingering.delete(taskId);
+    this.terminalRunner.stop(sessionId);
+  }
+  closeLingeringOf(run) {
+    for (const taskId of Object.keys(run.tasks)) this.closeLingering(taskId);
+  }
   forgetRun() {
     this.isolationRun = null;
     this.resolvers = {};
@@ -8811,11 +9136,18 @@ var TaskOrchestrator = class {
     if (!await this.openRun(() => this.start()) || this.running) return;
     console.log(`[TaskOrchestrator] Starting with ${this.store.allTasks.length} tasks (${this.store.allTasks.filter((t) => t.type === "ai" && t.prompt).length} AI ready)`);
     this.running = true;
+    this.haltedByFailure = false;
     this.planStatus = "running";
     this.emit("onTaskChanged");
     await this.tick();
   }
+  haltOnFailure() {
+    if (this.running) this.haltedByFailure = true;
+    this.running = false;
+    this.planStatus = "approved";
+  }
   stop() {
+    this.haltedByFailure = false;
     this.running = false;
     this.planStatus = "approved";
     this.terminalRunner.stopAll();
@@ -8852,8 +9184,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
       await this.landPassed(task, landing);
     } else {
       this.store.markFailed(taskId);
-      this.running = false;
-      this.planStatus = "approved";
+      this.haltOnFailure();
       this.notifications.error(`Task "${task.title}" failed verification: ${verdict.reason}`);
       if (attempt.worktree) await this.releaseWorktree(taskId, { keep: true });
     }
@@ -8993,8 +9324,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
       if (whyNot) this.tell("info", whyNot);
     } else {
       this.store.markFailed(task.id);
-      this.running = false;
-      this.planStatus = "approved";
+      this.haltOnFailure();
       this.notifications.error(inRepo ? `Task "${task.title}" passed, but git could not integrate its work in ${inRepo}, so none of it landed. Its worktrees are kept for inspection.` : `Task "${task.title}" passed, but git could not integrate its work. Its worktree is kept for inspection.`);
     }
   }
@@ -9045,6 +9375,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     await integration;
     const run = this.isolationRun;
     if (!run?.tasks[taskId]) return;
+    if (!opts.keep) this.closeLingering(taskId);
     try {
       await this.isolation.release(run, taskId, opts);
     } catch (err) {
@@ -9193,7 +9524,8 @@ ${summary || "(empty \u2014 no output captured)"}`);
     this.onHold.delete(taskId);
     this.emit("onTaskChanged");
     await this.releaseWorktree(taskId, { keep: false }, ended?.integration);
-    await this.tick();
+    if (this.haltedByFailure && !this.running) await this.start();
+    else await this.tick();
   }
   /**
    * Manually start a single AI task right now, bypassing dependency/readiness
@@ -9319,6 +9651,8 @@ ${summary || "(empty \u2014 no output captured)"}`);
         // A merge to resolve is not new behaviour to drive test-first.
         tddEnabled: !attempt.repair && this.tddEnabled()
       });
+      this.closeLingering(task.id);
+      const env = await this.envForTask(cwd);
       const session = await this.terminalRunner.spawn({
         taskId: task.id,
         runner: attempt.runner,
@@ -9330,13 +9664,15 @@ ${summary || "(empty \u2014 no output captured)"}`);
         cwd,
         registry: this.registry ?? void 0,
         order: task.order,
-        title: task.title
+        title: task.title,
+        env
       });
       if (this.attempts.get(task.id) !== attempt) return this.abandonSpawn(task, attempt, session);
       attempt.phase = "running";
       attempt.session = session;
       this.output.attach(task.id, session);
       this.verifier.watch(task, session);
+      this.watchBlockingPrompts(task, attempt, session);
       this.emit("onTaskChanged");
       if (attempt.repair) {
         const group = this.isolationRun?.repos.some((r) => r.path !== SELF_REPO);
@@ -9569,6 +9905,7 @@ ${summary || "(empty \u2014 no output captured)"}`);
     const attempt = this.attempts.get(taskId);
     this.attempts.delete(taskId);
     if (attempt) this.output.detach(taskId);
+    if (reason === "verdict" && attempt?.session) this.lingering.set(taskId, attempt.session.id);
     if (reason === "cancel" || reason === "release" || reason === "complete" || reason === "retry") {
       const task = this.store.get(taskId);
       if (task) this.verifier.clear(task);
@@ -9711,29 +10048,29 @@ ${errors.map((e) => `- ${e}`).join("\n")}`
 };
 
 // src/services/ModelDiscovery.ts
-import * as path12 from "path";
+import * as path14 from "path";
 import { exec as exec3, spawn } from "child_process";
 import { promisify as promisify3 } from "util";
 import * as fsSync3 from "fs";
 import * as osMod from "os";
 
 // src/utils/globalDataDir.ts
-import * as fs5 from "fs";
-import * as path10 from "path";
-import * as os4 from "os";
+import * as fs6 from "fs";
+import * as path12 from "path";
+import * as os5 from "os";
 function globalDataDir() {
-  return path10.join(os4.homedir(), ".ordewell");
+  return path12.join(os5.homedir(), ".ordewell");
 }
 function copyDirSync(src, dest) {
-  fs5.mkdirSync(dest, { recursive: true });
-  const entries = fs5.readdirSync(src, { withFileTypes: true });
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path10.join(src, entry.name);
-    const destPath = path10.join(dest, entry.name);
+    const srcPath = path12.join(src, entry.name);
+    const destPath = path12.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -9741,50 +10078,29 @@ var migrated = false;
 function migrateOldConfigDir() {
   if (migrated) return;
   migrated = true;
-  const oldDir = path10.join(os4.homedir(), ".config", "ordewell");
-  if (!fs5.existsSync(oldDir)) return;
+  const oldDir = path12.join(os5.homedir(), ".config", "ordewell");
+  if (!fs6.existsSync(oldDir)) return;
   const newDir = globalDataDir();
   const liftFile = (name) => {
-    const oldFile = path10.join(oldDir, name);
-    const newFile = path10.join(newDir, name);
-    if (fs5.existsSync(oldFile) && !fs5.existsSync(newFile)) {
-      fs5.mkdirSync(newDir, { recursive: true });
-      fs5.copyFileSync(oldFile, newFile);
+    const oldFile = path12.join(oldDir, name);
+    const newFile = path12.join(newDir, name);
+    if (fs6.existsSync(oldFile) && !fs6.existsSync(newFile)) {
+      fs6.mkdirSync(newDir, { recursive: true });
+      fs6.copyFileSync(oldFile, newFile);
     }
   };
   liftFile("settings.json");
   liftFile(".env");
-  const oldPlugins = path10.join(oldDir, "plugins");
-  const newPlugins = path10.join(newDir, "plugins");
-  if (fs5.existsSync(oldPlugins) && !fs5.existsSync(newPlugins)) {
+  const oldPlugins = path12.join(oldDir, "plugins");
+  const newPlugins = path12.join(newDir, "plugins");
+  if (fs6.existsSync(oldPlugins) && !fs6.existsSync(newPlugins)) {
     copyDirSync(oldPlugins, newPlugins);
   }
 }
 
 // src/utils/launch.ts
 import * as fsSync2 from "fs";
-import * as path11 from "path";
-
-// src/utils/shell.ts
-var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\r/g;
-function stripAnsi(text) {
-  return text.replace(ANSI_RE, "");
-}
-function posixShellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-function buildShellInvocation(command, args) {
-  const inner = [command, ...args].map(posixShellQuote).join(" ");
-  return { shellPath: "/bin/bash", shellArgs: ["-lc", inner] };
-}
-function wrapWithPty(command, args, opts = {}) {
-  const inner = [command, ...args].map(posixShellQuote).join(" ");
-  const watcher = opts.controlChannel ? 'exec 4<&0; ( while read -r C R <&3; do stty cols "$C" rows "$R" <&4; done ) & ' : "";
-  const setup = opts.size ? `stty cols ${opts.size.cols} rows ${opts.size.rows}; ` : "";
-  return { command: "script", args: ["-q", "-e", "-f", "-c", `${watcher}${setup}${inner}`, "/dev/null"] };
-}
-
-// src/utils/launch.ts
+import * as path13 from "path";
 var DIRECT_EXTENSIONS = [".exe", ".com"];
 var BATCH_EXTENSIONS = [".cmd", ".bat"];
 var POWERSHELL_EXTENSIONS = [".ps1"];
@@ -9792,7 +10108,7 @@ var CMD_EXE_MAX_COMMAND_LINE = 8191;
 var WINDOWS_MAX_COMMAND_LINE = 32767;
 function defaultPowerShell() {
   const root = process.env.SystemRoot || process.env.windir;
-  return root ? path11.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+  return root ? path13.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
 }
 var POWERSHELL_FLAGS = ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File"];
 var CommandLineTooLongError = class extends Error {
@@ -9844,7 +10160,7 @@ Searched: ${searchedPath || "(empty PATH)"}`);
 };
 function isResolvableOnPosixPath(command, PATH, exists) {
   if (command.includes("/")) return exists(command);
-  return PATH.split(path11.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path11.join(dir, command)));
+  return PATH.split(path13.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path13.join(dir, command)));
 }
 function isExecutableResolved(command, plan, PATH, deps = {}) {
   if ((deps.platform ?? process.platform) === "win32") return plan.file !== command;
@@ -9884,9 +10200,9 @@ function cmdArgs(line) {
   return ["/d", "/s", "/c", `"${line}"`];
 }
 function candidateExtensions(command, pathExt) {
-  const declared = pathExt.split(path11.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
+  const declared = pathExt.split(path13.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
   const known = /* @__PURE__ */ new Set([...DIRECT_EXTENSIONS, ...BATCH_EXTENSIONS, ...POWERSHELL_EXTENSIONS, ...declared]);
-  const ext = path11.win32.extname(command).toLowerCase();
+  const ext = path13.win32.extname(command).toLowerCase();
   if (ext && known.has(ext)) {
     const route = BATCH_EXTENSIONS.includes(ext) ? "cmd" : POWERSHELL_EXTENSIONS.includes(ext) ? "powershell" : "direct";
     return { direct: [], cmd: [], powershell: [], [route]: [""] };
@@ -9907,13 +10223,13 @@ async function findWindowsExecutables(command, deps) {
   const exists = deps.exists ?? defaultExists2;
   const pathExt = (deps.pathExt ?? (() => process.env.PATHEXT ?? ""))();
   const byRoute = candidateExtensions(command, pathExt);
-  const dirs = path11.win32.basename(command) !== command ? [path11.win32.dirname(path11.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path11.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
-  const base = path11.win32.basename(command);
+  const dirs = path13.win32.basename(command) !== command ? [path13.win32.dirname(path13.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path13.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  const base = path13.win32.basename(command);
   const found = [];
   for (const route of ROUTES) {
     outer: for (const ext of byRoute[route]) {
       for (const dir of dirs) {
-        const candidate = path11.win32.join(dir, `${base}${ext}`);
+        const candidate = path13.win32.join(dir, `${base}${ext}`);
         if (exists(candidate)) {
           found.push({ file: candidate, route });
           break outer;
@@ -9959,10 +10275,10 @@ async function planShellLaunch(command, args, deps = {}) {
 }
 
 // src/utils/processTree.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 var HARD_KILL_DELAY_MS = 5e3;
 function defaultExecFile2(file, args, cb) {
-  execFile2(file, args, (err) => cb(err ?? null));
+  execFile3(file, args, (err) => cb(err ?? null));
 }
 function killTree(proc, deps = {}) {
   if (!proc || proc.killed || typeof proc.exitCode === "number") return;
@@ -10008,7 +10324,7 @@ var defaultAppServerClient = async (command, args, options) => {
   const PATH = await augmentedPath();
   const launch = await planDirectLaunch(command, args).catch(() => null);
   if (!launch) return null;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let child;
     try {
       child = spawn(launch.file, launch.args, {
@@ -10017,7 +10333,7 @@ var defaultAppServerClient = async (command, args, options) => {
         windowsVerbatimArguments: launch.verbatim
       });
     } catch {
-      resolve6(null);
+      resolve7(null);
       return;
     }
     let settled = false;
@@ -10026,7 +10342,7 @@ var defaultAppServerClient = async (command, args, options) => {
       settled = true;
       clearTimeout(timer);
       killTree(child);
-      resolve6(value);
+      resolve7(value);
     };
     const timer = setTimeout(() => finish(null), options?.timeout ?? 2e4);
     child.on("error", () => finish(null));
@@ -10093,7 +10409,7 @@ function geminiDiscoveryCacheKey(apiKey) {
   return {
     key: `gemini-models:${hash}`,
     dir,
-    file: path12.join(dir, `gemini_models_${hash}.json`)
+    file: path14.join(dir, `gemini_models_${hash}.json`)
   };
 }
 function readGeminiCache(apiKey) {
@@ -10616,8 +10932,8 @@ var ModelDiscovery = class {
 };
 
 // src/services/ModelCatalog.ts
-import * as fs6 from "fs";
-import * as path13 from "path";
+import * as fs7 from "fs";
+import * as path15 from "path";
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
@@ -10669,17 +10985,17 @@ var ModelCatalog = class {
       const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
       const key = storageKey(url);
       const cacheDir = globalCacheDir();
-      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      if (fs6.existsSync(cacheFile)) fs6.rmSync(cacheFile);
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      if (fs7.existsSync(cacheFile)) fs7.rmSync(cacheFile);
     } catch {
     }
   }
   static readCache(key) {
     try {
       const cacheDir = globalCacheDir();
-      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      if (!fs6.existsSync(cacheFile)) return null;
-      const raw = fs6.readFileSync(cacheFile, "utf8");
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      if (!fs7.existsSync(cacheFile)) return null;
+      const raw = fs7.readFileSync(cacheFile, "utf8");
       const data = JSON.parse(raw);
       if (Date.now() - data.cachedAt > CACHE_TTL_MS) return null;
       return JSON.stringify(data.models);
@@ -10690,9 +11006,9 @@ var ModelCatalog = class {
   static writeCache(key, models) {
     try {
       const cacheDir = globalCacheDir();
-      fs6.mkdirSync(cacheDir, { recursive: true });
-      const cacheFile = path13.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      fs6.writeFileSync(
+      fs7.mkdirSync(cacheDir, { recursive: true });
+      const cacheFile = path15.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      fs7.writeFileSync(
         cacheFile,
         JSON.stringify({ models, cachedAt: Date.now() }, null, 2)
       );
@@ -11068,72 +11384,12 @@ var RunnerInstallation = class {
   }
 };
 
-// src/services/settingsEnvAllowlist.ts
-var ORDEWELL_SETTABLE_ENV = [
-  "AI_PROVIDER",
-  "ORCHESTRATOR_MODEL",
-  "ORDEWELL_SUBAGENT_MODEL",
-  "ORDEWELL_PLANNER_EFFORT",
-  "ORDEWELL_RESEARCH_ENABLED",
-  "ORDEWELL_MAX_PARALLEL",
-  "ORDEWELL_CONFLICT_REPAIR_ATTEMPTS"
-];
-var SETTINGS_ENV_REFUSED = [
-  // Approval posture and pre-approved scope.
-  "ORDEWELL_AUTONOMOUS_MODE",
-  "ORDEWELL_APPROVAL_MODE",
-  "ORDEWELL_APPROVAL_ALLOW",
-  // Where settings are persisted.
-  "ORDEWELL_SETTINGS_PATH",
-  // Runtime options and dynamic loaders.
-  "NODE_OPTIONS",
-  "NODE_REPL_EXTERNAL_MODULE",
-  "NODE_PATH",
-  "ELECTRON_RUN_AS_NODE",
-  "LD_PRELOAD",
-  "LD_LIBRARY_PATH",
-  "LD_AUDIT",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "DYLD_FRAMEWORK_PATH",
-  // Executable resolution.
-  "PATH",
-  "PATHEXT",
-  "NODE"
-];
-var REFUSED = new Set(SETTINGS_ENV_REFUSED);
-function providerEnvKeys() {
-  const keys = [];
-  for (const meta of Object.values(ALL_PROVIDERS)) {
-    if (meta.apiKeyEnvVar) keys.push(meta.apiKeyEnvVar);
-    if (meta.baseUrlEnvVar) keys.push(meta.baseUrlEnvVar);
-    for (const detect of meta.detectEnvVars) keys.push(detect);
-  }
-  return keys;
-}
-var PROVIDER_CREDENTIAL_ENV = new Set(providerEnvKeys());
-var SETTINGS_ENV_ALLOWLIST = new Set(
-  [...providerEnvKeys(), ...ORDEWELL_SETTABLE_ENV].filter((key) => !REFUSED.has(key))
-);
-function admitSettingsEnv(env) {
-  const accepted = {};
-  const rejected = [];
-  for (const [key, value] of Object.entries(env)) {
-    if (REFUSED.has(key) || !SETTINGS_ENV_ALLOWLIST.has(key) || typeof value !== "string") {
-      rejected.push(key);
-      continue;
-    }
-    accepted[key] = value;
-  }
-  return { accepted, rejected };
-}
-
 // src/services/harness/CliAgentAiService.ts
 import { spawn as nodeSpawn } from "child_process";
 
 // src/utils/workspace.ts
-import * as fs7 from "fs";
-import * as path14 from "path";
+import * as fs8 from "fs";
+import * as path16 from "path";
 var WorkspaceNotFoundError = class extends Error {
   constructor(workspace) {
     super(`Workspace "${workspace}" does not exist.`);
@@ -11144,7 +11400,7 @@ var WorkspaceNotFoundError = class extends Error {
 };
 function defaultIsDirectory(candidate) {
   try {
-    return fs7.statSync(candidate).isDirectory();
+    return fs8.statSync(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -11180,8 +11436,8 @@ var PROJECT_MARKER_FILES = [
   "CMakeLists.txt"
 ];
 function assertWorkspaceIsProject(workspace, deps = {}) {
-  const realpath = deps.realpath ?? ((candidate) => fs7.realpathSync(candidate));
-  const exists = deps.exists ?? ((candidate) => fs7.existsSync(candidate));
+  const realpath = deps.realpath ?? ((candidate) => fs8.realpathSync(candidate));
+  const exists = deps.exists ?? ((candidate) => fs8.existsSync(candidate));
   let resolved;
   try {
     resolved = realpath(workspace);
@@ -11189,7 +11445,7 @@ function assertWorkspaceIsProject(workspace, deps = {}) {
     throw new WorkspaceNotAProjectError(workspace);
   }
   const hasMarker = [...PROJECT_MARKER_DIRS, ...PROJECT_MARKER_FILES].some(
-    (marker2) => exists(path14.join(resolved, marker2))
+    (marker2) => exists(path16.join(resolved, marker2))
   );
   if (!hasMarker) throw new WorkspaceNotAProjectError(workspace);
 }
@@ -11257,13 +11513,14 @@ var StdioAgentAdapter = class {
   }
   async start(opts) {
     assertWorkspaceExists(opts.cwd, { isDirectory: this.deps.isDirectory });
-    this.processEnded = new Promise((resolve6) => {
-      this.markEnded = resolve6;
+    this.processEnded = new Promise((resolve7) => {
+      this.markEnded = resolve7;
     });
     const spec = this.spawnSpec(opts);
     const resolvePath = this.deps.resolvePath ?? augmentedPath;
     const PATH = await resolvePath();
-    this.spawnEnv = withPath(process.env, PATH, spec.env);
+    const workspace = await (this.deps.workspaceEnv ?? workspaceEnvOf)(opts.cwd);
+    this.spawnEnv = withPath(process.env, PATH, { ...workspace, ...spec.env });
     const launch = await planDirectLaunch(spec.command, spec.args, {
       platform: this.deps.platform,
       resolvePath
@@ -11309,7 +11566,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
       onEvent({ type: "error", message: this.exitMessage() });
       return;
     }
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       let settled = false;
       const finish = () => {
         if (settled) return;
@@ -11320,7 +11577,7 @@ ${err.message}`).slice(-STDERR_TAIL_CHARS);
         signal?.removeEventListener("abort", onAbort);
         this.process?.removeListener("exit", onExit);
         this.process?.removeListener("error", onExit);
-        resolve6();
+        resolve7();
       };
       const emit = (event) => {
         onEvent(event);
@@ -11535,14 +11792,14 @@ function codexSandboxUnavailableMessage() {
   ].join("\n");
 }
 function runProbe(deps, cwd, env, flags) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let output = "";
     let settled = false;
     const finish = (code) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve6({ code, output });
+      resolve7({ code, output });
     };
     const timer = setTimeout(() => finish(null), PROBE_TIMEOUT_MS);
     timer.unref?.();
@@ -11625,8 +11882,8 @@ var CodexAdapter = class extends StdioAgentAdapter {
   async handshake(opts) {
     this.sandbox = await probeCodexSandbox(this.deps, opts.cwd, this.spawnEnv);
     if (this.sandbox === "unavailable") throw new Error(codexSandboxUnavailableMessage());
-    const ready = new Promise((resolve6) => {
-      this.settleHandshake = resolve6;
+    const ready = new Promise((resolve7) => {
+      this.settleHandshake = resolve7;
     });
     this.writeLine({
       jsonrpc: "2.0",
@@ -11639,8 +11896,8 @@ var CodexAdapter = class extends StdioAgentAdapter {
       // A binary that rejects `app-server` outright dies immediately; waiting
       // out the timeout would turn a one-line diagnostic into a 30s stall.
       this.processEnded.then(() => false),
-      new Promise((resolve6) => {
-        const t = setTimeout(() => resolve6(false), HANDSHAKE_TIMEOUT_MS);
+      new Promise((resolve7) => {
+        const t = setTimeout(() => resolve7(false), HANDSHAKE_TIMEOUT_MS);
         t.unref?.();
       })
     ]);
@@ -11917,12 +12174,12 @@ function describeError(err) {
   return lines.join(": ");
 }
 function delay(ms, signal) {
-  return new Promise((resolve6) => {
-    const timer = setTimeout(resolve6, ms);
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, ms);
     timer.unref?.();
     signal?.addEventListener("abort", () => {
       clearTimeout(timer);
-      resolve6();
+      resolve7();
     }, { once: true });
   });
 }
@@ -11956,17 +12213,17 @@ var OpenCodeAdapter = class {
       throw new ExecutableNotFoundError("opencode", PATH);
     }
     this.process = this.deps.spawn(launch.file, launch.args, {
-      env: withPath(process.env, PATH),
+      env: withPath(process.env, PATH, await (this.deps.workspaceEnv ?? workspaceEnvOf)(opts.cwd)),
       stdio: ["pipe", "pipe", "pipe"],
       cwd: opts.cwd,
       windowsVerbatimArguments: launch.verbatim
     });
-    const banner = new Promise((resolve6) => {
+    const banner = new Promise((resolve7) => {
       let seen = "";
       const scan = (chunk) => {
         seen += chunk.toString();
         const match = seen.match(/https?:\/\/[^\s]+/);
-        if (match) resolve6(match[0].replace(/[.,)]$/, ""));
+        if (match) resolve7(match[0].replace(/[.,)]$/, ""));
       };
       this.process.stdout?.on("data", scan);
       this.process.stderr?.on("data", (chunk) => {
@@ -11975,15 +12232,15 @@ var OpenCodeAdapter = class {
       });
       this.process.on("exit", () => {
         this.exited = true;
-        resolve6(null);
+        resolve7(null);
       });
       this.process.on("error", (err) => {
         this.exited = true;
         this.stderrTail = (this.stderrTail + `
 ${err.message}`).slice(-STDERR_TAIL_CHARS2);
-        resolve6(null);
+        resolve7(null);
       });
-      const timer = setTimeout(() => resolve6(null), SERVER_READY_TIMEOUT_MS);
+      const timer = setTimeout(() => resolve7(null), SERVER_READY_TIMEOUT_MS);
       timer.unref?.();
     });
     this.baseUrl = await banner;
@@ -12016,8 +12273,8 @@ ${this.stderrTail.trim()}` : ""}`);
     const streamAbort = new AbortController();
     let connected = () => {
     };
-    const streamReady = new Promise((resolve6) => {
-      connected = resolve6;
+    const streamReady = new Promise((resolve7) => {
+      connected = resolve7;
     });
     const live = this.streamEvents(
       streamAbort.signal,
@@ -12221,14 +12478,14 @@ ${part.text}` : part.text });
       }
     }
   }
-  async json(method, path23, body, signal) {
-    const response = await this.deps.fetch(`${this.baseUrl}${path23}`, {
+  async json(method, path25, body, signal) {
+    const response = await this.deps.fetch(`${this.baseUrl}${path25}`, {
       method,
       headers: { "content-type": "application/json" },
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       ...signal ? { signal } : {}
     });
-    if (!response.ok) throw new Error(`${method} ${path23} failed: ${response.status} ${response.statusText}`);
+    if (!response.ok) throw new Error(`${method} ${path25} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   nativeSessionId() {
@@ -12682,8 +12939,8 @@ var CliAgentAiService = class {
       this.lastNativeSessionId = previousSessionId;
     }
   }
-  async researchAndPlan(userDescription, runners, modelsByRunner, fs14, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
-    const contextStr = await collectResearchContext(fs14, runners);
+  async researchAndPlan(userDescription, runners, modelsByRunner, fs15, onProgress, _fetcher, runnerModes, modes = DEFAULT_PLANNER_MODES, signal) {
+    const contextStr = await collectResearchContext(fs15, runners);
     const researchLog = [
       { id: `up-${Date.now()}`, type: "user_prompt", content: userDescription, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
     ];
@@ -13582,25 +13839,25 @@ function retargetTaskRunner(task, runner, catalog) {
 }
 
 // src/services/SkillsService.ts
-import * as fs8 from "fs";
-import * as path16 from "path";
+import * as fs9 from "fs";
+import * as path18 from "path";
 
 // src/services/builtinSkills.ts
-import * as path15 from "path";
+import * as path17 from "path";
 import { fileURLToPath } from "url";
 function builtinSkillsDir() {
-  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path15.dirname(fileURLToPath(
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path17.dirname(fileURLToPath(
     // @ts-expect-error - import.meta is only valid under an ESM module setting
     import.meta.url
   ));
-  return path15.join(dir, "..", "skills");
+  return path17.join(dir, "..", "skills");
 }
 
 // src/services/SkillsService.ts
 var BUILTIN_SKILL_NAMES = ["grilling", "to-spec", "improve-codebase-architecture"];
 var RETIRED_BUILTIN_SKILL_NAMES = ["grill-me"];
 function parseSkillFile(filePath, name, source) {
-  const raw = fs8.readFileSync(filePath, "utf8");
+  const raw = fs9.readFileSync(filePath, "utf8");
   const frontmatter = {};
   let content = raw;
   if (raw.startsWith("---\n")) {
@@ -13629,23 +13886,23 @@ function parseSkillFile(filePath, name, source) {
   return { name, description: metadata.description, metadata, content, path: filePath, source };
 }
 function copyDirSync2(src, dest) {
-  fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path16.join(src, entry.name);
-    const destPath = path16.join(dest, entry.name);
+    const srcPath = path18.join(src, entry.name);
+    const destPath = path18.join(dest, entry.name);
     if (entry.isDirectory()) copyDirSync2(srcPath, destPath);
-    else fs8.copyFileSync(srcPath, destPath);
+    else fs9.copyFileSync(srcPath, destPath);
   }
 }
 function readDir(dir, source) {
-  if (!fs8.existsSync(dir)) return [];
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  if (!fs9.existsSync(dir)) return [];
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = path16.join(dir, entry.name, "SKILL.md");
-    if (!fs8.existsSync(skillFile)) continue;
+    const skillFile = path18.join(dir, entry.name, "SKILL.md");
+    if (!fs9.existsSync(skillFile)) continue;
     const parsed = parseSkillFile(skillFile, entry.name, source);
     if (parsed) skills.push(parsed);
   }
@@ -13657,22 +13914,22 @@ var SkillsService = class {
   }
   workspaceRoot;
   localDir() {
-    return this.workspaceRoot ? path16.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
+    return this.workspaceRoot ? path18.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
   }
   globalDir() {
-    return path16.join(globalDataDir(), "skills");
+    return path18.join(globalDataDir(), "skills");
   }
   seed(name) {
-    const dest = path16.join(this.globalDir(), name);
-    if (fs8.existsSync(dest)) return false;
+    const dest = path18.join(this.globalDir(), name);
+    if (fs9.existsSync(dest)) return false;
     let srcDir;
     try {
-      srcDir = path16.join(builtinSkillsDir(), name);
+      srcDir = path18.join(builtinSkillsDir(), name);
     } catch (err) {
       console.warn(`Could not locate built-in skills dir: ${String(err)}`);
       return false;
     }
-    if (!fs8.existsSync(srcDir)) {
+    if (!fs9.existsSync(srcDir)) {
       console.warn(`Built-in skill not found in package: ${name}`);
       return false;
     }
@@ -13686,14 +13943,14 @@ var SkillsService = class {
   isUnmodifiedRetiredSeed(dir, expectedName) {
     let entries;
     try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     if (entries.length !== 1 || entries[0].name !== "SKILL.md" || !entries[0].isFile()) return false;
     let raw;
     try {
-      raw = fs8.readFileSync(path16.join(dir, "SKILL.md"), "utf8");
+      raw = fs9.readFileSync(path18.join(dir, "SKILL.md"), "utf8");
     } catch {
       return false;
     }
@@ -13710,11 +13967,11 @@ var SkillsService = class {
   }
   pruneRetired() {
     for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
-      const dest = path16.join(this.globalDir(), name);
-      if (!fs8.existsSync(dest)) continue;
+      const dest = path18.join(this.globalDir(), name);
+      if (!fs9.existsSync(dest)) continue;
       if (!this.isUnmodifiedRetiredSeed(dest, name)) continue;
       try {
-        fs8.rmSync(dest, { recursive: true, force: true });
+        fs9.rmSync(dest, { recursive: true, force: true });
       } catch (err) {
         console.warn(`Could not prune retired skill ${name}: ${String(err)}`);
       }
@@ -13725,11 +13982,11 @@ var SkillsService = class {
     if (BUILTIN_SKILL_NAMES.includes(name)) this.seed(name);
     const localDir = this.localDir();
     if (localDir) {
-      const localFile = path16.join(localDir, name, "SKILL.md");
-      if (fs8.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
+      const localFile = path18.join(localDir, name, "SKILL.md");
+      if (fs9.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
     }
-    const globalFile = path16.join(this.globalDir(), name, "SKILL.md");
-    if (fs8.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
+    const globalFile = path18.join(this.globalDir(), name, "SKILL.md");
+    if (fs9.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
     return void 0;
   }
   listSkills() {
@@ -13756,8 +14013,8 @@ function createSkillsService(workspaceRoot) {
 }
 
 // src/utils/sessionStore.ts
-import * as fs9 from "fs";
-import * as path17 from "path";
+import * as fs10 from "fs";
+import * as path19 from "path";
 
 // src/utils/sessionId.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -13768,7 +14025,7 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path17.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path19.join(getStateDir(baseDir), SESSIONS_SUBDIR);
 }
 var REJECTION_MESSAGE = "This session was created with an older version of Ordewell. Please re-plan.";
 function hasScalarRunner(parsed) {
@@ -13790,11 +14047,11 @@ function legacySessionFilename(session) {
   return `${filenameStem(session)}_${session.id.slice(0, 8)}.json`;
 }
 function dropLegacyFile(sessionsDir, meta) {
-  const legacy = path17.join(sessionsDir, legacySessionFilename(meta));
-  if (legacy === path17.join(sessionsDir, sessionFilename(meta)) || !fs9.existsSync(legacy)) return;
+  const legacy = path19.join(sessionsDir, legacySessionFilename(meta));
+  if (legacy === path19.join(sessionsDir, sessionFilename(meta)) || !fs10.existsSync(legacy)) return;
   try {
-    const held = JSON.parse(fs9.readFileSync(legacy, "utf-8")).meta?.id;
-    if (held === meta.id) fs9.unlinkSync(legacy);
+    const held = JSON.parse(fs10.readFileSync(legacy, "utf-8")).meta?.id;
+    if (held === meta.id) fs10.unlinkSync(legacy);
   } catch {
   }
 }
@@ -13817,18 +14074,18 @@ function saveSession(plan, goal, baseDir, id) {
     plan: JSON.parse(JSON.stringify(plan))
   };
   const filename = sessionFilename(meta);
-  const filePath = path17.join(sessionsDir, filename);
-  fs9.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  const filePath = path19.join(sessionsDir, filename);
+  fs10.writeFileSync(filePath, JSON.stringify(session, null, 2));
   dropLegacyFile(sessionsDir, meta);
   return meta;
 }
 function listSessions(baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return [];
-  const files = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs10.existsSync(sessionsDir)) return [];
+  const files = fs10.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   return files.map((f) => {
     try {
-      const raw = fs9.readFileSync(path17.join(sessionsDir, f), "utf-8");
+      const raw = fs10.readFileSync(path19.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -13843,10 +14100,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 = fs9.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const files = fs10.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   for (const f of files) {
     try {
-      const raw = fs9.readFileSync(path17.join(sessionsDir, f), "utf-8");
+      const raw = fs10.readFileSync(path19.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -13857,11 +14114,11 @@ function findSessionFile(sessionsDir, sessionId, logger) {
 }
 function loadSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return null;
+  if (!fs10.existsSync(sessionsDir)) return null;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      const raw = fs9.readFileSync(path17.join(sessionsDir, file), "utf-8");
+      const raw = fs10.readFileSync(path19.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -13892,11 +14149,11 @@ function getLatestSession(baseDir, logger = defaultLogger) {
 }
 function deleteSession(sessionId, baseDir, logger = defaultLogger) {
   const sessionsDir = getSessionsDir(baseDir);
-  if (!fs9.existsSync(sessionsDir)) return false;
+  if (!fs10.existsSync(sessionsDir)) return false;
   try {
     const file = findSessionFile(sessionsDir, sessionId, logger);
     if (file) {
-      fs9.unlinkSync(path17.join(sessionsDir, file));
+      fs10.unlinkSync(path19.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -14577,6 +14834,10 @@ var Session = class {
     }
     await this.orchestrator.runTask(taskId);
   }
+  /** Start whatever the scheduler can now fit — after the parallel limit was raised mid-run, say. */
+  async reschedule() {
+    await this.orchestrator.tick();
+  }
   async retryTask(taskId) {
     await this.orchestrator.retryTask(taskId);
     this.persist();
@@ -15457,7 +15718,7 @@ var HeadlessRunner = class extends AbstractRunner {
     return {
       launch: await planDirectLaunch(command, args, this.launchDeps),
       resolvedPath,
-      env: invocation.env,
+      env: { ...opts.env, ...invocation.env },
       pty,
       submitPromptKey: invocation.submitPromptKey
     };
@@ -15476,11 +15737,11 @@ var HeadlessRunner = class extends AbstractRunner {
 };
 
 // src/services/TmuxRunner.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { tmpdir } from "os";
-import { join as join16 } from "path";
-import { existsSync as existsSync11, readFileSync as readFileSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
 
 // src/utils/tmux.ts
 import { execSync as execSync2 } from "child_process";
@@ -15531,7 +15792,7 @@ function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platfor
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
-var execFileAsync2 = promisify5(execFile3);
+var execFileAsync2 = promisify5(execFile4);
 var defaultExecFile3 = async (command, args) => {
   const { stdout, stderr } = await execFileAsync2(command, args);
   return { stdout: String(stdout), stderr: String(stderr) };
@@ -15587,7 +15848,7 @@ var TmuxSession = class extends AbstractTerminalSession {
     if (this.exited) return;
     let content;
     try {
-      content = existsSync11(this.logPath) ? readFileSync7(this.logPath, "utf8") : "";
+      content = existsSync11(this.logPath) ? readFileSync8(this.logPath, "utf8") : "";
     } catch {
       return;
     }
@@ -15766,10 +16027,10 @@ var TmuxRunner = class extends AbstractRunner {
       windowName,
       this.execFileImpl,
       this.pollIntervalMs,
-      join16(this.logDir, `${id}.log`),
+      join17(this.logDir, `${id}.log`),
       this.socket
     );
-    invocation.env = { ...invocation.env, PATH: await this.resolvePath() };
+    invocation.env = { ...opts.env, ...invocation.env, PATH: await this.resolvePath() };
     await session.start(invocation.command, invocation.args, opts.cwd, invocation.env);
     if (invocation.submitPromptKey) session.write("\r");
     this.registerSession(id, session);
@@ -15779,8 +16040,8 @@ var TmuxRunner = class extends AbstractRunner {
 
 // src/utils/daemonToken.ts
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
-import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeSync } from "fs";
-import { join as join17 } from "path";
+import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync9, unlinkSync as unlinkSync3, writeSync } from "fs";
+import { join as join18 } from "path";
 var BEARER_PREFIX = "bearer ";
 var DAEMON_TOKEN_SUBPROTOCOL_PREFIX = "ordewell.token.";
 var DAEMON_SUBPROTOCOL = "ordewell.v1";
@@ -15788,7 +16049,7 @@ function configDir() {
   return globalDataDir();
 }
 function daemonTokenPath(port) {
-  return join17(configDir(), `server-${port}.token`);
+  return join18(configDir(), `server-${port}.token`);
 }
 function mintDaemonToken(port) {
   const token = randomBytes3(32).toString("base64url");
@@ -15808,7 +16069,7 @@ function mintDaemonToken(port) {
 }
 function readDaemonToken(port) {
   try {
-    const token = readFileSync8(daemonTokenPath(port), "utf8").trim();
+    const token = readFileSync9(daemonTokenPath(port), "utf8").trim();
     return token === "" ? void 0 : token;
   } catch {
     return void 0;
@@ -15849,18 +16110,18 @@ function tokensMatch(presented, expected) {
 }
 
 // src/plugins/RunnerRegistry.ts
-import * as fs11 from "fs";
-import * as path20 from "path";
-import * as os5 from "os";
+import * as fs12 from "fs";
+import * as path22 from "path";
+import * as os6 from "os";
 import { execFileSync } from "child_process";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/plugins/FsPluginStore.ts
-import * as fs10 from "fs";
-import * as path19 from "path";
+import * as fs11 from "fs";
+import * as path21 from "path";
 
 // src/plugins/pluginNames.ts
-import * as path18 from "path";
+import * as path20 from "path";
 var PLUGIN_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
 var MAX_PLUGIN_NAME_LENGTH = 64;
 function isPlainPluginName(name) {
@@ -15875,10 +16136,10 @@ function assertPlainPluginName(name) {
 }
 function resolvePluginInstallDir(pluginsDir, name) {
   assertPlainPluginName(name);
-  const root = path18.resolve(pluginsDir);
-  const dest = path18.resolve(root, name);
-  const relative5 = path18.relative(root, dest);
-  if (relative5 !== name || relative5 === "" || path18.isAbsolute(relative5)) {
+  const root = path20.resolve(pluginsDir);
+  const dest = path20.resolve(root, name);
+  const relative5 = path20.relative(root, dest);
+  if (relative5 !== name || relative5 === "" || path20.isAbsolute(relative5)) {
     throw new Error(`Plugin install path escapes the plugins directory: ${JSON.stringify(name)}`);
   }
   return dest;
@@ -15893,13 +16154,13 @@ function isValidManifest(obj) {
 
 // src/plugins/FsPluginStore.ts
 function userPluginsDir() {
-  return path19.join(globalDataDir(), "plugins");
+  return path21.join(globalDataDir(), "plugins");
 }
 function loadManifestFromDir(dir) {
-  const manifestPath = path19.join(dir, "manifest.json");
-  if (!fs10.existsSync(manifestPath)) return null;
+  const manifestPath = path21.join(dir, "manifest.json");
+  if (!fs11.existsSync(manifestPath)) return null;
   try {
-    const raw = fs10.readFileSync(manifestPath, "utf8");
+    const raw = fs11.readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isValidManifest(parsed)) return null;
     return parsed;
@@ -15909,29 +16170,29 @@ function loadManifestFromDir(dir) {
 }
 function copyDirSync3(src, dest) {
   ensureDir(dest);
-  const entries = fs10.readdirSync(src, { withFileTypes: true });
+  const entries = fs11.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path19.join(src, entry.name);
-    const destPath = path19.join(dest, entry.name);
+    const srcPath = path21.join(src, entry.name);
+    const destPath = path21.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync3(srcPath, destPath);
     } else {
-      fs10.copyFileSync(srcPath, destPath);
+      fs11.copyFileSync(srcPath, destPath);
     }
   }
 }
 function rmDirSync(dir) {
-  if (!fs10.existsSync(dir)) return;
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  if (!fs11.existsSync(dir)) return;
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const p = path19.join(dir, entry.name);
+    const p = path21.join(dir, entry.name);
     if (entry.isDirectory()) {
       rmDirSync(p);
     } else {
-      fs10.unlinkSync(p);
+      fs11.unlinkSync(p);
     }
   }
-  fs10.rmdirSync(dir);
+  fs11.rmdirSync(dir);
 }
 var FsPluginStore = class {
   getUserPluginsDir() {
@@ -15939,10 +16200,10 @@ var FsPluginStore = class {
   }
   listUserPluginDirs() {
     const dir = userPluginsDir();
-    if (!fs10.existsSync(dir)) return [];
+    if (!fs11.existsSync(dir)) return [];
     let entries;
     try {
-      entries = fs10.readdirSync(dir, { withFileTypes: true });
+      entries = fs11.readdirSync(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -15950,7 +16211,7 @@ var FsPluginStore = class {
   }
   listDir(dir) {
     try {
-      return fs10.readdirSync(dir);
+      return fs11.readdirSync(dir);
     } catch {
       return [];
     }
@@ -15968,20 +16229,20 @@ var FsPluginStore = class {
     ensureDir(dir);
   }
   writeFile(filePath, content) {
-    fs10.writeFileSync(filePath, content);
+    fs11.writeFileSync(filePath, content);
   }
   readFile(filePath) {
     try {
-      return fs10.readFileSync(filePath, "utf8");
+      return fs11.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
   }
-  dirExists(path23) {
-    return fs10.existsSync(path23) && fs10.statSync(path23).isDirectory();
+  dirExists(path25) {
+    return fs11.existsSync(path25) && fs11.statSync(path25).isDirectory();
   }
-  exists(path23) {
-    return fs10.existsSync(path23);
+  exists(path25) {
+    return fs11.existsSync(path25);
   }
 };
 
@@ -16008,7 +16269,15 @@ var CLAUDE_CODE_MANIFEST = {
       "{{/if}}",
       "{{prompt}}"
     ],
-    promptInArgs: true
+    promptInArgs: true,
+    // Interactive sessions show these even with --dangerously-skip-permissions:
+    // a folder Claude Code has never been trusted in (a fresh clone, or a repo
+    // only ever planned in headlessly), and the first Bypass Permissions run.
+    blockingPrompts: [
+      { phrase: "Is this a project you created or one you trust", asks: "whether to trust the task's folder" },
+      { phrase: "Do you trust the files in this folder", asks: "whether to trust the task's folder" },
+      { phrase: "running in Bypass Permissions mode", asks: "you to accept Bypass Permissions mode" }
+    ]
   },
   features: {
     modelSelection: true,
@@ -16413,7 +16682,7 @@ var RunnerRegistry = class {
     return entry?.source === "builtin";
   }
   installFromPath(sourcePath) {
-    const absPath = path20.resolve(sourcePath);
+    const absPath = path22.resolve(sourcePath);
     if (!this.store.dirExists(absPath)) {
       throw new Error(`Plugin source must be a directory: ${absPath}`);
     }
@@ -16425,7 +16694,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path20.join(os5.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
+    const tmpDir = path22.join(os6.tmpdir(), `ordewell-plugin-${randomBytes4(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -16438,7 +16707,7 @@ var RunnerRegistry = class {
       const hasManifest = contents.some((f) => f === "manifest.json");
       let sourceDir = tmpDir;
       if (!hasManifest) {
-        const onlyEntry = contents.length === 1 ? path20.join(tmpDir, contents[0]) : void 0;
+        const onlyEntry = contents.length === 1 ? path22.join(tmpDir, contents[0]) : void 0;
         if (!onlyEntry || !this.store.dirExists(onlyEntry)) {
           throw new Error(`No manifest.json found in repository: ${validated.toString()}`);
         }
@@ -16486,7 +16755,7 @@ var RunnerRegistry = class {
   }
   createSkeleton(name, outputDir) {
     assertPlainPluginName(name);
-    const dir = path20.resolve(outputDir, name);
+    const dir = path22.resolve(outputDir, name);
     this.store.ensureDir(dir);
     const manifest = {
       name,
@@ -16518,8 +16787,8 @@ var RunnerRegistry = class {
         ]
       }
     };
-    this.store.writeFile(path20.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-    const runSh = path20.join(dir, "run.sh");
+    this.store.writeFile(path22.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const runSh = path22.join(dir, "run.sh");
     const scriptContent = `#!/usr/bin/env bash
 # Custom runner script for ${name}
 # Receives:
@@ -16545,30 +16814,30 @@ echo "Running ${name} with prompt: $prompt"
 };
 function fsChmodSync(fpath, mode) {
   try {
-    fs11.chmodSync(fpath, mode);
+    fs12.chmodSync(fpath, mode);
   } catch {
   }
 }
 
 // src/utils/stateStore.ts
-import * as fs12 from "fs";
-import * as path21 from "path";
+import * as fs13 from "fs";
+import * as path23 from "path";
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
-  return path21.join(getStateDir(baseDir), STATE_FILE);
+  return path23.join(getStateDir(baseDir), STATE_FILE);
 }
 function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path21.dirname(statePath));
+  ensureDir(path23.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs12.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  fs13.writeFileSync(statePath, JSON.stringify(plan, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (!fs12.existsSync(statePath)) return null;
+  if (!fs13.existsSync(statePath)) return null;
   try {
-    const raw = fs12.readFileSync(statePath, "utf-8");
+    const raw = fs13.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.`);
@@ -16585,16 +16854,16 @@ function loadState(baseDir, logger = defaultLogger) {
 function clearState(baseDir) {
   const dir = baseDir ?? process.cwd();
   const statePath = getStatePath(dir);
-  if (fs12.existsSync(statePath)) fs12.unlinkSync(statePath);
+  if (fs13.existsSync(statePath)) fs13.unlinkSync(statePath);
 }
 function stateExists(baseDir) {
   const dir = baseDir ?? process.cwd();
-  return fs12.existsSync(getStatePath(dir));
+  return fs13.existsSync(getStatePath(dir));
 }
 
 // src/services/SettingsService.ts
-import * as fs13 from "fs";
-import * as path22 from "path";
+import * as fs14 from "fs";
+import * as path24 from "path";
 var DEFAULTS = {
   tdd: { enabled: true },
   verification: { enabled: false }
@@ -16602,7 +16871,7 @@ var DEFAULTS = {
 function getSettingsPath() {
   const override = process.env.ORDEWELL_SETTINGS_PATH;
   if (override && override.trim()) return override.trim();
-  return path22.join(globalDataDir(), "settings.json");
+  return path24.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -16635,7 +16904,7 @@ var SettingsService = class {
   }
   fileMtimeMs() {
     try {
-      return fs13.statSync(this.filePath).mtimeMs;
+      return fs14.statSync(this.filePath).mtimeMs;
     } catch {
       return null;
     }
@@ -16707,8 +16976,8 @@ var SettingsService = class {
   load() {
     migrateOldConfigDir();
     try {
-      if (fs13.existsSync(this.filePath)) {
-        const raw = JSON.parse(fs13.readFileSync(this.filePath, "utf-8"));
+      if (fs14.existsSync(this.filePath)) {
+        const raw = JSON.parse(fs14.readFileSync(this.filePath, "utf-8"));
         const settings = {
           tdd: { enabled: raw.tdd?.enabled ?? DEFAULTS.tdd.enabled },
           verification: { enabled: raw.verification?.enabled ?? DEFAULTS.verification.enabled }
@@ -16730,11 +16999,11 @@ var SettingsService = class {
     return { ...DEFAULTS, tdd: { ...DEFAULTS.tdd }, verification: { ...DEFAULTS.verification } };
   }
   persist() {
-    const dir = path22.dirname(this.filePath);
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    const dir = path24.dirname(this.filePath);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
-    fs13.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
+    fs14.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2));
     this.cachedMtimeMs = this.fileMtimeMs();
   }
 };
@@ -16800,6 +17069,7 @@ export {
   ConversationEditError,
   DAEMON_SUBPROTOCOL,
   DAEMON_TOKEN_SUBPROTOCOL_PREFIX,
+  DEFAULT_MAX_PARALLEL,
   DENY_ALL,
   EmbeddedNewlineError,
   EnvConfig,
@@ -16982,6 +17252,7 @@ export {
   modifyValidationFeedback,
   normalizeAgentArgs,
   normalizeGeminiModel,
+  parseMaxParallel,
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,