swarmdo 1.27.0 → 1.29.0

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

@@ -32,6 +32,7 @@ async function run(ctx) {
     const root = ctx.cwd || process.cwd();
     const dryRun = ctx.flags['dry-run'] === true;
     const partial = ctx.flags.partial === true;
+    const strict = ctx.flags.strict === true;
     // The parser may deliver --fuzz as a number or a string; accept both.
     const fuzz = typeof ctx.flags.fuzz === 'number' ? ctx.flags.fuzz
         : typeof ctx.flags.fuzz === 'string' ? parseInt(ctx.flags.fuzz, 10)
@@ -61,6 +62,7 @@ async function run(ctx) {
     }
     let totalApplied = 0;
     let totalRejected = 0;
+    let totalAmbiguous = 0;
     const writes = [];
     for (const fp of patches) {
         const file = targetFile(root, fp);
@@ -85,8 +87,16 @@ async function run(ctx) {
         totalApplied += applied;
         totalRejected += rejected;
         const fuzzy = res.hunks.filter((h) => h.applied && (h.fuzzUsed ?? 0) > 0).length;
+        const ambiguous = res.hunks.filter((h) => h.applied && h.ambiguous).length;
+        totalAmbiguous += ambiguous;
         const tag = rejected === 0 ? output.dim('ok') : output.bold(`${rejected} rejected`);
-        output.writeln(`${rel}  ${applied}/${res.hunks.length} hunks${fuzzy ? output.dim(` (${fuzzy} fuzzy)`) : ''}  ${tag}`);
+        const ambTag = ambiguous ? output.error(` ⚠ ${ambiguous} ambiguous`) : '';
+        output.writeln(`${rel}  ${applied}/${res.hunks.length} hunks${fuzzy ? output.dim(` (${fuzzy} fuzzy)`) : ''}  ${tag}${ambTag}`);
+        if (ambiguous) {
+            for (const h of res.hunks.filter((x) => x.applied && x.ambiguous)) {
+                output.writeln(output.dim(`    ⚠ hunk @ line ${(h.at ?? 0) + 1}: matched a block that also appears elsewhere — verify it landed on the intended one`));
+            }
+        }
         if (rejected === 0 || partial) {
             if (res.result !== source)
                 writes.push({ file, content: res.result });
@@ -97,9 +107,11 @@ async function run(ctx) {
             fs.writeFileSync(w.file, w.content);
     }
     const verb = dryRun ? 'would apply' : 'applied';
-    output.writeln(output.dim(`${verb} ${totalApplied} hunks, ${totalRejected} rejected${dryRun ? ' (dry run)' : ''}`));
-    // Exit 1 if anything was rejected — a CI/agent can branch on it.
-    const code = totalRejected > 0 ? 1 : 0;
+    const ambSummary = totalAmbiguous ? `, ${totalAmbiguous} ambiguous` : '';
+    output.writeln(output.dim(`${verb} ${totalApplied} hunks, ${totalRejected} rejected${ambSummary}${dryRun ? ' (dry run)' : ''}`));
+    // Exit 1 if anything was rejected — a CI/agent can branch on it. With --strict,
+    // an ambiguous match (possibly landed on the wrong duplicate) also fails.
+    const code = totalRejected > 0 || (strict && totalAmbiguous > 0) ? 1 : 0;
     return { success: code === 0, exitCode: code };
 }
 export const applyCommand = {
@@ -109,6 +121,7 @@ export const applyCommand = {
         { name: 'dry-run', description: 'report what would apply/reject without writing', type: 'boolean' },
         { name: 'fuzz', description: 'max context lines to drop when matching a drifted hunk (default 2)', type: 'string' },
         { name: 'partial', description: 'write files even when some of their hunks are rejected', type: 'boolean' },
+        { name: 'strict', description: 'exit 1 if any hunk matched an ambiguous (duplicated) block, even if it applied', type: 'boolean' },
     ],
     examples: [
         { command: 'swarmdo apply changes.patch', description: 'Apply a patch file' },

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

@@ -0,0 +1,17 @@
+/**
+ * `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 type { Command } from '../types.js';
+export declare const compactSnapshotCommand: Command;
+export default compactSnapshotCommand;
+//# sourceMappingURL=compact-snapshot.d.ts.map

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/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/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/init/helpers-generator.js

@@ -790,7 +790,20 @@ export function generateIntelligenceStub() {
         '      return { entry: e, score: matchScore(promptWords, e.words || tokenize(e.content + " " + e.summary)) };',
         '    }).filter(function(s) { return s.score > 0.05; });',
         '    scored.sort(function(a, b) { return b.score - a.score; });',
-        '    var top = scored.slice(0, 5);',
+        '    // Dedupe by content signature before taking the top 5. The store can',
+        '    // accumulate many copies of one memory (re-imported each session) with',
+        '    // DISTINCT ids, so an id-only dedupe leaves identical memories that fill',
+        '    // every slot; key on normalized content so the 5 slots hold 5 DISTINCT',
+        '    // memories (parity with the full helper deduplicateByContent).',
+        '    var top = [];',
+        '    var seenSig = {};',
+        '    for (var si = 0; si < scored.length && top.length < 5; si++) {',
+        '      var sEntry = scored[si].entry;',
+        '      var sig = ((sEntry.summary || "") + "\\u0001" + (sEntry.content || "")).replace(/\\s+/g, " ").trim().toLowerCase().substring(0, 200);',
+        '      if (seenSig[sig]) continue;',
+        '      seenSig[sig] = true;',
+        '      top.push(scored[si]);',
+        '    }',
         '    if (!top.length) return null;',
         '    var prevMatched = sessionGet("lastMatchedPatterns");',
         '    var matchedIds = top.map(function(s) { return s.entry.id; });',
@@ -800,11 +813,28 @@ export function generateIntelligenceStub() {
         '      for (var i = 0; i < matchedIds.length; i++) newSet[matchedIds[i]] = true;',
         '    }',
         '    var lines2 = ["[INTELLIGENCE] Relevant patterns for this task:"];',
+        '    // Inject the matched memory CONTENT (budgeted), not just an 80-char',
+        '    // label, so stored memories are usable mid-session without a separate',
+        '    // lookup (#43 Phase 1). Total budget ~800 tokens; lexical match reused',
+        '    // so there is no per-prompt embedding cost.',
+        '    var BUDGET = 3200;',
+        '    var used = 0;',
         '    for (var j = 0; j < top.length; j++) {',
         '      var e = top[j];',
         '      var conf = e.entry.confidence || 0.5;',
-        '      var summary = (e.entry.summary || e.entry.content || "").substring(0, 80);',
-        '      lines2.push("  * (" + conf.toFixed(2) + ") " + summary);',
+        '      var label = (e.entry.summary || e.entry.category || "memory").substring(0, 80);',
+        '      var body = (e.entry.content || "").replace(/\\s+/g, " ").trim();',
+        '      var remaining = BUDGET - used;',
+        '      if (remaining <= 0) break;',
+        '      var perEntry = Math.max(160, Math.floor(remaining / (top.length - j)));',
+        '      var snippet = body.substring(0, perEntry);',
+        '      if (snippet.length < body.length) snippet += "\\u2026";',
+        '      used += label.length + snippet.length;',
+        '      if (snippet && snippet !== label) {',
+        '        lines2.push("  * (" + conf.toFixed(2) + ") " + label + " \\u2014 " + snippet);',
+        '      } else {',
+        '        lines2.push("  * (" + conf.toFixed(2) + ") " + label);',
+        '      }',
         '    }',
         '    return lines2.join("\\n");',
         '  },',

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

@@ -47,7 +47,7 @@ export const RULES = [
  * anchors it, so `keyboard=`/`monkey_val=` don't match; the entropy + length
  * gates keep low-entropy values (paths, short flags) from being flagged.
  */
-const ASSIGNMENT_RE = /(?:pass(?:word|wd)?|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|auth[_-]?token|client[_-]?secret|credential|creds|key)["']?\s*[:=]\s*["']?([^\s"'`,;]{8,})/gi;
+const ASSIGNMENT_RE = /(?:pass(?:word|phrase|wd)?|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|auth[_-]?token|client[_-]?secret|credential|creds|key)["']?\s*[:=]\s*["']?([^\s"'`,;]{8,})/gi;
 /** Shannon entropy in bits/char. Pure; used by the assignment fallback. */
 export function shannonEntropy(s) {
     if (!s)

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

@@ -139,8 +139,11 @@ export function buildSpdx(components, meta) {
         documentNamespace: `https://swarmdo/spdx/${safe(meta.name)}-${meta.version}`,
         packages: [
             { SPDXID: 'SPDXRef-Package-root', name: meta.name, versionInfo: meta.version, downloadLocation: 'NOASSERTION' },
-            ...components.map((c) => ({
-                SPDXID: `SPDXRef-Package-${safe(c.name)}-${safe(c.version)}`,
+            ...components.map((c, i) => ({
+                // Index prefix makes the ID self-delimiting (#11): name and version can
+                // both contain `-` after sanitizing, so `${name}-${version}` alone can
+                // collide across distinct (name, version) pairs.
+                SPDXID: `SPDXRef-Package-${i}-${safe(c.name)}-${safe(c.version)}`,
                 name: c.name,
                 versionInfo: c.version,
                 downloadLocation: 'NOASSERTION',

package/v3/@swarmdo/cli/dist/src/swarmvector/model-prices.js

@@ -35,14 +35,24 @@ export const MODEL_PRICES = {
     // Mid tier
     'anthropic/claude-haiku-4.5': { in: 1.00, out: 5.00 },
     'openai/gpt-4.1': { in: 2.00, out: 8.00 },
-    // Strong tier
+    // Strong tier — current-gen Claude (first-party list prices; OpenRouter
+    // mirrors them for anthropic/* slugs). Opus dropped to $5/$25 at 4.5 and
+    // held there through 4.8 — do NOT price these at the legacy $15/$75.
+    'anthropic/claude-sonnet-5': { in: 3.00, out: 15.00 },
     'anthropic/claude-sonnet-4-6': { in: 3.00, out: 15.00 },
+    'anthropic/claude-opus-4-8': { in: 5.00, out: 25.00 },
+    'anthropic/claude-opus-4-5': { in: 5.00, out: 25.00 },
+    'anthropic/claude-fable-5': { in: 10.00, out: 50.00 },
+    // Legacy Opus 4.0 kept — its $15/$75 is correct for THAT model, still a
+    // valid slug; the current opus tier is priced by claude-opus-4-8 above.
     'anthropic/claude-opus-4': { in: 15.00, out: 75.00 },
     // Tier-label fallbacks (when the trajectory only carries a coarse tier
     // and not a concrete modelId — happens before iter 13 wiring landed).
+    // "opus tier" today resolves to Opus 4.8-class ($5/$25); pricing it at the
+    // retired $15/$75 made the cost-optimal router avoid opus 3x too eagerly.
     haiku: { in: 1.00, out: 5.00 },
     sonnet: { in: 3.00, out: 15.00 },
-    opus: { in: 15.00, out: 75.00 },
+    opus: { in: 5.00, out: 25.00 },
     inherit: { in: 3.00, out: 15.00 },
 };
 /**