@neriros/ralphy 2.6.0 → 2.7.1

package/dist/cli/index.js

@@ -50548,8 +50548,8 @@ var require_axios = __commonJS((exports, module) => {
 });
 
 // apps/cli/src/index.ts
-import { resolve, join as join12, dirname as dirname4 } from "path";
-import { exists, mkdir as mkdir2 } from "fs/promises";
+import { resolve, join as join15, dirname as dirname4 } from "path";
+import { exists, mkdir as mkdir3 } from "fs/promises";
 
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/render.js
 import { Stream } from "stream";
@@ -56091,7 +56091,7 @@ var import_react20 = __toESM(require_react(), 1);
 // node_modules/.bun/ink@5.2.1+1f88f629f0141b18/node_modules/ink/build/hooks/use-focus-manager.js
 var import_react21 = __toESM(require_react(), 1);
 // apps/cli/src/index.ts
-var import_react58 = __toESM(require_react(), 1);
+var import_react59 = __toESM(require_react(), 1);
 
 // packages/output/src/output.ts
 var formatters = {
@@ -56117,7 +56117,7 @@ function log(msg) {
 }
 
 // apps/cli/src/cli.ts
-var VALID_MODES = new Set(["task", "list", "status", "init"]);
+var VALID_MODES = new Set(["task", "list", "status", "init", "agent"]);
 var VALID_MODELS = new Set(["haiku", "sonnet", "opus"]);
 var HELP_TEXT = [
   "Usage: ralph <command> [options]",
@@ -56127,6 +56127,7 @@ var HELP_TEXT = [
   "  list                    List active changes",
   "  status                  Show detailed change status",
   "  init                    Initialize OpenSpec in current directory",
+  "  agent                   Poll Linear for new tasks and run loops concurrently",
   "",
   "Options:",
   "  --name <name>           Change name (required for most commands)",
@@ -56143,6 +56144,15 @@ var HELP_TEXT = [
   "  --unlimited             No iteration limit (default)",
   "  --log                   Log raw engine stream",
   "  --verbose               Verbose output",
+  "",
+  "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)",
+  "",
   "  --help, -h              Show this help message",
   "",
   "Examples:",
@@ -56171,7 +56181,13 @@ async function parseArgs(argv) {
     maxConsecutiveFailures: 5,
     delay: 0,
     log: false,
-    verbose: false
+    verbose: false,
+    linearTeam: "",
+    linearAssignee: "",
+    linearStatus: [],
+    linearLabel: [],
+    pollInterval: 60,
+    concurrency: 1
   };
   let expectModel = false;
   let expectModelFlag = false;
@@ -56185,6 +56201,12 @@ async function parseArgs(argv) {
   let expectMaxIterations = false;
   let expectTimeout = false;
   let expectPushInterval = false;
+  let expectLinearTeam = false;
+  let expectLinearAssignee = false;
+  let expectLinearStatus = false;
+  let expectLinearLabel = false;
+  let expectPollInterval = false;
+  let expectConcurrency = false;
   for (const arg of argv) {
     if (expectModel) {
       if (VALID_MODELS.has(arg)) {
@@ -56250,6 +56272,36 @@ async function parseArgs(argv) {
       expectPushInterval = false;
       continue;
     }
+    if (expectLinearTeam) {
+      result2.linearTeam = arg;
+      expectLinearTeam = false;
+      continue;
+    }
+    if (expectLinearAssignee) {
+      result2.linearAssignee = arg;
+      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;
+      continue;
+    }
+    if (expectConcurrency) {
+      result2.concurrency = parseInt(arg, 10);
+      expectConcurrency = false;
+      continue;
+    }
     switch (arg) {
       case "--claude":
         if (result2.engineSet && result2.engine !== "claude") {
@@ -56308,6 +56360,24 @@ async function parseArgs(argv) {
       case "--verbose":
         result2.verbose = true;
         break;
+      case "--linear-team":
+        expectLinearTeam = true;
+        break;
+      case "--linear-assignee":
+        expectLinearAssignee = true;
+        break;
+      case "--linear-status":
+        expectLinearStatus = true;
+        break;
+      case "--linear-label":
+        expectLinearLabel = true;
+        break;
+      case "--poll-interval":
+        expectPollInterval = true;
+        break;
+      case "--concurrency":
+        expectConcurrency = true;
+        break;
       default:
         if (VALID_MODES.has(arg)) {
           result2.mode = arg;
@@ -56374,8 +56444,8 @@ function createDefaultContext() {
 }
 
 // apps/cli/src/components/App.tsx
-var import_react57 = __toESM(require_react(), 1);
-import { join as join11 } from "path";
+var import_react58 = __toESM(require_react(), 1);
+import { join as join14 } from "path";
 
 // packages/core/src/state.ts
 import { join as join2 } from "path";
@@ -69501,12 +69571,603 @@ function TaskLoop({ opts }) {
   }, undefined, true, undefined, this);
 }
 
+// apps/cli/src/components/AgentMode.tsx
+var import_react57 = __toESM(require_react(), 1);
+
+// 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) {
+  const where = {};
+  if (filter2.team)
+    where.team = { key: { eq: filter2.team } };
+  if (filter2.assignee) {
+    if (filter2.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 {
+    where.state = { type: { in: [...OPEN_STATE_TYPES] } };
+  }
+  if (filter2.labels && filter2.labels.length > 0) {
+    where.labels = { some: { name: { in: filter2.labels } } };
+  }
+  const query = `query Issues($filter: IssueFilter) {
+    issues(filter: $filter, first: 50) {
+      nodes {
+        id identifier title description url
+        state { name type }
+        assignee { id email name }
+        labels { nodes { name } }
+      }
+    }
+  }`;
+  const data = await linearRequest(apiKey, query, {
+    filter: where
+  });
+  return data.issues.nodes.map((n) => ({
+    id: n.id,
+    identifier: n.identifier,
+    title: n.title,
+    description: n.description,
+    url: n.url,
+    state: n.state,
+    assignee: n.assignee,
+    labels: n.labels.nodes.map((l) => l.name)
+  }));
+}
+async function linearRequest(apiKey, query, variables) {
+  const res = await fetch(LINEAR_API, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: apiKey },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    const err = new Error("Linear API request failed");
+    err.status = res.status;
+    err.body = await res.text();
+    throw err;
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    const err = new Error("Linear API returned errors");
+    err.messages = json.errors.map((e) => e.message);
+    throw err;
+  }
+  if (!json.data) {
+    throw new Error("Linear API returned no data");
+  }
+  return json.data;
+}
+async function addIssueComment(apiKey, issueId, body) {
+  const mutation = `mutation Comment($issueId: String!, $body: String!) {
+    commentCreate(input: { issueId: $issueId, body: $body }) { success }
+  }`;
+  await linearRequest(apiKey, mutation, {
+    issueId,
+    body
+  });
+}
+async function fetchIssueComments(apiKey, issueId) {
+  const query = `query Comments($id: String!) {
+    issue(id: $id) {
+      comments(first: 50) {
+        nodes { id body createdAt user { name email } }
+      }
+    }
+  }`;
+  const data = await linearRequest(apiKey, query, { id: issueId });
+  return data.issue?.comments.nodes ?? [];
+}
+async function fetchWorkflowStates(apiKey, teamKey) {
+  const query = `query States($team: String!) {
+    workflowStates(filter: { team: { key: { eq: $team } } }, first: 50) {
+      nodes { id name type }
+    }
+  }`;
+  const data = await linearRequest(apiKey, query, {
+    team: teamKey
+  });
+  return data.workflowStates.nodes;
+}
+async function updateIssueState(apiKey, issueId, stateId) {
+  const mutation = `mutation Update($id: String!, $stateId: String!) {
+    issueUpdate(id: $id, input: { stateId: $stateId }) { success }
+  }`;
+  await linearRequest(apiKey, mutation, {
+    id: issueId,
+    stateId
+  });
+}
+
+// apps/cli/src/agent/state.ts
+import { join as join10 } from "path";
+var AgentStateSchema = exports_external.object({
+  processedIssueIds: exports_external.array(exports_external.string()).default([]),
+  lastPollAt: exports_external.string().nullable().default(null)
+});
+function statePath(projectRoot) {
+  return join10(projectRoot, ".ralph", "agent-state.json");
+}
+async function readAgentState(projectRoot) {
+  const file = Bun.file(statePath(projectRoot));
+  if (!await file.exists()) {
+    return AgentStateSchema.parse({});
+  }
+  return AgentStateSchema.parse(await file.json());
+}
+async function writeAgentState(projectRoot, state) {
+  await Bun.write(statePath(projectRoot), JSON.stringify(state, null, 2) + `
+`);
+}
+
+// apps/cli/src/agent/scaffold.ts
+import { join as join11 } from "path";
+import { mkdir } from "fs/promises";
+function changeNameForIssue(issue) {
+  const slug = issue.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return slug ? `${issue.identifier.toLowerCase()}-${slug}` : issue.identifier.toLowerCase();
+}
+async function scaffoldChangeForIssue(tasksDir, statesDir, issue, comments = []) {
+  const name = changeNameForIssue(issue);
+  const changeDir = join11(tasksDir, name);
+  const stateDir = join11(statesDir, name);
+  await mkdir(changeDir, { recursive: true });
+  await mkdir(join11(changeDir, "specs"), { recursive: true });
+  await mkdir(stateDir, { recursive: true });
+  const commentsBlock = comments.length > 0 ? [
+    "",
+    "## Linear comments",
+    "",
+    ...comments.flatMap((c) => [
+      `**${c.user?.name ?? "unknown"}** \u2014 ${c.createdAt}`,
+      "",
+      c.body.trim(),
+      ""
+    ])
+  ] : [];
+  const proposal = [
+    `# ${issue.identifier}: ${issue.title}`,
+    "",
+    `Source: [${issue.identifier}](${issue.url})`,
+    `Status: ${issue.state.name}`,
+    issue.assignee ? `Assignee: ${issue.assignee.name}` : "",
+    issue.labels.length ? `Labels: ${issue.labels.join(", ")}` : "",
+    "",
+    "## Description",
+    "",
+    issue.description?.trim() || "_No description provided in Linear._",
+    ...commentsBlock,
+    "",
+    "## Steering",
+    "",
+    "_Add steering notes here as the loop runs._",
+    ""
+  ].filter((l) => l !== "").join(`
+`);
+  const tasks = [
+    `# Tasks for ${issue.identifier}`,
+    "",
+    `- [ ] Read the Linear issue at ${issue.url} and break it into concrete subtasks`,
+    `- [ ] Implement the changes described in proposal.md`,
+    `- [ ] Add or update tests covering the new behavior`,
+    `- [ ] Run \`bun run lint\` and \`bun run test\` and fix any failures`,
+    ""
+  ].join(`
+`);
+  const design = [
+    `# Design for ${issue.identifier}`,
+    "",
+    "_Fill in the technical design as you work through the issue._",
+    ""
+  ].join(`
+`);
+  await Bun.write(join11(changeDir, "proposal.md"), proposal);
+  await Bun.write(join11(changeDir, "tasks.md"), tasks);
+  await Bun.write(join11(changeDir, "design.md"), design);
+  return name;
+}
+
+// apps/cli/src/agent/config.ts
+import { join as join12 } from "path";
+var RalphyConfigSchema = exports_external.object({
+  concurrency: exports_external.number().int().positive().default(1),
+  pollIntervalSeconds: exports_external.number().int().positive().default(60),
+  maxIterationsPerTask: exports_external.number().int().nonnegative().default(0),
+  maxCostUsdPerTask: exports_external.number().nonnegative().default(0),
+  engine: exports_external.enum(["claude", "codex"]).default("claude"),
+  model: exports_external.enum(["haiku", "sonnet", "opus"]).default("opus"),
+  linear: exports_external.object({
+    team: exports_external.string().optional(),
+    assignee: exports_external.string().optional(),
+    statuses: exports_external.array(exports_external.string()).default([]),
+    labels: exports_external.union([exports_external.array(exports_external.string()), exports_external.string()]).transform((v) => typeof v === "string" ? [v] : v).default([]),
+    inProgressStatus: exports_external.string().optional(),
+    doneStatus: exports_external.string().optional(),
+    postComments: exports_external.boolean().default(true)
+  }).default({ statuses: [], labels: [], postComments: true })
+}).default({
+  concurrency: 1,
+  pollIntervalSeconds: 60,
+  maxIterationsPerTask: 0,
+  maxCostUsdPerTask: 0,
+  engine: "claude",
+  model: "opus",
+  linear: { statuses: [], labels: [], postComments: true }
+});
+async function loadRalphyConfig(projectRoot) {
+  const path = join12(projectRoot, "ralphy.config.json");
+  const file = Bun.file(path);
+  if (!await file.exists()) {
+    return RalphyConfigSchema.parse({});
+  }
+  const raw = await file.json();
+  return RalphyConfigSchema.parse(raw);
+}
+async function ensureRalphyConfig(projectRoot) {
+  const path = join12(projectRoot, "ralphy.config.json");
+  const file = Bun.file(path);
+  if (await file.exists())
+    return path;
+  const defaults2 = RalphyConfigSchema.parse({});
+  await Bun.write(path, JSON.stringify(defaults2, null, 2) + `
+`);
+  return path;
+}
+
+// apps/cli/src/agent/coordinator.ts
+class AgentCoordinator {
+  deps;
+  opts;
+  workers = [];
+  pendingIds = new Set;
+  queue = [];
+  state = null;
+  stopped = false;
+  constructor(deps, opts) {
+    this.deps = deps;
+    this.opts = opts;
+  }
+  get activeCount() {
+    return this.workers.length;
+  }
+  get queuedCount() {
+    return this.queue.length;
+  }
+  get activeWorkers() {
+    return this.workers;
+  }
+  async init() {
+    this.state = await this.deps.loadState();
+  }
+  async pollOnce() {
+    if (this.stopped)
+      return { found: 0, added: 0 };
+    let issues;
+    try {
+      issues = await this.deps.fetchIssues(this.opts.filter);
+    } catch (err) {
+      this.deps.onLog(`! Linear poll failed: ${err.message}`, "red");
+      return { found: 0, added: 0 };
+    }
+    const state = this.state;
+    const seen = new Set(state.processedIssueIds);
+    const queued = new Set(this.queue.map((i) => i.id));
+    const active = new Set(this.workers.map((w) => w.issueId));
+    let added = 0;
+    for (const issue of issues) {
+      if (seen.has(issue.id))
+        continue;
+      if (queued.has(issue.id))
+        continue;
+      if (active.has(issue.id))
+        continue;
+      if (this.pendingIds.has(issue.id))
+        continue;
+      this.queue.push(issue);
+      added += 1;
+    }
+    state.lastPollAt = new Date().toISOString();
+    await this.deps.saveState(state);
+    this.spawnNext();
+    return { found: issues.length, added };
+  }
+  spawnNext() {
+    if (this.stopped || !this.state)
+      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);
+    }
+  }
+  async launchWorker(issue) {
+    let changeName;
+    try {
+      changeName = await this.deps.scaffold(issue);
+    } catch (err) {
+      this.pendingIds.delete(issue.id);
+      this.deps.onLog(`! scaffold failed for ${issue.identifier}: ${err.message}`, "red");
+      this.spawnNext();
+      return;
+    }
+    if (this.stopped) {
+      this.pendingIds.delete(issue.id);
+      return;
+    }
+    this.deps.onLog(`\u25B6 ${issue.identifier} \u2192 ${changeName} (worker started)`, "cyan");
+    const handle = this.deps.spawnWorker(changeName, issue);
+    const worker = {
+      changeName,
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      kill: handle.kill
+    };
+    this.workers.push(worker);
+    this.pendingIds.delete(issue.id);
+    this.deps.onWorkersChanged();
+    this.notifyStarted(issue, changeName);
+    handle.exited.then((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");
+      if (ok && this.state && !this.state.processedIssueIds.includes(issue.id)) {
+        this.state.processedIssueIds.push(issue.id);
+        this.deps.saveState(this.state);
+      }
+      this.notifyExited(issue, changeName, code);
+      this.deps.onWorkersChanged();
+      this.spawnNext();
+    });
+  }
+  async notifyStarted(issue, changeName) {
+    const updater = this.deps.updater;
+    if (!updater)
+      return;
+    if (this.opts.postComments !== false) {
+      try {
+        await updater.postComment(issue, `\uD83E\uDD16 Ralph started working on this issue. Tracking change: \`${changeName}\``);
+      } 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;
+    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}\``;
+      try {
+        await updater.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);
+    }
+  }
+  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;
+      }
+      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() {
+    this.stopped = true;
+    for (const w of this.workers) {
+      try {
+        w.kill();
+      } catch {}
+    }
+  }
+}
+
+// apps/cli/src/components/AgentMode.tsx
+var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
+var lineCounter = 0;
+function nextId() {
+  lineCounter += 1;
+  return `${Date.now()}-${lineCounter}`;
+}
+function AgentMode({ args, projectRoot, statesDir, tasksDir }) {
+  const { exit } = use_app_default();
+  const [logs, setLogs] = import_react57.useState([]);
+  const [, setTick] = import_react57.useState(0);
+  const coordRef = import_react57.useRef(null);
+  function appendLog(text, color) {
+    setLogs((prev) => [...prev, { id: nextId(), text, color }]);
+  }
+  import_react57.useEffect(() => {
+    let pollTimer = null;
+    let cancelled = false;
+    async function init2() {
+      const cfgPath = await ensureRalphyConfig(projectRoot);
+      const cfg = await loadRalphyConfig(projectRoot);
+      appendLog(`agent mode \u2014 config: ${cfgPath}`, "gray");
+      const concurrency = args.concurrency || cfg.concurrency;
+      const pollInterval = args.pollInterval || cfg.pollIntervalSeconds;
+      appendLog(`concurrency=${concurrency} pollInterval=${pollInterval}s`, "gray");
+      const apiKey = process.env["LINEAR_API_KEY"];
+      if (!apiKey) {
+        appendLog("! LINEAR_API_KEY not set \u2014 cannot poll Linear", "red");
+        exit();
+        return;
+      }
+      const filter2 = {
+        team: args.linearTeam || cfg.linear.team,
+        assignee: args.linearAssignee || cfg.linear.assignee,
+        statuses: args.linearStatus.length ? args.linearStatus : cfg.linear.statuses,
+        labels: args.linearLabel.length ? args.linearLabel : cfg.linear.labels
+      };
+      const stateCache = new Map;
+      const teamKeyOf = (issue) => issue.identifier.split("-")[0];
+      const coord2 = new AgentCoordinator({
+        fetchIssues: (f2) => fetchOpenIssues(apiKey, f2),
+        scaffold: async (issue) => {
+          let comments = [];
+          try {
+            comments = await fetchIssueComments(apiKey, issue.id);
+          } catch (err) {
+            appendLog(`! Linear comment fetch failed for ${issue.identifier}: ${err.message}`, "yellow");
+          }
+          return scaffoldChangeForIssue(tasksDir, statesDir, issue, comments);
+        },
+        spawnWorker: (changeName) => {
+          const cmd = [
+            process.execPath,
+            process.argv[1] ?? "",
+            "task",
+            "--name",
+            changeName,
+            "--" + (args.engineSet ? args.engine : cfg.engine),
+            args.engineSet ? args.model : cfg.model
+          ];
+          const maxIter = args.maxIterations || cfg.maxIterationsPerTask;
+          if (maxIter > 0)
+            cmd.push("--max-iterations", String(maxIter));
+          const maxCost = args.maxCostUsd || cfg.maxCostUsdPerTask;
+          if (maxCost > 0)
+            cmd.push("--max-cost", String(maxCost));
+          const proc = Bun.spawn({
+            cmd,
+            cwd: projectRoot,
+            stdout: "ignore",
+            stderr: "ignore",
+            stdin: "ignore"
+          });
+          return { exited: proc.exited, kill: () => proc.kill() };
+        },
+        loadState: () => readAgentState(projectRoot),
+        saveState: (s) => writeAgentState(projectRoot, s),
+        onLog: appendLog,
+        onWorkersChanged: () => setTick((t) => t + 1),
+        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;
+          }
+        }
+      }, {
+        concurrency,
+        filter: filter2,
+        inProgressStatus: cfg.linear.inProgressStatus,
+        doneStatus: cfg.linear.doneStatus,
+        postComments: cfg.linear.postComments
+      });
+      coordRef.current = coord2;
+      await coord2.init();
+      const tick = async () => {
+        if (cancelled)
+          return;
+        const filterDesc = `team=${filter2.team ?? "*"}, assignee=${filter2.assignee ?? "*"}, statuses=${filter2.statuses?.length ? filter2.statuses.join(",") : "open"}${filter2.labels?.length ? `, labels=${filter2.labels.join(",")}` : ""}`;
+        appendLog(`\u2026 polling Linear (${filterDesc})`);
+        const { found, added } = await coord2.pollOnce();
+        appendLog(`  found ${found} open, ${added} new (queue=${coord2.queuedCount})`);
+        if (cancelled)
+          return;
+        pollTimer = setTimeout(tick, pollInterval * 1000);
+      };
+      tick();
+    }
+    init2();
+    const onSig = () => {
+      cancelled = true;
+      appendLog("stopping agent \u2014 sending SIGTERM to workers", "yellow");
+      coordRef.current?.stop();
+      if (pollTimer)
+        clearTimeout(pollTimer);
+      exit();
+    };
+    process.on("SIGINT", onSig);
+    process.on("SIGTERM", onSig);
+    return () => {
+      cancelled = true;
+      if (pollTimer)
+        clearTimeout(pollTimer);
+      coordRef.current?.stop();
+      process.off("SIGINT", onSig);
+      process.off("SIGTERM", onSig);
+    };
+  }, []);
+  const coord = coordRef.current;
+  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Static, {
+        items: logs,
+        children: (line) => line.color ? /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+          color: line.color,
+          children: line.text
+        }, line.id, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+          children: line.text
+        }, line.id, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Box_default, {
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              "workers active: ",
+              coord?.activeCount ?? 0,
+              " \xB7 queued: ",
+              coord?.queuedCount ?? 0
+            ]
+          }, undefined, true, undefined, this),
+          coord?.activeWorkers.map((w) => /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+            color: "cyan",
+            children: [
+              "  ",
+              "\u25CF ",
+              w.issueIdentifier,
+              " (",
+              w.changeName,
+              ")"
+            ]
+          }, w.changeName, true, undefined, this))
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
 // packages/openspec/src/openspec-change-store.ts
