swarmdo 1.4.8 → 1.5.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.4.51';
   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

@@ -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
@@ -276,6 +276,8 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo task … --dependencies` | **Task dependency DAG** — `task ready` lists unblocked work, `task graph` renders the graph, the dispatcher gates on readiness |
 | `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 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`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.4.8",
+  "version": "1.5.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/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

@@ -68,6 +68,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

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-*' },

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

@@ -0,0 +1,15 @@
+/**
+ * release.ts — `swarmdo release [patch|minor|major|x.y.z]`
+ *
+ * One command for the whole proven release train: bump the version trio +
+ * lockfile, sync doc version strings, commit+push, build + stage the
+ * self-contained @swarmdo/cli, publish both packages, verify the registry,
+ * tag, and cut a GitHub release with `swarmdo changelog` notes.
+ *
+ * DRY-RUN BY DEFAULT — prints the exact plan; `--confirm` executes it
+ * step-by-step and stops on the first failure.
+ */
+import type { Command } from '../types.js';
+export declare const releaseCommand: Command;
+export default releaseCommand;
+//# sourceMappingURL=release.d.ts.map