ralphctl 0.7.0 → 0.7.2

package/dist/cli.mjs

@@ -2253,30 +2253,6 @@ var runSignalParsers = (text, timestamp, parsers = DEFAULT_SIGNAL_PARSERS) => {
 var parseHarnessSignals = (text, timestamp) => runSignalParsers(text, timestamp);
 
 // src/integration/ai/providers/claude/parse-stream.ts
-var parseClaudeJsonEnvelope = (stdout) => {
-  const trimmed = stdout.trim();
-  if (trimmed.length === 0) {
-    return { body: "", sessionId: void 0, model: void 0 };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return { body: stdout, sessionId: void 0, model: void 0 };
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return { body: stdout, sessionId: void 0, model: void 0 };
-  }
-  const obj = parsed;
-  const result = stringField(obj, "result");
-  const sessionId2 = stringField(obj, "session_id", "sessionId");
-  const model = stringField(obj, "model");
-  return {
-    body: result ?? stdout,
-    sessionId: sessionId2,
-    model
-  };
-};
 var stringField = (obj, ...names) => {
   for (const name of names) {
     const v = obj[name];
@@ -2284,6 +2260,63 @@ var stringField = (obj, ...names) => {
   }
   return void 0;
 };
+var createClaudeStreamParser = () => {
+  let buffer = "";
+  let body = "";
+  let sessionId2;
+  let model;
+  const emit = (raw, onLine) => {
+    if (raw.length === 0) return;
+    if (raw.startsWith("{") && raw.endsWith("}")) {
+      try {
+        const json = JSON.parse(raw);
+        onLine({ raw, json });
+        return;
+      } catch {
+      }
+    }
+    onLine({ raw });
+  };
+  const ingest = (line) => {
+    const json = line.json;
+    if (json === void 0) return;
+    if (sessionId2 === void 0) {
+      const seen = stringField(json, "session_id", "sessionId");
+      if (seen !== void 0) sessionId2 = seen;
+    }
+    const type = stringField(json, "type");
+    if (type === "system" && model === void 0) {
+      const m = stringField(json, "model");
+      if (m !== void 0) model = m;
+    }
+    if (type === "result") {
+      const r = stringField(json, "result");
+      if (r !== void 0) body = r;
+    }
+  };
+  return {
+    feed(chunk, onLine) {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        emit(line, onLine);
+        nl = buffer.indexOf("\n");
+      }
+    },
+    flush(onLine) {
+      if (buffer.length > 0) {
+        emit(buffer, onLine);
+        buffer = "";
+      }
+    },
+    ingest,
+    snapshot() {
+      return { body, sessionId: sessionId2, model };
+    }
+  };
+};
 
 // src/integration/ai/providers/_engine/idle-watchdog.ts
 var DEFAULT_IDLE_MS = 5 * 6e4;
@@ -2428,7 +2461,7 @@ var buildClaudeArgs = (session) => {
       })
     );
   }
-  const args = ["-p", "--output-format", "json", "--model", session.model];
+  const args = ["-p", "--verbose", "--output-format", "stream-json", "--model", session.model];
   args.push("--permission-mode", "bypassPermissions");
   const denied = disallowedToolsFor(session.permissions);
   if (denied.length > 0) {
@@ -2505,13 +2538,14 @@ var spawnAttempt = async (input) => {
   const child = spawnFn(command, args, {
     stdio: ["pipe", "pipe", "pipe"]
   });
-  let stdoutBuf = "";
+  const parser = createClaudeStreamParser();
   let stderrBuf = "";
+  const onLine = (line) => {
+    parser.ingest(line);
+  };
   const { code, signal } = await runHeadlessSpawn({
     child,
-    onStdout: (chunk) => {
-      stdoutBuf += chunk;
-    },
+    onStdout: (chunk) => parser.feed(chunk, onLine),
     onStderr: (chunk) => {
       stderrBuf += chunk;
     },
@@ -2530,6 +2564,7 @@ var spawnAttempt = async (input) => {
       });
     }
   });
+  parser.flush(onLine);
   if (signal === "SIGTERM") {
     return {
       kind: "error",
@@ -2541,9 +2576,8 @@ var spawnAttempt = async (input) => {
       })
     };
   }