-import { join as join10, dirname as dirname3 } from "path";
-import { readdir, mkdir } from "fs/promises";
+import { join as join13, dirname as dirname3 } from "path";
+import { readdir, mkdir as mkdir2 } from "fs/promises";
 function resolveOpenspecBin() {
   const pkgJsonPath = Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir);
-  return join10(dirname3(pkgJsonPath), "bin", "openspec.js");
+  return join13(dirname3(pkgJsonPath), "bin", "openspec.js");
 }
 function runOpenspec(args, options = {}) {
   const stdio = options.inherit ? ["inherit", "inherit", "inherit"] : ["ignore", "pipe", "pipe"];
@@ -69532,7 +70193,7 @@ class OpenSpecChangeStore {
     }
   }
   getChangeDirectory(name) {
-    return join10("openspec", "changes", name);
+    return join13("openspec", "changes", name);
   }
   async listChanges() {
     const result2 = runOpenspec(["list", "--json"]);
@@ -69546,7 +70207,7 @@ class OpenSpecChangeStore {
         }
       } catch {}
     }
-    const changesDir = join10("openspec", "changes");
+    const changesDir = join13("openspec", "changes");
     if (!await Bun.file(changesDir).exists())
       return [];
     try {
@@ -69557,29 +70218,29 @@ class OpenSpecChangeStore {
     }
   }
   async readTaskList(name) {
-    const file = Bun.file(join10("openspec", "changes", name, "tasks.md"));
+    const file = Bun.file(join13("openspec", "changes", name, "tasks.md"));
     if (!await file.exists())
       return "";
     return await file.text();
   }
   async writeTaskList(name, content) {
-    const path = join10("openspec", "changes", name, "tasks.md");
-    await mkdir(dirname3(path), { recursive: true });
+    const path = join13("openspec", "changes", name, "tasks.md");
+    await mkdir2(dirname3(path), { recursive: true });
     await Bun.write(path, content);
   }
   async appendSteering(name, message) {
-    const path = join10("openspec", "changes", name, "steering.md");
+    const path = join13("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 mkdir(dirname3(path), { recursive: true });
+    await mkdir2(dirname3(path), { recursive: true });
     await Bun.write(path, updated);
   }
   async readSection(name, artifact, heading) {
-    const file = Bun.file(join10("openspec", "changes", name, artifact));
+    const file = Bun.file(join13("openspec", "changes", name, artifact));
     if (!await file.exists())
       return "";
     const content = await file.text();
@@ -69620,67 +70281,74 @@ ${existing.trimStart()}` : `${message}
   }
 }
 // apps/cli/src/components/App.tsx
