swarmdo 1.19.0 → 1.29.0

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

@@ -0,0 +1,133 @@
+/**
+ * `swarmdo compact-snapshot` — capture / restore a compaction-survival digest.
+ *
+ *   swarmdo compact-snapshot write   # snapshot working state (call on PreCompact)
+ *   swarmdo compact-snapshot read    # print the digest, then consume it (first
+ *                                    # prompt after compaction re-injects it)
+ *   swarmdo compact-snapshot read --keep   # print without consuming
+ *
+ * The digest (recently edited files, uncommitted changes, branch) lets an agent
+ * re-ground after context compaction instead of re-exploring. The engine is
+ * pure + tested (../compact-snapshot/compact-snapshot.ts); this wrapper does the
+ * fs read (edit ledger), git calls, and one-shot persistence.
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { output } from '../output.js';
+import { buildDigest, formatDigest, isDigestEmpty, } from '../compact-snapshot/compact-snapshot.js';
+const DIGEST_FILE = 'compact-digest.json';
+const LEDGER_FILE = 'pending-insights.jsonl';
+function dataDir(root) {
+    return path.join(root, '.swarmdo', 'data');
+}
+/** Best-effort git; returns '' on any failure (not-a-repo, no git). */
+function git(root, args) {
+    try {
+        return execFileSync('git', args, { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 8 * 1024 * 1024 });
+    }
+    catch {
+        return '';
+    }
+}
+/** Read edit records from the pending-insights ledger. Tolerant of junk lines. */
+function readEdits(root) {
+    const p = path.join(dataDir(root), LEDGER_FILE);
+    let raw;
+    try {
+        raw = fs.readFileSync(p, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const rec = JSON.parse(line);
+            if (rec && rec.type === 'edit' && typeof rec.file === 'string') {
+                out.push({ file: rec.file, timestamp: typeof rec.timestamp === 'number' ? rec.timestamp : 0 });
+            }
+        }
+        catch { /* skip malformed line */ }
+    }
+    return out;
+}
+function doWrite(root) {
+    // Drop swarmdo's own state dirs — they're not the user's working set and
+    // are usually gitignored anyway; filtering keeps the digest signal clean.
+    const gitStatus = git(root, ['status', '--porcelain'])
+        .split('\n')
+        .filter(Boolean)
+        .filter((l) => !/(^|\s|"|-> )\.(swarmdo|swarm|git)\//.test(l));
+    const digest = buildDigest({
+        now: Date.now(),
+        edits: readEdits(root),
+        gitStatus,
+        branch: git(root, ['rev-parse', '--abbrev-ref', 'HEAD']).trim() || undefined,
+    });
+    if (isDigestEmpty(digest)) {
+        // Nothing worth restoring — remove any stale digest so a later `read` is clean.
+        try {
+            fs.rmSync(path.join(dataDir(root), DIGEST_FILE));
+        }
+        catch { /* none */ }
+        output.writeln('compact-snapshot: no working state to capture');
+        return { success: true, exitCode: 0 };
+    }
+    try {
+        fs.mkdirSync(dataDir(root), { recursive: true });
+        fs.writeFileSync(path.join(dataDir(root), DIGEST_FILE), JSON.stringify(digest, null, 2) + '\n');
+    }
+    catch (e) {
+        output.printError(`compact-snapshot: could not write digest — ${e.message}`);
+        return { success: false, exitCode: 1 };
+    }
+    output.writeln(`compact-snapshot: captured ${digest.recentFiles.length} edited + ${digest.uncommitted.length} uncommitted`);
+    return { success: true, exitCode: 0 };
+}
+function doRead(root, keep) {
+    const file = path.join(dataDir(root), DIGEST_FILE);
+    let digest;
+    try {
+        digest = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return { success: true, exitCode: 0 };
+    } // no digest → nothing to inject
+    const text = formatDigest(digest, Date.now());
+    if (text)
+        process.stdout.write(text + '\n');
+    if (!keep) {
+        try {
+            fs.rmSync(file);
+        }
+        catch { /* already gone */ }
+    } // consume-once
+    return { success: true, exitCode: 0 };
+}
+async function run(ctx) {
+    const root = ctx.cwd || process.cwd();
+    const mode = (ctx.args[0] ?? 'read').toLowerCase();
+    if (mode === 'write')
+        return doWrite(root);
+    if (mode === 'read')
+        return doRead(root, ctx.flags.keep === true);
+    output.printError(`compact-snapshot: unknown mode "${mode}" (use write | read)`);
+    return { success: false, exitCode: 1 };
+}
+export const compactSnapshotCommand = {
+    name: 'compact-snapshot',
+    description: 'Capture/restore a working-state digest that survives context compaction — recent edits, uncommitted changes, branch — so an agent re-grounds instead of re-exploring',
+    options: [
+        { name: 'keep', description: 'on read, print the digest without consuming it', type: 'boolean' },
+    ],
+    examples: [
+        { command: 'swarmdo compact-snapshot write', description: 'Snapshot working state (wire to a PreCompact hook)' },
+        { command: 'swarmdo compact-snapshot read', description: 'Print + consume the digest (wire to the first post-compaction prompt)' },
+    ],
+    action: run,
+};
+export default compactSnapshotCommand;
+//# sourceMappingURL=compact-snapshot.js.map

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

@@ -15,6 +15,7 @@ async function run(ctx) {
     const root = ctx.cwd || process.cwd();
     const asJson = ctx.flags.format === 'json';
     const ci = ctx.flags.ci === true;
+    const includeTypeOnly = ctx.flags['include-type-only'] === true;
     let index = loadIndex(root);
     if (!index) {
         index = scanRepo(root);
@@ -23,7 +24,7 @@ async function run(ctx) {
         }
         catch { /* read-only fs — index is in memory */ }
     }
-    const res = findCycles(index);
+    const res = findCycles(index, { includeTypeOnly });
     const count = res.cycles.length + res.selfLoops.length;
     if (asJson) {
         process.stdout.write(JSON.stringify({ count, ...res }, null, 2) + '\n');
@@ -40,10 +41,12 @@ export const cyclesCommand = {
     description: 'Find circular import dependencies via the import graph (madge --circular style) — catch the TDZ/undefined-export bugs they cause',
     options: [
         { name: 'ci', description: 'exit 1 if any circular dependency exists (gate a build)', type: 'boolean' },
+        { name: 'include-type-only', description: 'also count TypeScript `import type` edges (excluded by default — they erase at compile time and cause no runtime cycle)', type: 'boolean' },
     ],
     examples: [
         { command: 'swarmdo cycles', description: 'List circular imports in the repo' },
         { command: 'swarmdo cycles --ci', description: 'Fail CI when a cycle is introduced' },
+        { command: 'swarmdo cycles --include-type-only', description: 'Strict view: count type-only imports too' },
     ],
     action: run,
 };

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

@@ -33,8 +33,11 @@ async function run(ctx) {
     }
     // Global --format (text|json|table); text and table both render the table.
     const asJson = ctx.flags.format === 'json';
-    // Capture history: SOH-delimited header + numstat, no merges.
-    const args = ['log', '--no-merges', '--numstat', `--since=${since}`, '--format=format:%x01%H%x1f%an%x1f%aI'];
+    // Capture history: SOH-delimited header + numstat, no merges. `%aN` (not
+    // `%an`) resolves author names through `.mailmap`, so name/email variants of
+    // the same person fold into one identity — otherwise the author-spread factor
+    // in the risk score is silently inflated. Identical to `%an` when no .mailmap.
+    const args = ['log', '--no-merges', '--numstat', `--since=${since}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
     if (pathArg)
         args.push('--', pathArg);
     let raw;

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

@@ -22,6 +22,7 @@ const commandLoaders = {
     // Deterministic command-output compression (rtk/headroom demand) — a
     // zero-token stream filter, distinct from caveman `compress` for files.
     compact: () => import('./compact.js'),
+    'compact-snapshot': () => import('./compact-snapshot.js'),
     // Secret detection + redaction on the agent data path (gitleaks/trufflehog
     // demand) — mask API keys/tokens before they reach an LLM/log/memory.
     redact: () => import('./redact.js'),
@@ -286,7 +287,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, compactCmd, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd,] = 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, codegraphCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd, compactSnapshotCmd,] = 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'),
@@ -294,7 +295,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('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'), loadCommand('testreport'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('demo'), loadCommand('usage'), loadCommand('repair'), loadCommand('hud'), loadCommand('compact'), loadCommand('codegraph'), loadCommand('redact'), loadCommand('pack'), loadCommand('env'), loadCommand('license'), loadCommand('sbom'), loadCommand('apply'), loadCommand('hotspots'), loadCommand('affected'), loadCommand('cycles'), loadCommand('testreport'), loadCommand('compact-snapshot'),
     ]);
     return {
         primary: [
@@ -310,7 +311,7 @@ export async function getCommandsByCategory() {
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
             migrateCmd, workflowCmd, demoCmd,
-            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd, efficiencyCmd,
+            statuslineCmd, compressCmd, compactCmd, redactCmd, packCmd, envCmd, licenseCmd, sbomCmd, applyCmd, hotspotsCmd, affectedCmd, cyclesCmd, testreportCmd, compactSnapshotCmd, efficiencyCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd, usageCmd, hudCmd, codegraphCmd,

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

@@ -13,6 +13,14 @@
  * land in the bundle.
  */
 import type { Command } from '../types.js';
+/**
+ * Decode a file buffer to bundle text, honoring BOMs (#10). UTF-16 LE/BE
+ * files decode to text (previously their NUL bytes tripped the binary
+ * heuristic and the file was silently dropped); a UTF-8 BOM is stripped
+ * instead of leaking into the bundle. Returns null for genuinely-binary
+ * content (NUL byte without a text BOM). Exported for tests.
+ */
+export declare function decodeText(buf: Buffer): string | null;
 export declare const packCommand: Command;
 export default packCommand;
 //# sourceMappingURL=pack.d.ts.map

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

@@ -35,6 +35,31 @@ function looksBinary(buf) {
             return true;
     return false;
 }
+/**
+ * Decode a file buffer to bundle text, honoring BOMs (#10). UTF-16 LE/BE
+ * files decode to text (previously their NUL bytes tripped the binary
+ * heuristic and the file was silently dropped); a UTF-8 BOM is stripped
+ * instead of leaking into the bundle. Returns null for genuinely-binary
+ * content (NUL byte without a text BOM). Exported for tests.
+ */
+export function decodeText(buf) {
+    if (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
+        return buf.subarray(3).toString('utf8');
+    }
+    if (buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe) {
+        const body = buf.subarray(2);
+        if (body.length % 2 !== 0)
+            return null;
+        return body.toString('utf16le');
+    }
+    if (buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff) {
+        const body = Buffer.from(buf.subarray(2)); // copy: swap16 mutates in place
+        if (body.length % 2 !== 0)
+            return null;
+        return body.swap16().toString('utf16le');
+    }
+    return looksBinary(buf) ? null : buf.toString('utf8');
+}
 function walk(o) {
     const files = [];
     const stack = [o.root];
@@ -82,9 +107,10 @@ function walk(o) {
                 catch {
                     continue;
                 }
-                if (looksBinary(buf))
+                const text = decodeText(buf);
+                if (text === null)
                     continue;
-                files.push({ path: rel, content: buf.toString('utf8') });
+                files.push({ path: rel, content: text });
             }
         }
     }

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

@@ -15,6 +15,10 @@ import * as os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { output } from '../output.js';
 import { planRelease, renderStep } from '../release/release.js';
+/** Escape every regex metacharacter (incl. backslash) so a value is a literal in `new RegExp`. */
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function repoRootFrom(cwd) {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
@@ -47,7 +51,7 @@ function syncDocs(root, files, current, next) {
         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.replace(new RegExp(`\\*\\*Swarmdo v${escapeRegExp(next)}\\*\\* \\(\\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

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

@@ -98,7 +98,8 @@ async function run(ctx) {
     else {
         output.writeln(formatSummary(summary, { top: top > 0 ? top : undefined }));
     }
-    const code = ci && summary.failed > 0 ? 1 : 0;
+    // A bail-out aborts the suite → results are incomplete → treat as failure in CI.
+    const code = ci && (summary.failed > 0 || summary.bailedOut) ? 1 : 0;
     return { success: code === 0, exitCode: code };
 }
 export const testreportCommand = {

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

@@ -95,21 +95,31 @@ function foldNodeFrames(lines) {
     }
     return out;
 }
-/** Collapse ≥3 consecutive blank lines to a single blank. */
+/**
+ * Collapse runs of ≥3 consecutive blank lines to a single blank. Runs of 1 or 2
+ * blanks are preserved (a 2-blank run is meaningful — e.g. PEP 8 spacing between
+ * top-level defs), so the full run length is counted before deciding.
+ */
 function collapseBlankLines(lines) {
     const out = [];
     let blanks = 0;
+    const flush = () => {
+        if (blanks === 0)
+            return;
+        const keep = blanks >= 3 ? 1 : blanks; // ≥3 → 1; 1 or 2 → unchanged
+        for (let i = 0; i < keep; i++)
+            out.push('');
+        blanks = 0;
+    };
     for (const line of lines) {
         if (line.trim() === '') {
             blanks++;
-            if (blanks <= 1)
-                out.push('');
-        }
-        else {
-            blanks = 0;
-            out.push(line);
+            continue;
         }
+        flush();
+        out.push(line);
     }
+    flush();
     return out;
 }
 /** Keep head + tail lines, eliding the middle with a marker. */

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

@@ -0,0 +1,58 @@
+/**
+ * compact-snapshot.ts — build a "survival digest" that lets an agent re-ground
+ * after context compaction. Post-compaction, the model loses its working set
+ * and tends to re-explore files it just edited and repeat corrected mistakes
+ * (a widely-reported pain, #45). This captures the cheap signals swarmdo
+ * already tracks — recently edited files (the pending-insights edit ledger),
+ * uncommitted changes (`git status --porcelain`), and the current branch —
+ * into a compact digest that the first post-compaction prompt re-injects.
+ *
+ * Pure + deterministic: inputs in (including `now`, so no clock dependency),
+ * a digest / rendered string out. The fs read (edit ledger), git calls, and
+ * digest persistence live in ../commands/compact-snapshot.ts, so this is
+ * fixture-testable.
+ */
+/** One edit-ledger record (a line of .swarmdo/data/pending-insights.jsonl). */
+export interface EditRecord {
+    file: string;
+    timestamp: number;
+}
+export interface DigestInput {
+    /** recent edit-ledger records; most-recent-wins when a file repeats */
+    edits?: EditRecord[];
+    /** raw `git status --porcelain` lines (uncommitted changes) */
+    gitStatus?: string[];
+    /** current branch name, if known */
+    branch?: string;
+    /** epoch ms the snapshot was taken (injected, not read from a clock) */
+    now: number;
+}
+export interface CompactDigest {
+    takenAt: number;
+    branch?: string;
+    /** distinct edited files, most-recently-edited first, capped */
+    recentFiles: string[];
+    /** distinct uncommitted file paths, capped */
+    uncommitted: string[];
+}
+/**
+ * Extract the working-tree path from one `git status --porcelain` line.
+ * Format is `XY <path>` (two status chars + space); a rename is
+ * `R  <old> -> <new>` — we want the destination. Quoted paths (git quotes
+ * names with special chars) are unwrapped. Returns null for a blank line.
+ * Pure.
+ */
+export declare function porcelainPath(line: string): string | null;
+/** Build the digest from raw session signals. Pure. */
+export declare function buildDigest(input: DigestInput, opts?: {
+    maxFiles?: number;
+}): CompactDigest;
+/** A digest with no files and no branch carries nothing worth re-injecting. Pure. */
+export declare function isDigestEmpty(d: CompactDigest): boolean;
+/**
+ * Render the digest as a re-grounding block for the first post-compaction
+ * prompt. Empty digest → '' (nothing to inject). `now` is passed so the
+ * relative age is deterministic. Pure.
+ */
+export declare function formatDigest(d: CompactDigest, now: number): string;
+//# sourceMappingURL=compact-snapshot.d.ts.map

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

@@ -0,0 +1,104 @@
+/**
+ * compact-snapshot.ts — build a "survival digest" that lets an agent re-ground
+ * after context compaction. Post-compaction, the model loses its working set
+ * and tends to re-explore files it just edited and repeat corrected mistakes
+ * (a widely-reported pain, #45). This captures the cheap signals swarmdo
+ * already tracks — recently edited files (the pending-insights edit ledger),
+ * uncommitted changes (`git status --porcelain`), and the current branch —
+ * into a compact digest that the first post-compaction prompt re-injects.
+ *
+ * Pure + deterministic: inputs in (including `now`, so no clock dependency),
+ * a digest / rendered string out. The fs read (edit ledger), git calls, and
+ * digest persistence live in ../commands/compact-snapshot.ts, so this is
+ * fixture-testable.
+ */
+const DEFAULT_MAX_FILES = 12;
+/**
+ * Extract the working-tree path from one `git status --porcelain` line.
+ * Format is `XY <path>` (two status chars + space); a rename is
+ * `R  <old> -> <new>` — we want the destination. Quoted paths (git quotes
+ * names with special chars) are unwrapped. Returns null for a blank line.
+ * Pure.
+ */
+export function porcelainPath(line) {
+    if (!line || line.length < 4)
+        return null;
+    let rest = line.slice(3); // strip the 2 status chars + the separating space
+    const arrow = rest.indexOf(' -> ');
+    if (arrow >= 0)
+        rest = rest.slice(arrow + 4); // rename/copy → destination path
+    rest = rest.trim();
+    if (rest.startsWith('"') && rest.endsWith('"') && rest.length >= 2) {
+        rest = rest.slice(1, -1); // unwrap git's quoted path (escapes left as-is)
+    }
+    return rest || null;
+}
+/** Build the digest from raw session signals. Pure. */
+export function buildDigest(input, opts = {}) {
+    const max = opts.maxFiles ?? DEFAULT_MAX_FILES;
+    // Distinct edited files, most-recent edit first. A file edited repeatedly
+    // keeps its latest timestamp; ties preserve first-seen (stable) order.
+    const latest = new Map();
+    for (const e of input.edits ?? []) {
+        if (!e || typeof e.file !== 'string' || !e.file)
+            continue;
+        const t = typeof e.timestamp === 'number' ? e.timestamp : 0;
+        const prev = latest.get(e.file);
+        if (prev === undefined || t >= prev)
+            latest.set(e.file, t);
+    }
+    const recentFiles = [...latest.entries()]
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, max)
+        .map(([f]) => f);
+    const seenUncommitted = new Set();
+    const uncommitted = [];
+    for (const line of input.gitStatus ?? []) {
+        const p = porcelainPath(line);
+        if (p && !seenUncommitted.has(p)) {
+            seenUncommitted.add(p);
+            uncommitted.push(p);
+        }
+        if (uncommitted.length >= max)
+            break;
+    }
+    return {
+        takenAt: input.now,
+        ...(input.branch ? { branch: input.branch } : {}),
+        recentFiles,
+        uncommitted,
+    };
+}
+/** A digest with no files and no branch carries nothing worth re-injecting. Pure. */
+export function isDigestEmpty(d) {
+    return d.recentFiles.length === 0 && d.uncommitted.length === 0;
+}
+/** Compact human "Nm ago" for the snapshot age. Pure. */
+function ago(fromMs, now) {
+    const s = Math.max(0, Math.round((now - fromMs) / 1000));
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    return `${Math.round(m / 60)}h ago`;
+}
+/**
+ * Render the digest as a re-grounding block for the first post-compaction
+ * prompt. Empty digest → '' (nothing to inject). `now` is passed so the
+ * relative age is deterministic. Pure.
+ */
+export function formatDigest(d, now) {
+    if (isDigestEmpty(d))
+        return '';
+    const lines = [`[swarmdo] Working context restored after compaction (snapshot ${ago(d.takenAt, now)}):`];
+    if (d.branch)
+        lines.push(`- Branch: ${d.branch}`);
+    if (d.recentFiles.length)
+        lines.push(`- Recently edited (${d.recentFiles.length}): ${d.recentFiles.join(', ')}`);
+    if (d.uncommitted.length)
+        lines.push(`- Uncommitted changes (${d.uncommitted.length}): ${d.uncommitted.join(', ')}`);
+    lines.push('Resume this work; re-read these files only as needed rather than re-exploring from scratch.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=compact-snapshot.js.map

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

@@ -13,9 +13,23 @@ export const TOPOLOGIES = ['hierarchical', 'mesh', 'hierarchical-mesh', 'ring',
 export const MEMORY_BACKENDS = ['agentdb', 'sqlite', 'hybrid', 'memory'];
 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'];
+// Current Claude Code hook events (source: code.claude.com/docs/en/hooks).
+// Kept in sync with the runtime; a stale list here false-warns on valid hooks.
 export const HOOK_EVENTS = [
-    'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop', 'SubagentStop',
-    'SessionStart', 'SessionEnd', 'PreCompact', 'TeammateIdle', 'TaskCompleted', 'PermissionDecision',
+    // session lifecycle
+    'SessionStart', 'Setup', 'SessionEnd',
+    // per-turn
+    'UserPromptSubmit', 'UserPromptExpansion', 'Stop', 'StopFailure',
+    // agentic loop
+    'PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'PostToolBatch', 'PermissionRequest', 'PermissionDenied',
+    // subagent & task
+    'SubagentStart', 'SubagentStop', 'TeammateIdle', 'TaskCreated', 'TaskCompleted',
+    // system & file
+    'Notification', 'MessageDisplay', 'CwdChanged', 'FileChanged', 'ConfigChange', 'InstructionsLoaded', 'PreCompact', 'PostCompact',
+    // MCP elicitation
+    'Elicitation', 'ElicitationResult',
+    // worktree
+    'WorktreeCreate', 'WorktreeRemove',
 ];
 /** Parse a JSON file's raw text; a null raw means "file absent" (fine). */
 export function lintJson(file, raw) {

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

@@ -12,8 +12,18 @@
  * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
  */
 import type { CodeIndex } from '../codegraph/codegraph.js';
+export interface CycleOptions {
+    /**
+     * Include TypeScript `import type`/`export type` edges. They erase at compile
+     * time so a type-only "cycle" causes none of the runtime bugs this detector
+     * exists to catch — excluded by DEFAULT to avoid false positives. Set true for
+     * a strict structural view. An edge counts as a runtime edge if ANY import
+     * between the two files is a value import (mixed imports keep the edge).
+     */
+    includeTypeOnly?: boolean;
+}
 /** Build file → sorted list of internal (resolved) imports. Pure. */
-export declare function buildAdjacency(index: CodeIndex): Map<string, string[]>;
+export declare function buildAdjacency(index: CodeIndex, opts?: CycleOptions): Map<string, string[]>;
 /**
  * Tarjan's SCC. Returns every strongly-connected component as a member list.
  * Iterative (no recursion) so deep graphs don't overflow the stack. Deterministic:
@@ -31,7 +41,7 @@ export interface CycleResult {
  * it has ≥2 files (mutual reachability) or a single file with a self-edge.
  * Deterministic: groups sorted by size desc then first member.
  */
-export declare function findCycles(index: CodeIndex): CycleResult;
+export declare function findCycles(index: CodeIndex, opts?: CycleOptions): CycleResult;
 /** Human-readable summary. Pure. */
 export declare function formatCycles(res: CycleResult): string;
 //# sourceMappingURL=cycles.d.ts.map

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

@@ -12,7 +12,7 @@
  * The index load lives in ../commands/cycles.ts, so this is fixture-testable.
  */
 /** Build file → sorted list of internal (resolved) imports. Pure. */
-export function buildAdjacency(index) {
+export function buildAdjacency(index, opts = {}) {
     const adj = new Map();
     const ensure = (f) => {
         let l = adj.get(f);
@@ -25,6 +25,8 @@ export function buildAdjacency(index) {
     for (const e of index.imports) {
         if (!e.resolved)
             continue; // external — not part of internal cycles
+        if (e.isTypeOnly && !opts.includeTypeOnly)
+            continue; // type-only → no runtime edge
         const l = ensure(e.from);
         if (!l.includes(e.resolved))
             l.push(e.resolved);
@@ -101,8 +103,8 @@ export function stronglyConnectedComponents(adj) {
  * it has ≥2 files (mutual reachability) or a single file with a self-edge.
  * Deterministic: groups sorted by size desc then first member.
  */
-export function findCycles(index) {
-    const adj = buildAdjacency(index);
+export function findCycles(index, opts = {}) {
+    const adj = buildAdjacency(index, opts);
     const selfLoops = [];
     for (const [from, tos] of adj)
         if (tos.includes(from))

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

@@ -29,8 +29,11 @@ export interface EnvReport {
 export declare function extractEnvRefs(source: string, file: string): EnvRef[];
 /**
  * Parse a `.env` file into an ordered list of declared keys. Handles `KEY=val`,
- * `export KEY=val`, quoted values, `# comments`, and blank lines. Values are
- * ignored — we only reconcile key presence. Pure.
+ * `export KEY=val`, quoted values, `# comments`, and blank lines. The key
+ * charset + `:` separator mirror the reference `dotenv` package's grammar
+ * (`[\w.-]+` with `=` or `: ` as separator), so dotted/hyphenated keys like
+ * `APP.NAME` aren't silently dropped. Values are ignored — we only reconcile
+ * key presence. Pure.
  */
 export declare function parseDotenv(text: string): string[];
 export interface ReconcileInput {