swarmdo 1.4.8 → 1.6.0

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

@@ -0,0 +1,170 @@
+/**
+ * compact.ts — deterministic command-output compression.
+ *
+ * Noisy command output (test runners, builds, installers, `git log`) burns a
+ * large share of an agent's context window on repetition and formatting that
+ * carries no signal. This engine shrinks that output BEFORE it reaches an LLM,
+ * with no model call — every transform is a pure, signal-preserving rewrite:
+ *
+ *   1. strip ANSI escape sequences (colour, cursor moves)
+ *   2. resolve carriage-return progress spam to each line's final state
+ *   3. collapse runs of identical consecutive lines → `<line>  … (×N)`
+ *   4. fold consecutive node_modules stack frames → `… N frames in node_modules`
+ *   5. collapse ≥3 blank lines to one; trim trailing whitespace
+ *   6. (opt-in) window very long output to head + tail with an elision marker
+ *
+ * Distinct from `swarmdo compress` (caveman, LLM-based, for memory FILES) —
+ * this is a zero-token STREAM filter. Pure: no I/O, fully testable.
+ */
+// SGR colour codes, cursor moves, and other CSI/OSC escapes. Intentionally
+// broad within the ESC-[ / ESC-] families; does not touch ordinary text.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+const NODE_FRAME_RE = /^\s*at\s.*[/\\]node_modules[/\\]/;
+/** Remove ANSI escapes from a string. Exported for reuse/testing. */
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}
+/**
+ * Resolve carriage-return progress updates: a terminal renders `a\rb\rc` as
+ * just `c` (each CR returns to column 0 and overwrites). Keep the final
+ * segment of each line so progress bars collapse to their last frame.
+ */
+function resolveCarriageReturns(line) {
+    if (!line.includes('\r'))
+        return line;
+    const segs = line.split('\r');
+    // Drop empty trailing segment from a line that ended with \r.
+    while (segs.length > 1 && segs[segs.length - 1] === '')
+        segs.pop();
+    return segs[segs.length - 1] ?? '';
+}
+/**
+ * Collapse runs of ≥ minRun identical consecutive lines into `<line>  … (×N)`.
+ * Blank/whitespace-only runs are left untouched — those are the blank-line
+ * collapser's job, so the `(×N)` marker only ever tags repeated *content*.
+ */
+function collapseRepeats(lines, minRun) {
+    if (minRun <= 0)
+        return lines;
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i].trim() === '') {
+            out.push(lines[i]);
+            i++;
+            continue;
+        }
+        let j = i + 1;
+        while (j < lines.length && lines[j] === lines[i])
+            j++;
+        const run = j - i;
+        out.push(lines[i]);
+        if (run >= minRun)
+            out.push(`  … (×${run})`);
+        else
+            for (let k = 1; k < run; k++)
+                out.push(lines[i]);
+        i = j;
+    }
+    return out;
+}
+/** Fold consecutive node_modules stack frames into a single summary line. */
+function foldNodeFrames(lines) {
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (NODE_FRAME_RE.test(lines[i])) {
+            let j = i + 1;
+            while (j < lines.length && NODE_FRAME_RE.test(lines[j]))
+                j++;
+            const run = j - i;
+            if (run >= 2) {
+                const indent = lines[i].match(/^\s*/)?.[0] ?? '    ';
+                out.push(`${indent}… ${run} frames in node_modules`);
+            }
+            else {
+                out.push(lines[i]);
+            }
+            i = j;
+        }
+        else {
+            out.push(lines[i]);
+            i++;
+        }
+    }
+    return out;
+}
+/** Collapse ≥3 consecutive blank lines to a single blank. */
+function collapseBlankLines(lines) {
+    const out = [];
+    let blanks = 0;
+    for (const line of lines) {
+        if (line.trim() === '') {
+            blanks++;
+            if (blanks <= 1)
+                out.push('');
+        }
+        else {
+            blanks = 0;
+            out.push(line);
+        }
+    }
+    return out;
+}
+/** Keep head + tail lines, eliding the middle with a marker. */
+function windowLines(lines, head, tail) {
+    if (lines.length <= head + tail + 1)
+        return lines;
+    const elided = lines.length - head - tail;
+    return [
+        ...lines.slice(0, head),
+        `… ${elided} lines elided …`,
+        ...lines.slice(lines.length - tail),
+    ];
+}
+/**
+ * Compact command output. Pure — returns the rewritten text plus byte/line
+ * savings. The input's trailing newline (if any) is preserved.
+ */
+export function compactOutput(input, opts = {}) {
+    const { stripAnsi: doStrip = true, minRun = 3, foldNodeModules = true, collapseBlanks = true, window, } = opts;
+    const bytesIn = Buffer.byteLength(input, 'utf8');
+    const hadTrailingNewline = input.endsWith('\n');
+    let text = doStrip ? stripAnsi(input) : input;
+    // Split without the trailing empty element a final newline would create.
+    let lines = text.split('\n');
+    if (hadTrailingNewline)
+        lines.pop();
+    const linesIn = lines.length;
+    lines = lines.map(resolveCarriageReturns);
+    if (minRun > 0)
+        lines = collapseRepeats(lines, minRun);
+    if (foldNodeModules)
+        lines = foldNodeFrames(lines);
+    if (collapseBlanks)
+        lines = collapseBlankLines(lines);
+    if (window)
+        lines = windowLines(lines, window.head, window.tail);
+    const linesOut = lines.length;
+    text = lines.join('\n');
+    if (hadTrailingNewline && text !== '')
+        text += '\n';
+    const bytesOut = Buffer.byteLength(text, 'utf8');
+    const savedFraction = bytesIn === 0 ? 0 : Math.max(0, (bytesIn - bytesOut) / bytesIn);
+    return { text, stats: { linesIn, linesOut, bytesIn, bytesOut, savedFraction } };
+}
+/** Human-readable byte count (for the savings summary). */
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+/** One-line savings summary for stderr. */
+export function formatSavings(stats) {
+    const pct = Math.round(stats.savedFraction * 100);
+    return `compacted: ${stats.linesIn}→${stats.linesOut} lines, ${formatBytes(stats.bytesIn)}→${formatBytes(stats.bytesOut)} (−${pct}%)`;
+}
+//# sourceMappingURL=compact.js.map

