swarmdo 1.27.0 → 1.30.0

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

@@ -14,10 +14,16 @@
  */
 import { output } from '../output.js';
 import { aggregateBlocks, aggregateUsage, collectUsage, totalUsage, localDateKey, } from '../usage/transcript-usage.js';
-import { collectToolErrors } from '../usage/transcript-errors.js';
+import { collectToolErrors, delegationFromReport } 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';
+import { computeReflection, monthsBefore, hourSparkline } from '../usage/reflect.js';
+import { renderReflectionHtml } from '../usage/reflect-html.js';
+import { forecastWindow, parseRateLimits, worstStatus, formatForecast, formatLimitSegment } from '../usage/limits.js';
+import { readFileSync } from 'node:fs';
+import { toCsv } from '../util/csv.js';
+import { projectMonthEnd, daysInMonthOf } from '../usage/spend-forecast.js';
 const VIEWS = {
     daily: { dimension: 'day', label: 'Date' },
     monthly: { dimension: 'month', label: 'Month' },
@@ -376,6 +382,143 @@ function runGuardView(ctx, collection) {
         output.writeln(output.dim('exit 1 (--strict + over budget)'));
     return { success: exitCode === 0, exitCode };
 }
+const PERIOD_MONTHS = { '1m': 1, '3m': 3, '6m': 6, '12m': 12 };
+/** `usage reflect` — a wrapped-style retrospective over the local transcripts (#47). */
+function runReflectView(ctx, collection) {
+    const periodFlag = (typeof ctx.flags.period === 'string' ? ctx.flags.period : '3m').toLowerCase();
+    const months = PERIOD_MONTHS[periodFlag];
+    if (!months) {
+        output.printError(`unknown --period "${periodFlag}" (expected ${Object.keys(PERIOD_MONTHS).join('|')})`);
+        return { success: false, exitCode: 1 };
+    }
+    const to = localDateKey(new Date());
+    const from = monthsBefore(to, months);
+    const dayRows = aggregateUsage(collection.events, 'day').map((r) => ({ key: r.key, totals: r.totals }));
+    const md = new Map();
+    const pd = new Map(); // per-(project, day) for top projects
+    const hourHistogram = new Array(24).fill(0); // local-hour cost, windowed to [from,to]
+    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);
+        // per-(project, day) fold (space separator is safe — dateKey is fixed-width)
+        const pk = `${e.project} ${e.dateKey}`;
+        const prow = pd.get(pk) ?? { key: e.project, day: e.dateKey, totals: { costUsd: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 0 } };
+        prow.totals.costUsd += e.costUsd;
+        prow.totals.totalTokens += e.inputTokens + e.outputTokens + e.cacheWriteTokens + e.cacheReadTokens;
+        pd.set(pk, prow);
+        if (e.dateKey >= from && e.dateKey <= to)
+            hourHistogram[new Date(e.timestampMs).getHours()] += e.costUsd;
+    }
+    const reflection = computeReflection(dayRows, [...md.values()], from, to, {}, [...pd.values()], hourHistogram);
+    // Delegation ratio (#47): reuse the (windowed) tool-error scan to count Task
+    // (subagent) calls vs all tool calls — the parsing is already tested there.
+    const delDirFlag = ctx.flags.dir;
+    const delDirs = typeof delDirFlag === 'string' ? [delDirFlag] : Array.isArray(delDirFlag) ? delDirFlag.map(String) : undefined;
+    const delegation = delegationFromReport(collectToolErrors({ dirs: delDirs, since: from, until: to }));
+    if (ctx.flags.json === true) {
+        output.printJson({ ...reflection, delegation });
+        return { success: true, data: reflection };
+    }
+    if (ctx.flags.html === true) {
+        output.writeln(renderReflectionHtml(reflection, { generatedAt: to, delegation }));
+        return { success: true, exitCode: 0 };
+    }
+    const r = reflection;
+    const pctStr = (x) => `${Math.round(x * 100)}%`;
+    const arrow = r.trend.direction === 'up' ? '↑' : r.trend.direction === 'down' ? '↓' : '→';
+    output.writeln(output.bold(`Usage reflect  ${r.period.from}..${r.period.to}`) + output.dim(`  (${periodFlag}, ${r.period.spanDays} days)`));
+    if (r.totals.activeDays === 0) {
+        output.writeln(output.info('no Claude Code activity in this window'));
+        return { success: true, exitCode: 0 };
+    }
+    output.writeln('');
+    output.writeln(`  Total spend        ${output.bold(fmtCost(r.totals.costUsd))}  ${output.dim(`across ${r.totals.activeDays} active day${r.totals.activeDays === 1 ? '' : 's'} of ${r.period.spanDays}`)}`);
+    output.writeln(`  Total tokens       ${r.totals.totalTokens.toLocaleString()}`);
+    if (r.busiestDay)
+        output.writeln(`  Busiest day        ${r.busiestDay.day}  ${output.dim(`(${fmtCost(r.busiestDay.costUsd)}, ${r.busiestDay.totalTokens.toLocaleString()} tok)`)}`);
+    output.writeln(`  Longest streak     ${r.longestStreak} day${r.longestStreak === 1 ? '' : 's'}`);
+    output.writeln(`  Avg / active day   ${fmtCost(r.avgCostPerActiveDay)}`);
+    output.writeln(`  Cache read share   ${pctStr(r.cacheReadPct)}`);
+    if (delegation.toolCalls > 0) {
+        output.writeln(`  Delegation         ${pctStr(delegation.ratio)}  ${output.dim(`(${delegation.taskCalls} of ${delegation.toolCalls} tool calls to subagents)`)}`);
+    }
+    output.writeln(`  Cost trend         ${arrow} ${fmtCost(r.trend.firstHalfCost)} → ${fmtCost(r.trend.secondHalfCost)} ${output.dim(`(${r.trend.direction})`)}`);
+    if (r.peakHour)
+        output.writeln(`  Peak hour          ${String(r.peakHour.hour).padStart(2, '0')}:00  ${output.dim(`(${fmtCost(r.peakHour.value)})`)}`);
+    if (r.hourHistogram.some((v) => v > 0)) {
+        output.writeln(`  By hour            ${hourSparkline(r.hourHistogram)}  ${output.dim('0…23')}`);
+    }
+    if (r.topModels.length) {
+        output.writeln('');
+        output.writeln(output.bold('  Top models'));
+        r.topModels.forEach((m, i) => {
+            output.writeln(`    ${i + 1}. ${m.model.padEnd(22)} ${fmtCost(m.costUsd).padStart(9)}  ${output.dim(pctStr(m.pct))}`);
+        });
+    }
+    if (r.topProjects.length) {
+        output.writeln('');
+        output.writeln(output.bold('  Top projects'));
+        r.topProjects.forEach((p, i) => {
+            const name = p.model.length > 34 ? '…' + p.model.slice(-33) : p.model;
+            output.writeln(`    ${i + 1}. ${name.padEnd(34)} ${fmtCost(p.costUsd).padStart(9)}  ${output.dim(pctStr(p.pct))}`);
+        });
+    }
+    return { success: true, exitCode: 0 };
+}
+/** `usage limits` — forecast the official 5h/7d quota windows from the
+ * statusline rate_limits payload (stdin or --payload). #46. */
+function runLimitsView(ctx) {
+    const nowMs = Date.now();
+    let raw = typeof ctx.flags.payload === 'string' ? ctx.flags.payload : '';
+    if (!raw && !process.stdin.isTTY) {
+        try {
+            raw = readFileSync(0, 'utf8');
+        }
+        catch { /* no piped input */ }
+    }
+    if (!raw.trim()) {
+        output.writeln(output.info("no rate_limits payload — pipe Claude Code's statusline JSON in, or pass --payload '<json>'"));
+        output.writeln(output.dim('  e.g. in a statusline command:  … | swarmdo usage limits'));
+        return { success: true, exitCode: 0 };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        output.printError('payload is not valid JSON');
+        return { success: false, exitCode: 1 };
+    }
+    const windows = parseRateLimits(payload);
+    if (windows.length === 0) {
+        output.writeln(output.info('no five_hour / seven_day rate_limits found in the payload'));
+        return { success: true, exitCode: 0 };
+    }
+    const forecasts = windows.map((w) => ({ label: w.label, f: forecastWindow(w.state, nowMs) }));
+    if (ctx.flags.json === true) {
+        output.printJson(forecasts.map((x) => ({ label: x.label, ...x.f })));
+        return { success: true, data: forecasts };
+    }
+    if (ctx.flags.oneline === true) {
+        // Compact statusline-ready indicator, e.g. "5h 72%⚠ · 7d 12%".
+        output.writeln(formatLimitSegment(forecasts));
+        const worstOne = worstStatus(forecasts.map((x) => x.f));
+        return { success: true, exitCode: ctx.flags.strict === true && worstOne === 'over' ? 1 : 0 };
+    }
+    const worst = worstStatus(forecasts.map((x) => x.f));
+    output.writeln(output.bold('Usage limits') + output.dim(`  (${worst})`));
+    for (const { label, f } of forecasts) {
+        const line = formatForecast(label, f, nowMs);
+        output.writeln('  ' + (f.status === 'over' ? output.error(line) : f.status === 'warn' ? line : output.dim(line)));
+    }
+    const exitCode = ctx.flags.strict === true && worst === 'over' ? 1 : 0;
+    if (exitCode === 1)
+        output.writeln(output.dim('exit 1 (--strict + cap reached)'));
+    return { success: exitCode === 0, exitCode };
+}
 async function run(ctx) {
     const viewName = (ctx.args[0] || 'daily').toLowerCase();
     if (viewName === 'blocks') {
@@ -409,9 +552,17 @@ async function run(ctx) {
         const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
         return runDiffView(ctx, collectUsage({ dirs }));
     }
+    if (viewName === 'reflect') {
+        const dirFlag = ctx.flags.dir;
+        const dirs = typeof dirFlag === 'string' ? [dirFlag] : Array.isArray(dirFlag) ? dirFlag.map(String) : undefined;
+        return runReflectView(ctx, collectUsage({ dirs }));
+    }
+    if (viewName === 'limits') {
+        return runLimitsView(ctx); // reads the rate_limits payload from stdin/--payload, not transcripts
+    }
     const view = VIEWS[viewName];
     if (!view) {
-        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard|diff)`));
+        output.writeln(output.error(`unknown view: ${viewName} (expected ${Object.keys(VIEWS).join('|')}|blocks|errors|cache|guard|diff|reflect|limits)`));
         return { success: false, exitCode: 1 };
     }
     const since = typeof ctx.flags.since === 'string' ? ctx.flags.since : undefined;
@@ -433,12 +584,31 @@ async function run(ctx) {
         output.writeln(JSON.stringify(jsonPayload(viewName, collection, rows, grand, since, until), null, 2));
         return { success: true, exitCode: 0, data: grand };
     }
+    if (ctx.flags.csv === true) {
+        // Portable export for spreadsheets / expense reports.
+        const headers = ['key', 'costUsd', 'inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'totalTokens', 'entries'];
+        const csvRows = rows.map((r) => [r.key, r.totals.costUsd, r.totals.inputTokens, r.totals.outputTokens, r.totals.cacheReadTokens, r.totals.cacheWriteTokens, r.totals.totalTokens, r.totals.entries]);
+        output.writeln(toCsv(headers, csvRows));
+        return { success: true, exitCode: 0, data: grand };
+    }
     if (collection.events.length === 0) {
         output.writeln(output.info(`no usage entries found in ${collection.filesScanned} transcript files`));
         return { success: true, exitCode: 0 };
     }
     output.writeln(output.bold(`Claude Code usage — ${viewName}`) + (since || until ? output.dim(`  (${since ?? '…'} → ${until ?? '…'})`) : ''));
     renderTable(view.label, rows, grand);
+    if (viewName === 'monthly') {
+        // Month-end pace projection for the current calendar month.
+        const today = localDateKey(new Date());
+        const curMonth = today.slice(0, 7);
+        const dom = Number(today.slice(8, 10));
+        const curRow = rows.find((r) => r.key === curMonth);
+        const dim = daysInMonthOf(curMonth);
+        if (curRow && dom > 0 && Number.isFinite(dim)) {
+            const p = projectMonthEnd(curRow.totals.costUsd, dom, dim);
+            output.writeln(output.dim(`${curMonth} on pace for ~${fmtCost(p.projectedUsd)}  (${fmtCost(p.monthToDateUsd)} over ${dom}/${p.daysInMonth} days · ~${fmtCost(p.remainingUsd)} to go)`));
+        }
+    }
     output.writeln(output.dim(`${collection.filesScanned} transcript files · ${grand.entries} billed responses · sources: ${collection.dirsScanned.join(', ')}`));
     if (collection.unpricedModels.length > 0) {
         const { unpricedResponses, unpricedTokens } = unpricedStats(collection.events);
@@ -456,11 +626,13 @@ export const usageCommand = {
         { name: 'dir', description: 'explicit Claude projects dir (replaces auto-discovery)', type: 'string' },
         { name: 'limit', description: 'max rows for models/projects/sessions views', type: 'number' },
         { name: 'json', description: 'machine-readable output', type: 'boolean', default: false },
+        { name: 'csv', description: 'CSV export (daily|monthly|models|projects|sessions views)', type: 'boolean', default: false },
     ],
     examples: [
         { command: 'swarmdo usage', description: 'Daily token/cost table across all local Claude Code sessions' },
         { command: 'swarmdo usage models --since 2026-07-01', description: 'Spend per model this month' },
         { command: 'swarmdo usage projects --json', description: 'Per-project totals as JSON' },
+        { command: 'swarmdo usage monthly --csv > usage.csv', description: 'Export monthly spend to CSV' },
         { command: 'swarmdo cost sessions --limit 10', description: 'Ten most expensive sessions (alias)' },
     ],
     action: run,

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 },
 };
 /**

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

@@ -11,14 +11,23 @@
  * No XML dependency — well-formed JUnit escapes <>& in attribute values, so a
  * focused tokenizer over <testcase>/<failure> is safe.
  */
-/** Decode the five predefined XML entities. Pure. */
+/** A numeric character reference → its char, or the original ref if the code
+ * point is out of the valid Unicode range (so a malformed entity never throws
+ * and leaks literally instead of aborting the parse). Pure. */
+function fromCodePointSafe(n, original) {
+    return Number.isInteger(n) && n >= 0 && n <= 0x10ffff ? String.fromCodePoint(n) : original;
+}
+/** Decode the five predefined XML entities plus decimal AND hex numeric
+ * character references (`&#65;`, `&#x1b;`). XML 1.0 allows both numeric forms;
+ * JUnit stack traces with ANSI colouring escape control chars as hex. Pure. */
 function decodeXml(s) {
     return s
         .replace(/&lt;/g, '<')
         .replace(/&gt;/g, '>')
         .replace(/&quot;/g, '"')
         .replace(/&apos;/g, "'")
-        .replace(/&#(\d+);/g, (_, d) => String.fromCharCode(parseInt(d, 10)))
+        .replace(/&#x([0-9a-fA-F]+);/g, (m, h) => fromCodePointSafe(parseInt(h, 16), m))
+        .replace(/&#(\d+);/g, (m, d) => fromCodePointSafe(parseInt(d, 10), m))
         .replace(/&amp;/g, '&'); // last, so &amp;lt; → &lt; not <
 }
 /**

package/v3/@swarmdo/cli/dist/src/transcript/export.d.ts

@@ -45,6 +45,11 @@ export interface RenderOptions {
 export declare function cleanUserText(s: string): string;
 /** Flatten tool_result content (string | array of {text}) to text. */
 export declare function contentToText(content: unknown): string;
+/** Count the conversational turns in a rendered body by matching only the
+ * exact role-heading lines. Anchored to end-of-line so `### Foo` markdown
+ * headings written *inside* a user/assistant message don't inflate the count.
+ * Pure. */
+export declare function countRenderedTurns(markdown: string): number;
 /** Render an ordered list of parsed transcript lines into Markdown. */
 export declare function renderTranscriptMarkdown(lines: RawTranscriptLine[], opts?: RenderOptions): string;
 export interface SessionSummary {

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

@@ -92,6 +92,13 @@ function renderLine(role, content, opts) {
         sections.push(results.join('\n'));
     return sections.join('\n\n');
 }
+/** Count the conversational turns in a rendered body by matching only the
+ * exact role-heading lines. Anchored to end-of-line so `### Foo` markdown
+ * headings written *inside* a user/assistant message don't inflate the count.
+ * Pure. */
+export function countRenderedTurns(markdown) {
+    return (markdown.match(/^### (?:🤖 Assistant|👤 User)$/gm) || []).length;
+}
 /** Render an ordered list of parsed transcript lines into Markdown. */
 export function renderTranscriptMarkdown(lines, opts = {}) {
     const resolved = {
@@ -202,7 +209,7 @@ export function exportSession(idOrLatest, opts = {}) {
     const sessionId = sessionIdFromFile(file);
     const project = path.basename(path.dirname(file));
     const body = renderTranscriptMarkdown(lines, opts);
-    const turns = (body.match(/^### /gm) || []).length;
+    const turns = countRenderedTurns(body);
     const header = `# Claude Code session \`${sessionId}\`\n\n- Project: \`${project}\`\n- Turns: ${turns}\n\n---\n\n`;
     return { markdown: header + body, sessionId, project, turns, file };
 }

package/v3/@swarmdo/cli/dist/src/usage/claude-pricing.d.ts

@@ -29,8 +29,12 @@ export interface TranscriptModelPrice {
  *   'claude-sonnet-4-6@20260115'           → 'claude-sonnet-4-6'  (Vertex)
  */
 export declare function normalizeTranscriptModelId(raw: string): string;
-/** Longest-prefix price lookup; undefined = unpriced (report it, don't guess). */
-export declare function resolveTranscriptPrice(rawModelId: string): TranscriptModelPrice | undefined;
+/**
+ * Longest-prefix price lookup; undefined = unpriced (report it, don't guess).
+ * Pass the transcript entry's timestamp as `atMs` to get date-ranged promo
+ * rates (e.g. Sonnet 5 intro pricing); omitted → sticker price.
+ */
+export declare function resolveTranscriptPrice(rawModelId: string, atMs?: number): TranscriptModelPrice | undefined;
 /** Token counts for one billed API response. */
 export interface TokenBundle {
     inputTokens: number;