@eventmodelers/cli 1.0.163 → 2.0.2

package/shared/build-kit/lib/slice-run.js

@@ -0,0 +1,181 @@
+// The run loop's shell around the pure slice-state core: claim a slice, settle it after the build, and
+// release claims a dead process left behind. Every step appends events and re-projects status for the
+// build agent; `decide*` (slice-state.js) says what to do, this executes it.
+//
+// `board` is injected: { setStatus(sliceId, status), readStatus(sliceId) → status | null }. null means
+// no board (--local): nothing is pushed or read, the log alone decides.
+
+import { appendEvent, readEvents } from './slice-events.js';
+import { fold, decideSettle, decideRecovery, statusKey } from './slice-state.js';
+import { adoptAgentEdits, projectStatus } from './slice-projection.js';
+import { discardUnfinishedWork, gitBase } from './slice-git.js';
+
+// Appends an event and re-projects status, so the files the agent reads never lag the log.
+export function recordEvent(kitDir, event, meta) {
+  appendEvent(kitDir, event, meta);
+  const state = fold(readEvents(kitDir));
+  projectStatus(kitDir, state);
+  return state;
+}
+
+export function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM'; // exists, just not ours; ESRCH means gone
+  }
+}
+
+// The build agent's side (behind `eventmodelers slice-status`): it records the outcome of the slice the
+// loop has claimed, instead of editing index.json. The loop pushes it to the board when the build ends.
+// The slice is the one open claim, or the one named by id or title. Appends `agent-recorded` and
+// projects straight away — the file the agent reads must never lag the log, or the next refresh would
+// take the stale file for an edit.
+export function recordAgentStatus({ kitDir, status, sliceId, meta }) {
+  const claimed = Object.entries(fold(readEvents(kitDir)).slices).filter(([, s]) => s.claim);
+  let match;
+  if (sliceId) {
+    const wanted = sliceId.trim().toLowerCase();
+    match = claimed.find(([id, s]) => id === sliceId || s.claim.title?.toLowerCase() === wanted);
+    if (!match) throw new Error(`slice "${sliceId}" is not claimed by the run loop — only a slice the loop is building has its status recorded here`);
+  } else if (claimed.length === 1) {
+    match = claimed[0];
+  } else if (claimed.length > 1) {
+    throw new Error(`${claimed.length} slices are claimed (${claimed.map(([, s]) => s.claim.title).join(', ')}) — name one with --slice`);
+  } else {
+    throw new Error('no slice is claimed by the run loop. For a task from tasks.json, set the status with the update-slice-status skill instead');
+  }
+  const [id, { claim }] = match;
+  recordEvent(kitDir, { type: 'agent-recorded', slice: id, status }, meta);
+  return { slice: id, title: claim.title ?? id, status };
+}
+
+// Claims a slice before it is built. The log is the local arbiter (the first claim wins); the board is
+// the cross-agent one — it rejects a move into the status a slice is already in, and a claim first checks the slice is
+// still in the pickup status. Returns 'won', 'held'
+// (another live process owns it in this kit) or 'lost' (the board refused; nothing was built).
+export async function claimSlice({ kitDir, planned, board, meta, cleanTree, pid = process.pid, pickupStatus = 'Planned' }) {
+  const open = fold(readEvents(kitDir)).slices[planned.id]?.claim;
+  if (open && open.pid !== pid && isProcessAlive(open.pid)) return 'held';
+  // Look at the board before claiming. Its same-status guard only turns away an InProgress over an InProgress, so an
+  // agent working from a stale view (Planned, while another has already built and finished it) would otherwise move
+  // a Done slice back to InProgress and build it twice. What the board really shows is recorded, which also puts the
+  // loop's stale local view right. (Two claims in the same instant are still decided by that same-status guard.)
+  if (board) {
+    let current;
+    try {
+      current = await board.readStatus(planned.id);
+    } catch (err) {
+      console.error(`[ralph] Could not read the board before claiming "${planned.title}":`, err.message);
+      return 'lost';
+    }
+    if (current && statusKey(current) !== statusKey(pickupStatus)) {
+      console.log(`[ralph] "${planned.title}" is ${current} on the board, not ${pickupStatus} — someone else got there first.`);
+      recordEvent(kitDir, { type: 'board-observed', slice: planned.id, status: current }, meta);
+      return 'lost';
+    }
+  }
+  const state = recordEvent(kitDir, {
+    type: 'claimed', slice: planned.id, ctx: planned.ctx, title: planned.title, pid, base: gitBase(kitDir), cleanTree,
+    // What the board says about the slice at build time, when it says anything: both can change between builds.
+    ...(planned.ticketNumber ? { ticketNumber: planned.ticketNumber } : {}),
+    ...(planned.assignee ? { assignee: planned.assignee } : {}),
+  }, meta);
+  if (state.slices[planned.id].claim?.pid !== pid) return 'held';
+  if (board) {
+    try {
+      await board.setStatus(planned.id, 'InProgress');
+    } catch (err) {
+      console.error(`[ralph] Could not claim "${planned.title}" on the board:`, err.message);
+      recordEvent(kitDir, { type: 'released', slice: planned.id, reason: 'lost' }, meta);
+      // Counted like any attempt that did not move the slice, so one the board keeps refusing is switched away from.
+      recordEvent(kitDir, { type: 'attempt-failed', slice: planned.id, reason: 'claim-lost', lastReply: null }, meta);
+      return 'lost';
+    }
+  }
+  recordEvent(kitDir, { type: 'claim-confirmed', slice: planned.id }, meta);
+  return 'won';
+}
+
+// Executes what decideSettle / decideRecovery returned for one slice. false when the board refused the
+// push — no `settled` is appended then, so the claim stays open and the next iteration settles it again.
+async function runActions({ kitDir, planned, board, meta, actions, details }) {
+  const unfinished = actions.some((a) => a.type === 'discard');
+  let discarded = null;
+  for (const a of actions) {
+    if (a.type === 'discard') {
+      discarded = discardUnfinishedWork(kitDir, planned, !a.skip, a.base);
+    } else if (a.type === 'push') {
+      if (board) {
+        try {
+          await board.setStatus(planned.id, a.status);
+        } catch (err) {
+          console.error(`[ralph] Could not settle the status of "${planned.title}":`, err.message);
+          return false;
+        }
+      }
+      recordEvent(kitDir, { type: 'settled', slice: planned.id, status: a.status }, meta);
+      console.log(`[ralph] "${planned.title}" InProgress → ${a.status}.`);
+    } else if (a.type === 'release') {
+      recordEvent(kitDir, { type: 'released', slice: planned.id, reason: a.reason }, meta);
+    }
+  }
+  // Counted once the slice is actually back, so a retried settle cannot count the attempt twice.
+  if (unfinished) {
+    recordEvent(kitDir, {
+      type: 'attempt-failed',
+      slice: planned.id,
+      reason: details.built === false ? 'turn-failed' : 'no-outcome',
+      status: actions.find((a) => a.type === 'push')?.status,
+      lastReply: details.lastReply ?? null,
+      ...(discarded ?? {}),
+    }, meta);
+    console.log(`[ralph] "${planned.title}" ended without an outcome.`);
+  }
+  return true;
+}
+
+// After a build: the outcome the agent recorded is pushed to the board; no outcome means unfinished —
+// its work is discarded and the slice goes back to `pickupStatus`. Returns true once settled; false when
+// it could not be (the claim stays open and the loop tries again at the top of its next iteration).
+export async function settleSlice({ kitDir, planned, board, meta, pickupStatus = 'Planned', details = {} }) {
+  const state = adoptAgentEdits(kitDir, fold(readEvents(kitDir)), meta);
+  if (!state.slices[planned.id]?.claim) return true;
+  let boardStatus = null;
+  if (board) {
+    try {
+      boardStatus = await board.readStatus(planned.id);
+    } catch (err) {
+      console.error(`[ralph] Could not read the board to settle "${planned.title}":`, err.message);
+      return false;
+    }
+  }
+  const actions = decideSettle(state, planned.id, { boardStatus, pickupStatus });
+  return runActions({ kitDir, planned, board, meta, actions, details });
+}
+
+// Claims still open at the top of an iteration are leftovers: the process died mid-build, or settling
+// failed last time. Each is settled like a finished build; one held by another live process is left alone.
+export async function settleLeftoverClaims({ kitDir, board, meta, pickupStatus = 'Planned', selfPid = process.pid, isAlive = isProcessAlive }) {
+  const state = adoptAgentEdits(kitDir, fold(readEvents(kitDir)), meta);
+  const boardStatuses = {};
+  const unreadable = new Set();
+  for (const [id, s] of Object.entries(state.slices)) {
+    if (!s.claim || !board || (s.claim.pid !== selfPid && isAlive(s.claim.pid))) continue;
+    try {
+      boardStatuses[id] = await board.readStatus(id);
+    } catch (err) {
+      console.error(`[ralph] Could not read the board to settle the leftover claim on "${s.claim.title ?? id}":`, err.message);
+      unreadable.add(id);
+    }
+  }
+  for (const { slice, actions } of decideRecovery(state, { isAlive, selfPid, boardStatuses, pickupStatus })) {
+    if (unreadable.has(slice)) continue;
+    const claim = state.slices[slice].claim;
+    const planned = { id: slice, title: claim.title ?? slice, ctx: claim.ctx };
+    console.log(`[ralph] Found an unsettled claim on "${planned.title}" — settling it.`);
+    await runActions({ kitDir, planned, board, meta, actions, details: { built: false } });
+  }
+}