+  const envelope = parser.snapshot();
   if (code === 0) {
-    const envelope = parseClaudeJsonEnvelope(stdoutBuf);
-    stdoutBuf = "";
     if (envelope.sessionId !== void 0) {
       deps.eventBus.publish({
         type: "log",
@@ -2578,13 +2612,12 @@ var spawnAttempt = async (input) => {
     };
   }
   if (RATE_LIMIT_RE.test(stderrBuf)) {
-    const sessionIdOnFailure = parseClaudeJsonEnvelope(stdoutBuf).sessionId;
     return {
       kind: "rate-limit",
       error: new RateLimitError({
         subCode: "spawn-stderr",
         message: `claude-provider: rate-limit detected in stderr (exit ${String(code)})`,
-        ...sessionIdOnFailure !== void 0 ? { sessionId: sessionIdOnFailure } : {}
+        ...envelope.sessionId !== void 0 ? { sessionId: envelope.sessionId } : {}
       })
     };
   }
@@ -2634,24 +2667,16 @@ var buildCodexArgs = (session, opts) => {
   const perms = sandboxFor(session.permissions);
   if (!perms.ok) return Result.error(perms.error);
   const args = ["exec"];
-  if (session.resume !== void 0) {
+  const isResume = session.resume !== void 0;
+  if (isResume) {
     args.push("resume", String(session.resume));
   }
-  args.push(
-    "--ephemeral",
-    "--skip-git-repo-check",
-    "-o",
-    opts.outputFile,
-    "--json",
-    "-m",
-    session.model,
-    "-C",
-    String(session.cwd),
-    "-s",
-    perms.value.sandbox
-  );
-  for (const root of session.additionalRoots ?? []) {
-    args.push("--add-dir", String(root));
+  args.push("--ephemeral", "--skip-git-repo-check", "-o", opts.outputFile, "--json", "-m", session.model);
+  if (!isResume) {
+    args.push("-C", String(session.cwd), "-s", perms.value.sandbox);
+    for (const root of session.additionalRoots ?? []) {
+      args.push("--add-dir", String(root));
+    }
   }
   if (opts.reasoningEffort !== void 0) {
     args.push("-c", `model_reasoning_effort=${opts.reasoningEffort}`);
@@ -2829,6 +2854,18 @@ var spawnAttempt2 = async (input) => {
     const signals = parseHarnessSignals(body, IsoTimestamp.now());
     const wrote = await writeJsonAtomic(String(session.signalsFile), signals);
     if (!wrote.ok) return { kind: "error", error: wrote.error };
+    if (session.bodyFile !== void 0) {
+      const bodyWrote = await writeTextAtomic(String(session.bodyFile), body);
+      if (!bodyWrote.ok) {
+        deps.eventBus.publish({
+          type: "log",
+          level: "warn",
+          message: `codex-provider: failed to write body file \u2014 diagnostic capture skipped`,
+          meta: { bodyFile: String(session.bodyFile), error: bodyWrote.error.message },
+          at: IsoTimestamp.now()
+        });
+      }
+    }
     return {
       kind: "success",
       output: {
@@ -3211,6 +3248,7 @@ var stringifyError4 = (cause) => cause instanceof Error ? cause.message : String
 
 // src/integration/ai/providers/codex/interactive.ts
 import { spawn as nodeSpawn7 } from "child_process";
+import { dirname as dirname4 } from "path";
 var defaultSpawn7 = (command, args, options) => nodeSpawn7(command, [...args], { stdio: options.stdio, cwd: options.cwd });
 var createInteractiveCodexProvider = (deps) => {
   const spawnFn = deps.spawn ?? defaultSpawn7;
@@ -3227,10 +3265,23 @@ var createInteractiveCodexProvider = (deps) => {
           })
         );
       }
+      const allRoots = [
+        String(input.cwd),
+        ...input.additionalRoots?.map((r) => String(r)) ?? [],
+        dirname4(String(input.outputFile)),
+        dirname4(String(input.promptFile))
+      ];
+      const seen = /* @__PURE__ */ new Set();
+      const dirFlags = allRoots.filter((p) => {
+        if (seen.has(p)) return false;
+        seen.add(p);
+        return true;
+      }).flatMap((p) => ["--add-dir", shellQuote2(p)]);
       const inner = [
         "codex",
         "--cd",
         shellQuote2(String(input.cwd)),
+        ...dirFlags,
         "--model",
         shellQuote2(input.model),
         "-s",
@@ -3286,7 +3337,7 @@ var stringifyError5 = (cause) => cause instanceof Error ? cause.message : String
 // src/integration/ai/providers/copilot/interactive.ts
 import { promises as fs6 } from "fs";
 import { spawn as nodeSpawn8 } from "child_process";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 var defaultSpawn8 = (command, args, options) => nodeSpawn8(command, [...args], { stdio: options.stdio, cwd: options.cwd });
 var defaultReadFile = (path) => fs6.readFile(path, "utf8");
 var createInteractiveCopilotProvider = (deps) => {
@@ -3320,8 +3371,8 @@ var createInteractiveCopilotProvider = (deps) => {
       const allRoots = [
         String(input.cwd),
         ...input.additionalRoots?.map((r) => String(r)) ?? [],
-        dirname4(String(input.outputFile)),
-        dirname4(String(input.promptFile))
+        dirname5(String(input.outputFile)),
+        dirname5(String(input.promptFile))
       ];
       const seen = /* @__PURE__ */ new Set();
       const dirFlags = allRoots.filter((p) => {
@@ -3864,7 +3915,7 @@ var createPullRequestCreator = (deps) => async (input) => {
 
 // src/integration/ai/prompts/_engine/fs-template-loader.ts
 import { promises as fs7 } from "fs";
-import { dirname as dirname5, join as join6 } from "path";
+import { dirname as dirname6, join as join6 } from "path";
 import { fileURLToPath } from "url";
 var createFsTemplateLoader = (templatesDir) => ({
   async load(name) {
@@ -3898,7 +3949,7 @@ var tryRead = async (path) => {
   }
 };
 var TEMPLATES_DIR = (() => {
-  const here = dirname5(fileURLToPath(import.meta.url));
+  const here = dirname6(fileURLToPath(import.meta.url));
   const isBundled = import.meta.url.endsWith("/cli.mjs") || import.meta.url.endsWith("\\cli.mjs");
   const path = isBundled ? join6(here, "prompts") : join6(here, "..");
   const parsed = AbsolutePath.parse(path);
@@ -3911,11 +3962,7 @@ var defaultTemplatesDir = () => TEMPLATES_DIR;
 var isNodeErrnoCode2 = (cause, code) => typeof cause === "object" && cause !== null && cause.code === code;
 
 // src/integration/ai/readiness/claude/probe.ts
-import { promises as fs8 } from "fs";
-import { basename, join as join7 } from "path";
-
-// src/domain/value/kebab-case.ts
-var toKebabCase = (input) => input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
+import { join as join8 } from "path";
 
 // src/domain/value/error/probe-error.ts
 var ProbeError = class extends Error {
@@ -3936,66 +3983,22 @@ var ProbeError = class extends Error {
   }
 };
 
-// src/integration/ai/readiness/_engine/state.ts
-var unknownState = { kind: "unknown" };
-var absentState = (evaluatedAt) => ({ kind: "absent", evaluatedAt });
-var presentState = (evaluatedAt, artifacts) => ({
-  kind: "present",
-  evaluatedAt,
-  artifacts
-});
+// src/integration/ai/readiness/_engine/probe-fs.ts
+import { promises as fs8 } from "fs";
+import { basename, join as join7 } from "path";
 
-// src/integration/ai/readiness/_engine/predicates.ts
-var isPresent = (state) => state.kind === "present";
-var hasAnyClaudeArtifact = (a) => a.claudeMd !== void 0 || a.agentsMd !== void 0 || a.settings !== void 0 || a.settingsLocal !== void 0 || a.mcpConfig !== void 0 || a.skills.length > 0 || a.commands.length > 0 || a.agents.length > 0 || a.hooks.length > 0;
-var hasAnyCopilotArtifact = (a) => a.copilotInstructions !== void 0;
+// src/domain/value/kebab-case.ts
+var toKebabCase = (input) => input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
 
-// src/integration/ai/readiness/claude/probe.ts
-var claudeProbe = {
-  tool: "claude-code",
-  async evaluate(repository, now) {
-    const root = repository.path;
-    const claudeMd = await probeFile(join7(root, "CLAUDE.md"));
-    if (!claudeMd.ok) return Result.error(claudeMd.error);
-    const agentsMd = await probeFile(join7(root, "AGENTS.md"));
-    if (!agentsMd.ok) return Result.error(agentsMd.error);
-    const settings = await probeFile(join7(root, ".claude/settings.json"));
-    if (!settings.ok) return Result.error(settings.error);
-    const settingsLocal = await probeFile(join7(root, ".claude/settings.local.json"));
-    if (!settingsLocal.ok) return Result.error(settingsLocal.error);
-    const mcpConfig = await probeFile(join7(root, ".mcp.json"));
-    if (!mcpConfig.ok) return Result.error(mcpConfig.error);
-    const skills = await probeNamedDirCollection(join7(root, ".claude/skills"), "SKILL.md");
-    if (!skills.ok) return Result.error(skills.error);
-    const commands = await probeNamedFileCollection(join7(root, ".claude/commands"));
-    if (!commands.ok) return Result.error(commands.error);
-    const agents = await probeNamedFileCollection(join7(root, ".claude/agents"));
-    if (!agents.ok) return Result.error(agents.error);
-    const hooks = await readHooks([settings.value, settingsLocal.value]);
-    if (!hooks.ok) return Result.error(hooks.error);
-    const artifacts = {
-      tool: "claude-code",
-      ...claudeMd.value !== void 0 ? { claudeMd: claudeMd.value } : {},
-      ...agentsMd.value !== void 0 ? { agentsMd: agentsMd.value } : {},
-      ...settings.value !== void 0 ? { settings: settings.value } : {},
-      ...settingsLocal.value !== void 0 ? { settingsLocal: settingsLocal.value } : {},
-      ...mcpConfig.value !== void 0 ? { mcpConfig: mcpConfig.value } : {},
-      skills: skills.value,
-      commands: commands.value,
-      agents: agents.value,
-      hooks: hooks.value
-    };
-    return Result.ok(hasAnyClaudeArtifact(artifacts) ? presentState(now, artifacts) : absentState(now));
-  }
-};
+// src/integration/ai/readiness/_engine/probe-fs.ts
 var probeFile = async (path) => {
   try {
     const stat = await fs8.stat(path);
     if (!stat.isFile()) return Result.ok(void 0);
     return Result.ok({ path });
   } catch (cause) {
-    if (isNodeErrnoCode3(cause, "ENOENT")) return Result.ok(void 0);
-    if (isNodeErrnoCode3(cause, "EACCES")) {
+    if (isNodeErrnoCode(cause, "ENOENT")) return Result.ok(void 0);
+    if (isNodeErrnoCode(cause, "EACCES")) {
       return Result.error(
         new ProbeError({ subCode: "fs-permission", message: `permission denied reading ${path}`, path, cause })
       );
@@ -4003,23 +4006,6 @@ var probeFile = async (path) => {
     return Result.error(new ProbeError({ subCode: "fs-read", message: `failed to stat ${path}`, path, cause }));
   }
 };
-var probeNamedFileCollection = async (dir) => {
-  const entries = await listDir2(dir);
-  if (!entries.ok) return Result.error(entries.error);
-  const refs = [];
-  for (const entry of entries.value) {
-    if (!entry.endsWith(".md")) continue;
-    const full = join7(dir, entry);
-    const stat = await statSafely(full);
-    if (!stat.ok) return Result.error(stat.error);
-    if (stat.value === void 0 || !stat.value.isFile()) continue;
-    const baseName = entry.slice(0, -".md".length);
-    const slug = Slug.parse(toKebabCase(baseName));
-    if (!slug.ok) continue;
-    refs.push({ name: slug.value, path: full });
-  }
-  return Result.ok(refs);
-};
 var probeNamedDirCollection = async (dir, childMarker) => {
   const entries = await listDir2(dir);
   if (!entries.ok) return Result.error(entries.error);
@@ -4039,12 +4025,29 @@ var probeNamedDirCollection = async (dir, childMarker) => {
   }
   return Result.ok(refs);
 };
+var probeNamedFileCollection = async (dir) => {
+  const entries = await listDir2(dir);
+  if (!entries.ok) return Result.error(entries.error);
+  const refs = [];
+  for (const entry of entries.value) {
+    if (!entry.endsWith(".md")) continue;
+    const full = join7(dir, entry);
+    const stat = await statSafely(full);
+    if (!stat.ok) return Result.error(stat.error);
+    if (stat.value === void 0 || !stat.value.isFile()) continue;
+    const baseName = entry.slice(0, -".md".length);
+    const slug = Slug.parse(toKebabCase(baseName));
+    if (!slug.ok) continue;
+    refs.push({ name: slug.value, path: full });
+  }
+  return Result.ok(refs);
+};
 var listDir2 = async (dir) => {
   try {
     return Result.ok(await fs8.readdir(dir));
   } catch (cause) {
-    if (isNodeErrnoCode3(cause, "ENOENT") || isNodeErrnoCode3(cause, "ENOTDIR")) return Result.ok([]);
-    if (isNodeErrnoCode3(cause, "EACCES")) {
+    if (isNodeErrnoCode(cause, "ENOENT") || isNodeErrnoCode(cause, "ENOTDIR")) return Result.ok([]);
+    if (isNodeErrnoCode(cause, "EACCES")) {
       return Result.error(
         new ProbeError({ subCode: "fs-permission", message: `permission denied listing ${dir}`, path: dir, cause })
       );
@@ -4056,8 +4059,8 @@ var statSafely = async (path) => {
   try {
     return Result.ok(await fs8.stat(path));
   } catch (cause) {
-    if (isNodeErrnoCode3(cause, "ENOENT")) return Result.ok(void 0);
-    if (isNodeErrnoCode3(cause, "EACCES")) {
+    if (isNodeErrnoCode(cause, "ENOENT")) return Result.ok(void 0);
+    if (isNodeErrnoCode(cause, "EACCES")) {
       return Result.error(
         new ProbeError({ subCode: "fs-permission", message: `permission denied stat ${path}`, path, cause })
       );
@@ -4065,6 +4068,73 @@ var statSafely = async (path) => {
     return Result.error(new ProbeError({ subCode: "fs-read", message: `failed to stat ${path}`, path, cause }));
   }
 };
+var readFileSafely = async (path) => {
+  try {
+    return Result.ok(await fs8.readFile(path, "utf8"));
+  } catch (cause) {
+    if (isNodeErrnoCode(cause, "ENOENT")) return Result.ok(void 0);
+    if (isNodeErrnoCode(cause, "EACCES")) {
+      return Result.error(
+        new ProbeError({ subCode: "fs-permission", message: `permission denied reading ${path}`, path, cause })
+      );
+    }
+    return Result.error(new ProbeError({ subCode: "fs-read", message: `failed to read ${path}`, path, cause }));
+  }
+};
+
+// src/integration/ai/readiness/_engine/state.ts
+var unknownState = { kind: "unknown" };
+var absentState = (evaluatedAt) => ({ kind: "absent", evaluatedAt });
+var presentState = (evaluatedAt, artifacts) => ({
+  kind: "present",
+  evaluatedAt,
+  artifacts
+});
+
+// src/integration/ai/readiness/_engine/predicates.ts
+var isPresent = (state) => state.kind === "present";
+var hasAnyClaudeArtifact = (a) => a.claudeMd !== void 0 || a.agentsMd !== void 0 || a.settings !== void 0 || a.settingsLocal !== void 0 || a.mcpConfig !== void 0 || a.skills.length > 0 || a.commands.length > 0 || a.agents.length > 0 || a.hooks.length > 0;
+var hasAnyCopilotArtifact = (a) => a.copilotInstructions !== void 0;
+var hasAnyCodexArtifact = (a) => a.agentsMd !== void 0 || a.skills.length > 0;
+
+// src/integration/ai/readiness/claude/probe.ts
+var claudeProbe = {
+  tool: "claude-code",
+  async evaluate(repository, now) {
+    const root = repository.path;
+    const claudeMd = await probeFile(join8(root, "CLAUDE.md"));
+    if (!claudeMd.ok) return Result.error(claudeMd.error);
+    const agentsMd = await probeFile(join8(root, "AGENTS.md"));
+    if (!agentsMd.ok) return Result.error(agentsMd.error);
+    const settings = await probeFile(join8(root, ".claude/settings.json"));
+    if (!settings.ok) return Result.error(settings.error);
+    const settingsLocal = await probeFile(join8(root, ".claude/settings.local.json"));
+    if (!settingsLocal.ok) return Result.error(settingsLocal.error);
+    const mcpConfig = await probeFile(join8(root, ".mcp.json"));
+    if (!mcpConfig.ok) return Result.error(mcpConfig.error);
+    const skills = await probeNamedDirCollection(join8(root, ".claude/skills"), "SKILL.md");
+    if (!skills.ok) return Result.error(skills.error);
+    const commands = await probeNamedFileCollection(join8(root, ".claude/commands"));
+    if (!commands.ok) return Result.error(commands.error);
+    const agents = await probeNamedFileCollection(join8(root, ".claude/agents"));
+    if (!agents.ok) return Result.error(agents.error);
+    const hooks = await readHooks([settings.value, settingsLocal.value]);
+    if (!hooks.ok) return Result.error(hooks.error);
+    const artifacts = {
+      tool: "claude-code",
+      ...claudeMd.value !== void 0 ? { claudeMd: claudeMd.value } : {},
+      ...agentsMd.value !== void 0 ? { agentsMd: agentsMd.value } : {},
+      ...settings.value !== void 0 ? { settings: settings.value } : {},
+      ...settingsLocal.value !== void 0 ? { settingsLocal: settingsLocal.value } : {},
+      ...mcpConfig.value !== void 0 ? { mcpConfig: mcpConfig.value } : {},
+      skills: skills.value,
+      commands: commands.value,
+      agents: agents.value,
+      hooks: hooks.value
+    };
+    return Result.ok(hasAnyClaudeArtifact(artifacts) ? presentState(now, artifacts) : absentState(now));
+  }
+};
 var readHooks = async (settingsRefs) => {
   const hooks = [];
   for (const ref2 of settingsRefs) {
@@ -4084,19 +4154,6 @@ var readHooks = async (settingsRefs) => {
   }
   return Result.ok(hooks);
 };
-var readFileSafely = async (path) => {
-  try {
-    return Result.ok(await fs8.readFile(path, "utf8"));
-  } catch (cause) {
-    if (isNodeErrnoCode3(cause, "ENOENT")) return Result.ok(void 0);
-    if (isNodeErrnoCode3(cause, "EACCES")) {
-      return Result.error(
-        new ProbeError({ subCode: "fs-permission", message: `permission denied reading ${path}`, path, cause })
-      );
-    }
-    return Result.error(new ProbeError({ subCode: "fs-read", message: `failed to read ${path}`, path, cause }));
-  }
-};
 var extractHooks = (settings, sink) => {
   if (typeof settings !== "object" || settings === null) return;
   const hooks = settings.hooks;
@@ -4117,33 +4174,41 @@ var extractHooks = (settings, sink) => {
     }
   }
 };
-var isNodeErrnoCode3 = (cause, code) => typeof cause === "object" && cause !== null && cause.code === code;
 
 // src/integration/ai/readiness/codex/probe.ts
+import { join as join9 } from "path";
 var codexProbe = {
   tool: "codex",
-  evaluate(repository, now) {
-    void repository;
-    void now;
-    return Promise.resolve(Result.ok(unknownState));
+  async evaluate(repository, now) {
+    const root = repository.path;
+    const agentsMd = await probeFile(join9(root, "AGENTS.md"));
+    if (!agentsMd.ok) return Result.error(agentsMd.error);
+    const skills = await probeNamedDirCollection(join9(root, ".agents/skills"), "SKILL.md");
+    if (!skills.ok) return Result.error(skills.error);
+    const artifacts = {
+      tool: "codex",
+      ...agentsMd.value !== void 0 ? { agentsMd: agentsMd.value } : {},
+      skills: skills.value
+    };
+    return Result.ok(hasAnyCodexArtifact(artifacts) ? presentState(now, artifacts) : absentState(now));
   }
 };
 
 // src/integration/ai/readiness/copilot/probe.ts
 import { promises as fs9 } from "fs";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 var copilotProbe = {
   tool: "copilot",
   async evaluate(repository, now) {
-    const path = join8(repository.path, ".github/copilot-instructions.md");
+    const path = join10(repository.path, ".github/copilot-instructions.md");
     try {
       const stat = await fs9.stat(path);
       if (!stat.isFile()) return Result.ok(absentState(now));
       const artifacts = { tool: "copilot", copilotInstructions: { path } };
       return Result.ok(hasAnyCopilotArtifact(artifacts) ? presentState(now, artifacts) : absentState(now));
     } catch (cause) {
-      if (isNodeErrnoCode4(cause, "ENOENT")) return Result.ok(absentState(now));
-      if (isNodeErrnoCode4(cause, "EACCES")) {
+      if (isNodeErrnoCode(cause, "ENOENT")) return Result.ok(absentState(now));
+      if (isNodeErrnoCode(cause, "EACCES")) {
         return Result.error(
           new ProbeError({ subCode: "fs-permission", message: `permission denied reading ${path}`, path, cause })
         );
@@ -4152,7 +4217,6 @@ var copilotProbe = {
     }
   }
 };
-var isNodeErrnoCode4 = (cause, code) => typeof cause === "object" && cause !== null && cause.code === code;
 
 // src/integration/observability/in-memory-event-bus.ts
 var createInMemoryEventBus = () => {
@@ -4200,7 +4264,7 @@ var loggerForScope = (deps, scope) => {
 };
 
 // src/integration/version/npm-version-checker.ts
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 import { z as z15 } from "zod";
 
 // src/business/version/version-check.ts
@@ -4242,7 +4306,7 @@ var buildVersionCheck = (current, latest, now) => ({
 var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1e3;
 var DEFAULT_FETCH_TIMEOUT_MS = 3e3;
 var RegistryPayloadSchema = z15.object({ version: z15.string() });
-var cachePath = (stateRoot) => join9(String(stateRoot), "version-check.json");
+var cachePath = (stateRoot) => join11(String(stateRoot), "version-check.json");
 var registryUrl = (packageName) => `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
 var shouldSkip = (env) => env["NO_NETWORK"] !== void 0 || env["VITEST"] !== void 0;
 var readCache = async (path) => {
@@ -4296,7 +4360,7 @@ var createNpmVersionChecker = (deps) => {
 // package.json
 var package_default = {
   name: "ralphctl",
-  version: "0.7.0",
+  version: "0.7.2",
   description: "Agent harness for long-running AI coding tasks \u2014 orchestrates Claude Code & GitHub Copilot across repositories",
   homepage: "https://github.com/lukas-grigis/ralphctl",
   type: "module",
@@ -4398,11 +4462,11 @@ var CLI_METADATA = {
 // src/integration/ai/skills/_engine/filesystem-skills-adapter.ts
 import { existsSync } from "fs";
 import { mkdir, rm, rmdir, writeFile } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 
 // src/integration/io/git-exclude.ts
 import { promises as fs10 } from "fs";
-import { isAbsolute as isAbsolute2, join as join10 } from "path";
+import { isAbsolute as isAbsolute2, join as join12 } from "path";
 var ensureGitExcludeWildcard = async (repoRoot, pattern) => {
   const resolved = await resolveExcludePath(String(repoRoot));
   if (resolved === void 0) return Result.ok(void 0);
@@ -4410,7 +4474,7 @@ var ensureGitExcludeWildcard = async (repoRoot, pattern) => {
   try {
     existing = await fs10.readFile(resolved, "utf8");
   } catch (cause) {
-    if (isNodeErrnoCode5(cause, "ENOENT")) {
+    if (isNodeErrnoCode3(cause, "ENOENT")) {
     } else {
       return Result.error(
         new StorageError({
@@ -4431,16 +4495,16 @@ var ensureGitExcludeWildcard = async (repoRoot, pattern) => {
   return writeTextAtomic(resolved, next);
 };
 var resolveExcludePath = async (repoRoot) => {
-  const gitMarker = join10(repoRoot, ".git");
+  const gitMarker = join12(repoRoot, ".git");
   let stat;
   try {
     stat = await fs10.stat(gitMarker);
   } catch (cause) {
-    if (isNodeErrnoCode5(cause, "ENOENT") || isNodeErrnoCode5(cause, "ENOTDIR")) return void 0;
+    if (isNodeErrnoCode3(cause, "ENOENT") || isNodeErrnoCode3(cause, "ENOTDIR")) return void 0;
     throw cause;
   }
   if (stat.isDirectory()) {
-    return join10(gitMarker, "info", "exclude");
+    return join12(gitMarker, "info", "exclude");
   }
   if (!stat.isFile()) return void 0;
   let pointer;
@@ -4452,10 +4516,10 @@ var resolveExcludePath = async (repoRoot) => {
   const match = /^gitdir:\s*(.+)\s*$/m.exec(pointer);
   if (match === null) return void 0;
   const gitdir = match[1].trim();
-  const absoluteGitdir = isAbsolute2(gitdir) ? gitdir : join10(repoRoot, gitdir);
-  return join10(absoluteGitdir, "info", "exclude");
+  const absoluteGitdir = isAbsolute2(gitdir) ? gitdir : join12(repoRoot, gitdir);
+  return join12(absoluteGitdir, "info", "exclude");
 };
-var isNodeErrnoCode5 = (cause, code) => typeof cause === "object" && cause !== null && cause.code === code;
+var isNodeErrnoCode3 = (cause, code) => typeof cause === "object" && cause !== null && cause.code === code;
 
 // src/integration/ai/skills/_engine/filesystem-skills-adapter.ts
 var renderSkill = (skill) => {
@@ -4478,7 +4542,7 @@ var tryRmdirIfEmpty = async (path) => {
 var createFilesystemSkillsAdapter = (deps) => {
   const installed = /* @__PURE__ */ new Map();
   const excludeAttempted = /* @__PURE__ */ new Set();
-  const skillsSubdir = join11(deps.parentDir, "skills");
+  const skillsSubdir = join13(deps.parentDir, "skills");
   const excludePattern = `${skillsSubdir}/ralphctl-*`;
   const pruneStale = () => {
     for (const key of [...installed.keys()]) {
@@ -4488,14 +4552,14 @@ var createFilesystemSkillsAdapter = (deps) => {
   return {
     async install(sessionDir, skills) {
       pruneStale();
-      const skillsDir = join11(String(sessionDir), skillsSubdir);
+      const skillsDir = join13(String(sessionDir), skillsSubdir);
       const tracked = installed.get(String(sessionDir)) ?? /* @__PURE__ */ new Set();
       for (const skill of skills) {
-        const dst = join11(skillsDir, skill.name);
+        const dst = join13(skillsDir, skill.name);
         if (existsSync(dst)) continue;
         try {
           await mkdir(dst, { recursive: true });
-          await writeFile(join11(dst, "SKILL.md"), renderSkill(skill), "utf-8");
+          await writeFile(join13(dst, "SKILL.md"), renderSkill(skill), "utf-8");
           tracked.add(skill.name);
         } catch (cause) {
           if (tracked.size > 0) installed.set(String(sessionDir), tracked);
@@ -4526,10 +4590,10 @@ var createFilesystemSkillsAdapter = (deps) => {
       const key = String(sessionDir);
       const tracked = installed.get(key);
       if (tracked === void 0 || tracked.size === 0) return Result.ok(void 0);
-      const skillsDir = join11(key, skillsSubdir);
+      const skillsDir = join13(key, skillsSubdir);
       try {
         for (const id of tracked) {
-          await rm(join11(skillsDir, id), { recursive: true, force: true });
+          await rm(join13(skillsDir, id), { recursive: true, force: true });
         }
         installed.delete(key);
       } catch (cause) {
@@ -4543,7 +4607,7 @@ var createFilesystemSkillsAdapter = (deps) => {
         );
       }
       await tryRmdirIfEmpty(skillsDir);
-      await tryRmdirIfEmpty(join11(key, deps.parentDir));
+      await tryRmdirIfEmpty(join13(key, deps.parentDir));
       return Result.ok(void 0);
     }
   };
@@ -4605,7 +4669,7 @@ var createSkillsAdapter = (deps) => {
 };
 
 // src/integration/ai/skills/bundled/source.ts
-import { dirname as dirname6, join as join12 } from "path";
+import { dirname as dirname7, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { readFile } from "fs/promises";
 
@@ -4632,9 +4696,9 @@ var skillsForFlow = (flowId) => FLOW_SKILLS[flowId];
 
 // src/integration/ai/skills/bundled/source.ts
 var defaultBundledRoot = (() => {
-  const here = dirname6(fileURLToPath2(import.meta.url));
+  const here = dirname7(fileURLToPath2(import.meta.url));
   const isBundled = import.meta.url.endsWith("/cli.mjs") || import.meta.url.endsWith("\\cli.mjs");
-  return isBundled ? join12(here, "skills") : here;
+  return isBundled ? join14(here, "skills") : here;
 })();
 var splitFrontmatter = (raw) => {
   const trimmed = raw.replace(/^\uFEFF/u, "");
@@ -4662,7 +4726,7 @@ var parseSimpleYaml = (input) => {
   return result;
 };
 var readSkill = async (root, name) => {
-  const path = join12(root, name, "SKILL.md");
+  const path = join14(root, name, "SKILL.md");
   let raw;
   try {
     raw = await readFile(path, "utf-8");
@@ -5652,13 +5716,13 @@ var probeGitConfig = async (id, label, key, runCommand2, hint) => {
   }
   return { id, label, status: "warn", detail: `${key} not set`, hint, group: "vcs" };
 };
-var probeCliAuth = async (id, label, binary, args, hint, runCommand2) => {
+var probeCliAuth = async (id, label, binary, args, hint, runCommand2, group = "vcs") => {
   const r = await runCommand2(binary, args);
   if (r.ok) {
-    return { id, label, status: "pass", detail: "authenticated", group: "vcs" };
+    return { id, label, status: "pass", detail: "authenticated", group };
   }
   const detail = r.stderr.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "not authenticated";
-  return { id, label, status: "warn", detail, hint, group: "vcs" };
+  return { id, label, status: "warn", detail, hint, group };
 };
 var createDoctorFlow = (deps) => leaf("doctor", {
   useCase: {
@@ -5770,6 +5834,7 @@ var createDoctorFlow = (deps) => leaf("doctor", {
       }
       const settings = await deps.settingsRepo.load();
       const configuredProvider = settings.ok ? settings.value.ai.provider : void 0;
+      let codexInstalled = false;
       for (const provider of Object.keys(PROVIDER_BINARY)) {
         const binary = PROVIDER_BINARY[provider];
         const isConfigured = provider === configuredProvider;
@@ -5781,12 +5846,26 @@ var createDoctorFlow = (deps) => leaf("doctor", {
           deps.commandExists,
           `install the '${binary}' CLI and ensure it is on your PATH`
         );
+        if (provider === "openai-codex") codexInstalled = probe.status === "pass";
         if (probe.status === "fail") {
           probes.push({ ...probe, status: "warn" });
         } else {
           probes.push(probe);
         }
       }
+      if (configuredProvider === "openai-codex" && codexInstalled) {
+        probes.push(
+          await probeCliAuth(
+            "codex-auth",
+            "OpenAI Codex CLI authenticated",
+            "codex",
+            ["login", "status"],
+            "run `codex login` to sign in",
+            deps.runCommand,
+            "ai"
+          )
+        );
+      }
       const projects = await deps.projectRepo.list();
       probes.push({
         id: "projects-list",
@@ -9129,14 +9208,14 @@ var launchAddTickets = (ctx) => {
 };
 
 // src/application/ui/shared/launch/refine.ts
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 
 // src/application/flows/refine/flow.ts
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 
 // src/application/flows/_shared/build-unit.ts
 import { promises as fs11 } from "fs";
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 var buildUnitLeaf = (opts) => leaf(opts.name, {
   useCase: {
     execute: async (input) => {
@@ -9157,7 +9236,7 @@ var buildUnitLeaf = (opts) => leaf(opts.name, {
       return Result.ok(parsed.value);
     }
   },
-  input: (ctx) => ({ path: join13(String(opts.parent(ctx)), opts.slug(ctx)) }),
+  input: (ctx) => ({ path: join15(String(opts.parent(ctx)), opts.slug(ctx)) }),
   output: (ctx, root) => opts.write(ctx, root)
 });
 
@@ -9350,7 +9429,7 @@ var refineTicketInteractiveLeaf = (deps, ticket) => leaf(`refine-ticket-${String
     execute: async (input) => {
       const session = await deps.runInTerminal(
         async () => deps.interactiveAi.run({
-          cwd: deps.cwd,
+          cwd: input.cwd,
           promptFile: input.promptFile,
           outputFile: input.outputFile,
           model: deps.model
@@ -9407,9 +9486,18 @@ var refineTicketInteractiveLeaf = (deps, ticket) => leaf(`refine-ticket-${String
         message: `refine-ticket-${String(ticket.id)}: prompt/output paths missing \u2014 render-prompt-to-file must run first`
       });
     }
+    if (ctx.currentUnitRoot === void 0) {
+      throw new InvalidStateError({
+        entity: "chain",
+        currentState: "pre-refine",
+        attemptedAction: `refine-ticket-${String(ticket.id)}`,
+        message: `refine-ticket-${String(ticket.id)}: unit root missing \u2014 build-refine-unit must run first`
+      });
+    }
     return {
       sprint: ctx.sprint,
       ticket,
+      cwd: ctx.currentUnitRoot,
       promptFile: ctx.currentPromptFile,
       outputFile: ctx.currentOutputFile
     };
@@ -9610,8 +9698,8 @@ var createRefineFlow = (deps, opts) => {
         parent: () => opts.refinementRoot,
         slug: () => ticketSlug(ticket),
         write: (ctx, root) => {
-          const promptPath = AbsolutePath.parse(join14(String(root), "prompt.md"));
-          const outputPath = AbsolutePath.parse(join14(String(root), "requirements.md"));
+          const promptPath = AbsolutePath.parse(join16(String(root), "prompt.md"));
+          const outputPath = AbsolutePath.parse(join16(String(root), "requirements.md"));
           if (!promptPath.ok || !outputPath.ok) {
             throw promptPath.ok ? outputPath.ok ? new Error("unreachable") : outputPath.error : promptPath.error;
           }
@@ -9648,9 +9736,17 @@ var createRefineFlow = (deps, opts) => {
         {
           name: `install-skills-${String(ticket.id)}`,
           flowId: "refine",
-          // Skills land in the AI session's cwd (the repo) — the provider-native conventions
-          // only auto-discover skills from cwd, not from `--add-dir` roots.
-          cwdPicker: () => opts.cwd
+          // Skills land in the AI session's cwd — for refine that's the per-ticket unit root
+          // (`<sprintDir>/refinement/<ticket-slug>/`), not the user's repo. Refinement is
+          // implementation-agnostic, so we keep the AI out of the repo's auto-discovered context.
+          cwdPicker: (ctx) => {
+            if (ctx.currentUnitRoot === void 0) {
+              throw new Error(
+                `install-skills-${String(ticket.id)}: currentUnitRoot missing \u2014 build-refine-unit must run first`
+              );
+            }
+            return ctx.currentUnitRoot;
+          }
         }
       ),
       refineTicketInteractiveLeaf(
@@ -9658,7 +9754,6 @@ var createRefineFlow = (deps, opts) => {
           interactiveAi: deps.interactiveAi,
           runInTerminal: deps.runInTerminal,
           logger: deps.logger,
-          cwd: opts.cwd,
           model: opts.model,
           ...deps.reviewBeforeApprove !== void 0 ? { reviewBeforeApprove: deps.reviewBeforeApprove } : {},
           ...deps.issuePusher !== void 0 ? { issuePusher: deps.issuePusher } : {},
@@ -9668,7 +9763,17 @@ var createRefineFlow = (deps, opts) => {
       ),
       uninstallSkillsLeaf(
         { skillsAdapter: deps.skillsAdapter },
-        { name: `uninstall-skills-${String(ticket.id)}`, cwdPicker: () => opts.cwd }
+        {
+          name: `uninstall-skills-${String(ticket.id)}`,
+          cwdPicker: (ctx) => {
+            if (ctx.currentUnitRoot === void 0) {
+              throw new Error(
+                `uninstall-skills-${String(ticket.id)}: currentUnitRoot missing \u2014 build-refine-unit must run first`
+              );
+            }
+            return ctx.currentUnitRoot;
+          }
+        }
       ),
       saveSprintLeaf({ sprintRepo: deps.sprintRepo }, `save-after-${String(ticket.id)}`)
     ])
@@ -9691,12 +9796,11 @@ var deriveOriginFromGit = async (cwd, gitRunner) => {
   return parsed === null ? void 0 : parsed;
 };
 var launchRefine = async (ctx) => {
-  const { deps, snapshot, extras, settings, interactiveAi, skillsAdapter, skillSource, cwd, bridge, sessionId: sessionId2 } = ctx;
+  const { deps, snapshot, extras, settings, interactiveAi, skillsAdapter, skillSource, bridge, sessionId: sessionId2 } = ctx;
   if (!snapshot.sprint) return { ok: false, reason: "No sprint selected." };
-  if (!cwd) return { ok: false, reason: "No repository path resolvable from the project." };
   const pending = snapshot.sprint.tickets.filter((t) => t.status === "pending");
   const refinementRoot = AbsolutePath.parse(
-    join15(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "refinement")
+    join17(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "refinement")
   );
   if (!refinementRoot.ok) return { ok: false, reason: refinementRoot.error.message };
   let defaultIssueOrigin = snapshot.project?.defaultIssueOrigin;
@@ -9756,7 +9860,6 @@ ${body.trim()}`;
     {
       sprintId: snapshot.sprint.id,
       pendingTickets: pending,
-      cwd,
       model: extras.modelOverride ?? settings.ai.models.refine,
       refinementRoot: refinementRoot.value
     }
@@ -9770,10 +9873,10 @@ ${body.trim()}`;
 };
 
 // src/application/ui/shared/launch/plan.ts
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 
 // src/application/flows/plan/flow.ts
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 
 // src/application/flows/_shared/sprint/load-execution.ts
 var loadSprintExecutionLeaf = (deps, name = "load-sprint-execution") => leaf(name, {
@@ -10214,6 +10317,13 @@ var markTaskBlocked = (task, reason) => {
   if (!guard2.ok) return Result.error(guard2.error);
   return Result.ok({ ...guard2.value, status: "blocked", blockedReason: reason });
 };
+var unblockTask = (task) => {
+  const guard2 = requireStatus("task", task, ["blocked"], "unblock");
+  if (!guard2.ok) return Result.error(guard2.error);
+  const { blockedReason: _ignored, ...rest } = guard2.value;
+  void _ignored;
+  return Result.ok({ ...rest, status: "todo" });
+};
 var latestCritique = (task) => {
   for (let i = task.attempts.length - 1; i >= 0; i--) {
     const att = task.attempts[i];
@@ -10394,7 +10504,7 @@ var callPlannerInteractiveLeaf = (deps) => leaf("call-planner-interactive", {
       const additionalRoots = deps.additionalRoots ?? [];
       const session = await deps.runInTerminal(
         async () => deps.interactiveAi.run({
-          cwd: deps.cwd,
+          cwd: input.cwd,
           promptFile: input.promptFile,
           outputFile: input.outputFile,
           model: deps.model,
@@ -10471,10 +10581,19 @@ var callPlannerInteractiveLeaf = (deps) => leaf("call-planner-interactive", {
         message: "call-planner-interactive: prompt/output paths missing \u2014 render-prompt-to-file must run first"
       });
     }
+    if (ctx.currentUnitRoot === void 0) {
+      throw new InvalidStateError({
+        entity: "chain",
+        currentState: "pre-plan",
+        attemptedAction: "call-planner-interactive",
+        message: "call-planner-interactive: unit root missing \u2014 build-plan-unit must run first"
+      });
+    }
     return {
       sprint: ctx.sprint,
       project: ctx.project,
       existingTasks: ctx.tasks ?? [],
+      cwd: ctx.currentUnitRoot,
       promptFile: ctx.currentPromptFile,
       outputFile: ctx.currentOutputFile
     };
@@ -10498,8 +10617,8 @@ var createPlanFlow = (deps, opts) => {
       parent: () => opts.planRoot,
       slug: () => slug,
       write: (ctx, root) => {
-        const promptPath = AbsolutePath.parse(join16(String(root), "prompt.md"));
-        const outputPath = AbsolutePath.parse(join16(String(root), "plan.json"));
+        const promptPath = AbsolutePath.parse(join18(String(root), "prompt.md"));
+        const outputPath = AbsolutePath.parse(join18(String(root), "plan.json"));
         if (!promptPath.ok) throw promptPath.error;
         if (!outputPath.ok) throw outputPath.error;
         return {
@@ -10536,9 +10655,21 @@ var createPlanFlow = (deps, opts) => {
       { skillsAdapter: deps.skillsAdapter, skillSource: deps.skillSource },
       {
         flowId: "plan",
-        // Skills land in the AI session's cwd (the repo) — the provider-native conventions
-        // only auto-discover skills from cwd, not from `--add-dir` roots.
-        cwdPicker: () => opts.cwd
+        // Skills land in the AI session's cwd — for plan that's the per-sprint plan unit root
+        // (`<sprintDir>/plan/<run-slug>/`), not any project repo. Plan mounts every repo as an
+        // equal `--add-dir` source; rooting the session in any one repo would auto-load that
+        // repo's `CLAUDE.md` / agents / `.mcp.json` and bias the planner toward it.
+        cwdPicker: (ctx) => {
+          if (ctx.currentUnitRoot === void 0) {
+            throw new InvalidStateError({
+              entity: "chain",
+              currentState: "pre-plan",
+              attemptedAction: "install-skills",
+              message: "install-skills: currentUnitRoot missing \u2014 build-plan-unit must run first"
+            });
+          }
+          return ctx.currentUnitRoot;
+        }
       }
     ),
     callPlannerInteractiveLeaf({
@@ -10546,12 +10677,26 @@ var createPlanFlow = (deps, opts) => {
       runInTerminal: deps.runInTerminal,
       logger: deps.logger,
       clock: deps.clock,
-      cwd: opts.cwd,
       model: opts.model,
       ...opts.additionalRoots !== void 0 && opts.additionalRoots.length > 0 ? { additionalRoots: opts.additionalRoots } : {},
       ...deps.reviewBeforeApprove !== void 0 ? { reviewBeforeApprove: deps.reviewBeforeApprove } : {}
     }),
-    uninstallSkillsLeaf({ skillsAdapter: deps.skillsAdapter }, { cwdPicker: () => opts.cwd }),
+    uninstallSkillsLeaf(
+      { skillsAdapter: deps.skillsAdapter },
+      {
+        cwdPicker: (ctx) => {
+          if (ctx.currentUnitRoot === void 0) {
+            throw new InvalidStateError({
+              entity: "chain",
+              currentState: "pre-plan",
+              attemptedAction: "uninstall-skills",
+              message: "uninstall-skills: currentUnitRoot missing \u2014 build-plan-unit must run first"
+            });
+          }
+          return ctx.currentUnitRoot;
+        }
+      }
+    ),
     saveTasksLeaf({ taskRepo: deps.taskRepo }),
     saveSprintLeaf({ sprintRepo: deps.sprintRepo })
   ]);
@@ -10559,12 +10704,11 @@ var createPlanFlow = (deps, opts) => {
 
 // src/application/ui/shared/launch/plan.ts
 var launchPlan = (ctx) => {
-  const { deps, snapshot, extras, settings, interactiveAi, skillsAdapter, skillSource, cwd, bridge, sessionId: sessionId2 } = ctx;
+  const { deps, snapshot, extras, settings, interactiveAi, skillsAdapter, skillSource, bridge, sessionId: sessionId2 } = ctx;
   if (!snapshot.project) return { ok: false, reason: "No project loaded." };
   if (!snapshot.sprint) return { ok: false, reason: "No sprint selected." };
-  if (!cwd) return { ok: false, reason: "No repository path resolvable from the project." };
   const planRoot = AbsolutePath.parse(
-    join17(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "plan")
+    join19(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "plan")
   );
   if (!planRoot.ok) return { ok: false, reason: planRoot.error.message };
   const reviewBeforeApprove = async (proposedTasks) => {
@@ -10601,9 +10745,9 @@ ${summary}`;
     {
       sprintId: snapshot.sprint.id,
       projectId: snapshot.project.id,
-      cwd,
-      // Mount every repo on the project so the planner can navigate across them without per-file
-      // approval prompts. Duplicates with `cwd` are folded out by the adapter.
+      // Mount every repo on the project as an equal `--add-dir` source so the planner can
+      // navigate across them without per-file approval prompts. No repo enjoys cwd privilege —
+      // the session's cwd is the per-sprint plan unit root.
       additionalRoots: snapshot.project.repositories.map((r) => r.path),
       model: extras.modelOverride ?? settings.ai.models.plan,
       planRoot: planRoot.value
@@ -10618,7 +10762,7 @@ ${summary}`;
 };
 
 // src/application/ui/shared/launch/implement.ts
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 
 // src/application/chain/build/guard.ts
 var guard = (name, predicate, body) => ({
@@ -10675,7 +10819,7 @@ var loop = (name, body, opts = {}) => ({
 
 // src/integration/observability/sinks/progress-file-sink.ts
 import { promises as fs14 } from "fs";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 var MAX_QUEUE_DEPTH = 1e4;
 var createProgressFileSink = (deps) => {
   const queue = [];
@@ -10795,7 +10939,7 @@ var TEMPLATE = `${TITLE}
 ${HEADINGS.map((h) => `## ${h}
 `).join("\n")}`;
 var mergeSection = async (path, rendered) => {
-  await fs14.mkdir(dirname7(path), { recursive: true });
+  await fs14.mkdir(dirname8(path), { recursive: true });
   let current;
   try {
     current = await fs14.readFile(path, "utf8");
@@ -11017,6 +11161,45 @@ var gitCommitWithMessage = async (runner, cwd, message) => {
   if (!head.ok) return Result.error(head.error);
   return Result.ok({ committed: true, headSha: head.value });
 };
+var gitStashPush = async (runner, cwd, message) => {
+  const dirty = await gitHasUncommittedChanges(runner, cwd);
+  if (!dirty.ok) return Result.error(dirty.error);
+  if (!dirty.value) return Result.ok({ stashed: false });
+  const stash = await runner.run(cwd, ["stash", "push", "-u", "-m", message]);
+  if (!stash.ok) return Result.error(stash.error);
+  if (stash.value.exitCode !== 0) {
+    return Result.error(
+      new StorageError({
+        subCode: "io",
+        message: `git stash push failed: ${(stash.value.stderr || stash.value.stdout).trim()}`
+      })
+    );
+  }
+  return Result.ok({ stashed: true });
+};
+var gitResetHard = async (runner, cwd) => {
+  const reset = await runner.run(cwd, ["reset", "--hard", "HEAD"]);
+  if (!reset.ok) return Result.error(reset.error);
+  if (reset.value.exitCode !== 0) {
+    return Result.error(
+      new StorageError({
+        subCode: "io",
+        message: `git reset --hard failed: ${(reset.value.stderr || reset.value.stdout).trim()}`
+      })
+    );
+  }
+  const clean = await runner.run(cwd, ["clean", "-fd"]);
+  if (!clean.ok) return Result.error(clean.error);
+  if (clean.value.exitCode !== 0) {
+    return Result.error(
+      new StorageError({
+        subCode: "io",
+        message: `git clean -fd failed: ${(clean.value.stderr || clean.value.stdout).trim()}`
+      })
+    );
+  }
+  return Result.ok(void 0);
+};
 var gitGetCurrentBranch = async (runner, cwd) => {
   const result = await runner.run(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!result.ok) return Result.error(result.error);
@@ -11492,9 +11675,9 @@ var implementSession = (sandboxCwd, repoPath, prompt, model, signalsFile) => ({
 });
 
 // src/application/flows/implement/leaves/round-artifacts.ts
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 var nextRoundNum = async (workspaceRoot) => {
-  const entries = await listDir(join18(String(workspaceRoot), "rounds"));
+  const entries = await listDir(join20(String(workspaceRoot), "rounds"));
   if (!entries.ok) return 1;
   let max = 0;
   for (const name of entries.value) {
@@ -11503,12 +11686,12 @@ var nextRoundNum = async (workspaceRoot) => {
   }
   return max + 1;
 };
-var roundSignalsPath = (workspaceRoot, round, role) => join18(String(workspaceRoot), "rounds", String(round), role, "signals.json");
-var roundEvaluationRelativePath = (round) => join18("rounds", String(round), "evaluator", "evaluation.md");
-var roundDir = (workspaceRoot, round, role) => join18(String(workspaceRoot), "rounds", String(round), role);
+var roundSignalsPath = (workspaceRoot, round, role) => join20(String(workspaceRoot), "rounds", String(round), role, "signals.json");
+var roundEvaluationRelativePath = (round) => join20("rounds", String(round), "evaluator", "evaluation.md");
+var roundDir = (workspaceRoot, round, role) => join20(String(workspaceRoot), "rounds", String(round), role);
 var writeEvaluatorRoundArtifacts = async (workspaceRoot, round, signals, logger) => {
   const base = roundDir(workspaceRoot, round, "evaluator");
-  const evaluation = await writeTextAtomic(join18(base, "evaluation.md"), renderEvaluation(findEvaluation2(signals)));
+  const evaluation = await writeTextAtomic(join20(base, "evaluation.md"), renderEvaluation(findEvaluation2(signals)));
   if (!evaluation.ok) {
     logger?.warn("failed to write evaluator round artifact", { round, base, error: evaluation.error.message });
   }
@@ -12015,6 +12198,7 @@ var postTaskCheckLeaf = (deps, opts, taskId) => {
 };
 
 // src/business/task/preflight-task.ts
+var ELEMENT_NAME = "preflight-task";
 var preflightTaskUseCase = async (props) => {
   const log = props.logger.named("task.preflight");
   log.debug("checking working tree", { cwd: props.cwd });
@@ -12035,6 +12219,9 @@ var preflightTaskUseCase = async (props) => {
     });
     return Result.ok(void 0);
   }
+  if (policy === "prompt") {
+    return resolveViaPrompt(props, count.value);
+  }
   log.warn("refusing to start a task on a dirty tree", { cwd: props.cwd, dirtyEntries: count.value });
   return Result.error(
     new InvalidStateError({
@@ -12046,24 +12233,105 @@ var preflightTaskUseCase = async (props) => {
     })
   );
 };
+var resolveViaPrompt = async (props, dirtyEntries) => {
+  const log = props.logger.named("task.preflight");
+  if (props.askDirtyTreeChoice === void 0 || props.gitStash === void 0 || props.gitReset === void 0 || props.clock === void 0) {
+    throw new InvalidStateError({
+      entity: ELEMENT_NAME,
+      currentState: "prompt-without-deps",
+      attemptedAction: "configure-prompt-deps",
+      message: "preflight-task: dirtyTreePolicy='prompt' requires askDirtyTreeChoice, gitStash, gitReset, and clock dependencies"
+    });
+  }
+  const choice = await props.askDirtyTreeChoice({ cwd: props.cwd, dirtyEntries });
+  if (!choice.ok) {
+    return Result.error(choice.error);
+  }
+  switch (choice.value) {
+    case "keep":
+      log.info(`working tree dirty (${String(dirtyEntries)} entries) \u2014 proceeding (user chose 'keep')`, {
+        cwd: props.cwd,
+        dirtyEntries
+      });
+      return Result.ok(void 0);
+    case "stash": {
+      const sprintLabel = props.sprintId !== void 0 && props.sprintId.length > 0 ? props.sprintId : "unknown";
+      const message = `ralphctl preflight stash (sprint ${sprintLabel}, ${String(props.clock())})`;
+      const stashed = await props.gitStash(props.cwd, message);
+      if (!stashed.ok) return Result.error(stashed.error);
+      if (!stashed.value.stashed) {
+        log.warn("stash reported no changes despite dirty status \u2014 proceeding", { cwd: props.cwd });
+        return Result.ok(void 0);
+      }
+      log.info(`stashed working tree \u2014 recoverable as: ${message}`, { cwd: props.cwd, stashMessage: message });
+      return Result.ok(void 0);
+    }
+    case "reset": {
+      const reset = await props.gitReset(props.cwd);
+      if (!reset.ok) return Result.error(reset.error);
+      log.info("reset working tree \u2014 discarded uncommitted + untracked changes", { cwd: props.cwd });
+      return Result.ok(void 0);
+    }
+    case "cancel":
+      return Result.error(
+        new AbortError({ elementName: ELEMENT_NAME, reason: "user cancelled on dirty working tree" })
+      );
+  }
+};
 
 // src/application/flows/implement/leaves/preflight-task.ts
+var ELEMENT_NAME2 = "preflight-task";
 var preflightTaskLeaf = (deps, cwd, name = "preflight-task") => {
   const gitStatusEntryCount = async (path) => {
     const status = await gitStatusPorcelain(deps.gitRunner, path);
     if (!status.ok) return status;
     return { ok: true, value: status.value.length };
   };
+  const gitStash = (path, message) => gitStashPush(deps.gitRunner, path, message);
+  const gitReset = (path) => gitResetHard(deps.gitRunner, path);
+  const askDirtyTreeChoice = async ({
+    cwd: dirtyCwd,
+    dirtyEntries
+  }) => {
+    const choice = await deps.interactive.askChoice(
+      `Working tree at ${String(dirtyCwd)} has ${String(dirtyEntries)} uncommitted change(s). How do you want to handle it?`,
+      [
+        {
+          label: "Keep changes \u2014 proceed on the dirty tree",
+          value: "keep",
+          description: "AI may build on / overwrite the pending diff"
+        },
+        { label: "Stash \u2014 save changes to a recoverable stash, then proceed", value: "stash" },
+        {
+          label: "Reset \u2014 discard all uncommitted + untracked changes, then proceed",
+          value: "reset",
+          description: "git reset --hard && git clean -fd"
+        },
+        { label: "Cancel \u2014 abort the implement run", value: "cancel" }
+      ]
+    );
+    if (!choice.ok) {
+      return Result.error(
+        new AbortError({ elementName: ELEMENT_NAME2, reason: `dirty-tree prompt cancelled \u2014 ${choice.error.message}` })
+      );
+    }
+    return Result.ok(choice.value);
+  };
   return leaf(name, {
     useCase: {
-      execute: async () => preflightTaskUseCase({
+      execute: async (input) => preflightTaskUseCase({
         cwd,
         gitStatusEntryCount,
+        gitStash,
+        gitReset,
+        askDirtyTreeChoice,
+        clock: deps.clock,
+        sprintId: input.sprintId,
         logger: deps.logger,
         ...deps.dirtyTreePolicy !== void 0 ? { dirtyTreePolicy: deps.dirtyTreePolicy } : {}
       })
     },
-    input: () => void 0,
+    input: (ctx) => ({ sprintId: String(ctx.sprintId) }),
     output: (ctx) => ctx
   });
 };
@@ -12547,7 +12815,7 @@ var startAttemptLeaf = (deps, taskId) => leaf(
 
 // src/application/flows/implement/leaves/build-task-workspace.ts
 import { promises as fs16 } from "fs";
-import { join as join19 } from "path";
+import { join as join21 } from "path";
 var renderDoneCriteria = (task) => {
   const header = `# Done criteria \u2014 ${task.name}
 
@@ -12580,7 +12848,7 @@ var buildTaskWorkspaceLeaf = (deps, opts, taskId) => leaf(`build-task-workspace-
   useCase: {
     execute: async (input) => {
       const log = deps.logger.named("implement.workspace");
-      const workspaceRoot = join19(String(opts.sprintDir), "implement", String(input.task.id));
+      const workspaceRoot = join21(String(opts.sprintDir), "implement", String(input.task.id));
       const prompt = await buildImplementPrompt(deps.templateLoader, {
         task: input.task,
         projectPath: String(opts.cwd),
@@ -12588,10 +12856,10 @@ var buildTaskWorkspaceLeaf = (deps, opts, taskId) => leaf(`build-task-workspace-
         ...opts.checkScript !== void 0 ? { checkScript: opts.checkScript } : {}
       });
       if (!prompt.ok) return Result.error(prompt.error);
-      const wrotePrompt = await writeOrError(join19(workspaceRoot, "prompt.md"), String(prompt.value));
+      const wrotePrompt = await writeOrError(join21(workspaceRoot, "prompt.md"), String(prompt.value));
       if (!wrotePrompt.ok) return Result.error(wrotePrompt.error);
       const wroteCriteria = await writeOrError(
-        join19(workspaceRoot, "done-criteria.md"),
+        join21(workspaceRoot, "done-criteria.md"),
         renderDoneCriteria(input.task)
       );
       if (!wroteCriteria.ok) return Result.error(wroteCriteria.error);
@@ -12662,15 +12930,20 @@ var transitionSprintToReviewLeaf = (deps) => leaf("transition-sprint-to-review",
 
 // src/integration/io/lock-paths.ts
 import { createHash } from "crypto";
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 var repoLockFile = (locksRoot, worktreePath) => {
   const hash = createHash("sha1").update(String(worktreePath)).digest("hex").slice(0, 16);
-  return AbsolutePath.parse(join20(String(locksRoot), `repo-${hash}.lock`));
+  return AbsolutePath.parse(join22(String(locksRoot), `repo-${hash}.lock`));
 };
 
 // src/application/flows/implement/leaves/with-repo-lock.ts
 var withRepoLock = (opts, inner) => ({
   name: `with-repo-lock(${inner.name})`,
+  // Expose the wrapped chain through the composite-pattern `children` slot so `flattenLeaves`
+  // walks into it when the TUI builds its planned-leaf list. Without this the wrapper looked
+  // like an opaque single leaf and the Flow-steps panel rendered only "with-repo-lock(…)" —
+  // never the real setup / per-task / teardown sequence inside the lock.
+  children: [inner],
   async execute(ctx, signal, onTrace) {
     const lockPath = repoLockFile(opts.locksRoot, opts.worktreePath);
     if (!lockPath.ok) {
@@ -12837,12 +13110,15 @@ var createImplementFlow = (deps, opts) => {
     path: r.path,
     ...r.setupScript !== void 0 ? { setupScript: r.setupScript } : {}
   }));
+  const dirtyTreePolicy = opts.dirtyTreePolicy ?? "prompt";
   const preflightLeaves = uniqueRepoCwds.map(
     (cwd, i) => preflightTaskLeaf(
       {
         gitRunner: deps.gitRunner,
+        interactive: deps.interactive,
+        clock: deps.clock,
         logger: deps.logger,
-        ...opts.dirtyTreePolicy !== void 0 ? { dirtyTreePolicy: opts.dirtyTreePolicy } : {}
+        dirtyTreePolicy
       },
       cwd,
       `preflight-task-${String(i + 1)}-${String(cwd)}`
@@ -12903,7 +13179,7 @@ var createImplementFlow = (deps, opts) => {
 
 // src/integration/observability/sinks/file-log-sink.ts
 import { promises as fs17 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 var startFileLogSink = (deps) => {
   const queue = [];
   let draining;
@@ -12915,7 +13191,7 @@ var startFileLogSink = (deps) => {
       if (next === void 0) continue;
       try {
         if (!dirEnsured) {
-          await fs17.mkdir(dirname8(String(deps.file)), { recursive: true });
+          await fs17.mkdir(dirname9(String(deps.file)), { recursive: true });
           dirEnsured = true;
         }
         await fs17.appendFile(String(deps.file), `${JSON.stringify(next)}
@@ -12957,11 +13233,11 @@ var launchImplement = (ctx) => {
     return a.status === "in_progress" ? -1 : 1;
   });
   if (todoTasks.length === 0) return { ok: false, reason: "No tasks to implement or resume." };
-  const sprintDirPath = AbsolutePath.parse(join21(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id)));
+  const sprintDirPath = AbsolutePath.parse(join23(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id)));
   if (!sprintDirPath.ok) return { ok: false, reason: sprintDirPath.error.message };
-  const progressPath = AbsolutePath.parse(join21(String(sprintDirPath.value), "progress.md"));
+  const progressPath = AbsolutePath.parse(join23(String(sprintDirPath.value), "progress.md"));
   if (!progressPath.ok) return { ok: false, reason: progressPath.error.message };
-  const chainLogPath = AbsolutePath.parse(join21(String(sprintDirPath.value), "chain.log"));
+  const chainLogPath = AbsolutePath.parse(join23(String(sprintDirPath.value), "chain.log"));
   if (!chainLogPath.ok) return { ok: false, reason: chainLogPath.error.message };
   const chainLog = startFileLogSink({ file: chainLogPath.value, bus: deps.app.eventBus });
   const repositories = /* @__PURE__ */ new Map();
@@ -13026,7 +13302,7 @@ var launchImplement = (ctx) => {
 };
 
 // src/application/ui/shared/launch/review.ts
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 
 // src/application/flows/review/leaves/ensure-feedback-file.ts
 import { promises as fs18 } from "fs";
@@ -13269,12 +13545,12 @@ var buildApplyFeedbackPrompt = async (deps, input) => buildPrompt(deps, applyFee
 
 // src/integration/ai/signals/_engine/temp-signals-file.ts
 import { tmpdir as tmpdir2 } from "os";
-import { join as join22 } from "path";
+import { join as join24 } from "path";
 var counter = 0;
 var allocSignalsTempPath = (label) => {
   counter += 1;
   const filename = `ralphctl-signals-${label}-${String(process.pid)}-${String(Date.now())}-${String(counter)}.json`;
-  return AbsolutePath.parse(join22(tmpdir2(), filename));
+  return AbsolutePath.parse(join24(tmpdir2(), filename));
 };
 var withSignalsTempPath = async (label, fn) => {
   const path = allocSignalsTempPath(label);
@@ -13533,11 +13809,11 @@ var launchReview = (ctx) => {
   if (!snapshot.sprint) return { ok: false, reason: "No sprint selected." };
   if (!cwd) return { ok: false, reason: "No repository path resolvable from the project." };
   const feedbackPath = AbsolutePath.parse(
-    join23(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "feedback.md")
+    join25(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "feedback.md")
   );
   if (!feedbackPath.ok) return { ok: false, reason: feedbackPath.error.message };
   const progressPath = AbsolutePath.parse(
-    join23(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "progress.md")
+    join25(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "progress.md")
   );
   if (!progressPath.ok) return { ok: false, reason: progressPath.error.message };
   const checkScript = snapshot.project?.repositories.find((r) => r.checkScript !== void 0)?.checkScript;
@@ -13766,11 +14042,11 @@ var probeReadinessLeaf = (deps) => leaf("probe", {
 import { promises as fs21 } from "fs";
 
 // src/integration/ai/readiness/_engine/setup.ts
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 
 // src/integration/ai/runs/_engine/run-artifacts.ts
 import { promises as fs20 } from "fs";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 var BODY_PREVIEW_LIMIT = 800;
 var buildRunDirName = () => {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -13780,7 +14056,7 @@ var buildRunDirName = () => {
 var readRunBodyPreview = async (runDir, options) => {
   let raw;
   try {
-    raw = await fs20.readFile(join24(String(runDir), "body.txt"), "utf8");
+    raw = await fs20.readFile(join26(String(runDir), "body.txt"), "utf8");
   } catch (cause) {
     if (isErrnoException(cause) && cause.code === "ENOENT") return void 0;
     const code = isErrnoException(cause) ? cause.code : "unknown";
@@ -13909,11 +14185,11 @@ var setupReadinessUseCase = async (deps, input) => {
     ...input.existingContextFile !== void 0 ? { existingContextFile: input.existingContextFile } : {}
   });
   if (!prompt.ok) return Result.error(prompt.error);
-  const runDir = AbsolutePath.parse(join25(String(deps.runsRoot), "readiness", buildRunDirName()));
+  const runDir = AbsolutePath.parse(join27(String(deps.runsRoot), "readiness", buildRunDirName()));
   if (!runDir.ok) return Result.error(runDir.error);
-  const promptFile = AbsolutePath.parse(join25(String(runDir.value), "prompt.md"));
+  const promptFile = AbsolutePath.parse(join27(String(runDir.value), "prompt.md"));
   if (!promptFile.ok) return Result.error(promptFile.error);
-  const bodyFile = AbsolutePath.parse(join25(String(runDir.value), "body.txt"));
+  const bodyFile = AbsolutePath.parse(join27(String(runDir.value), "body.txt"));
   if (!bodyFile.ok) return Result.error(bodyFile.error);
   const promptWrote = await writeTextAtomic(String(promptFile.value), String(prompt.value));
   if (!promptWrote.ok) return Result.error(promptWrote.error);
@@ -13962,7 +14238,7 @@ var setupReadinessUseCase = async (deps, input) => {
     const verifyScript = signals.value.find(
       (s) => s.type === "verify-script"
     )?.command;
-    const targetPath = AbsolutePath.parse(join25(String(input.repository.path), targetPathFor(input.tool)));
+    const targetPath = AbsolutePath.parse(join27(String(input.repository.path), targetPathFor(input.tool)));
     if (!targetPath.ok) return Result.error(targetPath.error);
     log.info(`proposal ready for repo ${input.repository.name}`, {
       repositoryId: String(input.repository.id),
@@ -14028,6 +14304,9 @@ var pickExistingContextPath = (tool, state) => {
   if (tool === "copilot" && a.tool === "copilot") {
     return a.copilotInstructions !== void 0 ? String(a.copilotInstructions.path) : void 0;
   }
+  if (tool === "codex" && a.tool === "codex") {
+    return a.agentsMd !== void 0 ? String(a.agentsMd.path) : void 0;
+  }
   return void 0;
 };
 var proposeReadinessLeaf = (deps) => leaf("propose", {
@@ -14208,7 +14487,7 @@ var launchReadiness = (ctx) => {
 };
 
 // src/application/flows/detect-skills/leaves/propose.ts
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 
 // src/integration/ai/prompts/detect-skills/definition.ts
 var detectSkillsPromptDef = {
@@ -14272,11 +14551,11 @@ var proposeUseCase = async (deps, input) => {
     skillsConvention: deps.skillsAdapter.describeSkillsConvention()
   });
   if (!prompt.ok) return Result.error(prompt.error);
-  const runDir = AbsolutePath.parse(join26(String(deps.runsRoot), "detect-skills", buildRunDirName()));
+  const runDir = AbsolutePath.parse(join28(String(deps.runsRoot), "detect-skills", buildRunDirName()));
   if (!runDir.ok) return Result.error(runDir.error);
-  const promptFile = AbsolutePath.parse(join26(String(runDir.value), "prompt.md"));
+  const promptFile = AbsolutePath.parse(join28(String(runDir.value), "prompt.md"));
   if (!promptFile.ok) return Result.error(promptFile.error);
-  const bodyFile = AbsolutePath.parse(join26(String(runDir.value), "body.txt"));
+  const bodyFile = AbsolutePath.parse(join28(String(runDir.value), "body.txt"));
   if (!bodyFile.ok) return Result.error(bodyFile.error);
   const promptWrote = await writeTextAtomic(String(promptFile.value), String(prompt.value));
   if (!promptWrote.ok) return Result.error(promptWrote.error);
@@ -14890,7 +15169,7 @@ var launchDetectSkills = (ctx) => {
 };
 
 // src/application/flows/detect-scripts/leaves/propose.ts
-import { join as join27 } from "path";
+import { join as join29 } from "path";
 
 // src/integration/ai/prompts/detect-scripts/definition.ts
 var detectScriptsPromptDef = {
@@ -14935,11 +15214,11 @@ var proposeUseCase2 = async (deps, input) => {
     repositoryPath: String(input.repository.path)
   });
   if (!prompt.ok) return Result.error(prompt.error);
-  const runDir = AbsolutePath.parse(join27(String(deps.runsRoot), "detect-scripts", buildRunDirName()));
+  const runDir = AbsolutePath.parse(join29(String(deps.runsRoot), "detect-scripts", buildRunDirName()));
   if (!runDir.ok) return Result.error(runDir.error);
-  const promptFile = AbsolutePath.parse(join27(String(runDir.value), "prompt.md"));
+  const promptFile = AbsolutePath.parse(join29(String(runDir.value), "prompt.md"));
   if (!promptFile.ok) return Result.error(promptFile.error);
-  const bodyFile = AbsolutePath.parse(join27(String(runDir.value), "body.txt"));
+  const bodyFile = AbsolutePath.parse(join29(String(runDir.value), "body.txt"));
   if (!bodyFile.ok) return Result.error(bodyFile.error);
   const promptWrote = await writeTextAtomic(String(promptFile.value), String(prompt.value));
   if (!promptWrote.ok) return Result.error(promptWrote.error);
@@ -15283,10 +15562,10 @@ var launchDetectScripts = (ctx) => {
 };
 
 // src/application/ui/shared/launch/ideate.ts
-import { join as join29 } from "path";
+import { join as join31 } from "path";
 
 // src/application/flows/ideate/flow.ts
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 
 // src/integration/ai/prompts/ideate/definition.ts
 var nonEmpty2 = (field) => (v) => v.trim().length === 0 ? Result.error(new ValidationError({ field, value: v, message: `${field} must not be empty` })) : Result.ok(v);
@@ -15523,8 +15802,8 @@ var createIdeateFlow = (deps, opts) => {
       parent: () => opts.ideateRoot,
       slug: () => slug,
       write: (ctx, root) => {
-        const promptPath = AbsolutePath.parse(join28(String(root), "prompt.md"));
-        const outputPath = AbsolutePath.parse(join28(String(root), "ideate.json"));
+        const promptPath = AbsolutePath.parse(join30(String(root), "prompt.md"));
+        const outputPath = AbsolutePath.parse(join30(String(root), "ideate.json"));
         if (!promptPath.ok) throw promptPath.error;
         if (!outputPath.ok) throw outputPath.error;
         return {
@@ -15588,7 +15867,7 @@ var launchIdeate = async (ctx) => {
   const bodyAns = await deps.interactive.askText("Idea description (paste or type)");
   if (!bodyAns.ok) return { ok: false, reason: bodyAns.error.message };
   const ideateRoot = AbsolutePath.parse(
-    join29(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "ideate")
+    join31(String(deps.storage.dataRoot), "sprints", String(snapshot.sprint.id), "ideate")
   );
   if (!ideateRoot.ok) return { ok: false, reason: ideateRoot.error.message };
   const element = createIdeateFlow(
@@ -16704,6 +16983,39 @@ var createTicketRemoveFlow = (deps) => leaf("ticket-remove", {
   output: (c, o) => ({ ...c, output: o })
 });
 
+// src/business/task/unblock-task.ts
+var unblockTaskUseCase = async (props) => {
+  const log = props.logger.named("task.unblock");
+  if (props.task.status === "todo") {
+    log.debug("already todo, skipping", { taskId: props.task.id, sprintId: props.sprintId });
+    return Result.ok(props.task);
+  }
+  log.debug("unblocking task", {
+    taskId: props.task.id,
+    sprintId: props.sprintId,
+    from: props.task.status
+  });
+  const transitioned = unblockTask(props.task);
+  if (!transitioned.ok) {
+    log.warn("invalid state transition", {
+      taskId: props.task.id,
+      from: props.task.status,
+      error: transitioned.error.message
+    });
+    return Result.error(transitioned.error);
+  }
+  const persisted = await props.taskRepo.update(props.sprintId, transitioned.value);
+  if (!persisted.ok) {
+    log.error("persist failed", { taskId: transitioned.value.id, error: persisted.error.message });
+    return Result.error(persisted.error);
+  }
+  log.info(`unblocked task '${transitioned.value.name}'`, {
+    taskId: transitioned.value.id,
+    sprintId: props.sprintId
+  });
+  return Result.ok(transitioned.value);
+};
+
 // src/application/ui/tui/views/sprint-detail-view.tsx
 import { jsx as jsx41, jsxs as jsxs30 } from "react/jsx-runtime";
 var buildFocusList = (sprint, tasks) => [
@@ -16772,12 +17084,15 @@ var SprintDetailView = () => {
   const [feedback, setFeedback] = useState25(void 0);
   const ticketsEditable = sprint?.status === "draft";
   const inDetail = openIdx !== void 0;
+  const focusedNow = focusList[Math.min(cursorIdx, Math.max(0, focusList.length - 1))];
+  const focusedBlockedTask = focusedNow?.kind === "task" && focusedNow.task.status === "blocked" ? focusedNow.task : void 0;
   useViewHints(
     inDetail ? [{ keys: "esc", label: "back to list" }] : [
       { keys: "n", label: "flows" },
       { keys: "\u21B5/o", label: "open" },
       { keys: "a", label: "add ticket" },
-      { keys: "d", label: "remove ticket" }
+      { keys: "d", label: "remove ticket" },
+      ...focusedBlockedTask !== void 0 ? [{ keys: "u", label: "unblock" }] : []
     ]
   );
   useInput14((input, key) => {
@@ -16805,6 +17120,10 @@ var SprintDetailView = () => {
     if (input === "d" && ticketsEditable) {
       const focused = focusList[Math.min(cursorIdx, focusList.length - 1)];
       if (focused?.kind === "ticket") setConfirmRemove(focused.ticket);
+      return;
+    }
+    if (input === "u" && focusedBlockedTask !== void 0) {
+      void handleUnblock(focusedBlockedTask);
     }
   });
   useEffect17(() => confirmRemove !== void 0 ? ui.claimPrompt() : void 0, [confirmRemove, ui.claimPrompt]);
@@ -16820,6 +17139,21 @@ var SprintDetailView = () => {
     setFeedback(`\u2713 removed "${target.title}"`);
     reload();
   };
+  const handleUnblock = async (target) => {
+    if (sprint === void 0) return;
+    const r = await unblockTaskUseCase({
+      task: target,
+      sprintId: sprint.id,
+      taskRepo: deps.taskRepo,
+      logger: deps.logger
+    });
+    if (!r.ok) {
+      setFeedback(`\u2717 ${r.error.message}`);
+      return;
+    }
+    setFeedback(`\u2713 unblocked "${target.name}"`);
+    reload();
+  };
   return /* @__PURE__ */ jsx41(ViewShell, { title: "Sprint", subtitle: state.kind === "ok" ? state.value.sprint.name : "loading", children: ui.helpOpen ? /* @__PURE__ */ jsx41(HelpOverlay, {}) : state.kind === "loading" || state.kind === "idle" ? /* @__PURE__ */ jsx41(Box29, { paddingX: spacing.indent, children: /* @__PURE__ */ jsx41(Spinner, { label: "Loading\u2026" }) }) : state.kind === "error" ? /* @__PURE__ */ jsx41(Box29, { paddingX: spacing.indent, children: /* @__PURE__ */ jsx41(Text31, { children: "Failed to load sprint." }) }) : confirmRemove !== void 0 ? /* @__PURE__ */ jsxs30(Box29, { flexDirection: "column", paddingX: spacing.indent, children: [
     /* @__PURE__ */ jsxs30(Text31, { children: [
       "Remove ticket ",
@@ -17688,30 +18022,23 @@ var SignalLine = ({ signal }) => {
     /* @__PURE__ */ jsx43(Text33, { bold: row.bold ?? false, children: truncate2(row.text, 80) })
   ] });
 };
+var LEGEND_ENTRIES = [
+  { label: "change", color: inkColors.info, description: "file/code edit" },
+  { label: "learning", color: inkColors.highlight, description: "cross-task insight" },
+  { label: "decision", color: inkColors.highlight, description: "design choice" },
+  { label: "verified", color: inkColors.success, description: "task self-check passed" },
+  { label: "blocked", color: inkColors.error, description: "task self-blocked" },
+  { label: "commit", color: inkColors.info, description: "proposed commit message" }
+];
 var SignalLegend = () => /* @__PURE__ */ jsxs32(Box31, { flexDirection: "column", paddingX: spacing.indent, marginBottom: spacing.section, children: [
-  /* @__PURE__ */ jsxs32(Text33, { dimColor: true, children: [
-    /* @__PURE__ */ jsx43(Text33, { bold: true, children: "legend" }),
-    "  ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.info, children: "change" }),
-    " = file/code edit",
-    "   ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.highlight, children: "learning" }),
-    " = cross-task insight",
-    "   ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.highlight, children: "decision" }),
-    " = design choice"
-  ] }),
-  /* @__PURE__ */ jsxs32(Text33, { dimColor: true, children: [
-    "        ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.success, children: "verified" }),
-    " = task self-check passed",
-    "   ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.error, children: "blocked" }),
-    " = task self-blocked",
-    "   ",
-    /* @__PURE__ */ jsx43(Text33, { color: inkColors.info, children: "commit" }),
-    " = proposed commit message"
-  ] })
+  /* @__PURE__ */ jsx43(Text33, { dimColor: true, bold: true, children: "legend" }),
+  /* @__PURE__ */ jsx43(Box31, { flexDirection: "column", paddingLeft: 2, children: LEGEND_ENTRIES.map((entry) => /* @__PURE__ */ jsxs32(Box31, { children: [
+    /* @__PURE__ */ jsx43(Text33, { color: entry.color, bold: true, children: padLabel2(entry.label) }),
+    /* @__PURE__ */ jsxs32(Text33, { dimColor: true, children: [
+      "= ",
+      entry.description
+    ] })
+  ] }, entry.label)) })
 ] });
 var EvaluationLine = ({ evaluation }) => {
   const color = evaluation.status === "passed" ? inkColors.success : evaluation.status === "failed" ? inkColors.error : inkColors.warning;
@@ -18288,7 +18615,7 @@ var ExecuteView = () => {
       ] })
     ] })
   ] }) });
-  const outerFlowFilter = (name) => !isPerTaskLeaf(name);
+  const outerFlowFilter = (name) => !isPerTaskLeaf(name) && !name.startsWith("with-repo-lock(");
   const flowStepsPanel = /* @__PURE__ */ jsx46(
     StepTrace,
     {
@@ -19020,7 +19347,7 @@ var ProbeRow = ({ probe }) => /* @__PURE__ */ jsxs39(Box38, { flexDirection: "co
 // src/application/ui/tui/views/export-context-view.tsx
 import { useCallback as useCallback7, useEffect as useEffect25, useState as useState31 } from "react";
 import { Box as Box39, Text as Text41, useInput as useInput20 } from "ink";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 
 // src/business/sprint/views/context-md.ts
 var renderSprintContextMarkdown = (input) => {
@@ -19152,7 +19479,7 @@ var ExportContextView = () => {
       return;
     }
     const outputPath = AbsolutePath.parse(
-      join30(String(storage2.dataRoot), "sprints", String(selection.sprintId), "context.md")
+      join32(String(storage2.dataRoot), "sprints", String(selection.sprintId), "context.md")
     );
     if (!outputPath.ok) {
       setRun({ kind: "error", message: outputPath.error.message });
@@ -19210,7 +19537,7 @@ var ExportContextView = () => {
 // src/application/ui/tui/views/export-requirements-view.tsx
 import { useCallback as useCallback8, useEffect as useEffect26, useState as useState32 } from "react";
 import { Box as Box40, Text as Text42, useInput as useInput21 } from "ink";
-import { join as join31 } from "path";
+import { join as join33 } from "path";
 
 // src/business/sprint/views/requirements-md.ts
 var renderSprintRequirementsMarkdown = (sprint) => {
@@ -19275,7 +19602,7 @@ var ExportRequirementsView = () => {
       return;
     }
     const outputPath = AbsolutePath.parse(
-      join31(String(storage2.dataRoot), "sprints", String(selection.sprintId), "requirements.md")
+      join33(String(storage2.dataRoot), "sprints", String(selection.sprintId), "requirements.md")
     );
     if (!outputPath.ok) {
       setRun({ kind: "error", message: outputPath.error.message });
@@ -19610,12 +19937,12 @@ var WelcomeView = () => {
 import { useEffect as useEffect29, useState as useState36 } from "react";
 import { Box as Box44, Text as Text46 } from "ink";
 import { homedir as osHomedir2 } from "os";
-import { basename as basename3, join as join33 } from "path";
+import { basename as basename3, join as join35 } from "path";
 
 // src/application/ui/tui/prompts/path-picker-prompt.tsx
 import { useEffect as useEffect28, useState as useState35 } from "react";
 import { promises as fs24 } from "fs";
-import { dirname as dirname9, join as join32 } from "path";
+import { dirname as dirname10, join as join34 } from "path";
 import { homedir } from "os";
 import { Box as Box43, Text as Text45, useInput as useInput23 } from "ink";
 import { jsx as jsx55, jsxs as jsxs44 } from "react/jsx-runtime";
@@ -19623,7 +19950,7 @@ var VISIBLE_ROWS2 = 12;
 var clamp5 = (n, min, max) => Math.max(min, Math.min(max, n));
 var expandHome = (input) => {
   if (input === "~") return homedir();
-  if (input.startsWith("~/")) return join32(homedir(), input.slice(2));
+  if (input.startsWith("~/")) return join34(homedir(), input.slice(2));
   return input;
 };
 var PathPickerPrompt = ({
@@ -19675,7 +20002,7 @@ var PathPickerPrompt = ({
         return;
       }
       if (key.backspace || key.delete) {
-        const parent = dirname9(cwd);
+        const parent = dirname10(cwd);
         if (parent !== cwd) {
           setCwd(parent);
           setCursor(1);
@@ -19700,7 +20027,7 @@ var PathPickerPrompt = ({
         const row = rows[cursor];
         if (row === void 0) return;
         if (row.kind === "parent") {
-          const parent = dirname9(cwd);
+          const parent = dirname10(cwd);
           if (parent !== cwd) {
             setCwd(parent);
             setCursor(1);
@@ -19711,7 +20038,7 @@ var PathPickerPrompt = ({
           onSubmit(cwd);
           return;
         }
-        setCwd(join32(cwd, row.entry.name));
+        setCwd(join34(cwd, row.entry.name));
         setCursor(1);
       }
     },
@@ -19793,7 +20120,7 @@ var labelFor = (row) => {
 import { jsx as jsx56, jsxs as jsxs45 } from "react/jsx-runtime";
 var expandHome2 = (input) => {
   if (input === "~") return osHomedir2();
-  if (input.startsWith("~/")) return join33(osHomedir2(), input.slice(2));
+  if (input.startsWith("~/")) return join35(osHomedir2(), input.slice(2));
   return input;
 };
 var backStep = (step) => {
@@ -20009,11 +20336,11 @@ var StepView = ({ step, onChange, onCancel, onSubmit }) => {
 import { useEffect as useEffect30, useState as useState37 } from "react";
 import { Box as Box45, Text as Text47 } from "ink";
 import { homedir as osHomedir3 } from "os";
-import { basename as basename4, join as join34 } from "path";
+import { basename as basename4, join as join36 } from "path";
 import { jsx as jsx57, jsxs as jsxs46 } from "react/jsx-runtime";
 var expandHome3 = (input) => {
   if (input === "~") return osHomedir3();
-  if (input.startsWith("~/")) return join34(osHomedir3(), input.slice(2));
+  if (input.startsWith("~/")) return join36(osHomedir3(), input.slice(2));
   return input;
 };
 var backStep2 = (step) => {
@@ -20844,10 +21171,10 @@ var resolveInitialState = ({
 
 // src/integration/persistence/selection/last-selection-store.ts
 import { promises as fs25 } from "fs";
-import { join as join35 } from "path";
+import { join as join37 } from "path";
 var FILE_NAME = "last-selection.json";
 var createLastSelectionStore = (stateRoot) => {
-  const path = join35(String(stateRoot), FILE_NAME);
+  const path = join37(String(stateRoot), FILE_NAME);
   return {
     async read() {
       try {
@@ -21734,6 +22061,44 @@ var registerTaskCommand = (program) => {
       return;
     }
     process.stdout.write(`${JSON.stringify(result.value, null, 2)}
+`);
+  });
+  task.command("unblock <taskId>").description("flip a blocked task back to todo so the implement loop picks it up again").requiredOption("-s, --sprint <id>", "sprint id").action(async (rawTaskId, opts) => {
+    const sprintId = SprintId.parse(opts.sprint);
+    if (!sprintId.ok) {
+      process.stderr.write(`error: invalid sprint id: ${sprintId.error.message}
+`);
+      process.exit(1);
+      return;
+    }
+    const taskId = TaskId.parse(rawTaskId);
+    if (!taskId.ok) {
+      process.stderr.write(`error: invalid task id: ${taskId.error.message}
+`);
+      process.exit(1);
+      return;
+    }
+    const { deps } = await bootstrapCli();
+    const loaded = await deps.taskRepo.findById(sprintId.value, taskId.value);
+    if (!loaded.ok) {
+      process.stderr.write(`error: ${loaded.error.message}
+`);
+      process.exit(1);
+      return;
+    }
+    const result = await unblockTaskUseCase({
+      task: loaded.value,
+      sprintId: sprintId.value,
+      taskRepo: deps.taskRepo,
+      logger: deps.logger
+    });
+    if (!result.ok) {
+      process.stderr.write(`error: ${result.error.message}
+`);
+      process.exit(1);
+      return;
+    }
+    process.stdout.write(`unblocked task '${result.value.name}' (${String(result.value.id)})
 `);
   });
 };