@neriros/ralphy 2.13.15 → 2.14.0

package/dist/cli/index.js

@@ -50837,8 +50837,8 @@ var require_axios = __commonJS((exports, module) => {
 });
 
 // apps/cli/src/index.ts
-import { resolve as resolve2, join as join19, dirname as dirname5 } from "path";
-import { exists as exists2, mkdir as mkdir5, rm } from "fs/promises";
+import { resolve as resolve2, join as join19, dirname as dirname6 } from "path";
+import { exists as exists2, mkdir as mkdir6, rm } from "fs/promises";
 
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/render.js
 import { Stream } from "stream";
@@ -56116,6 +56116,12 @@ function Static(props) {
 }
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/components/Transform.js
 var import_react12 = __toESM(require_react(), 1);
+function Transform({ children, transform: transform2 }) {
+  if (children === undefined || children === null) {
+    return null;
+  }
+  return import_react12.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row" }, internal_transform: transform2 }, children);
+}
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/components/Newline.js
 var import_react13 = __toESM(require_react(), 1);
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/components/Spacer.js
@@ -56411,10 +56417,13 @@ function log(msg) {
 import { readFileSync as readFileSync2 } from "fs";
 import { resolve } from "path";
 function getVersion() {
+  try {
+    if ("2.14.0")
+      return "2.14.0";
+  } catch {}
   const dirsToTry = [];
   try {
-    const cliDir = import.meta.dir;
-    dirsToTry.push(cliDir);
+    dirsToTry.push(import.meta.dir);
   } catch {}
   dirsToTry.push(process.cwd());
   for (const startDir of dirsToTry) {
@@ -70108,8 +70117,9 @@ function TaskLoop({ opts }) {
 
 // apps/cli/src/components/AgentMode.tsx
 var import_react57 = __toESM(require_react(), 1);
-import { join as join16, relative } from "path";
+import { join as join16, relative, dirname as dirname4 } from "path";
 import { homedir as homedir3 } from "os";
+import { appendFile, mkdir as mkdir4 } from "fs/promises";
 
 // apps/cli/src/agent/config.ts
 import { join as join10 } from "path";
@@ -70280,45 +70290,34 @@ var DEFAULT_CONFIG_TEMPLATE = `{
     // Post a progress update every N iterations. 0 disables. Requires postComments.
     "updateEveryIterations": 10,
 
-    // ---------------------------------------------------------------------------
-    // Linear indicators \u2014 COMMENTED OUT BY DEFAULT
-    //
     // Indicators map Ralph lifecycle events to Linear labels/statuses.
-    // WARNING: Activating indicators will query AND mutate your Linear workspace.
-    // Labels or statuses that do not already exist may be created automatically.
-    // Review every value against your actual Linear workspace before enabling,
-    // then replace the empty object below with the full indicators block.
-    //
-    // To activate, replace "indicators": {} with:
-    //
-    // "indicators": {
-    //   // Issues to pick up (any-of filter \u2014 Ralph will start working on these).
-    //   "getTodo": { "filter": [{ "type": "status", "value": "Todo" }] },
-    //
-    //   // Issues already in flight (resume after restart).
-    //   "getInProgress": { "filter": [{ "type": "label", "value": "ralph:in-progress" }] },
-    //
-    //   // Issues whose PR has a merge conflict (Ralph will attempt a re-fix run).
-    //   "getConflicted": { "filter": [{ "type": "label", "value": "ralph:conflict" }] },
-    //
-    //   // Applied when Ralph picks up an issue.
-    //   "setInProgress": { "type": "label", "value": "ralph:in-progress" },
-    //
-    //   // Applied on clean success.
-    //   "setDone": { "type": "status", "value": "In Review" },
-    //
-    //   // Applied when the task exits with an error (quarantine signal).
-    //   "setError": { "type": "label", "value": "ralph:error" },
-    //
-    //   // Applied when a PR merge conflict is detected.
-    //   "setConflicted": { "type": "label", "value": "ralph:conflict" },
-    //
-    //   // Label-only marker(s) removed once the conflict is fixed.
-    //   // Note: only label-typed markers are valid here \u2014 status removal is not supported.
-    //   "clearConflicted": { "type": "label", "value": "ralph:conflict" }
-    // }
-    // ---------------------------------------------------------------------------
-    "indicators": {}
+    // WARNING: activating indicators will query AND mutate your Linear workspace.
+    // Uncomment each entry after confirming the label/status names match your workspace.
+    "indicators": {
+      // Issues to pick up (any-of filter \u2014 Ralph will start working on these).
+      // "getTodo": { "filter": [{ "type": "status", "value": "Todo" }] },
+
+      // Issues already in flight (resume after restart).
+      // "getInProgress": { "filter": [{ "type": "label", "value": "ralph:in-progress" }] },
+
+      // Issues whose PR has a merge conflict (Ralph will attempt a re-fix run).
+      // "getConflicted": { "filter": [{ "type": "label", "value": "ralph:conflict" }] },
+
+      // Applied when Ralph picks up an issue.
+      // "setInProgress": { "type": "label", "value": "ralph:in-progress" },
+
+      // Applied on clean success.
+      // "setDone": { "type": "status", "value": "In Review" },
+
+      // Applied when the task exits with an error (quarantine signal).
+      // "setError": { "type": "label", "value": "ralph:error" },
+
+      // Applied when a PR merge conflict is detected.
+      // "setConflicted": { "type": "label", "value": "ralph:conflict" },
+
+      // Label removed once the conflict is fixed (status removal is not supported here).
+      // "clearConflicted": { "type": "label", "value": "ralph:conflict" }
+    }
   }
 }
 `;
@@ -70530,14 +70529,19 @@ async function fetchTeamIdByKey(apiKey, teamKey) {
   });
   return data.teams.nodes[0]?.id ?? null;
 }
-async function createIssueLabel(apiKey, teamId, name) {
-  const mutation = `mutation CreateLabel($teamId: String!, $name: String!) {
+async function createIssueLabel(apiKey, teamId, name, parentId) {
+  const mutation = parentId ? `mutation CreateLabel($teamId: String!, $name: String!, $parentId: String!) {
+    issueLabelCreate(input: { teamId: $teamId, name: $name, parentId: $parentId }) {
+      success
+      issueLabel { id }
+    }
+  }` : `mutation CreateLabel($teamId: String!, $name: String!) {
     issueLabelCreate(input: { teamId: $teamId, name: $name }) {
       success
       issueLabel { id }
     }
   }`;
-  const data = await linearRequest(apiKey, mutation, { teamId, name });
+  const data = await linearRequest(apiKey, mutation, parentId ? { teamId, name, parentId } : { teamId, name });
   return data.issueLabelCreate.issueLabel?.id ?? null;
 }
 async function addLabelToIssue(apiKey, issueId, labelId) {
@@ -70790,7 +70794,7 @@ class AgentCoordinator {
       this.pendingIds.delete(issue.id);
       return;
     }
-    if (mode === "fresh" && this.opts.setInProgress) {
+    if (mode !== "resume" && this.opts.setInProgress) {
       try {
         await this.deps.applyIndicator(issue, this.opts.setInProgress);
       } catch (err) {
@@ -70896,6 +70900,11 @@ class AgentCoordinator {
             error: err.message
           });
         }
+        if (this.opts.setInProgress) {
+          try {
+            await this.deps.removeIndicator(issue, this.opts.setInProgress);
+          } catch {}
+        }
       }
     } else if (this.opts.setError) {
       try {
@@ -70908,6 +70917,11 @@ class AgentCoordinator {
           error: err.message
         });
       }
+      if (this.opts.setInProgress) {
+        try {
+          await this.deps.removeIndicator(issue, this.opts.setInProgress);
+        } catch {}
+      }
     }
   }
   stop() {
@@ -71135,6 +71149,7 @@ async function createPullRequest(input, runner) {
 // apps/cli/src/agent/ci.ts
 var PR_CHECKS_FIELDS = "name,bucket,link,workflow,event";
 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 NO_CHECKS_RE = /no checks reported/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;
@@ -71159,7 +71174,18 @@ ${e.stdout ?? ""}`;
   throw lastErr;
 }
 async function getPrChecksStatus(prRef, runner, cwd2, onTransientRetry) {
-  const out = await runGhWithRetry(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], runner, cwd2, onTransientRetry);
+  let out;
+  try {
+    out = await runGhWithRetry(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], runner, cwd2, onTransientRetry);
+  } catch (err) {
+    const e = err;
+    const blob = `${e.message}
+${e.stderr ?? ""}
+${e.stdout ?? ""}`;
+    if (NO_CHECKS_RE.test(blob))
+      return { bucket: "pass", failedRunIds: [] };
+    throw err;
+  }
   const checks = JSON.parse(out.stdout || "[]").filter((c) => c.bucket !== "skipping");
   if (checks.some((c) => c.bucket === "pending")) {
     return { bucket: "pending", failedRunIds: [] };
@@ -71262,6 +71288,261 @@ async function reactivateState(stateFilePath, log2, changeName) {
     log2(`! could not reactivate state for ${changeName}: ${err.message}`, "yellow");
   }
 }
+async function runWorkerWithFixTask(ctx, heading, body) {
+  try {
+    await prependFixTask(join14(ctx.changeDir, "tasks.md"), heading, body);
+  } catch (err) {
+    ctx.log(`! could not prepend fix task: ${err.message}`, "red");
+    return 1;
+  }
+  await reactivateState(ctx.stateFilePath, ctx.log, ctx.changeName);
+  return ctx.respawnWorker();
+}
+async function pushWithLeases(ctx) {
+  try {
+    ctx.emit("pushing", "after conflict resolution");
+    await ctx.cmd.run(["git", "push", "origin", ctx.branch], ctx.cwd);
+    return true;
+  } catch (pushErr) {
+    const pe = pushErr;
+    const blob = `${pe.message}
+${pe.stderr ?? ""}`;
+    if (!/non-fast-forward|Updates were rejected/i.test(blob)) {
+      ctx.log(`! push after conflict fix failed: ${pe.message}`, "red");
+      return false;
+    }
+    try {
+      await ctx.cmd.run(["git", "push", "--force-with-lease", "origin", ctx.branch], ctx.cwd);
+      return true;
+    } catch (forceErr) {
+      ctx.log(`! force-push after conflict fix failed: ${forceErr.message}`, "red");
+      return false;
+    }
+  }
+}
+async function commitResidualChanges(ctx, maxAttempts) {
+  let hookFixAttempt = 0;
+  while (true) {
+    ctx.emit("committing", "git status");
+    let dirty = "";
+    try {
+      const status = await ctx.cmd.run(["git", "status", "--porcelain"], ctx.cwd);
+      dirty = status.stdout.trim();
+    } catch (err) {
+      ctx.log(`! git status failed for ${ctx.changeName}: ${err.message}`, "yellow");
+      break;
+    }
+    if (!dirty)
+      break;
+    try {
+      ctx.emit("committing", "git add -A");
+      await ctx.cmd.run(["git", "add", "-A"], ctx.cwd);
+      ctx.emit("committing", "git commit");
+      await ctx.cmd.run(["git", "commit", "-m", `chore(ralph): residual changes for ${ctx.changeName}`], ctx.cwd);
+      ctx.log(`  committed residual changes for ${ctx.changeName}`, "gray");
+      break;
+    } catch (err) {
+      const e = err;
+      const detail = e.stderr?.trim() || e.message;
+      const combined = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+      if (/nothing to commit/i.test(combined) || /empty git commit/i.test(combined))
+        break;
+      if (hookFixAttempt >= maxAttempts) {
+        ctx.log(`! commit rejected for ${ctx.changeName} after ${hookFixAttempt} hook-fix attempts (host pre-commit hook still failing) \u2014 worktree preserved at ${ctx.cwd}`, "red");
+        ctx.log(`    detail: ${detail}`, "red");
+        return { gaveUp: true, hookFixAttempt };
+      }
+      hookFixAttempt += 1;
+      ctx.emit("commit-retry", `${hookFixAttempt}/${maxAttempts}`);
+      ctx.log(`! commit rejected for ${ctx.changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxAttempts})`, "yellow");
+      ctx.log(`    detail: ${detail}`, "yellow");
+      const retryCode = await runWorkerWithFixTask(ctx, "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.
+
+` + combined.trim());
+      if (retryCode !== 0) {
+        ctx.log(`! worker re-run after commit rejection exited code ${retryCode} \u2014 giving up`, "red");
+        return { gaveUp: true, hookFixAttempt };
+      }
+    }
+  }
+  return { gaveUp: false, hookFixAttempt };
+}
+async function createPrWithRetry(ctx, issue, initialHookFixAttempt) {
+  const maxAttempts = ctx.cfg.maxCiFixAttempts;
+  let hookFixAttempt = initialHookFixAttempt;
+  let nonFfRebaseAttempted = false;
+  let pr = null;
+  while (true) {
+    try {
+      ctx.emit("pr-create", "git push + gh pr create");
+      pr = await createPullRequest({ cwd: ctx.cwd, branch: ctx.branch, issue, base: ctx.cfg.prBaseBranch }, ctx.cmd);
+      return { pr, gaveUp: false };
+    } catch (err) {
+      const e = err;
+      const detail = e.stderr?.trim() || e.message;
+      const combined = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+      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;
+        ctx.emit("rebasing", `git pull --rebase origin ${ctx.branch}`);
+        ctx.log(`  non-fast-forward push for ${ctx.changeName} \u2014 rebasing onto origin/${ctx.branch}`, "yellow");
+        try {
+          await ctx.cmd.run(["git", "fetch", "origin", ctx.branch], ctx.cwd);
+          await ctx.cmd.run(["git", "pull", "--rebase", "origin", ctx.branch], ctx.cwd);
+          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) {
+            ctx.log(`! rebase failed for ${ctx.changeName}: ${rebaseErr.message} \u2014 giving up`, "red");
+            return { pr: null, gaveUp: true };
+          }
+          ctx.emit("rebasing", "conflicts detected \u2014 aborting + queueing fix task");
+          try {
+            await ctx.cmd.run(["git", "rebase", "--abort"], ctx.cwd);
+          } catch {}
+          let conflictedFiles = "";
+          try {
+            const r = await ctx.cmd.run(["git", "diff", "--name-only", `HEAD..origin/${ctx.branch}`], ctx.cwd);
+            conflictedFiles = r.stdout.trim();
+          } catch {}
+          if (hookFixAttempt >= maxAttempts) {
+            ctx.log(`! merge conflict on rebase of ${ctx.branch} after ${hookFixAttempt} attempts \u2014 worktree preserved at ${ctx.cwd}`, "red");
+            ctx.log(`    detail: ${reBlob.trim().split(`
+`).slice(0, 8).join(`
+`)}`, "red");
+            return { pr: null, gaveUp: true };
+          }
+          hookFixAttempt += 1;
+          ctx.emit("rebasing", `conflict-fix ${hookFixAttempt}/${maxAttempts}`);
+          ctx.log(`! merge conflict rebasing ${ctx.branch} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxAttempts})`, "yellow");
+          const retryCode2 = await runWorkerWithFixTask(ctx, "Resolve merge conflict with origin/" + ctx.branch, `Push to origin/${ctx.branch} was rejected as non-fast-forward, and rebasing ` + `onto origin/${ctx.branch} produced merge conflicts.
+
+` + `Run \`git fetch origin ${ctx.branch}\` and \`git rebase origin/${ctx.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/${ctx.branch}:
+${conflictedFiles}
+
+` : "") + `Rebase output:
+${reBlob.trim()}`);
+          if (retryCode2 !== 0) {
+            ctx.log(`! worker re-run after merge conflict exited code ${retryCode2} \u2014 giving up`, "red");
+            return { pr: null, gaveUp: true };
+          }
+          nonFfRebaseAttempted = false;
+          continue;
+        }
+      }
+      if (!pushRejected || hookFixAttempt >= maxAttempts) {
+        if (pushRejected) {
+          ctx.log(`! push rejected for ${ctx.changeName} after ${hookFixAttempt} fix attempts (push still failing) \u2014 worktree preserved at ${ctx.cwd}`, "red");
+          ctx.log(`    detail: ${detail}`, "red");
+        } else {
+          ctx.log(`! PR create failed for ${ctx.changeName}: ${detail}`, "red");
+        }
+        return { pr: null, gaveUp: true };
+      }
+      hookFixAttempt += 1;
+      ctx.emit("push-retry", `${hookFixAttempt}/${maxAttempts}`);
+      ctx.log(`! push rejected for ${ctx.changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxAttempts})`, "yellow");
+      ctx.log(`    detail: ${detail}`, "yellow");
+      const retryCode = await runWorkerWithFixTask(ctx, "Fix push rejection", `Push to origin/${ctx.branch} was rejected. Fix the underlying problem ` + `(e.g. failing pre-push hook checks), then the push will be retried.
+
+` + combined.trim());
+      if (retryCode !== 0) {
+        ctx.log(`! worker re-run after push rejection exited code ${retryCode} \u2014 giving up`, "red");
+        return { pr: null, gaveUp: true };
+      }
+    }
+  }
+}
+async function fixConflictsAndCiLoop(ctx, prUrl, wantFixCi, checkPrConflict) {
+  const wantConflictLoop = !!checkPrConflict;
+  const maxOuterAttempts = ctx.cfg.maxCiFixAttempts;
+  let outerAttempt = 0;
+  let ciConfirmedGreen = false;
+  while (outerAttempt < maxOuterAttempts) {
+    if (wantConflictLoop) {
+      ctx.emit("conflict-check");
+      let conflicting = false;
+      try {
+        conflicting = await checkPrConflict(prUrl);
+      } catch (err) {
+        ctx.log(`! conflict check failed: ${err.message}`, "yellow");
+      }
+      if (conflicting) {
+        outerAttempt++;
+        ciConfirmedGreen = false;
+        ctx.emit("conflict-fix-inner", `attempt ${outerAttempt}/${maxOuterAttempts}`);
+        ctx.log(`  merge conflicts on PR (attempt ${outerAttempt}/${maxOuterAttempts}) \u2014 spawning resolution task`, "yellow");
+        const conflictCode = await runWorkerWithFixTask(ctx, "Resolve PR merge conflicts", [
+          `The PR ${prUrl} has merge conflicts with \`${ctx.cfg.prBaseBranch}\`.`,
+          "",
+          "Steps:",
+          `1. \`git fetch origin ${ctx.cfg.prBaseBranch}\` then rebase or merge \`${ctx.cfg.prBaseBranch}\` into the current branch.`,
+          "2. Resolve conflicts in the files git lists.",
+          "3. Stage and commit the resolution."
+        ].join(`
+`));
+        if (conflictCode !== 0) {
+          ctx.log(`! conflict resolution worker exited code ${conflictCode} \u2014 giving up`, "red");
+          return PR_FAILED_EXIT;
+        }
+        const pushed = await pushWithLeases(ctx);
+        if (!pushed)
+          return PR_FAILED_EXIT;
+        continue;
+      }
+    }
+    if (!wantFixCi)
+      break;
+    if (!ciConfirmedGreen) {
+      ctx.log(`  watching CI for ${prUrl} (max ${ctx.cfg.maxCiFixAttempts} fix attempts)`, "gray");
+      ctx.emit("ci-poll", "starting");
+      const result2 = await fixCiUntilGreen({
+        onPhase: (p, d) => ctx.emit(p, d),
+        getStatus: () => getPrChecksStatus(prUrl, ctx.cmd, ctx.cwd, (n, ms, why) => ctx.log(`  gh transient (try ${n}) \u2014 retry in ${Math.round(ms / 1000)}s \xB7 ${why}`, "yellow")),
+        getFailedLogs: (ids) => fetchFailedRunLogs(ids, ctx.cmd, ctx.cwd),
+        runTaskWithSteering: async (steering) => {
+          try {
+            await prependFixTask(join14(ctx.changeDir, "tasks.md"), "Fix failing CI checks", steering);
+          } catch (err) {
+            ctx.log(`! could not prepend fix task: ${err.message}`, "red");
+          }
+          return ctx.respawnWorker();
+        },
+        pushBranch: async () => {
+          await ctx.cmd.run(["git", "push", "origin", ctx.branch], ctx.cwd);
+        },
+        log: ctx.log,
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms))
+      }, {
+        maxAttempts: ctx.cfg.maxCiFixAttempts,
+        pollIntervalSeconds: ctx.cfg.ciPollIntervalSeconds
+      });
+      if (!result2.success) {
+        ctx.log(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
+        return CI_FAILED_EXIT;
+      }
+      ciConfirmedGreen = true;
+    }
+    if (wantConflictLoop) {
+      continue;
+    }
+    return 0;
+  }
+  if (outerAttempt >= maxOuterAttempts) {
+    ctx.log(`! outer fix loop exhausted ${maxOuterAttempts} attempts \u2014 giving up`, "red");
+    return CI_FAILED_EXIT;
+  }
+  return 0;
+}
 async function runPostTask(input, deps) {
   const { log: log2, cmd, git, runScript } = deps;
   const emit = (phase, detail) => deps.onPhase?.(phase, detail);
@@ -71293,201 +71574,33 @@ async function runPostTask(input, deps) {
       log2(`! createPr requested but no worktree branch is tracked for ${changeName} (use --worktree)`, "yellow");
       effectiveCode = PR_FAILED_EXIT;
     } else {
-      const maxHookFixAttempts = cfg.maxCiFixAttempts;
-      const runWorkerWithFixTask = async (heading, failureOutput) => {
-        try {
-          await prependFixTask(join14(changeDir, "tasks.md"), heading, failureOutput);
-        } catch (err) {
-          log2(`! could not prepend fix task: ${err.message}`, "red");
-          return 1;
-        }
-        await reactivateState(stateFilePath, log2, changeName);
-        return respawnWorker();
+      const ctx = {
+        changeName,
+        cwd: cwd2,
+        branch,
+        changeDir,
+        stateFilePath,
+        cfg,
+        cmd,
+        log: log2,
+        emit,
+        respawnWorker
       };
-      let hookFixAttempt = 0;
-      let commitGaveUp = false;
-      while (true) {
-        emit("committing", "git status");
-        let dirty = "";
-        try {
-          const status = await cmd.run(["git", "status", "--porcelain"], cwd2);
-          dirty = status.stdout.trim();
-        } catch (err) {
-          log2(`! git status failed for ${changeName}: ${err.message}`, "yellow");
-          break;
-        }
-        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;
-        } catch (err) {
-          const e = err;
-          const detail = e.stderr?.trim() || e.message;
-          const combined = `${e.stdout ?? ""}
-${e.stderr ?? ""}`;
-          if (/nothing to commit/i.test(combined))
-            break;
-          if (hookFixAttempt >= maxHookFixAttempts) {
-            log2(`! commit rejected for ${changeName} after ${hookFixAttempt} hook-fix attempts (host pre-commit hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
-            log2(`    detail: ${detail}`, "red");
-            effectiveCode = PR_FAILED_EXIT;
-            commitGaveUp = true;
-            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.
-
-` + combined.trim());
-          if (retryCode !== 0) {
-            log2(`! worker re-run after commit rejection exited code ${retryCode} \u2014 giving up`, "red");
-            effectiveCode = PR_FAILED_EXIT;
-            commitGaveUp = true;
-            break;
-          }
-        }
-      }
-      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) {
-          const e = err;
-          const detail = e.stderr?.trim() || e.message;
-          const combined = `${e.stdout ?? ""}
-${e.stderr ?? ""}`;
-          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 (!pushRejected || hookFixAttempt >= maxHookFixAttempts) {
-            if (pushRejected) {
-              log2(`! push rejected for ${changeName} after ${hookFixAttempt} fix attempts (push still failing) \u2014 worktree preserved at ${cwd2}`, "red");
-              log2(`    detail: ${detail}`, "red");
-            } else {
-              log2(`! PR create failed for ${changeName}: ${detail}`, "red");
-            }
-            effectiveCode = PR_FAILED_EXIT;
-            prGaveUp = true;
-            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 push rejection", `Push to origin/${branch} was rejected. Fix the underlying problem ` + `(e.g. failing pre-push hook checks), then the push will be retried.
-
-` + combined.trim());
-          if (retryCode !== 0) {
-            log2(`! worker re-run after push rejection exited code ${retryCode} \u2014 giving up`, "red");
-            effectiveCode = PR_FAILED_EXIT;
-            prGaveUp = true;
-            break;
-          }
-        }
-      }
-      if (prGaveUp) {} else if (!pr) {
-        log2(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
+      const { gaveUp: commitGaveUp, hookFixAttempt } = await commitResidualChanges(ctx, cfg.maxCiFixAttempts);
+      if (commitGaveUp) {
+        effectiveCode = PR_FAILED_EXIT;
       } else {
-        log2(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
-        deps.registerPr?.(changeName, pr.url);
-        if (wantFixCi) {
-          log2(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
-          emit("ci-poll", "starting");
-          const result2 = await fixCiUntilGreen({
-            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 {
-                await prependFixTask(join14(changeDir, "tasks.md"), "Fix failing CI checks", steering);
-              } catch (err) {
-                log2(`! could not prepend fix task: ${err.message}`, "red");
-              }
-              return respawnWorker();
-            },
-            pushBranch: async () => {
-              await cmd.run(["git", "push", "origin", branch], cwd2);
-            },
-            log: log2,
-            sleep: (ms) => new Promise((r) => setTimeout(r, ms))
-          }, {
-            maxAttempts: cfg.maxCiFixAttempts,
-            pollIntervalSeconds: cfg.ciPollIntervalSeconds
-          });
-          if (!result2.success) {
-            log2(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
-            effectiveCode = CI_FAILED_EXIT;
-          }
+        const { pr, gaveUp: prGaveUp } = await createPrWithRetry(ctx, issue, hookFixAttempt);
+        if (prGaveUp) {
+          effectiveCode = PR_FAILED_EXIT;
+        } else if (!pr) {
+          log2(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
+        } else {
+          log2(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
+          deps.registerPr?.(changeName, pr.url);
+          const loopCode = await fixConflictsAndCiLoop(ctx, pr.url, wantFixCi, deps.checkPrConflict);
+          if (loopCode !== 0)
+            effectiveCode = loopCode;
         }
       }
     }
@@ -71664,13 +71777,31 @@ function buildAgentCoordinator(input) {
         teamId = fetched;
         teamIdCache.set(t, teamId);
       }
-      const newId = await createIssueLabel(apiKey, teamId, name);
+      const colonIdx = name.indexOf(":");
+      let parentId;
+      let childName = name;
+      if (colonIdx > 0) {
+        const groupName = name.slice(0, colonIdx);
+        childName = name.slice(colonIdx + 1);
+        const existingGroup = map2.get(groupName.toLowerCase());
+        if (existingGroup) {
+          parentId = existingGroup;
+        } else {
+          const groupId = await createIssueLabel(apiKey, teamId, groupName);
+          if (groupId) {
+            map2.set(groupName.toLowerCase(), groupId);
+            parentId = groupId;
+          }
+        }
+      }
+      const newId = await createIssueLabel(apiKey, teamId, childName, parentId);
       if (!newId)
         return null;
       map2.set(name.toLowerCase(), newId);
       onLog(`  created Linear label '${name}' for team ${t}`, "gray");
       return newId;
-    } catch {
+    } catch (err) {
+      onLog(`! Linear label '${name}' creation threw: ${err.message}`, "yellow");
       return null;
     }
   }
@@ -71897,6 +72028,13 @@ PR: ${prUrl}` : ""
         return null;
       }
     };
+    const ANSI_RE = /\x1b(?:\[[0-9;]*[A-Za-z]|\][^\x07\x1b]*(?:\x07|\x1b\\)|.)/g;
+    const BOX_ONLY_RE = /^[\s\u2500\u2502\u256D\u256E\u2570\u256F\u254C\u2504\u2501\u2503]+$/;
+    const STATUS_BAR_LINE_RE = /^[\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F\u2713\u2717]\s+iter\s+\d+/;
+    const ITER_HEADER_LINE_RE = /^\u2500\u2500/;
+    function isLogWorthy(clean) {
+      return !BOX_ONLY_RE.test(clean) && !STATUS_BAR_LINE_RE.test(clean) && !ITER_HEADER_LINE_RE.test(clean);
+    }
     async function pump(stream, label) {
       if (!stream)
         return;
@@ -71916,16 +72054,18 @@ PR: ${prUrl}` : ""
 `)) >= 0) {
             const line = buf.slice(0, nl);
             buf = buf.slice(nl + 1);
-            if (writer)
-              writer.write(line + `
+            const clean = line.replace(ANSI_RE, "").trim();
+            if (writer && clean && isLogWorthy(clean))
+              writer.write(clean + `
 `);
             if (line)
               onWorkerOutput?.(changeName, label === "err" ? `! ${line}` : line);
           }
         }
         if (buf) {
-          if (writer)
-            writer.write(buf + `
+          const clean = buf.replace(ANSI_RE, "").trim();
+          if (writer && clean && isLogWorthy(clean))
+            writer.write(clean + `
 `);
           onWorkerOutput?.(changeName, label === "err" ? `! ${buf}` : buf);
         }
@@ -72011,6 +72151,14 @@ PR: ${prUrl}` : ""
         },
         ...onWorkerPhase && {
           onPhase: (phase, detail) => onWorkerPhase(changeName, phase, detail)
+        },
+        checkPrConflict: async (prUrl) => {
+          try {
+            const res = await tracedCmd.run(["gh", "pr", "view", prUrl, "--json", "mergeable", "--jq", ".mergeable"], cwd2);
+            return res.stdout.trim() === "CONFLICTING";
+          } catch {
+            return false;
+          }
         }
       });
       cwdByChange.delete(changeName);
@@ -72165,21 +72313,21 @@ function prLabel(prUrl) {
   const m = prUrl.match(/\/pull\/(\d+)/);
   return m ? `#${m[1]}` : "PR";
 }