package/shared/build-kit/lib/slice-state.js

@@ -0,0 +1,184 @@
+// Local slice state as an event log: `fold` derives it, `decide*` turn it into actions. Both are pure —
+// the run loop appends the events, executes the actions and appends what came of them.
+// Design and the precedence rule: slice-state-test-design.md.
+//
+// Events (one writer per type): board-observed, claimed, claim-confirmed, agent-recorded, settled,
+// released, attempt-failed, blocked, learning-recorded, learning-retracted, learning-merged, learnings-curated,
+// task-queued, task-done, prompt-received, prompt-finished. Unknown types are ignored, so a
+// newer loop's log is readable.
+
+const emptySlice = () => ({
+  status: undefined,
+  claim: null,
+  pendingOutcome: null,
+  lastBoardStatus: undefined,
+  attempts: 0,
+  retryStatus: undefined,
+  lastFailure: null,
+  blocked: null,
+});
+
+// `Handover` is the old name of `Waiting`: boards and files written before the rename still hold it.
+export const statusKey = (s) => { const k = (s || '').toLowerCase(); return k === 'handover' ? 'waiting' : k; };
+const same = (a, b) => typeof a === 'string' && typeof b === 'string' && statusKey(a) === statusKey(b);
+
+const apply = {
+  // While a claim is open the board's view is recorded but does not touch `status`: a refresh that
+  // still shows InProgress must not revert the outcome the agent recorded. Attempts reset only between
+  // builds — our own claim moving the board to InProgress is not the slice leaving Planned.
+  'board-observed'(s, e) {
+    s.lastBoardStatus = e.status;
+    if (s.claim) return;
+    s.status = e.status;
+    // Attempts count builds that failed to move the slice off the status it was put back to (Planned, or
+    // Waiting for UI kits); any other status means it moved. Any status but Blocked lifts a block.
+    if (!same(e.status, s.retryStatus ?? 'Planned')) { s.attempts = 0; s.lastFailure = null; }
+    if (!same(e.status, 'Blocked')) s.blocked = null;
+  },
+  // First claim wins: while one is open a second `claimed` for the slice is ignored.
+  claimed(s, e) {
+    if (s.claim) return;
+    s.claim = { pid: e.pid, confirmed: false, base: e.base ?? null, cleanTree: e.cleanTree, ctx: e.ctx, title: e.title, prevStatus: s.status };
+    s.pendingOutcome = null;
+    s.status = 'InProgress';
+  },
+  'claim-confirmed'(s) {
+    if (s.claim) s.claim.confirmed = true;
+  },
+  'agent-recorded'(s, e) {
+    s.status = e.status;
+    if (s.claim) s.pendingOutcome = e.status;
+  },
+  settled(s, e) {
+    s.claim = null;
+    s.pendingOutcome = null;
+    s.status = e.status;
+    s.lastBoardStatus = e.status;
+  },
+  // The claim ended without anything pushed: the slice shows what the board last said (someone else may
+  // have moved it meanwhile), or what it was before the claim if the board was never observed.
+  released(s) {
+    if (!s.claim) return;
+    s.status = s.lastBoardStatus ?? s.claim.prevStatus;
+    s.claim = null;
+    s.pendingOutcome = null;
+  },
+  'attempt-failed'(s, e) {
+    s.attempts += 1;
+    s.retryStatus = e.status ?? 'Planned';
+    // What the next build is told about the one that failed.
+    s.lastFailure = { at: e.at, reason: e.reason, lastReply: e.lastReply ?? null, branch: e.branch ?? null, created: e.created ?? [], changed: e.changed ?? '' };
+  },
+  // A block starts the count afresh: an unblocked slice gets a full budget again.
+  blocked(s, e) {
+    s.blocked = { reason: e.reason, at: e.at };
+    s.status = 'Blocked';
+    s.attempts = 0;
+    s.lastFailure = null;
+  },
+};
+
+// The curator's merge: the known sources are replaced by one learning, in the slot of the first of them.
+function mergeLearnings(learnings, e) {
+  const sources = learnings.filter((l) => e.learnings?.includes(l.id));
+  if (!sources.length) return learnings;
+  const tags = [...new Set([...sources.flatMap((l) => l.tags), ...(e.tags ?? [])])];
+  const merged = { id: e.id, text: e.text, topic: e.topic ?? sources[0].topic, slice: undefined, scope: e.scope ?? sources[0].scope, tags, curated: true };
+  return learnings.flatMap((l) => (l === sources[0] ? [merged] : sources.includes(l) ? [] : [l]));
+}
+
+export function fold(events) {
+  const slices = {};
+  let learnings = [];
+  let tasks = [];
+  const prompts = new Map(); // board prompts the modeling agent took and has not finished, in the order received
+  for (const e of events) {
+    if (!e) continue;
+    if (e.type === 'prompt-received' && e.prompt?.id) {
+      const { id, text, board_id, priority, agent_id } = e.prompt;
+      prompts.set(id, { id, pid: e.pid, at: e.at, text, board_id, priority, agent_id: agent_id ?? null });
+    } else if (e.type === 'prompt-finished') {
+      prompts.delete(e.prompt);
+    }
+    // The task queue: slice changes the agent has to react to, oldest first. A newer change to the same
+    // slice replaces its queued task (and goes to the back); `task-done` names a task by id, so a change that
+    // arrived while the agent was working the old one is a new task and survives.
+    if (e.type === 'task-queued') {
+      const sliceId = e.payload?.sliceId;
+      tasks = tasks.filter((t) => sliceId === undefined || t.payload?.sliceId !== sliceId);
+      tasks.push({ id: e.id, at: e.at, payload: e.payload });
+    } else if (e.type === 'task-done') {
+      tasks = tasks.filter((t) => t.id !== e.task);
+    }
+    // Learnings are not about one slice (the slice is just where it was learned), so they sit beside them.
+    if (e.type === 'learning-recorded') learnings.push({ id: e.id, text: e.text, topic: e.topic, slice: e.slice, scope: e.scope ?? 'repo', tags: e.tags ?? [], curated: false });
+    else if (e.type === 'learning-retracted') learnings = learnings.filter((l) => l.id !== e.learning);
+    else if (e.type === 'learning-merged') learnings = mergeLearnings(learnings, e);
+    else if (e.type === 'learnings-curated') learnings = learnings.map((l) => ({ ...l, curated: true }));
+    if (!e.slice || !Object.hasOwn(apply, e.type)) continue;
+    apply[e.type](slices[e.slice] ??= emptySlice(), e);
+  }
+  return { slices, learnings, tasks, prompts: [...prompts.values()] };
+}
+
+// The curator (an LLM, writing events) is worth a turn once this many learnings have been recorded since
+// it last reviewed them.
+export function needsCuration(state, threshold) {
+  return state.learnings.filter((l) => !l.curated).length >= threshold && threshold > 0;
+}
+
+// Two learnings that differ only in case or whitespace are the same learning.
+export function learningKey(text) {
+  return String(text).replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+// AGENTS.md: the learnings, grouped by topic (in order of first appearance), one line each, duplicates
+// dropped. Nothing is written into the file by hand — it is regenerated from the log.
+export function renderLearnings(state) {
+  const topics = new Map();
+  const seen = new Set();
+  for (const { text, topic } of state.learnings) {
+    const key = learningKey(text);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    const name = topic?.trim() || 'General';
+    if (!topics.has(name)) topics.set(name, []);
+    topics.get(name).push(String(text).trim());
+  }
+  if (!topics.size) return '';
+  const body = [...topics].map(([name, lines]) => `## ${name}\n${lines.map((l) => `- ${l}`).join('\n')}\n`).join('\n');
+  return `<!-- Generated from the slice-state event log. Record learnings with the learn command; do not edit. -->\n\n${body}`;
+}
+
+// What to do with a claimed slice once its build is over. `boardStatus` is the board's current status
+// for it (null when unknown or there is no board); `pickupStatus` is what an unfinished slice goes back
+// to (Planned, or Waiting for UI kits). Actions: discard {base, skip}, push {status}, release {reason} —
+// the loop appends `settled` after a successful push and `released` for a release. A failed push appends
+// nothing, so the claim stays open and the next iteration settles it again.
+export function decideSettle(state, sliceId, { boardStatus = null, pickupStatus = 'Planned' } = {}) {
+  const s = state.slices[sliceId];
+  const claim = s?.claim;
+  if (!claim) return [];
+  // Never confirmed on the board: nothing of ours to push there — the slice may belong to the winner of the race.
+  if (!claim.confirmed) return [{ type: 'release', reason: 'unconfirmed' }];
+  // Someone else moved it (a person, request-feedback's Blocked) — theirs to keep.
+  if (boardStatus && !same(boardStatus, 'InProgress')) return [{ type: 'release', reason: 'moved' }];
+  const outcome = s.pendingOutcome;
+  const unfinished = !outcome || same(outcome, 'InProgress') || same(outcome, pickupStatus);
+  if (!unfinished) return [{ type: 'push', status: outcome }];
+  // `skip`: the tree already held someone's edits at claim time, so none of it is the build's debris.
+  return [{ type: 'discard', base: claim.base, skip: !claim.cleanTree }, { type: 'push', status: pickupStatus }];
+}
+
+// Claims still open at the top of a loop iteration are leftovers: the process died mid-build, or settling
+// failed last time. Each is settled the way a finished build is. A claim held by another live process
+// belongs to it — left alone.
+export function decideRecovery(state, { isAlive, selfPid, boardStatuses = {}, pickupStatus = 'Planned' }) {
+  const result = [];
+  for (const [slice, s] of Object.entries(state.slices)) {
+    if (!s.claim) continue;
+    if (s.claim.pid !== selfPid && isAlive(s.claim.pid)) continue;
+    result.push({ slice, actions: decideSettle(state, slice, { boardStatus: boardStatuses[slice] ?? null, pickupStatus }) });
+  }
+  return result;
+}

package/shared/build-kit/lib/slice-tasks.js

@@ -0,0 +1,35 @@
+// The task queue is the event log: the realtime agent queues a slice change as `task-queued`, the loop replays
+// the log to find the oldest task still waiting, hands it to the agent, and appends `task-done` when the turn is
+// over. Nobody reads or rewrites a queue file, so there is nothing for two writers to collide on — a change that
+// lands mid-turn is just another event, and `task-done` names the task by id.
+
+import { appendEvent, readEvents } from './slice-events.js';
+import { fold } from './slice-state.js';
+
+// `payload` is the slice change ({ sliceId, sliceTitle, sliceStatus, ... }). Returns { id } of the task.
+export function queueTask({ kitDir, payload, meta }) {
+  return { id: appendEvent(kitDir, { type: 'task-queued', payload }, meta) };
+}
+
+export function pendingTasks(kitDir) {
+  return fold(readEvents(kitDir)).tasks;
+}
+
+// The oldest task waiting, or null. Handing it out does not consume it — `completeTask` does.
+export function nextTask(kitDir) {
+  return pendingTasks(kitDir)[0] ?? null;
+}
+
+export function completeTask({ kitDir, task, meta }) {
+  appendEvent(kitDir, { type: 'task-done', task }, meta);
+}
+
+// One turn for the oldest waiting task. `run(task)` is the agent turn and says whether it finished (false: it
+// timed out — the task stays queued and is handed out again; a turn that throws leaves it queued too). The
+// task is completed only after a finished turn. Returns whether a task was worked.
+export async function workNextTask({ kitDir, meta, run }) {
+  const task = nextTask(kitDir);
+  if (!task) return false;
+  if (await run(task)) completeTask({ kitDir, task: task.id, meta });
+  return true;
+}

package/shared/build-kit/ralph-claude.js

@@ -78,7 +78,7 @@ function describeToolUse(block) {
 }
 
 // `slice` is set for a planned-slice build (see startRalph) — the only turns that are traced.
-function runClaude(prompt, slice = null) {
+function runClaude(prompt, slice = null, extraEnv = {}) {
   return new Promise((resolve, reject) => {
     // The prompt goes in on stdin, never as a `-p` argument: on Windows a multi-line argv entry
     // is cut at its first newline, so `claude` saw only the connect header, answered "I don't see
@@ -86,7 +86,7 @@ function runClaude(prompt, slice = null) {
     const proc = spawn('claude', [...claudeArgs, '-p'], {
       cwd: projectDir,
       stdio: ['pipe', 'pipe', 'inherit'],
-      env: claudeEnv,
+      env: { ...claudeEnv, ...extraEnv },
     });
     proc.stdin.end(inlineHeader + prompt);
     const turn = superviseTurn(proc, { timeoutMs, label: 'Claude turn', log: (line) => console.error(`[ralph] ${line}`) });
@@ -134,6 +134,8 @@ startRalph({
   projectDir,
   onTask: runClaude,
   onPlannedSlice: runClaude,
+  // The curation turn: the learnings tidied by an agent that may only merge and retract (see lib/slice-curation.js).
+  onCurate: (prompt, { env } = {}) => runClaude(prompt, null, env),
   localOnly,
 }).catch((err) => {
   console.error('[ralph] Fatal:', err);

package/shared/build-kit/ralph-exec.js

@@ -102,7 +102,7 @@ function collectUsage(stream) {
 }
 
 // `slice` is set for a planned-slice build (see startRalph) — the only turns that are traced.
-function runExec(prompt, slice = null) {
+function runExec(prompt, slice = null, extraEnv = {}) {
   return new Promise((resolvePromise, reject) => {
     const full = inlineHeader + prompt;
     const promptFile = join(promptDir, 'prompt.md');
@@ -118,7 +118,7 @@ function runExec(prompt, slice = null) {
       cwd: projectDir,
       stdio: ['inherit', traced ? 'pipe' : 'inherit', 'inherit'],
       shell: true,
-      env: { ...childEnv, RALPH_PROMPT_FILE: promptFile },
+      env: { ...childEnv, RALPH_PROMPT_FILE: promptFile, ...extraEnv },
     });
     const turn = superviseTurn(proc, { timeoutMs, label: 'exec turn', viaShell: true, log: (line) => console.error(`[ralph-exec] ${line}`) });
     const usage = traced ? collectUsage(proc.stdout) : null;
@@ -141,6 +141,8 @@ startRalph({
   projectDir,
   onTask: runExec,
   onPlannedSlice: runExec,
+  // The curation turn: the learnings tidied by an agent that may only merge and retract (see lib/slice-curation.js).
+  onCurate: (prompt, { env } = {}) => runExec(prompt, null, env),
   localOnly,
 }).catch((err) => {
   console.error('[ralph] Fatal:', err);

package/shared/build-kit/ralph-local-ai.js

@@ -16,13 +16,15 @@ const kitDir = dirname(fileURLToPath(import.meta.url));
 const projectDir = process.argv[2] ? resolve(process.argv[2]) : resolve(kitDir, '..');
 
 
-function runLocalAi() {
+// The task goes in on stdin, as it does for the Claude runner: the loop has already picked it.
+function runLocalAi(prompt) {
   return new Promise((resolve, reject) => {
     const proc = spawn('node', [join(kitDir, 'lib', 'local-ai-agent.js')], {
       cwd: projectDir,
-      stdio: 'inherit',
+      stdio: ['pipe', 'inherit', 'inherit'],
       env: process.env,
     });
+    proc.stdin.end(prompt);
     proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`local-ai-agent exited ${code}`))));
     proc.on('error', reject);
   });
@@ -32,7 +34,7 @@ startRalph({
   kitDir,
   projectDir,
   onTask: runLocalAi,
-  // onPlannedSlice omitted — local-ai-agent manages its own task queue
+  // onPlannedSlice omitted — this runner works the queued tasks only
   localOnly: process.env.RALPH_LOCAL === '1',
 }).catch((err) => {
   console.error('[ralph] Fatal:', err);

package/shared/scaffold/LICENSE-em-scaffold

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adrian Mowat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.