let-them-talk 5.4.3 → 5.5.3

package/package.json

@@ -1,113 +1,114 @@
-{
-  "name": "let-them-talk",
-  "version": "5.4.3",
-  "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
-  "main": "server.js",
-  "bin": {
-    "agent-bridge": "./cli.js",
-    "let-them-talk": "./cli.js"
-  },
-  "scripts": {
-    "start": "node server.js",
-    "dashboard": "node dashboard.js",
-    "export:markdown-workspace": "node scripts/export-markdown-workspace.js",
-    "sync:packaged-docs": "node scripts/sync-packaged-docs.js",
-    "prepack": "npm run sync:packaged-docs",
-    "test": "npm run verify",
-    "verify": "npm run verify:contracts && npm run verify:replay && npm run verify:invariants",
-    "verify:docs-onboarding": "node scripts/check-docs-onboarding.js",
-    "verify:contracts": "npm run verify:contracts:runtime && npm run verify:contracts:schema && npm run verify:contracts:branches && npm run verify:contracts:markdown-workspace",
-    "verify:contracts:runtime": "node scripts/check-runtime-contract.js",
-    "verify:contracts:schema": "node scripts/check-event-schema.js",
-    "verify:contracts:branches": "node scripts/check-branch-semantics.js",
-    "verify:contracts:markdown-workspace": "node scripts/check-markdown-workspace.js",
-    "verify:replay": "npm run verify:replay:positive && npm run verify:replay:negative",
-    "verify:replay:positive": "npm run verify:replay:healthy && npm run verify:replay:clean",
-    "verify:replay:healthy": "node scripts/check-message-replay.js --scenario healthy",
-    "verify:replay:clean": "node scripts/check-message-replay.js --scenario clean",
-    "verify:replay:negative": "node scripts/run-verification-suite.js replay-negative",
-    "verify:invariants": "npm run verify:invariants:authority && npm run verify:invariants:dashboard-control-plane && npm run verify:invariants:performance-indexing && npm run verify:invariants:capabilities && npm run verify:invariants:api-agent-parity && npm run verify:invariants:dashboard-semantic-gap && npm run verify:invariants:migration-hardening && npm run verify:invariants:branches && npm run verify:invariants:sessions && npm run verify:invariants:evidence && npm run verify:invariants:context && npm run verify:invariants:autonomy-v2 && npm run verify:invariants:autonomy-v2-watchdog && npm run verify:invariants:autonomy-v2-execution && npm run verify:invariants:agent-contracts && npm run verify:invariants:managed-team-integration && npm run verify:invariants:lifecycle-hooks && npm run verify:invariants:markdown-workspace-export && npm run verify:invariants:markdown-workspace-safety",
-    "verify:invariants:authority": "node scripts/check-invariants.js --suite authority",
-    "verify:invariants:dashboard-control-plane": "node scripts/check-dashboard-control-plane.js",
-    "verify:invariants:performance-indexing": "node scripts/check-performance-indexing.js",
-    "verify:invariants:capabilities": "node scripts/check-provider-capabilities.js",
-    "verify:invariants:api-agent-parity": "node scripts/check-api-agent-parity.js",
-    "verify:invariants:dashboard-semantic-gap": "node scripts/run-verification-suite.js dashboard-semantic-gap",
-    "verify:invariants:migration-hardening": "node scripts/check-migration-hardening.js",
-    "verify:invariants:branches": "node scripts/check-branch-isolation.js && node scripts/check-branch-fork-snapshot.js",
-    "verify:invariants:branch-fork": "node scripts/check-branch-fork-snapshot.js",
-    "verify:invariants:sessions": "node scripts/check-session-lifecycle.js",
-    "verify:invariants:evidence": "node scripts/check-evidence-completion.js",
-    "verify:invariants:context": "node scripts/check-session-aware-context.js",
-    "verify:invariants:autonomy-v2": "node scripts/check-autonomy-v2-decision.js",
-    "verify:invariants:autonomy-v2-watchdog": "node scripts/check-autonomy-v2-watchdog.js",
-    "verify:invariants:autonomy-v2-execution": "node scripts/check-autonomy-v2-execution.js",
-    "verify:invariants:agent-contracts": "node scripts/check-agent-contract-advisory.js",
-    "verify:invariants:managed-team-integration": "node scripts/check-managed-team-integration.js",
-    "verify:invariants:lifecycle-hooks": "node scripts/check-lifecycle-hooks.js",
-    "verify:invariants:markdown-workspace-export": "node scripts/check-markdown-workspace-export.js",
-    "verify:invariants:markdown-workspace-safety": "node scripts/check-markdown-workspace-safety.js",
-    "verify:smoke": "node scripts/run-verification-suite.js smoke"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "data-dir.js",
-    "server.js",
-    "dashboard.js",
-    "dashboard.html",
-    "api-agents.js",
-    "runtime-descriptor.js",
-    "agent-contracts.js",
-    "managed-team-integration.js",
-    "autonomy/",
-    "events/",
-    "state/",
-    "providers/",
-    "office/",
-    "mods/",
-    "scripts/",
-    "docs/",
-    "USAGE.md",
-    "cli.js",
-    "templates/",
-    "conversation-templates/",
-    "logo.png",
-    "LICENSE",
-    "SECURITY.md",
-    "CHANGELOG.md"
-  ],
-  "keywords": [
-    "mcp",
-    "claude",
-    "claude-code",
-    "gemini-cli",
-    "codex-cli",
-    "agent",
-    "multi-agent",
-    "communication",
-    "message-broker",
-    "ai-agents",
-    "let-them-talk"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Dekelelz/let-them-talk.git"
-  },
-  "homepage": "https://talk.unrealai.studio",
-  "bugs": {
-    "url": "https://github.com/Dekelelz/let-them-talk/issues"
-  },
-  "author": "Dekelelz <contact@talk.unrealai.studio>",
-  "license": "SEE LICENSE IN LICENSE",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "three": "0.175.0"
-  },
-  "overrides": {
-    "hono": "^4.12.14",
-    "path-to-regexp": "^8.4.2",
-    "@hono/node-server": "^1.19.14"
-  }
-}
+{
+  "name": "let-them-talk",
+  "version": "5.5.3",
+  "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
+  "main": "server.js",
+  "bin": {
+    "agent-bridge": "./cli.js",
+    "let-them-talk": "./cli.js"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "dashboard": "node dashboard.js",
+    "export:markdown-workspace": "node scripts/export-markdown-workspace.js",
+    "sync:packaged-docs": "node scripts/sync-packaged-docs.js",
+    "prepack": "npm run sync:packaged-docs",
+    "test": "npm run verify",
+    "verify": "npm run verify:contracts && npm run verify:replay && npm run verify:invariants",
+    "verify:docs-onboarding": "node scripts/check-docs-onboarding.js",
+    "verify:contracts": "npm run verify:contracts:runtime && npm run verify:contracts:schema && npm run verify:contracts:branches && npm run verify:contracts:markdown-workspace",
+    "verify:contracts:runtime": "node scripts/check-runtime-contract.js",
+    "verify:contracts:schema": "node scripts/check-event-schema.js",
+    "verify:contracts:branches": "node scripts/check-branch-semantics.js",
+    "verify:contracts:markdown-workspace": "node scripts/check-markdown-workspace.js",
+    "verify:replay": "npm run verify:replay:positive && npm run verify:replay:negative",
+    "verify:replay:positive": "npm run verify:replay:healthy && npm run verify:replay:clean",
+    "verify:replay:healthy": "node scripts/check-message-replay.js --scenario healthy",
+    "verify:replay:clean": "node scripts/check-message-replay.js --scenario clean",
+    "verify:replay:negative": "node scripts/run-verification-suite.js replay-negative",
+    "verify:invariants": "npm run verify:invariants:authority && npm run verify:invariants:dashboard-control-plane && npm run verify:invariants:performance-indexing && npm run verify:invariants:capabilities && npm run verify:invariants:api-agent-parity && npm run verify:invariants:dashboard-semantic-gap && npm run verify:invariants:migration-hardening && npm run verify:invariants:branches && npm run verify:invariants:sessions && npm run verify:invariants:evidence && npm run verify:invariants:context && npm run verify:invariants:autonomy-v2 && npm run verify:invariants:autonomy-v2-watchdog && npm run verify:invariants:autonomy-v2-execution && npm run verify:invariants:agent-contracts && npm run verify:invariants:managed-team-integration && npm run verify:invariants:lifecycle-hooks && npm run verify:invariants:markdown-workspace-export && npm run verify:invariants:markdown-workspace-safety",
+    "verify:invariants:authority": "node scripts/check-invariants.js --suite authority",
+    "verify:invariants:dashboard-control-plane": "node scripts/check-dashboard-control-plane.js",
+    "verify:invariants:performance-indexing": "node scripts/check-performance-indexing.js",
+    "verify:invariants:capabilities": "node scripts/check-provider-capabilities.js",
+    "verify:invariants:api-agent-parity": "node scripts/check-api-agent-parity.js",
+    "verify:invariants:dashboard-semantic-gap": "node scripts/run-verification-suite.js dashboard-semantic-gap",
+    "verify:invariants:migration-hardening": "node scripts/check-migration-hardening.js",
+    "verify:invariants:branches": "node scripts/check-branch-isolation.js && node scripts/check-branch-fork-snapshot.js",
+    "verify:invariants:branch-fork": "node scripts/check-branch-fork-snapshot.js",
+    "verify:invariants:sessions": "node scripts/check-session-lifecycle.js",
+    "verify:invariants:evidence": "node scripts/check-evidence-completion.js",
+    "verify:invariants:context": "node scripts/check-session-aware-context.js",
+    "verify:invariants:autonomy-v2": "node scripts/check-autonomy-v2-decision.js",
+    "verify:invariants:autonomy-v2-watchdog": "node scripts/check-autonomy-v2-watchdog.js",
+    "verify:invariants:autonomy-v2-execution": "node scripts/check-autonomy-v2-execution.js",
+    "verify:invariants:agent-contracts": "node scripts/check-agent-contract-advisory.js",
+    "verify:invariants:managed-team-integration": "node scripts/check-managed-team-integration.js",
+    "verify:invariants:lifecycle-hooks": "node scripts/check-lifecycle-hooks.js",
+    "verify:invariants:markdown-workspace-export": "node scripts/check-markdown-workspace-export.js",
+    "verify:invariants:markdown-workspace-safety": "node scripts/check-markdown-workspace-safety.js",
+    "verify:smoke": "node scripts/run-verification-suite.js smoke"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "data-dir.js",
+    "server.js",
+    "dashboard.js",
+    "dashboard.html",
+    "api-agents.js",
+    "runtime-descriptor.js",
+    "agent-contracts.js",
+    "managed-team-integration.js",
+    "autonomy/",
+    "events/",
+    "state/",
+    "providers/",
+    "office/",
+    "mods/",
+    "scripts/",
+    "docs/",
+    "vendor/",
+    "USAGE.md",
+    "cli.js",
+    "templates/",
+    "conversation-templates/",
+    "logo.png",
+    "LICENSE",
+    "SECURITY.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "gemini-cli",
+    "codex-cli",
+    "agent",
+    "multi-agent",
+    "communication",
+    "message-broker",
+    "ai-agents",
+    "let-them-talk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dekelelz/let-them-talk.git"
+  },
+  "homepage": "https://talk.unrealai.studio",
+  "bugs": {
+    "url": "https://github.com/Dekelelz/let-them-talk/issues"
+  },
+  "author": "Dekelelz <contact@talk.unrealai.studio>",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "three": "0.175.0"
+  },
+  "overrides": {
+    "hono": "^4.12.14",
+    "path-to-regexp": "^8.4.2",
+    "@hono/node-server": "^1.19.14"
+  }
+}

