@eventmodelers/cli 1.0.162 → 2.0.1

package/lib/adapters/spec-kitty-adapter.js

@@ -14,11 +14,8 @@
 // adapter's whole job is producing a good brief and calling `intake`, nothing
 // more.
 //
-// Lives here (not only inside a bridge-kit install) so it has exactly one
-// entry point regardless of caller: `eventmodelers fetch --spec-kitty` calls
-// it directly for a one-shot sync; `eventmodelers bridge` (via
-// ralph-static.js) calls the same run() from a copy the bridge-kit installer
-// places at .bridge-kit/adapters/ — see installStack in cli.js.
+// Its one entry point is `eventmodelers fetch --spec-kitty`, a one-shot sync. (A standing bridge loop that
+// ran the same run() from a copy in .bridge-kit/ is retired.)
 //
 // Exports run({ cfg, projectDir, contextName }).
 
@@ -43,8 +40,7 @@ function slugify(text) {
 
 // Mirrors lib/fetch.js's per-context call rather than importing runFetch
 // directly — this fetches raw JSON only, it never touches .slices/ (fetch.js
-// owns writing that), and a copy of this file also has to run standalone
-// inside an installed .bridge-kit/ with no access to lib/fetch.js at all.
+// owns writing that).
 async function fetchFullSliceData(cfg, contextName) {
   const baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
   const url = `${baseUrl}/api/org/${cfg.organizationId}/boards/${cfg.boardId}/slicedata?contextName=${encodeURIComponent(contextName)}`;

package/lib/global-agent-id.js

@@ -0,0 +1,45 @@
+// A run on the global install keeps one agent id per board and repo — "repo" being the directory the run is
+// started in (its git root, or the directory itself outside git). It is the same agent on every start: its chat
+// sessions, its star on the board and the prompts it holds all stay addressed to it. The ids live in one small
+// file next to the per-board credentials; nothing is written into the repo.
+
+import { execFileSync } from 'child_process';
+import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { dirname } from 'path';
+
+function real(path) {
+  try { return realpathSync(path); } catch { return path; }
+}
+
+// The git root of `dir`, else `dir` — both with symlinks resolved, so two paths to one repo are one repo.
+export function repoKey(dir) {
+  const start = real(dir);
+  try {
+    const top = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: start, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    return top ? real(top) : start;
+  } catch {
+    return start;
+  }
+}
+
+function readIds(file) {
+  try {
+    const ids = JSON.parse(readFileSync(file, 'utf-8'));
+    return ids && typeof ids === 'object' && !Array.isArray(ids) ? ids : {};
+  } catch {
+    return {};
+  }
+}
+
+export function stableGlobalAgentId({ file, boardId, dir, mint = randomUUID }) {
+  const key = `${boardId}|${repoKey(dir)}`;
+  const ids = readIds(file);
+  if (typeof ids[key] === 'string' && ids[key]) return ids[key];
+  const id = mint();
+  mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ ...ids, [key]: id }, null, 2), 'utf-8');
+  renameSync(tmp, file);
+  return id;
+}

package/lib/modeling-local-ai.js

@@ -2,7 +2,7 @@
 //
 // The build kit's own local runner (shared/build-kit/lib/local-ai-agent.js) is a
 // template copied into user projects, so it owns its whole lifecycle: it reads
-// config.json off disk, pulls one task out of tasks.json and exits. This one is the
+// config.json off disk, pulls one task off the queue and exits. This one is the
 // same idea mounted the other way round — the modeling loop already owns the prompt
 // queue, the standalone board-change lane and the idle review, and only ever needed
 // something to hand a turn's text to. So this exports a runner with one method,
@@ -175,7 +175,7 @@ function systemPrompt({ boardId, organizationId, standalone }) {
   ].join('\n');
 }
 
