@ordewell/core 0.5.1 → 0.5.2

package/dist/index.js

@@ -56,6 +56,7 @@ __export(index_exports, {
   ConversationEditError: () => ConversationEditError,
   DAEMON_SUBPROTOCOL: () => DAEMON_SUBPROTOCOL,
   DAEMON_TOKEN_SUBPROTOCOL_PREFIX: () => DAEMON_TOKEN_SUBPROTOCOL_PREFIX,
+  DEFAULT_MAX_PARALLEL: () => DEFAULT_MAX_PARALLEL,
   DENY_ALL: () => DENY_ALL,
   EmbeddedNewlineError: () => EmbeddedNewlineError,
   EnvConfig: () => EnvConfig,
@@ -238,6 +239,7 @@ __export(index_exports, {
   modifyValidationFeedback: () => modifyValidationFeedback,
   normalizeAgentArgs: () => normalizeAgentArgs,
   normalizeGeminiModel: () => normalizeGeminiModel,
+  parseMaxParallel: () => parseMaxParallel,
   parsePartialPlan: () => parsePartialPlan,
   parsePlanJson: () => parsePlanJson,
   parseTaskOpsJson: () => parseTaskOpsJson,
@@ -3191,33 +3193,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 ?? "");
@@ -3325,14 +3327,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?.();
@@ -3430,9 +3432,9 @@ function applyHeadLimit(stdout, headLimit) {
 }
 function formatSearchOutput(capped, root, opts) {
   if (capped.rows.length === 0) return opts.emptyMessage;
-  const sep = opts.sep ?? import_node_path.default.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 ?? import_node_path.default.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}
@@ -4023,6 +4025,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\//, "");
@@ -4227,7 +4238,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";
@@ -4468,28 +4479,28 @@ function posixBinDirs() {
   ];
 }
 function windowsBinDirs(env, home) {
-  const join23 = (...parts) => path5.win32.join(...parts);
-  const under = (base, ...parts) => base ? [join23(base, ...parts)] : [];
+  const join24 = (...parts) => path5.win32.join(...parts);
+  const under = (base, ...parts) => base ? [join24(base, ...parts)] : [];
   const appData = env.APPDATA;
   const localAppData = env.LOCALAPPDATA;
   const programData = env.ProgramData;
   return [
     // Native per-user installers, PowerShell-driven and otherwise.
-    join23(home, ".local", "bin"),
-    join23(home, ".opencode", "bin"),
-    join23(home, ".claude", "bin"),
-    join23(home, ".codex", "bin"),
+    join24(home, ".local", "bin"),
+    join24(home, ".opencode", "bin"),
+    join24(home, ".claude", "bin"),
+    join24(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"),
-    join23(home, "AppData", "Roaming", "npm"),
+    join24(home, "AppData", "Roaming", "npm"),
     ...under(localAppData, "pnpm"),
     ...under(localAppData, "Yarn", "bin"),
-    join23(home, ".bun", "bin"),
+    join24(home, ".bun", "bin"),
     // Windows package managers.
-    join23(home, "scoop", "shims"),
+    join24(home, "scoop", "shims"),
     ...under(env.SCOOP, "shims"),
     ...under(env.SCOOP_GLOBAL ?? programData, "scoop", "shims"),
     ...under(programData, "chocolatey", "bin"),
@@ -4499,7 +4510,7 @@ function windowsBinDirs(env, home) {
     ...under(localAppData, "Microsoft", "WindowsApps"),
     // Version managers. Volta's Windows home is not the POSIX `~/.volta`.
     ...under(localAppData, "Volta", "bin"),
-    join23(home, ".volta", "bin")
+    join24(home, ".volta", "bin")
   ];
 }
 function wellKnownBinDirs(deps = {}) {
@@ -6694,12 +6705,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
@@ -6708,7 +6719,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
@@ -8067,8 +8078,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) {
@@ -8095,8 +8106,8 @@ ${firstContext.dirStructure}
   return contextStr;
 }
 var ContextCollector = class {
-  constructor(fs14, registry) {
-    this.fs = fs14;
+  constructor(fs15, registry) {
+    this.fs = fs15;
     this.registry = registry;
   }
   fs;
@@ -8177,10 +8188,10 @@ function summarizeToolCall(tool, argsJson, toolLabel) {
       const scope = args.include ? ` in ${args.include}` : "";
       return `grep ${ellipsize(String(args.pattern), 40)}${scope}${mode}`;
     }
-    const path24 = args.filePath || args.file_path || args.path;
-    if (path24) {
-      const basename = String(path24).split("/").pop() || String(path24);
-      return `${display} ${basename}`;
+    const path26 = args.filePath || args.file_path || args.path;
+    if (path26) {
+      const basename2 = String(path26).split("/").pop() || String(path26);
+      return `${display} ${basename2}`;
     }
     if (args.pattern) {
       return `${display} ${args.pattern}`;
@@ -8213,22 +8224,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 });
@@ -8239,13 +8250,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++) {
@@ -8262,7 +8273,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 = {
@@ -8378,7 +8389,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 };
@@ -8389,20 +8400,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 = "";
@@ -8421,18 +8432,18 @@ var BaseAiService = class _BaseAiService {
         const subagentId = (0, import_uuid3.v4)();
         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) + `
@@ -8618,7 +8629,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({
@@ -8645,7 +8656,7 @@ ${llmOutput}
       if (!turn.hasToolCalls) break;
       const { toolResults, logEntries, resultsText } = await this.executeToolCalls(
         turn.toolCalls,
-        fs14,
+        fs15,
         onProgress,
         fetcher,
         step,
@@ -8878,11 +8889,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()}
 
@@ -8893,17 +8904,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}
@@ -8919,12 +8930,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);
@@ -9160,11 +9171,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()}
@@ -9182,17 +9193,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}
@@ -9208,12 +9219,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);
@@ -9232,6 +9243,9 @@ ${collected.aiflowContext}
   }
 };
 
+// src/services/TaskOrchestrator.ts
+var path12 = __toESM(require("path"));
+
 // src/services/promptAugment.ts
 var MAX_TAIL_CHARS = 500;
 var DEFAULT_PLAN_MAP_MAX_ENTRIES = 30;
@@ -9818,17 +9832,229 @@ ${line}
 
 // src/services/transcriptCapture.ts
 var import_fs = require("fs");
+var os4 = __toESM(require("os"));
+var path11 = __toESM(require("path"));
+
+// src/services/workspaceEnv.ts
+var import_child_process3 = require("child_process");
+var fs5 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
 var path10 = __toESM(require("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) => {
+      (0, import_child_process3.execFile)(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, path10.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 = path10.resolve(cwd).split(path10.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(path10.sep) || path10.sep;
+  const mapped = path10.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 = path10.resolve(start);
+  for (; ; ) {
+    const candidate = path10.join(dir, relative5);
+    if (deps.readFile(candidate) !== null) return candidate;
+    const parent = path10.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", path10.basename(file)], { cwd: path10.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("~/") ? path10.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,
+      path11.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 {
@@ -9837,20 +10063,20 @@ var HomeTranscriptReader = class {
   }
 };
 var CLAUDE_PROJECT_NAME_MAX = 200;
-function claudeProjectDirs(home, cwd) {
-  const projects = path10.join(home, ".claude", "projects");
+function claudeProjectDirs(configDir2, cwd) {
+  const projects = path11.join(configDir2, "projects");
   const munged = cwd.replace(/[^a-zA-Z0-9]/g, "-");
   if (munged.length <= CLAUDE_PROJECT_NAME_MAX) {
-    const dir = path10.join(projects, munged);
+    const dir = path11.join(projects, munged);
     return (0, import_fs.existsSync)(dir) ? [dir] : [];
   }
   if (!(0, import_fs.existsSync)(projects)) return [];
   const prefix = `${munged.slice(0, CLAUDE_PROJECT_NAME_MAX)}-`;
-  return (0, import_fs.readdirSync)(projects).filter((name) => name.startsWith(prefix)).map((name) => path10.join(projects, name));
+  return (0, import_fs.readdirSync)(projects).filter((name) => name.startsWith(prefix)).map((name) => path11.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) => (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path10.join(dir, f))).filter((f) => cutoff ? (0, import_fs.statSync)(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => (0, import_fs.statSync)(b).mtimeMs - (0, import_fs.statSync)(a).mtimeMs);
+  const candidates = configDirs.flatMap((dir) => claudeProjectDirs(dir, query.cwd)).flatMap((dir) => (0, import_fs.readdirSync)(dir).filter((f) => f.endsWith(".jsonl")).map((f) => path11.join(dir, f))).filter((f) => cutoff ? (0, import_fs.statSync)(f).mtimeMs >= cutoff - 5e3 : true).sort((a, b) => (0, import_fs.statSync)(b).mtimeMs - (0, import_fs.statSync)(a).mtimeMs);
   for (const file of candidates) {
     const raw = (0, import_fs.readFileSync)(file, "utf8");
     if (!raw.includes(query.marker)) continue;
@@ -9886,7 +10112,7 @@ async function opencodeFinal(home, query, maxChars) {
   } catch {
     return null;
   }
-  const dbPath = path10.join(home, ".local", "share", "opencode", "opencode.db");
+  const dbPath = path11.join(home, ".local", "share", "opencode", "opencode.db");
   if (!(0, import_fs.existsSync)(dbPath)) return null;
   let db;
   try {
@@ -9939,7 +10165,7 @@ async function opencodeFinal(home, query, maxChars) {
   }
 }
 function codexFinal(home, query, maxChars) {
-  const root = path10.join(home, ".codex", "sessions");
+  const root = path11.join(home, ".codex", "sessions");
   if (!(0, import_fs.existsSync)(root)) return null;
   const cutoff = query.startedAt ? Date.parse(query.startedAt) : 0;
   const files = [];
@@ -9953,7 +10179,7 @@ function codexFinal(home, query, maxChars) {
       continue;
     }
     for (const e of entries) {
-      const full = path10.join(dir, e);
+      const full = path11.join(dir, e);
       let st;
       try {
         st = (0, import_fs.statSync)(full);
@@ -10404,6 +10630,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) {
@@ -10467,6 +10730,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
@@ -10510,6 +10792,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 ${path12.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;
   }
@@ -10654,6 +10962,7 @@ var TaskOrchestrator = class {
     return result;
   }
   async clearMergedRun(run) {
+    this.closeLingeringOf(run);
     try {
       await this.isolation.discard(run, { integration: "delete-merged" });
     } catch (err) {
@@ -10664,14 +10973,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 = {};
@@ -10759,11 +11086,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();
@@ -10800,8 +11134,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 });
     }
@@ -10941,8 +11274,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.`);
     }
   }
@@ -10993,6 +11325,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) {
@@ -11141,7 +11474,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
@@ -11267,6 +11601,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,
@@ -11278,13 +11614,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);
@@ -11517,6 +11855,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);
@@ -11659,29 +11998,29 @@ ${errors.map((e) => `- ${e}`).join("\n")}`
 };
 
 // src/services/ModelDiscovery.ts
-var path13 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
+var path15 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
 var import_util3 = require("util");
 var fsSync3 = __toESM(require("fs"));
 var osMod = __toESM(require("os"));
 
 // src/utils/globalDataDir.ts
-var fs5 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
+var fs6 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
 function globalDataDir() {
-  return path11.join(os4.homedir(), ".ordewell");
+  return path13.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 = path11.join(src, entry.name);
-    const destPath = path11.join(dest, entry.name);
+    const srcPath = path13.join(src, entry.name);
+    const destPath = path13.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -11689,50 +12028,29 @@ var migrated = false;
 function migrateOldConfigDir() {
   if (migrated) return;
   migrated = true;
-  const oldDir = path11.join(os4.homedir(), ".config", "ordewell");
-  if (!fs5.existsSync(oldDir)) return;
+  const oldDir = path13.join(os5.homedir(), ".config", "ordewell");
+  if (!fs6.existsSync(oldDir)) return;
   const newDir = globalDataDir();
   const liftFile = (name) => {
-    const oldFile = path11.join(oldDir, name);
-    const newFile = path11.join(newDir, name);
-    if (fs5.existsSync(oldFile) && !fs5.existsSync(newFile)) {
-      fs5.mkdirSync(newDir, { recursive: true });
-      fs5.copyFileSync(oldFile, newFile);
+    const oldFile = path13.join(oldDir, name);
+    const newFile = path13.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 = path11.join(oldDir, "plugins");
-  const newPlugins = path11.join(newDir, "plugins");
-  if (fs5.existsSync(oldPlugins) && !fs5.existsSync(newPlugins)) {
+  const oldPlugins = path13.join(oldDir, "plugins");
+  const newPlugins = path13.join(newDir, "plugins");
+  if (fs6.existsSync(oldPlugins) && !fs6.existsSync(newPlugins)) {
     copyDirSync(oldPlugins, newPlugins);
   }
 }
 
 // src/utils/launch.ts
 var fsSync2 = __toESM(require("fs"));
-var path12 = __toESM(require("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
+var path14 = __toESM(require("path"));
 var DIRECT_EXTENSIONS = [".exe", ".com"];
 var BATCH_EXTENSIONS = [".cmd", ".bat"];
 var POWERSHELL_EXTENSIONS = [".ps1"];
@@ -11740,7 +12058,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 ? path12.win32.join(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe") : "powershell.exe";
+  return root ? path14.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 {
@@ -11792,7 +12110,7 @@ Searched: ${searchedPath || "(empty PATH)"}`);
 };
 function isResolvableOnPosixPath(command, PATH, exists) {
   if (command.includes("/")) return exists(command);
-  return PATH.split(path12.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path12.join(dir, command)));
+  return PATH.split(path14.delimiter).map((d) => d.trim()).filter(Boolean).some((dir) => exists(path14.join(dir, command)));
 }
 function isExecutableResolved(command, plan, PATH, deps = {}) {
   if ((deps.platform ?? process.platform) === "win32") return plan.file !== command;
@@ -11832,9 +12150,9 @@ function cmdArgs(line) {
   return ["/d", "/s", "/c", `"${line}"`];
 }
 function candidateExtensions(command, pathExt) {
-  const declared = pathExt.split(path12.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
+  const declared = pathExt.split(path14.win32.delimiter).map((e) => e.trim().toLowerCase()).filter(Boolean);
   const known = /* @__PURE__ */ new Set([...DIRECT_EXTENSIONS, ...BATCH_EXTENSIONS, ...POWERSHELL_EXTENSIONS, ...declared]);
-  const ext = path12.win32.extname(command).toLowerCase();
+  const ext = path14.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]: [""] };
@@ -11855,13 +12173,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 = path12.win32.basename(command) !== command ? [path12.win32.dirname(path12.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path12.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
-  const base = path12.win32.basename(command);
+  const dirs = path14.win32.basename(command) !== command ? [path14.win32.dirname(path14.win32.resolve(command))] : (await (deps.resolvePath ?? augmentedPath)() || "").split(path14.win32.delimiter).map((d) => d.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  const base = path14.win32.basename(command);
   const found = [];
   for (const route of ROUTES) {
     outer: for (const ext of byRoute[route]) {
       for (const dir of dirs) {
-        const candidate = path12.win32.join(dir, `${base}${ext}`);
+        const candidate = path14.win32.join(dir, `${base}${ext}`);
         if (exists(candidate)) {
           found.push({ file: candidate, route });
           break outer;
@@ -11907,10 +12225,10 @@ async function planShellLaunch(command, args, deps = {}) {
 }
 
 // src/utils/processTree.ts
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var HARD_KILL_DELAY_MS = 5e3;
 function defaultExecFile2(file, args, cb) {
-  (0, import_child_process3.execFile)(file, args, (err) => cb(err ?? null));
+  (0, import_child_process4.execFile)(file, args, (err) => cb(err ?? null));
 }
 function killTree(proc, deps = {}) {
   if (!proc || proc.killed || typeof proc.exitCode === "number") return;
@@ -11946,7 +12264,7 @@ function killTree(proc, deps = {}) {
 }
 
 // src/services/ModelDiscovery.ts
-var execAsync3 = (0, import_util3.promisify)(import_child_process4.exec);
+var execAsync3 = (0, import_util3.promisify)(import_child_process5.exec);
 var defaultExec2 = async (command, options) => {
   const PATH = await augmentedPath();
   const { stdout } = await execAsync3(command, { ...options, maxBuffer: 32 * 1024 * 1024, env: withPath(process.env, PATH) });
@@ -11956,16 +12274,16 @@ 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 = (0, import_child_process4.spawn)(launch.file, launch.args, {
+      child = (0, import_child_process5.spawn)(launch.file, launch.args, {
         env: withPath(process.env, PATH),
         stdio: ["pipe", "pipe", "ignore"],
         windowsVerbatimArguments: launch.verbatim
       });
     } catch {
-      resolve6(null);
+      resolve7(null);
       return;
     }
     let settled = false;
@@ -11974,7 +12292,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));
@@ -12041,7 +12359,7 @@ function geminiDiscoveryCacheKey(apiKey) {
   return {
     key: `gemini-models:${hash}`,
     dir,
-    file: path13.join(dir, `gemini_models_${hash}.json`)
+    file: path15.join(dir, `gemini_models_${hash}.json`)
   };
 }
 function readGeminiCache(apiKey) {
@@ -12564,8 +12882,8 @@ var ModelDiscovery = class {
 };
 
 // src/services/ModelCatalog.ts
-var fs6 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var CACHE_KEY = "model-catalog";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function storageKey(baseUrl) {
@@ -12617,17 +12935,17 @@ var ModelCatalog = class {
       const url = (baseUrl || "https://openrouter.ai/api/v1").replace(/\/+$/, "");
       const key = storageKey(url);
       const cacheDir = globalCacheDir();
-      const cacheFile = path14.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      if (fs6.existsSync(cacheFile)) fs6.rmSync(cacheFile);
+      const cacheFile = path16.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      if (fs7.existsSync(cacheFile)) fs7.rmSync(cacheFile);
     } catch {
     }
   }
   static readCache(key) {
     try {
       const cacheDir = globalCacheDir();
-      const cacheFile = path14.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      if (!fs6.existsSync(cacheFile)) return null;
-      const raw = fs6.readFileSync(cacheFile, "utf8");
+      const cacheFile = path16.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);
@@ -12638,9 +12956,9 @@ var ModelCatalog = class {
   static writeCache(key, models) {
     try {
       const cacheDir = globalCacheDir();
-      fs6.mkdirSync(cacheDir, { recursive: true });
-      const cacheFile = path14.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
-      fs6.writeFileSync(
+      fs7.mkdirSync(cacheDir, { recursive: true });
+      const cacheFile = path16.join(cacheDir, `${key.replace(/[:/]/g, "_")}.json`);
+      fs7.writeFileSync(
         cacheFile,
         JSON.stringify({ models, cachedAt: Date.now() }, null, 2)
       );
@@ -12907,9 +13225,9 @@ var ModelResolver = class {
 };
 
 // src/services/RunnerInstallation.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_util4 = require("util");
-var execAsync4 = (0, import_util4.promisify)(import_child_process5.exec);
+var execAsync4 = (0, import_util4.promisify)(import_child_process6.exec);
 var defaultExec3 = async (command, options) => {
   const PATH = await augmentedPath();
   const { stdout } = await execAsync4(command, { ...options, env: withPath(process.env, PATH) });
@@ -13016,72 +13334,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
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 
 // src/utils/workspace.ts
-var fs7 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var WorkspaceNotFoundError = class extends Error {
   constructor(workspace) {
     super(`Workspace "${workspace}" does not exist.`);
@@ -13092,7 +13350,7 @@ var WorkspaceNotFoundError = class extends Error {
 };
 function defaultIsDirectory(candidate) {
   try {
-    return fs7.statSync(candidate).isDirectory();
+    return fs8.statSync(candidate).isDirectory();
   } catch {
     return false;
   }
@@ -13128,8 +13386,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);
@@ -13137,7 +13395,7 @@ function assertWorkspaceIsProject(workspace, deps = {}) {
     throw new WorkspaceNotAProjectError(workspace);
   }
   const hasMarker = [...PROJECT_MARKER_DIRS, ...PROJECT_MARKER_FILES].some(
-    (marker2) => exists(path15.join(resolved, marker2))
+    (marker2) => exists(path17.join(resolved, marker2))
   );
   if (!hasMarker) throw new WorkspaceNotAProjectError(workspace);
 }
@@ -13205,13 +13463,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
@@ -13257,7 +13516,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;
@@ -13268,7 +13527,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);
@@ -13483,14 +13742,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?.();
@@ -13573,8 +13832,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",
@@ -13587,8 +13846,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?.();
       })
     ]);
@@ -13865,12 +14124,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 });
   });
 }
@@ -13904,17 +14163,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) => {
@@ -13923,15 +14182,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;
@@ -13964,8 +14223,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,
@@ -14169,14 +14428,14 @@ ${part.text}` : part.text });
       }
     }
   }
-  async json(method, path24, body, signal) {
-    const response = await this.deps.fetch(`${this.baseUrl}${path24}`, {
+  async json(method, path26, body, signal) {
+    const response = await this.deps.fetch(`${this.baseUrl}${path26}`, {
       method,
       headers: { "content-type": "application/json" },
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       ...signal ? { signal } : {}
     });
-    if (!response.ok) throw new Error(`${method} ${path24} failed: ${response.status} ${response.statusText}`);
+    if (!response.ok) throw new Error(`${method} ${path26} failed: ${response.status} ${response.statusText}`);
     return await response.json().catch(() => null);
   }
   nativeSessionId() {
@@ -14269,7 +14528,7 @@ var CliAgentAiService = class {
     if (!runner) throw new Error(`${config.aiProvider} is not a coding-agent planner.`);
     this.runner = runner;
     this.processDeps = {
-      spawn: deps.spawn ?? import_child_process6.spawn,
+      spawn: deps.spawn ?? import_child_process7.spawn,
       fetch: deps.fetch ?? globalThis.fetch,
       resolvePath: deps.resolvePath,
       platform: deps.platform,
@@ -14630,8 +14889,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() }
     ];
@@ -15530,26 +15789,26 @@ function retargetTaskRunner(task, runner, catalog) {
 }
 
 // src/services/SkillsService.ts
-var fs8 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 
 // src/services/builtinSkills.ts
-var path16 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var import_url = require("url");
 var import_meta = {};
 function builtinSkillsDir() {
-  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path16.dirname((0, import_url.fileURLToPath)(
+  const dir = typeof __dirname !== "undefined" && __dirname ? __dirname : path18.dirname((0, import_url.fileURLToPath)(
     // @ts-expect-error - import.meta is only valid under an ESM module setting
     import_meta.url
   ));
-  return path16.join(dir, "..", "skills");
+  return path18.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")) {
@@ -15578,23 +15837,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 = path17.join(src, entry.name);
-    const destPath = path17.join(dest, entry.name);
+    const srcPath = path19.join(src, entry.name);
+    const destPath = path19.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 = path17.join(dir, entry.name, "SKILL.md");
-    if (!fs8.existsSync(skillFile)) continue;
+    const skillFile = path19.join(dir, entry.name, "SKILL.md");
+    if (!fs9.existsSync(skillFile)) continue;
     const parsed = parseSkillFile(skillFile, entry.name, source);
     if (parsed) skills.push(parsed);
   }
@@ -15606,22 +15865,22 @@ var SkillsService = class {
   }
   workspaceRoot;
   localDir() {
-    return this.workspaceRoot ? path17.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
+    return this.workspaceRoot ? path19.join(this.workspaceRoot, ".ordewell", "skills") : void 0;
   }
   globalDir() {
-    return path17.join(globalDataDir(), "skills");
+    return path19.join(globalDataDir(), "skills");
   }
   seed(name) {
-    const dest = path17.join(this.globalDir(), name);
-    if (fs8.existsSync(dest)) return false;
+    const dest = path19.join(this.globalDir(), name);
+    if (fs9.existsSync(dest)) return false;
     let srcDir;
     try {
-      srcDir = path17.join(builtinSkillsDir(), name);
+      srcDir = path19.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;
     }
@@ -15635,14 +15894,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(path17.join(dir, "SKILL.md"), "utf8");
+      raw = fs9.readFileSync(path19.join(dir, "SKILL.md"), "utf8");
     } catch {
       return false;
     }
@@ -15659,11 +15918,11 @@ var SkillsService = class {
   }
   pruneRetired() {
     for (const name of RETIRED_BUILTIN_SKILL_NAMES) {
-      const dest = path17.join(this.globalDir(), name);
-      if (!fs8.existsSync(dest)) continue;
+      const dest = path19.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)}`);
       }
@@ -15674,11 +15933,11 @@ var SkillsService = class {
     if (BUILTIN_SKILL_NAMES.includes(name)) this.seed(name);
     const localDir = this.localDir();
     if (localDir) {
-      const localFile = path17.join(localDir, name, "SKILL.md");
-      if (fs8.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
+      const localFile = path19.join(localDir, name, "SKILL.md");
+      if (fs9.existsSync(localFile)) return parseSkillFile(localFile, name, "local");
     }
-    const globalFile = path17.join(this.globalDir(), name, "SKILL.md");
-    if (fs8.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
+    const globalFile = path19.join(this.globalDir(), name, "SKILL.md");
+    if (fs9.existsSync(globalFile)) return parseSkillFile(globalFile, name, "global");
     return void 0;
   }
   listSkills() {
@@ -15759,8 +16018,8 @@ function truncateCheckpointSummary(summary) {
 }
 
 // src/utils/sessionStore.ts
-var fs9 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 
 // src/utils/sessionId.ts
 var import_crypto2 = require("crypto");
@@ -15771,7 +16030,7 @@ function mintSessionId() {
 // src/utils/sessionStore.ts
 var SESSIONS_SUBDIR = "sessions";
 function getSessionsDir(baseDir) {
-  return path18.join(getStateDir(baseDir), SESSIONS_SUBDIR);
+  return path20.join(getStateDir(baseDir), SESSIONS_SUBDIR);
 }
 var REJECTION_MESSAGE = "This session was created with an older version of Ordewell. Please re-plan.";
 function hasScalarRunner(parsed) {
@@ -15793,11 +16052,11 @@ function legacySessionFilename(session) {
   return `${filenameStem(session)}_${session.id.slice(0, 8)}.json`;
 }
 function dropLegacyFile(sessionsDir, meta) {
-  const legacy = path18.join(sessionsDir, legacySessionFilename(meta));
-  if (legacy === path18.join(sessionsDir, sessionFilename(meta)) || !fs9.existsSync(legacy)) return;
+  const legacy = path20.join(sessionsDir, legacySessionFilename(meta));
+  if (legacy === path20.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 {
   }
 }
@@ -15820,18 +16079,18 @@ function saveSession(plan, goal, baseDir, id) {
     plan: JSON.parse(JSON.stringify(plan))
   };
   const filename = sessionFilename(meta);
-  const filePath = path18.join(sessionsDir, filename);
-  fs9.writeFileSync(filePath, JSON.stringify(session, null, 2));
+  const filePath = path20.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(path18.join(sessionsDir, f), "utf-8");
+      const raw = fs10.readFileSync(path20.join(sessionsDir, f), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${f}: ${REJECTION_MESSAGE}`);
@@ -15846,10 +16105,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(path18.join(sessionsDir, f), "utf-8");
+      const raw = fs10.readFileSync(path20.join(sessionsDir, f), "utf-8");
       const session = JSON.parse(raw);
       if (session.meta.id === sessionId) return f;
     } catch (err) {
@@ -15860,11 +16119,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(path18.join(sessionsDir, file), "utf-8");
+      const raw = fs10.readFileSync(path20.join(sessionsDir, file), "utf-8");
       const parsed = JSON.parse(raw);
       if (hasScalarRunner(parsed)) {
         logger.warn("sessionStore", `session file ${file}: ${REJECTION_MESSAGE}`);
@@ -15895,11 +16154,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(path18.join(sessionsDir, file));
+      fs10.unlinkSync(path20.join(sessionsDir, file));
       return true;
     }
   } catch (err) {
@@ -16580,6 +16839,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();
@@ -17337,7 +17600,7 @@ function buildRunnerInvocation(opts) {
 }
 
 // src/services/HeadlessRunner.ts
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 
 // src/services/AbstractRunner.ts
 var import_events = require("events");
@@ -17392,7 +17655,7 @@ var AbstractRunner = class {
 function defaultHasScriptCmd() {
   if (process.platform === "win32") return false;
   try {
-    (0, import_child_process7.execSync)("which script", { stdio: "ignore" });
+    (0, import_child_process8.execSync)("which script", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -17482,7 +17745,7 @@ var HeadlessRunner = class extends AbstractRunner {
   defaultInteractive = false;
   constructor(deps = {}) {
     super();
-    this.spawnImpl = deps.spawnImpl ?? import_child_process7.spawn;
+    this.spawnImpl = deps.spawnImpl ?? import_child_process8.spawn;
     this.hasScriptCmd = deps.hasScriptCmd ?? defaultHasScriptCmd;
     this.resolvePath = deps.resolvePath ?? augmentedPath;
     this.launchDeps = { resolvePath: this.resolvePath, ...deps.launchDeps };
@@ -17522,7 +17785,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
     };
@@ -17541,14 +17804,14 @@ var HeadlessRunner = class extends AbstractRunner {
 };
 
 // src/services/TmuxRunner.ts
-var import_child_process9 = require("child_process");
+var import_child_process10 = require("child_process");
 var import_util5 = require("util");
 var import_os = require("os");
 var import_path = require("path");
 var import_fs2 = require("fs");
 
 // src/utils/tmux.ts
-var import_child_process8 = require("child_process");
+var import_child_process9 = require("child_process");
 function tmuxSessionName(port) {
   return `ordewell-${port}`;
 }
@@ -17561,7 +17824,7 @@ function tmuxWindowName(taskId, planSessionId) {
   return `t-${scope}${slug(taskId).slice(0, 16)}`;
 }
 var defaultProbe = () => {
-  (0, import_child_process8.execSync)(process.platform === "win32" ? "where tmux" : "which tmux", { stdio: "ignore" });
+  (0, import_child_process9.execSync)(process.platform === "win32" ? "where tmux" : "which tmux", { stdio: "ignore" });
 };
 function hasTmux(probe = defaultProbe) {
   try {
@@ -17573,7 +17836,7 @@ function hasTmux(probe = defaultProbe) {
 }
 var defaultHasBin = (bin) => {
   try {
-    (0, import_child_process8.execSync)(`${process.platform === "win32" ? "where" : "which"} ${bin}`, { stdio: "ignore" });
+    (0, import_child_process9.execSync)(`${process.platform === "win32" ? "where" : "which"} ${bin}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -17596,7 +17859,7 @@ function clipboardCopyCommand(hasBin = defaultHasBin, platform = process.platfor
 
 // src/services/TmuxRunner.ts
 var EXIT_RE = /<<<ORDEWELL_TMUX_EXIT:(\d+)>>>/;
-var execFileAsync2 = (0, import_util5.promisify)(import_child_process9.execFile);
+var execFileAsync2 = (0, import_util5.promisify)(import_child_process10.execFile);
 var defaultExecFile3 = async (command, args) => {
   const { stdout, stderr } = await execFileAsync2(command, args);
   return { stdout: String(stdout), stderr: String(stderr) };
@@ -17834,7 +18097,7 @@ var TmuxRunner = class extends AbstractRunner {
       (0, import_path.join)(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);
@@ -17914,18 +18177,18 @@ function tokensMatch(presented, expected) {
 }
 
 // src/plugins/RunnerRegistry.ts
-var fs11 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
-var os5 = __toESM(require("os"));
-var import_child_process10 = require("child_process");
+var fs12 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+var os6 = __toESM(require("os"));
+var import_child_process11 = require("child_process");
 var import_crypto4 = require("crypto");
 
 // src/plugins/FsPluginStore.ts
-var fs10 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 
 // src/plugins/pluginNames.ts
-var path19 = __toESM(require("path"));
+var path21 = __toESM(require("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) {
@@ -17940,10 +18203,10 @@ function assertPlainPluginName(name) {
 }
 function resolvePluginInstallDir(pluginsDir, name) {
   assertPlainPluginName(name);
-  const root = path19.resolve(pluginsDir);
-  const dest = path19.resolve(root, name);
-  const relative5 = path19.relative(root, dest);
-  if (relative5 !== name || relative5 === "" || path19.isAbsolute(relative5)) {
+  const root = path21.resolve(pluginsDir);
+  const dest = path21.resolve(root, name);
+  const relative5 = path21.relative(root, dest);
+  if (relative5 !== name || relative5 === "" || path21.isAbsolute(relative5)) {
     throw new Error(`Plugin install path escapes the plugins directory: ${JSON.stringify(name)}`);
   }
   return dest;
@@ -17958,13 +18221,13 @@ function isValidManifest(obj) {
 
 // src/plugins/FsPluginStore.ts
 function userPluginsDir() {
-  return path20.join(globalDataDir(), "plugins");
+  return path22.join(globalDataDir(), "plugins");
 }
 function loadManifestFromDir(dir) {
-  const manifestPath = path20.join(dir, "manifest.json");
-  if (!fs10.existsSync(manifestPath)) return null;
+  const manifestPath = path22.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;
@@ -17974,29 +18237,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 = path20.join(src, entry.name);
-    const destPath = path20.join(dest, entry.name);
+    const srcPath = path22.join(src, entry.name);
+    const destPath = path22.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 = path20.join(dir, entry.name);
+    const p = path22.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() {
@@ -18004,10 +18267,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 [];
     }
@@ -18015,7 +18278,7 @@ var FsPluginStore = class {
   }
   listDir(dir) {
     try {
-      return fs10.readdirSync(dir);
+      return fs11.readdirSync(dir);
     } catch {
       return [];
     }
@@ -18033,20 +18296,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(path24) {
-    return fs10.existsSync(path24) && fs10.statSync(path24).isDirectory();
+  dirExists(path26) {
+    return fs11.existsSync(path26) && fs11.statSync(path26).isDirectory();
   }
-  exists(path24) {
-    return fs10.existsSync(path24);
+  exists(path26) {
+    return fs11.existsSync(path26);
   }
 };
 
@@ -18073,7 +18336,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,
@@ -18417,7 +18688,7 @@ function isReservedRunnerName(name) {
   return RESERVED_RUNNER_NAMES.has(name.toLowerCase());
 }
 function gitClone(url, destDir) {
-  (0, import_child_process10.execFileSync)("git", ["clone", "--depth", "1", "--", url, destDir], {
+  (0, import_child_process11.execFileSync)("git", ["clone", "--depth", "1", "--", url, destDir], {
     stdio: "pipe",
     timeout: 3e4,
     // A repository that demands credentials should fail, not hang on a prompt.
@@ -18478,7 +18749,7 @@ var RunnerRegistry = class {
     return entry?.source === "builtin";
   }
   installFromPath(sourcePath) {
-    const absPath = path21.resolve(sourcePath);
+    const absPath = path23.resolve(sourcePath);
     if (!this.store.dirExists(absPath)) {
       throw new Error(`Plugin source must be a directory: ${absPath}`);
     }
@@ -18490,7 +18761,7 @@ var RunnerRegistry = class {
   }
   installFromGit(url) {
     const validated = assertInstallablePluginUrl(url);
-    const tmpDir = path21.join(os5.tmpdir(), `ordewell-plugin-${(0, import_crypto4.randomBytes)(12).toString("hex")}`);
+    const tmpDir = path23.join(os6.tmpdir(), `ordewell-plugin-${(0, import_crypto4.randomBytes)(12).toString("hex")}`);
     this.store.ensureDir(tmpDir);
     try {
       try {
@@ -18503,7 +18774,7 @@ var RunnerRegistry = class {
       const hasManifest = contents.some((f) => f === "manifest.json");
       let sourceDir = tmpDir;
       if (!hasManifest) {
-        const onlyEntry = contents.length === 1 ? path21.join(tmpDir, contents[0]) : void 0;
+        const onlyEntry = contents.length === 1 ? path23.join(tmpDir, contents[0]) : void 0;
         if (!onlyEntry || !this.store.dirExists(onlyEntry)) {
           throw new Error(`No manifest.json found in repository: ${validated.toString()}`);
         }
@@ -18551,7 +18822,7 @@ var RunnerRegistry = class {
   }
   createSkeleton(name, outputDir) {
     assertPlainPluginName(name);
-    const dir = path21.resolve(outputDir, name);
+    const dir = path23.resolve(outputDir, name);
     this.store.ensureDir(dir);
     const manifest = {
       name,
@@ -18583,8 +18854,8 @@ var RunnerRegistry = class {
         ]
       }
     };
-    this.store.writeFile(path21.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
-    const runSh = path21.join(dir, "run.sh");
+    this.store.writeFile(path23.join(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+    const runSh = path23.join(dir, "run.sh");
     const scriptContent = `#!/usr/bin/env bash
 # Custom runner script for ${name}
 # Receives:
@@ -18610,30 +18881,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
-var fs12 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
-  return path22.join(getStateDir(baseDir), STATE_FILE);
+  return path24.join(getStateDir(baseDir), STATE_FILE);
 }
 function saveState(plan, baseDir) {
   const statePath = getStatePath(baseDir ?? process.cwd());
-  ensureDir(path22.dirname(statePath));
+  ensureDir(path24.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.`);
@@ -18650,16 +18921,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
-var fs13 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var DEFAULTS = {
   tdd: { enabled: true },
   verification: { enabled: false }
@@ -18667,7 +18938,7 @@ var DEFAULTS = {
 function getSettingsPath() {
   const override = process.env.ORDEWELL_SETTINGS_PATH;
   if (override && override.trim()) return override.trim();
-  return path23.join(globalDataDir(), "settings.json");
+  return path25.join(globalDataDir(), "settings.json");
 }
 function readPlannerModels(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
@@ -18700,7 +18971,7 @@ var SettingsService = class {
   }
   fileMtimeMs() {
     try {
-      return fs13.statSync(this.filePath).mtimeMs;
+      return fs14.statSync(this.filePath).mtimeMs;
     } catch {
       return null;
     }
@@ -18772,8 +19043,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 }
@@ -18795,11 +19066,11 @@ var SettingsService = class {
     return { ...DEFAULTS, tdd: { ...DEFAULTS.tdd }, verification: { ...DEFAULTS.verification } };
   }
   persist() {
-    const dir = path23.dirname(this.filePath);
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    const dir = path25.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();
   }
 };
@@ -18866,6 +19137,7 @@ var PlannerModelMemory = class {
   ConversationEditError,
   DAEMON_SUBPROTOCOL,
   DAEMON_TOKEN_SUBPROTOCOL_PREFIX,
+  DEFAULT_MAX_PARALLEL,
   DENY_ALL,
   EmbeddedNewlineError,
   EnvConfig,
@@ -19048,6 +19320,7 @@ var PlannerModelMemory = class {
   modifyValidationFeedback,
   normalizeAgentArgs,
   normalizeGeminiModel,
+  parseMaxParallel,
   parsePartialPlan,
   parsePlanJson,
   parseTaskOpsJson,