package/v3/@swarmdo/cli/dist/src/config-lint/lint.js

@@ -11,7 +11,8 @@
 const f = (file, severity, rule, message) => ({ file, severity, rule, message });
 export const TOPOLOGIES = ['hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive'];
 export const MEMORY_BACKENDS = ['agentdb', 'sqlite', 'hybrid', 'memory'];
-export const KNOWN_CONFIG_KEYS = ['topology', 'maxAgents', 'strategy', 'consensus', 'memory', 'memoryBackend', 'hnsw', 'neural', 'embeddings', 'providers', 'mcp', 'logging', 'daemon', 'hooks', 'version', '$schema'];
+import { parseOpenRouterConfig } from '../providers/openrouter-config.js';
+export const KNOWN_CONFIG_KEYS = ['topology', 'maxAgents', 'strategy', 'consensus', 'memory', 'memoryBackend', 'hnsw', 'neural', 'embeddings', 'providers', 'mcp', 'logging', 'daemon', 'hooks', 'version', 'openrouter', '$schema'];
 export const HOOK_EVENTS = [
     'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop', 'SubagentStop',
     'SessionStart', 'SessionEnd', 'PreCompact', 'TeammateIdle', 'TaskCompleted', 'PermissionDecision',
@@ -39,6 +40,15 @@ export function lintSwarmdoConfig(file, obj) {
     for (const key of Object.keys(c)) {
         if (!KNOWN_CONFIG_KEYS.includes(key))
             out.push(f(file, 'warn', 'unknown-key', `unknown key "${key}" (known: ${KNOWN_CONFIG_KEYS.filter(k => k !== '$schema').join(', ')})`));
+        if (key === 'openrouter') {
+            // reuse the runtime parser so lint findings and runtime behavior can't drift
+            const { config: orCfg, warnings } = parseOpenRouterConfig(c.openrouter);
+            for (const w of warnings)
+                out.push(f(file, 'warn', 'openrouter-config', w));
+            if (orCfg.enabled && orCfg.models.length === 0 && !orCfg.defaultModel) {
+                out.push(f(file, 'warn', 'openrouter-config', 'openrouter.enabled=true but no valid models[] or defaultModel — swarms have nothing to select from'));
+            }
+        }
     }
     if (c.topology !== undefined && !TOPOLOGIES.includes(String(c.topology))) {
         out.push(f(file, 'error', 'bad-topology', `topology "${String(c.topology)}" is not one of: ${TOPOLOGIES.join(', ')}`));

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

@@ -93,8 +93,10 @@ export class CLI {
             // Parse arguments
             const parseResult = this.parser.parse(args);
             const { command: commandPath, flags, positional } = parseResult;
-            // Handle global flags
-            if (flags.version || flags.V) {
+            // Handle global flags. --version is only global when no command was
+            // resolved — commands may define their own `version` option (e.g.
+            // `changelog --version v1.5.0`), which this used to swallow.
+            if (!commandPath && (flags.version || flags.V)) {
                 this.showVersion();
                 return;
             }

package/v3/@swarmdo/cli/dist/src/init/statusline-generator.js

@@ -384,7 +384,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(),
@@ -652,9 +652,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;
@@ -720,8 +720,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;
 
@@ -729,7 +729,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/v3/@swarmdo/cli/dist/src/integrations/integrations.d.ts

@@ -0,0 +1,54 @@
+/**
+ * integrations.ts — wire swarmdo into agent CLIs beyond Claude Code.
+ *
+ * Targets: OpenAI Codex CLI, GitHub Copilot CLI, pi. Two standards do the
+ * heavy lifting: AGENTS.md (the cross-agent instructions file all three
+ * read) and MCP (swarmdo already ships a stdio server — `swarmdo mcp
+ * start`). Each merge below is PURE (string/JSON in → out), additive, and
+ * idempotent, so the whole surface is unit-testable and re-running install
+ * never duplicates or clobbers.
+ *
+ * INVARIANT (do-not-break-Claude): nothing in this module produces content
+ * for `.claude/**`, `.mcp.json`, or `CLAUDE.md` — the Claude Code surfaces
+ * are owned by init/mcp-generator and are only ever READ for status here.
+ */
+export declare const MCP_COMMAND = "npx";
+export declare const MCP_ARGS: string[];
+/** Codex CLI (~/.codex/config.toml): add the marked [mcp_servers.swarmdo]
+ * block when absent. Existing content — including a user's own hand-written
+ * swarmdo server — is left untouched. */
+export declare function mergeCodexToml(existing: string | null): {
+    content: string;
+    changed: boolean;
+};
+/** Copilot CLI (~/.copilot/mcp-config.json): same mcpServers schema Claude
+ * uses. Adds the swarmdo entry when absent; other servers preserved. */
+export declare function mergeCopilotMcpJson(existing: string | null): {
+    content: string;
+    changed: boolean;
+};
+/** Cross-agent AGENTS.md for projects that don't have one. Existing files
+ * are never rewritten (report-only) — teams own their AGENTS.md. */
+export declare function crossAgentAgentsMd(): string;
+/** .github/copilot-instructions.md — Copilot reads this per-repo. Kept as a
+ * thin pointer so AGENTS.md stays the single source of truth. */
+export declare function copilotInstructionsMd(): string;
+export type IntegrationTarget = 'codex' | 'copilot' | 'pi' | 'claude';
+export declare const INSTALLABLE: IntegrationTarget[];
+export interface TargetStatus {
+    target: IntegrationTarget;
+    ok: boolean;
+    details: string[];
+}
+/** Pure status evaluation over pre-read file contents (null = absent). */
+export declare function evaluateStatus(files: {
+    agentsMd: string | null;
+    codexToml: string | null;
+    copilotJson: string | null;
+    copilotInstructions: string | null;
+    claudeMcpJson: string | null;
+    /** ~/.claude.json — Claude Code's user-level config (claude mcp add) */
+    claudeUserJson?: string | null;
+    claudeDirExists: boolean;
+}): TargetStatus[];
+//# sourceMappingURL=integrations.d.ts.map

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

@@ -0,0 +1,162 @@
+/**
+ * integrations.ts — wire swarmdo into agent CLIs beyond Claude Code.
+ *
+ * Targets: OpenAI Codex CLI, GitHub Copilot CLI, pi. Two standards do the
+ * heavy lifting: AGENTS.md (the cross-agent instructions file all three
+ * read) and MCP (swarmdo already ships a stdio server — `swarmdo mcp
+ * start`). Each merge below is PURE (string/JSON in → out), additive, and
+ * idempotent, so the whole surface is unit-testable and re-running install
+ * never duplicates or clobbers.
+ *
+ * INVARIANT (do-not-break-Claude): nothing in this module produces content
+ * for `.claude/**`, `.mcp.json`, or `CLAUDE.md` — the Claude Code surfaces
+ * are owned by init/mcp-generator and are only ever READ for status here.
+ */
+export const MCP_COMMAND = 'npx';
+export const MCP_ARGS = ['-y', 'swarmdo@latest', 'mcp', 'start'];
+const TOML_BEGIN = '# >>> swarmdo mcp (managed by `swarmdo integrations`) >>>';
+const TOML_END = '# <<< swarmdo mcp <<<';
+/** Codex CLI (~/.codex/config.toml): add the marked [mcp_servers.swarmdo]
+ * block when absent. Existing content — including a user's own hand-written
+ * swarmdo server — is left untouched. */
+export function mergeCodexToml(existing) {
+    const base = existing ?? '';
+    if (base.includes(TOML_BEGIN) || /\[mcp_servers\.swarmdo\]/.test(base)) {
+        return { content: base, changed: false };
+    }
+    const block = [
+        TOML_BEGIN,
+        '[mcp_servers.swarmdo]',
+        `command = "${MCP_COMMAND}"`,
+        `args = [${MCP_ARGS.map((a) => `"${a}"`).join(', ')}]`,
+        TOML_END,
+        '',
+    ].join('\n');
+    const sep = base.length > 0 && !base.endsWith('\n\n') ? (base.endsWith('\n') ? '\n' : '\n\n') : '';
+    return { content: base + sep + block, changed: true };
+}
+/** Copilot CLI (~/.copilot/mcp-config.json): same mcpServers schema Claude
+ * uses. Adds the swarmdo entry when absent; other servers preserved. */
+export function mergeCopilotMcpJson(existing) {
+    let cfg;
+    try {
+        cfg = existing ? JSON.parse(existing) : {};
+    }
+    catch {
+        // never clobber an unparseable user file
+        return { content: existing ?? '', changed: false };
+    }
+    if (cfg.mcpServers && Object.prototype.hasOwnProperty.call(cfg.mcpServers, 'swarmdo')) {
+        return { content: JSON.stringify(cfg, null, 2) + '\n', changed: false };
+    }
+    cfg.mcpServers = { ...(cfg.mcpServers ?? {}), swarmdo: { type: 'local', command: MCP_COMMAND, args: MCP_ARGS, tools: ['*'] } };
+    return { content: JSON.stringify(cfg, null, 2) + '\n', changed: true };
+}
+/** Cross-agent AGENTS.md for projects that don't have one. Existing files
+ * are never rewritten (report-only) — teams own their AGENTS.md. */
+export function crossAgentAgentsMd() {
+    return `# AGENTS.md — swarmdo project
+
+> Read by Codex CLI, GitHub Copilot CLI, pi, and other AGENTS.md-aware
+> agents. Claude Code uses CLAUDE.md instead — both coexist in this repo.
+
+## What swarmdo gives you
+
+This project is wired to **swarmdo** — agent orchestration with persistent
+vector memory, swarm coordination, and 300+ MCP tools.
+
+- **MCP server**: \`swarmdo mcp start\` (stdio). If your CLI supports MCP,
+  \`swarmdo integrations install <your-cli>\` wires it; key tools:
+  \`memory_search\`, \`memory_store\`, \`swarm_init\`, \`agent_spawn\`.
+- **CLI**: \`npx swarmdo@latest <command>\` — \`memory search -q "topic"\`,
+  \`usage\`, \`task\`, \`hud\`, \`security scan\`, \`config lint\`.
+
+## Working agreement (any agent)
+
+1. **Search memory BEFORE starting**: \`memory_search(query="task keywords")\`
+   — patterns with score > 0.7 are load-bearing precedent.
+2. **You are the executor** — swarmdo coordinates and remembers; it never
+   writes your code for you.
+3. **Store what worked AFTER success**:
+   \`memory_store(key="pattern-…", value="what worked", namespace="patterns")\`.
+4. Claude Code users: the same surfaces are namespaced under \`/sDo:\`
+   commands and \`/sdo-\` skills.
+
+## Do not
+
+- Do not commit secrets or .env files.
+- Do not edit \`.claude/\`, \`.mcp.json\`, or \`CLAUDE.md\` — those belong to
+  the Claude Code integration and are managed by \`swarmdo init\`.
+`;
+}
+/** .github/copilot-instructions.md — Copilot reads this per-repo. Kept as a
+ * thin pointer so AGENTS.md stays the single source of truth. */
+export function copilotInstructionsMd() {
+    return `# Copilot instructions
+
+This repository uses **swarmdo** for agent orchestration and persistent
+memory. Follow \`AGENTS.md\` at the repo root — it is the canonical
+cross-agent working agreement (memory-first workflow, executor role, MCP
+tools). The swarmdo MCP server (\`swarmdo mcp start\`) provides
+memory_search / memory_store / swarm_init; wire it with
+\`swarmdo integrations install copilot\`.
+`;
+}
+export const INSTALLABLE = ['codex', 'copilot', 'pi'];
+/** Pure status evaluation over pre-read file contents (null = absent). */
+export function evaluateStatus(files) {
+    const agentsOk = files.agentsMd !== null;
+    const codexMcp = !!files.codexToml && /\[mcp_servers\.swarmdo\]/.test(files.codexToml);
+    const copilotMcp = (() => {
+        try {
+            return !!files.copilotJson && 'swarmdo' in (JSON.parse(files.copilotJson).mcpServers ?? {});
+        }
+        catch {
+            return false;
+        }
+    })();
+    const hasSwarmdoServer = (raw) => {
+        try {
+            return !!raw && 'swarmdo' in (JSON.parse(raw).mcpServers ?? {});
+        }
+        catch {
+            return false;
+        }
+    };
+    const claudeProject = hasSwarmdoServer(files.claudeMcpJson);
+    const claudeUser = hasSwarmdoServer(files.claudeUserJson);
+    const claudeMcp = claudeProject || claudeUser;
+    return [
+        {
+            target: 'claude', ok: files.claudeDirExists && claudeMcp,
+            details: [
+                `.claude/ ${files.claudeDirExists ? 'present' : 'MISSING'}`,
+                `swarmdo MCP server ${claudeMcp ? `wired (${claudeProject ? '.mcp.json' : '~/.claude.json'})` : 'missing from .mcp.json and ~/.claude.json'}`,
+                '(read-only here — managed by `swarmdo init`)',
+            ],
+        },
+        {
+            target: 'codex', ok: agentsOk && codexMcp,
+            details: [
+                `AGENTS.md ${agentsOk ? 'present' : 'missing'}`,
+                `~/.codex/config.toml [mcp_servers.swarmdo] ${codexMcp ? 'wired' : 'missing'}`,
+            ],
+        },
+        {
+            target: 'copilot', ok: agentsOk && copilotMcp && files.copilotInstructions !== null,
+            details: [
+                `AGENTS.md ${agentsOk ? 'present' : 'missing'}`,
+                `.github/copilot-instructions.md ${files.copilotInstructions !== null ? 'present' : 'missing'}`,
+                `~/.copilot/mcp-config.json swarmdo server ${copilotMcp ? 'wired' : 'missing'}`,
+            ],
+        },
+        {
+            target: 'pi', ok: agentsOk,
+            details: [
+                `AGENTS.md ${agentsOk ? 'present (pi reads it natively)' : 'missing'}`,
+                'MCP: point pi at `npx -y swarmdo@latest mcp start` if your pi build supports MCP servers',
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=integrations.js.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/agent-execute-core.js

@@ -80,16 +80,34 @@ export async function callAnthropicMessages(input) {
     const useOpenRouter = explicitProvider === 'openrouter' || (!anthropicKey && !!openrouterKey);
     const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !!ollamaKey && !openrouterKey);
     if (useOpenRouter && openrouterKey) {
+        // Configurable model pool: swarmdo.config.json `openrouter` section lets
+        // the swarm draw from user-configured models (explicit slug > tier pick
+        // via Thompson sampling > config defaultModel). Env vars still win for
+        // base URL and as the final default for un-configured projects.
+        let configuredModel;
+        let configuredBaseUrl;
+        try {
+            const { loadOpenRouterConfig, resolveOpenRouterModel } = await import('../providers/openrouter-config.js');
+            const { config } = loadOpenRouterConfig();
+            if (config.enabled) {
+                configuredBaseUrl = config.baseUrl;
+                configuredModel = resolveOpenRouterModel({ requested: input.model, cfg: config })?.model;
+            }
+        }
+        catch { /* config unreadable — env-only behavior */ }
         return callOpenAICompat({
             ...input,
+            // a resolved pool pick replaces tier words / Anthropic ids; explicit
+            // slugs pass through resolveOpenRouterModel unchanged
+            model: configuredModel ?? input.model,
             apiKey: openrouterKey,
-            baseUrl: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api',
+            baseUrl: process.env.OPENROUTER_BASE_URL || configuredBaseUrl || 'https://openrouter.ai/api',
             providerLabel: 'openrouter',
             // #2357 Finding C: anthropic/claude-3.5-sonnet was retired Oct 2025.
             // Default to the same canonical family the rest of the resolver uses
             // (MODEL_MAP). `OPENROUTER_DEFAULT_MODEL` still wins for callers who
             // want to pin a specific OpenRouter slug.
-            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || 'anthropic/claude-sonnet-4-6',
+            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || configuredModel || 'anthropic/claude-sonnet-4-6',
         });
     }
     if (useOllama && ollamaKey) {
@@ -445,7 +463,8 @@ export async function executeAgentTask(input) {
     const fallbackBudget = Math.max(0, parseInt(process.env.SWARMDO_ROUTER_FALLBACK_MAX_RETRIES ?? '1', 10) || 1);
     const fallbackHistory = [];
     if (!result.success && agent.modelId && fallbackBudget > 0) {
-        const isRetryable = /\b(429|500|502|503|504|timeout|ECONNRESET|ETIMEDOUT)\b/i.test(result.error ?? '');
+        const { isRetryableError, computeBackoffMs, sleep } = await import('../resilience/backoff.js');
+        const isRetryable = isRetryableError(result.error);
         if (isRetryable) {
             try {
                 const { nextCostOptimalAlternative } = await import('../swarmvector/neural-router.js');
@@ -459,6 +478,9 @@ export async function executeAgentTask(input) {
                     const excludeIds = [agent.modelId];
                     for (let attempt = 0; attempt < fallbackBudget && !result.success; attempt++) {
                         fallbackHistory.push({ modelId: excludeIds[excludeIds.length - 1], error: result.error ?? '' });
+                        // full-jitter exponential backoff — a 429 is usually account-wide,
+                        // so an instant re-call against the same provider burns the attempt
+                        await sleep(computeBackoffMs(attempt));
                         const alt = await nextCostOptimalAlternative(embedding, excludeIds);
                         if (!alt || !alt.modelId)
                             break;

package/v3/@swarmdo/cli/dist/src/mcp-tools/agentdb-tools.js

@@ -996,11 +996,11 @@ export const agentdbGraphQuery = {
                 catch { /* fall through to sql.js */ }
                 // SQL CTE fallback for k-hop up to depth 3
                 try {
-                    const { getBridgeDb } = await import('../memory/graph-edge-writer.js');
+                    const { getBridgeDb, execRows } = await import('../memory/graph-edge-writer.js');
                     const db = await getBridgeDb();
                     if (db) {
                         const cteSql = buildKHopCTE(nodeId, Math.min(depth, 3), relation, budget.maxNodesVisited);
-                        const result = db.exec(cteSql);
+                        const result = execRows(db, cteSql);
                         const rows = result?.[0]?.values ?? [];
                         return {
                             success: true, mode, nodeId, depth,
@@ -1021,14 +1021,14 @@ export const agentdbGraphQuery = {
                     const queryEmb = await generateEmbedding(nodeId);
                     if (!queryEmb)
                         throw new Error('embedding failed');
-                    const { getBridgeDb } = await import('../memory/graph-edge-writer.js');
+                    const { getBridgeDb, execRows } = await import('../memory/graph-edge-writer.js');
                     // #2246 fix: lazy-create memory.db on first pathfinder call so
                     // fresh environments work without a pre-existing memory init.
                     const db = await getBridgeDb(undefined, { createIfMissing: true });
                     if (!db)
                         return { success: false, error: 'graph_edges DB unavailable (sql.js could not load)', hint: 'Check Node version + try `swarmdo memory init` to initialize manually.', mode, nodeId };
                     // Load all rows with embedding_ref and score by cosine
-                    const rowResult = db.exec(`SELECT id, source_id, target_id, relation, weight, embedding_ref FROM graph_edges WHERE embedding_ref IS NOT NULL LIMIT ?`, [budget.maxNodesVisited]);
+                    const rowResult = execRows(db, `SELECT id, source_id, target_id, relation, weight, embedding_ref FROM graph_edges WHERE embedding_ref IS NOT NULL LIMIT ?`, [budget.maxNodesVisited]);
                     const rows = rowResult?.[0]?.values ?? [];
                     const { decodeEmbedding } = await import('../memory/embedding-quantization.js');
                     const scored = [];
@@ -1061,13 +1061,13 @@ export const agentdbGraphQuery = {
             // ── pagerank mode ────────────────────────────────────────────────────────
             if (mode === 'pagerank') {
                 try {
-                    const { getBridgeDb } = await import('../memory/graph-edge-writer.js');
+                    const { getBridgeDb, execRows } = await import('../memory/graph-edge-writer.js');
                     // #2246 fix: lazy-create memory.db on first pathfinder call so
                     // fresh environments work without a pre-existing memory init.
                     const db = await getBridgeDb(undefined, { createIfMissing: true });
                     if (!db)
                         return { success: false, error: 'graph_edges DB unavailable (sql.js could not load)', hint: 'Check Node version + try `swarmdo memory init` to initialize manually.', mode, nodeId };
-                    const edgeResult = db.exec(`SELECT source_id, target_id, weight FROM graph_edges LIMIT ?`, [budget.maxNodesVisited]);
+                    const edgeResult = execRows(db, `SELECT source_id, target_id, weight FROM graph_edges LIMIT ?`, [budget.maxNodesVisited]);
                     const edges = edgeResult?.[0]?.values ?? [];
                     if (edges.length === 0) {
                         return { success: true, mode, nodeId, results: [], count: 0, message: 'graph_edges is empty', elapsedMs: Date.now() - t0 };
@@ -1248,7 +1248,7 @@ export const agentdbGraphPathfinder = {
                 return { success: false, error: `Unknown algorithm: ${algorithm}. Valid: ${validAlgorithms.join(', ')}` };
             }
             // Load edges from graph_edges
-            const { getBridgeDb } = await import('../memory/graph-edge-writer.js');
+            const { getBridgeDb, execRows } = await import('../memory/graph-edge-writer.js');
             // #2246 fix: lazy-create memory.db on first pathfinder call.
             const db = await getBridgeDb(undefined, { createIfMissing: true });
             if (!db)
@@ -1258,7 +1258,7 @@ export const agentdbGraphPathfinder = {
                 : algorithm === 'temporal-centrality'
                     ? 'source_id, target_id, weight, last_reinforced, confidence'
                     : 'source_id, target_id, weight';
-            const edgeResult = db.exec(`SELECT ${colsSql} FROM graph_edges LIMIT ?`, [budget.maxNodesVisited]);
+            const edgeResult = execRows(db, `SELECT ${colsSql} FROM graph_edges LIMIT ?`, [budget.maxNodesVisited]);
             const rawEdges = edgeResult?.[0]?.values ?? [];
             if (rawEdges.length === 0) {
                 return { success: true, paths: [], count: 0, message: `no edges found from seedNodeId`, seedNodeId, algorithm, elapsedMs: Date.now() - t0 };

package/v3/@swarmdo/cli/dist/src/memory/graph-edge-writer.d.ts

@@ -58,6 +58,18 @@ export interface GraphEdgeInput {
     metadata?: Record<string, unknown>;
     dbPath?: string;
 }
+/**
+ * Engine-compat read: run a SELECT and return rows in sql.js exec() shape
+ * ([{columns, values}] or [] when no rows). getBridgeDb returned sql.js
+ * historically and better-sqlite3 since #2431 — readers written against the
+ * old shape (agentdb graph query/pathfinder) go through this shim so they
+ * work on either engine. better-sqlite3's own exec() neither binds params
+ * nor returns rows, which surfaced as "datatype mismatch" on every LIMIT ?.
+ */
+export declare function execRows(db: any, sql: string, params?: unknown[]): Array<{
+    columns: string[];
+    values: unknown[][];
+}>;
 /**
  * Insert a single edge into graph_edges.
  * Fire-and-forget — errors are suppressed.