@neriros/ralphy 2.11.1 → 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 join17, 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.1",
+  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 join16 } from "path";
+import { join as join19 } from "path";
 
 // packages/core/src/state.ts
 import { join as join2 } from "path";
@@ -65702,11 +65702,16 @@ async function runEngine(opts) {
     stderr: isClaude ? "inherit" : "pipe",
     ...opts.cwd ? { cwd: opts.cwd } : {}
   });
+  let intentionalKill = false;
+  const killProc = () => {
+    intentionalKill = true;
+    proc.kill();
+  };
   if (opts.signal) {
     if (opts.signal.aborted) {
-      proc.kill();
+      killProc();
     } else {
-      opts.signal.addEventListener("abort", () => proc.kill(), { once: true });
+      opts.signal.addEventListener("abort", killProc, { once: true });
     }
   }
   const stdin = proc.stdin;
@@ -65742,7 +65747,7 @@ async function runEngine(opts) {
   if (opts.signal) {
     const onAbort = () => {
       aborted = true;
-      proc.kill();
+      killProc();
     };
     if (opts.signal.aborted) {
       onAbort();
@@ -65778,7 +65783,7 @@ async function runEngine(opts) {
         emitEvent(event);
       }
       if (claudeState.gotResult) {
-        proc.kill();
+        killProc();
         break;
       }
     }
@@ -65807,7 +65812,7 @@ async function runEngine(opts) {
   }
   await closeRaw();
   const exitCode = await proc.exited;
-  const wasIntentionalKill = (exitCode === 143 || exitCode === 137) && (usage !== null || aborted);
+  const wasIntentionalKill = intentionalKill && (exitCode === 143 || exitCode === 137);
   const normalizedExitCode = wasIntentionalKill ? 0 : exitCode;
   return { exitCode: normalizedExitCode, usage, sessionId, rateLimited: detectedRateLimit };
 }
@@ -69477,8 +69482,9 @@ async function shutdown() {
 
 // packages/core/src/loop.ts
 import { join as join7 } from "path";
-var STEERING_MAX_LINES = 20;
-function extractFirstUncheckedSection(tasksContent) {
+
+// packages/core/src/tasks-md.ts
+function firstUnchecked(tasksContent) {
   const sections = tasksContent.split(/(?=^## )/m);
   for (const section of sections) {
     if (/^## /m.test(section) && /^- \[ \]/m.test(section))
@@ -69488,12 +69494,41 @@ function extractFirstUncheckedSection(tasksContent) {
     return tasksContent.trim();
   return null;
 }
-function countUncheckedTasks(tasksContent) {
+function countUnchecked(tasksContent) {
   return (tasksContent.match(/^- \[ \]/gm) ?? []).length;
 }
-function allTasksCompleted(tasksContent) {
+function allCompleted(tasksContent) {
   return !/^- \[ \]/m.test(tasksContent);
 }
+function prependSection(existing, heading, body) {
+  const section = `## ${heading}
+
+${body.trimEnd()}
+
+`;
+  const headingIdx = existing.search(/^## /m);
+  if (headingIdx === -1) {
+    return existing.trimEnd() + (existing ? `
+
+` : "") + section;
+  }
+  return existing.slice(0, headingIdx) + section + existing.slice(headingIdx);
+}
+async function prependFixTask(tasksPath, heading, failureOutput) {
+  const file = Bun.file(tasksPath);
+  const existing = await file.exists() ? await file.text() : "";
+  const stamped = `${heading} (${new Date().toISOString()})`;
+  const fence = "```";
+  const body = `- [ ] ${heading}. Read the error block below, fix the underlying ` + `problem (do not just retry the failing command), then check this box.
+
+` + `${fence}
+${failureOutput.trim()}
+${fence}`;
+  await Bun.write(tasksPath, prependSection(existing, stamped, body));
+}
+
+// packages/core/src/loop.ts
+var STEERING_MAX_LINES = 20;
 function buildTaskPrompt(state, taskDir) {
   const storage = getStorage();
   let prompt = "";
@@ -69518,7 +69553,7 @@ function buildTaskPrompt(state, taskDir) {
   }
   const tasksContent = storage.read(join7(taskDir, "tasks.md"));
   if (tasksContent !== null) {
-    const section = extractFirstUncheckedSection(tasksContent);
+    const section = firstUnchecked(tasksContent);
     if (section) {
       prompt += `---
 
@@ -69753,10 +69788,10 @@ function useLoop(opts) {
         }
         const tasksContent = storage.read(join8(tasksDir, "tasks.md"));
         if (tasksContent !== null) {
-          const remaining = countUncheckedTasks(tasksContent);
+          const remaining = countUnchecked(tasksContent);
           addInfo(`tasks.md: ${remaining} unchecked item${remaining === 1 ? "" : "s"} remaining`);
         }
-        if (tasksContent !== null && allTasksCompleted(tasksContent)) {
+        if (tasksContent !== null && allCompleted(tasksContent)) {
           addInfo("All tasks completed \u2014 archiving change.");
           currentState = {
             ...currentState,
@@ -70069,6 +70104,170 @@ function TaskLoop({ opts }) {
 
 // apps/cli/src/components/AgentMode.tsx
 var import_react57 = __toESM(require_react(), 1);
+import { join as join17 } from "path";
+
+// apps/cli/src/agent/state.ts
+import { join as join10 } from "path";
+var TaskStateSchema = exports_external.enum(["started", "processed", "failed"]);
+var TaskEntrySchema = exports_external.object({
+  issueId: exports_external.string(),
+  identifier: exports_external.string(),
+  state: TaskStateSchema,
+  changeName: exports_external.string().optional(),
+  startedAt: exports_external.string().optional(),
+  finishedAt: exports_external.string().optional(),
+  exitCode: exports_external.number().optional(),
+  commentPosted: exports_external.boolean().optional()
+});
+var AgentStateSchema = exports_external.object({
+  tasks: exports_external.record(exports_external.string(), TaskEntrySchema).default({}),
+  lastPollAt: exports_external.string().nullable().default(null)
+});
+function statePath(projectRoot) {
+  return join10(projectRoot, ".ralph", "agent-state.json");
+}
+async function readState2(projectRoot) {
+  const file = Bun.file(statePath(projectRoot));
+  if (!await file.exists()) {
+    return AgentStateSchema.parse({});
+  }
+  const raw = await file.json();
+  return AgentStateSchema.parse(raw);
+}
+async function writeState2(projectRoot, state) {
+  await Bun.write(statePath(projectRoot), JSON.stringify(state, null, 2) + `
+`);
+}
+
+class AgentStateStore {
+  projectRoot;
+  state = null;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async load() {
+    this.state = await readState2(this.projectRoot);
+  }
+  snapshot() {
+    if (!this.state) {
+      throw new Error("AgentStateStore: load() must be called before snapshot()");
+    }
+    return this.state;
+  }
+  async upsertTask(issue, patch) {
+    const s = this.snapshot();
+    const existing = s.tasks[issue.identifier];
+    s.tasks[issue.identifier] = {
+      issueId: issue.id,
+      identifier: issue.identifier,
+      state: existing?.state ?? "started",
+      ...existing,
+      ...patch
+    };
+    await this.flush();
+  }
+  async setLastPollAt(when) {
+    const s = this.snapshot();
+    s.lastPollAt = when;
+    await this.flush();
+  }
+  async removeByChangeName(changeName) {
+    const s = this.snapshot();
+    const entry = Object.values(s.tasks).find((t) => t.changeName === changeName);
+    if (!entry)
+      return null;
+    delete s.tasks[entry.identifier];
+    await this.flush();
+    return { identifier: entry.identifier, issueId: entry.issueId };
+  }
+  async flush() {
+    await writeState2(this.projectRoot, this.snapshot());
+  }
+}
+
+// apps/cli/src/agent/config.ts
+import { join as join11 } from "path";
+var RalphyConfigSchema = exports_external.object({
+  concurrency: exports_external.number().int().positive().default(1),
+  pollIntervalSeconds: exports_external.number().int().positive().default(60),
+  maxIterationsPerTask: exports_external.number().int().nonnegative().default(0),
+  maxCostUsdPerTask: exports_external.number().nonnegative().default(0),
+  maxRuntimeMinutesPerTask: exports_external.number().nonnegative().default(0),
+  maxConsecutiveFailuresPerTask: exports_external.number().int().nonnegative().default(5),
+  iterationDelaySeconds: exports_external.number().int().nonnegative().default(0),
+  logRawStream: exports_external.boolean().default(false),
+  taskVerbose: exports_external.boolean().default(false),
+  useWorktree: exports_external.boolean().default(false),
+  cleanupWorktreeOnSuccess: exports_external.boolean().default(false),
+  setupScript: exports_external.string().optional(),
+  teardownScript: exports_external.string().optional(),
+  appendPrompt: exports_external.string().optional(),
+  createPrOnSuccess: exports_external.boolean().default(false),
+  prBaseBranch: exports_external.string().default("main"),
+  fixCiOnFailure: exports_external.boolean().default(false),
+  maxCiFixAttempts: exports_external.number().int().positive().default(5),
+  ciPollIntervalSeconds: exports_external.number().int().positive().default(30),
+  engine: exports_external.enum(["claude", "codex"]).default("claude"),
+  model: exports_external.enum(["haiku", "sonnet", "opus"]).default("opus"),
+  linear: exports_external.object({
+    team: exports_external.string().optional(),
+    assignee: exports_external.string().optional(),
+    statuses: exports_external.array(exports_external.string()).default([]),
+    labels: exports_external.union([exports_external.array(exports_external.string()), exports_external.string()]).transform((v) => typeof v === "string" ? [v] : v).default([]),
+    inProgressStatus: exports_external.string().optional(),
+    doneStatus: exports_external.string().optional(),
+    doneLabel: exports_external.string().optional(),
+    postComments: exports_external.boolean().default(true),
+    updateEveryIterations: exports_external.number().int().nonnegative().default(10)
+  }).default({ statuses: [], labels: [], postComments: true })
+}).default({
+  concurrency: 1,
+  pollIntervalSeconds: 60,
+  maxIterationsPerTask: 0,
+  maxCostUsdPerTask: 0,
+  engine: "claude",
+  model: "opus",
+  linear: { statuses: [], labels: [], postComments: true }
+});
+async function loadRalphyConfig(projectRoot) {
+  const path = join11(projectRoot, "ralphy.config.json");
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return RalphyConfigSchema.parse({});
+  }
+  const raw = await file.json();
+  return RalphyConfigSchema.parse(raw);
+}
+async function ensureRalphyConfig(projectRoot) {
+  const path = join11(projectRoot, "ralphy.config.json");
+  const file = Bun.file(path);
+  if (await file.exists())
+    return path;
+  const defaults2 = RalphyConfigSchema.parse({});
+  await Bun.write(path, JSON.stringify(defaults2, null, 2) + `
+`);
+  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";
+function projectLayout(root) {
+  const statesDir = join12(root, ".ralph", "tasks");
+  const tasksDir = join12(root, "openspec", "changes");
+  return {
+    root,
+    statesDir,
+    tasksDir,
+    agentStateFile: join12(root, ".ralph", "agent-state.json"),
+    changeDir: (name) => join12(tasksDir, name),
+    taskStateDir: (name) => join12(statesDir, name),
+    stateFile: (name) => join12(statesDir, name, STATE_FILE2)
+  };
+}
 
 // apps/cli/src/agent/linear.ts
 var OPEN_STATE_TYPES = ["unstarted", "started", "backlog"];
@@ -70211,300 +70410,78 @@ async function addLabelToIssue(apiKey, issueId, labelId) {
   });
 }
 
-// apps/cli/src/agent/state.ts
-import { join as join10 } from "path";
-var TaskStateSchema = exports_external.enum(["started", "processed", "failed"]);
-var TaskEntrySchema = exports_external.object({
-  issueId: exports_external.string(),
-  identifier: exports_external.string(),
-  state: TaskStateSchema,
-  changeName: exports_external.string().optional(),
-  startedAt: exports_external.string().optional(),
-  finishedAt: exports_external.string().optional(),
-  exitCode: exports_external.number().optional(),
-  commentPosted: exports_external.boolean().optional()
-});
-var AgentStateSchema = exports_external.object({
-  tasks: exports_external.record(exports_external.string(), TaskEntrySchema).default({}),
-  lastPollAt: exports_external.string().nullable().default(null)
-});
-var LegacyAgentStateSchema = exports_external.object({
-  processedIssueIds: exports_external.array(exports_external.string()).default([]),
-  startedIssueIds: exports_external.array(exports_external.string()).default([]),
-  failedIssueIds: exports_external.array(exports_external.string()).default([]),
-  lastPollAt: exports_external.string().nullable().default(null),
-  changeMeta: exports_external.record(exports_external.string(), exports_external.object({ issueId: exports_external.string(), identifier: exports_external.string() })).default({})
-}).partial();
-function migrateLegacy(raw) {
-  const parsed = LegacyAgentStateSchema.safeParse(raw);
-  if (!parsed.success)
-    return AgentStateSchema.parse({});
-  const legacy = parsed.data;
-  const tasks = {};
-  const byIssueId = new Map;
-  for (const [changeName, meta] of Object.entries(legacy.changeMeta ?? {})) {
-    byIssueId.set(meta.issueId, { identifier: meta.identifier, changeName });
-  }
-  const fold = (ids, state) => {
-    for (const issueId of ids ?? []) {
-      const found = byIssueId.get(issueId);
-      if (!found)
+// apps/cli/src/agent/coordinator.ts
+class AgentCoordinator {
+  deps;
+  opts;
+  workers = [];
+  pendingIds = new Set;
+  queue = [];
+  stopped = false;
+  constructor(deps, opts) {
+    this.deps = deps;
+    this.opts = opts;
+  }
+  get activeCount() {
+    return this.workers.length;
+  }
+  get queuedCount() {
+    return this.queue.length;
+  }
+  get activeWorkers() {
+    return this.workers;
+  }
+  async init() {}
+  async pollOnce() {
+    if (this.stopped)
+      return { found: 0, added: 0 };
+    let issues;
+    try {
+      issues = await this.deps.fetchIssues(this.opts.filter);
+    } catch (err) {
+      this.deps.onLog(`! Linear poll failed: ${err.message}`, "red");
+      return { found: 0, added: 0 };
+    }
+    const state = this.deps.store.snapshot();
+    const tasksByIssueId = new Map;
+    for (const entry of Object.values(state.tasks)) {
+      tasksByIssueId.set(entry.issueId, entry);
+    }
+    const isProcessed = (id) => tasksByIssueId.get(id)?.state === "processed";
+    const isFailed = (id) => tasksByIssueId.get(id)?.state === "failed";
+    const queued = new Set(this.queue.map((i) => i.id));
+    const active = new Set(this.workers.map((w) => w.issueId));
+    let added = 0;
+    for (const issue of issues) {
+      if (isProcessed(issue.id))
         continue;
-      tasks[found.identifier] = {
-        issueId,
-        identifier: found.identifier,
-        state,
-        changeName: found.changeName
-      };
+      if (isFailed(issue.id))
+        continue;
+      if (queued.has(issue.id))
+        continue;
+      if (active.has(issue.id))
+        continue;
+      if (this.pendingIds.has(issue.id))
+        continue;
+      const blocker = issue.blockedByIds.find((bid) => !isProcessed(bid));
+      if (blocker !== undefined) {
+        this.deps.onLog(`  \u23F8 ${issue.identifier} skipped \u2014 blocked by unresolved dependency`, "yellow");
+        continue;
+      }
+      this.queue.push(issue);
+      added += 1;
     }
-  };
-  fold(legacy.startedIssueIds, "started");
-  fold(legacy.processedIssueIds, "processed");
-  fold(legacy.failedIssueIds, "failed");
-  for (const issueId of legacy.startedIssueIds ?? []) {
-    const found = byIssueId.get(issueId);
-    if (!found)
-      continue;
-    const entry = tasks[found.identifier];
-    if (entry)
-      entry.commentPosted = true;
-  }
-  return { tasks, lastPollAt: legacy.lastPollAt ?? null };
-}
-function statePath(projectRoot) {
-  return join10(projectRoot, ".ralph", "agent-state.json");
-}
-function looksLegacy(raw) {
-  if (typeof raw !== "object" || raw === null)
-    return false;
-  const r = raw;
-  return "processedIssueIds" in r || "startedIssueIds" in r || "failedIssueIds" in r || "changeMeta" in r;
-}
-async function readAgentState(projectRoot) {
-  const file = Bun.file(statePath(projectRoot));
-  if (!await file.exists()) {
-    return AgentStateSchema.parse({});
-  }
-  const raw = await file.json();
-  if (looksLegacy(raw))
-    return migrateLegacy(raw);
-  return AgentStateSchema.parse(raw);
-}
-async function writeAgentState(projectRoot, state) {
-  await Bun.write(statePath(projectRoot), JSON.stringify(state, null, 2) + `
-`);
-}
-
-// apps/cli/src/agent/scaffold.ts
-import { join as join11 } from "path";
-import { mkdir as mkdir2 } from "fs/promises";
-function changeNameForIssue(issue) {
-  const slug = issue.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
-  return slug ? `${issue.identifier.toLowerCase()}-${slug}` : issue.identifier.toLowerCase();
-}
-async function scaffoldChangeForIssue(tasksDir, statesDir, issue, comments = [], appendPrompt = "") {
-  const name = changeNameForIssue(issue);
-  const changeDir = join11(tasksDir, name);
-  const stateDir = join11(statesDir, name);
-  await mkdir2(changeDir, { recursive: true });
-  await mkdir2(join11(changeDir, "specs"), { recursive: true });
-  await mkdir2(stateDir, { recursive: true });
-  const commentsBlock = comments.length > 0 ? [
-    "",
-    "## Linear comments",
-    "",
-    ...comments.flatMap((c) => [
-      `**${c.user?.name ?? "unknown"}** \u2014 ${c.createdAt}`,
-      "",
-      c.body.trim(),
-      ""
-    ])
-  ] : [];
-  const proposal = [
-    `# ${issue.identifier}: ${issue.title}`,
-    "",
-    `Source: [${issue.identifier}](${issue.url})`,
-    `Status: ${issue.state.name}`,
-    issue.assignee ? `Assignee: ${issue.assignee.name}` : "",
-    issue.labels.length ? `Labels: ${issue.labels.join(", ")}` : "",
-    "",
-    "## Description",
-    "",
-    issue.description?.trim() || "_No description provided in Linear._",
-    ...commentsBlock,
-    ...appendPrompt.trim() ? ["", "## Additional instructions", "", appendPrompt.trim()] : [],
-    "",
-    "## Steering",
-    "",
-    "_Add steering notes here as the loop runs._",
-    ""
-  ].filter((l) => l !== "").join(`
-`);
-  const tasks = [
-    `# Tasks for ${issue.identifier}`,
-    "",
-    "## Subtasks",
-    "",
-    `- [ ] Read the Linear issue at ${issue.url} and break it into concrete subtasks`,
-    `- [ ] Implement the changes described in proposal.md`,
-    `- [ ] Add or update tests covering the new behavior`,
-    `- [ ] Run \`bun run lint\` and \`bun run test\` and fix any failures`,
-    ""
-  ].join(`
-`);
-  const design = [
-    `# Design for ${issue.identifier}`,
-    "",
-    "_Fill in the technical design as you work through the issue._",
-    ""
-  ].join(`
-`);
-  await Bun.write(join11(changeDir, "proposal.md"), proposal);
-  await Bun.write(join11(changeDir, "tasks.md"), tasks);
-  await Bun.write(join11(changeDir, "design.md"), design);
-  return name;
-}
-
-// apps/cli/src/agent/config.ts
-import { join as join12 } from "path";
-var RalphyConfigSchema = exports_external.object({
-  concurrency: exports_external.number().int().positive().default(1),
-  pollIntervalSeconds: exports_external.number().int().positive().default(60),
-  maxIterationsPerTask: exports_external.number().int().nonnegative().default(0),
-  maxCostUsdPerTask: exports_external.number().nonnegative().default(0),
-  maxRuntimeMinutesPerTask: exports_external.number().nonnegative().default(0),
-  maxConsecutiveFailuresPerTask: exports_external.number().int().nonnegative().default(5),
-  iterationDelaySeconds: exports_external.number().int().nonnegative().default(0),
-  logRawStream: exports_external.boolean().default(false),
-  taskVerbose: exports_external.boolean().default(false),
-  useWorktree: exports_external.boolean().default(false),
-  cleanupWorktreeOnSuccess: exports_external.boolean().default(false),
-  setupScript: exports_external.string().optional(),
-  teardownScript: exports_external.string().optional(),
-  appendPrompt: exports_external.string().optional(),
-  createPrOnSuccess: exports_external.boolean().default(false),
-  prBaseBranch: exports_external.string().default("main"),
-  fixCiOnFailure: exports_external.boolean().default(false),
-  maxCiFixAttempts: exports_external.number().int().positive().default(5),
-  ciPollIntervalSeconds: exports_external.number().int().positive().default(30),
-  engine: exports_external.enum(["claude", "codex"]).default("claude"),
-  model: exports_external.enum(["haiku", "sonnet", "opus"]).default("opus"),
-  linear: exports_external.object({
-    team: exports_external.string().optional(),
-    assignee: exports_external.string().optional(),
-    statuses: exports_external.array(exports_external.string()).default([]),
-    labels: exports_external.union([exports_external.array(exports_external.string()), exports_external.string()]).transform((v) => typeof v === "string" ? [v] : v).default([]),
-    inProgressStatus: exports_external.string().optional(),
-    doneStatus: exports_external.string().optional(),
-    doneLabel: exports_external.string().optional(),
-    postComments: exports_external.boolean().default(true),
-    updateEveryIterations: exports_external.number().int().nonnegative().default(10)
-  }).default({ statuses: [], labels: [], postComments: true })
-}).default({
-  concurrency: 1,
-  pollIntervalSeconds: 60,
-  maxIterationsPerTask: 0,
-  maxCostUsdPerTask: 0,
-  engine: "claude",
-  model: "opus",
-  linear: { statuses: [], labels: [], postComments: true }
-});
-async function loadRalphyConfig(projectRoot) {
-  const path = join12(projectRoot, "ralphy.config.json");
-  const file = Bun.file(path);
-  if (!await file.exists()) {
-    return RalphyConfigSchema.parse({});
-  }
-  const raw = await file.json();
-  return RalphyConfigSchema.parse(raw);
-}
-async function ensureRalphyConfig(projectRoot) {
-  const path = join12(projectRoot, "ralphy.config.json");
-  const file = Bun.file(path);
-  if (await file.exists())
-    return path;
-  const defaults2 = RalphyConfigSchema.parse({});
-  await Bun.write(path, JSON.stringify(defaults2, null, 2) + `
-`);
-  return path;
-}
-
-// apps/cli/src/agent/coordinator.ts
-class AgentCoordinator {
-  deps;
-  opts;
-  workers = [];
-  pendingIds = new Set;
-  queue = [];
-  state = null;
-  stopped = false;
-  constructor(deps, opts) {
-    this.deps = deps;
-    this.opts = opts;
-  }
-  get activeCount() {
-    return this.workers.length;
-  }
-  get queuedCount() {
-    return this.queue.length;
-  }
-  get activeWorkers() {
-    return this.workers;
-  }
-  async init() {
-    this.state = await this.deps.loadState();
-  }
-  async pollOnce() {
-    if (this.stopped)
-      return { found: 0, added: 0 };
-    let issues;
-    try {
-      issues = await this.deps.fetchIssues(this.opts.filter);
-    } catch (err) {
-      this.deps.onLog(`! Linear poll failed: ${err.message}`, "red");
-      return { found: 0, added: 0 };
-    }
-    const state = this.state;
-    const tasksByIssueId = new Map;
-    for (const entry of Object.values(state.tasks)) {
-      tasksByIssueId.set(entry.issueId, entry);
-    }
-    const isProcessed = (id) => tasksByIssueId.get(id)?.state === "processed";
-    const isFailed = (id) => tasksByIssueId.get(id)?.state === "failed";
-    const queued = new Set(this.queue.map((i) => i.id));
-    const active = new Set(this.workers.map((w) => w.issueId));
-    let added = 0;
-    for (const issue of issues) {
-      if (isProcessed(issue.id))
-        continue;
-      if (isFailed(issue.id))
-        continue;
-      if (queued.has(issue.id))
-        continue;
-      if (active.has(issue.id))
-        continue;
-      if (this.pendingIds.has(issue.id))
-        continue;
-      const blocker = issue.blockedByIds.find((bid) => !isProcessed(bid));
-      if (blocker !== undefined) {
-        this.deps.onLog(`  \u23F8 ${issue.identifier} skipped \u2014 blocked by unresolved dependency`, "yellow");
-        continue;
-      }
-      this.queue.push(issue);
-      added += 1;
-    }
-    if (added > 0) {
-      this.queue.sort((a, b) => {
-        const pa = a.priority === 0 ? Infinity : a.priority;
-        const pb = b.priority === 0 ? Infinity : b.priority;
-        return pa - pb;
-      });
-    }
-    state.lastPollAt = new Date().toISOString();
-    await this.deps.saveState(state);
-    this.spawnNext();
-    await this.reportProgress();
-    return { found: issues.length, added };
+    if (added > 0) {
+      this.queue.sort((a, b) => {
+        const pa = a.priority === 0 ? Infinity : a.priority;
+        const pb = b.priority === 0 ? Infinity : b.priority;
+        return pa - pb;
+      });
+    }
+    await this.deps.store.setLastPollAt(new Date().toISOString());
+    this.spawnNext();
+    await this.reportProgress();
+    return { found: issues.length, added };
   }
   async reportProgress() {
     const updater = this.deps.updater;
@@ -70535,7 +70512,7 @@ class AgentCoordinator {
     }
   }
   spawnNext() {
-    if (this.stopped || !this.state)
+    if (this.stopped)
       return;
     while (this.workers.length + this.pendingIds.size < this.opts.concurrency && this.queue.length > 0) {
       const issue = this.queue.shift();
@@ -70543,18 +70520,6 @@ class AgentCoordinator {
       this.launchWorker(issue);
     }
   }
-  upsertTask(issue, patch) {
-    if (!this.state)
-      return;
-    const existing = this.state.tasks[issue.identifier];
-    this.state.tasks[issue.identifier] = {
-      issueId: issue.id,
-      identifier: issue.identifier,
-      state: existing?.state ?? "started",
-      ...existing,
-      ...patch
-    };
-  }
   async launchWorker(issue) {
     let changeName;
     try {
@@ -70569,13 +70534,13 @@ class AgentCoordinator {
       this.pendingIds.delete(issue.id);
       return;
     }
-    if (this.state) {
-      this.upsertTask(issue, {
+    {
+      const existing = this.deps.store.snapshot().tasks[issue.identifier];
+      this.deps.store.upsertTask(issue, {
         state: "started",
         changeName,
-        startedAt: this.state.tasks[issue.identifier]?.startedAt ?? new Date().toISOString()
+        startedAt: existing?.startedAt ?? new Date().toISOString()
       });
-      this.deps.saveState(this.state);
     }
     this.deps.onLog(`\u25B6 ${issue.identifier} \u2192 ${changeName} (worker started)`, "cyan");
     const handle = this.deps.spawnWorker(changeName, issue);
@@ -70597,14 +70562,11 @@ class AgentCoordinator {
         this.workers.splice(idx, 1);
       const ok = code === 0;
       this.deps.onLog(`${ok ? "\u2713" : "\u2717"} ${issue.identifier} \u2192 ${changeName} exited (code ${code})`, ok ? "green" : "red");
-      if (this.state) {
-        this.upsertTask(issue, {
-          state: ok ? "processed" : "failed",
-          finishedAt: new Date().toISOString(),
-          exitCode: code
-        });
-        this.deps.saveState(this.state);
-      }
+      this.deps.store.upsertTask(issue, {
+        state: ok ? "processed" : "failed",
+        finishedAt: new Date().toISOString(),
+        exitCode: code
+      });
       this.notifyExited(issue, changeName, code);
       this.deps.onWorkersChanged();
       this.spawnNext();
@@ -70614,14 +70576,11 @@ class AgentCoordinator {
     const updater = this.deps.updater;
     if (!updater)
       return;
-    const alreadyCommented = this.state?.tasks[issue.identifier]?.commentPosted === true;
+    const alreadyCommented = this.deps.store.snapshot().tasks[issue.identifier]?.commentPosted === true;
     if (this.opts.postComments !== false && !alreadyCommented) {
       try {
         await updater.postComment(issue, `\uD83E\uDD16 Ralph started working on this issue. Tracking change: \`${changeName}\``);
-        if (this.state) {
-          this.upsertTask(issue, { commentPosted: true });
-          await this.deps.saveState(this.state);
-        }
+        await this.deps.store.upsertTask(issue, { commentPosted: true });
       } catch (err) {
         this.deps.onLog(`! Linear comment failed for ${issue.identifier}: ${err.message}`, "red");
       }
@@ -70694,66 +70653,137 @@ class AgentCoordinator {
   }
 }
 
-// apps/cli/src/agent/worktree.ts
-import { basename, join as join13 } from "path";
-import { homedir as homedir2 } from "os";
-function worktreesDir(projectRoot) {
-  return join13(homedir2(), ".ralph", basename(projectRoot), "worktrees");
-}
-function branchForChange(changeName) {
-  return `ralph/${changeName}`;
-}
-async function createWorktree(projectRoot, changeName, runner) {
-  const dir = worktreesDir(projectRoot);
-  const cwd2 = join13(dir, changeName);
-  const branch = branchForChange(changeName);
-  const list = await runner.run(["worktree", "list", "--porcelain"], projectRoot);
-  if (list.stdout.includes(`worktree ${cwd2}
-`)) {
-    return { cwd: cwd2, branch };
-  }
-  let branchExists = true;
-  try {
-    await runner.run(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], projectRoot);
-  } catch {
-    branchExists = false;
-  }
-  const cmd = branchExists ? ["worktree", "add", cwd2, branch] : ["worktree", "add", "-b", branch, cwd2];
-  await runner.run(cmd, projectRoot);
-  return { cwd: cwd2, branch };
-}
-async function removeWorktree(projectRoot, cwd2, runner) {
-  await runner.run(["worktree", "remove", "--force", cwd2], projectRoot);
+// apps/cli/src/agent/scaffold.ts
+import { join as join13 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+function changeNameForIssue(issue) {
+  const slug = issue.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return slug ? `${issue.identifier.toLowerCase()}-${slug}` : issue.identifier.toLowerCase();
 }
-async function isWorktreeSafeToRemove(cwd2, base2, runner) {
-  const status = await runner.run(["status", "--porcelain"], cwd2);
-  const dirty = status.stdout.trim();
-  let unpushedCommits = "";
-  try {
-    const log2 = await runner.run(["log", "--oneline", `${base2}..HEAD`, "--no-merges"], cwd2);
-    unpushedCommits = log2.stdout.trim();
-  } catch {
-    unpushedCommits = "<unknown: failed to compare against base>";
-  }
-  if (dirty && unpushedCommits) {
-    return {
-      safe: false,
-      reason: "uncommitted changes AND unpushed commits present",
-      dirty,
-      unpushedCommits
-    };
-  }
-  if (dirty) {
-    return {
-      safe: false,
-      reason: "uncommitted or untracked files present",
-      dirty,
-      unpushedCommits
-    };
-  }
-  if (unpushedCommits) {
-    return {
-      safe: false,
+async function scaffoldChangeForIssue(tasksDir, statesDir, issue, comments = [], appendPrompt = "") {
+  const name = changeNameForIssue(issue);
+  const changeDir = join13(tasksDir, name);
+  const stateDir = join13(statesDir, name);
+  await mkdir2(changeDir, { recursive: true });
+  await mkdir2(join13(changeDir, "specs"), { recursive: true });
+  await mkdir2(stateDir, { recursive: true });
+  const commentsBlock = comments.length > 0 ? [
+    "",
+    "## Linear comments",
+    "",
+    ...comments.flatMap((c) => [
+      `**${c.user?.name ?? "unknown"}** \u2014 ${c.createdAt}`,
+      "",
+      c.body.trim(),
+      ""
+    ])
+  ] : [];
+  const proposal = [
+    `# ${issue.identifier}: ${issue.title}`,
+    "",
+    `Source: [${issue.identifier}](${issue.url})`,
+    `Status: ${issue.state.name}`,
+    issue.assignee ? `Assignee: ${issue.assignee.name}` : "",
+    issue.labels.length ? `Labels: ${issue.labels.join(", ")}` : "",
+    "",
+    "## Description",
+    "",
+    issue.description?.trim() || "_No description provided in Linear._",
+    ...commentsBlock,
+    ...appendPrompt.trim() ? ["", "## Additional instructions", "", appendPrompt.trim()] : [],
+    "",
+    "## Steering",
+    "",
+    "_Add steering notes here as the loop runs._",
+    ""
+  ].filter((l) => l !== "").join(`
+`);
+  const tasks = [
+    `# Tasks for ${issue.identifier}`,
+    "",
+    "## Subtasks",
+    "",
+    `- [ ] Read the Linear issue at ${issue.url} and break it into concrete subtasks`,
+    `- [ ] Implement the changes described in proposal.md`,
+    `- [ ] Add or update tests covering the new behavior`,
+    `- [ ] Run \`bun run lint\` and \`bun run test\` and fix any failures`,
+    ""
+  ].join(`
+`);
+  const design = [
+    `# Design for ${issue.identifier}`,
+    "",
+    "_Fill in the technical design as you work through the issue._",
+    ""
+  ].join(`
+`);
+  await Bun.write(join13(changeDir, "proposal.md"), proposal);
+  await Bun.write(join13(changeDir, "tasks.md"), tasks);
+  await Bun.write(join13(changeDir, "design.md"), design);
+  return name;
+}
+
+// apps/cli/src/agent/worktree.ts
+import { basename, join as join14 } from "path";
+import { homedir as homedir2 } from "os";
+import { exists } from "fs/promises";
+function worktreesDir(projectRoot) {
+  return join14(homedir2(), ".ralph", basename(projectRoot), "worktrees");
+}
+function branchForChange(changeName) {
+  return `ralph/${changeName}`;
+}
+async function createWorktree(projectRoot, changeName, runner) {
+  const dir = worktreesDir(projectRoot);
+  const cwd2 = join14(dir, changeName);
+  const branch = branchForChange(changeName);
+  const list = await runner.run(["worktree", "list", "--porcelain"], projectRoot);
+  if (list.stdout.includes(`worktree ${cwd2}
+`)) {
+    return { cwd: cwd2, branch };
+  }
+  let branchExists = true;
+  try {
+    await runner.run(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], projectRoot);
+  } catch {
+    branchExists = false;
+  }
+  const cmd = branchExists ? ["worktree", "add", cwd2, branch] : ["worktree", "add", "-b", branch, cwd2];
+  await runner.run(cmd, projectRoot);
+  return { cwd: cwd2, branch };
+}
+async function removeWorktree(projectRoot, cwd2, runner) {
+  await runner.run(["worktree", "remove", "--force", cwd2], projectRoot);
+}
+async function isWorktreeSafeToRemove(cwd2, base2, runner) {
+  const status = await runner.run(["status", "--porcelain"], cwd2);
+  const dirty = status.stdout.trim();
+  let unpushedCommits = "";
+  try {
+    const log2 = await runner.run(["log", "--oneline", `${base2}..HEAD`, "--no-merges"], cwd2);
+    unpushedCommits = log2.stdout.trim();
+  } catch {
+    unpushedCommits = "<unknown: failed to compare against base>";
+  }
+  if (dirty && unpushedCommits) {
+    return {
+      safe: false,
+      reason: "uncommitted changes AND unpushed commits present",
+      dirty,
+      unpushedCommits
+    };
+  }
+  if (dirty) {
+    return {
+      safe: false,
+      reason: "uncommitted or untracked files present",
+      dirty,
+      unpushedCommits
+    };
+  }
+  if (unpushedCommits) {
+    return {
+      safe: false,
       reason: `commits ahead of ${base2} were not pushed/PR'd`,
       dirty,
       unpushedCommits
@@ -70761,6 +70791,32 @@ async function isWorktreeSafeToRemove(cwd2, base2, runner) {
   }
   return { safe: true, dirty, unpushedCommits };
 }
+async function seedWorktreeMcpConfig(projectRoot, worktreeCwd) {
+  const dst = join14(worktreeCwd, ".mcp.json");
+  const src = join14(projectRoot, ".mcp.json");
+  const source = await exists(dst) ? dst : await exists(src) ? src : null;
+  if (!source)
+    return;
+  let parsed;
+  try {
+    parsed = await Bun.file(source).json();
+  } catch {
+    return;
+  }
+  const servers = parsed.mcpServers;
+  if (servers && typeof servers === "object") {
+    for (const cfg of Object.values(servers)) {
+      if (Array.isArray(cfg.args)) {
+        cfg.args = cfg.args.map((a) => typeof a === "string" && a.startsWith(".ralph/") ? join14(projectRoot, a) : a);
+      }
+    }
+  }
+  await Bun.write(dst, JSON.stringify(parsed, null, 2) + `
+`);
+}
+
+// apps/cli/src/agent/post-task.ts
+import { join as join15 } from "path";
 
 // apps/cli/src/agent/pr.ts
 function defaultTitle(issue) {
@@ -70811,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: [] };
@@ -70849,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:
 
 \`\`\`
@@ -70870,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");
@@ -70877,39 +70969,297 @@ ${logs}
         }
         break;
       }
+      deps.onPhase?.("ci-poll", `attempt ${attempt2}/${opts.maxAttempts} \xB7 pending, waiting`);
       await deps.sleep(opts.pollIntervalSeconds * 1000);
     }
   }
   return { success: false, attempts: opts.maxAttempts, reason: "max-attempts" };
 }
 
-// apps/cli/src/components/AgentMode.tsx
-var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
-import { join as join14 } from "path";
-import { exists } from "fs/promises";
-async function seedWorktreeMcpConfig(projectRoot, worktreeCwd) {
-  const dst = join14(worktreeCwd, ".mcp.json");
-  const src = join14(projectRoot, ".mcp.json");
-  const source = await exists(dst) ? dst : await exists(src) ? src : null;
-  if (!source)
+// apps/cli/src/agent/post-task.ts
+var CI_FAILED_EXIT = 70;
+var PR_FAILED_EXIT = 71;
+async function reactivateState(stateFilePath, log2, changeName) {
+  const file = Bun.file(stateFilePath);
+  if (!await file.exists())
     return;
-  let parsed;
   try {
-    parsed = await Bun.file(source).json();
-  } catch {
-    return;
+    const stateObj = JSON.parse(await file.text());
+    if (stateObj.status !== "active") {
+      stateObj.status = "active";
+      stateObj.lastModified = new Date().toISOString();
+      await Bun.write(stateFilePath, JSON.stringify(stateObj, null, 2) + `
+`);
+    }
+  } catch (err) {
+    log2(`! could not reactivate state for ${changeName}: ${err.message}`, "yellow");
   }
-  const servers = parsed.mcpServers;
-  if (servers && typeof servers === "object") {
-    for (const cfg of Object.values(servers)) {
-      if (Array.isArray(cfg.args)) {
-        cfg.args = cfg.args.map((a) => typeof a === "string" && a.startsWith(".ralph/") ? join14(projectRoot, a) : a);
+}
+async function runPostTask(input, deps) {
+  const { log: log2, cmd, git, runScript } = deps;
+  const emit = (phase, detail) => deps.onPhase?.(phase, detail);
+  const {
+    changeName,
+    cwd: cwd2,
+    projectRoot,
+    changeDir,
+    stateFilePath,
+    branch,
+    issue,
+    exitCode,
+    useWorktree,
+    wantPr,
+    wantFixCi,
+    cfg,
+    respawnWorker
+  } = input;
+  if (cfg.teardownScript) {
+    emit("teardown", cfg.teardownScript);
+    try {
+      await runScript("teardown", cfg.teardownScript, cwd2);
+    } catch {}
+  }
+  let effectiveCode = exitCode;
+  const ok = exitCode === 0;
+  if (ok && wantPr) {
+    if (!branch || !issue) {
+      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(join15(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();
+      };
+      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 (!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");
+            } 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 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.
+
+` + 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");
+      } else {
+        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({
+            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(join15(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;
+          }
+        }
       }
     }
   }
-  await Bun.write(dst, JSON.stringify(parsed, null, 2) + `
-`);
+  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,
+        reason: `safety check failed: ${err.message}`,
+        dirty: "",
+        unpushedCommits: ""
+      }));
+      if (!check.safe) {
+        log2(`! preserving worktree for ${changeName}: ${check.reason}`, "yellow");
+        if (check.dirty)
+          log2(`    uncommitted:
+${check.dirty}`, "yellow");
+        if (check.unpushedCommits)
+          log2(`    commits:
+${check.unpushedCommits}`, "yellow");
+        log2(`    path: ${cwd2}`, "yellow");
+      } else {
+        try {
+          await removeWorktree(projectRoot, cwd2, git);
+          log2(`  removed worktree ${cwd2}`, "gray");
+        } catch (err) {
+          log2(`! worktree remove failed for ${changeName}: ${err.message}`, "yellow");
+        }
+      }
+    }
+  }
+  return effectiveCode;
 }
+
+// apps/cli/src/agent/wire.ts
 var bunGitRunner = {
   run: async (args, cwd2) => {
     const proc = Bun.spawn({ cmd: ["git", ...args], cwd: cwd2, stdout: "pipe", stderr: "pipe" });
@@ -70943,35 +71293,346 @@ 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,
+    cfg,
+    projectRoot,
+    statesDir,
+    tasksDir,
+    apiKey,
+    store,
+    onLog,
+    onWorkersChanged,
+    onWorkerStarted,
+    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;
+  const baseStatuses = args.linearStatus.length ? args.linearStatus : cfg.linear.statuses;
+  const effectiveStatuses = inProgressName && baseStatuses.length > 0 && !baseStatuses.includes(inProgressName) ? [...baseStatuses, inProgressName] : baseStatuses;
+  const filter2 = {
+    team: args.linearTeam || cfg.linear.team,
+    assignee: args.linearAssignee || cfg.linear.assignee,
+    statuses: effectiveStatuses,
+    labels: args.linearLabel.length ? args.linearLabel : cfg.linear.labels
+  };
+  const stateCache = new Map;
+  const labelCache = new Map;
+  const teamKeyOf = (issue) => issue.identifier.split("-")[0];
+  const useWorktree = args.worktree || cfg.useWorktree;
+  const cwdByChange = new Map;
+  const statesDirByChange = new Map;
+  const branchByChange = new Map;
+  const issueByChange = new Map;
+  async function runScript(label, cmd, cwd2) {
+    onLog(`  ${label}: ${cmd}`, "gray");
+    const proc = Bun.spawn({
+      cmd: ["sh", "-c", cmd],
+      cwd: cwd2,
+      stdout: "ignore",
+      stderr: "pipe",
+      stdin: "ignore"
+    });
+    const code = await proc.exited;
+    if (code !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      onLog(`! ${label} exited code ${code}${stderr ? `: ${stderr.trim().split(`
+`)[0]}` : ""}`, "yellow");
+    }
+  }
+  async function scaffoldCallback(issue) {
+    let comments = [];
+    try {
+      comments = await fetchIssueComments(apiKey, issue.id);
+    } catch (err) {
+      onLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
+    }
+    let workerCwd = projectRoot;
+    let scaffoldTasksDir = tasksDir;
+    let scaffoldStatesDir = statesDir;
+    let workerBranch = null;
+    const probeName = issue.identifier.toLowerCase();
+    if (useWorktree) {
+      try {
+        const wt = await createWorktree(projectRoot, probeName, bunGitRunner);
+        workerCwd = wt.cwd;
+        workerBranch = wt.branch;
+        const wtLayout = projectLayout(wt.cwd);
+        scaffoldTasksDir = wtLayout.tasksDir;
+        scaffoldStatesDir = wtLayout.statesDir;
+        onLog(`  ${issue.identifier} worktree: ${wt.cwd} (${wt.branch})`, "gray");
+        try {
+          await seedWorktreeMcpConfig(projectRoot, wt.cwd);
+        } catch (err) {
+          onLog(`! seeding .mcp.json failed for ${issue.identifier}: ${err.message}`, "yellow");
+        }
+      } catch (err) {
+        onLog(`! worktree create failed for ${issue.identifier}: ${err.message} \u2014 falling back to project root`, "yellow");
+      }
+    }
+    const appendPrompt = args.prompt || cfg.appendPrompt || "";
+    const changeName = await scaffoldChangeForIssue(scaffoldTasksDir, scaffoldStatesDir, issue, comments, appendPrompt);
+    cwdByChange.set(changeName, workerCwd);
+    statesDirByChange.set(changeName, scaffoldStatesDir);
+    issueByChange.set(changeName, issue);
+    if (workerBranch)
+      branchByChange.set(changeName, workerBranch);
+    if (cfg.setupScript) {
+      await runScript("setup", cfg.setupScript, workerCwd);
+    }
+    return changeName;
+  }
+  function buildTaskCmdFor(changeName) {
+    const c = [
+      process.execPath,
+      process.argv[1] ?? "",
+      "task",
+      "--name",
+      changeName,
+      "--" + (args.engineSet ? args.engine : cfg.engine),
+      args.engineSet ? args.model : cfg.model
+    ];
+    const maxIter = args.maxIterations || cfg.maxIterationsPerTask;
+    if (maxIter > 0)
+      c.push("--max-iterations", String(maxIter));
+    const maxCost = args.maxCostUsd || cfg.maxCostUsdPerTask;
+    if (maxCost > 0)
+      c.push("--max-cost", String(maxCost));
+    const maxRuntime = args.maxRuntimeMinutes || cfg.maxRuntimeMinutesPerTask;
+    if (maxRuntime > 0)
+      c.push("--max-runtime", String(maxRuntime));
+    const maxFailures = args.maxConsecutiveFailures !== 5 ? args.maxConsecutiveFailures : cfg.maxConsecutiveFailuresPerTask;
+    if (maxFailures !== 5)
+      c.push("--max-failures", String(maxFailures));
+    const delay2 = args.delay || cfg.iterationDelaySeconds;
+    if (delay2 > 0)
+      c.push("--delay", String(delay2));
+    if (args.log || cfg.logRawStream)
+      c.push("--log");
+    if (args.verbose || cfg.taskVerbose)
+      c.push("--verbose");
+    return c;
+  }
+  function spawnWorker(changeName) {
+    const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
+    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: "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 = 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) => {
+      const workerLayout = projectLayout(cwd2);
+      const effectiveCode = await runPostTask({
+        changeName,
+        cwd: cwd2,
+        projectRoot,
+        changeDir: workerLayout.changeDir(changeName),
+        stateFilePath: workerLayout.stateFile(changeName),
+        branch: branchByChange.get(changeName) ?? null,
+        issue: issueByChange.get(changeName) ?? null,
+        exitCode: code,
+        useWorktree,
+        wantPr,
+        wantFixCi,
+        cfg: {
+          teardownScript: cfg.teardownScript ?? null,
+          prBaseBranch: cfg.prBaseBranch,
+          maxCiFixAttempts: cfg.maxCiFixAttempts,
+          ciPollIntervalSeconds: cfg.ciPollIntervalSeconds,
+          cleanupWorktreeOnSuccess: cfg.cleanupWorktreeOnSuccess
+        },
+        respawnWorker: respawn
+      }, {
+        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);
+      issueByChange.delete(changeName);
+      onWorkerExited(changeName);
+      return effectiveCode;
+    });
+    return { exited: wrapped, kill: () => proc.kill() };
+  }
+  const coord = new AgentCoordinator({
+    fetchIssues: (f2) => fetchOpenIssues(apiKey, f2),
+    scaffold: scaffoldCallback,
+    spawnWorker,
+    store,
+    onLog,
+    onWorkersChanged,
+    getIterationCount: async (changeName) => {
+      const root = cwdByChange.get(changeName) ?? projectRoot;
+      const file = Bun.file(projectLayout(root).stateFile(changeName));
+      if (!await file.exists())
+        return 0;
+      const json = await file.json();
+      return json.iteration ?? 0;
+    },
+    updater: {
+      postComment: (issue, body) => addIssueComment(apiKey, issue.id, body),
+      setState: (issue, stateId) => updateIssueState(apiKey, issue.id, stateId),
+      resolveStateId: async (issue, stateName) => {
+        const team = teamKeyOf(issue);
+        let map2 = stateCache.get(team);
+        if (!map2) {
+          const states = await fetchWorkflowStates(apiKey, team);
+          map2 = new Map(states.map((s) => [s.name.toLowerCase(), s.id]));
+          stateCache.set(team, map2);
+        }
+        return map2.get(stateName.toLowerCase()) ?? null;
+      },
+      addLabel: (issue, labelId) => addLabelToIssue(apiKey, issue.id, labelId),
+      resolveLabelId: async (issue, labelName) => {
+        const team = teamKeyOf(issue);
+        let map2 = labelCache.get(team);
+        if (!map2) {
+          const labels = await fetchIssueLabels(apiKey, team);
+          map2 = new Map(labels.map((l) => [l.name.toLowerCase(), l.id]));
+          labelCache.set(team, map2);
+        }
+        return map2.get(labelName.toLowerCase()) ?? null;
+      }
+    }
+  }, {
+    concurrency,
+    filter: filter2,
+    inProgressStatus: args.inProgressStatus || cfg.linear.inProgressStatus,
+    doneStatus: args.doneStatus || cfg.linear.doneStatus,
+    doneLabel: args.doneLabel || cfg.linear.doneLabel,
+    postComments: cfg.linear.postComments,
+    commentEveryIterations: cfg.linear.updateEveryIterations
+  });
+  const filterDesc = `team=${filter2.team ?? "*"}, assignee=${filter2.assignee ?? "*"}, statuses=` + `${filter2.statuses?.length ? filter2.statuses.join(",") : "open"}` + `${filter2.labels?.length ? `, labels=${filter2.labels.join(",")}` : ""}`;
+  return {
+    coord,
+    filterDesc,
+    concurrency,
+    pollInterval,
+    getWorkerCwd: (changeName) => cwdByChange.get(changeName)
+  };
+}
+
+// apps/cli/src/components/AgentMode.tsx
+var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
 var lineCounter = 0;
 function nextId() {
   lineCounter += 1;
   return `${Date.now()}-${lineCounter}`;
 }
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-async function injectFixSteering(changeDir, heading, steering) {
-  const steeringFile = Bun.file(join14(changeDir, "steering.md"));
-  const existing = await steeringFile.exists() ? await steeringFile.text() : "";
-  const stamped = `## ${heading} (${new Date().toISOString()})
-
-${steering}
-`;
-  const nextSteering = existing ? `${stamped}
-${existing.trimStart()}` : `${stamped}
-`;
-  await Bun.write(join14(changeDir, "steering.md"), nextSteering);
-  const tasksFile = Bun.file(join14(changeDir, "tasks.md"));
-  const tasks = await tasksFile.exists() ? await tasksFile.text() : "";
-  const taskSection = `
-## ${heading} (${new Date().toISOString()})
-
-` + `- [ ] ${heading}. The error output is recorded in steering.md \u2014 read it first, ` + `then fix the underlying problem (do not just retry the failing command).
-`;
-  const nextTasks = tasks.endsWith(`
-`) ? tasks + taskSection : tasks + `
-` + taskSection;
-  await Bun.write(join14(changeDir, "tasks.md"), nextTasks);
+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);
   if (s < 60)
@@ -70991,7 +71652,6 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
   const coordRef = import_react57.useRef(null);
   const workerMetaRef = import_react57.useRef(new Map);
   const nextPollAtRef = import_react57.useRef(0);
-  const pollIntervalRef = import_react57.useRef(0);
   const [pollStatus, setPollStatus] = import_react57.useState({ state: "idle", lastFound: null, lastAdded: null, lastAt: null, filterDesc: "" });
   function appendLog(text, color) {
     setLogs((prev) => [...prev, { id: nextId(), text, color }]);
@@ -71002,389 +71662,74 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
     async function init2() {
       const cfgPath = await ensureRalphyConfig(projectRoot);
       const cfg = await loadRalphyConfig(projectRoot);
-      appendLog(`agent mode \u2014 config: ${cfgPath}`, "gray");
-      const concurrency = args.concurrency || cfg.concurrency;
-      const pollInterval = args.pollInterval || cfg.pollIntervalSeconds;
-      pollIntervalRef.current = pollInterval;
-      appendLog(`concurrency=${concurrency} pollInterval=${pollInterval}s`, "gray");
+      appendLog(`agent mode v${VERSION} \u2014 config: ${cfgPath}`, "gray");
       const apiKey = process.env["LINEAR_API_KEY"];
       if (!apiKey) {
         appendLog("! LINEAR_API_KEY not set \u2014 cannot poll Linear", "red");
         exit();
         return;
       }
-      const inProgressName = args.inProgressStatus || cfg.linear.inProgressStatus;
-      const baseStatuses = args.linearStatus.length ? args.linearStatus : cfg.linear.statuses;
-      const effectiveStatuses = inProgressName && baseStatuses.length > 0 && !baseStatuses.includes(inProgressName) ? [...baseStatuses, inProgressName] : baseStatuses;
-      const filter2 = {
-        team: args.linearTeam || cfg.linear.team,
-        assignee: args.linearAssignee || cfg.linear.assignee,
-        statuses: effectiveStatuses,
-        labels: args.linearLabel.length ? args.linearLabel : cfg.linear.labels
-      };
-      const stateCache = new Map;
-      const labelCache = new Map;
-      const teamKeyOf = (issue) => issue.identifier.split("-")[0];
-      const useWorktree = args.worktree || cfg.useWorktree;
-      const cwdByChange = new Map;
-      const statesDirByChange = new Map;
-      const branchByChange = new Map;
-      const issueByChange = new Map;
-      async function runScript(label, cmd, cwd2) {
-        appendLog(`  ${label}: ${cmd}`, "gray");
-        const proc = Bun.spawn({
-          cmd: ["sh", "-c", cmd],
-          cwd: cwd2,
-          stdout: "ignore",
-          stderr: "pipe",
-          stdin: "ignore"
-        });
-        const code = await proc.exited;
-        if (code !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          appendLog(`! ${label} exited code ${code}${stderr ? `: ${stderr.trim().split(`
-`)[0]}` : ""}`, "yellow");
-        }
-      }
-      const coord2 = new AgentCoordinator({
-        fetchIssues: (f2) => fetchOpenIssues(apiKey, f2),
-        scaffold: async (issue) => {
-          let comments = [];
-          try {
-            comments = await fetchIssueComments(apiKey, issue.id);
-          } catch (err) {
-            appendLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
-          }
-          let workerCwd = projectRoot;
-          let scaffoldTasksDir = tasksDir;
-          let scaffoldStatesDir = statesDir;
-          let workerBranch = null;
-          const probeName = issue.identifier.toLowerCase();
-          if (useWorktree) {
-            try {
-              const wt = await createWorktree(projectRoot, probeName, bunGitRunner);
-              workerCwd = wt.cwd;
-              workerBranch = wt.branch;
-              scaffoldTasksDir = join14(wt.cwd, "openspec", "changes");
-              scaffoldStatesDir = join14(wt.cwd, ".ralph", "tasks");
-              appendLog(`  ${issue.identifier} worktree: ${wt.cwd} (${wt.branch})`, "gray");
-              try {
-                await seedWorktreeMcpConfig(projectRoot, wt.cwd);
-              } catch (err) {
-                appendLog(`! seeding .mcp.json failed for ${issue.identifier}: ${err.message}`, "yellow");
-              }
-            } catch (err) {
-              appendLog(`! worktree create failed for ${issue.identifier}: ${err.message} \u2014 falling back to project root`, "yellow");
-            }
-          }
-          const appendPrompt = args.prompt || cfg.appendPrompt || "";
-          const changeName = await scaffoldChangeForIssue(scaffoldTasksDir, scaffoldStatesDir, issue, comments, appendPrompt);
-          cwdByChange.set(changeName, workerCwd);
-          statesDirByChange.set(changeName, scaffoldStatesDir);
-          issueByChange.set(changeName, issue);
-          if (workerBranch)
-            branchByChange.set(changeName, workerBranch);
-          if (cfg.setupScript) {
-            await runScript("setup", cfg.setupScript, workerCwd);
-          }
-          return changeName;
-        },
-        spawnWorker: (changeName) => {
-          const buildTaskCmd = () => {
-            const c = [
-              process.execPath,
-              process.argv[1] ?? "",
-              "task",
-              "--name",
-              changeName,
-              "--" + (args.engineSet ? args.engine : cfg.engine),
-              args.engineSet ? args.model : cfg.model
-            ];
-            const maxIter = args.maxIterations || cfg.maxIterationsPerTask;
-            if (maxIter > 0)
-              c.push("--max-iterations", String(maxIter));
-            const maxCost = args.maxCostUsd || cfg.maxCostUsdPerTask;
-            if (maxCost > 0)
-              c.push("--max-cost", String(maxCost));
-            const maxRuntime = args.maxRuntimeMinutes || cfg.maxRuntimeMinutesPerTask;
-            if (maxRuntime > 0)
-              c.push("--max-runtime", String(maxRuntime));
-            const maxFailures = args.maxConsecutiveFailures !== 5 ? args.maxConsecutiveFailures : cfg.maxConsecutiveFailuresPerTask;
-            if (maxFailures !== 5)
-              c.push("--max-failures", String(maxFailures));
-            const delay2 = args.delay || cfg.iterationDelaySeconds;
-            if (delay2 > 0)
-              c.push("--delay", String(delay2));
-            if (args.log || cfg.logRawStream)
-              c.push("--log");
-            if (args.verbose || cfg.taskVerbose)
-              c.push("--verbose");
-            return c;
-          };
-          const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
-          const proc = Bun.spawn({
-            cmd: buildTaskCmd(),
-            cwd: cwd2,
-            stdout: "ignore",
-            stderr: "ignore",
-            stdin: "ignore"
-          });
+      const store = new AgentStateStore(projectRoot);
+      await store.load();
+      const { coord: coord2, filterDesc, concurrency, pollInterval } = buildAgentCoordinator({
+        args,
+        cfg,
+        projectRoot,
+        statesDir,
+        tasksDir,
+        apiKey,
+        store,
+        onLog: appendLog,
+        onWorkersChanged: () => setTick((t) => t + 1),
+        onWorkerStarted: (changeName, dir, logFile) => {
           workerMetaRef.current.set(changeName, {
             startedAt: Date.now(),
-            statesDir: statesDirByChange.get(changeName) ?? statesDir,
-            iter: 0
+            statesDir: dir,
+            logFile,
+            iter: 0,
+            phase: "working",
+            phaseDetail: "",
+            phaseStartedAt: Date.now(),
+            currentCmd: null,
+            lastCmd: null,
+            tail: []
           });
-          const wantPr = args.createPr || cfg.createPrOnSuccess;
-          const CI_FAILED_EXIT = 70;
-          const PR_FAILED_EXIT = 71;
-          const wrapped = proc.exited.then(async (code) => {
-            if (cfg.teardownScript) {
-              try {
-                await runScript("teardown", cfg.teardownScript, cwd2);
-              } catch {}
-            }
-            let effectiveCode = code;
-            const ok = code === 0;
-            if (ok && wantPr) {
-              const branch = branchByChange.get(changeName);
-              const prIssue = issueByChange.get(changeName);
-              if (!branch || !prIssue) {
-                appendLog(`! createPr requested but no worktree branch is tracked for ${changeName} (use --worktree)`, "yellow");
-                effectiveCode = PR_FAILED_EXIT;
-              } else {
-                const changeDir = join14(statesDirByChange.get(changeName) ?? statesDir, "..", "..", "openspec", "changes", changeName);
-                const maxHookFixAttempts = cfg.maxCiFixAttempts;
-                const runWorkerWithFixSteering = async (heading, steering) => {
-                  try {
-                    await injectFixSteering(changeDir, heading, steering);
-                  } catch (steerErr) {
-                    appendLog(`! could not inject steering: ${steerErr.message}`, "red");
-                    return 1;
-                  }
-                  const rp = Bun.spawn({
-                    cmd: buildTaskCmd(),
-                    cwd: cwd2,
-                    stdout: "ignore",
-                    stderr: "ignore",
-                    stdin: "ignore"
-                  });
-                  return rp.exited;
-                };
-                let commitFixAttempt = 0;
-                let commitGaveUp = false;
-                while (true) {
-                  let dirty = "";
-                  try {
-                    const status = await bunCmdRunner.run(["git", "status", "--porcelain"], cwd2);
-                    dirty = status.stdout.trim();
-                  } catch (err) {
-                    appendLog(`! git status failed for ${changeName}: ${err.message}`, "yellow");
-                    break;
-                  }
-                  if (!dirty)
-                    break;
-                  try {
-                    await bunCmdRunner.run(["git", "add", "-A"], cwd2);
-                    await bunCmdRunner.run(["git", "commit", "-m", `ralph: residual changes for ${changeName}`], cwd2);
-                    appendLog(`  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 (commitFixAttempt >= maxHookFixAttempts) {
-                      appendLog(`! commit rejected for ${changeName} after ${commitFixAttempt} fix attempts (host pre-commit hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
-                      appendLog(`    detail: ${detail}`, "red");
-                      effectiveCode = PR_FAILED_EXIT;
-                      commitGaveUp = true;
-                      break;
-                    }
-                    commitFixAttempt += 1;
-                    appendLog(`! commit rejected for ${changeName} \u2014 feeding error back to worker (attempt ${commitFixAttempt}/${maxHookFixAttempts})`, "yellow");
-                    appendLog(`    detail: ${detail}`, "yellow");
-                    const retryCode = await runWorkerWithFixSteering("Fix host pre-commit hook rejection", `Committing residual changes was rejected by the host repo's pre-commit hook. ` + `Fix the underlying problem reported below, then the commit will be retried.
-
-` + "```\n" + combined.trim() + "\n```");
-                    if (retryCode !== 0) {
-                      appendLog(`! worker re-run after commit rejection exited code ${retryCode} \u2014 giving up`, "red");
-                      effectiveCode = PR_FAILED_EXIT;
-                      commitGaveUp = true;
-                      break;
-                    }
-                  }
-                }
-                let pushFixAttempt = 0;
-                let pr = null;
-                let prGaveUp = commitGaveUp;
-                while (!prGaveUp) {
-                  try {
-                    pr = await createPullRequest({ cwd: cwd2, branch, issue: prIssue, base: cfg.prBaseBranch }, bunCmdRunner);
-                    break;
-                  } catch (err) {
-                    const e = err;
-                    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 || pushFixAttempt >= maxHookFixAttempts) {
-                      if (pushRejected) {
-                        appendLog(`! push rejected for ${changeName} after ${pushFixAttempt} fix attempts (host pre-push hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
-                        appendLog(`    detail: ${detail}`, "red");
-                      } else {
-                        appendLog(`! PR create failed for ${changeName}: ${detail}`, "red");
-                      }
-                      effectiveCode = PR_FAILED_EXIT;
-                      prGaveUp = true;
-                      break;
-                    }
-                    pushFixAttempt += 1;
-                    appendLog(`! push rejected for ${changeName} \u2014 feeding error back to worker (attempt ${pushFixAttempt}/${maxHookFixAttempts})`, "yellow");
-                    appendLog(`    detail: ${detail}`, "yellow");
-                    const retryCode = await runWorkerWithFixSteering("Fix host pre-push hook rejection", `Push to origin/${branch} was rejected by the host repo's pre-push hook. ` + `Fix the underlying problem reported below, then the push will be retried.
-
-` + "```\n" + combined.trim() + "\n```");
-                    if (retryCode !== 0) {
-                      appendLog(`! 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) {
-                  appendLog(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
-                } else {
-                  appendLog(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
-                  const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
-                  if (wantFixCi) {
-                    appendLog(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
-                    const result2 = await fixCiUntilGreen({
-                      getStatus: () => getPrChecksStatus(pr.url, bunCmdRunner, cwd2),
-                      getFailedLogs: (ids) => fetchFailedRunLogs(ids, bunCmdRunner, cwd2),
-                      runTaskWithSteering: async (steering) => {
-                        try {
-                          await injectFixSteering(changeDir, "Fix failing CI checks", `CI feedback:
-
-${steering}`);
-                        } catch (err) {
-                          appendLog(`! could not inject steering: ${err.message}`, "red");
-                        }
-                        const p = Bun.spawn({
-                          cmd: buildTaskCmd(),
-                          cwd: cwd2,
-                          stdout: "ignore",
-                          stderr: "ignore",
-                          stdin: "ignore"
-                        });
-                        return p.exited;
-                      },
-                      pushBranch: async () => {
-                        await bunCmdRunner.run(["git", "push", "origin", branch], cwd2);
-                      },
-                      log: appendLog,
-                      sleep: (ms) => new Promise((r) => setTimeout(r, ms))
-                    }, {
-                      maxAttempts: cfg.maxCiFixAttempts,
-                      pollIntervalSeconds: cfg.ciPollIntervalSeconds
-                    });
-                    if (!result2.success) {
-                      appendLog(`! CI fix loop gave up after ${result2.attempts} attempts (${result2.reason ?? "unknown"}) \u2014 withholding done-status until CI passes`, "red");
-                      effectiveCode = CI_FAILED_EXIT;
-                    }
-                  }
-                }
-              }
-            }
-            if (useWorktree && cwd2 !== projectRoot) {
-              if (effectiveCode === 0 && cfg.cleanupWorktreeOnSuccess) {
-                const check = await isWorktreeSafeToRemove(cwd2, cfg.prBaseBranch, bunGitRunner).catch((err) => ({
-                  safe: false,
-                  reason: `safety check failed: ${err.message}`,
-                  dirty: "",
-                  unpushedCommits: ""
-                }));
-                if (!check.safe) {
-                  appendLog(`! preserving worktree for ${changeName}: ${check.reason}`, "yellow");
-                  if (check.dirty) {
-                    appendLog(`    uncommitted:
-${check.dirty}`, "yellow");
-                  }
-                  if (check.unpushedCommits) {
-                    appendLog(`    commits:
-${check.unpushedCommits}`, "yellow");
-                  }
-                  appendLog(`    path: ${cwd2}`, "yellow");
-                } else {
-                  try {
-                    await removeWorktree(projectRoot, cwd2, bunGitRunner);
-                    appendLog(`  removed worktree ${cwd2}`, "gray");
-                  } catch (err) {
-                    appendLog(`! worktree remove failed for ${changeName}: ${err.message}`, "yellow");
-                  }
-                }
-              }
-            }
-            cwdByChange.delete(changeName);
-            statesDirByChange.delete(changeName);
-            branchByChange.delete(changeName);
-            issueByChange.delete(changeName);
-            workerMetaRef.current.delete(changeName);
-            return effectiveCode;
-          });
-          return { exited: wrapped, kill: () => proc.kill() };
         },
-        loadState: () => readAgentState(projectRoot),
-        saveState: (s) => writeAgentState(projectRoot, s),
-        onLog: appendLog,
-        onWorkersChanged: () => setTick((t) => t + 1),
-        getIterationCount: async (changeName) => {
-          const dir = statesDirByChange.get(changeName) ?? statesDir;
-          const file = Bun.file(join14(dir, changeName, ".ralph-state.json"));
-          if (!await file.exists())
-            return 0;
-          const json = await file.json();
-          return json.iteration ?? 0;
+        onWorkerExited: (changeName) => {
+          workerMetaRef.current.delete(changeName);
         },
-        updater: {
-          postComment: (issue, body) => addIssueComment(apiKey, issue.id, body),
-          setState: (issue, stateId) => updateIssueState(apiKey, issue.id, stateId),
-          resolveStateId: async (issue, stateName) => {
-            const team = teamKeyOf(issue);
-            let map2 = stateCache.get(team);
-            if (!map2) {
-              const states = await fetchWorkflowStates(apiKey, team);
-              map2 = new Map(states.map((s) => [s.name.toLowerCase(), s.id]));
-              stateCache.set(team, map2);
-            }
-            return map2.get(stateName.toLowerCase()) ?? null;
-          },
-          addLabel: (issue, labelId) => addLabelToIssue(apiKey, issue.id, labelId),
-          resolveLabelId: async (issue, labelName) => {
-            const team = teamKeyOf(issue);
-            let map2 = labelCache.get(team);
-            if (!map2) {
-              const labels = await fetchIssueLabels(apiKey, team);
-              map2 = new Map(labels.map((l) => [l.name.toLowerCase(), l.id]));
-              labelCache.set(team, map2);
-            }
-            return map2.get(labelName.toLowerCase()) ?? null;
+        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 };
           }
         }
-      }, {
-        concurrency,
-        filter: filter2,
-        inProgressStatus: args.inProgressStatus || cfg.linear.inProgressStatus,
-        doneStatus: args.doneStatus || cfg.linear.doneStatus,
-        doneLabel: args.doneLabel || cfg.linear.doneLabel,
-        postComments: cfg.linear.postComments,
-        commentEveryIterations: cfg.linear.updateEveryIterations
       });
+      appendLog(`concurrency=${concurrency} pollInterval=${pollInterval}s`, "gray");
       coordRef.current = coord2;
       await coord2.init();
-      const filterDesc = `team=${filter2.team ?? "*"}, assignee=${filter2.assignee ?? "*"}, statuses=${filter2.statuses?.length ? filter2.statuses.join(",") : "open"}${filter2.labels?.length ? `, labels=${filter2.labels.join(",")}` : ""}`;
       const tick = async () => {
         if (cancelled)
           return;
@@ -71435,7 +71780,7 @@ ${check.unpushedCommits}`, "yellow");
       (async () => {
         for (const [changeName, meta] of workerMetaRef.current) {
           try {
-            const file = Bun.file(join14(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;
@@ -71493,19 +71838,56 @@ ${check.unpushedCommits}`, "yellow");
             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);
           })
@@ -71516,11 +71898,11 @@ ${check.unpushedCommits}`, "yellow");
 }
 
 // packages/openspec/src/openspec-change-store.ts
-import { join as join15, 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 join15(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"];
@@ -71546,7 +71928,7 @@ class OpenSpecChangeStore {
     }
   }
   getChangeDirectory(name) {
-    return join15("openspec", "changes", name);
+    return join18("openspec", "changes", name);
   }
   async listChanges() {
     const result2 = runOpenspec(["list", "--json"]);
@@ -71560,7 +71942,7 @@ class OpenSpecChangeStore {
         }
       } catch {}
     }
-    const changesDir = join15("openspec", "changes");
+    const changesDir = join18("openspec", "changes");
     if (!await Bun.file(changesDir).exists())
       return [];
     try {
@@ -71571,18 +71953,18 @@ class OpenSpecChangeStore {
     }
   }
   async readTaskList(name) {
-    const file = Bun.file(join15("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 = join15("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 = join15("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}
@@ -71593,7 +71975,7 @@ ${existing.trimStart()}` : `${message}
     await Bun.write(path, updated);
   }
   async readSection(name, artifact, heading) {
-    const file = Bun.file(join15("openspec", "changes", name, artifact));
+    const file = Bun.file(join18("openspec", "changes", name, artifact));
     if (!await file.exists())
       return "";
     const content = await file.text();
@@ -71675,8 +72057,8 @@ function App2({ args, statesDir, tasksDir, projectRoot }) {
           message: "Error: --name is required for status mode"
         }, undefined, false, undefined, this);
       }
-      const stateDir = join16(statesDir, args.name);
-      if (getStorage().read(join16(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);
@@ -71737,7 +72119,7 @@ if (typeof globalThis.Bun === "undefined") {
 async function findProjectRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (await exists2(join17(dir, "openspec")))
+    if (await exists2(join20(dir, "openspec")))
       return dir;
     dir = resolve(dir, "..");
   }
@@ -71772,11 +72154,12 @@ try {
 capture("command_run", { mode: args.mode, engine: args.engine, model: args.model });
 try {
   const projectRoot = await findProjectRoot();
-  const statesDir = join17(projectRoot, ".ralph", "tasks");
-  const tasksDir = join17(projectRoot, "openspec", "changes");
+  const layout = projectLayout(projectRoot);
+  const statesDir = layout.statesDir;
+  const tasksDir = layout.tasksDir;
   if (args.mode === "init") {
     await mkdir4(statesDir, { recursive: true });
-    const openspecBin = join17(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"],
@@ -71789,9 +72172,9 @@ try {
 `);
       process.exit(1);
     }
-    const worktreeDir = join17(worktreesDir(projectRoot), args.name);
-    const changeDir = join17(tasksDir, args.name);
-    const stateDir = join17(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)) {
@@ -71830,12 +72213,11 @@ try {
       removed.push(`task state ${stateDir}`);
     }
     try {
-      const agentState = await readAgentState(projectRoot);
-      const entry = Object.values(agentState.tasks).find((t) => t.changeName === args.name);
-      if (entry) {
-        delete agentState.tasks[entry.identifier];
-        await writeAgentState(projectRoot, agentState);
-        removed.push(`agent-state entry for ${entry.identifier} (${entry.issueId})`);
+      const store = new AgentStateStore(projectRoot);
+      await store.load();
+      const removedEntry = await store.removeByChangeName(args.name);
+      if (removedEntry) {
+        removed.push(`agent-state entry for ${removedEntry.identifier} (${removedEntry.issueId})`);
       }
     } catch {}
     if (removed.length === 0) {
@@ -71852,13 +72234,13 @@ try {
     process.exit(0);
   }
   if (args.mode === "task" && args.name) {
-    await mkdir4(join17(statesDir, args.name), { recursive: true });
-    await mkdir4(join17(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(join17(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 }));