package/scripts/repair-canonical-events.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// Repair a corrupted canonical event log in-place.
+//
+// Problem this fixes:
+//   Pre-v5.5.3 Clear Messages would emit a message.redacted event for every
+//   message currently in the projection, even if that message had no
+//   corresponding message.sent event in the canonical log (e.g. legacy
+//   projection-only messages left over from a partial migration, or an
+//   earlier clear cycle). On the next rebuild/replay the redacted event
+//   fails with "cannot apply message.redacted because message X does not
+//   exist", which blocks further Clear Messages on that branch.
+//
+//   v5.5.3 fixed the root cause in clearMessages so new redactions are
+//   gated on the presence of a message.sent ancestor. This script cleans
+//   up the orphan redactions that are already in the event log from
+//   previous versions so the branch can replay again.
+//
+// What it does:
+//   - For every branch under .agent-bridge/runtime/branches/<branch>/:
+//     - Reads events.jsonl
+//     - Collects the set of message IDs that have a message.sent event
+//     - Drops message.redacted and message.corrected events whose
+//       payload.message_id is not in that set (orphans)
+//     - Backs up the original events.jsonl to events.jsonl.pre-repair-<ts>
+//     - Writes the cleaned stream back
+//   - Deletes the branch's projection files (messages.jsonl, history.jsonl,
+//     dashboard-query-projection.json, events.head.json) so the runtime
+//     rebuilds them cleanly on the next read.
+//
+// Usage:
+//   node agent-bridge/scripts/repair-canonical-events.js [project-path]
+//   node agent-bridge/scripts/repair-canonical-events.js --dry-run [project-path]
+//
+// project-path defaults to the current working directory.
+
+const fs = require('fs');
+const path = require('path');
+const { resolveDataDir } = require('../data-dir');
+
+function readJsonl(file) {
+  if (!fs.existsSync(file)) return [];
+  return fs
+    .readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter((line) => line.trim())
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function repairBranch(branchDir, opts) {
+  const eventsFile = path.join(branchDir, 'events.jsonl');
+  if (!fs.existsSync(eventsFile)) return { skipped: true, reason: 'no events.jsonl' };
+
+  const events = readJsonl(eventsFile);
+  if (events.length === 0) return { skipped: true, reason: 'empty events.jsonl' };
+
+  const sentIds = new Set();
+  for (const ev of events) {
+    if (ev && ev.type === 'message.sent' && ev.payload && ev.payload.message && typeof ev.payload.message.id === 'string') {
+      sentIds.add(ev.payload.message.id);
+    }
+  }
+
+  const kept = [];
+  const orphans = [];
+  for (const ev of events) {
+    if (ev && (ev.type === 'message.redacted' || ev.type === 'message.corrected')) {
+      const msgId = ev.payload && ev.payload.message_id;
+      if (msgId && !sentIds.has(msgId)) {
+        orphans.push(ev);
+        continue;
+      }
+    }
+    kept.push(ev);
+  }
+
+  const result = {
+    branch: path.basename(branchDir),
+    total_events: events.length,
+    message_sent_events: sentIds.size,
+    orphan_redacted: orphans.filter((o) => o.type === 'message.redacted').length,
+    orphan_corrected: orphans.filter((o) => o.type === 'message.corrected').length,
+    kept_events: kept.length,
+  };
+
+  if (opts.dryRun) {
+    result.dryRun = true;
+    return result;
+  }
+
+  if (orphans.length === 0) {
+    result.skipped = true;
+    result.reason = 'no orphan events';
+    return result;
+  }
+
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const backupFile = path.join(branchDir, `events.jsonl.pre-repair-${stamp}`);
+  fs.copyFileSync(eventsFile, backupFile);
+  result.backup = backupFile;
+
+  fs.writeFileSync(eventsFile, kept.map((e) => JSON.stringify(e)).join('\n') + '\n');
+
+  // Drop cached projections + head pointer so the runtime rebuilds next read
+  for (const name of ['messages.jsonl', 'history.jsonl', 'dashboard-query-projection.json', 'events.head.json']) {
+    const p = path.join(branchDir, name);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+  result.projections_cleared = true;
+
+  return result;
+}
+
+function main(argv) {
+  const args = argv.slice(2);
+  const dryRun = args.includes('--dry-run') || args.includes('-n');
+  const projectArg = args.filter((a) => !a.startsWith('-'))[0] || process.cwd();
+
+  const dataDir = resolveDataDir({ cwd: projectArg });
+  const branchesDir = path.join(dataDir, 'runtime', 'branches');
+
+  console.log('');
+  console.log('  Canonical event log repair');
+  console.log('  ==========================');
+  console.log('  Project: ' + projectArg);
+  console.log('  Runtime: ' + branchesDir);
+  console.log(dryRun ? '  Mode: DRY RUN (no changes written)' : '  Mode: apply');
+  console.log('');
+
+  if (!fs.existsSync(branchesDir)) {
+    console.log('  [info] No canonical runtime at this path. Nothing to repair.');
+    return;
+  }
+
+  const branches = fs.readdirSync(branchesDir).filter((name) => {
+    const p = path.join(branchesDir, name);
+    return fs.statSync(p).isDirectory();
+  });
+
+  if (branches.length === 0) {
+    console.log('  [info] No branches present. Nothing to repair.');
+    return;
+  }
+
+  for (const name of branches) {
+    const r = repairBranch(path.join(branchesDir, name), { dryRun });
+    console.log(`  Branch "${name}":`);
+    if (r.skipped) {
+      console.log('    skipped — ' + r.reason);
+    } else {
+      console.log(`    ${r.total_events} total events, ${r.message_sent_events} sent messages`);
+      console.log(`    orphan redactions: ${r.orphan_redacted}, orphan corrections: ${r.orphan_corrected}`);
+      if (!dryRun) {
+        console.log('    [ok] rewrote events.jsonl (' + r.kept_events + ' events kept)');
+        console.log('    [ok] backup: ' + r.backup);
+        console.log('    [ok] projections cleared — will rebuild on next read');
+      } else {
+        console.log('    [dry-run] would drop ' + (r.orphan_redacted + r.orphan_corrected) + ' orphan event(s) and back up the original');
+      }
+    }
+  }
+
+  console.log('');
+  if (!dryRun) {
+    console.log('  Done. Clear Messages should now work on the repaired branches.');
+  } else {
+    console.log('  Re-run without --dry-run to apply.');
+  }
+  console.log('');
+}
+
+if (require.main === module) {
+  try { main(process.argv); }
+  catch (e) { console.error('  [error] ' + (e && e.stack ? e.stack : e)); process.exit(1); }
+}
+
+module.exports = { repairBranch };

package/server.js

@@ -1918,6 +1918,8 @@ function buildGuide(level = 'standard') {
   rules.push('SELF-RELIANCE RULE: When the Owner gives you a goal, treat it as a goal — NOT a checklist of approval gates. Break it down yourself, pick tasks via get_work(), and work until done. NEVER stop to ask "should I do X?" or "do you want me to Y?" for decisions you and the team can make. Your default answer to uncertainty is: decide, log_decision() to record the choice, continue. Asking the Owner for permission on small decisions is the failure mode — deciding and moving is the success mode.');
   rules.push('TEAM-FIRST ESCALATION RULE: Before DMing Dashboard/Owner with a question, try these in order: (1) kb_read() — did the team already decide this? (2) DM a teammate with the relevant skill (use list_agents() to find them). (3) call_vote() if the team genuinely disagrees. (4) log_decision() to lock in your choice and move forward. Only escalate to Owner when: (a) the overall goal is complete and the next strategic direction genuinely needs a human call, or (b) you hit a true blocker only the Owner can resolve (credentials, priorities, business rules, access). "I am not sure which design to pick" is NOT an Owner question — it is a team_decision() question.');
   rules.push('DONE-WHEN-DONE RULE: "Done" means the Owner\'s original GOAL is achieved, not "I finished my current step". After verify_and_advance(), immediately call get_work() again to find the next piece of the goal. The loop ends when the goal is complete and evidence is recorded — not when the current step ends. If get_work() returns nothing and the goal still is not done, synthesize: break the remaining work into new tasks with create_task() and keep going.');
+  rules.push('FORMATTING RULE (dashboard is rendered rich markdown): The Messages tab renders GFM markdown, GitHub-quality tables, fenced code with syntax highlighting, Obsidian-style callouts, Mermaid diagrams, KaTeX math, and clickable images. WRITE LIKE YOU ARE PUBLISHING. Use: (1) **tables** for structured data (status, file changes, comparisons) — NEVER use indented lists for tabular info; (2) fenced code blocks with language tag (```ts, ```bash, ```json); (3) callouts for status: > [!SUCCESS] when something shipped, > [!WARNING] for risks, > [!DANGER] for blockers, > [!NOTE] for context, > [!SUMMARY]- (collapsible) for long reports; (4) ```mermaid blocks for architecture/flow/sequence diagrams instead of ASCII art; (5) headings (##, ###) to structure long updates; (6) task lists (- [x] done / - [ ] todo) for action items. A terse structured report beats a wall of text.');
+  rules.push('STATUS-REPORT TEMPLATE: When reporting progress to the Owner or Quality Lead, follow this shape:\n\n> [!SUMMARY]- Headline (1 sentence)\n> \n> ## What shipped\n> | Area | Change | Evidence |\n> |---|---|---|\n> | ... | ... | files_changed + verification |\n> \n> ## Blockers\n> > [!WARNING] describe blocker + what unblocks it\n> \n> ## Next\n> - [ ] next step 1\n> - [ ] next step 2\n\nIf nothing is blocked, omit the Blockers section. If you are only reporting a small update, skip the collapsible summary and use a callout with the headline inline. Do not narrate in prose when a table would be clearer.');
 
   // Minimal level: Tier 0 only — for experienced agents refreshing rules
   if (level === 'minimal') {
@@ -3607,14 +3609,13 @@ async function toolListenGroup() {
         sendsSinceLastListen = 0;
         sendLimit = 10;
         touchHeartbeat(registeredName);
-        resolve({
-          messages: [],
-          message_count: 0,
-          retry: true,
-          batch_summary: isManagedMode()
-            ? 'No new messages — this is NORMAL, not an error. Call listen() again immediately to keep waiting. Codex CLI may end the call near 120s; that is the host limit, not a failure.'
-            : 'No new messages — this is NORMAL, not an error. Call listen_group() again immediately to keep listening. Codex CLI may end the call near 120s; that is the host limit, not a failure.',
-        });
+        // Minimal empty-batch response — the EMPTY-RETURN RULE is already in
+        // every agent's guide + AGENTS.md block, so there's no need to repeat
+        // the "this is normal, call again" reminder every 90s. Trimmed to the
+        // irreducible payload so long listen loops cost as few tokens as
+        // possible. Over a full session this saves ~2 tokens per wake-up *
+        // hundreds of wake-ups = meaningful savings on long-running agents.
+        resolve({ messages: [], retry: true });
       }
     };
 
@@ -3707,101 +3708,41 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
     return new Date(a.timestamp) - new Date(b.timestamp);
   });
 
-  // Build batch summary for triage
-  const summaryCounts = {};
-  for (const m of batch) {
-    const type = m.system || m.from === '__system__' ? 'system'
-      : m.broadcast ? 'broadcast' : (m.reply_to || m.thread_id) ? 'thread' : 'direct';
-    const key = `${m.from}:${type}`;
-    summaryCounts[key] = (summaryCounts[key] || 0) + 1;
-  }
-  const summaryParts = [];
-  for (const [key, count] of Object.entries(summaryCounts)) {
-    const [from, type] = key.split(':');
-    summaryParts.push(`${count} ${type} from ${from}`);
-  }
-  const batchSummary = `${batch.length} messages: ${summaryParts.join(', ')}`;
-
-  // Agent statuses — lightweight, no history reads. Uses the recency grace
-  // so peers that just briefly returned from listen_group() to process a
-  // batch still read as "listening", not "working".
-  const agents = getAgents();
-  const agentNames = Object.keys(agents).filter(n => isPidAlive(agents[n].pid, agents[n].last_activity));
-  const agentStatus = {};
-  for (const n of agentNames) {
-    if (isRecentlyListening(agents[n])) {
-      agentStatus[n] = 'listening';
-    } else {
-      const lastListened = agents[n].last_listened_at;
-      const sinceLastListen = lastListened ? Date.now() - new Date(lastListened).getTime() : Infinity;
-      agentStatus[n] = sinceLastListen > 120000 ? 'unresponsive' : 'working';
-    }
-  }
-
-  const now = Date.now();
+  // LEAN RESPONSE (v5.5.3+): the agent already has every prior message in its
+  // own LLM context, plus the full rule set from get_guide() + AGENTS.md. We
+  // only send the NEW messages + the managed-mode signals needed for
+  // turn-taking. No repeated reminders, no agent rosters, no "next_action"
+  // — agents already know what to do from their guide.
   const result = {
     messages: batch.map(m => {
-      const ageSec = Math.round((now - new Date(m.timestamp).getTime()) / 1000);
       const isOwnerMsg = m.from === 'Dashboard' || m.from === 'Owner' || m.from === 'dashboard' || m.from === 'owner';
       return {
         id: m.id, from: m.from, to: m.to, content: m.content,
         timestamp: m.timestamp,
-        age_seconds: ageSec,
-        ...(ageSec > 30 && { delayed: true }),
         ...(m.reply_to && { reply_to: m.reply_to }),
         ...(m.thread_id && { thread_id: m.thread_id }),
         ...(m.addressed_to && { addressed_to: m.addressed_to }),
-        ...(m.to === '__group__' && {
-          addressed_to_you: !m.addressed_to || m.addressed_to.includes(agentName),
-          should_respond: !m.addressed_to || m.addressed_to.includes(agentName),
-        }),
-        ...(isOwnerMsg && {
-          from_owner: true,
-          system_instruction: 'OWNER MESSAGE. You MUST reply by calling send_message(to="Dashboard", content="your reply") — the owner reads replies ONLY in the dashboard Messages tab. Any text you write in your CLI terminal is INVISIBLE to the owner and does not count as a reply. After send_message, call listen_group() again immediately.',
-        }),
+        ...(isOwnerMsg && { from_owner: true }),
       };
     }),
-    message_count: batch.length,
-    batch_summary: batchSummary,
-    agents_online: agentNames.length,
-    agents_status: agentStatus,
   };
 
-  // Managed mode: add context so agents know whether to respond
+  // Managed mode: minimal turn-taking signal. Managers need to know the
+  // floor/phase to decide next yield_floor(); participants need to know if
+  // they hold the floor. The managed-mode RULE TEXT is already in the guide
+  // so we don't repeat it per call.
   if (isManagedMode()) {
     const managed = getManagedConfig();
-    const youHaveFloor = managed.turn_current === agentName;
-    const youAreManager = managed.manager === agentName;
-
     result.managed_context = {
-      phase: managed.phase, floor: managed.floor, manager: managed.manager,
-      you_have_floor: youHaveFloor, you_are_manager: youAreManager,
+      phase: managed.phase,
+      floor: managed.floor,
+      manager: managed.manager,
+      you_have_floor: managed.turn_current === agentName,
+      you_are_manager: managed.manager === agentName,
       turn_current: managed.turn_current,
     };
-
-    if (youAreManager) {
-      result.should_respond = true;
-      result.instructions = 'You are the MANAGER. Decide who speaks next using yield_floor(), or advance the phase using set_phase().';
-    } else if (youHaveFloor) {
-      result.should_respond = true;
-      result.instructions = 'It is YOUR TURN to speak. Respond now, then the floor will return to the manager.';
-    } else if (managed.floor === 'execution') {
-      result.should_respond = false;
-      result.instructions = `EXECUTION PHASE: Focus on your assigned tasks. Only message the manager (${managed.manager}) if you need help or to report completion.`;
-    } else {
-      result.should_respond = false;
-      result.instructions = 'DO NOT RESPOND. Wait for the manager to give you the floor. Call listen() again to wait.';
-    }
   }
 
-  const fromDashboard = Array.isArray(batch) && batch.some(m => m && (m.from === 'Dashboard' || m.from === 'Owner' || m.from === 'dashboard' || m.from === 'owner'));
-  const dashboardReplyHint = fromDashboard
-    ? ' One of these messages is from Dashboard/Owner — reply via send_message(to="Dashboard") so the owner sees your reply in the dashboard Messages tab. Do NOT narrate the reply in your CLI terminal; terminal output is invisible to the owner.'
-    : '';
-  result.next_action = (isAutonomousMode()
-    ? 'Process these messages, then call get_work() to continue the proactive work loop. Do NOT call listen_group() — use get_work() instead.'
-    : 'After processing these messages and sending your response, call listen_group() again immediately. Never stop listening.') + dashboardReplyHint;
-
   const listenSurface = isManagedMode() && result.managed_context && result.managed_context.you_are_manager
     ? 'manager_listen'
     : (isManagedMode() ? 'participant_listen' : 'team_listen');
@@ -8195,7 +8136,7 @@ function toolToggleRule(ruleId) {
 // --- MCP Server setup ---
 
 const server = new Server(
-  { name: 'agent-bridge', version: '5.4.3' },
+  { name: 'agent-bridge', version: '5.5.3' },
   { capabilities: { tools: {} } }
 );
 
@@ -9324,7 +9265,7 @@ async function main() {
   try {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('Agent Bridge MCP server v5.4.3 running (65 tools)');
+    console.error('Agent Bridge MCP server v5.5.3 running (65 tools)');
   } catch (e) {
     console.error('ERROR: MCP server failed to start: ' + e.message);
     console.error('Fix: Run "npx let-them-talk doctor" to check your setup.');

package/state/canonical.js

@@ -2770,8 +2770,22 @@ function createCanonicalState(options = {}) {
       const redactedAt = params.redactedAt || new Date().toISOString();
       const clearedMessageIds = [];
 
+      // Only redact messages that actually have a canonical message.sent event
+      // in this branch's log. Redacting a message that was never "sent" in
+      // canonical terms (e.g. a legacy projection-only message left over from
+      // pre-canonical clear cycles) would create an orphan redaction that
+      // breaks future replay — the rebuild fails with "cannot apply
+      // message.redacted because message X does not exist".
+      const canonicalSentIds = new Set();
+      for (const event of readCanonicalMessageEvents(branch)) {
+        if (event && event.type === 'message.sent' && event.payload && event.payload.message && typeof event.payload.message.id === 'string') {
+          canonicalSentIds.add(event.payload.message.id);
+        }
+      }
+
       for (const message of Array.isArray(currentMessages) ? currentMessages : []) {
         if (!message || typeof message.id !== 'string' || !message.id) continue;
+        if (!canonicalSentIds.has(message.id)) continue; // skip projection-only / orphan
         appendCanonicalMessageRedactedEvent({
           branch,
           actorAgent,