swarmdo 1.30.0 → 1.37.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/brand/logo-full.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.30.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
+[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.37.0-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](https://github.com/SwarmDo/swarmdo/blob/main/LICENSE)
 [![Website](https://img.shields.io/badge/swarmdo.com-e2a33c?style=for-the-badge&logoColor=black)](https://swarmdo.com)
 [![Star on GitHub](https://img.shields.io/github/stars/SwarmDo/swarmdo?style=for-the-badge&logo=github&color=gold)](https://github.com/SwarmDo/swarmdo)
@@ -271,7 +271,7 @@ The recent release train added a full day-to-day operations layer around the swa
 
 | Command | What it does |
 |---------|-------------|
-| `swarmdo usage` (alias `cost`) | Claude Code **spend analytics** from your local transcripts — `daily`, `monthly` (with a month-end spend projection), `models`, `projects`, `sessions`, live 5-hour `blocks` burn, `errors` (tool-failure analytics), `cache` (prompt-cache efficiency + $ saved), `diff` (period-over-period comparison with per-model movers), `reflect` (a wrapped-style retrospective — busiest day, streak, top models/projects, peak hour, delegation ratio — with a shareable `--html` dashboard), and `limits` (an official-quota **exhaustion forecaster** over Claude Code's `rate_limits`); the standard views take `--csv` for spreadsheet export |
+| `swarmdo usage` (alias `cost`) | Claude Code **spend analytics** from your local transcripts — `daily`, `weekly`, `monthly` (with a month-end spend projection), `models`, `projects`, `sessions`, live 5-hour `blocks` burn, `errors` (tool-failure analytics), `cache` (prompt-cache efficiency + $ saved), `diff` (period-over-period comparison with per-model movers), `reflect` (a wrapped-style retrospective — busiest day, streak, top models/projects, peak hour, delegation ratio — with a shareable `--html` dashboard), and `limits` (an official-quota **exhaustion forecaster** over Claude Code's `rate_limits`); the standard views take `--csv` for spreadsheet export |
 | `swarmdo usage guard` | **Budget policy** — limits for the active 5h block / today / month via flags or `SWARMDO_GUARD_*` env → ok / warn / over; `--strict` exits 1, safe for CI gates and Stop hooks |
 | `swarmdo hud` | **One-screen ops HUD** — 5h block burn, task readiness, daemon workers, memory snapshots (`--watch`, `--json`) |
 | `swarmdo repair` (alias `tdd-repair`) | **Test-Driven Repair** — a bounded, budget-capped headless `claude` loop that fixes source until a failing test passes; dry-run unless `--confirm` |
@@ -294,8 +294,11 @@ The recent release train added a full day-to-day operations layer around the swa
 | OpenRouter model pool | **Let swarms pick from any models you configure** — declare tier-mapped OpenRouter models in `swarmdo.config.json`; the router Thompson-samples among them per task and the execution layer dispatches the winner |
 | `swarmdo changelog` (alias `notes`) | **Release notes from conventional commits** — `--out NOTES.md` feeds `gh release create --notes-file` |
 | `swarmdo mcp doctor` | **MCP config diagnosis** — missing binaries, bad URLs, malformed entries across `.mcp.json` + `~/.claude.json` |
+| `swarmdo permissions` (alias `perms`) | **Audit your Claude Code permission rules** — static analysis of `permissions.allow`/`deny`/`ask` in `.claude/settings*.json`: flags allow↔deny conflicts (dead rules), over-broad `Bash(*)` grants, shadowed/redundant rules, duplicates, and malformed entries. `--strict` gates CI. Read-only; the static-safety sibling of `config lint` / `mcp doctor` |
+| `swarmdo comms` (alias `mailbox`) | **Cross-session agent mailbox** — one Claude Code session messages another by name (`send -t <session>`, `-t all` broadcasts, `inbox`, `read`, `watch`); sessions on the same repo share `.swarmdo/comms/`. `inbox --hook` surfaces new mail as prompt context without polling. Also MCP tools (`comms_send`/`comms_inbox`) |
+| `swarmdo hooks memory-inject` | **Prompt-time semantic memory injection** — embeds each prompt, vector-searches your stored memories, and injects the most relevant under a token budget (recall at the moment of need); wire it with `hooks recipe memory-inject` |
 | `swarmdo hooks notify -d` | **Desktop notifications** — OS-native toast (macOS `osascript`, Linux `notify-send`) |
-| `swarmdo hooks recipe` | **One-command Claude Code hooks** — "ping me when Claude finishes / needs input"; dry-run by default, idempotent merge that never clobbers your settings |
+| `swarmdo hooks recipe` | **One-command Claude Code hooks** — install `notify-done`/`notify-input` (desktop pings), `memory-inject` (relevant memories each prompt), or `comms-inbox` (new mail as context); dry-run by default, idempotent merge that never clobbers your settings |
 | `swarmdo preset` + `init --preset` | **5-tier capability ladder** — `minimal` → `basic`★ → `standard` → `advanced` → `max`; one word instead of dozens of flags |
 | `swarmdo memory export/import -f obsidian` | **Obsidian vault roundtrip** — DB → markdown notes (YAML frontmatter, `[[wikilinks]]` stay live) → edit in Obsidian → sync back, re-embedded; `import --watch` keeps the vault live-synced as you edit |
 | `swarmdo memory backup` / `revectorize` | WAL-safe nightly DB snapshots · repair hash-era vectors |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.30.0",
+  "version": "1.37.0",
   "description": "Swarmdo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@swarmdo/cli/dist/src/affected/affected.d.ts

@@ -10,7 +10,12 @@
  * diff and index load live in ../commands/affected.ts, so it's fixture-testable.
  */
 import type { CodeIndex } from '../codegraph/codegraph.js';
-/** Default matcher for test files (Jest/Vitest/Mocha conventions). */
+/**
+ * Default matcher for test files (Jest/Vitest/Mocha conventions). A file under
+ * `__tests__/` counts only if it has a JS/TS extension — matching Jest's default
+ * `testMatch` (`**​/__tests__/**​/*.[jt]s?(x)`); docs/fixtures (`.md`, `.json`)
+ * living beside the tests are NOT test files and must not be fed to the runner.
+ */
 export declare function isTestFile(path: string): boolean;
 /** file it resolves to → files that import it (reverse of the import edges). Pure. */
 export declare function reverseDeps(index: CodeIndex): Map<string, string[]>;

package/v3/@swarmdo/cli/dist/src/affected/affected.js

@@ -9,9 +9,14 @@
  * closure). Pure — CodeIndex + changed paths in, affected/tests out; the git
  * diff and index load live in ../commands/affected.ts, so it's fixture-testable.
  */
-/** Default matcher for test files (Jest/Vitest/Mocha conventions). */
+/**
+ * Default matcher for test files (Jest/Vitest/Mocha conventions). A file under
+ * `__tests__/` counts only if it has a JS/TS extension — matching Jest's default
+ * `testMatch` (`**​/__tests__/**​/*.[jt]s?(x)`); docs/fixtures (`.md`, `.json`)
+ * living beside the tests are NOT test files and must not be fed to the runner.
+ */
 export function isTestFile(path) {
-    return /(^|\/)__tests__\//.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(path);
+    return /(^|\/)__tests__\/.*\.[cm]?[jt]sx?$/.test(path) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(path);
 }
 /** file it resolves to → files that import it (reverse of the import edges). Pure. */
 export function reverseDeps(index) {

package/v3/@swarmdo/cli/dist/src/apply/apply.js

@@ -184,16 +184,27 @@ export function applyPatch(source, patch, opts = {}) {
         // matched (trimmed) block against the current lines BEFORE splicing.
         const matchedBlock = oldBlock.slice(trimLead, oldBlock.length - trimTail);
         const ambiguous = countMatches(matchLines, matchedBlock) > 1;
-        // Splice: remove oldBlock.length lines at `placed`, insert newBlock —
-        // raw lines get the file's dominant EOL, the match twin stays stripped.
-        const insertRaw = dominantCrlf ? newBlock.map((l) => l + '\r') : newBlock;
-        lines.splice(placed, oldBlock.length, ...insertRaw);
-        matchLines.splice(placed, oldBlock.length, ...newBlock);
-        offset += newBlock.length - oldBlock.length;
+        // Splice ONLY the matched middle. When fuzz trimmed leading/trailing context
+        // (trimLead/trimTail > 0) the FULL block matched nowhere, so those trimmed
+        // context lines are unverified anchors — the real source at those positions
+        // may differ (drift). Splicing the whole oldBlock.length at `placed` would
+        // delete a drifted-but-real line and rewrite it with the hunk's stale context
+        // copy — silent data loss on a line the hunk never marked to change. So splice
+        // from the matched position (placed + trimLead) over just the matched span,
+        // inserting newBlock minus the same lead/tail (context is identical on both
+        // sides), leaving the anchor lines exactly as the source has them. For a
+        // non-fuzzy hunk (trimLead = trimTail = 0) this is byte-identical to before.
+        const removeAt = placed + trimLead;
+        const removeCount = oldBlock.length - trimLead - trimTail;
+        const insert = newBlock.slice(trimLead, newBlock.length - trimTail);
+        const insertRaw = dominantCrlf ? insert.map((l) => l + '\r') : insert;
+        lines.splice(removeAt, removeCount, ...insertRaw);
+        matchLines.splice(removeAt, removeCount, ...insert);
+        offset += insert.length - removeCount; // === newBlock.length - oldBlock.length
         results.push({ hunk, applied: true, at: placed, fuzzUsed: usedFuzz, ...(ambiguous && { ambiguous: true }) });
         // If this hunk's new content is now the tail of the file, its markers
         // determine whether the file ends with a newline.
-        if (placed + newBlock.length === lines.length)
+        if (removeAt + insert.length === lines.length)
             eofNoEol = newSideEndsNoEol(hunk);
     }
     let result = lines.join('\n');

package/v3/@swarmdo/cli/dist/src/changelog/changelog.js

@@ -44,7 +44,10 @@ export function parseCommit(hash, subject, body = '') {
             hash,
             type: 'revert',
             scope: inner ? inner[2] ?? null : null,
-            breaking: BREAKING_RE.test(body),
+            // A revert of a breaking commit is itself breaking — mirror the non-revert
+            // branch and consult the reverted subject's `!` marker (inner group 3),
+            // not just a BREAKING CHANGE footer on the revert body.
+            breaking: (inner ? inner[3] === '!' : false) || BREAKING_RE.test(body),
             subject: inner ? inner[4].trim() : rev[1].trim(),
             raw: trimmed,
         };

package/v3/@swarmdo/cli/dist/src/codegraph/codegraph.js

@@ -37,6 +37,7 @@ const MATCHERS = [
 function declaratorNames(decl) {
     const names = [];
     let depth = 0;
+    let angle = 0; // generic type-argument depth: `Map<string, number>`
     let start = 0;
     let str = null;
     const take = (seg) => {
@@ -57,7 +58,16 @@ function declaratorNames(decl) {
             depth++;
         else if (ch === ')' || ch === ']' || ch === '}')
             depth--;
-        else if (ch === ',' && depth === 0) {
+        // Generic type-args: a comma inside `Map<string, number>` must not split the
+        // declarator list. Only treat `<` as an opener when it directly follows an
+        // identifier char (Map<, Record<, Array<) — so a spaced comparison `a < b`
+        // isn't misread as a generic — and exclude `<<`/`<=`. Close on `>`, skipping
+        // the `>` of an arrow `=>` so `Record<string, () => void>` stays balanced.
+        else if (ch === '<' && i > 0 && /[\w$]/.test(decl[i - 1]) && decl[i - 1] !== '<' && decl[i + 1] !== '<' && decl[i + 1] !== '=')
+            angle++;
+        else if (ch === '>' && angle > 0 && decl[i - 1] !== '=')
+            angle--;
+        else if (ch === ',' && depth === 0 && angle === 0) {
             take(decl.slice(start, i));
             start = i + 1;
         }

package/v3/@swarmdo/cli/dist/src/commands/comms.d.ts

@@ -0,0 +1,16 @@
+/**
+ * comms.ts — `swarmdo comms` — a cross-session agent mailbox (#44).
+ *
+ *   swarmdo comms send -t <session> -m "<message>"   leave a message for a session
+ *   swarmdo comms inbox [-t <self>] [-u]              list your messages (newest first)
+ *   swarmdo comms read <id>                           show a full message + mark it read
+ *
+ * Any Claude Code session on the same repo shares `.swarmdo/comms/store.json`, so
+ * one session can message another by name ("multiplayer swarms"). Address `all`
+ * to broadcast. The message model, filtering, and retention live in the pure
+ * comms/mailbox.ts engine; this layer is fs persistence + presentation.
+ */
+import type { Command } from '../types.js';
+export declare const commsCommand: Command;
+export default commsCommand;
+//# sourceMappingURL=comms.d.ts.map

package/v3/@swarmdo/cli/dist/src/commands/comms.js

@@ -0,0 +1,280 @@
+/**
+ * comms.ts — `swarmdo comms` — a cross-session agent mailbox (#44).
+ *
+ *   swarmdo comms send -t <session> -m "<message>"   leave a message for a session
+ *   swarmdo comms inbox [-t <self>] [-u]              list your messages (newest first)
+ *   swarmdo comms read <id>                           show a full message + mark it read
+ *
+ * Any Claude Code session on the same repo shares `.swarmdo/comms/store.json`, so
+ * one session can message another by name ("multiplayer swarms"). Address `all`
+ * to broadcast. The message model, filtering, and retention live in the pure
+ * comms/mailbox.ts engine; this layer is fs persistence + presentation.
+ */
+import { output } from '../output.js';
+import { createMessage, addMessage, filterInbox, unreadCount, markRead, pruneMailbox, renderInboxContext, } from '../comms/mailbox.js';
+import { loadMailbox, saveMailbox, resolveSelf, newMessageId, RETENTION } from '../comms/store.js';
+/** Compact relative age, e.g. "3m", "2h", "5d", or "now". */
+function relAge(iso, nowMs) {
+    const ms = nowMs - Date.parse(iso);
+    if (!Number.isFinite(ms) || ms < 0)
+        return '—';
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return 'now';
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h`;
+    return `${Math.floor(h / 24)}d`;
+}
+const sendCommand = {
+    name: 'send',
+    description: 'Send a message to another session (address "all" to broadcast)',
+    options: [
+        { name: 'to', short: 't', description: 'Recipient session name (or "all")', type: 'string' },
+        { name: 'message', short: 'm', description: 'Message body', type: 'string' },
+        { name: 'subject', short: 's', description: 'Subject line', type: 'string' },
+        { name: 'from', short: 'f', description: 'Sender name (default: this session)', type: 'string' },
+        { name: 'json', description: 'Machine-readable output', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo comms send -t reviewer -m "auth PR is ready" -s "PR #42"', description: 'Message the "reviewer" session' },
+        { command: 'swarmdo comms send -t all -m "rebasing main in 5min"', description: 'Broadcast to every session' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const to = (ctx.flags.to || ctx.args[0] || '').trim();
+        const body = (ctx.flags.message ?? ctx.args[1] ?? '').toString();
+        if (!to) {
+            output.printError('Recipient required. Use --to/-t <session> (or "all").');
+            return { success: false, exitCode: 1 };
+        }
+        if (!body.trim()) {
+            output.printError('Message body required. Use --message/-m "<text>".');
+            return { success: false, exitCode: 1 };
+        }
+        const from = resolveSelf(ctx.flags.from);
+        const msg = createMessage({
+            id: newMessageId(),
+            from,
+            to,
+            subject: ctx.flags.subject,
+            body,
+            createdAt: new Date().toISOString(),
+        });
+        let box = addMessage(loadMailbox(cwd), msg);
+        box = pruneMailbox(box, { ...RETENTION, nowMs: Date.now() });
+        saveMailbox(cwd, box);
+        if (ctx.flags.json === true) {
+            output.printJson({ sent: true, id: msg.id, to: msg.to, from: msg.from });
+            return { success: true, data: { id: msg.id } };
+        }
+        output.printSuccess(`Sent to ${output.highlight(msg.to)} — id ${output.dim(msg.id)}`);
+        return { success: true, data: { id: msg.id } };
+    },
+};
+const inboxCommand = {
+    name: 'inbox',
+    aliases: ['list'],
+    description: 'List messages addressed to you (newest first)',
+    options: [
+        { name: 'to', short: 't', description: 'Whose inbox (default: this session)', type: 'string' },
+        { name: 'from', short: 'f', description: 'Only messages from this sender', type: 'string' },
+        { name: 'unread', short: 'u', description: 'Only unread messages', type: 'boolean' },
+        { name: 'since', description: 'Only messages after this ISO timestamp', type: 'string' },
+        { name: 'mark-read', description: 'Mark all shown messages as read', type: 'boolean' },
+        { name: 'hook', description: 'Emit unread messages as UserPromptSubmit additionalContext JSON, then mark them read (for hook delivery)', type: 'boolean' },
+        { name: 'json', description: 'Machine-readable output', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo comms inbox', description: 'Your unread + read messages' },
+        { command: 'swarmdo comms inbox -u --mark-read', description: 'Show unread, then mark them read' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const self = resolveSelf(ctx.flags.to);
+        // --hook: delivery path. Emit unread mail as UserPromptSubmit additionalContext
+        // and mark it read so it surfaces once, without polling. Hook-safe: NEVER
+        // errors (that would break the prompt) and stays silent when there's no mail.
+        if (ctx.flags.hook === true) {
+            try {
+                if (process.env.SWARMDO_COMMS_DISABLE === '1')
+                    return { success: true };
+                const box = loadMailbox(cwd);
+                const unread = filterInbox(box, { to: self, unreadOnly: true });
+                if (unread.length > 0) {
+                    const block = renderInboxContext(unread);
+                    process.stdout.write(JSON.stringify({
+                        hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: block },
+                    }) + '\n');
+                    const { box: next, marked } = markRead(box, unread.map((m) => m.id));
+                    if (marked > 0)
+                        saveMailbox(cwd, next);
+                }
+            }
+            catch {
+                /* never fail a hook */
+            }
+            return { success: true };
+        }
+        const box = loadMailbox(cwd);
+        const inbox = filterInbox(box, {
+            to: self,
+            from: ctx.flags.from,
+            unreadOnly: ctx.flags.unread === true,
+            since: ctx.flags.since,
+        });
+        const now = Date.now();
+        if (ctx.flags.json === true) {
+            output.printJson({ to: self, unread: unreadCount(box, self), messages: inbox });
+        }
+        else if (inbox.length === 0) {
+            output.printInfo(`No messages for ${output.highlight(self)}.`);
+        }
+        else {
+            output.writeln(output.bold(`Inbox: ${self}`) + output.dim(`  (${unreadCount(box, self)} unread)`));
+            output.printTable({
+                columns: [
+                    { key: 'flag', header: '', width: 2 },
+                    { key: 'id', header: 'ID', width: 14 },
+                    { key: 'from', header: 'From', width: 16 },
+                    { key: 'subject', header: 'Subject', width: 34 },
+                    { key: 'age', header: 'Age', width: 6, align: 'right' },
+                ],
+                data: inbox.map((m) => ({ flag: m.read ? ' ' : '●', id: m.id, from: m.from, subject: m.subject, age: relAge(m.createdAt, now) })),
+            });
+            output.writeln(output.dim('● = unread · read a message:  swarmdo comms read <id>'));
+        }
+        if (ctx.flags['mark-read'] === true && inbox.length > 0) {
+            const { box: next, marked } = markRead(box, inbox.map((m) => m.id));
+            if (marked > 0)
+                saveMailbox(cwd, next);
+            if (ctx.flags.json !== true)
+                output.printInfo(`Marked ${marked} read.`);
+        }
+        return { success: true, data: { to: self, count: inbox.length } };
+    },
+};
+const readCommand = {
+    name: 'read',
+    description: 'Show a full message and mark it read',
+    options: [{ name: 'json', description: 'Machine-readable output', type: 'boolean' }],
+    examples: [{ command: 'swarmdo comms read msg_ab12cd34ef56', description: 'Open a message by id' }],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const id = (ctx.args[0] || '').trim();
+        if (!id) {
+            output.printError('Message id required:  swarmdo comms read <id>');
+            return { success: false, exitCode: 1 };
+        }
+        const box = loadMailbox(cwd);
+        const m = box.messages[id];
+        if (!m) {
+            output.printError(`No message with id ${id}.`);
+            return { success: false, exitCode: 1 };
+        }
+        const { box: next, marked } = markRead(box, [id]);
+        if (marked > 0)
+            saveMailbox(cwd, next);
+        if (ctx.flags.json === true) {
+            output.printJson({ ...m, read: true });
+            return { success: true, data: { id } };
+        }
+        output.writeln();
+        output.printList([
+            `${output.bold('From')}:    ${m.from}`,
+            `${output.bold('To')}:      ${m.to}`,
+            `${output.bold('Subject')}: ${m.subject}`,
+            `${output.bold('Sent')}:    ${m.createdAt}`,
+        ]);
+        output.writeln();
+        output.writeln(m.body);
+        output.writeln();
+        return { success: true, data: { id } };
+    },
+};
+const watchCommand = {
+    name: 'watch',
+    description: 'Live-tail your inbox — print new messages as they arrive (Ctrl-C to stop)',
+    options: [
+        { name: 'to', short: 't', description: 'Whose inbox (default: this session)', type: 'string' },
+        { name: 'from', short: 'f', description: 'Only messages from this sender', type: 'string' },
+        { name: 'interval', short: 'i', description: 'Poll interval in seconds', type: 'number', default: 5 },
+    ],
+    examples: [
+        { command: 'swarmdo comms watch', description: 'Live-tail your inbox' },
+        { command: 'swarmdo comms watch -i 2', description: 'Poll every 2 seconds' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const self = resolveSelf(ctx.flags.to);
+        const from = ctx.flags.from;
+        const intervalMs = Math.max(1, Number(ctx.flags.interval ?? 5)) * 1000;
+        // Only surface messages that arrive AFTER watch starts.
+        let cursor = new Date().toISOString();
+        output.printInfo(`Watching ${output.highlight(self)}'s inbox every ${intervalMs / 1000}s (Ctrl-C to stop)…`);
+        return await new Promise((resolve) => {
+            const tick = () => {
+                try {
+                    const box = loadMailbox(cwd);
+                    // filterInbox is newest-first; reverse to print in arrival order.
+                    const fresh = filterInbox(box, { to: self, from, since: cursor }).reverse();
+                    for (const m of fresh) {
+                        output.writeln(`${output.dim(new Date(m.createdAt).toLocaleTimeString())} ${output.bold(m.from)} › ${m.subject}: ${m.body.replace(/\s+/g, ' ').trim()}`);
+                        if (m.createdAt > cursor)
+                            cursor = m.createdAt;
+                    }
+                }
+                catch {
+                    /* keep watching despite a transient read error */
+                }
+            };
+            const timer = setInterval(tick, intervalMs);
+            const stop = () => {
+                clearInterval(timer);
+                output.writeln();
+                output.printInfo('Stopped watching.');
+                resolve({ success: true });
+            };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+    },
+};
+export const commsCommand = {
+    name: 'comms',
+    aliases: ['mailbox'],
+    description: 'Cross-session agent mailbox — message another session by name',
+    subcommands: [sendCommand, inboxCommand, readCommand, watchCommand],
+    options: [],
+    examples: [
+        { command: 'swarmdo comms send -t reviewer -m "PR ready"', description: 'Send a message' },
+        { command: 'swarmdo comms inbox -u', description: 'List your unread messages' },
+        { command: 'swarmdo comms read <id>', description: 'Open a message' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const self = resolveSelf();
+        const box = loadMailbox(cwd);
+        const unread = unreadCount(box, self);
+        output.writeln();
+        output.writeln(output.bold('Cross-session agent mailbox'));
+        output.writeln();
+        output.writeln(`You are ${output.highlight(self)} — ${unread} unread message${unread === 1 ? '' : 's'}.`);
+        output.writeln();
+        output.writeln('Usage: swarmdo comms <send|inbox|read|watch> [options]');
+        output.printList([
+            `${output.highlight('send')}   - Send a message (\`-t <session> -m "…"\`, \`-t all\` to broadcast)`,
+            `${output.highlight('inbox')}  - List your messages (\`-u\` unread, \`--mark-read\`, \`--hook\`)`,
+            `${output.highlight('read')}   - Show a full message by id and mark it read`,
+            `${output.highlight('watch')}  - Live-tail your inbox for new messages`,
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Sessions on the same repo share .swarmdo/comms/. Name yourself with $SWARMDO_SESSION.'));
+        return { success: true, data: { self, unread } };
+    },
+};
+export default commsCommand;
+//# sourceMappingURL=comms.js.map

package/v3/@swarmdo/cli/dist/src/commands/compact.js

@@ -34,8 +34,12 @@ function optsFromFlags(ctx) {
     };
     if (typeof ctx.flags['min-run'] === 'number')
         opts.minRun = ctx.flags['min-run'];
-    else if (typeof ctx.flags['min-run'] === 'string')
-        opts.minRun = parseInt(ctx.flags['min-run'], 10) || 3;
+    else if (typeof ctx.flags['min-run'] === 'string') {
+        // Explicit NaN check, NOT `|| 3` — the documented `--min-run 0` ("disables")
+        // is falsy and would otherwise be silently coerced back to the default 3.
+        const parsed = parseInt(ctx.flags['min-run'], 10);
+        opts.minRun = Number.isNaN(parsed) ? 3 : parsed;
+    }
     const win = ctx.flags.window;
     if (typeof win === 'string' && /^\d+:\d+$/.test(win)) {
         const [head, tail] = win.split(':').map((n) => parseInt(n, 10));

package/v3/@swarmdo/cli/dist/src/commands/config.js

@@ -438,6 +438,7 @@ const lintCommand = {
             settingsFiles: [read('.claude/settings.json'), read('.claude/settings.local.json')],
             mcpConfig: read('.mcp.json'),
             commandsRoot: list('.claude/commands'),
+            sdoCommands: list('.claude/commands/sDo'),
             skills: list('.claude/skills'),
         });
         const failed = report.errors > 0 || (ctx.flags.strict === true && report.warnings > 0);

package/v3/@swarmdo/cli/dist/src/commands/hooks.js

@@ -8,6 +8,8 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { bridgeSearchEntries } from '../memory/memory-bridge.js';
+import { selectInjectionMemories, mapSearchResultsToCandidates, extractPromptFromPayload, } from '../memory-inject/select.js';
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
  * surfaces as `"NaN"` (or earlier crashed `.toFixed`) in the metrics
@@ -731,6 +733,122 @@ const routeCommand = {
         }
     }
 };
+/**
+ * Read a Claude Code hook payload from stdin (JSON on UserPromptSubmit), with a
+ * short timeout so it never hangs when stdin isn't closed (a known Windows
+ * failure mode). Returns '' for a TTY or on any error — the caller then simply
+ * injects nothing.
+ */
+async function readHookStdin(timeoutMs = 1500) {
+    if (process.stdin.isTTY)
+        return '';
+    return new Promise((resolve) => {
+        let data = '';
+        const finish = (v) => {
+            try {
+                process.stdin.pause();
+            }
+            catch { /* noop */ }
+            resolve(v);
+        };
+        const timer = setTimeout(() => finish(data), timeoutMs);
+        try {
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (c) => { data += c; });
+            process.stdin.on('end', () => { clearTimeout(timer); finish(data); });
+            process.stdin.on('error', () => { clearTimeout(timer); finish(data); });
+            process.stdin.resume();
+        }
+        catch {
+            clearTimeout(timer);
+            finish('');
+        }
+    });
+}
+const DEFAULT_INJECT_NAMESPACES = ['claude-memories', 'auto-memory', 'patterns'];
+/**
+ * memory-inject — the #43 prompt-time semantic memory injection hook. Embeds the
+ * submitted prompt, vector-searches AgentDB across the memory namespaces, and
+ * emits the most relevant stored memories as UserPromptSubmit `additionalContext`
+ * under a strict token budget. Wired for the hook path: it NEVER errors out
+ * (that would break the user's prompt) and stays silent when nothing is relevant.
+ */
+const memoryInjectCommand = {
+    name: 'memory-inject',
+    description: 'Inject relevant stored memories into the prompt (UserPromptSubmit hook)',
+    options: [
+        { name: 'prompt', short: 'p', description: 'Prompt text (else read the hook JSON from stdin)', type: 'string' },
+        { name: 'namespaces', description: 'Comma-separated namespaces to search', type: 'string', default: DEFAULT_INJECT_NAMESPACES.join(',') },
+        { name: 'budget', description: 'Max tokens of injected context', type: 'number', default: 800 },
+        { name: 'min-relevance', description: 'Minimum relevance score (0..1)', type: 'number', default: 0.35 },
+        { name: 'top-k', short: 'K', description: 'Max memories to inject', type: 'number', default: 5 },
+        { name: 'limit', description: 'Max search results to rank', type: 'number', default: 20 },
+        { name: 'preview', description: 'Print the block for humans instead of emitting hook JSON', type: 'boolean' },
+        { name: 'db', description: 'Path to the memory database', type: 'string' },
+    ],
+    examples: [
+        { command: 'swarmdo hooks memory-inject -p "refactor the auth module" --preview', description: 'Preview relevant memories for a prompt' },
+        { command: "echo '{\"prompt\":\"fix bug\"}' | swarmdo hooks memory-inject", description: 'Run as a UserPromptSubmit hook' },
+    ],
+    action: async (ctx) => {
+        const preview = Boolean(ctx.flags.preview);
+        // A hook must NEVER break the user's prompt: swallow every error and emit nothing.
+        try {
+            if (process.env.SWARMDO_MEMORY_INJECT_DISABLE === '1')
+                return { success: true };
+            let prompt = (ctx.flags.prompt || ctx.args.join(' ')).trim();
+            if (!prompt)
+                prompt = extractPromptFromPayload(await readHookStdin());
+            if (!prompt)
+                return { success: true }; // nothing to search on
+            const namespaces = String(ctx.flags.namespaces ?? DEFAULT_INJECT_NAMESPACES.join(','))
+                .split(',').map((s) => s.trim()).filter(Boolean);
+            const minRelevance = ctx.flags.minRelevance ?? 0.35;
+            const topK = ctx.flags.topK ?? 5;
+            const limit = Math.max(ctx.flags.limit ?? 20, topK);
+            const search = await bridgeSearchEntries({
+                query: prompt,
+                namespace: 'all',
+                limit,
+                threshold: minRelevance,
+                fullContent: true,
+                dbPath: ctx.flags.db,
+            });
+            const rows = (search && search.success ? search.results : []);
+            const candidates = mapSearchResultsToCandidates(rows, namespaces);
+            const result = selectInjectionMemories(candidates, {
+                budgetTokens: ctx.flags.budget ?? 800,
+                minRelevance,
+                topK,
+            });
+            if (preview) {
+                if (!result.block) {
+                    output.printInfo('No relevant memories to inject.');
+                }
+                else {
+                    output.writeln(result.block);
+                    output.writeln();
+                    output.printInfo(`Injected ${result.used.length} memor${result.used.length === 1 ? 'y' : 'ies'} ` +
+                        `(~${result.tokensUsed} tokens${result.skipped ? `, ${result.skipped} skipped` : ''}).`);
+                }
+                return { success: true, data: { used: result.used.length, skipped: result.skipped, tokensUsed: result.tokensUsed } };
+            }
+            // Hook mode: emit additionalContext JSON ONLY when there's something to add,
+            // so an irrelevant prompt leaves Claude's context untouched.
+            if (result.block) {
+                process.stdout.write(JSON.stringify({
+                    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: result.block },
+                }) + '\n');
+            }
+            return { success: true };
+        }
+        catch (err) {
+            if (preview)
+                output.printError(`Memory injection failed: ${String(err)}`);
+            return { success: true }; // never fail the hook
+        }
+    },
+};
 // Explain subcommand
 const explainCommand = {
     name: 'explain',
@@ -4447,7 +4565,7 @@ const notifyCommand = {
 const recipeCommand = {
     name: 'recipe',
     aliases: ['recipes'],
-    description: 'Install ready-made Claude Code hook recipes (desktop notify) into settings — dry-run unless --apply',
+    description: 'Install ready-made Claude Code hook recipes (desktop notify, memory injection) into settings — dry-run unless --apply',
     options: [
         { name: 'apply', type: 'boolean', description: 'write the change (default: preview only)', default: false },
         { name: 'shared', type: 'boolean', description: 'target .claude/settings.json (shared/committed) instead of settings.local.json', default: false },
@@ -4553,6 +4671,7 @@ export const hooksCommand = {
         sessionEndCommand,
         sessionRestoreCommand,
         routeCommand,
+        memoryInjectCommand,
         explainCommand,
         pretrainCommand,
         buildAgentsCommand,
@@ -4610,6 +4729,7 @@ export const hooksCommand = {
             `${output.highlight('session-end')}     - End current session and persist state`,
             `${output.highlight('session-restore')} - Restore a previous session`,
             `${output.highlight('route')}           - Route tasks to optimal agents`,
+            `${output.highlight('memory-inject')}   - Inject relevant memories into the prompt (UserPromptSubmit)`,
             `${output.highlight('explain')}         - Explain routing decisions`,
             `${output.highlight('pretrain')}        - Bootstrap intelligence from repository`,
             `${output.highlight('build-agents')}    - Generate optimized agent configs`,