-var HYPERLINKS_SUPPORTED = (() => {
-  if (process.env["TMUX"])
-    return false;
-  const tp = process.env["TERM_PROGRAM"];
-  if (tp === "iTerm.app" || tp === "WezTerm" || tp === "Hyper")
-    return true;
-  const term = process.env["TERM"];
-  if (term === "xterm-kitty" || term === "foot" || term === "xterm-ghostty")
-    return true;
-  if (process.env["VTE_VERSION"])
-    return true;
-  return false;
-})();
-function osc8(url, label) {
-  return HYPERLINKS_SUPPORTED ? `\x1B]8;;${url}\x07${label}\x1B]8;;\x07` : label;
+var HYPERLINKS_SUPPORTED = !process.env["TMUX"];
+function Link({ url, label, color }) {
+  if (!HYPERLINKS_SUPPORTED)
+    return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+      color,
+      children: label
+    }, undefined, false, undefined, this);
+  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Transform, {
+    transform: (output) => `\x1B]8;;${url}\x07${output}\x1B]8;;\x07`,
+    children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+      color,
+      underline: true,
+      children: label
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
 }
 var ANSI_STRIP_RE = /\x1b(?:\[[0-9;]*[A-Za-z]|\][^\x07\x1b]*(?:\x07|\x1b\\)|.)/g;
 var BOX_ONLY_RE = /^[\s\u2500\u2502\u256D\u256E\u2570\u256F\u254C\u2504\u2501\u2503]+$/;
