@neriros/ralphy 2.12.0 → 2.13.0

package/dist/cli/index.js

@@ -50837,8 +50837,8 @@ var require_axios = __commonJS((exports, module) => {
 });
 
 // apps/cli/src/index.ts
-import { resolve, join as join20, dirname as dirname5 } from "path";
-import { exists as exists2, mkdir as mkdir4, rm } from "fs/promises";
+import { resolve, join as join19, dirname as dirname5 } from "path";
+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.12.0",
+  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;
@@ -56879,7 +56900,7 @@ function createDefaultContext() {
 
 // apps/cli/src/components/App.tsx
 var import_react58 = __toESM(require_react(), 1);
-import { join as join19 } from "path";
+import { join as join18 } from "path";
 
 // packages/core/src/state.ts
 import { join as join2 } from "path";
@@ -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(),
@@ -70104,89 +70128,46 @@ function TaskLoop({ opts }) {
 
 // apps/cli/src/components/AgentMode.tsx
 var import_react57 = __toESM(require_react(), 1);
-import { join as join17 } from "path";
+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;
@@ -70250,49 +70243,85 @@ async function ensureRalphyConfig(projectRoot) {
 }
 
 // apps/cli/src/agent/wire.ts
-import { join as join16 } from "path";
+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 {
@@ -70409,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 {
@@ -70418,6 +70456,7 @@ class AgentCoordinator {
   pendingIds = new Set;
   queue = [];
   stopped = false;
+  conflictNotified = new Set;
   constructor(deps, opts) {
     this.deps = deps;
     this.opts = opts;
@@ -70435,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) {
@@ -70504,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;
     }
@@ -70534,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");
+      }
     }
-    this.deps.onLog(`\u25B6 ${issue.identifier} \u2192 ${changeName} (worker started)`, "cyan");
-    const handle = this.deps.spawnWorker(changeName, issue);
+    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 ${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() {
@@ -70654,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);
@@ -70662,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 ? [
     "",
@@ -70717,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}
@@ -70792,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;
@@ -70807,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);
       }
     }
   }
@@ -70816,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) {
@@ -71029,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;
@@ -71192,6 +71284,7 @@ ${reBlob.trim()}`);
         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");
@@ -71201,7 +71294,7 @@ ${reBlob.trim()}`);
             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");
               }
@@ -71309,6 +71402,34 @@ function traceCmdRunner(base2, onStart, onEnd) {
     }
   };
 }
+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,
@@ -71317,7 +71438,6 @@ function buildAgentCoordinator(input) {
     statesDir,
     tasksDir,
     apiKey,
-    store,
     onLog,
     onWorkersChanged,
     onWorkerStarted,
@@ -71326,28 +71446,96 @@ function buildAgentCoordinator(input) {
     onWorkerOutput,
     onWorkerCmd
   } = input;
-  const logsDir = join16(projectRoot, ".ralph", "logs");
+  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,
@@ -71358,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(`! worktree create failed for ${issue.identifier}: ${err.message} \u2014 falling back to project root`, "yellow");
+        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(`! 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 = [
@@ -71435,9 +71684,8 @@ function buildAgentCoordinator(input) {
       c.push("--verbose");
     return c;
   }
-  function spawnWorker(changeName) {
-    const cwd2 = cwdByChange.get(changeName) ?? projectRoot;
-    const logFilePath = join16(logsDir, `${changeName}.log`);
+  function defaultSpawn(changeName, cmd, cwd2, note) {
+    const logFilePath = join15(logsDir, `${changeName}.log`);
     let logWriter = null;
     const ensureLogWriter = async () => {
       if (logWriter)
@@ -71489,34 +71737,49 @@ function buildAgentCoordinator(input) {
         } catch {}
       }
     }
-    const launch = (note) => {
-      const p = Bun.spawn({
-        cmd: buildTaskCmdFor(changeName),
-        cwd: cwd2,
-        stdout: "pipe",
-        stderr: "pipe",
-        stdin: "ignore"
-      });
-      if (note && logWriter)
-        logWriter.write(`
+    const p = Bun.spawn({
+      cmd,
+      cwd: cwd2,
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore"
+    });
+    (async () => {
+      const writer = await ensureLogWriter();
+      if (note && writer)
+        writer.write(`
 --- ${note} ---
 `);
-      pump(p.stdout, "out");
-      pump(p.stderr, "err");
-      return p;
-    };
+    })();
+    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");
-      const rp = launch(`respawn at ${new Date().toISOString()}`);
-      return rp.exited;
+      if (injected)
+        return injected(buildTaskCmdFor(changeName), cwd2).exited;
+      return defaultSpawn(changeName, buildTaskCmdFor(changeName), cwd2, `respawn at ${new Date().toISOString()}`).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 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,
@@ -71540,17 +71803,17 @@ function buildAgentCoordinator(input) {
         respawnWorker: respawn
       }, {
         cmd: tracedCmd,
-        git: bunGitRunner,
+        git: gitRunner,
         log: onLog,
         runScript,
+        registerPr: (cn, url) => {
+          prByChange.set(cn, url);
+          prUnavailable.delete(cn);
+        },
         ...onWorkerPhase && {
           onPhase: (phase, detail) => onWorkerPhase(changeName, phase, detail)
         }
       });
-      try {
-        logWriter?.flush();
-        await logWriter?.end();
-      } catch {}
       cwdByChange.delete(changeName);
       statesDirByChange.delete(changeName);
       branchByChange.delete(changeName);
