swarmdo 1.4.8 → 1.6.0

package/.claude/helpers/statusline.cjs

@@ -323,7 +323,7 @@ function buildLocalFallback() {
   return applyLocalOverlays({
     user: { name: 'user', gitBranch: '', modelName: 'Claude Code' },
     v3Progress: { domainsCompleted: 0, totalDomains: 5, dddProgress: 0, patternsLearned: 0, sessionsCompleted: 0 },
-    security: { status: 'NONE', cvesFixed: 0, totalCves: 0 },
+    security: { status: 'NONE', critical: 0, high: 0, total: 0 },
     swarm: { activeAgents: 0, maxAgents: CONFIG.maxAgents, coordinationActive: false },
     system: { memoryMB: memMB, contextPct: 0, intelligencePct: 0, subAgents: 0 },
     lastUpdated: new Date().toISOString(),
@@ -515,7 +515,7 @@ function getCostFromStdin() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
-  let ver = '1.3.30';
+  let ver = '1.6.0';
   try {
     const home = os.homedir();
     const pkgPaths = [
@@ -591,9 +591,9 @@ function generateStatusline() {
   const intelligencePct = system.intelligencePct || 0;
   const memoryMB = system.memoryMB || 0;
   const subAgents = system.subAgents || 0;
-  const cvesFixed = security.cvesFixed || 0;
-  const totalCves = security.totalCves || 0;
+  const secCritHigh = (security.critical || 0) + (security.high || 0);
   const secStatus = security.status || 'NONE';
+  const secLabel = secStatus === 'VULN' ? 'sec ' + secCritHigh + '!' : secStatus === 'CLEAN' ? 'sec ✓' : secStatus === 'STALE' ? 'sec stale' : 'sec —';
   const adrCount = adrs.count || 0;
   const adrImpl = adrs.implemented || 0;
   const hooksEnabled = hooks.enabled || 0;
@@ -659,8 +659,8 @@ function generateStatusline() {
   // Line 2: Swarm + Hooks + CVE + Memory + Intelligence
   const swarmInd = coordinationActive ? c.brightGreen + '◉' + c.reset : c.dim + '○' + c.reset;
   const agentsColor = activeAgents > 0 ? c.brightGreen : c.red;
-  const secIcon = secStatus === 'CLEAN' ? '🟢' : (secStatus === 'IN_PROGRESS' || secStatus === 'STALE') ? '🟡' : (secStatus === 'NONE' ? '⚪' : '🔴');
-  const secColor = secStatus === 'CLEAN' ? c.brightGreen : (secStatus === 'IN_PROGRESS' || secStatus === 'STALE') ? c.brightYellow : (secStatus === 'NONE' ? c.dim : c.brightRed);
+  const secIcon = secStatus === 'CLEAN' ? '🟢' : secStatus === 'STALE' ? '🟡' : (secStatus === 'NONE' ? '⚪' : '🔴');
+  const secColor = secStatus === 'CLEAN' ? c.brightGreen : secStatus === 'STALE' ? c.brightYellow : (secStatus === 'NONE' ? c.dim : c.brightRed);
   const hooksColor = hooksEnabled > 0 ? c.brightGreen : c.dim;
   const intellColor = intelligencePct >= 80 ? c.brightGreen : intelligencePct >= 40 ? c.brightYellow : c.dim;
 
@@ -668,7 +668,7 @@ function generateStatusline() {
     c.brightYellow + '🤖 Swarm' + c.reset + '  ' + swarmInd + ' [' + agentsColor + String(activeAgents).padStart(2) + c.reset + '/' + c.brightWhite + maxAgents + c.reset + ']  ' +
     c.brightPurple + '👥 ' + subAgents + c.reset + '    ' +
     c.brightBlue + '🪝 ' + hooksColor + hooksEnabled + c.reset + '/' + c.brightWhite + hooksTotal + c.reset + '    ' +
-    secIcon + ' ' + secColor + 'CVE ' + cvesFixed + c.reset + '/' + c.brightWhite + totalCves + c.reset + '    ' +
+    secIcon + ' ' + secColor + secLabel + c.reset + '    ' +
     c.brightCyan + '💾 ' + memoryMB + 'MB' + c.reset + '    ' +
     intellColor + '🧠 ' + String(intelligencePct).padStart(3) + '%' + c.reset
   );

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/swarmdo-banner.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.4.8-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.6.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)
@@ -89,7 +89,7 @@ This adds slash commands and agent definitions only. The Swarmdo MCP server is N
 | [**swarmdo-agentdb**](plugins/swarmdo-agentdb/README.md) | Fast vector database for agent memory |
 | [**swarmdo-rag-memory**](plugins/swarmdo-rag-memory/README.md) | Smart retrieval — hybrid search, graph hops, diversity ranking |
 | [**swarmdo-rvf**](plugins/swarmdo-rvf/README.md) | Save and restore agent memory across sessions |
-| [**swarmdo-swarmvector**](plugins/swarmdo-swarmvector/README.md) | [`swarmvector`](https://npmjs.com/package/swarmvector) — GPU-accelerated search, Graph RAG, 103 tools |
+| [**swarmdo-swarmvector**](plugins/swarmdo-swarmvector/README.md) | `swarmvector` (vendored in-repo at `v3/vendor/swarmvector`) — GPU-accelerated search, Graph RAG, 103 tools |
 | [**swarmdo-knowledge-graph**](plugins/swarmdo-knowledge-graph/README.md) | Build and traverse entity relationship maps |
 
 #### Intelligence & Learning
@@ -269,19 +269,22 @@ 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`, `models`, `projects`, `sessions`, live 5-hour `blocks` burn, `errors` (tool-failure analytics), and `cache` (prompt-cache efficiency + $ saved) |
+| `swarmdo usage` (alias `cost`) | Claude Code **spend analytics** from your local transcripts — `daily`, `monthly`, `models`, `projects`, `sessions`, live 5-hour `blocks` burn, `errors` (tool-failure analytics), `cache` (prompt-cache efficiency + $ saved), and `diff` (period-over-period comparison with per-model movers) |
 | `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` |
-| `swarmdo task … --dependencies` | **Task dependency DAG** — `task ready` lists unblocked work, `task graph` renders the graph, the dispatcher gates on readiness |
+| `swarmdo task … --dependencies` | **Task dependency DAG** — `task ready` lists unblocked work, `task graph` renders the graph, the dispatcher gates on readiness; `task parse-prd <spec.md>` decomposes a PRD straight into the DAG |
 | `swarmdo worktree` (alias `wt`) | **Parallel-agent isolation** on git worktrees — add / list / diff / merge / remove |
-| `swarmdo transcript` (alias `tx`) | **Export any Claude Code session** to clean markdown — system noise stripped, ready to share |
+| `swarmdo transcript` (alias `tx`) | **Export any Claude Code session** to clean markdown — system noise stripped, ready to share; `transcript search <query>` full-text-searches every session |
+| `swarmdo compact` | **Compress noisy command output** before it reaches an LLM — strip ANSI, collapse repeats, fold `node_modules` stack frames, window long logs. `npm test 2>&1 \| swarmdo compact` or `swarmdo compact -- npm test` (exit code propagates). Deterministic, zero tokens |
+| `swarmdo integrations` (alias `integrate`) | **Use swarmdo from Codex CLI, GitHub Copilot CLI, and pi** — one command wires AGENTS.md + each CLI's MCP config (idempotent, dry-run first, never touches your Claude Code setup) |
+| 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 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 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 |
+| `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 |
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.4.8",
+  "version": "1.6.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",
@@ -56,7 +56,9 @@
     "!.claude/**/*.db",
     "!.claude/**/*.map",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "!.claude/scheduled_tasks.lock",
+    "!.claude/**/__pycache__/**"
   ],
   "scripts": {
     "dev": "tsx watch src/index.ts",
@@ -86,7 +88,7 @@
     "@swarmdo/shared": "file:v3/@swarmdo/shared",
     "@swarmvector/rabitq-wasm": "file:v3/@swarmvector/rabitq-wasm",
     "agentic-flow": "file:v3/vendor/agentic-flow",
-    "pg": "^8.22.0",
+    "pg": "8.22.0",
     "swarmvector": "file:v3/vendor/swarmvector",
     "swarmvector-attention-wasm": "file:v3/vendor/swarmvector-attention-wasm",
     "swarmvector-graph-transformer-wasm": "file:v3/vendor/swarmvector-graph-transformer-wasm",

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

@@ -0,0 +1,16 @@
+/**
+ * `swarmdo compact` — compress noisy command output before it reaches an LLM.
+ *
+ * Two modes:
+ *   npm test 2>&1 | swarmdo compact        # stdin filter
+ *   swarmdo compact -- npm test            # wrap a command (stdout+stderr)
+ *
+ * Compacted text goes to stdout (pipeable); a one-line savings summary goes to
+ * stderr unless --quiet. When wrapping a command, the command's exit code is
+ * propagated verbatim — `swarmdo compact -- npm test` still fails if the tests
+ * fail. Deterministic, zero tokens (see ../compact/compact.ts).
+ */
+import type { Command } from '../types.js';
+export declare const compactCommand: Command;
+export default compactCommand;
+//# sourceMappingURL=compact.d.ts.map

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

@@ -0,0 +1,106 @@
+/**
+ * `swarmdo compact` — compress noisy command output before it reaches an LLM.
+ *
+ * Two modes:
+ *   npm test 2>&1 | swarmdo compact        # stdin filter
+ *   swarmdo compact -- npm test            # wrap a command (stdout+stderr)
+ *
+ * Compacted text goes to stdout (pipeable); a one-line savings summary goes to
+ * stderr unless --quiet. When wrapping a command, the command's exit code is
+ * propagated verbatim — `swarmdo compact -- npm test` still fails if the tests
+ * fail. Deterministic, zero tokens (see ../compact/compact.ts).
+ */
+import { spawnSync } from 'node:child_process';
+import { output } from '../output.js';
+import { compactOutput, formatSavings } from '../compact/compact.js';
+/**
+ * Read all of stdin as UTF-8. A stream read (not readFileSync(0)) — the
+ * synchronous form throws EAGAIN on a non-blocking pipe on macOS/Linux.
+ */
+function readStdin() {
+    return new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on('data', (c) => chunks.push(Buffer.from(c)));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        process.stdin.on('error', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+}
+function optsFromFlags(ctx) {
+    const opts = {
+        stripAnsi: ctx.flags['no-ansi'] !== true,
+        foldNodeModules: ctx.flags['no-fold'] !== true,
+        collapseBlanks: true,
+    };
+    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;
+    const win = ctx.flags.window;
+    if (typeof win === 'string' && /^\d+:\d+$/.test(win)) {
+        const [head, tail] = win.split(':').map((n) => parseInt(n, 10));
+        opts.window = { head, tail };
+    }
+    return opts;
+}
+async function run(ctx) {
+    const opts = optsFromFlags(ctx);
+    const quiet = ctx.flags.quiet === true;
+    // Command-wrap mode: everything after `--` is the command to run.
+    if (ctx.args.length > 0) {
+        const [cmd, ...cmdArgs] = ctx.args;
+        const r = spawnSync(cmd, cmdArgs, {
+            cwd: ctx.cwd,
+            encoding: 'utf8',
+            maxBuffer: 256 * 1024 * 1024,
+            // Merge streams so interleaved stdout/stderr stay in order.
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        if (r.error) {
+            output.printError(`failed to run ${cmd}: ${r.error.message}`);
+            return { success: false, exitCode: 127 };
+        }
+        const combined = (r.stdout || '') + (r.stderr || '');
+        const { text, stats } = compactOutput(combined, opts);
+        process.stdout.write(text);
+        if (!quiet)
+            process.stderr.write(formatSavings(stats) + '\n');
+        // Propagate the wrapped command's exit code verbatim.
+        const code = r.status ?? (r.signal ? 1 : 0);
+        return { success: code === 0, exitCode: code };
+    }
+    // Stdin-filter mode.
+    if (process.stdin.isTTY) {
+        output.writeln(output.error('Usage: swarmdo compact -- <command>   OR   <command> | swarmdo compact'));
+        return { success: false, exitCode: 1 };
+    }
+    const input = await readStdin();
+    const { text, stats } = compactOutput(input, opts);
+    if (ctx.flags['stats-json'] === true) {
+        process.stderr.write(JSON.stringify(stats) + '\n');
+    }
+    else if (!quiet) {
+        process.stderr.write(formatSavings(stats) + '\n');
+    }
+    process.stdout.write(text);
+    return { success: true, exitCode: 0 };
+}
+export const compactCommand = {
+    name: 'compact',
+    description: 'Compress noisy command output (tests/builds/logs) before it reaches an LLM — deterministic, zero tokens',
+    options: [
+        { name: 'no-ansi', description: 'keep ANSI colour/escape codes (default: strip)', type: 'boolean' },
+        { name: 'no-fold', description: 'keep full node_modules stack frames (default: fold)', type: 'boolean' },
+        { name: 'min-run', description: 'collapse a run of ≥N identical lines (default 3; 0 disables)', type: 'string' },
+        { name: 'window', description: 'keep first H + last T lines of long output, e.g. --window 40:20', type: 'string' },
+        { name: 'stats-json', description: 'emit compaction stats as JSON on stderr (stdin mode)', type: 'boolean' },
+        { name: 'quiet', description: 'suppress the savings summary on stderr', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'npm test 2>&1 | swarmdo compact', description: 'Filter noisy test output on stdin' },
+        { command: 'swarmdo compact -- npm run build', description: 'Wrap a command; exit code propagates' },
+        { command: 'swarmdo compact --window 40:20 -- pnpm install', description: 'Head+tail window a long install log' },
+    ],
+    action: run,
+};
+export default compactCommand;
+//# sourceMappingURL=compact.js.map

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

@@ -3413,32 +3413,34 @@ const statuslineCommand = {
             const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
             return { domainsCompleted, totalDomains, dddProgress, patternsLearned: learning.patterns, sessionsCompleted: learning.sessions };
         }
-        // Get security status
+        // Get security status from the last real `security scan` artifact.
+        // (Until v1.4.17 this counted files in never-written directories against a
+        // hardcoded totalCves=3 — the V3-era CVE-1/2/3 tracker — so every install
+        // showed PENDING forever.)
         function getSecurityStatus() {
-            const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
-            let cvesFixed = 0;
-            const totalCves = 3;
-            if (fs.existsSync(scanResultsPath)) {
-                try {
-                    const scans = fs.readdirSync(scanResultsPath).filter((f) => f.endsWith('.json'));
-                    cvesFixed = Math.min(totalCves, scans.length);
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            const auditPath = path.join(process.cwd(), '.swarm', 'security');
-            if (fs.existsSync(auditPath)) {
+            const candidates = [
+                path.join(process.cwd(), '.swarmdo', 'security', 'last-scan.json'),
+                path.join(process.cwd(), '.swarm', 'security', 'last-scan.json'), // legacy layout
+            ];
+            for (const p of candidates) {
                 try {
-                    const audits = fs.readdirSync(auditPath).filter((f) => f.includes('audit'));
-                    cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
+                    if (!fs.existsSync(p))
+                        continue;
+                    const scan = JSON.parse(fs.readFileSync(p, 'utf-8'));
+                    const critical = Number(scan.critical) || 0;
+                    const high = Number(scan.high) || 0;
+                    const total = Number(scan.total) || 0;
+                    const scannedAt = typeof scan.scannedAt === 'string' ? scan.scannedAt : null;
+                    const ageMs = scannedAt ? Date.now() - new Date(scannedAt).getTime() : Number.POSITIVE_INFINITY;
+                    const status = critical + high > 0 ? 'VULN' : ageMs > 7 * 24 * 3600 * 1000 ? 'STALE' : 'CLEAN';
+                    return { status, critical, high, total, scannedAt };
                 }
                 catch {
-                    // Ignore
+                    // unreadable artifact — try next candidate
                 }
             }
-            const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
-            return { status, cvesFixed, totalCves };
+            // no scan has ever run — nothing is "pending", there is just no data
+            return { status: 'NONE', critical: 0, high: 0, total: 0, scannedAt: null };
         }
         // Get swarm status
         function getSwarmStatus() {
@@ -3578,7 +3580,7 @@ const statuslineCommand = {
         const terminalCols = process.stdout.columns ?? 80;
         const autoCompact = !ctx.flags.full && terminalCols < COMPACT_WIDTH_THRESHOLD;
         if (ctx.flags.compact || autoCompact) {
-            const line = `DDD:${progress.domainsCompleted}/${progress.totalDomains} CVE:${security.cvesFixed}/${security.totalCves} Swarm:${swarm.activeAgents}/${swarm.maxAgents} Ctx:${system.contextPct}% Int:${system.intelligencePct}%`;
+            const line = `DDD:${progress.domainsCompleted}/${progress.totalDomains} Sec:${security.status} Swarm:${swarm.activeAgents}/${swarm.maxAgents} Ctx:${system.contextPct}% Int:${system.intelligencePct}%`;
             output.writeln(line);
             return { success: true, data: statusData };
         }
@@ -3752,13 +3754,13 @@ const statuslineCommand = {
             perfIndicator;
         const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
         const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-        const securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
-        const securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
+        const securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'STALE' ? '🟡' : security.status === 'NONE' ? '⚪' : '🔴';
+        const securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'STALE' ? c.brightYellow : security.status === 'NONE' ? c.dim : c.brightRed;
         const hooksColor = hooksStats.enabled > 0 ? c.brightGreen : c.dim;
         const line2 = `${c.brightYellow}🤖 Swarm${c.reset}  ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
             `${c.brightPurple}👥 ${system.subAgents}${c.reset}    ` +
             `${c.brightBlue}🪝 ${hooksColor}${hooksStats.enabled}${c.reset}/${c.brightWhite}${hooksStats.total}${c.reset}    ` +
-            `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}    ` +
+            `${securityIcon} ${securityColor}sec ${security.status === 'VULN' ? (security.critical + security.high) + '!' : security.status === 'CLEAN' ? '✓' : security.status === 'STALE' ? 'stale' : '—'}${c.reset}    ` +
             `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}    ` +
             `${c.brightPurple}🧠 ${String(system.intelligencePct).padStart(3)}%${c.reset}`;
         const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;

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

@@ -19,6 +19,9 @@ const commandLoaders = {
     status: () => import('./status.js'),
     statusline: () => import('./statusline.js'),
     compress: () => import('./compress.js'),
+    // Deterministic command-output compression (rtk/headroom demand) — a
+    // zero-token stream filter, distinct from caveman `compress` for files.
+    compact: () => import('./compact.js'),
     efficiency: () => import('./efficiency.js'),
     task: () => import('./task.js'),
     session: () => import('./session.js'),
@@ -68,6 +71,10 @@ const commandLoaders = {
     preset: () => import('./preset.js'),
     presets: () => import('./preset.js'), // alias via loader key
     // Release notes from conventional commits (git-cliff/conventional-changelog demand)
+    integrations: () => import('./integrations.js'),
+    integrate: () => import('./integrations.js'), // alias via loader key
+    release: () => import('./release.js'),
+    ship: () => import('./release.js'), // alias via loader key
     changelog: () => import('./changelog.js'),
     notes: () => import('./changelog.js'), // alias via loader key
     // Q-Learning Routing Commands
@@ -244,7 +251,7 @@ export async function getCommandsByCategory() {
     // three slots from 'statusline' onward (completionsCmd received the
     // statusline module, analyzeCmd received completions, …), scrambling the
     // categorized help. Every load now has a named slot.
-    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd,] = await Promise.all([
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, swarmvectorCmd, hiveMindCmd, configCmd, statuslineCmd, compressCmd, efficiencyCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, demoCmd, usageCmd, repairCmd, hudCmd, compactCmd,] = await Promise.all([
         loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
         loadCommand('performance'), loadCommand('security'), loadCommand('swarmvector'), loadCommand('hive-mind'),
         loadCommand('config'), loadCommand('statusline'), loadCommand('compress'), loadCommand('efficiency'),
@@ -252,7 +259,7 @@ export async function getCommandsByCategory() {
         loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
         loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
         loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
-        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'),
     ]);
     return {
         primary: [
@@ -268,7 +275,7 @@ export async function getCommandsByCategory() {
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
             migrateCmd, workflowCmd, demoCmd,
-            statuslineCmd, compressCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd,

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

@@ -0,0 +1,14 @@
+/**
+ * integrations.ts — `swarmdo integrations` (alias `integrate`)
+ *
+ * Wire swarmdo into agent CLIs beyond Claude Code: Codex CLI, GitHub
+ * Copilot CLI, pi. Dry-run by default; `--apply` writes. All merges are
+ * additive + idempotent (pure engine in ../integrations/integrations.js).
+ *
+ * NEVER writes `.claude/**`, `.mcp.json`, or `CLAUDE.md` — the Claude Code
+ * integration is owned by `swarmdo init` and only read for status.
+ */
+import type { Command } from '../types.js';
+export declare const integrationsCommand: Command;
+export default integrationsCommand;
+//# sourceMappingURL=integrations.d.ts.map

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

@@ -0,0 +1,158 @@
+/**
+ * integrations.ts — `swarmdo integrations` (alias `integrate`)
+ *
+ * Wire swarmdo into agent CLIs beyond Claude Code: Codex CLI, GitHub
+ * Copilot CLI, pi. Dry-run by default; `--apply` writes. All merges are
+ * additive + idempotent (pure engine in ../integrations/integrations.js).
+ *
+ * NEVER writes `.claude/**`, `.mcp.json`, or `CLAUDE.md` — the Claude Code
+ * integration is owned by `swarmdo init` and only read for status.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { output } from '../output.js';
+import { mergeCodexToml, mergeCopilotMcpJson, crossAgentAgentsMd, copilotInstructionsMd, evaluateStatus, INSTALLABLE, } from '../integrations/integrations.js';
+function readOrNull(p) {
+    try {
+        return fs.readFileSync(p, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function planFor(target, cwd, home) {
+    const writes = [];
+    const notes = [];
+    const agentsPath = path.join(cwd, 'AGENTS.md');
+    const ensureAgentsMd = () => {
+        if (readOrNull(agentsPath) === null) {
+            writes.push({ file: agentsPath, kind: 'create', content: crossAgentAgentsMd() });
+        }
+        else {
+            notes.push('AGENTS.md already exists — left untouched (teams own their AGENTS.md)');
+        }
+    };
+    switch (target) {
+        case 'codex': {
+            ensureAgentsMd();
+            const tomlPath = path.join(home, '.codex', 'config.toml');
+            const merged = mergeCodexToml(readOrNull(tomlPath));
+            if (merged.changed)
+                writes.push({ file: tomlPath, kind: readOrNull(tomlPath) === null ? 'create' : 'update', content: merged.content });
+            else
+                notes.push('~/.codex/config.toml already has [mcp_servers.swarmdo]');
+            break;
+        }
+        case 'copilot': {
+            ensureAgentsMd();
+            const instrPath = path.join(cwd, '.github', 'copilot-instructions.md');
+            if (readOrNull(instrPath) === null)
+                writes.push({ file: instrPath, kind: 'create', content: copilotInstructionsMd() });
+            else
+                notes.push('.github/copilot-instructions.md already exists — left untouched');
+            const jsonPath = path.join(home, '.copilot', 'mcp-config.json');
+            const merged = mergeCopilotMcpJson(readOrNull(jsonPath));
+            if (merged.changed)
+                writes.push({ file: jsonPath, kind: readOrNull(jsonPath) === null ? 'create' : 'update', content: merged.content });
+            else
+                notes.push('~/.copilot/mcp-config.json already has the swarmdo server (or is unparseable — never clobbered)');
+            break;
+        }
+        case 'pi': {
+            ensureAgentsMd();
+            notes.push('pi reads AGENTS.md natively; if your pi build supports MCP servers, point it at: npx -y swarmdo@latest mcp start');
+            break;
+        }
+        case 'claude':
+            notes.push('Claude Code integration is managed by `swarmdo init` — nothing to install here (read-only status)');
+            break;
+    }
+    return { writes, notes };
+}
+export const integrationsCommand = {
+    name: 'integrations',
+    aliases: ['integrate'],
+    description: 'Wire swarmdo into other agent CLIs (codex, copilot, pi) via AGENTS.md + MCP — never touches the Claude Code surfaces',
+    options: [
+        { name: 'apply', type: 'boolean', description: 'write the changes (default: preview)', default: false },
+        { name: 'json', type: 'boolean', description: 'machine-readable output', default: false },
+    ],
+    examples: [
+        { command: 'swarmdo integrations', description: 'Status of every CLI integration' },
+        { command: 'swarmdo integrations install all --apply', description: 'Wire codex + copilot + pi' },
+        { command: 'swarmdo integrations install codex --apply', description: 'AGENTS.md + [mcp_servers.swarmdo] in ~/.codex/config.toml' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const home = os.homedir();
+        const sub = (ctx.args[0] || 'status').toLowerCase();
+        const gatherStatus = () => evaluateStatus({
+            agentsMd: readOrNull(path.join(cwd, 'AGENTS.md')),
+            codexToml: readOrNull(path.join(home, '.codex', 'config.toml')),
+            copilotJson: readOrNull(path.join(home, '.copilot', 'mcp-config.json')),
+            copilotInstructions: readOrNull(path.join(cwd, '.github', 'copilot-instructions.md')),
+            claudeMcpJson: readOrNull(path.join(cwd, '.mcp.json')),
+            claudeUserJson: readOrNull(path.join(home, '.claude.json')),
+            claudeDirExists: fs.existsSync(path.join(cwd, '.claude')),
+        });
+        if (sub === 'status' || sub === 'list') {
+            const statuses = gatherStatus();
+            if (ctx.flags.json === true) {
+                output.printJson(statuses);
+                return { success: true, data: statuses };
+            }
+            output.writeln(output.bold('Agent CLI integrations'));
+            for (const s of statuses) {
+                output.writeln(`  ${s.ok ? '◉' : '○'} ${s.target}`);
+                for (const d of s.details)
+                    output.writeln(output.dim(`      ${d}`));
+            }
+            output.writeln(output.dim('install:  swarmdo integrations install <codex|copilot|pi|all> --apply'));
+            return { success: true };
+        }
+        if (sub !== 'install') {
+            output.printError(`unknown subcommand "${sub}" (expected status|install)`);
+            return { success: false, exitCode: 1 };
+        }
+        const rawTarget = (ctx.args[1] || '').toLowerCase();
+        const targets = rawTarget === 'all'
+            ? INSTALLABLE
+            : INSTALLABLE.includes(rawTarget) ? [rawTarget] : [];
+        if (targets.length === 0) {
+            output.printError(`install what? (${INSTALLABLE.join('|')}|all) — claude is managed by \`swarmdo init\``);
+            return { success: false, exitCode: 1 };
+        }
+        const allWrites = [];
+        for (const t of targets) {
+            const { writes, notes } = planFor(t, cwd, home);
+            output.writeln(output.bold(`▸ ${t}`));
+            for (const w of writes) {
+                // safety invariant: never under .claude/, never .mcp.json, never CLAUDE.md
+                const rel = path.relative(cwd, w.file);
+                if (rel.startsWith('.claude') || rel === '.mcp.json' || rel === 'CLAUDE.md') {
+                    output.printError(`refusing to touch Claude Code surface: ${w.file}`);
+                    return { success: false, exitCode: 1 };
+                }
+                output.writeln(`    ${w.kind === 'create' ? '+' : '~'} ${w.file}`);
+                allWrites.push(w);
+            }
+            for (const n of notes)
+                output.writeln(output.dim(`    · ${n}`));
+        }
+        if (ctx.flags.apply !== true) {
+            output.writeln('');
+            output.writeln(output.dim(`dry run — ${allWrites.length} write(s) planned; re-run with --apply`));
+            return { success: true, data: { dryRun: true, writes: allWrites.map((w) => w.file) } };
+        }
+        for (const w of allWrites) {
+            fs.mkdirSync(path.dirname(w.file), { recursive: true });
+            fs.writeFileSync(w.file, w.content, 'utf8');
+        }
+        output.printSuccess(`applied ${allWrites.length} write(s)`);
+        output.writeln(output.dim('restart the target CLI(s) to pick up MCP config changes'));
+        return { success: true, data: { applied: allWrites.map((w) => w.file) } };
+    },
+};
+export default integrationsCommand;
+//# sourceMappingURL=integrations.js.map

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

@@ -1230,12 +1230,20 @@ const importCommand = {
             type: 'string',
             choices: ['json', 'obsidian', 'md'],
             default: 'json'
+        },
+        {
+            name: 'watch',
+            short: 'w',
+            description: 'Keep watching the vault directory and sync notes as they change (obsidian format only; Ctrl-C to stop)',
+            type: 'boolean',
+            default: false
         }
     ],
     examples: [
         { command: 'swarmdo memory import -i ./backup.json', description: 'Import from file' },
         { command: 'swarmdo memory import -i ./data.json -n archive', description: 'Import to namespace' },
-        { command: 'swarmdo memory import -i ./vault -f obsidian', description: 'Sync an edited Obsidian vault back into memory (re-embeds; foreign notes skipped)' }
+        { command: 'swarmdo memory import -i ./vault -f obsidian', description: 'Sync an edited Obsidian vault back into memory (re-embeds; foreign notes skipped)' },
+        { command: 'swarmdo memory import -i ./vault -f obsidian --watch', description: 'Live-sync: watch the vault and import notes as you save them in Obsidian' }
     ],
     action: async (ctx) => {
         const inputPath = ctx.flags.input || ctx.args[0];
@@ -1290,6 +1298,47 @@ const importCommand = {
                     `Foreign notes ignored: ${foreign}`,
                     `Index files ignored: ${index}`,
                 ]);
+                if (ctx.flags.watch === true) {
+                    const { ChangeCollector } = await import('../memory-vault/watch.js');
+                    const { parseVault } = await import('../memory-vault/import.js');
+                    output.writeln(output.dim(`watching ${inputPath}/ — save a note in Obsidian to sync it (Ctrl-C to stop)`));
+                    const syncBatch = async (rels) => {
+                        const files = rels
+                            .filter((rel) => fs.existsSync(path.join(inputPath, rel)))
+                            .map((rel) => ({ relPath: rel, content: fs.readFileSync(path.join(inputPath, rel), 'utf8') }));
+                        const parsed = parseVault(files);
+                        if (parsed.entries.length === 0)
+                            return;
+                        const btmp = path.join(os.tmpdir(), `swarmdo-vaultwatch-${process.pid}-${Math.floor(Math.random() * 1e6)}.json`);
+                        try {
+                            fs.writeFileSync(btmp, JSON.stringify({ schema: 'swarmdo-memory-export/v1', entries: parsed.entries }), 'utf8');
+                            const r = await callMCPTool('memory_import', { inputPath: btmp, merge: true, namespace: ctx.flags.namespace });
+                            output.writeln(`  ⇄ synced ${r.imported.entries} note${r.imported.entries === 1 ? '' : 's'}: ${rels.join(', ')}`);
+                        }
+                        catch (e) {
+                            output.printError(`sync failed for ${rels.join(', ')}: ${e instanceof MCPClientError ? e.message : String(e)}`);
+                        }
+                        finally {
+                            try {
+                                fs.rmSync(btmp, { force: true });
+                            }
+                            catch { /* best-effort */ }
+                        }
+                    };
+                    let syncing = Promise.resolve();
+                    const collector = new ChangeCollector((rels) => { syncing = syncing.then(() => syncBatch(rels)); });
+                    const watcher = fs.watch(inputPath, { recursive: true }, (_event, filename) => {
+                        if (filename)
+                            collector.add(String(filename));
+                    });
+                    await new Promise((resolve) => {
+                        const stop = () => { watcher.close(); collector.drain(); resolve(); };
+                        process.once('SIGINT', stop);
+                        process.once('SIGTERM', stop);
+                    });
+                    await syncing;
+                    return { success: true, data: { watched: true } };
+                }
                 return { success: true, data: { imported: result.imported.entries, foreign, index } };
             }
             catch (error) {

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

@@ -14,6 +14,9 @@ const PROVIDER_CATALOG = [
     // #1725: Ollama Cloud — Tier-2 default per ADR-026 (~$100/mo flat-rate alternative
     // to per-token pricing). OpenAI-compat API at https://ollama.com/v1/chat/completions.
     { name: 'Ollama', type: 'LLM', models: 'gpt-oss:120b-cloud, llama3:70b-cloud, qwen2.5-coder:32b-cloud', envVar: 'OLLAMA_API_KEY', configName: 'ollama' },
+    // Configurable multi-model gateway: swarms select among the models the
+    // user declares in swarmdo.config.json `openrouter.models` (tier-mapped).
+    { name: 'OpenRouter', type: 'LLM', models: 'any OpenRouter slug — pool configured in swarmdo.config.json', envVar: 'OPENROUTER_API_KEY', configName: 'openrouter' },
     { name: 'Transformers.js', type: 'Embedding', models: 'Xenova/all-MiniLM-L6-v2' },
     { name: 'Agentic Flow', type: 'Embedding', models: 'ONNX optimized' },
     { name: 'Mock', type: 'All', models: 'mock-*' },