@neriros/ralphy 2.11.2 → 2.12.0

package/dist/cli/index.js

@@ -50837,7 +50837,7 @@ var require_axios = __commonJS((exports, module) => {
 });
 
 // apps/cli/src/index.ts
-import { resolve, join as join19, dirname as dirname5 } from "path";
+import { resolve, join as join20, dirname as dirname5 } from "path";
 import { exists as exists2, mkdir as mkdir4, rm } from "fs/promises";
 
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/render.js
@@ -56407,7 +56407,7 @@ function log(msg) {
 // package.json
 var package_default = {
   name: "@neriros/ralphy",
-  version: "2.11.2",
+  version: "2.12.0",
   description: "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   keywords: [
     "agent",
@@ -56879,7 +56879,7 @@ function createDefaultContext() {
 
 // apps/cli/src/components/App.tsx
 var import_react58 = __toESM(require_react(), 1);
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // packages/core/src/state.ts
 import { join as join2 } from "path";
@@ -70104,7 +70104,7 @@ function TaskLoop({ opts }) {
 
 // apps/cli/src/components/AgentMode.tsx
 var import_react57 = __toESM(require_react(), 1);
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // apps/cli/src/agent/state.ts
 import { join as join10 } from "path";
@@ -70249,6 +70249,9 @@ async function ensureRalphyConfig(projectRoot) {
   return path;
 }
 
+// apps/cli/src/agent/wire.ts
+import { join as join16 } from "path";
+
 // packages/core/src/layout.ts
 import { join as join12 } from "path";
 var STATE_FILE2 = ".ralph-state.json";
@@ -70864,8 +70867,32 @@ async function createPullRequest(input, runner) {
 
 // apps/cli/src/agent/ci.ts
 var PR_CHECKS_FIELDS = "name,bucket,link,workflow,event";
-async function getPrChecksStatus(prRef, runner, cwd2) {
-  const out = await runner.run(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], cwd2);
+var TRANSIENT_GH_RE = /HTTP 5\d\d|Gateway Timeout|Bad Gateway|Service Unavailable|connection reset|ECONNRESET|ETIMEDOUT|getaddrinfo|EAI_AGAIN|could not resolve host/i;
+var GH_RETRY_DELAYS = [5000, 15000, 45000];
+async function runGhWithRetry(cmd, runner, cwd2, onRetry, sleep2 = (ms) => new Promise((r) => setTimeout(r, ms))) {
+  let lastErr;
+  for (let i = 0;i <= GH_RETRY_DELAYS.length; i++) {
+    try {
+      return await runner.run(cmd, cwd2);
+    } catch (err) {
+      const e = err;
+      const blob = `${e.message}
+${e.stderr ?? ""}
+${e.stdout ?? ""}`;
+      if (!TRANSIENT_GH_RE.test(blob) || i === GH_RETRY_DELAYS.length)
+        throw err;
+      const delay2 = GH_RETRY_DELAYS[i];
+      const firstLine = (e.stderr?.trim().split(`
+`)[0] ?? e.message).slice(0, 120);
+      onRetry?.(i + 1, delay2, firstLine);
+      await sleep2(delay2);
+      lastErr = err;
+    }
+  }
+  throw lastErr;
+}
+async function getPrChecksStatus(prRef, runner, cwd2, onTransientRetry) {
+  const out = await runGhWithRetry(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], runner, cwd2, onTransientRetry);
   const checks = JSON.parse(out.stdout || "[]").filter((c) => c.bucket !== "skipping");
   if (checks.some((c) => c.bucket === "pending")) {
     return { bucket: "pending", failedRunIds: [] };
@@ -70902,17 +70929,28 @@ ${truncated}`);
 }
 async function fixCiUntilGreen(deps, opts) {
   for (let attempt2 = 1;attempt2 <= opts.maxAttempts; attempt2++) {
+    let pollN = 0;
     while (true) {
       if (deps.cancelled?.())
         return { success: false, attempts: attempt2 - 1, reason: "cancelled" };
-      const s = await deps.getStatus();
+      pollN += 1;
+      deps.onPhase?.("ci-poll", `attempt ${attempt2}/${opts.maxAttempts} \xB7 poll ${pollN}`);
+      let s;
+      try {
+        s = await deps.getStatus();
+      } catch (err) {
+        deps.log(`! gh pr checks failed permanently: ${err.message} \u2014 giving up CI watch`, "red");
+        return { success: false, attempts: attempt2 - 1, reason: "gh-failed" };
+      }
       if (s.bucket === "pass") {
         deps.log(`\u2713 CI green for PR (after ${attempt2 - 1} fix attempts)`, "green");
         return { success: true, attempts: attempt2 - 1 };
       }
       if (s.bucket === "fail") {
         deps.log(`\u2717 CI failing (attempt ${attempt2}/${opts.maxAttempts}) \u2014 fetching logs and re-running task`, "yellow");
+        deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 fetching logs`);
         const logs = await deps.getFailedLogs(s.failedRunIds);
+        deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 re-running worker`);
         const steering = `CI is failing on this PR. Investigate and fix:
 
 \`\`\`
@@ -70923,6 +70961,7 @@ ${logs}
           deps.log(`! task loop exited code ${code} during CI fix attempt ${attempt2}`, "red");
         }
         try {
+          deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 pushing fix`);
           await deps.pushBranch();
         } catch (err) {
           deps.log(`! push failed during CI fix: ${err.message}`, "red");
@@ -70930,6 +70969,7 @@ ${logs}
         }
         break;
       }
+      deps.onPhase?.("ci-poll", `attempt ${attempt2}/${opts.maxAttempts} \xB7 pending, waiting`);
       await deps.sleep(opts.pollIntervalSeconds * 1000);
     }
   }