@@ -72284,10 +72432,16 @@ function displayTailLines(activeCount) {
 }
 var AGENT_LOG_PATH = join16(homedir3(), ".ralph", "agent-mode.log");
 var SESSION_START = new Date().toISOString();
+mkdir4(dirname4(AGENT_LOG_PATH), { recursive: true }).catch(() => {
+  return;
+});
 function writeAgentLog(text) {
-  const line = `[${new Date().toISOString()}] ${text}
+  const clean = text.replace(ANSI_STRIP_RE, "").trim();
+  if (!clean)
+    return;
+  const line = `[${new Date().toISOString()}] ${clean}
 `;
-  Bun.file(AGENT_LOG_PATH).text().catch(() => "").then((existing) => Bun.write(AGENT_LOG_PATH, existing + line)).catch(() => {
+  appendFile(AGENT_LOG_PATH, line).catch(() => {
     return;
   });
 }
@@ -72491,9 +72645,10 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
         setFocusedIdx(n - 1);
     }
   }, { isActive: isRawModeSupported && activeCount > 1 });
-  const FIXED_OVERHEAD = 22;
   const nonFocusedCount = Math.max(0, activeCount - 1);
-  const focusedTailLines = Math.max(5, termHeight - FIXED_OVERHEAD - nonFocusedCount);
+  const tasksBoxLines = activeCount > 0 ? 5 : 0;
+  const FIXED_OVERHEAD = 5 + 5 + tasksBoxLines + 8 + nonFocusedCount * 4;
+  const focusedTailLines = Math.max(3, termHeight - FIXED_OVERHEAD);
   const compactTailLines = displayTailLines(activeCount);
   return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
     flexDirection: "column",
@@ -72993,10 +73148,10 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
                           dimColor: true,
                           children: "\u2197 LINEAR"
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
-                          color: "blue",
-                          underline: HYPERLINKS_SUPPORTED,
-                          children: osc8(w.issue.url, w.issueIdentifier)
+                        /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Link, {
+                          url: w.issue.url,
+                          label: w.issueIdentifier,
+                          color: "blue"
                         }, undefined, false, undefined, this)
                       ]
                     }, undefined, true, undefined, this),
@@ -73007,10 +73162,10 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
                           dimColor: true,
                           children: "\u2197 PR"
                         }, undefined, false, undefined, this),
-                        /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
-                          color: "green",
-                          underline: HYPERLINKS_SUPPORTED,
-                          children: osc8(prUrl, prLabel(prUrl))
+                        /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Link, {
+                          url: prUrl,
+                          label: prLabel(prUrl),
+                          color: "green"
                         }, undefined, false, undefined, this)
                       ]
                     }, undefined, true, undefined, this)
@@ -73119,11 +73274,11 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
 }
 
 // packages/openspec/src/openspec-change-store.ts
-import { join as join17, dirname as dirname4 } from "path";
-import { readdir, mkdir as mkdir4 } from "fs/promises";
+import { join as join17, dirname as dirname5 } from "path";
+import { readdir, mkdir as mkdir5 } 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 join17(dirname5(pkgJsonPath), "bin", "openspec.js");
 }
 function runOpenspec(args, options = {}) {
   const stdio = options.inherit ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"];
@@ -73181,7 +73336,7 @@ class OpenSpecChangeStore {
   }
   async writeTaskList(name, content) {
     const path = join17("openspec", "changes", name, "tasks.md");
-    await mkdir4(dirname4(path), { recursive: true });
+    await mkdir5(dirname5(path), { recursive: true });
     await Bun.write(path, content);
   }
   async appendSteering(name, message) {
@@ -73192,7 +73347,7 @@ class OpenSpecChangeStore {
 
 ${existing.trimStart()}` : `${message}
 `;
-    await mkdir4(dirname4(path), { recursive: true });
+    await mkdir5(dirname5(path), { recursive: true });
     await Bun.write(path, updated);
   }
   async readSection(name, artifact, heading) {
@@ -73403,8 +73558,8 @@ try {
   const statesDir = layout.statesDir;
   const tasksDir = layout.tasksDir;
   if (args.mode === "init") {
-    await mkdir5(statesDir, { recursive: true });
-    const openspecBin = join19(dirname5(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
+    await mkdir6(statesDir, { recursive: true });
+    const openspecBin = join19(dirname6(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"],
@@ -73471,13 +73626,13 @@ try {
     process.exit(0);
   }
   if (args.mode === "task" && args.name) {
-    await mkdir5(join19(statesDir, args.name), { recursive: true });
-    await mkdir5(join19(tasksDir, args.name), { recursive: true });
+    await mkdir6(join19(statesDir, args.name), { recursive: true });
+    await mkdir6(join19(tasksDir, args.name), { recursive: true });
   }
   if (args.mode === "agent") {
-    await mkdir5(statesDir, { recursive: true });
-    await mkdir5(tasksDir, { recursive: true });
-    await mkdir5(join19(projectRoot, ".ralph"), { recursive: true });
+    await mkdir6(statesDir, { recursive: true });
+    await mkdir6(tasksDir, { recursive: true });
+    await mkdir6(join19(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.13.15",
+  "version": "2.14.0",
   "description": "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   "keywords": [
     "agent",