swarmdo 1.4.8 → 1.6.0

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

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

@@ -0,0 +1,241 @@
+/**
+ * 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 * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { output } from '../output.js';
+import { planRelease, renderStep } from '../release/release.js';
+function repoRootFrom(cwd) {
+    try {
+        return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function bumpJson(file, version) {
+    const d = JSON.parse(fs.readFileSync(file, 'utf8'));
+    d.version = version;
+    fs.writeFileSync(file, JSON.stringify(d, null, 2) + '\n');
+}
+function bumpLock(file, version) {
+    const d = JSON.parse(fs.readFileSync(file, 'utf8'));
+    d.version = version;
+    if (d.packages && d.packages[''])
+        d.packages[''].version = version;
+    fs.writeFileSync(file, JSON.stringify(d, null, 2) + '\n');
+}
+/** Replace the previous version's known doc occurrences with the next. */
+function syncDocs(root, files, current, next) {
+    const today = new Date().toISOString().slice(0, 10);
+    const touched = [];
+    for (const rel of files) {
+        const abs = path.join(root, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        const before = fs.readFileSync(abs, 'utf8');
+        let after = before;
+        // exact patterns used by every release since 1.4.x
+        after = after.replaceAll(`**Swarmdo v${current}** (`, `**Swarmdo v${next}** (`);
+        after = after.replace(new RegExp(`\\*\\*Swarmdo v${next.replace(/\./g, '\\.')}\\*\\* \\(\\d{4}-\\d{2}-\\d{2}\\)`), `**Swarmdo v${next}** (${today})`);
+        after = after.replaceAll(`swarmdo@${current}\` (umbrella), \`@swarmdo/cli@${current}\`, \`swarmdo-bridge@${current}\``, `swarmdo@${next}\` (umbrella), \`@swarmdo/cli@${next}\`, \`swarmdo-bridge@${next}\``);
+        // README badge + website carry the last PUBLISHED version, which lags
+        // the repo version (`current`) between releases — match any semver in
+        // these swarmdo-specific markers instead of interpolating `current`.
+        after = after.replace(/npx%20swarmdo-v\d+\.\d+\.\d+-cb3837/g, `npx%20swarmdo-v${next}-cb3837`);
+        after = after.replace(/"softwareVersion":"\d+\.\d+\.\d+"/g, `"softwareVersion":"${next}"`);
+        after = after.replace(/<span class="ver">v\d+\.\d+\.\d+ · MIT<\/span>/g, `<span class="ver">v${next} · MIT</span>`);
+        after = after.replace(/▊ Swarmdo V\d+\.\d+\.\d+ /g, `▊ Swarmdo V${next} `);
+        if (after !== before) {
+            fs.writeFileSync(abs, after);
+            touched.push(rel);
+        }
+    }
+    return touched;
+}
+async function executePlan(plan, root) {
+    const run = (s) => {
+        output.writeln(output.dim(`  $ ${s.cmd} ${s.args.join(' ')}   (${path.relative(root, s.cwd) || '.'})`));
+        execFileSync(s.cmd, s.args, { cwd: s.cwd, stdio: 'inherit' });
+    };
+    for (const [i, step] of plan.steps.entries()) {
+        output.writeln(output.bold(`[${i + 1}/${plan.steps.length}] ${renderStep(step)}`));
+        switch (step.kind) {
+            case 'bump-json':
+                bumpJson(path.join(root, step.file), step.version);
+                break;
+            case 'bump-lock':
+                bumpLock(path.join(root, step.file), step.version);
+                break;
+            case 'sync-docs': {
+                const touched = syncDocs(root, step.files, plan.current, plan.next);
+                output.writeln(output.dim(`  synced: ${touched.join(', ') || '(none)'}`));
+                break;
+            }
+            case 'exec':
+                run(step);
+                break;
+            case 'verify-npm': {
+                for (const pkg of step.packages) {
+                    let seen = '';
+                    for (let attempt = 0; attempt < 20; attempt++) {
+                        try {
+                            seen = execFileSync('npm', ['view', `${pkg}@latest`, 'version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+                        }
+                        catch {
+                            seen = '';
+                        }
+                        if (seen === step.version)
+                            break;
+                        execFileSync('sleep', ['3']);
+                    }
+                    if (seen !== step.version) {
+                        output.printError(`${pkg}@latest is "${seen || '(unset)'}" — expected ${step.version}`);
+                        return { success: false, exitCode: 1 };
+                    }
+                    output.writeln(output.dim(`  ${pkg}@latest = ${seen} ✓`));
+                }
+                break;
+            }
+            case 'deploy-site': {
+                // user rule 2026-07-07: the live site ships with every release.
+                // Copy the working copy into the SwarmDo/swarmdo.com repo, push,
+                // and verify production actually serves the new version string.
+                const siteDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmdo-site-'));
+                execFileSync('gh', ['repo', 'clone', 'SwarmDo/swarmdo.com', siteDir, '--', '-q'], { stdio: 'inherit' });
+                fs.copyFileSync(path.join(root, 'website', 'index.html'), path.join(siteDir, 'index.html'));
+                const smap = path.join(siteDir, 'sitemap.xml');
+                if (fs.existsSync(smap)) {
+                    const today = new Date().toISOString().slice(0, 10);
+                    fs.writeFileSync(smap, fs.readFileSync(smap, 'utf8').replace(/<lastmod>[^<]*<\/lastmod>/g, `<lastmod>${today}</lastmod>`));
+                }
+                const g = (args) => { execFileSync('git', args, { cwd: siteDir, stdio: 'inherit' }); };
+                g(['add', '-A']);
+                try {
+                    g(['commit', '-m', `release: sync site for v${plan.next}\n\nCo-Authored-By: Swarmdo <maintainers@swarmdo.com>`]);
+                }
+                catch {
+                    output.writeln(output.dim('  site already in sync — nothing to commit'));
+                    break;
+                }
+                g(['push', 'origin', 'main']);
+                // poll production (GitHub Pages deploys in ~1min)
+                let live = false;
+                for (let i = 0; i < 30; i++) {
+                    try {
+                        const body = execFileSync('curl', ['-s', 'https://swarmdo.com'], { encoding: 'utf8' });
+                        if (body.includes(`v${plan.next}`)) {
+                            live = true;
+                            break;
+                        }
+                    }
+                    catch { /* transient */ }
+                    execFileSync('sleep', ['10']);
+                }
+                if (!live) {
+                    output.printError(`swarmdo.com is not serving v${plan.next} after 5min — check the Pages build`);
+                    return { success: false, exitCode: 1 };
+                }
+                output.writeln(output.dim(`  swarmdo.com serves v${plan.next} ✓`));
+                break;
+            }
+            case 'gh-release': {
+                const notes = path.join(os.tmpdir(), `swarmdo-relnotes-${process.pid}.md`);
+                const { changelogCommand } = await import('./changelog.js');
+                // step.notesFrom is v<previous repo version>, but the repo
+                // patch-bumps every commit while tags only land per release —
+                // that ref usually isn't a tag. Fall back to the newest real tag
+                // that isn't the one being released.
+                let notesFrom = step.notesFrom;
+                try {
+                    execFileSync('git', ['rev-parse', '--verify', `${notesFrom}^{commit}`], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+                }
+                catch {
+                    const { makeGitRunner } = await import('../changelog/changelog.js');
+                    const tags = makeGitRunner(root)(['tag', '--sort=-creatordate']).split('\n').map(t => t.trim()).filter(t => t && t !== plan.tag);
+                    notesFrom = tags[0];
+                    output.writeln(output.dim(`  ${step.notesFrom} is not a ref — notes range falls back to ${notesFrom ?? '(repo start)'}`));
+                }
+                const r = await changelogCommand.action({ args: [], flags: { ...(notesFrom ? { from: notesFrom } : {}), version: plan.tag, out: notes }, cwd: root, interactive: false });
+                if (r && r.success === false)
+                    return { success: false, exitCode: 1 };
+                execFileSync('gh', ['release', 'create', plan.tag, '--title', `${plan.tag}`, '--notes-file', notes], { cwd: root, stdio: 'inherit' });
+                try {
+                    fs.rmSync(notes, { force: true });
+                }
+                catch { /* best-effort */ }
+                break;
+            }
+        }
+    }
+    output.printSuccess(`released ${plan.tag}`);
+    return { success: true, exitCode: 0 };
+}
+export const releaseCommand = {
+    name: 'release',
+    aliases: ['ship'],
+    description: 'Run the full release train: bump trio+docs, commit, build+stage, publish both npm packages, verify, tag, GitHub release — dry-run unless --confirm',
+    options: [
+        { name: 'confirm', type: 'boolean', description: 'actually execute (default: print the plan)', default: false },
+        { name: 'skip-publish', type: 'boolean', description: 'skip npm publish + registry verify steps', default: false },
+        { name: 'skip-gh-release', type: 'boolean', description: 'skip the GitHub release step', default: false },
+        { name: 'skip-site', type: 'boolean', description: 'skip the live-site deploy (docs-sync rule: only for zero-user-facing releases)', default: false },
+        { name: 'json', type: 'boolean', description: 'print the plan as JSON', default: false },
+    ],
+    examples: [
+        { command: 'swarmdo release', description: 'Plan a patch release (dry-run)' },
+        { command: 'swarmdo release minor --confirm', description: 'Execute a minor release end-to-end' },
+        { command: 'swarmdo release 2.0.0 --skip-publish --confirm', description: 'Bump/tag/release 2.0.0 without publishing to npm' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        const root = repoRootFrom(cwd);
+        if (!root) {
+            output.printError('not a git repository');
+            return { success: false, exitCode: 1 };
+        }
+        const trioHead = path.join(root, 'v3/@swarmdo/cli/package.json');
+        if (!fs.existsSync(trioHead)) {
+            output.printError('this does not look like the swarmdo repo (v3/@swarmdo/cli/package.json missing)');
+            return { success: false, exitCode: 1 };
+        }
+        const current = String(JSON.parse(fs.readFileSync(trioHead, 'utf8')).version ?? '');
+        let plan;
+        try {
+            plan = planRelease({
+                current,
+                bump: (ctx.args[0] || 'patch').toLowerCase(),
+                repoRoot: root,
+                skipPublish: ctx.flags['skip-publish'] === true,
+                skipGhRelease: ctx.flags['skip-gh-release'] === true,
+                skipSite: ctx.flags['skip-site'] === true,
+            });
+        }
+        catch (e) {
+            output.printError(e.message);
+            return { success: false, exitCode: 1 };
+        }
+        if (ctx.flags.json === true) {
+            output.printJson(plan);
+            return { success: true, data: plan };
+        }
+        if (ctx.flags.confirm !== true) {
+            output.writeln(output.bold(`Release plan  ${plan.current} → ${plan.next}`) + output.dim('  (dry-run — re-run with --confirm to execute)'));
+            plan.steps.forEach((s, i) => output.writeln(`  ${String(i + 1).padStart(2)}. ${renderStep(s)}`));
+            return { success: true, data: { dryRun: true, ...plan } };
+        }
+        return executePlan(plan, root);
+    },
+};
+export default releaseCommand;
+//# sourceMappingURL=release.js.map

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

@@ -6,6 +6,7 @@
  */
 import { output } from '../output.js';
 import { execSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
 // Scan subcommand
 const scanCommand = {
     name: 'scan',
@@ -190,6 +191,19 @@ const scanCommand = {
                 scanCodeDir(path.resolve(target), scanDepth);
             }
             spinner.succeed('Scan complete');
+            // Persist the summary so the statusline (and future tooling) reflects
+            // real scans instead of the retired V3 CVE tracker (v1.4.17).
+            try {
+                const artifactDir = path.join(process.cwd(), '.swarmdo', 'security');
+                mkdirSync(artifactDir, { recursive: true });
+                writeFileSync(path.join(artifactDir, 'last-scan.json'), JSON.stringify({
+                    scannedAt: new Date().toISOString(),
+                    target, depth, type: scanType,
+                    critical: criticalCount, high: highCount, medium: mediumCount, low: lowCount,
+                    total: findings.length,
+                }, null, 2) + '\n');
+            }
+            catch { /* statusline signal is best-effort */ }
             // Display results
             output.writeln();
             if (findings.length > 0) {

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

@@ -9,6 +9,7 @@
  * unit-tested; reuses the usage transcript infra).
  */
 import * as fs from 'node:fs';
+import { parseQuery, searchLines, rankMatches } from '../transcript/search.js';
 import { output } from '../output.js';
 import { listSessions, exportSession } from '../transcript/export.js';
 function fmtAge(mtimeMs, nowMs) {
@@ -108,11 +109,91 @@ const exportCommand = {
         return { success: true, data: { turns: res.turns, sessionId: res.sessionId } };
     },
 };
+// Full-text search across session transcripts ("which session did I discuss X in?")
+const searchCommand = {
+    name: 'search',
+    description: 'Search what you and Claude actually said across all session transcripts',
+    options: [
+        { name: 'limit', short: 'n', type: 'number', description: 'sessions to show', default: 10 },
+        { name: 'json', type: 'boolean', description: 'machine-readable output', default: false },
+    ],
+    examples: [
+        { command: 'swarmdo transcript search obsidian vault', description: 'Sessions mentioning both terms (AND)' },
+        { command: 'swarmdo tx search "npm publish" -n 5', description: 'Top 5 sessions about npm publish' },
+    ],
+    action: async (ctx) => {
+        const fs = await import('node:fs');
+        const { defaultClaudeProjectDirs, findTranscriptFiles } = await import('../usage/transcript-usage.js');
+        const { sessionIdFromFile } = await import('../transcript/export.js');
+        let terms;
+        try {
+            terms = parseQuery(ctx.args.slice(1).join(' '));
+        }
+        catch {
+            output.printError('usage: swarmdo transcript search <terms…>');
+            return { success: false, exitCode: 1 };
+        }
+        const matches = [];
+        let scanned = 0;
+        for (const dir of defaultClaudeProjectDirs()) {
+            for (const { file, project } of findTranscriptFiles(dir)) {
+                scanned++;
+                let raw;
+                try {
+                    raw = fs.readFileSync(file, 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                const lines = raw.split('\n').flatMap((l) => {
+                    if (!l.trim())
+                        return [];
+                    try {
+                        return [JSON.parse(l)];
+                    }
+                    catch {
+                        return [];
+                    }
+                });
+                const { hits, snippets } = searchLines(lines, terms);
+                if (hits > 0) {
+                    let mtimeMs = 0;
+                    try {
+                        mtimeMs = fs.statSync(file).mtimeMs;
+                    }
+                    catch { /* keep 0 */ }
+                    matches.push({ sessionId: sessionIdFromFile(file), project, mtimeMs, hits, snippets });
+                }
+            }
+        }
+        const ranked = rankMatches(matches).slice(0, Number(ctx.flags.limit) || 10);
+        if (ctx.flags.json === true) {
+            output.printJson({ query: terms, scanned, matched: matches.length, sessions: ranked });
+            return { success: true, data: ranked };
+        }
+        if (ranked.length === 0) {
+            output.writeln(output.dim(`no sessions matched "${terms.join(' ')}" (${scanned} transcripts scanned)`));
+            return { success: true, exitCode: 0 };
+        }
+        output.writeln(output.bold(`${matches.length} session(s) match "${terms.join(' ')}"`) + output.dim(`  — ${scanned} transcripts scanned`));
+        for (const m of ranked) {
+            const when = m.mtimeMs ? new Date(m.mtimeMs).toISOString().slice(0, 16).replace('T', ' ') : '?';
+            output.writeln('');
+            output.writeln(`${output.info(m.sessionId.slice(0, 8))}  ${output.dim(when)}  ${m.hits} hit${m.hits === 1 ? '' : 's'}  ${output.dim(m.project)}`);
+            for (const sn of m.snippets) {
+                output.writeln(`   ${sn.role === 'user' ? '👤' : '🤖'} ${sn.snippet}`);
+            }
+        }
+        output.writeln('');
+        output.writeln(output.dim('open one:  swarmdo transcript export -s <id-prefix>'));
+        return { success: true, data: ranked };
+    },
+};
 export const transcriptCommand = {
     name: 'transcript',
     aliases: ['tx'],
     description: 'Export Claude Code sessions to readable Markdown (list/export)',
-    subcommands: [listCommand, exportCommand],
+    subcommands: [listCommand, exportCommand, searchCommand],
     options: [],
     examples: [
         { command: 'swarmdo transcript list', description: 'Recent sessions, newest first' },

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

@@ -17,6 +17,7 @@ import { aggregateBlocks, aggregateUsage, collectUsage, totalUsage, localDateKey
 import { collectToolErrors } from '../usage/transcript-errors.js';
 import { computeCacheStats } from '../usage/cache-stats.js';
 import { evaluateGuard } from '../usage/spend-guard.js';
+import { resolvePeriodPair, parseRange, diffPeriods, modelMovers } from '../usage/diff.js';
 const VIEWS = {
     daily: { dimension: 'day', label: 'Date' },
     monthly: { dimension: 'month', label: 'Month' },
@@ -232,6 +233,79 @@ function runCacheView(ctx, collection) {
     output.writeln(output.dim('"From cache" = share of input tokens served as cache reads (0.1x cost); higher is cheaper.'));
     return { success: true, exitCode: 0 };
 }
+/** Diff view — compare two periods (day|week|month presets or explicit
+ * --a/--b YYYY-MM-DD:YYYY-MM-DD ranges): totals, deltas, per-model movers. */
+function runDiffView(ctx, collection) {
+    const kind = (ctx.args[1] || 'week').toLowerCase();
+    let a;
+    let b;
+    try {
+        if (typeof ctx.flags.a === 'string' || typeof ctx.flags.b === 'string') {
+            if (typeof ctx.flags.a !== 'string' || typeof ctx.flags.b !== 'string') {
+                output.printError('explicit ranges need BOTH --a and --b (YYYY-MM-DD:YYYY-MM-DD)');
+                return { success: false, exitCode: 1 };
+            }
+            a = parseRange(ctx.flags.a, 'A');
+            b = parseRange(ctx.flags.b, 'B');
+        }
+        else {
+            ({ a, b } = resolvePeriodPair(kind, localDateKey(new Date())));
+        }
+    }
+    catch (e) {
+        output.printError(e.message);
+        return { success: false, exitCode: 1 };
+    }
+    const dayRows = aggregateUsage(collection.events, 'day').map((r) => ({ key: r.key, totals: r.totals }));
+    const report = diffPeriods(dayRows, a, b);
+    // per-(model, day) fold for the movers table
+    const md = new Map();
+    for (const e of collection.events) {
+        const k = `${e.model}\u0000${e.dateKey}`;
+        const row = md.get(k) ?? { key: e.model, day: e.dateKey, totals: { costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0 } };
+        row.totals.costUsd += e.costUsd;
+        row.totals.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+        md.set(k, row);
+    }
+    const movers = modelMovers([...md.values()], a, b);
+    if (ctx.flags.json === true) {
+        output.printJson({ ...report, movers });
+        return { success: true, data: { ...report, movers } };
+    }
+    const pct = (m) => (m.pct === null ? 'new' : `${m.pct >= 0 ? '+' : ''}${Math.round(m.pct * 100)}%`);
+    const sign = (n, f) => `${n >= 0 ? '+' : '−'}${f(Math.abs(n))}`;
+    output.writeln(output.bold(`Usage diff  ${a.label}  vs  ${b.label}`) + output.dim(`   (${a.from}..${a.to} vs ${b.from}..${b.to})`));
+    output.printTable({
+        columns: [
+            { key: 'metric', header: 'Metric', width: 14 },
+            { key: 'a', header: a.label.slice(0, 14), width: 14, align: 'right' },
+            { key: 'b', header: b.label.slice(0, 14), width: 14, align: 'right' },
+            { key: 'delta', header: 'Δ', width: 14, align: 'right' },
+            { key: 'pct', header: '%', width: 7, align: 'right' },
+        ],
+        data: [
+            { metric: 'Cost', a: fmtCost(report.cost.a), b: fmtCost(report.cost.b), delta: sign(report.cost.delta, fmtCost), pct: pct(report.cost) },
+            { metric: 'Tokens', a: fmtInt(report.totalTokens.a), b: fmtInt(report.totalTokens.b), delta: sign(report.totalTokens.delta, fmtInt), pct: pct(report.totalTokens) },
+            { metric: 'Output tok', a: fmtInt(report.outputTokens.a), b: fmtInt(report.outputTokens.b), delta: sign(report.outputTokens.delta, fmtInt), pct: pct(report.outputTokens) },
+            { metric: 'Cache reads', a: fmtInt(report.cacheReadTokens.a), b: fmtInt(report.cacheReadTokens.b), delta: sign(report.cacheReadTokens.delta, fmtInt), pct: pct(report.cacheReadTokens) },
+            { metric: 'Active days', a: String(report.activeDays.a), b: String(report.activeDays.b), delta: sign(report.activeDays.delta, String), pct: pct(report.activeDays) },
+        ],
+    });
+    if (movers.length > 0) {
+        output.writeln(output.bold('Model movers') + output.dim('  (by |Δ cost|)'));
+        output.printTable({
+            columns: [
+                { key: 'model', header: 'Model', width: 34 },
+                { key: 'a', header: 'A', width: 12, align: 'right' },
+                { key: 'b', header: 'B', width: 12, align: 'right' },
+                { key: 'delta', header: 'Δ', width: 12, align: 'right' },
+                { key: 'pct', header: '%', width: 7, align: 'right' },
+            ],
+            data: movers.map((m) => ({ model: m.model, a: fmtCost(m.cost.a), b: fmtCost(m.cost.b), delta: sign(m.cost.delta, fmtCost), pct: pct(m.cost) })),
+        });
+    }
+    return { success: true, data: { ...report, movers } };
+}
 /** Build a threshold from a --flag or its SWARMDO_GUARD_* env fallback. */
 function guardThreshold(ctx, flagKey, envKey, current, label, unit) {
     const raw = ctx.flags[flagKey] ?? process.env[envKey];
@@ -330,9 +404,14 @@ async function run(ctx) {
         const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
         return runGuardView(ctx, collectUsage({ dirs }));
     }
+    if (viewName === 'diff') {
+        const dirFlag = ctx.flags.dir;
+        const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
+        return runDiffView(ctx, collectUsage({ dirs }));
+    }
     const view = VIEWS[viewName];
     if (!view) {
-        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard)`));
+        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard|diff)`));
         return { success: false, exitCode: 1 };
     }
     const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;

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

@@ -0,0 +1,60 @@
+/**
+ * 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.
+ */
+export interface CompactOptions {
+    /** Strip ANSI escape sequences. Default true. */
+    stripAnsi?: boolean;
+    /** Collapse a run of ≥ this many identical lines. Default 3; 0 disables. */
+    minRun?: number;
+    /** Fold consecutive node_modules stack frames. Default true. */
+    foldNodeModules?: boolean;
+    /** Collapse ≥3 consecutive blank lines to one. Default true. */
+    collapseBlanks?: boolean;
+    /**
+     * Opt-in windowing for very long output: keep the first `head` and last
+     * `tail` lines, eliding the middle. Omit to keep everything.
+     */
+    window?: {
+        head: number;
+        tail: number;
+    };
+}
+export interface CompactStats {
+    linesIn: number;
+    linesOut: number;
+    bytesIn: number;
+    bytesOut: number;
+    /** Fraction of bytes removed, 0..1 (0 when input was empty). */
+    savedFraction: number;
+}
+export interface CompactResult {
+    text: string;
+    stats: CompactStats;
+}
+/** Remove ANSI escapes from a string. Exported for reuse/testing. */
+export declare function stripAnsi(s: string): string;
+/**
+ * Compact command output. Pure — returns the rewritten text plus byte/line
+ * savings. The input's trailing newline (if any) is preserved.
+ */
+export declare function compactOutput(input: string, opts?: CompactOptions): CompactResult;
+/** Human-readable byte count (for the savings summary). */
+export declare function formatBytes(n: number): string;
+/** One-line savings summary for stderr. */
+export declare function formatSavings(stats: CompactStats): string;
+//# sourceMappingURL=compact.d.ts.map