@@ -70957,6 +70997,7 @@ async function reactivateState(stateFilePath, log2, changeName) {
 }
 async function runPostTask(input, deps) {
   const { log: log2, cmd, git, runScript } = deps;
+  const emit = (phase, detail) => deps.onPhase?.(phase, detail);
   const {
     changeName,
     cwd: cwd2,
@@ -70973,6 +71014,7 @@ async function runPostTask(input, deps) {
     respawnWorker
   } = input;
   if (cfg.teardownScript) {
+    emit("teardown", cfg.teardownScript);
     try {
       await runScript("teardown", cfg.teardownScript, cwd2);
     } catch {}
@@ -70998,6 +71040,7 @@ async function runPostTask(input, deps) {
       let hookFixAttempt = 0;
       let commitGaveUp = false;
       while (true) {
+        emit("committing", "git status");
         let dirty = "";
         try {
           const status = await cmd.run(["git", "status", "--porcelain"], cwd2);
@@ -71009,7 +71052,9 @@ async function runPostTask(input, deps) {
         if (!dirty)
           break;
         try {
+          emit("committing", "git add -A");
           await cmd.run(["git", "add", "-A"], cwd2);
+          emit("committing", "git commit");
           await cmd.run(["git", "commit", "-m", `chore(ralph): residual changes for ${changeName}`], cwd2);
           log2(`  committed residual changes for ${changeName}`, "gray");
           break;
@@ -71028,6 +71073,7 @@ ${e.stderr ?? ""}`;
             break;
           }
           hookFixAttempt += 1;
+          emit("commit-retry", `${hookFixAttempt}/${maxHookFixAttempts}`);
           log2(`! commit rejected for ${changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
           log2(`    detail: ${detail}`, "yellow");
           const retryCode = await runWorkerWithFixTask("Fix host pre-commit hook rejection", `Committing residual changes was rejected by the host repo's pre-commit hook. ` + `Fix the underlying problem, then the commit will be retried.
@@ -71043,8 +71089,10 @@ ${e.stderr ?? ""}`;
       }
       let pr = null;
       let prGaveUp = commitGaveUp;
+      let nonFfRebaseAttempted = false;
       while (!prGaveUp) {
         try {
+          emit("pr-create", "git push + gh pr create");
           pr = await createPullRequest({ cwd: cwd2, branch, issue, base: cfg.prBaseBranch }, cmd);
           break;
         } catch (err) {
@@ -71052,8 +71100,69 @@ ${e.stderr ?? ""}`;
           const detail = e.stderr?.trim() || e.message;
           const combined = `${e.stdout ?? ""}
 ${e.stderr ?? ""}`;
-          const pushRejected = /failed to push some refs|pre-push hook|hook declined/i.test(combined);
-          if (!pushRejected || hookFixAttempt >= maxHookFixAttempts) {
+          const isNonFastForward = /non-fast-forward|Updates were rejected because the (tip of your current branch is behind|remote contains work)/i.test(combined) && !/pre-push hook|hook declined/i.test(combined);
+          const isHookReject = /pre-push hook|hook declined/i.test(combined);
+          const pushRejected = isHookReject || /failed to push some refs/i.test(combined);
+          if (isNonFastForward && !nonFfRebaseAttempted) {
+            nonFfRebaseAttempted = true;
+            emit("rebasing", `git pull --rebase origin ${branch}`);
+            log2(`  non-fast-forward push for ${changeName} \u2014 rebasing onto origin/${branch}`, "yellow");
+            try {
+              await cmd.run(["git", "fetch", "origin", branch], cwd2);
+              await cmd.run(["git", "pull", "--rebase", "origin", branch], cwd2);
+              continue;
+            } catch (rebaseErr) {
+              const re = rebaseErr;
+              const reBlob = `${re.stdout ?? ""}
+${re.stderr ?? ""}`;
+              const isConflict = /CONFLICT|Merge conflict|could not apply|both modified/i.test(reBlob);
+              if (!isConflict) {
+                log2(`! rebase failed for ${changeName}: ${rebaseErr.message} \u2014 giving up`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              emit("rebasing", "conflicts detected \u2014 aborting + queueing fix task");
+              try {
+                await cmd.run(["git", "rebase", "--abort"], cwd2);
+              } catch {}
+              let conflictedFiles = "";
+              try {
+                const r = await cmd.run(["git", "diff", "--name-only", `HEAD..origin/${branch}`], cwd2);
+                conflictedFiles = r.stdout.trim();
+              } catch {}
+              if (hookFixAttempt >= maxHookFixAttempts) {
+                log2(`! merge conflict on rebase of ${branch} after ${hookFixAttempt} attempts \u2014 worktree preserved at ${cwd2}`, "red");
+                log2(`    detail: ${reBlob.trim().split(`
+`).slice(0, 8).join(`
+`)}`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              hookFixAttempt += 1;
+              emit("rebasing", `conflict-fix ${hookFixAttempt}/${maxHookFixAttempts}`);
+              log2(`! merge conflict rebasing ${branch} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
+              const retryCode2 = await runWorkerWithFixTask("Resolve merge conflict with origin/" + branch, `Push to origin/${branch} was rejected as non-fast-forward, and rebasing ` + `onto origin/${branch} produced merge conflicts.
+
+` + `Run \`git fetch origin ${branch}\` and \`git rebase origin/${branch}\`, ` + `resolve every conflict, \`git add\` the resolved files, and finish with ` + `\`git rebase --continue\`. The push will be retried after this loop ` + `iteration finishes.
+
+` + (conflictedFiles ? `Files that differ between your branch and origin/${branch}:
+${conflictedFiles}
+
+` : "") + `Rebase output:
+${reBlob.trim()}`);
+              if (retryCode2 !== 0) {
+                log2(`! worker re-run after merge conflict exited code ${retryCode2} \u2014 giving up`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              nonFfRebaseAttempted = false;
+              continue;
+            }
+          }
+          if (!isHookReject || hookFixAttempt >= maxHookFixAttempts) {
             if (pushRejected) {
               log2(`! push rejected for ${changeName} after ${hookFixAttempt} hook-fix attempts (host pre-push hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
               log2(`    detail: ${detail}`, "red");
@@ -71065,6 +71174,7 @@ ${e.stderr ?? ""}`;
             break;
           }
           hookFixAttempt += 1;
+          emit("push-retry", `${hookFixAttempt}/${maxHookFixAttempts}`);
           log2(`! push rejected for ${changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
           log2(`    detail: ${detail}`, "yellow");
           const retryCode = await runWorkerWithFixTask("Fix host pre-push hook rejection", `Push to origin/${branch} was rejected by the host repo's pre-push hook. ` + `Fix the underlying problem, then the push will be retried.
@@ -71084,8 +71194,10 @@ ${e.stderr ?? ""}`;
         log2(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
         if (wantFixCi) {
           log2(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
+          emit("ci-poll", "starting");
           const result2 = await fixCiUntilGreen({
-            getStatus: () => getPrChecksStatus(pr.url, cmd, cwd2),
+            onPhase: (p, d) => emit(p, d),
+            getStatus: () => getPrChecksStatus(pr.url, cmd, cwd2, (n, ms, why) => log2(`  gh transient (try ${n}) \u2014 retry in ${Math.round(ms / 1000)}s \xB7 ${why}`, "yellow")),
             getFailedLogs: (ids) => fetchFailedRunLogs(ids, cmd, cwd2),
             runTaskWithSteering: async (steering) => {
               try {
@@ -71112,7 +71224,12 @@ ${e.stderr ?? ""}`;
       }
     }
   }
+  if (effectiveCode === 0)
+    emit("done");
+  else
+    emit("gave-up", `exit ${effectiveCode}`);
   if (useWorktree && cwd2 !== projectRoot) {
+    emit("cleanup", "checking worktree safety");
     if (effectiveCode === 0 && cfg.cleanupWorktreeOnSuccess) {
       const check = await isWorktreeSafeToRemove(cwd2, cfg.prBaseBranch, git).catch((err) => ({
         safe: false,
@@ -71176,6 +71293,22 @@ var bunCmdRunner = {
     return { stdout, stderr };
   }
 };
+function traceCmdRunner(base2, onStart, onEnd) {
+  return {
+    run: async (cmd, cwd2) => {
+      const t0 = Date.now();
+      onStart(cmd);
+      try {
+        const r = await base2.run(cmd, cwd2);
+        onEnd(cmd, Date.now() - t0, true);
+        return r;
+      } catch (err) {
+        onEnd(cmd, Date.now() - t0, false);
+        throw err;
+      }
+    }
+  };
+}
 function buildAgentCoordinator(input) {
   const {
     args,
@@ -71188,8 +71321,12 @@ function buildAgentCoordinator(input) {
     onLog,
     onWorkersChanged,
     onWorkerStarted,
-    onWorkerExited
+    onWorkerExited,
+    onWorkerPhase,
+    onWorkerOutput,
+    onWorkerCmd
   } = input;
+  const logsDir = join16(projectRoot, ".ralph", "logs");
   const concurrency = args.concurrency || cfg.concurrency;
   const pollInterval = args.pollInterval || cfg.pollIntervalSeconds;
   const inProgressName = args.inProgressStatus || cfg.linear.inProgressStatus;
@@ -71300,24 +71437,83 @@ function buildAgentCoordinator(input) {
   }
   function spawnWorker(changeName) {
     const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
-    const respawn = () => {
-      const rp = Bun.spawn({
+    const logFilePath = join16(logsDir, `${changeName}.log`);
+    let logWriter = null;
+    const ensureLogWriter = async () => {
+      if (logWriter)
+        return logWriter;
+      try {
+        await Bun.write(logFilePath, "");
+        logWriter = Bun.file(logFilePath).writer();
+        return logWriter;
+      } catch (err) {
+        onLog(`! could not open worker log ${logFilePath}: ${err.message}`, "yellow");
+        return null;
+      }
+    };
+    async function pump(stream, label) {
+      if (!stream)
+        return;
+      const reader = stream.getReader();
+      const decoder = new TextDecoder;
+      let buf = "";
+      const writer = await ensureLogWriter();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          const chunk2 = decoder.decode(value, { stream: true });
+          buf += chunk2;
+          let nl;
+          while ((nl = buf.indexOf(`
+`)) >= 0) {
+            const line = buf.slice(0, nl);
+            buf = buf.slice(nl + 1);
+            if (writer)
+              writer.write(line + `
+`);
+            if (line)
+              onWorkerOutput?.(changeName, label === "err" ? `! ${line}` : line);
+          }
+        }
+        if (buf) {
+          if (writer)
+            writer.write(buf + `
+`);
+          onWorkerOutput?.(changeName, label === "err" ? `! ${buf}` : buf);
+        }
+      } catch {} finally {
+        try {
+          writer?.flush();
+        } catch {}
+      }
+    }
+    const launch = (note) => {
+      const p = Bun.spawn({
         cmd: buildTaskCmdFor(changeName),
         cwd: cwd2,
-        stdout: "ignore",
-        stderr: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
         stdin: "ignore"
       });
+      if (note && logWriter)
+        logWriter.write(`
+--- ${note} ---
+`);
+      pump(p.stdout, "out");
+      pump(p.stderr, "err");
+      return p;
+    };
+    const respawn = () => {
+      onWorkerPhase?.(changeName, "working", "respawn");
+      const rp = launch(`respawn at ${new Date().toISOString()}`);
       return rp.exited;
     };
-    const proc = Bun.spawn({
-      cmd: buildTaskCmdFor(changeName),
-      cwd: cwd2,
-      stdout: "ignore",
-      stderr: "ignore",
-      stdin: "ignore"
-    });
-    onWorkerStarted(changeName, statesDirByChange.get(changeName) ?? statesDir);
+    const proc = launch(`spawn at ${new Date().toISOString()}`);
+    onWorkerStarted(changeName, statesDirByChange.get(changeName) ?? statesDir, logFilePath);
+    onWorkerPhase?.(changeName, "working");
+    const tracedCmd = onWorkerCmd ? traceCmdRunner(bunCmdRunner, (cmd) => onWorkerCmd(changeName, cmd, "start"), (cmd, ms, ok) => onWorkerCmd(changeName, cmd, "end", ms, ok)) : bunCmdRunner;
     const wantPr = args.createPr || cfg.createPrOnSuccess;
     const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
     const wrapped = proc.exited.then(async (code) => {
@@ -71342,7 +71538,19 @@ function buildAgentCoordinator(input) {
           cleanupWorktreeOnSuccess: cfg.cleanupWorktreeOnSuccess
         },
         respawnWorker: respawn
-      }, { cmd: bunCmdRunner, git: bunGitRunner, log: onLog, runScript });
+      }, {
+        cmd: tracedCmd,
+        git: bunGitRunner,
+        log: onLog,
+        runScript,
+        ...onWorkerPhase && {
+          onPhase: (phase, detail) => onWorkerPhase(changeName, phase, detail)
+        }
+      });
+      try {
+        logWriter?.flush();
+        await logWriter?.end();
+      } catch {}
       cwdByChange.delete(changeName);
       statesDirByChange.delete(changeName);
       branchByChange.delete(changeName);
@@ -71418,6 +71626,12 @@ function nextId() {
   lineCounter += 1;
   return `${Date.now()}-${lineCounter}`;
 }
+var TAIL_MAX_LINES = 5;
+var CMD_DISPLAY_MAX = 80;
+function fmtCmd(argv) {
+  const joined = argv.join(" ");
+  return joined.length > CMD_DISPLAY_MAX ? joined.slice(0, CMD_DISPLAY_MAX - 1) + "\u2026" : joined;
+}
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 function fmtElapsed(ms) {
   const s = Math.floor(ms / 1000);
@@ -71467,15 +71681,50 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
         store,
         onLog: appendLog,
         onWorkersChanged: () => setTick((t) => t + 1),
-        onWorkerStarted: (changeName, dir) => {
+        onWorkerStarted: (changeName, dir, logFile) => {
           workerMetaRef.current.set(changeName, {
             startedAt: Date.now(),
             statesDir: dir,
-            iter: 0
+            logFile,
+            iter: 0,
+            phase: "working",
+            phaseDetail: "",
+            phaseStartedAt: Date.now(),
+            currentCmd: null,
+            lastCmd: null,
+            tail: []
           });
         },
         onWorkerExited: (changeName) => {
           workerMetaRef.current.delete(changeName);
+        },
+        onWorkerPhase: (changeName, phase, detail) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          if (m.phase !== phase)
+            m.phaseStartedAt = Date.now();
+          m.phase = phase;
+          m.phaseDetail = detail ?? "";
+        },
+        onWorkerOutput: (changeName, line) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          m.tail.push(line);
+          if (m.tail.length > TAIL_MAX_LINES)
+            m.tail.splice(0, m.tail.length - TAIL_MAX_LINES);
+        },
+        onWorkerCmd: (changeName, cmd, state, durationMs, ok) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          if (state === "start") {
+            m.currentCmd = { argv: cmd, startedAt: Date.now() };
+          } else {
+            m.currentCmd = null;
+            m.lastCmd = { argv: cmd, durationMs: durationMs ?? 0, ok: ok ?? true };
+          }
         }
       });
       appendLog(`concurrency=${concurrency} pollInterval=${pollInterval}s`, "gray");
@@ -71531,7 +71780,7 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
       (async () => {
         for (const [changeName, meta] of workerMetaRef.current) {
           try {
-            const file = Bun.file(join16(meta.statesDir, changeName, ".ralph-state.json"));
+            const file = Bun.file(join17(meta.statesDir, changeName, ".ralph-state.json"));
             if (await file.exists()) {
               const json = await file.json();
               meta.iter = json.iteration ?? meta.iter;
@@ -71589,19 +71838,56 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
             const meta = workerMetaRef.current.get(w.changeName);
             const elapsed = meta ? fmtElapsed(now2 - meta.startedAt) : "\u2013";
             const iter = meta?.iter ?? 0;
-            return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
-              color: "cyan",
+            const phase = meta?.phase ?? "working";
+            const phaseElapsed = meta ? fmtElapsed(now2 - meta.phaseStartedAt) : "\u2013";
+            const phaseDetail = meta?.phaseDetail ? ` (${meta.phaseDetail})` : "";
+            const cmd = meta?.currentCmd;
+            const cmdElapsed = cmd ? fmtElapsed(now2 - cmd.startedAt) : null;
+            const tail2 = meta?.tail ?? [];
+            return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+              flexDirection: "column",
               children: [
-                "  ",
-                spinnerFrame,
-                " ",
-                w.issueIdentifier,
-                " (",
-                w.changeName,
-                ") \xB7 iter ",
-                iter,
-                " \xB7 ",
-                elapsed
+                /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  color: "cyan",
+                  children: [
+                    "  ",
+                    spinnerFrame,
+                    " ",
+                    w.issueIdentifier,
+                    " (",
+                    w.changeName,
+                    ") \xB7 iter ",
+                    iter,
+                    " \xB7 ",
+                    elapsed
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  dimColor: true,
+                  children: [
+                    "      phase: ",
+                    phase,
+                    phaseDetail,
+                    " \xB7 ",
+                    phaseElapsed
+                  ]
+                }, undefined, true, undefined, this),
+                cmd && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  color: "yellow",
+                  children: [
+                    "      \u23F5 ",
+                    fmtCmd(cmd.argv),
+                    " \xB7 ",
+                    cmdElapsed
+                  ]
+                }, undefined, true, undefined, this),
+                tail2.map((line, i) => /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  dimColor: true,
+                  children: [
+                    "      \u2502 ",
+                    line.length > 110 ? line.slice(0, 109) + "\u2026" : line
+                  ]
+                }, `${w.changeName}-tail-${i}`, true, undefined, this))
               ]
             }, w.changeName, true, undefined, this);
           })
@@ -71612,11 +71898,11 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
 }
 
 // packages/openspec/src/openspec-change-store.ts
-import { join as join17, dirname as dirname4 } from "path";
+import { join as join18, dirname as dirname4 } from "path";
 import { readdir, mkdir as mkdir3 } from "fs/promises";
 function resolveOpenspecBin() {
   const pkgJsonPath = Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir);
-  return join17(dirname4(pkgJsonPath), "bin", "openspec.js");
+  return join18(dirname4(pkgJsonPath), "bin", "openspec.js");
 }
 function runOpenspec(args, options = {}) {
   const stdio = options.inherit ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"];
@@ -71642,7 +71928,7 @@ class OpenSpecChangeStore {
     }
   }
   getChangeDirectory(name) {
-    return join17("openspec", "changes", name);
+    return join18("openspec", "changes", name);
   }
   async listChanges() {
     const result2 = runOpenspec(["list", "--json"]);
@@ -71656,7 +71942,7 @@ class OpenSpecChangeStore {
         }
       } catch {}
     }
-    const changesDir = join17("openspec", "changes");
+    const changesDir = join18("openspec", "changes");
     if (!await Bun.file(changesDir).exists())
       return [];
     try {
@@ -71667,18 +71953,18 @@ class OpenSpecChangeStore {
     }
   }
   async readTaskList(name) {
-    const file = Bun.file(join17("openspec", "changes", name, "tasks.md"));
+    const file = Bun.file(join18("openspec", "changes", name, "tasks.md"));
     if (!await file.exists())
       return "";
     return await file.text();
   }
   async writeTaskList(name, content) {
-    const path = join17("openspec", "changes", name, "tasks.md");
+    const path = join18("openspec", "changes", name, "tasks.md");
     await mkdir3(dirname4(path), { recursive: true });
     await Bun.write(path, content);
   }
   async appendSteering(name, message) {
-    const path = join17("openspec", "changes", name, "steering.md");
+    const path = join18("openspec", "changes", name, "steering.md");
     const file = Bun.file(path);
     const existing = await file.exists() ? await file.text() : null;
     const updated = existing ? `${message}
@@ -71689,7 +71975,7 @@ ${existing.trimStart()}` : `${message}
     await Bun.write(path, updated);
   }
   async readSection(name, artifact, heading) {
-    const file = Bun.file(join17("openspec", "changes", name, artifact));
+    const file = Bun.file(join18("openspec", "changes", name, artifact));
     if (!await file.exists())
       return "";
     const content = await file.text();
@@ -71771,8 +72057,8 @@ function App2({ args, statesDir, tasksDir, projectRoot }) {
           message: "Error: --name is required for status mode"
         }, undefined, false, undefined, this);
       }
-      const stateDir = join18(statesDir, args.name);
-      if (getStorage().read(join18(stateDir, ".ralph-state.json")) === null) {
+      const stateDir = join19(statesDir, args.name);
+      if (getStorage().read(join19(stateDir, ".ralph-state.json")) === null) {
         return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ErrorMessage, {
           message: `Error: change '${args.name}' not found`
         }, undefined, false, undefined, this);
@@ -71833,7 +72119,7 @@ if (typeof globalThis.Bun === "undefined") {
 async function findProjectRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (await exists2(join19(dir, "openspec")))
+    if (await exists2(join20(dir, "openspec")))
       return dir;
     dir = resolve(dir, "..");
   }
@@ -71873,7 +72159,7 @@ try {
   const tasksDir = layout.tasksDir;
   if (args.mode === "init") {
     await mkdir4(statesDir, { recursive: true });
-    const openspecBin = join19(dirname5(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
+    const openspecBin = join20(dirname5(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
     Bun.spawnSync({
       cmd: [process.execPath, openspecBin, "init", "--tools", "none", "--force"],
       stdio: ["inherit", "inherit", "inherit"],
@@ -71886,9 +72172,9 @@ try {
 `);
       process.exit(1);
     }
-    const worktreeDir = join19(worktreesDir(projectRoot), args.name);
-    const changeDir = join19(tasksDir, args.name);
-    const stateDir = join19(statesDir, args.name);
+    const worktreeDir = join20(worktreesDir(projectRoot), args.name);
+    const changeDir = join20(tasksDir, args.name);
+    const stateDir = join20(statesDir, args.name);
     const branch = `ralph/${args.name}`;
     const removed = [];
     if (await exists2(worktreeDir)) {
@@ -71948,13 +72234,13 @@ try {
     process.exit(0);
   }
   if (args.mode === "task" && args.name) {
-    await mkdir4(join19(statesDir, args.name), { recursive: true });
-    await mkdir4(join19(tasksDir, args.name), { recursive: true });
+    await mkdir4(join20(statesDir, args.name), { recursive: true });
+    await mkdir4(join20(tasksDir, args.name), { recursive: true });
   }
   if (args.mode === "agent") {
     await mkdir4(statesDir, { recursive: true });
     await mkdir4(tasksDir, { recursive: true });
-    await mkdir4(join19(projectRoot, ".ralph"), { recursive: true });
+    await mkdir4(join20(projectRoot, ".ralph"), { recursive: true });
   }
   await runWithContext(createDefaultContext(), async () => {
     const { waitUntilExit } = render_default(import_react59.createElement(App2, { args, statesDir, tasksDir, projectRoot }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neriros/ralphy",
-  "version": "2.11.2",
+  "version": "2.12.0",
   "description": "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   "keywords": [
     "agent",