@@ -71558,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) => {
@@ -71574,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,
@@ -71618,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);
@@ -71669,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,
@@ -71678,7 +72001,6 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
         statesDir,
         tasksDir,
         apiKey,
-        store,
         onLog: appendLog,
         onWorkersChanged: () => setTick((t) => t + 1),
         onWorkerStarted: (changeName, dir, logFile) => {
@@ -71780,7 +72102,7 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
       (async () => {
         for (const [changeName, meta] of workerMetaRef.current) {
           try {
-            const file = Bun.file(join17(meta.statesDir, changeName, ".ralph-state.json"));
+            const file = Bun.file(join16(meta.statesDir, changeName, ".ralph-state.json"));
             if (await file.exists()) {
               const json = await file.json();
               meta.iter = json.iteration ?? meta.iter;
@@ -71898,11 +72220,11 @@ function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
 }
 
 // packages/openspec/src/openspec-change-store.ts
-import { join as join18, dirname as dirname4 } from "path";
-import { readdir, mkdir as mkdir3 } from "fs/promises";
+import { join as join17, dirname as dirname4 } from "path";
+import { readdir, mkdir as mkdir4 } from "fs/promises";
 function resolveOpenspecBin() {
   const pkgJsonPath = Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir);
-  return join18(dirname4(pkgJsonPath), "bin", "openspec.js");
+  return join17(dirname4(pkgJsonPath), "bin", "openspec.js");
 }
 function runOpenspec(args, options = {}) {
   const stdio = options.inherit ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"];
@@ -71928,7 +72250,7 @@ class OpenSpecChangeStore {
     }
   }
   getChangeDirectory(name) {
-    return join18("openspec", "changes", name);
+    return join17("openspec", "changes", name);
   }
   async listChanges() {
     const result2 = runOpenspec(["list", "--json"]);
@@ -71942,7 +72264,7 @@ class OpenSpecChangeStore {
         }
       } catch {}
     }
-    const changesDir = join18("openspec", "changes");
+    const changesDir = join17("openspec", "changes");
     if (!await Bun.file(changesDir).exists())
       return [];
     try {
@@ -71953,29 +72275,29 @@ class OpenSpecChangeStore {
     }
   }
   async readTaskList(name) {
-    const file = Bun.file(join18("openspec", "changes", name, "tasks.md"));
+    const file = Bun.file(join17("openspec", "changes", name, "tasks.md"));
     if (!await file.exists())
       return "";
     return await file.text();
   }
   async writeTaskList(name, content) {
-    const path = join18("openspec", "changes", name, "tasks.md");
-    await mkdir3(dirname4(path), { recursive: true });
+    const path = join17("openspec", "changes", name, "tasks.md");
+    await mkdir4(dirname4(path), { recursive: true });
     await Bun.write(path, content);
   }
   async appendSteering(name, message) {
-    const path = join18("openspec", "changes", name, "steering.md");
+    const path = join17("openspec", "changes", name, "steering.md");
     const file = Bun.file(path);
     const existing = await file.exists() ? await file.text() : null;
     const updated = existing ? `${message}
 
 ${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) {
-    const file = Bun.file(join18("openspec", "changes", name, artifact));
+    const file = Bun.file(join17("openspec", "changes", name, artifact));
     if (!await file.exists())
       return "";
     const content = await file.text();
@@ -72057,8 +72379,8 @@ function App2({ args, statesDir, tasksDir, projectRoot }) {
           message: "Error: --name is required for status mode"
         }, undefined, false, undefined, this);
       }
-      const stateDir = join19(statesDir, args.name);
-      if (getStorage().read(join19(stateDir, ".ralph-state.json")) === null) {
+      const stateDir = join18(statesDir, args.name);
+      if (getStorage().read(join18(stateDir, ".ralph-state.json")) === null) {
         return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ErrorMessage, {
           message: `Error: change '${args.name}' not found`
         }, undefined, false, undefined, this);
@@ -72119,7 +72441,7 @@ if (typeof globalThis.Bun === "undefined") {
 async function findProjectRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (await exists2(join20(dir, "openspec")))
+    if (await exists2(join19(dir, "openspec")))
       return dir;
     dir = resolve(dir, "..");
   }
@@ -72158,8 +72480,8 @@ try {
   const statesDir = layout.statesDir;
   const tasksDir = layout.tasksDir;
   if (args.mode === "init") {
-    await mkdir4(statesDir, { recursive: true });
-    const openspecBin = join20(dirname5(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
+    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"],
       stdio: ["inherit", "inherit", "inherit"],
@@ -72172,9 +72494,9 @@ try {
 `);
       process.exit(1);
     }
-    const worktreeDir = join20(worktreesDir(projectRoot), args.name);
-    const changeDir = join20(tasksDir, args.name);
-    const stateDir = join20(statesDir, args.name);
+    const worktreeDir = join19(worktreesDir(projectRoot), args.name);
+    const changeDir = join19(tasksDir, args.name);
+    const stateDir = join19(statesDir, args.name);
     const branch = `ralph/${args.name}`;
     const removed = [];
     if (await exists2(worktreeDir)) {
@@ -72212,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}'
 `);
@@ -72234,13 +72548,13 @@ try {
     process.exit(0);
   }
   if (args.mode === "task" && args.name) {
-    await mkdir4(join20(statesDir, args.name), { recursive: true });
-    await mkdir4(join20(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(join20(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 }));