@eventmodelers/cli 1.0.162 → 2.0.1

package/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'path';
 import {
@@ -10,6 +10,7 @@ import {
   copyFileSync,
   rmSync,
   readdirSync,
+  statSync,
   writeFileSync,
   readFileSync,
   appendFileSync,
@@ -29,14 +30,26 @@ import { modelingPermissions } from './lib/agent-permissions.js';
 // copyDirContents in installStack) for ralph.js to import standalone — see
 // shared/build-kit/lib/adapters/realtime-adapter.js for why it lives there instead.
 import { createRealtimeAdapter, keepSubscribed } from './shared/build-kit/lib/adapters/realtime-adapter.js';
+import { recordAgentStatus } from './shared/build-kit/lib/slice-run.js';
+import { defaultAgentName, withInstanceSuffix } from './shared/build-kit/lib/agent-name.js';
+import { acquireAgentId } from './shared/build-kit/lib/agent-lock.js';
+import { readEvents } from './shared/build-kit/lib/slice-events.js';
+import { findPromptEvent, replayRequest } from './shared/build-kit/lib/prompt-replay.js';
+import { prunableEvents, pruneLog, rememberPruneAnswer, shouldOfferPrune } from './shared/build-kit/lib/event-prune.js';
+import { fold } from './shared/build-kit/lib/slice-state.js';
+import { filterEvents, formatEvent, formatPayload, sliceTitles, summarize } from './shared/build-kit/lib/events-view.js';
+import { stableGlobalAgentId } from './lib/global-agent-id.js';
+import { ensureLearningsGitRules } from './shared/build-kit/lib/ralph.js';
+import { createCallTracker, heldPromptsRequest, journalPromptAction, shouldJournalCall, journalPromptFinished, journalPromptReceived, recoverOwnPrompts } from './shared/build-kit/lib/prompt-journal.js';
+import { listLearnings, mergeLearnings, recordLearning, recordTurnLearnings, retractLearning, syncLearnings } from './shared/build-kit/lib/slice-learnings.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // Each stack is a template set under stacks/<key>/templates/{.claude,root,<kitSubdir>}.
 // Stacks with useShared:true also get shared/build-kit/* copied into their kit dir
-// (ralph.js, ralph-claude.js, ralph-local-ai.js, ralph-exec.js, ralph.sh, realtime-agent.js,
-// code-export.mjs, lib/agent.sh, lib/local-ai-agent.js, package.json, README.md) —
+// (ralph.js, ralph-claude.js, ralph-local-ai.js, ralph-exec.js,
+// code-export.mjs, lib/local-ai-agent.js, package.json, README.md) —
 // those files have no per-stack content, so they live once instead of being
 // copy-pasted into every stack (that copy-pasting is exactly how they drifted out
 // of sync before: a bugfix or default landing in one stack's copy but not another's).
@@ -44,7 +57,7 @@ const __dirname = dirname(__filename);
 // (lib/prompt.md, lib/backend-prompt.md, lib/AGENT.md, checks, etc.); shared/build-kit/*
 // is copied after it, so the shared runtime always wins over any copy a stack still ships.
 // modeling-kit (below) is the one kit that opts out of all of this (useShared:false)
-// — it has no cold-spawn/tasks.json runtime at all, so none of shared/build-kit/*
+// — it has no cold-spawn/task-queue runtime at all, so none of shared/build-kit/*
 // applies to it; see its own templates/kit for its (much smaller) self-contained set.
 // --- Local-AI runner selection ------------------------------------------------
 // One runner drives every local/self-hosted backend. What differs between Ollama,
@@ -117,8 +130,8 @@ function resolveAgentPreset(opts, loop) {
     console.error('❌ --agent and --exec are mutually exclusive — --agent is a shortcut for --exec.');
     process.exit(1);
   }
-  if (resolveLocalAiTarget(opts) !== null || opts.bash) {
-    console.error('❌ --agent is mutually exclusive with --local-ai/--bash — pick one runner.');
+  if (resolveLocalAiTarget(opts) !== null) {
+    console.error('❌ --agent is mutually exclusive with --local-ai — pick one runner.');
     process.exit(1);
   }
   const cmd = AGENT_PRESETS[name]?.[loop] ?? null;
@@ -212,7 +225,7 @@ const STACKS = {
 
 // Not a stack — no backend scaffold, just skills + the agent loop. Installed via
 // `init --modeling` instead of the `init --stack <name>` picker.
-// useShared:false — unlike build-kit, modeling-kit has no cold-spawn/tasks.json
+// useShared:false — unlike build-kit, modeling-kit has no cold-spawn/task-queue
 // runtime to reuse from shared/build-kit/*; its only runtime mode is the CLI's
 // own warm, direct-dispatch loop (`run --modeling`), so its kit dir just needs
 // lib/config.js for config resolution — see stacks/modeling-kit/templates/kit.
@@ -225,34 +238,9 @@ const MODELING_KIT = {
   needsBoardId: false,
 };
 
-// Frameworks a bridge install can translate board slices into. Each key needs
-// a matching `bridge-<key>-specify` skill under shared/bridge/ — see
-// stacks/bridge/templates/bridge/lib/prompt.md for how the loop picks it up.
-const BRIDGE_TARGETS = {
-  'spec-kitty': { label: 'Spec Kitty' },
-};
-
-// Also not a stack — no backend scaffold, just the bridge-*/shared skills +
-// the agent loop. Installed via `init --bridge --target <name>` instead of
-// the `init --stack <name>` picker. useShared:true (unlike modeling-kit): a
-// bridge agent reuses build-kit's cold-spawn/tasks.json engine as-is
-// (lib/ralph.js) — it just reacts to every slice change instead of only
-// "Planned" ones (see queueAllStatuses in lib/ralph.js) and translates
-// instead of building. Its own templates/bridge overlay swaps in
-// bridge-specific prompt.md/AGENT.md and a ralph-claude.js that omits
-// onPlannedSlice entirely — see stacks/bridge/templates/bridge.
-const BRIDGE_KIT = {
-  key: 'bridge',
-  label: 'Bridge — translate board slices into another spec framework, no backend scaffold',
-  kitSubdir: 'bridge',
-  kitDirName: '.bridge-kit',
-  useShared: true,
-  needsBoardId: true,
-};
-
 // Also not a stack — installed via `init --build-kit` instead of `init --stack <name>`.
 // useShared:true, same as any real backend stack: it reuses build-kit's cold-spawn/
-// tasks.json engine as-is (lib/ralph.js). Its templates/build-kit/CLAUDE.md,
+// task-queue engine as-is (lib/ralph.js). Its templates/build-kit/CLAUDE.md,
 // lib/{prompt,backend-prompt}.md, and templates/.claude/skills/build-*/SKILL.md are
 // TODO-marked placeholders instead of real stack content (see stacks/blank/templates)
 // — this is for a stack that isn't built into this CLI yet: fill in the TODOs against
@@ -267,7 +255,7 @@ const BLANK_BUILD_KIT = {
   needsBoardId: true,
 };
 
-const KIT_DIR_NAMES = [...new Set([...Object.values(STACKS), MODELING_KIT, BRIDGE_KIT, BLANK_BUILD_KIT].map((s) => s.kitDirName))];
+const KIT_DIR_NAMES = [...new Set([...Object.values(STACKS), MODELING_KIT, BLANK_BUILD_KIT].map((s) => s.kitDirName))];
 
 // What `init --demo` installs, for the messages it prints. Kept in step with
 // shared/demo-slices/ (context.json's name, and the slice folders beside it).
@@ -953,7 +941,7 @@ async function installStack(stackKey, stackCfg, options = {}) {
     // install TO, versus where we install FROM.
     const targetDir = options.targetDir ? resolve(options.targetDir) : process.cwd();
     // `init --git <url>` passes a resolved clone dir's templates/ here instead — every
-    // other input (STACKS, MODELING_KIT, BRIDGE_KIT) keeps using the built-in path.
+    // other input (STACKS, MODELING_KIT) keeps using the built-in path.
     const templatesSource = options.templatesSource || join(__dirname, 'stacks', stackKey, 'templates');
     const sharedBuildKit = join(__dirname, 'shared', 'build-kit');
     // Skills with no stack-specific content (connect, learn-eventmodelers-api,
@@ -962,15 +950,7 @@ async function installStack(stackKey, stackCfg, options = {}) {
     // of sync with each other before (e.g. one stack's connect skill silently
     // missing a bugfix another stack's copy had).
     const sharedSkills = join(__dirname, 'shared', 'skills');
-    // Adapter skills that translate board slices for another spec framework —
-    // one subfolder per target (shared/bridge/spec-kitty/bridge-spec-kitty-*,
-    // shared/bridge/kiro/..., etc.), so a bridge install only ever pulls in
-    // the target it was actually configured for, not every framework's
-    // skills. Only relevant to a bridge install — never copied into the four
-    // backend stacks or modeling-kit.
-    const isBridge = stackKey === BRIDGE_KIT.key;
     const isModelingKit = stackKey === MODELING_KIT.key;
-    const sharedBridgeSkills = isBridge ? join(__dirname, 'shared', 'bridge', options.target) : null;
 
     if (!existsSync(templatesSource)) {
       console.error('❌ Templates directory not found at:', templatesSource);
@@ -983,7 +963,6 @@ async function installStack(stackKey, stackCfg, options = {}) {
     const claudeSkillsSrc = join(templatesSource, '.claude', 'skills');
     const installedSkills = [
       ...(existsSync(sharedSkills) ? readdirSync(sharedSkills) : []),
-      ...(isBridge && existsSync(sharedBridgeSkills) ? readdirSync(sharedBridgeSkills) : []),
       ...(existsSync(claudeSkillsSrc) ? readdirSync(claudeSkillsSrc) : []),
     ];
     let claudeExtras = [];
@@ -992,14 +971,12 @@ async function installStack(stackKey, stackCfg, options = {}) {
       const globalSkillsDir = join(homedir(), '.claude', 'skills');
       console.log('📦 Installing skills globally...');
       copyDirContents(sharedSkills, globalSkillsDir);
-      if (isBridge) copyDirContents(sharedBridgeSkills, globalSkillsDir);
       copyDirContents(claudeSkillsSrc, globalSkillsDir);
     } else {
       console.log('📦 Installing skills...');
       // Shared skills first, the stack's own templates last — so a build kit can override
       // a shared skill (e.g. `ui-contract`) just by shipping a skill of the same name.
       copyDirContents(sharedSkills, join(targetDir, '.claude', 'skills'));
-      if (isBridge) copyDirContents(sharedBridgeSkills, join(targetDir, '.claude', 'skills'));
       copyDirContents(join(templatesSource, '.claude'), join(targetDir, '.claude'));
       claudeExtras = existsSync(join(templatesSource, '.claude'))
         ? readdirSync(join(templatesSource, '.claude')).filter((f) => f !== 'skills')
@@ -1041,7 +1018,7 @@ async function installStack(stackKey, stackCfg, options = {}) {
       }
     }
 
-    // A modeling-kit + build-kit (or bridge) combo in the same project is supported
+    // A modeling-kit + build-kit combo in the same project is supported
     // (they share one config.json — see ensureAgentId) but each kit's own instructions
     // now live in its own kit dir (.build-kit/CLAUDE.md, .agent-modeling-kit/CLAUDE.md)
     // instead of root/CLAUDE.md, precisely so a second kit's install can never clobber
@@ -1131,16 +1108,8 @@ async function installStack(stackKey, stackCfg, options = {}) {
       }
     }
 
-    // Static (no-LLM) bridge adapters live once in this package's own lib/
-    // adapters/ — `fetch --spec-kitty` imports them directly, and a bridge
-    // install gets its own copy here so ralph-static.js can run standalone
-    // with no access back to the published package.
-    if (isBridge) {
-      copyDirContents(join(__dirname, 'lib', 'adapters'), join(kitDir, 'adapters'));
-    }
-
     // Make scripts executable
-    for (const script of ['ralph.sh', 'lib/agent.sh', 'ralph-claude.js', 'ralph-local-ai.js', 'ralph-exec.js']) {
+    for (const script of ['ralph-claude.js', 'ralph-local-ai.js', 'ralph-exec.js']) {
       const p = join(kitDir, script);
       if (existsSync(p)) {
         try { execSync(`chmod +x "${p}"`); } catch {}
@@ -1246,12 +1215,10 @@ async function installStack(stackKey, stackCfg, options = {}) {
     if (options.skipEpilogue) return;
 
     console.log('\n✅ Done! Start your agent:\n');
-    if (isBridge) {
-      console.log('  npx @eventmodelers/cli bridge\n');
-    } else if (isModelingKit) {
+    if (isModelingKit) {
       console.log('  npx @eventmodelers/cli run --modeling\n');
     } else {
-      console.log('  npx @eventmodelers/cli run          (--local-ai or --bash for other runners)\n');
+      console.log('  npx @eventmodelers/cli run          (--local-ai or --exec for other runners)\n');
     }
     console.log('Connect this project to an MCP client (Claude Code, VS Code, ...):\n');
     console.log(`  npx @eventmodelers/cli init-mcp\n`);
@@ -1390,7 +1357,7 @@ async function refreshSharedRuntime({ targetDir, kitDir, globalOpts, opts }) {
   if (existsSync(manifestPath)) {
     writeFileSync(manifestPath, JSON.stringify({ ...readJsonSafe(manifestPath), version: CLI_VERSION }, null, 2));
   }
-  for (const script of ['ralph.sh', 'lib/agent.sh', 'ralph-claude.js', 'ralph-local-ai.js', 'ralph-exec.js']) {
+  for (const script of ['ralph-claude.js', 'ralph-local-ai.js', 'ralph-exec.js']) {
     const p = join(kitDir, script);
     if (existsSync(p)) {
       try { execSync(`chmod +x "${p}"`); } catch {}
@@ -1750,6 +1717,22 @@ async function fetchDefaultBoardId(baseUrl, token) {
   }
 }
 
+// The board whose credentials were written most recently — the best guess for "the board I
+// was just driving" when nothing in this directory names one. Only offered as the default
+// of the interactive question, never applied silently.
+function lastUsedBoardId() {
+  try {
+    const dir = join(GLOBAL_DIR, 'boards');
+    return readdirSync(dir)
+      .filter((f) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/.test(f))
+      .map((f) => ({ id: f.slice(0, -5), mtime: statSync(join(dir, f)).mtimeMs, creds: readJsonSafe(join(dir, f)) }))
+      .filter((b) => b.creds.token)
+      .sort((a, b) => b.mtime - a.mtime)[0]?.id ?? null;
+  } catch {
+    return null;
+  }
+}
+
 // Per-run credentials for the global install. Precedence is this CLI's usual one, with the
 // per-board file slotted in as the most specific *file*: explicit flags beat
 // EVENTMODELERS_* env vars beat ~/.eventmodelers/boards/<board>.json beat the nearest
@@ -1789,6 +1772,7 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print,
   let boardChosen = !!(explicit.boardId || process.env.EVENTMODELERS_BOARD_ID);
   let pasted = null;
   if (!boardChosen && interactive) {
+    boardId = boardId || lastUsedBoardId();
     const answer = await prompt(boardId ? `\n  Board ID [${boardId}]: ` : '\n  Board ID: ');
     if (answer) {
       pasted = parseCredentialsPaste(answer, ['organizationId', 'token', 'boardId']);
@@ -1916,16 +1900,12 @@ async function resolveModelingCredentials(cwd, flags, explicitConfigPath, print,
     process.exit(1);
   }
 
-  // A fresh identity for every standalone run, deliberately not persisted. A standalone agent
-  // is started ad hoc from wherever, and nothing stops two of them running for the same board —
-  // with one id stored per board they upserted the same alive row (the heartbeat is keyed on
-  // token + agent_id + agent_type), so the second agent replaced the first instead of joining
-  // it: the board showed one agent however many were running, and their writes were
-  // indistinguishable. A per-run uuid costs the identity its continuity across restarts (a
-  // restarted agent is a new row, and the old one lingers until its 45s window lapses) — pass
-  // `run --id <uuid>` when an agent needs to keep one identity, which is also what makes
-  // "preferred agent" on the board stick to it.
-  config.agentId = randomUUID();
+  // One identity per board and repo — the directory the run is started in — kept in ~/.eventmodelers/agent-ids.json, so a
+  // standalone agent is the same agent on every start: its chat sessions, its star on the board and the prompts it holds
+  // stay addressed to it. This is the id it keeps; whether this process may use it (another live run may already be
+  // under it) is decided in the run action, which also lets `run --id` pin a different one. Not written into the
+  // per-board credentials file below — the id is not a credential.
+  config.agentId = stableGlobalAgentId({ file: join(GLOBAL_DIR, 'agent-ids.json'), boardId: config.boardId, dir: cwd });
   writeBoardCredentials(stored.useGlobal
     ? { boardId: config.boardId, useGlobal: true, agentName: config.agentName }
     : config);
@@ -1963,7 +1943,7 @@ async function ensureGlobalKit(baseUrl) {
 }
 
 // `run --modeling`: modeling-kit's one and only runtime mode — there is no
-// cold-spawn/tasks.json loop for this kit (that's a build-kit concept; see the
+// cold-spawn/task-queue loop for this kit (that's a build-kit concept; see the
 // `run` command's build-kit-vs-modeling-kit gate above). It keeps ONE Claude
 // process warm across turns via `--input-format stream-json`, subscribes to the
 // org's realtime channel itself, and writes each prompt straight to that
@@ -1990,6 +1970,27 @@ async function ensureGlobalKit(baseUrl) {
 // untargeted is handed straight back to the queue for another agent to take. It says
 // nothing about the standalone lane — a self-directed turn is nobody's task, so an
 // exclusive standalone agent still works the board on its own initiative.
+// A new instance of a loop starts by checking how big its event log has grown: at every multiple of 1000 events it
+// asks whether to prune it (`events --prune` does the same on demand). Only asked where someone can answer.
+async function offerPrune(kitDir, { interactive }) {
+  let count;
+  try { count = readEvents(kitDir).length; } catch { return; }
+  if (!shouldOfferPrune(kitDir, count)) return;
+  const prunable = prunableEvents(readEvents(kitDir)).length;
+  if (!interactive) {
+    console.error(`ℹ️  The event log has ${count} events (${prunable} of them prunable) — \`eventmodelers events --prune\` removes them.`);
+    return;
+  }
+  const answer = (await prompt(`The event log has ${count} events. Should we prune the log? Removes the journal of finished prompts (${prunable} events); slice state and learnings stay. [y/N] `)).toLowerCase();
+  if (answer === 'y' || answer === 'yes') {
+    const { removed, kept } = pruneLog(kitDir);
+    rememberPruneAnswer(kitDir, kept);
+    console.log(`Pruned ${removed} events, ${kept} left.\n`);
+  } else {
+    rememberPruneAnswer(kitDir, count);
+  }
+}
+
 async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false, standalone = false, exclusive = false, worker = false, overrides = null, maxAgents = DEFAULT_MAX_AGENTS, identity = {}, localAi = null, exec = null, model = null, skipPermissions = false, browser = false } = {}) {
   // --worker: only prompts — no chat, and no board-change turns (it has nowhere to propose).
   const chat = !worker;
@@ -2017,7 +2018,17 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
   // `run --id` overrides that for this run only — ensureAgentId is skipped rather than
   // overwritten, so the project's own stable id stays on disk and the next run without the
   // flag is the same agent the platform saw before.
-  if (!overrides) local.agentId = identity.agentId || ensureAgentId(kitDir, 'MODELING');
+  if (!overrides) {
+    if (identity.agentId) {
+      local.agentId = identity.agentId;
+    } else {
+      // The project's stable id — unless a live process already runs under it (two `run --modeling` in one
+      // project), in which case this one gets a fresh id (agent-lock.js).
+      const { agentId, fellBack } = acquireAgentId({ lockDir: join(projectDir, '.eventmodelers', 'locks'), stableId: ensureAgentId(kitDir, 'MODELING') });
+      local.agentId = agentId;
+      local.agentIdFellBack = fellBack;
+    }
+  }
   if (!local.token || !local.organizationId) {
     console.error('❌ --modeling needs platform credentials in .eventmodelers/config.json (token + organizationId) — run `/connect` once or paste your config first.');
     process.exit(1);
@@ -2026,6 +2037,17 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
   // resolveModelingCredentials just minted for this run, which would otherwise win back over
   // an explicit --id.
   const cfg = { ...applyEnvOverrides(await fetchPlatformConfig(local)), ...(overrides ?? {}), ...(identity.agentId ? { agentId: identity.agentId } : {}), ...(identity.agentName ? { agentName: identity.agentName } : {}), ...(model ? { model } : {}) }; // adds realtimeProvider + its provider-specific fields (supabaseUrl/supabaseAnonKey or pocketbaseUrl), + boardId if the config has a default one
+  // No name given (--name, agentName in the config): the repository's, so the board shows which agent is live.
+  // (On the global install projectDir is ~/.eventmodelers/kit; the repo is the directory the run was started in.)
+  if (!cfg.agentName) {
+    const base = defaultAgentName(codeDir ?? projectDir, 'MODELING');
+    cfg.agentName = cfg.agentIdFellBack ? withInstanceSuffix(base, cfg.agentId) : base;
+  }
+  // Learnings are kept only on a project install: the global install's kit dir (~/.eventmodelers/kit) is shared by every
+  // board and account, so what one board taught the agent would end up in another's AGENTS.md. The prompt journal has no
+  // such problem — every entry is stamped with its board (`events --board`) — so every run keeps it, standalone included.
+  const keepsRecord = !standalone && !overrides;
+  if (keepsRecord) ensureLearningsGitRules(kitDir);
   if (!cfg.boardId) {
     console.error('❌ --modeling needs a boardId — a modeling agent always runs for exactly one board. Run `/connect board=<uuid>` once, or add boardId to .eventmodelers/config.json.');
     process.exit(1);
@@ -2051,7 +2073,7 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
   let localRunner = null;
   if (localAi) {
     try {
-      localRunner = createModelingLocalAiRunner({ cfg, target: localAi, log, verbose, standalone });
+      localRunner = createModelingLocalAiRunner({ cfg, target: localAi, log, verbose, standalone, onToolUse: (name, input) => { const id = `local-${++localCallSeq}`; noteToolStart(id, name, input); return (outcome) => noteToolEnd(id, outcome); } });
     } catch (err) {
       console.error(`❌ --local-ai: ${err.message}`);
       process.exit(1);
@@ -2190,6 +2212,19 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
   let proc = null;
   let stdoutBuffer = '';
   let pending = null; // one in-flight turn at a time
+  let turnPromptId = null; // the prompt the current turn works, so the board writes it makes are journaled against it
+  // A call is journaled when it ends, so its entry carries how long it took (see journalPromptAction). Only the calls the
+  // journal will keep are tracked at all.
+  const calls = createCallTracker();
+  let localCallSeq = 0;
+  const journalCall = (call) => journal(() => journalPromptAction({ kitDir, id: turnPromptId, toolName: call.name, input: call.input, verbose, detail: verbose ? describeToolUse(call) : undefined, secrets: [cfg.token], startedAt: call.startedAt, durationMs: call.durationMs, error: call.error, meta: journalMeta }));
+  const noteToolStart = (id, name, input) => {
+    if (turnPromptId && shouldJournalCall(name, input, verbose)) calls.begin(id, { name, input });
+  };
+  const noteToolEnd = (id, outcome) => {
+    const call = calls.end(id, outcome);
+    if (call) journalCall(call);
+  };
   // The last message of each session this process has handed to Claude. A session the process has
   // never seen is read whole; after that only what came since — each message enters the warm
   // session's context once. Cleared whenever the process is (re)spawned: a fresh process has read
@@ -2248,10 +2283,16 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
     let msg;
     try { msg = JSON.parse(line); } catch { return; }
 
+    if (msg.type === 'user' && Array.isArray(msg.message?.content)) {
+      for (const block of msg.message.content) if (block.type === 'tool_result') noteToolEnd(block.tool_use_id, { isError: block.is_error });
+      return;
+    }
+
     if (msg.type === 'assistant') {
       for (const block of msg.message?.content ?? []) {
         if (block.type === 'text' && block.text && verbose) log(block.text);
         if (block.type === 'tool_use') {
+          noteToolStart(block.id, block.name, block.input);
           if (verbose) log(`→ ${describeToolUse(block)}`);
           else if (block.name === 'Skill') log(`→ Skill: ${block.input?.skill ?? ''}`);
           else log(`→ ${block.name}`);
@@ -2381,10 +2422,10 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
   log(chat ? 'chat: ON — answering chat messages addressed to this agent' : 'chat: off (--worker)');
   if (exclusive) {
     log(`exclusive: ON — only prompts addressed to ${cfg.agentId} are worked; every untargeted prompt is handed back to the queue`);
-    // A global/standalone run mints its id per run (see resolveModelingCredentials), so an id
-    // someone addressed a prompt to yesterday is not this agent — worth saying out loud here,
+    // A run keeps its stable id unless another live process is already running under it (agent-lock.js), in which
+    // case it got a fresh one — and an id someone addressed a prompt to is not this agent. Worth saying out loud here,
     // where the alternative is an agent that looks healthy and quietly works nothing.
-    if (overrides && !identity.agentId) log('exclusive: this run minted a fresh agent id — star it on the board now, or restart with `--id <uuid>` to keep one addressable identity');
+    if (cfg.agentIdFellBack) log('exclusive: another process is already running under this agent\'s usual id, so this run got a fresh one — star it on the board now, or stop the other process and restart');
   }
   // Both warm-ups are the same bet — pay the session's fixed setup cost before a turn arrives
   // rather than making whoever sends the first prompt wait for it. For a local model that cost
@@ -2420,7 +2461,16 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
       headers: { 'x-token': cfg.token, 'Content-Type': 'application/json', ...agentHeaders(cfg) },
       body: JSON.stringify({ status: 'ADDED' }),
     });
-    if (!res.ok) throw new Error(`prompts/${promptId}/status: HTTP ${res.status}`);
+    if (!res.ok) throw Object.assign(new Error(`prompts/${promptId}/status: HTTP ${res.status}`), { status: res.status });
+  }
+
+  // The prompts the platform shows as held (CLAIMED / IN_PROGRESS) under this agent's id — GET /prompts?claimed_by=,
+  // which reads and claims nothing. At start an agent holds none, so these are what an earlier run left behind.
+  async function fetchHeldPrompts(agentId) {
+    const { url, headers } = heldPromptsRequest({ baseUrl: cfg.baseUrl, organizationId: cfg.organizationId, boardId: cfg.boardId, token: cfg.token, jwt: realtimeToken, agentId });
+    const res = await fetch(url, { headers });
+    if (!res.ok) throw new Error(`prompts list: HTTP ${res.status}`);
+    return ((await res.json()).prompts ?? []).map((p) => ({ id: p.id, status: p.status }));
   }
 
   // ── Chat ───────────────────────────────────────────────────────────────────
@@ -2547,6 +2597,21 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
 
   let realtimeToken = await getRealtimeToken();
 
+  // What this agent writes into its own record: events in the kit, stamped with who and where (learnings: see keepsRecord).
+  const journalMeta = { agent_id: cfg.agentId, agent_type: 'MODELING', organization_id: cfg.organizationId, board_id: cfg.boardId };
+  const journal = (write) => {
+    try { write(); } catch (err) { log(`could not write the prompt journal: ${err.message}`); }
+  };
+
+  // Prompts an earlier run of this agent was holding are still CLAIMED / IN_PROGRESS — the platform never re-queues
+  // them by itself. This run holds none yet, so whatever the platform shows as held under this agent's id goes back.
+  {
+    const recovered = await recoverOwnPrompts({ kitDir, meta: journalMeta, agentId: cfg.agentId, fetchHeld: fetchHeldPrompts, release: releasePrompt });
+    if (recovered.released || recovered.settled || recovered.left) {
+      log(`prompts from an earlier run: ${recovered.released} handed back, ${recovered.settled} already settled${recovered.left ? `, ${recovered.left} left for the next start` : ''}`);
+    }
+  }
+
   let draining = false;
   async function drain() {
     if (draining) return;
@@ -2583,10 +2648,28 @@ async function runModeling(kitDir, projectDir, { codeDir = null, verbose = false
           continue;
         }
         log(`prompt received: "${p.prompt}" (board=${p.board_id ?? cfg.boardId ?? 'n/a'}, priority=${p.priority})`);
+        journal(() => journalPromptReceived({ kitDir, prompt: p, meta: journalMeta }));
         try {
-          await runTurn(buildTurn(p));
+          turnPromptId = p.id;
+          const reply = await runTurn(buildTurn(p));
+          // The agent cannot run `learn` (locked-down Bash), so it states learnings in its reply and they are recorded here.
+          // Best effort: a failed write never takes the prompt queue down.
+          if (keepsRecord) {
+            try {
+              const n = recordTurnLearnings({ kitDir, reply, meta: journalMeta });
+              if (n) log(`recorded ${n} learning${n === 1 ? '' : 's'} from the turn`);
+            } catch (err) {
+              log(`could not record the turn's learnings: ${err.message}`);
+            }
+          }
+          journal(() => journalPromptFinished({ kitDir, id: p.id, outcome: 'worked', meta: journalMeta }));
         } catch (err) {
+          // Not finished: the entry stays open, so the next start asks the platform about it and hands it back
+          // (or closes it if the agent had set DONE before the turn failed).
           log(`turn failed: ${err.message}`);
+        } finally {
+          for (const call of calls.drain()) journalCall(call); // never ended: the turn died mid-call, so no duration
+          turnPromptId = null;
         }
       }
     } finally {
@@ -3203,12 +3286,41 @@ program
 // dir: a modeling run falls back to the global install (see ensureGlobalKit) rather than
 // requiring one here, and the build-kit branch reports a better-targeted error of its own
 // than this generic gate can.
-const NO_INIT_REQUIRED = new Set(['init', 'init-config', 'stacks', 'status', 'config', 'uninstall', 'fetch', 'activate-context', 'set-slice-status', 'release-notes', 'run', 'listen']);
+const NO_INIT_REQUIRED = new Set(['init', 'init-config', 'stacks', 'status', 'config', 'uninstall', 'fetch', 'activate-context', 'set-slice-status', 'release-notes', 'run', 'listen', 'events', 'replay', 'bridge']);
 
 // Commands that install or refresh the kit themselves — a "your kit is outdated" hint in
 // front of them would only be noise.
 const NO_KIT_UPDATE_HINT = new Set(['init', 're-init', 'uninstall']);
 
+// Retired: still recognised, so an old script or muscle memory gets an explanation instead of "unknown option".
+// The hidden options and the `bridge` command exist only to say so; they do nothing else.
+const RETIRED_BASH = [
+  '❌ `run --bash` (the bash-only loop, ralph.sh) has been retired.',
+  '   Its task queue (tasks.json) is now an event log inside the kit, which the bash scripts cannot read or write.',
+  '   Use the default loop instead:  npx @eventmodelers/cli run',
+  '   (add --exec "<command>" to drive another agent harness, or --local-ai for a local model).',
+];
+const RETIRED_BRIDGE = [
+  '❌ The bridge kit (`init --bridge`, `bridge`) has been retired — it ran on the same tasks.json queue, which is now an event log.',
+  '   To hand slices to Spec Kitty, `fetch --spec-kitty` still works on its own, without a standing loop.',
+];
+function retire(lines) {
+  console.error(lines.join('\n'));
+  process.exit(1);
+}
+
+program
+  .command('bridge', { hidden: true })
+  .allowUnknownOption()
+  .allowExcessArguments()
+  .action(() => retire(RETIRED_BRIDGE));
+
+program.hook('preAction', (_thisCommand, actionCommand) => {
+  const o = actionCommand.opts();
+  if (actionCommand.name() === 'run' && o.bash) retire(RETIRED_BASH);
+  if (actionCommand.name() === 'init' && (o.bridge || o.target || o.hook)) retire(RETIRED_BRIDGE);
+});
+
 // Startup hint when this CLI is behind npm, or an installed kit here is behind this CLI.
 // Best effort and on stderr, so it never breaks piped output; EVENTMODELERS_NO_UPDATE_CHECK
 // (or CI) turns it off.
@@ -3228,7 +3340,6 @@ program.hook('preAction', (_thisCommand, actionCommand) => {
   console.error('   Run one of these first:');
   console.error(`     npx @eventmodelers/cli init --stack <name>   (${Object.keys(STACKS).join(', ')})`);
   console.error('     npx @eventmodelers/cli init --modeling');
-  console.error(`     npx @eventmodelers/cli init --bridge --target <name>   (${Object.keys(BRIDGE_TARGETS).join(', ')})`);
   process.exit(1);
 });
 
@@ -3278,15 +3389,15 @@ function identityOverridesFromOpts(opts) {
 credentialFlags(program
   .command('init')
   .alias('install')
-  .description('Scaffold a stack + install the agent kit into the current directory (or --modeling for skills + agent loop only, no backend scaffold; or --bridge to translate board slices into another spec framework; or --build-kit for a blank build-kit scaffold to fill in for a stack not built into this CLI yet; or --git to install a community/custom build kit from a git repo)')
+  .description('Scaffold a stack + install the agent kit into the current directory (or --modeling for skills + agent loop only, no backend scaffold; or --build-kit for a blank build-kit scaffold to fill in for a stack not built into this CLI yet; or --git to install a community/custom build kit from a git repo)')
   .option('--stack <name>', `Stack to install (${Object.keys(STACKS).join(', ')}), or a name of your choosing when combined with --git`)
   .option('--git <url>', 'Install a build kit not built into this CLI by cloning this git repo (used with --stack <name> to name it) — the repo must mirror the templates/.claude, templates/root, templates/<kitSubdir> layout of this CLI\'s own stacks/<name>/templates, optionally with a stack.json declaring label/kitSubdir/useShared/needsBoardId')
   .option('--branch <name>', 'Branch to clone — only meaningful with --git (defaults to the repo\'s default branch)')
-  .option('--modeling', 'Install skills + the agent loop only — no backend scaffold. Mutually exclusive with --stack/--bridge/--build-kit.')
-  .option('--bridge', 'Install a bridge kit — translates board slices into another spec framework instead of building code. Mutually exclusive with --stack/--modeling/--build-kit. Requires --target.')
-  .option('--target <name>', `Bridge target framework (${Object.keys(BRIDGE_TARGETS).join(', ')}) — only meaningful with --bridge`)
-  .option('--hook <command>', 'Persist a default shell command hook for `bridge` to run per batch of slice changes instead of Claude/Ollama (e.g. commit + push .slices/ for a CI pipeline to pick up) — only meaningful with --bridge. Can also be set per-run with `bridge --hook`.')
-  .option('--build-kit', 'Install a blank build-kit scaffold (.build-kit/ + .claude/skills/build-*/SKILL.md placeholders, all TODO-marked) for a stack not built into this CLI yet — no fixed backend. Mutually exclusive with --stack/--modeling/--bridge.')
+  .option('--modeling', 'Install skills + the agent loop only — no backend scaffold. Mutually exclusive with --stack/--build-kit.')
+  .addOption(new Option('--bridge').hideHelp())
+  .addOption(new Option('--target <name>').hideHelp())
+  .addOption(new Option('--hook <command>').hideHelp())
+  .option('--build-kit', 'Install a blank build-kit scaffold (.build-kit/ + .claude/skills/build-*/SKILL.md placeholders, all TODO-marked) for a stack not built into this CLI yet — no fixed backend. Mutually exclusive with --stack/--modeling.')
   .option('--hooks', 'Install the slice commit-scope guard (.githooks/pre-commit, running .build-kit/lib/check-commit-scope.cjs) and wire it up via `git config core.hooksPath .githooks` — only meaningful with --stack (build-kit stacks). Off by default.')
   .option('--demo', 'Install a ready-made demo model into the kit\'s .slices/ — the "Understanding Eventsourcing" context (16 shopping-cart slices covering every slice type), in exactly the shape `fetch` writes, so the build skills and the agent loop have something real to work on before this project is connected to a board. Skipped if .slices/ already holds fetched slices. Off by default.')
   .option('--global', 'Install skills into ~/.claude/skills/ instead of the project — available in every project')
@@ -3296,10 +3407,10 @@ credentialFlags(program
   .action(async (opts, command) => {
     const globalOpts = command.optsWithGlobals();
 
-    if (opts.modeling || opts.bridge || opts.buildKit) {
-      const modeCount = [opts.modeling, opts.bridge, opts.buildKit].filter(Boolean).length;
+    if (opts.modeling || opts.buildKit) {
+      const modeCount = [opts.modeling, opts.buildKit].filter(Boolean).length;
       if (opts.stack || opts.git || modeCount > 1) {
-        console.error('❌ --stack/--git, --modeling, --bridge, and --build-kit are mutually exclusive — pick one.');
+        console.error('❌ --stack/--git, --modeling and --build-kit are mutually exclusive — pick one.');
         process.exit(1);
       }
     }
@@ -3328,38 +3439,6 @@ credentialFlags(program
       return;
     }
 
-    if (opts.bridge) {
-      if (!opts.target) {
-        console.error(`❌ --bridge requires --target (${Object.keys(BRIDGE_TARGETS).join(', ')}).`);
-        process.exit(1);
-      }
-      if (!BRIDGE_TARGETS[opts.target]) {
-        console.error(`❌ Unknown bridge target "${opts.target}". Available: ${Object.keys(BRIDGE_TARGETS).join(', ')}`);
-        process.exit(1);
-      }
-      await installStack(BRIDGE_KIT.key, BRIDGE_KIT, {
-        configPath: globalOpts.config,
-        print: globalOpts.print,
-        global: opts.global,
-        force: opts.force,
-        credentialOverrides: { ...credentialOverridesFromOpts(opts), ...identityOverridesFromOpts(opts) },
-        demo: opts.demo,
-        target: opts.target,
-      });
-      // Deliberately NOT under .bridge-kit/.eventmodelers/ — that whole name is
-      // gitignored (a bare `.eventmodelers` pattern matches at any depth, since
-      // it protects the root credentials file), so anything written there is
-      // per-machine only. target/hookCommand are project policy — how this repo
-      // reacts to board changes — meant to be committed and shared by every
-      // teammate and CI runner, so they live in a plain sibling file instead.
-      const bridgeConfigPath = join(process.cwd(), BRIDGE_KIT.kitDirName, 'bridge.json');
-      const existingBridgeCfg = readJsonSafe(bridgeConfigPath);
-      mkdirSync(dirname(bridgeConfigPath), { recursive: true });
-      writeFileSync(bridgeConfigPath, JSON.stringify({ ...existingBridgeCfg, target: opts.target, ...(opts.hook ? { hookCommand: opts.hook } : {}) }, null, 2));
-      console.log(`  ✓ Bridge target set to "${opts.target}"${opts.hook ? ` with hook: ${opts.hook}` : ''}`);
-      return;
-    }
-
     if (opts.branch && !opts.git) {
       console.error('❌ --branch only applies to --git — nothing to clone without it.');
       process.exit(1);
@@ -3561,13 +3640,11 @@ program
   .description("Run this project's commit-scope checks (.build-kit/lib/check-commit-scope.cjs, the same runner .githooks/pre-commit calls) against the currently staged changeset. Works for any build-kit stack — stacks/installs that ship no checks yet report that and exit 0, so this is safe to call unconditionally (e.g. from an agent loop) without checking the stack first.")
   .action(() => {
     const cwd = process.cwd();
-    // Mirrors `run`'s buildKitDir resolution: modeling-kit/bridge-kit installs share
-    // KIT_DIR_NAMES but never ship check-commit-scope.cjs, so prefer whichever
-    // installed dir isn't one of those over blindly taking the first match.
+    // Mirrors `run`'s buildKitDir resolution: a modeling-kit install shares KIT_DIR_NAMES but never ships
+    // check-commit-scope.cjs, so prefer whichever installed dir isn't the modeling kit.
     const installedKitDirs = findAllInstalledKitDirs(cwd);
     const modelingKitDir = installedKitDirs.find((d) => d.endsWith(MODELING_KIT.kitDirName)) ?? null;
-    const bridgeKitDir = installedKitDirs.find((d) => d.endsWith(BRIDGE_KIT.kitDirName)) ?? null;
-    const kitDir = installedKitDirs.find((d) => d !== modelingKitDir && d !== bridgeKitDir) ?? installedKitDirs[0];
+    const kitDir = installedKitDirs.find((d) => d !== modelingKitDir) ?? installedKitDirs[0];
 
     const checkScript = join(kitDir, 'lib', 'check-commit-scope.cjs');
     if (!existsSync(checkScript)) {
@@ -3702,10 +3779,10 @@ credentialFlags(program
   .command('run')
   .description('Start the agent loop from the installed kit dir — build-kit stacks: ralph-claude.js (default); modeling-kit: --modeling, or --standalone, which needs no install at all')
   .option('--local-ai [target]', `Drive the loop with a local (or self-hosted) model instead of the default Claude runner: a build kit runs it via ralph-local-ai.js, and --modeling/--standalone via lib/modeling-local-ai.js (board tools over MCP, but no skills and no subagent fan-out — those are Claude Code features). Optional target preset picks the URL and wire dialect: ${LOCAL_AI_TARGETS.join(', ')} — bare --local-ai means ollama. Anything OpenAI-compatible (vLLM, LM Studio, llama.cpp, TGI) works by pointing LOCAL_AI_URL at it; see LOCAL_AI_* in the docs. Board work only: --local-ai never builds a Planned slice (no file, shell or git tools). To build code with a local model, use --exec with a coding harness pointed at it, e.g. "codex exec --oss --full-auto". Claude remains the default when this flag is absent.`)
-  .option('--agent [name]', `Pick the agent that does the work by name: ${Object.keys(AGENT_PRESETS).join(', ')}. claude is the default runner; any other is a shortcut for --exec with that harness's headless command filled in — plain-text output for --modeling/--standalone/--worker, JSON output (for agent tracing) for a build kit. Bare --agent lists the agents and the exact command each runs, then stops. Mutually exclusive with --exec, --local-ai and --bash.`)
+  .addOption(new Option('--bash').hideHelp())
+  .option('--agent [name]', `Pick the agent that does the work by name: ${Object.keys(AGENT_PRESETS).join(', ')}. claude is the default runner; any other is a shortcut for --exec with that harness's headless command filled in — plain-text output for --modeling/--standalone/--worker, JSON output (for agent tracing) for a build kit. Bare --agent lists the agents and the exact command each runs, then stops. Mutually exclusive with --exec and --local-ai.`)
   .option('--model <id>', 'The model the agent runs on, for this run only: `-m <id>` on the --agent opencode/codex/gemini command (e.g. opencode/big-pickle, gpt-5-codex, gemini-2.5-pro), `--model <id>` for Claude (overriding `model` from config), LOCAL_AI_MODEL for --local-ai. Not with --exec — put the harness\'s own model flag in the command there.')
   .option('--exec [command]', 'Fallback for any harness --agent does not cover, or other flags than its preset. Hand each prompt to an external agent command instead of the default Claude runner — for agentic harnesses that bring their own tool loop, e.g. "codex exec --full-auto", "gemini --yolo -p" or "opencode run". One process per prompt; the prompt is appended as a quoted argument and also written to the file named by RALPH_PROMPT_FILE. Bare --exec uses localAi.exec from .eventmodelers/config.json. Claude remains the default when this flag is absent. A build kit runs it via ralph-exec.js; there, with agent tracing on, include the harness\'s JSON output flag (codex exec --json, opencode run --format json, gemini --output-format stream-json) — without it no slice cost is recorded. With --modeling/--standalone/--worker it is how any agent takes board prompts and chats: the loop claims each prompt or chat message and runs the command once for it. Keep the harness in its plain-text output mode there — stdout is the turn\'s answer — the eventmodelers MCP server is registered for it on every run (opencode.json, .gemini/settings.json, or -c flags for codex; any other command logs what to register by hand), authenticating with $EVENTMODELERS_TOKEN from the env the command inherits, and `init-agents --hosts <harness>` installs the skills for a harness that does not read .claude/skills. No subagents: self-directed work is done inline.')
-  .option('--bash', 'Use the bash-only ralph.sh loop (build-kit stacks only, no realtime)')
   .option('--modeling', 'Connect a modeling agent to the board: it takes prompts and chat messages and hands each to an AI — by default one Claude process kept warm across prompts, for low-latency voice/live use; --agent (or --local-ai, or --exec as the manual fallback) picks another. Runs from a modeling-kit install in this directory, or from the global install (~/.eventmodelers/kit) when there is none. Built into the CLI, not a per-project file.')
   .option('-f, --force', 'Ask for credentials again before the modeling loop starts, even when a config already has everything required. With a modeling kit in this directory it re-runs the same prompt as `init --modeling`, overwriting the project\'s .eventmodelers/config.json; with the global install it drops the "keep the stored credentials" choice, so a board\'s credentials have to be answered afresh. Applies to build-kit runs too, where it re-asks against the project\'s .eventmodelers/config.json. Cannot be combined with --non-interactive, --print or --local.')
   .option('--non-interactive', 'Never ask anything: take the board and credentials that resolve from flags, EVENTMODELERS_* env vars and the config files, and fail with the reason if they are incomplete instead of interviewing for them. A TTY was previously the only signal — right for CI or a supervisor, wrong for a loop started from a terminal, where stdin is a TTY nobody is watching and the run stops on a question. Only affects the modeling loop (--modeling/--standalone/--worker/--global).')
@@ -3720,7 +3797,7 @@ credentialFlags(program
   .option('--handover', 'Backend build kit: for this run only, finish slices that have a UI at `Handover` instead of `Done` (same as the project setting `handover: true`, which `init --handover` / `config --handover on` save — this flag writes nothing). Without it the project setting applies; without both, slices end at `Done`.')
   .option('--status-trigger <status>', 'Build kit: the slice status the agent picks work up from, for this run only (e.g. Ready, Planned, Handover). Defaults to the kit\'s own pickup status — `Planned` for backend kits, `Handover` for the UI kits. Nothing is written to disk.')
   .option('--verbose', 'Log every tool call\'s full input (commands, skill args, file paths) and assistant reasoning text. Default is condensed, high-level per-step logging only.')
-  .option('--id <id>', 'Pin the agent id this run identifies itself with on the platform. A project install otherwise mints one id per project and reuses it on every restart; --global/--standalone mints a fresh one per run, since two ad-hoc agents for one board must not share a row (the heartbeat is keyed on token + agent_id + agent_type, so the second would replace the first). Pass this when an agent has to keep ONE identity across restarts — a supervisor that already knows the id, or a board where it is the starred "preferred agent". Per-run only: nothing is written to disk.')
+  .option('--id <id>', 'Pin the agent id this run identifies itself with on the platform. Without it an agent keeps one id: a project install per project, a --global/--standalone run per board and repo (the directory it is started in) — the same agent on every restart, with its chat, its star on the board and the prompts it holds. If another live process already runs under that id, this one gets a fresh id instead (two agents must not share a heartbeat row). Pass --id when a supervisor already knows the id you want, or for a second agent on purpose; it is used as given, with no such check. Per-run only: nothing is written to disk.')
   .option('--name <name>', 'A human-readable name for this agent, sent with every heartbeat so the board shows which agent is live rather than a bare uuid (e.g. "ci-builder", "martins-laptop"). Per-run only, like --id: the persistent name is `agentName` in config.json (set via `init --name` / `init-config --name`), and this overrides it for one run without writing anything.')
   .option('--credentials <values>', 'Credentials as the comma-separated blob from app.eventmodelers.ai/account (token=...,boardId=...,organizationId=...,baseUrl=...), the equivalent JSON, or - to read either from stdin. Saved to ~/.eventmodelers/boards/<board>.json, so it is only needed once per board, and passing it skips the first-run question. The individual flags below override single fields of it.'))
   .action(async (opts, command) => {
@@ -3779,11 +3856,6 @@ credentialFlags(program
         process.exit(1);
       }
     }
-    // ralph.sh has no realtime agent and never pings /api/agent-alive, so there is no
-    // identity for either flag to override there.
-    if ((identity.agentId || identity.agentName) && opts.bash) {
-      console.log('ℹ️  --id/--name only apply to agents that ping the platform; the --bash loop does not, so they are ignored here.');
-    }
     // Both kit dirs can be installed side by side (e.g. running a build-kit and a
     // modeling-kit agent from the same project). findInstalledKitDir only ever
     // returns its first fixed-order match, which would silently prefer one stack
@@ -3791,16 +3863,11 @@ credentialFlags(program
     // we resolve each stack's dir independently instead of relying on that order.
     const installedKitDirs = findAllInstalledKitDirs(cwd);
     const modelingKitDir = installedKitDirs.find((d) => d.endsWith(MODELING_KIT.kitDirName)) ?? null;
-    const bridgeKitDir = installedKitDirs.find((d) => d.endsWith(BRIDGE_KIT.kitDirName)) ?? null;
-    // A bridge kit is not a build-kit stand-in even though it also reuses
-    // lib/ralph.js — it has its own `eventmodelers bridge` entrypoint (no
-    // onPlannedSlice/--local-ai/--bash support), so it's excluded here rather
-    // than falling through to the generic build-kit runner below.
-    const buildKitDir = installedKitDirs.find((d) => d !== modelingKitDir && d !== bridgeKitDir) ?? null;
+    const buildKitDir = installedKitDirs.find((d) => d !== modelingKitDir) ?? null;
 
     // No overlap between the two stacks' runtimes: modeling-kit only ever runs the
     // warm, direct-dispatch loop (--modeling); build-kit only ever runs the
-    // cold-spawn/tasks.json loop (default, or --local-ai/--bash). Neither falls back
+    // cold-spawn/task-queue loop (default, or --local-ai/--exec). Neither falls back
     // to the other's mechanism, so each side is gated explicitly below rather than
     // just being left to fail on a missing file.
     // --standalone implies --modeling: it already refused every other runner, so there
@@ -3809,14 +3876,8 @@ credentialFlags(program
     // no meaning for a build kit, which is scaffolded per project by definition.
     if (opts.modeling || opts.standalone || opts.worker || opts.global) {
       const picked = opts.modeling ? '--modeling' : opts.standalone ? '--standalone' : opts.worker ? '--worker' : '--global';
-      // --bash stays build-kit only: it is the bash tasks.json loop, which the modeling loop has
-      // no equivalent of. --local-ai and --exec are different — they name what does a turn, not a
-      // queue, and the modeling loop has its own runner for each (lib/modeling-local-ai.js,
-      // lib/modeling-exec.js).
-      if (opts.bash) {
-        console.error(`❌ ${picked} is mutually exclusive with --bash — that selects a build-kit runner, which the modeling loop has no use for.`);
-        process.exit(1);
-      }
+      // --local-ai and --exec name what does a turn, not a queue, and the modeling loop has its own
+      // runner for each (lib/modeling-local-ai.js, lib/modeling-exec.js).
       const modelingLocalAi = resolveLocalAiTarget(opts);
       if (modelingLocalAi !== null && opts.exec) {
         console.error('❌ --local-ai and --exec are mutually exclusive — pick one runner.');
@@ -3865,6 +3926,13 @@ credentialFlags(program
           ...Object.fromEntries(Object.entries(credentialOverridesFromOpts(opts)).filter(([, v]) => v)),
         };
         const config = await resolveModelingCredentials(cwd, flags, globalOpts.config, globalOpts.print, !!opts.nonInteractive, !!opts.force);
+        // The stable id of this board and repo — unless `--id` pins another, or a live process already runs under it,
+        // in which case this run gets a fresh one (agent-lock.js).
+        if (!identity.agentId) {
+          const { agentId, fellBack } = acquireAgentId({ lockDir: join(GLOBAL_DIR, 'locks'), stableId: config.agentId });
+          config.agentId = agentId;
+          config.agentIdFellBack = fellBack;
+        }
         projectDir = await ensureGlobalKit(config.baseUrl);
         kitDir = join(projectDir, MODELING_KIT.kitDirName);
         overrides = config;
@@ -3896,6 +3964,7 @@ credentialFlags(program
       // right after (dynamic imports, config reads) can eat the event-loop tick this write
       // needed to drain, so a piped watcher sees the ping arrive after runModeling's own
       // [modeling] log lines instead of before them.
+      await offerPrune(kitDir, { interactive: !globalOpts.print && !opts.nonInteractive && !!process.stdin.isTTY });
       const shown = relative(cwd, kitDir);
       const runnerLabel = modelingLocalAi ? 'local model' : opts.exec ? 'one agent process per turn' : 'warm Claude process';
       await new Promise((res) => process.stdout.write(`▶ Starting modeling loop (${runnerLabel}) for ${shown && !shown.startsWith('..') ? shown : kitDir}...\n\n`, res));
@@ -3910,9 +3979,7 @@ credentialFlags(program
 
     if (!buildKitDir) {
       if (modelingKitDir) {
-        console.error(`❌ A modeling-kit install (${MODELING_KIT.kitDirName}/) only runs via \`eventmodelers run --modeling\` — there is no cold-spawn/tasks.json loop for modeling-only projects.`);
-      } else if (bridgeKitDir) {
-        console.error(`❌ A bridge-kit install (${BRIDGE_KIT.kitDirName}/) only runs via \`eventmodelers bridge\` — it has no --modeling/--local-ai/--bash modes.`);
+        console.error(`❌ A modeling-kit install (${MODELING_KIT.kitDirName}/) only runs via \`eventmodelers run --modeling\` — there is no cold-spawn/task-queue loop for modeling-only projects.`);
       } else {
         console.error(`❌ No kit installed in ${cwd} — run \`eventmodelers install\` first.`);
         console.error('   (A modeling agent needs no install at all: eventmodelers run --standalone --board-id <uuid>)');
@@ -3922,17 +3989,19 @@ credentialFlags(program
     const kitDir = buildKitDir;
 
     const localAiTarget = resolveLocalAiTarget(opts);
-    const pickedCount = [opts.bash, localAiTarget !== null, !!opts.exec].filter(Boolean).length;
+    const pickedCount = [localAiTarget !== null, !!opts.exec].filter(Boolean).length;
     if (pickedCount > 1) {
-      console.error('❌ --bash, --local-ai and --exec are mutually exclusive — pick one runner.');
+      console.error('❌ --local-ai and --exec are mutually exclusive — pick one runner.');
       process.exit(1);
     }
 
+    await offerPrune(kitDir, { interactive: !globalOpts.print && !opts.nonInteractive && !!process.stdin.isTTY });
+
     // The actual agent loop lives in the scaffolded kit dir, not in this package — this
     // is just a thin dispatcher so users don't have to remember the kit-dir name or which
     // runner file to invoke. Users (and the agent itself, via AGENT.md) may customize these
     // files freely; `run` always executes whatever is currently on disk.
-    const runner = opts.bash ? 'ralph.sh' : opts.exec ? 'ralph-exec.js' : localAiTarget !== null ? 'ralph-local-ai.js' : 'ralph-claude.js';
+    const runner = opts.exec ? 'ralph-exec.js' : localAiTarget !== null ? 'ralph-local-ai.js' : 'ralph-claude.js';
     const runnerPath = join(kitDir, runner);
     if (!existsSync(runnerPath)) {
       console.error(`❌ ${relative(cwd, runnerPath)} not found.`);
@@ -3983,77 +4052,16 @@ credentialFlags(program
     console.log(`▶ Starting ${relative(cwd, runnerPath)}...\n`);
     const cmd = runner.endsWith('.sh') ? `"${runnerPath}"` : `node "${runnerPath}"`;
     try {
-      // Only ralph-claude.js reads RALPH_VERBOSE — the bash loop and the local-AI executor have
-      // their own separate output paths with no stream-json parsing to gate. RALPH_LOCAL is
-      // read by all three runners (ralph.js's startRalph, and ralph.sh directly) to force the
-      // local-only branch even when .eventmodelers/config.json has valid credentials.
-      // RALPH_AGENT_ID/RALPH_AGENT_NAME (--id/--name) are read in ralph.js's startRalph, so
-      // they reach both node runners but not ralph.sh, which has no heartbeat to identify.
+      // Only ralph-claude.js reads RALPH_VERBOSE — the local-AI executor has its own separate output
+      // path with no stream-json parsing to gate. RALPH_LOCAL is read by ralph.js's startRalph to force
+      // the local-only branch even when .eventmodelers/config.json has valid credentials.
+      // RALPH_AGENT_ID/RALPH_AGENT_NAME (--id/--name) are read there too.
       execSync(cmd, { cwd: kitDir, stdio: 'inherit', env: { ...process.env, RALPH_VERBOSE: opts.verbose ? '1' : '', RALPH_LOCAL: opts.local ? '1' : '', RALPH_HANDOVER: opts.handover ? '1' : '', RALPH_STATUS_TRIGGER: opts.statusTrigger ? String(opts.statusTrigger).trim() : '', RALPH_AGENT_ID: identity.agentId ?? '', RALPH_AGENT_NAME: identity.agentName ?? '', ...(typeof localAiTarget === 'string' ? { LOCAL_AI_TARGET: localAiTarget } : {}), ...(typeof opts.exec === 'string' ? { RALPH_EXEC_CMD: opts.exec } : {}) } });
     } catch (err) {
       process.exit(err.status || 1);
     }
   });
 
-program
-  .command('bridge')
-  .description('Start the bridge agent loop from the installed .bridge-kit/ — translates board slice changes into another spec framework instead of building code. A deterministic adapter runs with no LLM call if one exists for the configured target (e.g. spec-kitty); otherwise Claude is the default executor. --local-ai, --hook, or --claude override the pick.')
-  .option('--local-ai [target]', `Use ralph-local-ai.js instead of the default runner — a local or self-hosted model. Optional target preset: ${LOCAL_AI_TARGETS.join(', ')} (bare flag means ollama).`)
-  .option('--hook <command>', 'Run this shell command instead of an AI agent for each batch of slice changes (e.g. commit + push .slices/ for a CI pipeline to pick up) — overrides any hook persisted via `init --bridge --hook` for this run only')
-  .option('--claude', 'Force the Claude runner even if a static adapter exists for this target')
-  .action((opts) => {
-    const cwd = process.cwd();
-    const kitDir = findAllInstalledKitDirs(cwd).find((d) => d.endsWith(BRIDGE_KIT.kitDirName)) ?? null;
-    if (!kitDir) {
-      console.error(`❌ No bridge-kit installed in ${cwd} — run \`eventmodelers init --bridge --target <name>\` first.`);
-      process.exit(1);
-    }
-
-    const localAiTarget = resolveLocalAiTarget(opts);
-    if ([localAiTarget !== null, opts.hook, opts.claude].filter(Boolean).length > 1) {
-      console.error('❌ --local-ai, --hook, and --claude are mutually exclusive — pick one executor.');
-      process.exit(1);
-    }
-
-    // A persisted default (from `init --bridge --hook`) lives in bridge.json, a
-    // plain sibling file — NOT under .eventmodelers/, which is gitignored (see
-    // the comment in `init`'s --bridge branch) and would otherwise make this
-    // per-machine instead of a shared, checked-in team/CI convention.
-    const bridgeCfg = readJsonSafe(join(kitDir, 'bridge.json'));
-    const persistedHook = bridgeCfg.hookCommand;
-    const hookCmd = opts.hook || persistedHook;
-
-    // A static adapter (adapters/<target>-adapter.js, e.g. spec-kitty-adapter.js)
-    // is deterministic and costs no LLM call, so it wins over the Claude default
-    // whenever one exists for the configured target — --claude opts back out.
-    const staticAdapterPath = join(kitDir, 'adapters', `${bridgeCfg.target}-adapter.js`);
-    const hasStaticAdapter = bridgeCfg.target && existsSync(staticAdapterPath);
-
-    const runner = hookCmd
-      ? 'ralph-hook.js'
-      : localAiTarget !== null
-        ? 'ralph-local-ai.js'
-        : !opts.claude && hasStaticAdapter
-          ? 'ralph-static.js'
-          : 'ralph-claude.js';
-    const runnerPath = join(kitDir, runner);
-    if (!existsSync(runnerPath)) {
-      console.error(`❌ ${relative(cwd, runnerPath)} not found.`);
-      process.exit(1);
-    }
-
-    console.log(`▶ Starting ${relative(cwd, runnerPath)}${hookCmd ? ` (hook: ${hookCmd})` : ''}...\n`);
-    try {
-      execSync(`node "${runnerPath}"`, {
-        cwd: kitDir,
-        stdio: 'inherit',
-        env: hookCmd ? { ...process.env, BRIDGE_HOOK_CMD: hookCmd } : process.env,
-      });
-    } catch (err) {
-      process.exit(err.status || 1);
-    }
-  });
-
 program
   .command('listen')
   .description('Start the code-export listener (code-export.mjs) from the installed kit dir, or the bundled copy when no kit is installed — receives slice/screen data pushed from the eventmodelers board UI and writes it into .slices/')
@@ -4360,6 +4368,236 @@ program
     console.log(`✅ Pushed status change to the board (node ${slice.id}).`);
   });
 
+// The kit a command that records events works against: a build kit if one is installed, else the modeling
+// kit. The build kit wins when both are installed — the modeling agent never runs these commands itself
+// (its Bash is an allowlist); it states its learnings in its reply and `runModeling` records them.
+function requireBuildKitDir(cwd) {
+  const installed = findAllInstalledKitDirs(cwd);
+  const kitDir = installed.find((d) => !d.endsWith(MODELING_KIT.kitDirName)) ?? installed.find((d) => d.endsWith(MODELING_KIT.kitDirName));
+  if (!kitDir) {
+    console.error('❌ This command needs a build or modeling kit (npx @eventmodelers/cli init --stack <name> or init --modeling).');
+    process.exit(1);
+  }
+  return kitDir;
+}
+
+// What the build agent's events are stamped with: the loop exports the agent id into its environment.
+function agentEventMeta(cwd, kitDir, command) {
+  const { config: cfg } = loadEffectiveConfig(cwd, kitDir, command.optsWithGlobals().config);
+  return {
+    agent_id: process.env.RALPH_AGENT_ID || process.env.EVENTMODELERS_AGENT_ID,
+    agent_type: 'BUILD', // `learn` and `slice-status` are the build agent's commands
+    organization_id: cfg.organizationId,
+    board_id: cfg.boardId,
+  };
+}
+
+program
+  .command('slice-status <status>')
+  .description("For a build agent: record the outcome of the slice the run loop is building (Done, Handover, Blocked, ...). The loop owns the slice's status on the board and pushes it when the build ends — never edit index.json or call update-slice-status for a loop build.")
+  .option('--slice <idOrTitle>', 'The slice, when the loop has claimed more than one (default: the one it is building)')
+  .action((status, opts, command) => {
+    const cwd = process.cwd();
+    const canonical = SLICE_STATUSES.find((s) => s.value.toLowerCase() === status.toLowerCase())?.value;
+    if (!canonical) {
+      console.error(`❌ "${status}" is not a slice status. Valid: ${SLICE_STATUSES.map((s) => s.value).join(', ')}`);
+      process.exit(1);
+    }
+    const kitDir = requireBuildKitDir(cwd);
+    const meta = agentEventMeta(cwd, kitDir, command);
+    try {
+      const result = recordAgentStatus({ kitDir, status: canonical, sliceId: opts.slice, meta });
+      console.log(`✅ "${result.title}": recorded ${result.status} — the run loop pushes it to the board when the build ends.`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('learn [text]')
+  .description("For a build agent: record one reusable learning (a codebase pattern, a gotcha, a command that works or doesn't, what a failed approach tried and why it failed). .build-kit/AGENTS.md is generated from the recorded learnings — never edit it by hand. --retract withdraws a wrong or obsolete one (ids: `learnings --ids`).")
+  .option('--topic <topic>', 'Group the learning under this heading in AGENTS.md')
+  .option('--tag <tag>', 'Label the learning (repeatable)', (tag, tags) => [...tags, tag], [])
+  .option('--scope <scope>', 'system: true of the modeled domain · repo: about the codebase and its tooling (default repo)')
+  .option('--slice <slice>', 'The slice it was learned on')
+  .option('--retract <id>', 'Withdraw the learning with this id (or a unique prefix of it) instead of recording one')
+  .option('--merge <ids>', 'Replace these learnings (comma-separated ids) by one with the given text — the curator\'s tool')
+  .option('--reason <reason>', 'Why — recorded with a retraction or a merge')
+  .action((text, opts, command) => {
+    const cwd = process.cwd();
+    const kitDir = requireBuildKitDir(cwd);
+    const meta = agentEventMeta(cwd, kitDir, command);
+    try {
+      if (opts.retract !== undefined) {
+        const gone = retractLearning({ kitDir, id: opts.retract, reason: opts.reason, meta });
+        console.log(`✅ Retracted: ${gone.text}`);
+        return;
+      }
+      if (opts.merge !== undefined) {
+        const ids = opts.merge.split(',').map((id) => id.trim()).filter(Boolean);
+        const merged = mergeLearnings({ kitDir, ids, text, topic: opts.topic, scope: opts.scope, tags: opts.tag, reason: opts.reason, meta });
+        console.log(`✅ Merged ${ids.length} learnings into one (${merged.id.slice(0, 8)}).`);
+        return;
+      }
+      if (text === undefined) throw new Error('give the learning as text, or --retract <id>, or --merge <ids> <text>');
+      // The curator may only merge and retract — an LLM asked to tidy must not add facts of its own.
+      if (process.env.EVENTMODELERS_CURATING === '1') throw new Error('a curation turn only merges and retracts — new learnings are not recorded during it');
+      const result = recordLearning({ kitDir, text, topic: opts.topic, tags: opts.tag, scope: opts.scope ?? 'repo', slice: opts.slice, meta });
+      console.log(result.duplicate ? `ℹ️  Already recorded (${result.id.slice(0, 8)}) — nothing to add.` : `✅ Recorded (${result.id.slice(0, 8)}) — .build-kit/AGENTS.md is updated.`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('events')
+  .description("Decode a kit's event log in the terminal: one line per event (claims, settles, learnings, tasks, prompts …) with the slice's title and the agent that wrote it. Filter it, print the raw events, or print the state the log folds to.")
+  .option('--kit <dir>', "Read this kit directory's log (default: the build kit of the current project, else its modeling kit)")
+  .option('--global', 'Read the log of the global install (~/.eventmodelers/kit) — what runs started without a project install wrote')
+  .option('--board <id>', "Only events stamped with this board (an id prefix) — the global install's log mixes every board")
+  .option('--type <types>', 'Only these event types, comma-separated (e.g. claimed,settled)')
+  .option('--slice <slice>', 'Only events of the slice with this id (prefix) or a title containing this text')
+  .option('--tag <tag>', 'Only events carrying this tag')
+  .option('--last <n>', 'Only the last n events (after the other filters)')
+  .option('--json', 'Print the raw events, one JSON object per line')
+  .option('--verbose', 'Print each event\'s payload under its line — for a tool call, the input it was sent (recorded by runs started with --verbose)')
+  .option('--state', 'Print the state the log folds to (slices, queue, open prompts, learnings) instead of the events')
+  .option('--prune', 'Delete the events nothing reads any more — the journal of finished prompts — and stop. Slice state, learnings and open prompts are kept; the same prune a run offers at every 1000 events.')
+  .option('--follow', 'Keep running and print events as they are appended')
+  .option('--watch', 'Same as --follow')
+  .action(async (opts) => {
+    const cwd = process.cwd();
+    if (opts.global && opts.kit) {
+      console.error('❌ --global and --kit are alternatives — pick one.');
+      process.exit(1);
+    }
+    const globalLog = join(GLOBAL_KIT_DIR, MODELING_KIT.kitDirName);
+    const kitDir = opts.global ? globalLog : opts.kit ? resolve(cwd, opts.kit) : requireBuildKitDir(cwd);
+    if (opts.prune) {
+      try {
+        const { removed, kept } = pruneLog(kitDir);
+        rememberPruneAnswer(kitDir, kept);
+        console.log(removed ? `Pruned ${removed} events, ${kept} left.` : `Nothing to prune — ${kept} events, all of them carry state.`);
+      } catch (err) {
+        console.error(`❌ ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+    let last;
+    if (opts.last !== undefined) {
+      last = Number(opts.last);
+      if (!Number.isInteger(last) || last < 1) {
+        console.error('❌ --last needs a positive number.');
+        process.exit(1);
+      }
+    }
+    const filter = { types: opts.type?.split(',').map((t) => t.trim()).filter(Boolean), slice: opts.slice, tag: opts.tag, board: opts.board };
+    const color = process.stdout.isTTY && !process.env.NO_COLOR;
+    const paint = (code, text) => (color ? `\x1b[${code}m${text}\x1b[0m` : text);
+    const family = (type) => (/^(claim|settled|agent-recorded|task-done|prompt-finished)/.test(type) ? '32' : /^(attempt-failed|blocked|released)/.test(type) ? '31' : /^(learning|learnings)/.test(type) ? '36' : /^(prompt|task)/.test(type) ? '35' : '33');
+    const print = (events, titles) => {
+      for (const e of events) {
+        if (opts.json) { console.log(JSON.stringify(e)); continue; }
+        const [time, ...rest] = formatEvent(e, { titles }).split('  ');
+        const type = rest.shift();
+        console.log([paint('2', time), paint(family(e.type), type), ...rest].join('  '));
+        if (opts.verbose) { const payload = formatPayload(e); if (payload) console.log(paint('2', payload)); }
+      }
+    };
+
+    const follow = opts.follow || opts.watch;
+    const events = readEvents(kitDir);
+    const titles = sliceTitles(events);
+    if (opts.state) {
+      if (follow) console.error('ℹ️  --follow/--watch does not apply to --state.');
+      console.log(events.length ? summarize(fold(events), titles) : 'No events yet in this kit.');
+      return;
+    }
+    if (!events.length && !follow) {
+      console.log(`No events yet in ${opts.global ? '~/.eventmodelers/kit' : relative(cwd, kitDir) || kitDir}.`);
+      // Runs started without a project install keep their log in the global kit — say so when it has one.
+      if (!opts.global && !opts.kit && readEvents(globalLog).length) console.log('The global install has a log of its own: `eventmodelers events --global`.');
+      return;
+    }
+    print(filterEvents(events, { ...filter, last }, titles), titles);
+    if (!follow) return;
+
+    // Follow: what has been printed is remembered by event id, and the log is read again twice a second.
+    const seen = new Set(events.map((e) => e.id));
+    setInterval(() => {
+      const all = readEvents(kitDir);
+      const fresh = all.filter((e) => !seen.has(e.id));
+      for (const e of fresh) seen.add(e.id);
+      if (fresh.length) print(filterEvents(fresh, filter, sliceTitles(all)), sliceTitles(all));
+    }, 500);
+  });
+
+program
+  .command('replay <id>')
+  .description("Submit a prompt from the event log again: puts it back on its board's queue as a new prompt, with the same text, node, comment, priority and canvas context, for an agent to work. <id> is a prompt id from `events` (a unique prefix will do). Writes to the platform.")
+  .option('--kit <dir>', "Read this kit directory's log (default: the build kit of the current project, else its modeling kit)")
+  .option('--global', 'Read the log of the global install (~/.eventmodelers/kit)')
+  .option('--dry-run', 'Show the request that would be sent and stop — nothing is submitted')
+  .option('--token <uuid>', 'API token (overrides config file / env var)')
+  .option('--organization-id <uuid>', 'Organization ID (overrides config file / env var)')
+  .option('--base-url <url>', 'Platform base URL (overrides config file / env var)')
+  .action(async (id, opts) => {
+    const cwd = process.cwd();
+    if (opts.global && opts.kit) {
+      console.error('❌ --global and --kit are alternatives — pick one.');
+      process.exit(1);
+    }
+    const kitDir = opts.global ? join(GLOBAL_KIT_DIR, MODELING_KIT.kitDirName) : opts.kit ? resolve(cwd, opts.kit) : requireBuildKitDir(cwd);
+    try {
+      const event = findPromptEvent(readEvents(kitDir), id);
+      const boardId = event.prompt.board_id ?? event.meta?.board_id;
+      // The credentials of the board the prompt was for: flags and env vars over the board's own file over the account's.
+      const stored = boardId ? readJsonSafe(boardCredentialsPath(boardId)) : {};
+      const explicit = Object.fromEntries(Object.entries(credentialOverridesFromOpts(opts)).filter(([, v]) => v));
+      const cfg = applyEnvOverrides({ ...loadEffectiveConfig(cwd, null, null).config, ...(stored.useGlobal || stored.useBoard ? {} : stored), ...explicit });
+      cfg.baseUrl = cfg.baseUrl || DEFAULT_BASE_URL;
+      if (!cfg.token || !cfg.organizationId) throw new Error('no credentials for this board — pass --token/--organization-id, or run the agent once for it');
+
+      const tokenRes = await fetch(`${cfg.baseUrl}/api/org/${cfg.organizationId}/prompts/realtime-token`, { headers: { 'x-token': cfg.token } });
+      if (!tokenRes.ok) throw new Error(`realtime-token: HTTP ${tokenRes.status}`);
+      const { url, headers, body } = replayRequest({ baseUrl: cfg.baseUrl, organizationId: cfg.organizationId, token: cfg.token, jwt: (await tokenRes.json()).token, event: { ...event, prompt: { ...event.prompt, board_id: boardId } } });
+      if (opts.dryRun) {
+        console.log(`POST ${url}\n${JSON.stringify(body, null, 2)}`);
+        return;
+      }
+      const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+      if (!res.ok) throw new Error(`prompts: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`);
+      const created = await res.json();
+      console.log(`Re-submitted prompt ${String(event.prompt.id).slice(0, 8)} as ${String(created.id ?? '').slice(0, 8)}: "${event.prompt.text.length > 80 ? `${event.prompt.text.slice(0, 79)}…` : event.prompt.text}"`);
+    } catch (err) {
+      console.error(`❌ ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('learnings')
+  .description('Print the recorded learnings — what .build-kit/AGENTS.md says. With --ids, one line each with the id to retract it by.')
+  .option('--ids', 'One line per learning: id, topic, text')
+  .action((opts, command) => {
+    const cwd = process.cwd();
+    const kitDir = requireBuildKitDir(cwd);
+    syncLearnings({ kitDir, meta: agentEventMeta(cwd, kitDir, command) });
+    const all = listLearnings(kitDir);
+    if (!all.length) {
+      console.log('No learnings recorded yet.');
+      return;
+    }
+    if (!opts.ids) {
+      console.log(readFileSync(join(kitDir, 'AGENTS.md'), 'utf-8').trimEnd());
+      return;
+    }
+    for (const l of all) console.log(`  ${l.id.slice(0, 8)}  [${l.topic ?? 'General'}]  ${l.text}`);
+  });
+
 program
   .command('stacks')
   .description('List available stacks (for `init --stack`)')
@@ -4455,16 +4693,14 @@ program
   .description('Remove everything init (with or without --modeling) installed: the kit dir, the skills it copied (project-local or ~/.claude/skills with --global), its MCP entry in .claude/settings.json, and any files written by init-agents. Leaves the root project scaffold untouched.')
   .option('--build-kit', `Remove ${STACKS.node.kitDirName}/ (the backend-stack kit dir)`)
   .option('--modeling-kit', `Remove ${MODELING_KIT.kitDirName}/ (the modeling-only kit dir)`)
-  .option('--bridge-kit', `Remove ${BRIDGE_KIT.kitDirName}/ (the bridge kit dir)`)
   .action((opts) => {
     const cwd = process.cwd();
     let targets;
 
-    if (opts.buildKit || opts.modelingKit || opts.bridgeKit) {
+    if (opts.buildKit || opts.modelingKit) {
       targets = [];
       if (opts.buildKit) targets.push(join(cwd, STACKS.node.kitDirName));
       if (opts.modelingKit) targets.push(join(cwd, MODELING_KIT.kitDirName));
-      if (opts.bridgeKit) targets.push(join(cwd, BRIDGE_KIT.kitDirName));
       targets = targets.filter((p) => existsSync(p));
       if (!targets.length) {
         console.log('ℹ️  Nothing to remove for the requested option(s).');
@@ -4477,7 +4713,7 @@ program
         return;
       }
       if (targets.length > 1) {
-        console.log('⚠️  Multiple kit dirs found — re-run with --build-kit, --modeling-kit, and/or --bridge-kit to pick which to remove.');
+        console.log('⚠️  Multiple kit dirs found — re-run with --build-kit and/or --modeling-kit to pick which to remove.');
         targets.forEach((t) => console.log(`     ${t}`));
         return;
       }