-var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
+var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
 function ExitAfterRender({ children }) {
   const { exit } = use_app_default();
-  import_react57.useEffect(() => {
+  import_react58.useEffect(() => {
     exit();
   }, [exit]);
-  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(jsx_dev_runtime9.Fragment, {
+  return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(jsx_dev_runtime10.Fragment, {
     children
   }, undefined, false, undefined, this);
 }
 function ErrorMessage({ message }) {
   const { exit } = use_app_default();
-  import_react57.useEffect(() => {
+  import_react58.useEffect(() => {
     process.exitCode = 1;
     exit();
   }, [exit]);
-  return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+  return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
     color: "red",
     children: message
   }, undefined, false, undefined, this);
 }
-function App2({ args, statesDir, tasksDir }) {
+function App2({ args, statesDir, tasksDir, projectRoot }) {
   switch (args.mode) {
     case "list":
-      return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(TaskList, {
+      return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(TaskList, {
         statesDir
       }, undefined, false, undefined, this);
+    case "agent":
+      return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(AgentMode, {
+        args,
+        projectRoot,
+        statesDir,
+        tasksDir
+      }, undefined, false, undefined, this);
     case "status": {
       if (!args.name) {
-        return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ErrorMessage, {
+        return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ErrorMessage, {
           message: "Error: --name is required for status mode"
         }, undefined, false, undefined, this);
       }
-      const stateDir = join11(statesDir, args.name);
-      if (getStorage().read(join11(stateDir, ".ralph-state.json")) === null) {
-        return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ErrorMessage, {
+      const stateDir = join14(statesDir, args.name);
+      if (getStorage().read(join14(stateDir, ".ralph-state.json")) === null) {
+        return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ErrorMessage, {
           message: `Error: change '${args.name}' not found`
         }, undefined, false, undefined, this);
       }
       const state = readState(stateDir);
-      return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ExitAfterRender, {
-        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(TaskStatus, {
+      return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ExitAfterRender, {
+        children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(TaskStatus, {
           state,
           stateDir
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this);
     }
     case "init":
-      return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ExitAfterRender, {
-        children: /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(Text, {
+      return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ExitAfterRender, {
+        children: /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(Text, {
           color: "green",
           children: "Initialized openspec directory"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this);
     case "task": {
       if (!args.name) {
-        return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(ErrorMessage, {
+        return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(ErrorMessage, {
           message: "Error: --name is required for task mode"
         }, undefined, false, undefined, this);
       }
-      return /* @__PURE__ */ jsx_dev_runtime9.jsxDEV(TaskLoop, {
+      return /* @__PURE__ */ jsx_dev_runtime10.jsxDEV(TaskLoop, {
         opts: {
           name: args.name,
           prompt: args.prompt,
@@ -69711,7 +70379,7 @@ if (typeof globalThis.Bun === "undefined") {
 async function findProjectRoot() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (await exists(join12(dir, "openspec")))
+    if (await exists(join15(dir, "openspec")))
       return dir;
     dir = resolve(dir, "..");
   }
@@ -69746,11 +70414,11 @@ try {
 capture("command_run", { mode: args.mode, engine: args.engine, model: args.model });
 try {
   const projectRoot = await findProjectRoot();
-  const statesDir = join12(projectRoot, ".ralph", "tasks");
-  const tasksDir = join12(projectRoot, "openspec", "changes");
+  const statesDir = join15(projectRoot, ".ralph", "tasks");
+  const tasksDir = join15(projectRoot, "openspec", "changes");
   if (args.mode === "init") {
-    await mkdir2(statesDir, { recursive: true });
-    const openspecBin = join12(dirname4(Bun.resolveSync("@fission-ai/openspec/package.json", import.meta.dir)), "bin", "openspec.js");
+    await mkdir3(statesDir, { recursive: true });
+    const openspecBin = join15(dirname4(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"],
@@ -69758,11 +70426,16 @@ try {
     });
   }
   if (args.mode === "task" && args.name) {
-    await mkdir2(join12(statesDir, args.name), { recursive: true });
-    await mkdir2(join12(tasksDir, args.name), { recursive: true });
+    await mkdir3(join15(statesDir, args.name), { recursive: true });
+    await mkdir3(join15(tasksDir, args.name), { recursive: true });
+  }
+  if (args.mode === "agent") {
+    await mkdir3(statesDir, { recursive: true });
+    await mkdir3(tasksDir, { recursive: true });
+    await mkdir3(join15(projectRoot, ".ralph"), { recursive: true });
   }
   await runWithContext(createDefaultContext(), async () => {
-    const { waitUntilExit } = render_default(import_react58.createElement(App2, { args, statesDir, tasksDir }));
+    const { waitUntilExit } = render_default(import_react59.createElement(App2, { args, statesDir, tasksDir, projectRoot }));
     await waitUntilExit();
   });
   await shutdown();

package/package.json

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