-export function createModelingLocalAiRunner({ cfg, target, log, verbose = false, standalone = false }) {
+export function createModelingLocalAiRunner({ cfg, target, log, verbose = false, standalone = false, onToolUse = () => () => {} }) {
   const t = resolveLocalAiTarget({ target, localAi: cfg.localAi || {} });
   let tools = null; // the MCP tool set, fetched once per session
 
@@ -269,6 +269,7 @@ export function createModelingLocalAiRunner({ cfg, target, log, verbose = false,
           : rawArgs;
 
         log(verbose ? `→ ${name}(${JSON.stringify(args).slice(0, 120)})` : `→ ${name}`);
+        const finish = onToolUse(name, args);
 
         let toolResult;
         try {
@@ -276,6 +277,7 @@ export function createModelingLocalAiRunner({ cfg, target, log, verbose = false,
         } catch (err) {
           toolResult = { isError: true, content: [{ type: 'text', text: err.message }] };
         }
+        finish({ isError: !!toolResult.isError });
         if (verbose) log(`  ${JSON.stringify(toolResult).slice(0, 160)}`);
 
         messages.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventmodelers/cli",
-  "version": "1.0.162",
+  "version": "2.0.1",
   "description": "Eventmodelers CLI — real-time Claude agent + skills for Claude Code, for any stack (Node, Supabase, Axon, OpenCQRS, UmaDB, Kurrent, or modeling-only)",
   "type": "module",
   "bin": {

package/shared/build-kit/README.md

@@ -27,8 +27,6 @@ node .build-kit/ralph-claude.js /path/to/project
 | `ralph-claude.js` | Runs the full loop using Claude Code as the executor |
 | `ralph-local-ai.js` | Runs the full loop using a local/self-hosted model (Ollama, vLLM, LM Studio, llama.cpp) |
 | `ralph-exec.js` | Runs the full loop handing each prompt to an external agent command (Codex CLI, OpenCode, …) |
-| `ralph.sh` | Shell-based loop — alternative to the JS entry points |
-| `realtime-agent.js` | Standalone realtime agent — only needed to run it in a separate terminal |
 
 **Internals** (`lib/`):
 
@@ -36,16 +34,15 @@ node .build-kit/ralph-claude.js /path/to/project
 |------|---------|
 | `lib/ralph.js` | Shared library — realtime agent + loop logic; imported by the entry points |
 | `lib/local-ai-agent.js` | Local-AI executor — called by `ralph-local-ai.js`, can also run manually |
-| `lib/agent.sh` | Thin shell wrapper around `claude` — called by `ralph.sh` |
 | `lib/prompt.md` | Phase 1 prompt: tells Claude how to load a slice from the board |
 | `lib/backend-prompt.md` | Phase 2 prompt: tells Claude how to build a planned slice |
 | `lib/AGENT.md` | Agent instructions included in Claude's context |
 
 ## How it works
 
-**Phase 1** — triggered when `tasks.json` has entries:
-- The realtime agent writes a task to `tasks.json` each time a `slice:changed` event arrives from the board
-- The loop picks it up and runs Claude (or a local model) with `prompt.md`
+**Phase 1** — triggered when the task queue has entries (the queue is the event log in `.build-kit/events/`):
+- The realtime agent queues a task (`task-queued`) each time a `slice:changed` event arrives from the board; a newer change to the same slice replaces its queued task
+- The loop hands the oldest one to Claude (or a local model) with `prompt.md` and completes it (`task-done`) when the turn ends
 - Claude loads the slice data and updates `.slices/`
 
 **Phase 2** — triggered when any file in `.slices/` contains `"status": "Planned"`:
@@ -55,18 +52,6 @@ node .build-kit/ralph-claude.js /path/to/project
 
 Both phases run in a continuous loop with a 3-second idle sleep. The realtime agent runs concurrently in the same process.
 
-## Running the realtime agent separately
-
-If you want the board subscription in one terminal and the Claude loop in another:
-
-```bash
-# Terminal 1 — realtime agent only
-node .build-kit/realtime-agent.js
-
-# Terminal 2 — loop only (poll tasks.json without the realtime subscription)
-.build-kit/ralph.sh
-```
-
 ## Local-AI configuration
 
 `ralph-local-ai.js` drives any local or self-hosted model that can do tool calling.
@@ -78,7 +63,7 @@ Claude (`ralph-claude.js`) stays the default runner — this is opt-in.
 Planned. That is by design, not a bug:
 
 - **Planned slices are never handed to it.** `ralph-local-ai.js` gives `startRalph` no
-  `onPlannedSlice`, so the loop only feeds it `tasks.json` prompts.
+  `onPlannedSlice`, so the loop only feeds it queued tasks.
 - **It has no coding tools.** `lib/local-ai-agent.js` exposes only the board MCP tools:
   no file read/write, no shell, no git, no test run.
 - **Its system prompt forbids file and shell access.** Such a request is answered with

package/shared/build-kit/lib/agent-lock.js

@@ -0,0 +1,75 @@
+// One agent id, one live process. An agent keeps its stable id (see ensureAgentId); a second process that would
+// share it — two `run`s in one project, two standalone runs from one repo — gets a fresh id instead. Sharing one
+// would make them fight over a single heartbeat row and a single chat, and the second one's start-up recovery
+// would hand back the first one's prompts.
+//
+// The id is claimed with an exclusive lock file (`<id>.lock`, holding the pid) that the process removes on exit. It
+// is written complete under a private name and then hard-linked into place, so a competitor never finds it empty
+// and mistakes a lock being taken for one left over.
+// A lock left by a process that is gone — a crash, kill -9 — is taken over. A lock problem never stops an agent:
+// if locking is impossible the stable id is simply kept.
+
+import { linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { join } from 'path';
+import { isProcessAlive } from './slice-run.js';
+
+const answers = new Map(); // lock file path → the answer given in this process, so asking twice is one decision
+const owned = new Set(); // lock files this process holds
+let exitHooked = false;
+
+function release() {
+  for (const path of owned) {
+    try {
+      if (JSON.parse(readFileSync(path, 'utf-8')).pid === process.pid) rmSync(path, { force: true });
+    } catch { /* already gone */ }
+  }
+  owned.clear();
+}
+
+// true: the lock is ours; false: a live process of another pid holds it.
+function lock(path, pid, isAlive) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const mine = `${path}.${pid}.${randomUUID()}.tmp`;
+      writeFileSync(mine, JSON.stringify({ pid, startedAt: new Date().toISOString() }));
+      try {
+        linkSync(mine, path); // EEXIST when someone holds it — atomically, and never half written
+      } finally {
+        rmSync(mine, { force: true });
+      }
+      owned.add(path);
+      if (!exitHooked) { exitHooked = true; process.on('exit', release); }
+      return true;
+    } catch (err) {
+      if (err.code !== 'EEXIST') return true; // cannot lock here (permissions, odd filesystem): do not get in the way
+      let holder = null;
+      try { holder = JSON.parse(readFileSync(path, 'utf-8')).pid; } catch { /* unreadable: left over */ }
+      if (holder === pid) return true;
+      if (holder !== null && isAlive(holder)) return false;
+      rmSync(path, { force: true }); // left over by a process that is gone — take it over
+    }
+  }
+  return true;
+}
+
+// `stableId` is the id this agent keeps. Returns { agentId, fellBack }: the stable id when this process got the
+// lock, else a fresh one. Decided once per process and lock directory.
+export function acquireAgentId({ lockDir, stableId, mint = randomUUID, isAlive = isProcessAlive, pid = process.pid }) {
+  const path = join(lockDir, `${stableId}.lock`);
+  if (answers.has(path)) return answers.get(path);
+  let taken = true;
+  try {
+    mkdirSync(lockDir, { recursive: true });
+    taken = lock(path, pid, isAlive);
+  } catch { /* cannot lock here: keep the stable id */ }
+  const answer = taken ? { agentId: stableId, fellBack: false } : { agentId: mint(), fellBack: true };
+  answers.set(path, answer);
+  return answer;
+}
+
+// Releases this process's locks and forgets what it decided — for tests, and a clean shutdown.
+export function forgetAgentLocks() {
+  release();
+  answers.clear();
+}

package/shared/build-kit/lib/agent-name.js

@@ -0,0 +1,27 @@
+// The name an agent shows on the board when nobody gave it one: the repository it runs in and what it is
+// ("cart-service (build)"). Derived on every start, so it is stable for as long as the repo is, and never
+// written into the project's config — `agentName` there (init --name) and `run --name` still win.
+
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+
+// `git@github.com:acme/cart-service.git`, `https://host/acme/cart-service/`, `ssh://git@host:2222/a/b.git` →
+// the last path segment without `.git`.
+function repoNameFromRemote(url) {
+  const last = url.trim().replace(/\/+$/, '').split(/[/:]/).pop() ?? '';
+  return last.replace(/\.git$/, '');
+}
+
+export function defaultAgentName(projectDir, agentType = 'BUILD') {
+  let repo = '';
+  try {
+    repo = repoNameFromRemote(execFileSync('git', ['config', '--get', 'remote.origin.url'], { cwd: projectDir, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }));
+  } catch { /* no remote, or not a git repo */ }
+  return `${repo || basename(projectDir)} (${agentType.toLowerCase()})`;
+}
+
+// A second agent in the same repo gets a fresh id (see agent-lock.js); its default name says which instance it is,
+// so the board does not show two rows of the same name.
+export function withInstanceSuffix(name, agentId) {
+  return `${name} · ${String(agentId).slice(0, 4)}`;
+}

package/shared/build-kit/lib/event-prune.js

@@ -0,0 +1,58 @@
+// Pruning the event log. The log only grows, and most of it is the prompt journal — a received/finished pair per
+// board prompt, plus every tool call of a `--verbose` run — which nothing reads once the prompt is finished. What
+// the state is derived from (claims, settles, learnings, the task queue, prompts still open) is never touched.
+// Before anything is deleted the state is folded from what would be left and compared with the state folded from
+// the whole log; a difference aborts the prune.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { isDeepStrictEqual } from 'util';
+import { join } from 'path';
+import { EVENTS_DIR, INDEX_FILE, readEvents } from './slice-events.js';
+import { fold } from './slice-state.js';
+
+export const PRUNE_EVERY = 1000;
+const ASKED_FILE = '.prune-asked'; // inside events/, which readEvents never lists and the kit's git rules already cover
+
+const JOURNAL_TYPES = new Set(['prompt-received', 'prompt-finished', 'prompt-action', 'tool-call']);
+
+// The events of prompts that have finished (and of nothing else).
+export function prunableEvents(events) {
+  const finished = new Set(events.filter((e) => e?.type === 'prompt-finished').map((e) => e.prompt));
+  return events.filter((e) => e && JOURNAL_TYPES.has(e.type) && finished.has(e.type === 'prompt-received' ? e.prompt?.id : e.prompt));
+}
+
+// Deletes them: their files, then their lines from the index (rewritten whole and renamed into place). Returns
+// { removed, kept }; removes nothing when there is nothing to remove, and throws without touching the log when
+// the state folded from the rest would differ.
+export function pruneLog(kitDir) {
+  const events = readEvents(kitDir);
+  const doomed = new Set(prunableEvents(events).map((e) => e.id));
+  if (!doomed.size) return { removed: 0, kept: events.length };
+  const rest = events.filter((e) => !doomed.has(e.id));
+  if (!isDeepStrictEqual(fold(rest), fold(events))) throw new Error('pruning would change the state the log folds to — nothing was deleted');
+
+  for (const id of doomed) rmSync(join(kitDir, EVENTS_DIR, `${id}.json`), { force: true });
+  const index = join(kitDir, INDEX_FILE);
+  const lines = readFileSync(index, 'utf-8').split('\n').filter((l) => l.trim() && !doomed.has(l.trim()));
+  const tmp = `${index}.tmp`;
+  writeFileSync(tmp, lines.length ? `${lines.join('\n')}\n` : '', 'utf-8');
+  renameSync(tmp, index);
+  return { removed: doomed.size, kept: rest.length };
+}
+
+// Asked when the log has reached a multiple of PRUNE_EVERY it has not been asked at yet — 1000, then 2000, … — so a
+// "no" is not repeated on every start. `remember` records the size the answer was given at.
+const askedPath = (kitDir) => join(kitDir, EVENTS_DIR, ASKED_FILE);
+const bucket = (n) => Math.floor(n / PRUNE_EVERY);
+
+export function shouldOfferPrune(kitDir, count) {
+  if (bucket(count) < 1) return false;
+  let asked = 0;
+  try { asked = Number(readFileSync(askedPath(kitDir), 'utf-8')) || 0; } catch { /* never asked */ }
+  return bucket(count) > bucket(asked);
+}
+
+export function rememberPruneAnswer(kitDir, count) {
+  if (!existsSync(join(kitDir, EVENTS_DIR))) mkdirSync(join(kitDir, EVENTS_DIR), { recursive: true });
+  writeFileSync(askedPath(kitDir), String(count), 'utf-8');
+}

package/shared/build-kit/lib/events-view.js

@@ -0,0 +1,121 @@
+// The slice-state event log, decoded for a terminal (`eventmodelers events`): one plain-text line per event, the
+// filters that go with it, and a summary of the state the log folds to. Colour is the command's business.
+
+const short = (id) => (id ? String(id).slice(0, 8) : '');
+const oneLine = (text, max) => {
+  const flat = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+};
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+
+// slice id → title, from what the log itself knows (a claim records the slice's title).
+export function sliceTitles(events) {
+  const titles = {};
+  for (const e of events) if (e.type === 'claimed' && e.slice && e.title) titles[e.slice] = e.title;
+  return titles;
+}
+
+// How long a call took, and that it failed — nothing for an event without a duration.
+const took = (e) => (typeof e.durationMs === 'number' ? ` (${e.durationMs < 1000 ? `${e.durationMs}ms` : `${(e.durationMs / 1000).toFixed(1)}s`}${e.error ? ', failed' : ''})` : '');
+
+// [subject, detail] — what the event is about, and what it says.
+function describe(e) {
+  const tags = e.tags?.length ? ` ${e.tags.map((t) => `#${t}`).join(' ')}` : '';
+  switch (e.type) {
+    case 'board-observed': case 'agent-recorded': case 'settled':
+      return [e.slice, e.status ?? ''];
+    case 'claimed': {
+      const tree = e.cleanTree === true ? 'clean tree' : e.cleanTree === false ? 'dirty tree' : 'not a git tree';
+      return [e.slice, `pid ${e.pid}, ${tree}${e.base ? `, ${e.base.branch}@${String(e.base.head).slice(0, 8)}` : ''}${e.ticketNumber ? `, ticket ${e.ticketNumber}` : ''}${e.assignee ? `, assignee ${e.assignee}` : ''}`];
+    }
+    case 'claim-confirmed':
+      return [e.slice, ''];
+    case 'released':
+      return [e.slice, e.reason ?? ''];
+    case 'attempt-failed': {
+      const files = String(e.changed ?? '').split('\n').filter((l) => l.trim()).length;
+      const parts = [e.reason, e.status ? `back to ${e.status}` : '', files ? plural(files, 'file') : '', e.branch ?? ''].filter(Boolean);
+      return [e.slice, `${parts.join(', ')}${e.lastReply ? `: ${oneLine(e.lastReply, 80)}` : ''}`];
+    }
+    case 'blocked':
+      return [e.slice, oneLine(e.reason, 120)];
+    case 'task-queued':
+      return [e.payload?.sliceId, e.payload?.sliceStatus ?? ''];
+    case 'task-done':
+      return [e.task, ''];
+    case 'learning-recorded':
+      return ['', `[${e.topic ?? 'General'}] ${oneLine(e.text, 160)} (${e.scope ?? 'repo'}${tags})`];
+    case 'learning-retracted':
+      return [e.learning, e.reason ? oneLine(e.reason, 120) : ''];
+    case 'learning-merged':
+      return ['', `${plural(e.sources?.length ?? e.learnings?.length ?? 0, 'learning')} → ${oneLine(e.text, 120)}${e.reason ? ` — ${oneLine(e.reason, 80)}` : ''}`];
+    case 'learnings-curated':
+      return ['', ''];
+    case 'prompt-received':
+      return [e.prompt?.id, `"${oneLine(e.prompt?.text, 80)}"${e.prompt?.priority ? ', priority' : ''}, pid ${e.pid}`];
+    case 'prompt-action':
+      return [e.prompt, `${e.action ?? ''}${e.detail ? ` ${oneLine(e.detail, 140)}` : ''}${took(e)}`];
+    case 'tool-call':
+      return [e.prompt, `${oneLine(e.detail ?? e.tool, 140)}${took(e)}`];
+    case 'prompt-finished':
+      return [e.prompt, `${e.outcome ?? ''}${e.reason ? ` — ${oneLine(e.reason, 80)}` : ''}`];
+    default: {
+      const { type, id, at, meta, slice, ...rest } = e;
+      return [slice, oneLine(JSON.stringify(rest), 160)];
+    }
+  }
+}
+
+// One line: date and time (UTC, as logged), type, subject (a slice with its title when known), detail, and the first four characters of the
+// agent that wrote it with its type (build or modeling) — a log shared by several agents says who did what.
+export function formatEvent(e, { titles = {} } = {}) {
+  const time = typeof e.at === 'string' && e.at.length >= 19 ? `${e.at.slice(0, 10)} ${e.at.slice(11, 19)}` : '-'.repeat(19);
+  const [rawSubject, detail] = describe(e);
+  const title = titles[rawSubject];
+  const subject = rawSubject ? `${short(rawSubject)}${title ? ` "${title}"` : ''}` : '';
+  const agent = [e.meta?.agent_id ? String(e.meta.agent_id).slice(0, 4) : '', String(e.meta?.agent_type ?? '').toLowerCase()].filter(Boolean).join(' ');
+  return [time, String(e.type).padEnd(18), subject, detail, agent].filter((p, i) => i < 2 || p).join('  ');
+}
+
+// What an event carries beyond its line, indented under it: every field but the ones the line already shows
+// (type, id, time, who). Empty when there is nothing more to say.
+export function formatPayload(e) {
+  const { type, id, at, meta, ...rest } = e;
+  if (!Object.keys(rest).length) return '';
+  return JSON.stringify(rest, null, 2).split('\n').map((l) => `    ${l}`).join('\n');
+}
+
+// types / slice (an id prefix or part of a title) / tag / board (an id prefix — a global kit's log mixes boards) narrow
+// the log; last keeps the final N that remain.
+export function filterEvents(events, { types, slice, tag, board, last } = {}, titles = {}) {
+  let out = events;
+  if (board) out = out.filter((e) => String(e.meta?.board_id ?? '').toLowerCase().startsWith(board.toLowerCase()));
+  if (types?.length) out = out.filter((e) => types.includes(e.type));
+  if (slice) {
+    const wanted = slice.toLowerCase();
+    out = out.filter((e) => {
+      const id = e.slice ?? e.payload?.sliceId;
+      return !!id && (String(id).toLowerCase().startsWith(wanted) || String(titles[id] ?? '').toLowerCase().includes(wanted));
+    });
+  }
+  if (tag) out = out.filter((e) => e.tags?.includes(tag));
+  return last ? out.slice(-last) : out;
+}
+
+// What the log folds to: slices (status, holder, attempts), the queue, prompts in hand, learnings.
+export function summarize(state, titles = {}) {
+  const lines = [];
+  const slices = Object.entries(state.slices);
+  if (!slices.length) lines.push('no slices in the log');
+  for (const [id, s] of slices) {
+    const claim = s.claim ? `  claimed by pid ${s.claim.pid}${s.claim.confirmed ? '' : ' (unconfirmed)'}` : '';
+    const name = titles[id] ?? s.claim?.title;
+    const title = name ? ` "${name}"` : '';
+    const attempts = s.attempts ? `  ${plural(s.attempts, 'failed attempt')}` : '';
+    const blocked = s.blocked ? `  blocked: ${oneLine(s.blocked.reason, 80)}` : '';
+    lines.push(`${short(id)}${title}  ${s.status ?? 'unknown'}${claim}${attempts}${blocked}`);
+  }
+  lines.push('');
+  lines.push(`${plural(state.tasks.length, 'task')} waiting · ${plural(state.prompts.length, 'prompt')} open · ${plural(state.learnings.length, 'learning')}`);
+  return lines.join('\n');
+}

package/shared/build-kit/lib/local-ai-agent.js

@@ -6,16 +6,17 @@
 //   ollama  — Ollama's native POST /api/chat
 //   openai  — the OpenAI-compatible POST /v1/chat/completions that vLLM, LM Studio,
 //             llama.cpp-server, TGI, SGLang (and hosted gateways) all speak
-// Everything above the transport — the MCP tool loop, the tasks.json queue, the
+// Everything above the transport — the MCP tool loop, the
 // security prompt — is identical for both, which is why this is one file and not
 // one kit per vendor.
 //
 // Usage: node local-ai-agent.js [model]
 //        LOCAL_AI_TARGET=vllm node local-ai-agent.js
 //        LOCAL_AI_URL=http://gpu-box:8000/v1 LOCAL_AI_MODEL=Qwen/Qwen3-8B node local-ai-agent.js
-// Reads tasks.json, picks the next task, and passes its prompts to the model.
+// The run loop (lib/ralph.js) picks the oldest queued task and hands it over as the prompt on stdin — one task
+// per run, completed by the loop when this process exits cleanly. There is no queue file to read.
 
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -254,28 +255,15 @@ async function runAgent(userPrompt, boardId) {
   return 'Max tool iterations reached.';
 }
 
-async function runNextTask() {
-  const tasksPath = resolve(__dirname, '..', 'tasks.json');
-  let tasks = [];
-  try { tasks = JSON.parse(readFileSync(tasksPath, 'utf8')); } catch {}
-
-  const blocked = tasks.filter(t => t.blocked === true || t.blockedBy?.length > 0);
-  if (blocked.length > 0) {
-    console.error(`[local-ai] removing ${blocked.length} blocked task(s): ${blocked.map(t => t.id).join(', ')}`);
-    tasks = tasks.filter(t => !blocked.includes(t));
-    writeFileSync(tasksPath, JSON.stringify(tasks, null, 2));
-  }
-
-  const task = tasks[0];
-  if (!task) return;
-
-  console.error(`[local-ai] task=${task.id} prompts=${task.prompts.length}`);
-
-  for (const p of task.prompts) {
-    console.log(await runAgent(p.prompt, p.board_id || defaultBoardId));
-  }
-
-  writeFileSync(tasksPath, JSON.stringify(tasks.slice(1), null, 2));
+async function readStdin() {
+  let text = '';
+  for await (const chunk of process.stdin) text += chunk;
+  return text;
 }
 
-await runNextTask();
+const prompt = await readStdin();
+if (!prompt.trim()) {
+  console.error('[local-ai] no prompt on stdin — this agent is started by the run loop with the task as its prompt');
+  process.exit(1);
+}
+console.log(await runAgent(prompt, defaultBoardId));

package/shared/build-kit/lib/mcp-register.js

@@ -3,6 +3,7 @@
 // loop (ralph-exec.js).
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { spawnSync } from 'child_process';
 import { homedir } from 'os';
 import { dirname, join } from 'path';
 
@@ -12,6 +13,18 @@ export function shellQuote(s) {
   return `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
 
+// Older OpenCode releases have no `run --standalone`; passing it makes `opencode run` print its
+// usage and exit 1, so every turn fails. Ask the installed binary once. Overridable for tests.
+let standaloneSupported = null;
+export function opencodeSupportsStandalone() {
+  if (standaloneSupported === null) {
+    const r = spawnSync('opencode', ['run', '--help'], { encoding: 'utf8' });
+    standaloneSupported = /--standalone\b/.test(`${r.stdout || ''}${r.stderr || ''}`);
+  }
+  return standaloneSupported;
+}
+export function setOpencodeStandaloneSupport(value) { standaloneSupported = value; }
+
 // Adds or refreshes one key in a project JSON config, leaving everything else in it alone. A file
 // that isn't plain JSON (a JSONC one with comments) is not rewritten — returns false instead, and
 // the caller says what to add by hand.
@@ -50,7 +63,10 @@ const MCP_REGISTRATIONS = {
     // A plain `opencode run` hands the turn to opencode's shared background service, which was
     // started with some other env: {env:EVENTMODELERS_TOKEN} resolves to nothing there and the
     // server refuses every call. --standalone runs a private server that inherits this one's env.
-    const standalone = /\s--(standalone|server)\b/.test(` ${command}`) ? command : `${command} --standalone`;
+    // A binary without the flag runs the turn in-process already, so the flag is dropped, not added.
+    const supported = opencodeSupportsStandalone();
+    const standalone = !supported ? command.replace(/\s--standalone\b/, '')
+      : /\s--(standalone|server)\b/.test(` ${command}`) ? command : `${command} --standalone`;
     return { command: standalone, file: ok ? 'opencode.json' : null, manual: ok ? null : `add mcp.eventmodelers = ${JSON.stringify(entry)} to opencode.json` };
   },
   gemini: (command, projectDir, url) => {