@neriros/ralphy 2.11.2 → 2.13.0

package/dist/cli/index.js

@@ -50838,7 +50838,7 @@ var require_axios = __commonJS((exports, module) => {
 
 // apps/cli/src/index.ts
 import { resolve, join as join19, dirname as dirname5 } from "path";
-import { exists as exists2, mkdir as mkdir4, rm } from "fs/promises";
+import { exists as exists2, mkdir as mkdir5, rm } from "fs/promises";
 
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/render.js
 import { Stream } from "stream";
@@ -56407,7 +56407,7 @@ function log(msg) {
 // package.json
 var package_default = {
   name: "@neriros/ralphy",
-  version: "2.11.2",
+  version: "2.13.0",
   description: "An iterative AI task execution framework. Orchestrates multi-phase autonomous work using Claude or Codex engines.",
   keywords: [
     "agent",
@@ -56502,6 +56502,17 @@ var package_default = {
 var VERSION = package_default.version;
 var VALID_MODES = new Set(["task", "list", "status", "init", "agent", "clean"]);
 var VALID_MODELS = new Set(["haiku", "sonnet", "opus"]);
+var INDICATOR_KEYS = new Set([
+  "getTodo",
+  "getInProgress",
+  "getConflicted",
+  "setInProgress",
+  "setDone",
+  "setError",
+  "setConflicted",
+  "clearConflicted"
+]);
+var GET_KEYS = new Set(["getTodo", "getInProgress", "getConflicted"]);
 var HELP_TEXT = [
   `ralph v${VERSION}`,
   "",
@@ -56534,23 +56545,25 @@ var HELP_TEXT = [
   "Agent mode options (require LINEAR_API_KEY env var):",
   "  --linear-team <key>     Linear team key (e.g. ENG)",
   "  --linear-assignee <id>  Filter by assignee (user id, email, or 'me')",
-  "  --linear-status <name>  Filter by status name (repeatable, e.g. Todo, In Progress)",
-  "  --linear-label <name>   Filter by label name (repeatable, any-of)",
   "  --poll-interval <s>     Seconds between Linear polls (default: 60)",
   "  --concurrency <n>       Max concurrent task loops (default: 1)",
-  "  --worktree              Run each task in its own git worktree (~/.ralph/<project>/worktrees/<name>)",
-  "  --in-progress-status <name>  Linear status to set when work starts on an issue",
-  "  --done-status <name>    Linear status to set when work completes successfully",
-  "  --done-label <name>     Linear label to add when work completes successfully",
+  "  --worktree              Run each task in its own git worktree",
+  "  --indicator <k>:<t>:<v> Override an indicator (repeatable). Examples:",
+  "                          --indicator getTodo:status:Todo",
+  "                          --indicator setDone:label:shipped",
+  "                          --indicator setDone:status:Done   (combined with above \u2192 multi-marker)",
+  "                          Keys: getTodo, getInProgress, getConflicted,",
+  "                                setInProgress, setDone, setError, setConflicted, clearConflicted",
+  "                          Types: label, status",
   "  --create-pr             Push the worker branch and open a GitHub PR on success (needs --worktree)",
-  "  --fix-ci                After opening the PR, re-run the task on CI failures until green (needs --create-pr)",
+  "  --fix-ci                After opening the PR, re-run on CI failures until green (needs --create-pr)",
   "",
   "  --help, -h              Show this help message",
   "",
   "Examples:",
   '  ralph task --name my-feature --prompt "Add dark mode"',
   "  ralph task --name my-feature --claude sonnet --max-iterations 10",
-  "  ralph task --name my-feature",
+  "  ralph agent --indicator getTodo:status:Todo --indicator setDone:status:Done",
   "  ralph list",
   "  ralph status --name my-feature",
   "  ralph init"
@@ -56559,6 +56572,53 @@ var HELP_TEXT = [
 function printHelp() {
   log(HELP_TEXT);
 }
+function parseIndicatorArg(raw) {
+  const firstColon = raw.indexOf(":");
+  if (firstColon < 0) {
+    const err = new Error("--indicator expects key:type:value");
+    err.input = raw;
+    throw err;
+  }
+  const secondColon = raw.indexOf(":", firstColon + 1);
+  if (secondColon < 0) {
+    const err = new Error("--indicator expects key:type:value");
+    err.input = raw;
+    throw err;
+  }
+  const key = raw.slice(0, firstColon);
+  const type = raw.slice(firstColon + 1, secondColon);
+  const value = raw.slice(secondColon + 1);
+  if (!INDICATOR_KEYS.has(key)) {
+    const err = new Error("unknown indicator key");
+    err.key = key;
+    throw err;
+  }
+  if (type !== "label" && type !== "status") {
+    const err = new Error("indicator type must be 'label' or 'status'");
+    err.type = type;
+    throw err;
+  }
+  if (!value)
+    throw new Error("indicator value cannot be empty");
+  return { key, marker: { type, value } };
+}
+function mergeIndicator(bag, key, marker) {
+  if (GET_KEYS.has(key)) {
+    const existing = bag[key];
+    const filter2 = existing ? [...existing.filter, marker] : [marker];
+    bag[key] = { filter: filter2 };
+  } else {
+    const existing = bag[key];
+    let next;
+    if (!existing)
+      next = marker;
+    else if ("apply" in existing)
+      next = { apply: [...existing.apply, marker] };
+    else
+      next = { apply: [existing, marker] };
+    bag[key] = next;
+  }
+}
 async function parseArgs(argv) {
   const result2 = {
     mode: "task",
@@ -56576,14 +56636,10 @@ async function parseArgs(argv) {
     verbose: false,
     linearTeam: "",
     linearAssignee: "",
-    linearStatus: [],
-    linearLabel: [],
     pollInterval: 60,
     concurrency: 1,
     worktree: false,
-    inProgressStatus: "",
-    doneStatus: "",
-    doneLabel: "",
+    indicators: {},
     createPr: false,
     fixCi: false
   };
@@ -56601,13 +56657,9 @@ async function parseArgs(argv) {
   let expectPushInterval = false;
   let expectLinearTeam = false;
   let expectLinearAssignee = false;
-  let expectLinearStatus = false;
-  let expectLinearLabel = false;
   let expectPollInterval = false;
   let expectConcurrency = false;
-  let expectInProgressStatus = false;
-  let expectDoneStatus = false;
-  let expectDoneLabel = false;
+  let expectIndicator = false;
   for (const arg of argv) {
     if (expectModel) {
       if (VALID_MODELS.has(arg)) {
@@ -56683,16 +56735,6 @@ async function parseArgs(argv) {
       expectLinearAssignee = false;
       continue;
     }
-    if (expectLinearStatus) {
-      result2.linearStatus.push(arg);
-      expectLinearStatus = false;
-      continue;
-    }
-    if (expectLinearLabel) {
-      result2.linearLabel.push(arg);
-      expectLinearLabel = false;
-      continue;
-    }
     if (expectPollInterval) {
       result2.pollInterval = parseInt(arg, 10);
       expectPollInterval = false;
@@ -56703,19 +56745,10 @@ async function parseArgs(argv) {
       expectConcurrency = false;
       continue;
     }
-    if (expectInProgressStatus) {
-      result2.inProgressStatus = arg;
-      expectInProgressStatus = false;
-      continue;
-    }
-    if (expectDoneStatus) {
-      result2.doneStatus = arg;
-      expectDoneStatus = false;
-      continue;
-    }
-    if (expectDoneLabel) {
-      result2.doneLabel = arg;
-      expectDoneLabel = false;
+    if (expectIndicator) {
+      const { key, marker } = parseIndicatorArg(arg);
+      mergeIndicator(result2.indicators, key, marker);
+      expectIndicator = false;
       continue;
     }
     switch (arg) {
@@ -56782,12 +56815,6 @@ async function parseArgs(argv) {
       case "--linear-assignee":
         expectLinearAssignee = true;
         break;
-      case "--linear-status":
-        expectLinearStatus = true;
-        break;
-      case "--linear-label":
-        expectLinearLabel = true;
-        break;
       case "--poll-interval":
         expectPollInterval = true;
         break;
@@ -56797,14 +56824,8 @@ async function parseArgs(argv) {
       case "--worktree":
         result2.worktree = true;
         break;
-      case "--in-progress-status":
-        expectInProgressStatus = true;
-        break;
-      case "--done-status":
-        expectDoneStatus = true;
-        break;
-      case "--done-label":
-        expectDoneLabel = true;
+      case "--indicator":
+        expectIndicator = true;
         break;
       case "--create-pr":
         result2.createPr = true;
@@ -60904,6 +60925,9 @@ var StateSchema = exports_external.object({
   history: exports_external.array(HistoryEntrySchema).default([]),
   metadata: exports_external.object({ branch: exports_external.string().optional() }).default({})
 });
+function markersOf(set2) {
+  return "apply" in set2 ? set2.apply : [set2];
+}
 var PhaseFrontmatterSchema = exports_external.object({
   name: exports_external.string(),
   order: exports_external.number(),
@@ -70106,87 +70130,44 @@ function TaskLoop({ opts }) {
 var import_react57 = __toESM(require_react(), 1);
 import { join as join16 } from "path";
 
-// apps/cli/src/agent/state.ts
+// apps/cli/src/agent/config.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 MarkerSchema = exports_external.object({
+  type: exports_external.enum(["label", "status"]),
+  value: exports_external.string().min(1)
 });
-var AgentStateSchema = exports_external.object({
-  tasks: exports_external.record(exports_external.string(), TaskEntrySchema).default({}),
-  lastPollAt: exports_external.string().nullable().default(null)
+var GetIndicatorSchema = exports_external.object({
+  filter: exports_external.array(MarkerSchema).default([])
 });
-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()");
+var SetIndicatorSchema = exports_external.union([
+  MarkerSchema,
+  exports_external.object({ apply: exports_external.array(MarkerSchema).min(1) })
+]);
+var IndicatorsSchema = exports_external.object({
+  getTodo: GetIndicatorSchema.optional(),
+  getInProgress: GetIndicatorSchema.optional(),
+  getConflicted: GetIndicatorSchema.optional(),
+  setInProgress: SetIndicatorSchema.optional(),
+  setDone: SetIndicatorSchema.optional(),
+  setError: SetIndicatorSchema.optional(),
+  setConflicted: SetIndicatorSchema.optional(),
+  clearConflicted: SetIndicatorSchema.optional()
+}).superRefine((value, ctx) => {
+  const clear = value.clearConflicted;
+  if (!clear)
+    return;
+  const markers = "apply" in clear ? clear.apply : [clear];
+  for (const m of markers) {
+    if (m.type !== "label") {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["clearConflicted"],
+        message: "clearConflicted markers must be label-typed (status removal is not supported)"
+      });
+      return;
     }
-    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),
@@ -70212,14 +70193,26 @@ var RalphyConfigSchema = exports_external.object({
   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 })
+    updateEveryIterations: exports_external.number().int().nonnegative().default(10),
+    indicators: IndicatorsSchema.default({})
+  }).passthrough().superRefine((value, ctx) => {
+    const LEGACY_KEYS = [
+      "statuses",
+      "labels",
+      "inProgressStatus",
+      "doneStatus",
+      "doneLabel"
+    ];
+    const found = LEGACY_KEYS.filter((k) => (k in value));
+    if (found.length === 0)
+      return;
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["linear"],
+      message: `legacy linear keys [${found.join(", ")}] cannot be used together with the new ` + `\`linear.indicators\` map \u2014 they describe the same lifecycle and combining them is ` + `not possible. Migrate by moving each legacy key into linear.indicators (e.g. ` + `doneStatus: "Done" \u2192 indicators.setDone: {type: "status", value: "Done"}; ` + `statuses/labels \u2192 indicators.getTodo.filter; inProgressStatus \u2192 indicators.setInProgress; ` + `doneLabel \u2192 indicators.setDone {type: "label", ...}).`
+    });
+  }).default({ postComments: true, updateEveryIterations: 10, indicators: {} })
 }).default({
   concurrency: 1,
   pollIntervalSeconds: 60,
@@ -70227,10 +70220,10 @@ var RalphyConfigSchema = exports_external.object({
   maxCostUsdPerTask: 0,
   engine: "claude",
   model: "opus",
-  linear: { statuses: [], labels: [], postComments: true }
+  linear: { postComments: true, updateEveryIterations: 10, indicators: {} }
 });
 async function loadRalphyConfig(projectRoot) {
-  const path = join11(projectRoot, "ralphy.config.json");
+  const path = join10(projectRoot, "ralphy.config.json");
   const file = Bun.file(path);
   if (!await file.exists()) {
     return RalphyConfigSchema.parse({});
@@ -70239,7 +70232,7 @@ async function loadRalphyConfig(projectRoot) {
   return RalphyConfigSchema.parse(raw);
 }
 async function ensureRalphyConfig(projectRoot) {
-  const path = join11(projectRoot, "ralphy.config.json");
+  const path = join10(projectRoot, "ralphy.config.json");
   const file = Bun.file(path);
   if (await file.exists())
     return path;
@@ -70249,47 +70242,86 @@ async function ensureRalphyConfig(projectRoot) {
   return path;
 }
 
+// apps/cli/src/agent/wire.ts
+import { join as join15 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+
 // packages/core/src/layout.ts
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 var STATE_FILE2 = ".ralph-state.json";
 function projectLayout(root) {
-  const statesDir = join12(root, ".ralph", "tasks");
-  const tasksDir = join12(root, "openspec", "changes");
+  const statesDir = join11(root, ".ralph", "tasks");
+  const tasksDir = join11(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)
+    agentStateFile: join11(root, ".ralph", "agent-state.json"),
+    changeDir: (name) => join11(tasksDir, name),
+    taskStateDir: (name) => join11(statesDir, name),
+    stateFile: (name) => join11(statesDir, name, STATE_FILE2)
   };
 }
 
 // apps/cli/src/agent/linear.ts
-var OPEN_STATE_TYPES = ["unstarted", "started", "backlog"];
 var LINEAR_API = "https://api.linear.app/graphql";
-async function fetchOpenIssues(apiKey, filter2) {
+function partition2(markers) {
+  const statuses = [];
+  const labels = [];
+  for (const m of markers) {
+    if (m.type === "status")
+      statuses.push(m.value);
+    else
+      labels.push(m.value);
+  }
+  return { statuses, labels };
+}
+function buildIssueFilter(spec) {
   const where = {};
-  if (filter2.team)
-    where.team = { key: { eq: filter2.team } };
-  if (filter2.assignee) {
-    if (filter2.assignee === "me") {
+  if (spec.team)
+    where.team = { key: { eq: spec.team } };
+  if (spec.assignee) {
+    if (spec.assignee === "me")
       where.assignee = { isMe: { eq: true } };
-    } else if (filter2.assignee.includes("@")) {
-      where.assignee = { email: { eq: filter2.assignee } };
-    } else {
-      where.assignee = { id: { eq: filter2.assignee } };
-    }
-  }
-  if (filter2.statuses && filter2.statuses.length > 0) {
-    where.state = { name: { in: filter2.statuses } };
+    else if (spec.assignee.includes("@"))
+      where.assignee = { email: { eq: spec.assignee } };
+    else
+      where.assignee = { id: { eq: spec.assignee } };
+  }
+  const inc = spec.include ?? [];
+  if (inc.length > 0) {
+    const { statuses, labels } = partition2(inc);
+    const branches = [];
+    if (statuses.length > 0)
+      branches.push({ state: { name: { in: statuses } } });
+    if (labels.length > 0)
+      branches.push({ labels: { some: { name: { in: labels } } } });
+    if (branches.length === 1)
+      Object.assign(where, branches[0]);
+    else
+      where.or = branches;
   } else {
-    where.state = { type: { in: [...OPEN_STATE_TYPES] } };
-  }
-  if (filter2.labels && filter2.labels.length > 0) {
-    where.labels = { some: { name: { in: filter2.labels } } };
+    where.state = { type: { in: ["unstarted", "started", "backlog"] } };
+  }
+  const exc = spec.exclude ?? [];
+  if (exc.length > 0) {
+    const { statuses, labels } = partition2(exc);
+    if (statuses.length > 0) {
+      const current = where.state;
+      const noStatus = { state: { name: { nin: statuses } } };
+      if (current === undefined)
+        Object.assign(where, noStatus);
+      else
+        where.and = [{ state: current }, noStatus];
+    }
+    if (labels.length > 0) {
+      where.labels = { ...where.labels, every: { name: { nin: labels } } };
+    }
   }
+  return where;
+}
+async function fetchOpenIssues(apiKey, spec) {
+  const where = buildIssueFilter(spec);
   const query = `query Issues($filter: IssueFilter) {
     issues(filter: $filter, first: 50) {
       nodes {
@@ -70406,6 +70438,15 @@ async function addLabelToIssue(apiKey, issueId, labelId) {
     labelId
   });
 }
+async function removeLabelFromIssue(apiKey, issueId, labelId) {
+  const mutation = `mutation RemoveLabel($id: String!, $labelId: String!) {
+    issueRemoveLabel(id: $id, labelId: $labelId) { success }
+  }`;
+  await linearRequest(apiKey, mutation, {
+    id: issueId,
+    labelId
+  });
+}
 
 // apps/cli/src/agent/coordinator.ts
 class AgentCoordinator {
@@ -70415,6 +70456,7 @@ class AgentCoordinator {
   pendingIds = new Set;
   queue = [];
   stopped = false;
+  conflictNotified = new Set;
   constructor(deps, opts) {
     this.deps = deps;
     this.opts = opts;
@@ -70432,58 +70474,86 @@ class AgentCoordinator {
   async pollOnce() {
     if (this.stopped)
       return { found: 0, added: 0 };
-    let issues;
+    let todo = [];
+    let inProgress = [];
+    let conflicted = [];
     try {
-      issues = await this.deps.fetchIssues(this.opts.filter);
+      [todo, inProgress, conflicted] = await Promise.all([
+        this.deps.fetchTodo(),
+        this.deps.fetchInProgress(),
+        this.deps.fetchConflicted()
+      ]);
     } 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));
+    const queuedIds = new Set(this.queue.map((q) => q.issue.id));
+    const activeIds = new Set(this.workers.map((w) => w.issueId));
+    const eligible = (id) => !queuedIds.has(id) && !activeIds.has(id) && !this.pendingIds.has(id);
     let added = 0;
-    for (const issue of issues) {
-      if (isProcessed(issue.id))
-        continue;
-      if (isFailed(issue.id))
+    for (const issue of inProgress) {
+      if (!eligible(issue.id))
         continue;
-      if (queued.has(issue.id))
+      if (!this.dependenciesResolved(issue))
         continue;
-      if (active.has(issue.id))
+      this.queue.push({ issue, mode: "resume" });
+      queuedIds.add(issue.id);
+      added += 1;
+    }
+    for (const issue of conflicted) {
+      if (!eligible(issue.id))
         continue;
-      if (this.pendingIds.has(issue.id))
+      this.queue.push({ issue, mode: "conflict-fix" });
+      queuedIds.add(issue.id);
+      added += 1;
+    }
+    for (const issue of todo) {
+      if (!eligible(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");
+      if (!this.dependenciesResolved(issue))
         continue;
-      }
-      this.queue.push(issue);
+      this.queue.push({ issue, mode: "fresh" });
+      queuedIds.add(issue.id);
       added += 1;
     }
     if (added > 0) {
+      const modeRank = {
+        resume: 0,
+        "conflict-fix": 1,
+        fresh: 2
+      };
       this.queue.sort((a, b) => {
-        const pa = a.priority === 0 ? Infinity : a.priority;
-        const pb = b.priority === 0 ? Infinity : b.priority;
-        return pa - pb;
+        const pa = a.issue.priority === 0 ? Infinity : a.issue.priority;
+        const pb = b.issue.priority === 0 ? Infinity : b.issue.priority;
+        if (pa !== pb)
+          return pa - pb;
+        return modeRank[a.mode] - modeRank[b.mode];
       });
     }
-    await this.deps.store.setLastPollAt(new Date().toISOString());
     this.spawnNext();
+    await this.scanDoneForConflicts();
     await this.reportProgress();
-    return { found: issues.length, added };
+    const found = todo.length + inProgress.length + conflicted.length;
+    return { found, added };
+  }
+  dependenciesResolved(issue) {
+    if (issue.blockedByIds.length === 0)
+      return true;
+    const openIds = new Set([
+      ...this.queue.map((q) => q.issue.id),
+      ...this.workers.map((w) => w.issueId)
+    ]);
+    const blocker = issue.blockedByIds.find((bid) => openIds.has(bid));
+    if (blocker !== undefined) {
+      this.deps.onLog(`  \u23F8 ${issue.identifier} skipped \u2014 blocked by unresolved dependency`, "yellow");
+      return false;
+    }
+    this.deps.onLog(`  \u23F8 ${issue.identifier} skipped \u2014 blocked by unresolved dependency`, "yellow");
+    return false;
   }
   async reportProgress() {
-    const updater = this.deps.updater;
     const everyN = this.opts.commentEveryIterations ?? 0;
-    if (everyN <= 0 || !updater || this.opts.postComments === false || !this.deps.getIterationCount) {
+    if (everyN <= 0 || this.opts.postComments === false || !this.deps.getIterationCount) {
       return;
     }
     for (const w of this.workers) {
@@ -70501,29 +70571,78 @@ class AgentCoordinator {
       if (currMilestone <= lastMilestone)
         continue;
       try {
-        await updater.postComment(w.issue, `\uD83D\uDD04 Ralph progress update: iteration ${count} on \`${w.changeName}\``);
+        await this.deps.postComment(w.issue, `\uD83D\uDD04 Ralph progress update: iteration ${count} on \`${w.changeName}\``);
         w.lastReportedIteration = count;
       } catch (err) {
         this.deps.onLog(`! Linear progress comment failed for ${w.issueIdentifier}: ${err.message}`, "red");
       }
     }
   }
+  async scanDoneForConflicts() {
+    if (!this.opts.setConflicted)
+      return;
+    let candidates = [];
+    try {
+      candidates = await this.deps.fetchDoneCandidates();
+    } catch (err) {
+      this.deps.onLog(`! conflict scan fetch failed: ${err.message}`, "yellow");
+      return;
+    }
+    if (candidates.length === 0)
+      return;
+    for (const issue of candidates) {
+      if (this.workers.some((w) => w.issueId === issue.id))
+        continue;
+      if (this.pendingIds.has(issue.id))
+        continue;
+      if (this.queue.some((q) => q.issue.id === issue.id))
+        continue;
+      let pr;
+      try {
+        pr = await this.deps.checkPrConflict(issue);
+      } catch (err) {
+        this.deps.onLog(`! PR conflict check failed for ${issue.identifier}: ${err.message}`, "yellow");
+        continue;
+      }
+      if (!pr || !pr.conflicting)
+        continue;
+      const alreadyNotified = this.conflictNotified.has(issue.id);
+      if (alreadyNotified)
+        continue;
+      try {
+        await this.deps.applyIndicator(issue, this.opts.setConflicted);
+      } catch (err) {
+        this.deps.onLog(`! Linear setConflicted failed for ${issue.identifier}: ${err.message}`, "red");
+        continue;
+      }
+      this.conflictNotified.add(issue.id);
+      if (this.opts.postComments !== false) {
+        try {
+          await this.deps.postComment(issue, `\u26A0 Ralph detected merge conflicts on this PR (${pr.url}) \u2014 re-running to resolve`);
+        } catch (err) {
+          this.deps.onLog(`! Linear conflict comment failed for ${issue.identifier}: ${err.message}`, "yellow");
+        }
+      }
+      this.queue.push({ issue, mode: "conflict-fix" });
+    }
+    this.spawnNext();
+  }
   spawnNext() {
     if (this.stopped)
       return;
     while (this.workers.length + this.pendingIds.size < this.opts.concurrency && this.queue.length > 0) {
-      const issue = this.queue.shift();
-      this.pendingIds.add(issue.id);
-      this.launchWorker(issue);
+      const next = this.queue.shift();
+      this.pendingIds.add(next.issue.id);
+      this.launchWorker(next.issue, next.mode);
     }
   }
-  async launchWorker(issue) {
-    let changeName;
+  async launchWorker(issue, mode) {
+    let prep;
     try {
-      changeName = await this.deps.scaffold(issue);
+      prep = await this.deps.prepare(issue, mode);
     } catch (err) {
       this.pendingIds.delete(issue.id);
-      this.deps.onLog(`! scaffold failed for ${issue.identifier}: ${err.message}`, "red");
+      this.deps.onLog(`! prepare(${mode}) failed for ${issue.identifier}: ${err.message}`, "red");
       this.spawnNext();
       return;
     }
@@ -70531,113 +70650,89 @@ class AgentCoordinator {
       this.pendingIds.delete(issue.id);
       return;
     }
-    {
-      const existing = this.deps.store.snapshot().tasks[issue.identifier];
-      this.deps.store.upsertTask(issue, {
-        state: "started",
-        changeName,
-        startedAt: existing?.startedAt ?? new Date().toISOString()
-      });
+    if (mode === "fresh" && this.opts.setInProgress) {
+      try {
+        await this.deps.applyIndicator(issue, this.opts.setInProgress);
+      } catch (err) {
+        this.deps.onLog(`! Linear setInProgress failed for ${issue.identifier}: ${err.message}`, "yellow");
+      }
+    }
+    if (mode === "fresh" && this.opts.postComments !== false) {
+      let alreadyPosted = false;
+      try {
+        const comments = await this.deps.fetchComments(issue.id);
+        alreadyPosted = comments.some((c) => c.body.startsWith("\uD83E\uDD16 Ralph started working"));
+      } catch (err) {
+        this.deps.onLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
+      }
+      if (!alreadyPosted) {
+        try {
+          await this.deps.postComment(issue, `\uD83E\uDD16 Ralph started working on this issue. Tracking change: \`${prep.changeName}\``);
+        } catch (err) {
+          this.deps.onLog(`! Linear comment failed for ${issue.identifier}: ${err.message}`, "red");
+        }
+      }
     }
-    this.deps.onLog(`\u25B6 ${issue.identifier} \u2192 ${changeName} (worker started)`, "cyan");
-    const handle = this.deps.spawnWorker(changeName, issue);
+    this.deps.onLog(`\u25B6 ${issue.identifier} \u2192 ${prep.changeName} (${mode})`, mode === "conflict-fix" ? "yellow" : "cyan");
+    const handle = this.deps.spawnWorker(prep.changeName, issue);
     const worker = {
-      changeName,
+      changeName: prep.changeName,
       issueId: issue.id,
       issueIdentifier: issue.identifier,
       issue,
+      mode,
       kill: handle.kill,
       lastReportedIteration: 0
     };
     this.workers.push(worker);
     this.pendingIds.delete(issue.id);
     this.deps.onWorkersChanged();
-    this.notifyStarted(issue, changeName);
-    handle.exited.then((code) => {
+    handle.exited.then(async (code) => {
       const idx = this.workers.indexOf(worker);
       if (idx >= 0)
         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");
-      this.deps.store.upsertTask(issue, {
-        state: ok ? "processed" : "failed",
-        finishedAt: new Date().toISOString(),
-        exitCode: code
-      });
-      this.notifyExited(issue, changeName, code);
+      this.deps.onLog(`${ok ? "\u2713" : "\u2717"} ${issue.identifier} \u2192 ${prep.changeName} exited (code ${code})`, ok ? "green" : "red");
+      await this.notifyExited(issue, prep.changeName, code, mode);
       this.deps.onWorkersChanged();
       this.spawnNext();
     });
   }
-  async notifyStarted(issue, changeName) {
-    const updater = this.deps.updater;
-    if (!updater)
-      return;
-    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}\``);
-        await this.deps.store.upsertTask(issue, { commentPosted: true });
-      } catch (err) {
-        this.deps.onLog(`! Linear comment failed for ${issue.identifier}: ${err.message}`, "red");
-      }
-    }
-    if (this.opts.inProgressStatus) {
-      await this.moveIssue(issue, this.opts.inProgressStatus);
-    }
-  }
-  async notifyExited(issue, changeName, code) {
-    const updater = this.deps.updater;
-    if (!updater)
-      return;
+  async notifyExited(issue, changeName, code, mode) {
     const ok = code === 0;
     if (this.opts.postComments !== false) {
-      const body = ok ? `\u2705 Ralph completed work on this issue. Change: \`${changeName}\`` : `\u2717 Ralph exited with code ${code} on this issue. Change: \`${changeName}\`
+      const body = ok ? mode === "conflict-fix" ? `\u2705 Ralph resolved merge conflicts on this issue. Change: \`${changeName}\`` : `\u2705 Ralph completed work on this issue. Change: \`${changeName}\`` : `\u2717 Ralph exited with code ${code} on this issue. Change: \`${changeName}\`
 
-` + `This issue has been quarantined and will not be auto-resumed on the next poll. ` + `Inspect the worktree at \`~/.ralph/<project>/worktrees/${changeName}\`, fix the underlying ` + `failure (e.g. lint/typecheck), then run \`ralph clean --name ${changeName}\` to ` + `clear the quarantine and let the next poll re-pick the issue.`;
+` + `This issue has been quarantined and will not be auto-resumed on the next poll. ` + `Inspect the worktree at \`~/.ralph/<project>/worktrees/${changeName}\`, fix the ` + `underlying failure, then remove the error marker on this Linear issue (or run ` + `\`ralph clean --name ${changeName}\`) to clear the quarantine.`;
       try {
-        await updater.postComment(issue, body);
+        await this.deps.postComment(issue, body);
       } catch (err) {
         this.deps.onLog(`! Linear comment failed for ${issue.identifier}: ${err.message}`, "red");
       }
     }
-    if (ok && this.opts.doneStatus) {
-      await this.moveIssue(issue, this.opts.doneStatus);
-    }
-    if (ok && this.opts.doneLabel) {
-      await this.tagIssue(issue, this.opts.doneLabel);
-    }
-  }
-  async tagIssue(issue, labelName) {
-    const updater = this.deps.updater;
-    if (!updater.resolveLabelId || !updater.addLabel) {
-      this.deps.onLog(`! Linear updater does not support labels (cannot tag ${issue.identifier} with '${labelName}')`, "yellow");
-      return;
-    }
-    try {
-      const labelId = await updater.resolveLabelId(issue, labelName);
-      if (!labelId) {
-        this.deps.onLog(`! Linear label '${labelName}' not found for ${issue.identifier}`, "yellow");
-        return;
+    if (ok) {
+      if (mode === "conflict-fix") {
+        if (this.opts.clearConflicted) {
+          try {
+            await this.deps.removeIndicator(issue, this.opts.clearConflicted);
+          } catch (err) {
+            this.deps.onLog(`! Linear clearConflicted failed for ${issue.identifier}: ${err.message}`, "red");
+          }
+        }
+        this.conflictNotified.delete(issue.id);
+      } else if (this.opts.setDone) {
+        try {
+          await this.deps.applyIndicator(issue, this.opts.setDone);
+        } catch (err) {
+          this.deps.onLog(`! Linear setDone failed for ${issue.identifier}: ${err.message}`, "red");
+        }
       }
-      await updater.addLabel(issue, labelId);
-      this.deps.onLog(`  \u2192 ${issue.identifier} tagged with '${labelName}'`, "gray");
-    } catch (err) {
-      this.deps.onLog(`! Linear label add failed for ${issue.identifier}: ${err.message}`, "red");
-    }
-  }
-  async moveIssue(issue, stateName) {
-    const updater = this.deps.updater;
-    try {
-      const stateId = await updater.resolveStateId(issue, stateName);
-      if (!stateId) {
-        this.deps.onLog(`! Linear state '${stateName}' not found for ${issue.identifier}`, "yellow");
-        return;
+    } else if (this.opts.setError) {
+      try {
+        await this.deps.applyIndicator(issue, this.opts.setError);
+      } catch (err) {
+        this.deps.onLog(`! Linear setError failed for ${issue.identifier}: ${err.message}`, "red");
       }
-      await updater.setState(issue, stateId);
-      this.deps.onLog(`  \u2192 ${issue.identifier} moved to '${stateName}'`, "gray");
-    } catch (err) {
-      this.deps.onLog(`! Linear state move failed for ${issue.identifier}: ${err.message}`, "red");
     }
   }
   stop() {
@@ -70651,7 +70746,7 @@ class AgentCoordinator {
 }
 
 // apps/cli/src/agent/scaffold.ts
-import { join as join13 } from "path";
+import { join as join12 } 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);
@@ -70659,10 +70754,10 @@ function changeNameForIssue(issue) {
 }
 async function scaffoldChangeForIssue(tasksDir, statesDir, issue, comments = [], appendPrompt = "") {
   const name = changeNameForIssue(issue);
-  const changeDir = join13(tasksDir, name);
-  const stateDir = join13(statesDir, name);
+  const changeDir = join12(tasksDir, name);
+  const stateDir = join12(statesDir, name);
   await mkdir2(changeDir, { recursive: true });
-  await mkdir2(join13(changeDir, "specs"), { recursive: true });
+  await mkdir2(join12(changeDir, "specs"), { recursive: true });
   await mkdir2(stateDir, { recursive: true });
   const commentsBlock = comments.length > 0 ? [
     "",
@@ -70714,25 +70809,25 @@ async function scaffoldChangeForIssue(tasksDir, statesDir, issue, comments = [],
     ""
   ].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);
+  await Bun.write(join12(changeDir, "proposal.md"), proposal);
+  await Bun.write(join12(changeDir, "tasks.md"), tasks);
+  await Bun.write(join12(changeDir, "design.md"), design);
   return name;
 }
 
 // apps/cli/src/agent/worktree.ts
-import { basename, join as join14 } from "path";
+import { basename, join as join13 } from "path";
 import { homedir as homedir2 } from "os";
 import { exists } from "fs/promises";
 function worktreesDir(projectRoot) {
-  return join14(homedir2(), ".ralph", basename(projectRoot), "worktrees");
+  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 = join14(dir, changeName);
+  const cwd2 = join13(dir, changeName);
   const branch = branchForChange(changeName);
   const list = await runner.run(["worktree", "list", "--porcelain"], projectRoot);
   if (list.stdout.includes(`worktree ${cwd2}
@@ -70789,8 +70884,8 @@ 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 dst = join13(worktreeCwd, ".mcp.json");
+  const src = join13(projectRoot, ".mcp.json");
   const source = await exists(dst) ? dst : await exists(src) ? src : null;
   if (!source)
     return;
@@ -70804,7 +70899,7 @@ async function seedWorktreeMcpConfig(projectRoot, worktreeCwd) {
   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);
+        cfg.args = cfg.args.map((a) => typeof a === "string" && a.startsWith(".ralph/") ? join13(projectRoot, a) : a);
       }
     }
   }
@@ -70813,7 +70908,7 @@ async function seedWorktreeMcpConfig(projectRoot, worktreeCwd) {
 }
 
 // apps/cli/src/agent/post-task.ts
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 
 // apps/cli/src/agent/pr.ts
 function defaultTitle(issue) {
@@ -70864,8 +70959,32 @@ async function createPullRequest(input, runner) {
 
 // apps/cli/src/agent/ci.ts
 var PR_CHECKS_FIELDS = "name,bucket,link,workflow,event";
-async function getPrChecksStatus(prRef, runner, cwd2) {
-  const out = await runner.run(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], cwd2);
+var TRANSIENT_GH_RE = /HTTP 5\d\d|Gateway Timeout|Bad Gateway|Service Unavailable|connection reset|ECONNRESET|ETIMEDOUT|getaddrinfo|EAI_AGAIN|could not resolve host/i;
+var GH_RETRY_DELAYS = [5000, 15000, 45000];
+async function runGhWithRetry(cmd, runner, cwd2, onRetry, sleep2 = (ms) => new Promise((r) => setTimeout(r, ms))) {
+  let lastErr;
+  for (let i = 0;i <= GH_RETRY_DELAYS.length; i++) {
+    try {
+      return await runner.run(cmd, cwd2);
+    } catch (err) {
+      const e = err;
+      const blob = `${e.message}
+${e.stderr ?? ""}
+${e.stdout ?? ""}`;
+      if (!TRANSIENT_GH_RE.test(blob) || i === GH_RETRY_DELAYS.length)
+        throw err;
+      const delay2 = GH_RETRY_DELAYS[i];
+      const firstLine = (e.stderr?.trim().split(`
+`)[0] ?? e.message).slice(0, 120);
+      onRetry?.(i + 1, delay2, firstLine);
+      await sleep2(delay2);
+      lastErr = err;
+    }
+  }
+  throw lastErr;
+}
+async function getPrChecksStatus(prRef, runner, cwd2, onTransientRetry) {
+  const out = await runGhWithRetry(["gh", "pr", "checks", prRef, "--json", PR_CHECKS_FIELDS], runner, cwd2, onTransientRetry);
   const checks = JSON.parse(out.stdout || "[]").filter((c) => c.bucket !== "skipping");
   if (checks.some((c) => c.bucket === "pending")) {
     return { bucket: "pending", failedRunIds: [] };
@@ -70902,17 +71021,28 @@ ${truncated}`);
 }
 async function fixCiUntilGreen(deps, opts) {
   for (let attempt2 = 1;attempt2 <= opts.maxAttempts; attempt2++) {
+    let pollN = 0;
     while (true) {
       if (deps.cancelled?.())
         return { success: false, attempts: attempt2 - 1, reason: "cancelled" };
-      const s = await deps.getStatus();
+      pollN += 1;
+      deps.onPhase?.("ci-poll", `attempt ${attempt2}/${opts.maxAttempts} \xB7 poll ${pollN}`);
+      let s;
+      try {
+        s = await deps.getStatus();
+      } catch (err) {
+        deps.log(`! gh pr checks failed permanently: ${err.message} \u2014 giving up CI watch`, "red");
+        return { success: false, attempts: attempt2 - 1, reason: "gh-failed" };
+      }
       if (s.bucket === "pass") {
         deps.log(`\u2713 CI green for PR (after ${attempt2 - 1} fix attempts)`, "green");
         return { success: true, attempts: attempt2 - 1 };
       }
       if (s.bucket === "fail") {
         deps.log(`\u2717 CI failing (attempt ${attempt2}/${opts.maxAttempts}) \u2014 fetching logs and re-running task`, "yellow");
+        deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 fetching logs`);
         const logs = await deps.getFailedLogs(s.failedRunIds);
+        deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 re-running worker`);
         const steering = `CI is failing on this PR. Investigate and fix:
 
 \`\`\`
@@ -70923,6 +71053,7 @@ ${logs}
           deps.log(`! task loop exited code ${code} during CI fix attempt ${attempt2}`, "red");
         }
         try {
+          deps.onPhase?.("ci-fix", `attempt ${attempt2}/${opts.maxAttempts} \xB7 pushing fix`);
           await deps.pushBranch();
         } catch (err) {
           deps.log(`! push failed during CI fix: ${err.message}`, "red");
@@ -70930,6 +71061,7 @@ ${logs}
         }
         break;
       }
+      deps.onPhase?.("ci-poll", `attempt ${attempt2}/${opts.maxAttempts} \xB7 pending, waiting`);
       await deps.sleep(opts.pollIntervalSeconds * 1000);
     }
   }
@@ -70957,6 +71089,7 @@ async function reactivateState(stateFilePath, log2, changeName) {
 }
 async function runPostTask(input, deps) {
   const { log: log2, cmd, git, runScript } = deps;
+  const emit = (phase, detail) => deps.onPhase?.(phase, detail);
   const {
     changeName,
     cwd: cwd2,
@@ -70973,6 +71106,7 @@ async function runPostTask(input, deps) {
     respawnWorker
   } = input;
   if (cfg.teardownScript) {
+    emit("teardown", cfg.teardownScript);
     try {
       await runScript("teardown", cfg.teardownScript, cwd2);
     } catch {}
@@ -70987,7 +71121,7 @@ async function runPostTask(input, deps) {
       const maxHookFixAttempts = cfg.maxCiFixAttempts;
       const runWorkerWithFixTask = async (heading, failureOutput) => {
         try {
-          await prependFixTask(join15(changeDir, "tasks.md"), heading, failureOutput);
+          await prependFixTask(join14(changeDir, "tasks.md"), heading, failureOutput);
         } catch (err) {
           log2(`! could not prepend fix task: ${err.message}`, "red");
           return 1;
@@ -70998,6 +71132,7 @@ async function runPostTask(input, deps) {
       let hookFixAttempt = 0;
       let commitGaveUp = false;
       while (true) {
+        emit("committing", "git status");
         let dirty = "";
         try {
           const status = await cmd.run(["git", "status", "--porcelain"], cwd2);
@@ -71009,7 +71144,9 @@ async function runPostTask(input, deps) {
         if (!dirty)
           break;
         try {
+          emit("committing", "git add -A");
           await cmd.run(["git", "add", "-A"], cwd2);
+          emit("committing", "git commit");
           await cmd.run(["git", "commit", "-m", `chore(ralph): residual changes for ${changeName}`], cwd2);
           log2(`  committed residual changes for ${changeName}`, "gray");
           break;
@@ -71028,6 +71165,7 @@ ${e.stderr ?? ""}`;
             break;
           }
           hookFixAttempt += 1;
+          emit("commit-retry", `${hookFixAttempt}/${maxHookFixAttempts}`);
           log2(`! commit rejected for ${changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
           log2(`    detail: ${detail}`, "yellow");
           const retryCode = await runWorkerWithFixTask("Fix host pre-commit hook rejection", `Committing residual changes was rejected by the host repo's pre-commit hook. ` + `Fix the underlying problem, then the commit will be retried.
@@ -71043,8 +71181,10 @@ ${e.stderr ?? ""}`;
       }
       let pr = null;
       let prGaveUp = commitGaveUp;
+      let nonFfRebaseAttempted = false;
       while (!prGaveUp) {
         try {
+          emit("pr-create", "git push + gh pr create");
           pr = await createPullRequest({ cwd: cwd2, branch, issue, base: cfg.prBaseBranch }, cmd);
           break;
         } catch (err) {
@@ -71052,8 +71192,69 @@ ${e.stderr ?? ""}`;
           const detail = e.stderr?.trim() || e.message;
           const combined = `${e.stdout ?? ""}
 ${e.stderr ?? ""}`;
-          const pushRejected = /failed to push some refs|pre-push hook|hook declined/i.test(combined);
-          if (!pushRejected || hookFixAttempt >= maxHookFixAttempts) {
+          const isNonFastForward = /non-fast-forward|Updates were rejected because the (tip of your current branch is behind|remote contains work)/i.test(combined) && !/pre-push hook|hook declined/i.test(combined);
+          const isHookReject = /pre-push hook|hook declined/i.test(combined);
+          const pushRejected = isHookReject || /failed to push some refs/i.test(combined);
+          if (isNonFastForward && !nonFfRebaseAttempted) {
+            nonFfRebaseAttempted = true;
+            emit("rebasing", `git pull --rebase origin ${branch}`);
+            log2(`  non-fast-forward push for ${changeName} \u2014 rebasing onto origin/${branch}`, "yellow");
+            try {
+              await cmd.run(["git", "fetch", "origin", branch], cwd2);
+              await cmd.run(["git", "pull", "--rebase", "origin", branch], cwd2);
+              continue;
+            } catch (rebaseErr) {
+              const re = rebaseErr;
+              const reBlob = `${re.stdout ?? ""}
+${re.stderr ?? ""}`;
+              const isConflict = /CONFLICT|Merge conflict|could not apply|both modified/i.test(reBlob);
+              if (!isConflict) {
+                log2(`! rebase failed for ${changeName}: ${rebaseErr.message} \u2014 giving up`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              emit("rebasing", "conflicts detected \u2014 aborting + queueing fix task");
+              try {
+                await cmd.run(["git", "rebase", "--abort"], cwd2);
+              } catch {}
+              let conflictedFiles = "";
+              try {
+                const r = await cmd.run(["git", "diff", "--name-only", `HEAD..origin/${branch}`], cwd2);
+                conflictedFiles = r.stdout.trim();
+              } catch {}
+              if (hookFixAttempt >= maxHookFixAttempts) {
+                log2(`! merge conflict on rebase of ${branch} after ${hookFixAttempt} attempts \u2014 worktree preserved at ${cwd2}`, "red");
+                log2(`    detail: ${reBlob.trim().split(`
+`).slice(0, 8).join(`
+`)}`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              hookFixAttempt += 1;
+              emit("rebasing", `conflict-fix ${hookFixAttempt}/${maxHookFixAttempts}`);
+              log2(`! merge conflict rebasing ${branch} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
+              const retryCode2 = await runWorkerWithFixTask("Resolve merge conflict with origin/" + branch, `Push to origin/${branch} was rejected as non-fast-forward, and rebasing ` + `onto origin/${branch} produced merge conflicts.
+
+` + `Run \`git fetch origin ${branch}\` and \`git rebase origin/${branch}\`, ` + `resolve every conflict, \`git add\` the resolved files, and finish with ` + `\`git rebase --continue\`. The push will be retried after this loop ` + `iteration finishes.
+
+` + (conflictedFiles ? `Files that differ between your branch and origin/${branch}:
+${conflictedFiles}
+
+` : "") + `Rebase output:
+${reBlob.trim()}`);
+              if (retryCode2 !== 0) {
+                log2(`! worker re-run after merge conflict exited code ${retryCode2} \u2014 giving up`, "red");
+                effectiveCode = PR_FAILED_EXIT;
+                prGaveUp = true;
+                break;
+              }
+              nonFfRebaseAttempted = false;
+              continue;
+            }
+          }
+          if (!isHookReject || hookFixAttempt >= maxHookFixAttempts) {
             if (pushRejected) {
               log2(`! push rejected for ${changeName} after ${hookFixAttempt} hook-fix attempts (host pre-push hook still failing) \u2014 worktree preserved at ${cwd2}`, "red");
               log2(`    detail: ${detail}`, "red");
@@ -71065,6 +71266,7 @@ ${e.stderr ?? ""}`;
             break;
           }
           hookFixAttempt += 1;
+          emit("push-retry", `${hookFixAttempt}/${maxHookFixAttempts}`);
           log2(`! push rejected for ${changeName} \u2014 prepending fix task and re-running loop (attempt ${hookFixAttempt}/${maxHookFixAttempts})`, "yellow");
           log2(`    detail: ${detail}`, "yellow");
           const retryCode = await runWorkerWithFixTask("Fix host pre-push hook rejection", `Push to origin/${branch} was rejected by the host repo's pre-push hook. ` + `Fix the underlying problem, then the push will be retried.
@@ -71082,14 +71284,17 @@ ${e.stderr ?? ""}`;
         log2(`  no commits ahead of ${cfg.prBaseBranch} \u2014 skipping PR`, "gray");
       } else {
         log2(`  ${pr.created ? "opened" : "found existing"} PR: ${pr.url}`, "green");
+        deps.registerPr?.(changeName, pr.url);
         if (wantFixCi) {
           log2(`  watching CI for ${pr.url} (max ${cfg.maxCiFixAttempts} fix attempts)`, "gray");
+          emit("ci-poll", "starting");
           const result2 = await fixCiUntilGreen({
-            getStatus: () => getPrChecksStatus(pr.url, cmd, cwd2),
+            onPhase: (p, d) => emit(p, d),
+            getStatus: () => getPrChecksStatus(pr.url, cmd, cwd2, (n, ms, why) => log2(`  gh transient (try ${n}) \u2014 retry in ${Math.round(ms / 1000)}s \xB7 ${why}`, "yellow")),
             getFailedLogs: (ids) => fetchFailedRunLogs(ids, cmd, cwd2),
             runTaskWithSteering: async (steering) => {
               try {
-                await prependFixTask(join15(changeDir, "tasks.md"), "Fix failing CI checks", steering);
+                await prependFixTask(join14(changeDir, "tasks.md"), "Fix failing CI checks", steering);
               } catch (err) {
                 log2(`! could not prepend fix task: ${err.message}`, "red");
               }
@@ -71112,7 +71317,12 @@ ${e.stderr ?? ""}`;
       }
     }
   }
+  if (effectiveCode === 0)
+    emit("done");
+  else
+    emit("gave-up", `exit ${effectiveCode}`);
   if (useWorktree && cwd2 !== projectRoot) {
+    emit("cleanup", "checking worktree safety");
     if (effectiveCode === 0 && cfg.cleanupWorktreeOnSuccess) {
       const check = await isWorktreeSafeToRemove(cwd2, cfg.prBaseBranch, git).catch((err) => ({
         safe: false,
@@ -71176,6 +71386,50 @@ 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 mergeIndicators(cfg, cli) {
+  const out = {};
+  for (const [k, v] of Object.entries(cfg)) {
+    if (v !== undefined)
+      out[k] = v;
+  }
+  for (const [k, v] of Object.entries(cli)) {
+    if (v !== undefined)
+      out[k] = v;
+  }
+  return out;
+}
+function unionMarkers(...sets) {
+  const out = [];
+  const seen = new Set;
+  for (const s of sets) {
+    if (!s)
+      continue;
+    for (const m of markersOf(s)) {
+      const key = `${m.type}:${m.value}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push(m);
+    }
+  }
+  return out;
+}
 function buildAgentCoordinator(input) {
   const {
     args,
@@ -71184,33 +71438,104 @@ function buildAgentCoordinator(input) {
     statesDir,
     tasksDir,
     apiKey,
-    store,
     onLog,
     onWorkersChanged,
     onWorkerStarted,
-    onWorkerExited
+    onWorkerExited,
+    onWorkerPhase,
+    onWorkerOutput,
+    onWorkerCmd
   } = input;
+  const logsDir = join15(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 indicators = mergeIndicators(cfg.linear.indicators, args.indicators);
+  const team = args.linearTeam || cfg.linear.team;
+  const assignee = args.linearAssignee || cfg.linear.assignee;
+  const excludeFromTodo = unionMarkers(indicators.setDone, indicators.setError, indicators.setConflicted);
+  const gitRunner = input.runners?.git ?? bunGitRunner;
+  const cmdRunner = input.runners?.cmd ?? bunCmdRunner;
   const stateCache = new Map;
   const labelCache = new Map;
   const teamKeyOf = (issue) => issue.identifier.split("-")[0];
-  const useWorktree = args.worktree || cfg.useWorktree;
+  async function resolveStateId(issue, name) {
+    const t = teamKeyOf(issue);
+    let map2 = stateCache.get(t);
+    if (!map2) {
+      const states = await fetchWorkflowStates(apiKey, t);
+      map2 = new Map(states.map((s) => [s.name.toLowerCase(), s.id]));
+      stateCache.set(t, map2);
+    }
+    return map2.get(name.toLowerCase()) ?? null;
+  }
+  async function resolveLabelId(issue, name) {
+    const t = teamKeyOf(issue);
+    let map2 = labelCache.get(t);
+    if (!map2) {
+      const labels = await fetchIssueLabels(apiKey, t);
+      map2 = new Map(labels.map((l) => [l.name.toLowerCase(), l.id]));
+      labelCache.set(t, map2);
+    }
+    return map2.get(name.toLowerCase()) ?? null;
+  }
+  async function applyMarker(issue, m) {
+    if (m.type === "status") {
+      const id = await resolveStateId(issue, m.value);
+      if (!id) {
+        onLog(`! Linear status '${m.value}' not found for ${issue.identifier}`, "yellow");
+        return;
+      }
+      await updateIssueState(apiKey, issue.id, id);
+      onLog(`  \u2192 ${issue.identifier} status='${m.value}'`, "gray");
+    } else {
+      const id = await resolveLabelId(issue, m.value);
+      if (!id) {
+        onLog(`! Linear label '${m.value}' not found for ${issue.identifier}`, "yellow");
+        return;
+      }
+      await addLabelToIssue(apiKey, issue.id, id);
+      onLog(`  \u2192 ${issue.identifier} +label='${m.value}'`, "gray");
+    }
+  }
+  async function applyIndicator(issue, ind) {
+    for (const m of markersOf(ind))
+      await applyMarker(issue, m);
+  }
+  async function removeIndicator(issue, ind) {
+    for (const m of markersOf(ind)) {
+      if (m.type !== "label")
+        continue;
+      const id = await resolveLabelId(issue, m.value);
+      if (!id) {
+        onLog(`! Linear label '${m.value}' not found for ${issue.identifier}`, "yellow");
+        continue;
+      }
+      await removeLabelFromIssue(apiKey, issue.id, id);
+      onLog(`  \u2192 ${issue.identifier} -label='${m.value}'`, "gray");
+    }
+  }
+  async function fetchByGet(inc, excl) {
+    if (!inc)
+      return [];
+    const include = "filter" in inc ? inc.filter : [];
+    if (include.length === 0)
+      return [];
+    const spec = {
+      team,
+      assignee,
+      include,
+      exclude: excl
+    };
+    return fetchOpenIssues(apiKey, spec);
+  }
   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 prByChange = new Map;
+  const prUnavailable = new Set;
+  const useWorktree = args.worktree || cfg.useWorktree;
+  const scriptRunner = input.runners?.runScript ?? (async (cmd, cwd2) => {
     const proc = Bun.spawn({
       cmd: ["sh", "-c", cmd],
       cwd: cwd2,
@@ -71221,51 +71546,112 @@ function buildAgentCoordinator(input) {
     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(`
+      onLog(`! script 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");
+    return code;
+  });
+  async function runScript(label, cmd, cwd2) {
+    onLog(`  ${label}: ${cmd}`, "gray");
+    const code = await scriptRunner(cmd, cwd2);
+    if (code !== 0) {
+      onLog(`! ${label} exited code ${code}`, "yellow");
     }
+  }
+  async function setupWorktree(issue) {
     let workerCwd = projectRoot;
     let scaffoldTasksDir = tasksDir;
     let scaffoldStatesDir = statesDir;
-    let workerBranch = null;
+    let branch = null;
+    if (!useWorktree)
+      return { workerCwd, scaffoldTasksDir, scaffoldStatesDir, branch };
     const probeName = issue.identifier.toLowerCase();
-    if (useWorktree) {
+    try {
+      const wt = await createWorktree(projectRoot, probeName, gitRunner);
+      workerCwd = wt.cwd;
+      branch = wt.branch;
+      const wtLayout = projectLayout(wt.cwd);
+      scaffoldTasksDir = wtLayout.tasksDir;
+      scaffoldStatesDir = wtLayout.statesDir;
+      onLog(`  ${issue.identifier} worktree: ${wt.cwd} (${wt.branch})`, "gray");
       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");
-        }
+        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");
+    }
+    return { workerCwd, scaffoldTasksDir, scaffoldStatesDir, branch };
+  }
+  async function prepare(issue, mode) {
+    const { workerCwd, scaffoldTasksDir, scaffoldStatesDir, branch } = await setupWorktree(issue);
+    let changeName;
+    if (mode === "fresh") {
+      let comments = [];
+      try {
+        comments = await fetchIssueComments(apiKey, issue.id);
       } catch (err) {
-        onLog(`! worktree create failed for ${issue.identifier}: ${err.message} \u2014 falling back to project root`, "yellow");
+        onLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
       }
+      const appendPrompt = args.prompt || cfg.appendPrompt || "";
+      changeName = await scaffoldChangeForIssue(scaffoldTasksDir, scaffoldStatesDir, issue, comments, appendPrompt);
+    } else {
+      changeName = changeNameForIssue(issue);
+      const wtLayout = projectLayout(workerCwd);
+      await mkdir3(wtLayout.changeDir(changeName), { recursive: true });
+      await mkdir3(wtLayout.taskStateDir(changeName), { recursive: true });
     }
-    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 (branch)
+      branchByChange.set(changeName, branch);
+    if (mode === "conflict-fix") {
+      const wtLayout = projectLayout(workerCwd);
+      const tasksFile = join15(wtLayout.changeDir(changeName), "tasks.md");
+      const prUrl = prByChange.get(changeName);
+      const body = [
+        `The PR for this change has merge conflicts with \`${cfg.prBaseBranch}\`.`,
+        "",
+        "Steps:",
+        `1. \`git fetch origin ${cfg.prBaseBranch}\` then rebase or merge \`${cfg.prBaseBranch}\` into the current branch.`,
+        "2. Resolve conflicts in the files git lists.",
+        "3. Stage and commit the resolution.",
+        prUrl ? `
+PR: ${prUrl}` : ""
+      ].filter(Boolean).join(`
+`);
+      try {
+        await prependFixTask(tasksFile, "Resolve PR merge conflicts", body);
+      } catch (err) {
+        onLog(`! could not prepend conflict-fix task: ${err.message}`, "red");
+      }
+      await reactivateState2(wtLayout.stateFile(changeName), changeName);
+    }
     if (cfg.setupScript) {
       await runScript("setup", cfg.setupScript, workerCwd);
     }
-    return changeName;
+    return {
+      changeName,
+      ...prByChange.has(changeName) ? { prUrl: prByChange.get(changeName) } : {}
+    };
+  }
+  async function reactivateState2(stateFilePath, changeName) {
+    const file = Bun.file(stateFilePath);
+    if (!await file.exists())
+      return;
+    try {
+      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) {
+      onLog(`! could not reactivate state for ${changeName}: ${err.message}`, "yellow");
+    }
   }
   function buildTaskCmdFor(changeName) {
     const c = [
@@ -71298,29 +71684,102 @@ function buildAgentCoordinator(input) {
       c.push("--verbose");
     return c;
   }
-  function spawnWorker(changeName) {
-    const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
-    const respawn = () => {
-      const rp = Bun.spawn({
-        cmd: buildTaskCmdFor(changeName),
-        cwd: cwd2,
-        stdout: "ignore",
-        stderr: "ignore",
-        stdin: "ignore"
-      });
-      return rp.exited;
+  function defaultSpawn(changeName, cmd, cwd2, note) {
+    const logFilePath = join15(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;
+      }
     };
-    const proc = Bun.spawn({
-      cmd: buildTaskCmdFor(changeName),
+    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 p = Bun.spawn({
+      cmd,
       cwd: cwd2,
-      stdout: "ignore",
-      stderr: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
       stdin: "ignore"
     });
-    onWorkerStarted(changeName, statesDirByChange.get(changeName) ?? statesDir);
+    (async () => {
+      const writer = await ensureLogWriter();
+      if (note && writer)
+        writer.write(`
+--- ${note} ---
+`);
+    })();
+    pump(p.stdout, "out");
+    pump(p.stderr, "err");
+    return { exited: p.exited, kill: () => p.kill(), logFilePath };
+  }
+  function spawnWorker(changeName) {
+    const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
+    const injected = input.runners?.spawnWorker;
+    let logFilePath;
+    let handle;
+    if (injected) {
+      logFilePath = join15(logsDir, `${changeName}.log`);
+      handle = injected(buildTaskCmdFor(changeName), cwd2);
+    } else {
+      const r = defaultSpawn(changeName, buildTaskCmdFor(changeName), cwd2, `spawn at ${new Date().toISOString()}`);
+      logFilePath = r.logFilePath;
+      handle = { exited: r.exited, kill: r.kill };
+    }
+    const respawn = () => {
+      onWorkerPhase?.(changeName, "working", "respawn");
+      if (injected)
+        return injected(buildTaskCmdFor(changeName), cwd2).exited;
+      return defaultSpawn(changeName, buildTaskCmdFor(changeName), cwd2, `respawn at ${new Date().toISOString()}`).exited;
+    };
+    onWorkerStarted(changeName, statesDirByChange.get(changeName) ?? statesDir, logFilePath);
+    onWorkerPhase?.(changeName, "working");
+    const tracedCmd = onWorkerCmd ? traceCmdRunner(cmdRunner, (cmd) => onWorkerCmd(changeName, cmd, "start"), (cmd, ms, ok) => onWorkerCmd(changeName, cmd, "end", ms, ok)) : cmdRunner;
     const wantPr = args.createPr || cfg.createPrOnSuccess;
     const wantFixCi = args.fixCi || cfg.fixCiOnFailure;
-    const wrapped = proc.exited.then(async (code) => {
+    const wrapped = handle.exited.then(async (code) => {
       const workerLayout = projectLayout(cwd2);
       const effectiveCode = await runPostTask({
         changeName,
@@ -71342,7 +71801,19 @@ function buildAgentCoordinator(input) {
           cleanupWorktreeOnSuccess: cfg.cleanupWorktreeOnSuccess
         },
         respawnWorker: respawn
-      }, { cmd: bunCmdRunner, git: bunGitRunner, log: onLog, runScript });
+      }, {
+        cmd: tracedCmd,
+        git: gitRunner,
+        log: onLog,
+        runScript,
+        registerPr: (cn, url) => {
+          prByChange.set(cn, url);
+          prUnavailable.delete(cn);
+        },
+        ...onWorkerPhase && {
+          onPhase: (phase, detail) => onWorkerPhase(changeName, phase, detail)
+        }
+      });
       cwdByChange.delete(changeName);
       statesDirByChange.delete(changeName);
       branchByChange.delete(changeName);
@@ -71350,13 +71821,73 @@ function buildAgentCoordinator(input) {
       onWorkerExited(changeName);
       return effectiveCode;
     });
-    return { exited: wrapped, kill: () => proc.kill() };
+    return { exited: wrapped, kill: () => handle.kill() };
+  }
+  async function checkPrConflict(issue) {
+    const changeName = changeNameForIssue(issue);
+    if (prUnavailable.has(changeName))
+      return null;
+    const branch = branchForChange(changeName);
+    let prUrl = prByChange.get(changeName);
+    if (!prUrl) {
+      try {
+        const res = await cmdRunner.run([
+          "gh",
+          "pr",
+          "list",
+          "--head",
+          branch,
+          "--state",
+          "open",
+          "--json",
+          "url",
+          "--jq",
+          ".[0].url // empty"
+        ], projectRoot);
+        const found = res.stdout.trim();
+        if (!found) {
+          prUnavailable.add(changeName);
+          return null;
+        }
+        prUrl = found;
+        prByChange.set(changeName, prUrl);
+      } catch {
+        prUnavailable.add(changeName);
+        return null;
+      }
+    }
+    try {
+      const res = await cmdRunner.run(["gh", "pr", "view", prUrl, "--json", "mergeable", "--jq", ".mergeable"], projectRoot);
+      const mergeable = res.stdout.trim();
+      return { url: prUrl, conflicting: mergeable === "CONFLICTING" };
+    } catch {
+      return null;
+    }
+  }
+  async function fetchDoneCandidates() {
+    if (!indicators.setDone)
+      return [];
+    const include = markersOf(indicators.setDone);
+    const exclude = indicators.setConflicted ? markersOf(indicators.setConflicted) : [];
+    if (include.length === 0)
+      return [];
+    return fetchOpenIssues(apiKey, { team, assignee, include, exclude });
   }
   const coord = new AgentCoordinator({
-    fetchIssues: (f2) => fetchOpenIssues(apiKey, f2),
-    scaffold: scaffoldCallback,
+    fetchTodo: () => fetchByGet(indicators.getTodo, excludeFromTodo),
+    fetchInProgress: () => fetchByGet(indicators.getInProgress, []),
+    fetchConflicted: () => fetchByGet(indicators.getConflicted, []),
+    fetchDoneCandidates,
+    prepare,
     spawnWorker,
-    store,
+    applyIndicator,
+    removeIndicator,
+    postComment: (issue, body) => addIssueComment(apiKey, issue.id, body),
+    fetchComments: async (issueId) => {
+      const c = await fetchIssueComments(apiKey, issueId);
+      return c.map((x) => ({ body: x.body }));
+    },
+    checkPrConflict,
     onLog,
     onWorkersChanged,
     getIterationCount: async (changeName) => {
@@ -71366,42 +71897,29 @@ function buildAgentCoordinator(input) {
         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,
+    ...indicators.setInProgress !== undefined ? { setInProgress: indicators.setInProgress } : {},
+    ...indicators.setDone !== undefined ? { setDone: indicators.setDone } : {},
+    ...indicators.setError !== undefined ? { setError: indicators.setError } : {},
+    ...indicators.setConflicted !== undefined ? { setConflicted: indicators.setConflicted } : {},
+    ...indicators.clearConflicted !== undefined ? { clearConflicted: indicators.clearConflicted } : {},
     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(",")}` : ""}`;
+  (async () => {
+    const legacy = Bun.file(projectLayout(projectRoot).agentStateFile);
+    if (await legacy.exists()) {
+      onLog("  legacy .ralph/agent-state.json detected \u2014 Linear is now the source of truth; deleting", "gray");
+      try {
+        await legacy.delete();
+      } catch (err) {
+        onLog(`! failed to delete legacy agent-state.json: ${err.message}`, "yellow");
+      }
+    }
+  })();
+  const filterDesc = describeIndicators(indicators, team, assignee);
   return {
     coord,
     filterDesc,
@@ -71410,6 +71928,21 @@ function buildAgentCoordinator(input) {
     getWorkerCwd: (changeName) => cwdByChange.get(changeName)
   };
 }
+function describeIndicators(indicators, team, assignee) {
+  const parts = [];
+  parts.push(`team=${team ?? "*"}`);
+  parts.push(`assignee=${assignee ?? "*"}`);
+  if (indicators.getTodo) {
+    parts.push(`todo=[${indicators.getTodo.filter.map((m) => `${m.type}:${m.value}`).join(",")}]`);
+  }
+  if (indicators.getInProgress) {
+    parts.push(`inProgress=[${indicators.getInProgress.filter.map((m) => `${m.type}:${m.value}`).join(",")}]`);
+  }
+  if (indicators.getConflicted) {
+    parts.push(`conflicted=[${indicators.getConflicted.filter.map((m) => `${m.type}:${m.value}`).join(",")}]`);
+  }
+  return parts.join(", ");
+}
 
 // apps/cli/src/components/AgentMode.tsx
 var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
@@ -71418,6 +71951,12 @@ function nextId() {
   lineCounter += 1;
   return `${Date.now()}-${lineCounter}`;
 }
+var TAIL_MAX_LINES = 5;
+var CMD_DISPLAY_MAX = 80;
+function fmtCmd(argv) {
+  const joined = argv.join(" ");
+  return joined.length > CMD_DISPLAY_MAX ? joined.slice(0, CMD_DISPLAY_MAX - 1) + "\u2026" : joined;
+}
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 function fmtElapsed(ms) {
   const s = Math.floor(ms / 1000);
@@ -71455,8 +71994,6 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
         exit();
         return;
       }
-      const store = new AgentStateStore(projectRoot);
-      await store.load();
       const { coord: coord2, filterDesc, concurrency, pollInterval } = buildAgentCoordinator({
         args,
         cfg,
@@ -71464,18 +72001,52 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
         statesDir,
         tasksDir,
         apiKey,
-        store,
         onLog: appendLog,
         onWorkersChanged: () => setTick((t) => t + 1),
-        onWorkerStarted: (changeName, dir) => {
+        onWorkerStarted: (changeName, dir, logFile) => {
           workerMetaRef.current.set(changeName, {
             startedAt: Date.now(),
             statesDir: dir,
-            iter: 0
+            logFile,
+            iter: 0,
+            phase: "working",
+            phaseDetail: "",
+            phaseStartedAt: Date.now(),
+            currentCmd: null,
+            lastCmd: null,
+            tail: []
           });
         },
         onWorkerExited: (changeName) => {
           workerMetaRef.current.delete(changeName);
+        },
+        onWorkerPhase: (changeName, phase, detail) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          if (m.phase !== phase)
+            m.phaseStartedAt = Date.now();
+          m.phase = phase;
+          m.phaseDetail = detail ?? "";
+        },
+        onWorkerOutput: (changeName, line) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          m.tail.push(line);
+          if (m.tail.length > TAIL_MAX_LINES)
+            m.tail.splice(0, m.tail.length - TAIL_MAX_LINES);
+        },
+        onWorkerCmd: (changeName, cmd, state, durationMs, ok) => {
+          const m = workerMetaRef.current.get(changeName);
+          if (!m)
+            return;
+          if (state === "start") {
+            m.currentCmd = { argv: cmd, startedAt: Date.now() };
+          } else {
+            m.currentCmd = null;
+            m.lastCmd = { argv: cmd, durationMs: durationMs ?? 0, ok: ok ?? true };
+          }
         }
       });
       appendLog(`concurrency=${concurrency} pollInterval=${pollInterval}s`, "gray");
@@ -71589,19 +72160,56 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
             const meta = workerMetaRef.current.get(w.changeName);
             const elapsed = meta ? fmtElapsed(now2 - meta.startedAt) : "\u2013";
             const iter = meta?.iter ?? 0;
-            return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
-              color: "cyan",
+            const phase = meta?.phase ?? "working";
+            const phaseElapsed = meta ? fmtElapsed(now2 - meta.phaseStartedAt) : "\u2013";
+            const phaseDetail = meta?.phaseDetail ? ` (${meta.phaseDetail})` : "";
+            const cmd = meta?.currentCmd;
+            const cmdElapsed = cmd ? fmtElapsed(now2 - cmd.startedAt) : null;
+            const tail2 = meta?.tail ?? [];
+            return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+              flexDirection: "column",
               children: [
-                "  ",
-                spinnerFrame,
-                " ",
-                w.issueIdentifier,
-                " (",
-                w.changeName,
-                ") \xB7 iter ",
-                iter,
-                " \xB7 ",
-                elapsed
+                /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  color: "cyan",
+                  children: [
+                    "  ",
+                    spinnerFrame,
+                    " ",
+                    w.issueIdentifier,
+                    " (",
+                    w.changeName,
+                    ") \xB7 iter ",
+                    iter,
+                    " \xB7 ",
+                    elapsed
+                  ]
+                }, undefined, true, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  dimColor: true,
+                  children: [
+                    "      phase: ",
+                    phase,
+                    phaseDetail,
+                    " \xB7 ",
+                    phaseElapsed
+                  ]
+                }, undefined, true, undefined, this),
+                cmd && /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  color: "yellow",
+                  children: [
+                    "      \u23F5 ",
+                    fmtCmd(cmd.argv),
+                    " \xB7 ",
+                    cmdElapsed
+                  ]
+                }, undefined, true, undefined, this),
+                tail2.map((line, i) => /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+                  dimColor: true,
+                  children: [
+                    "      \u2502 ",
+                    line.length > 110 ? line.slice(0, 109) + "\u2026" : line
+                  ]
+                }, `${w.changeName}-tail-${i}`, true, undefined, this))
               ]
             }, w.changeName, true, undefined, this);
           })
@@ -71613,7 +72221,7 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
 
 // packages/openspec/src/openspec-change-store.ts
 import { join as join17, dirname as dirname4 } from "path";
-import { readdir, mkdir as mkdir3 } from "fs/promises";
+import { readdir, mkdir as mkdir4 } from "fs/promises";
 function resolveOpenspecBin() {
   const pkgJsonPath = Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir);
   return join17(dirname4(pkgJsonPath), "bin", "openspec.js");
@@ -71674,7 +72282,7 @@ class OpenSpecChangeStore {
   }
   async writeTaskList(name, content) {
     const path = join17("openspec", "changes", name, "tasks.md");
-    await mkdir3(dirname4(path), { recursive: true });
+    await mkdir4(dirname4(path), { recursive: true });
     await Bun.write(path, content);
   }
   async appendSteering(name, message) {
@@ -71685,7 +72293,7 @@ class OpenSpecChangeStore {
 
 ${existing.trimStart()}` : `${message}
 `;
-    await mkdir3(dirname4(path), { recursive: true });
+    await mkdir4(dirname4(path), { recursive: true });
     await Bun.write(path, updated);
   }
   async readSection(name, artifact, heading) {
@@ -71872,7 +72480,7 @@ try {
   const statesDir = layout.statesDir;
   const tasksDir = layout.tasksDir;
   if (args.mode === "init") {
-    await mkdir4(statesDir, { recursive: true });
+    await mkdir5(statesDir, { recursive: true });
     const openspecBin = join19(dirname5(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
     Bun.spawnSync({
       cmd: [process.execPath, openspecBin, "init", "--tools", "none", "--force"],
@@ -71926,14 +72534,6 @@ try {
       await rm(stateDir, { recursive: true, force: true });
       removed.push(`task state ${stateDir}`);
     }
-    try {
-      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) {
       process.stdout.write(`Nothing to clean for '${args.name}'
 `);
@@ -71948,13 +72548,13 @@ try {
     process.exit(0);
   }
   if (args.mode === "task" && args.name) {
-    await mkdir4(join19(statesDir, args.name), { recursive: true });
-    await mkdir4(join19(tasksDir, args.name), { recursive: true });
+    await mkdir5(join19(statesDir, args.name), { recursive: true });
+    await mkdir5(join19(tasksDir, args.name), { recursive: true });
   }
   if (args.mode === "agent") {
-    await mkdir4(statesDir, { recursive: true });
-    await mkdir4(tasksDir, { recursive: true });
-    await mkdir4(join19(projectRoot, ".ralph"), { recursive: true });
+    await mkdir5(statesDir, { recursive: true });
+    await mkdir5(tasksDir, { recursive: true });
+    await mkdir5(join19(projectRoot, ".ralph"), { recursive: true });
   }
   await runWithContext(createDefaultContext(), async () => {
     const { waitUntilExit } = render_default(import_react59.createElement(App2, { args, statesDir, tasksDir, projectRoot }));