swarmdo 1.30.0 → 1.45.0

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

@@ -193,9 +193,13 @@ export function makeIgnoreMatcher(patterns) {
         const dirOnly = body.endsWith('/');
         if (dirOnly)
             body = body.slice(0, -1);
-        const anchored = body.startsWith('/');
-        if (anchored)
+        const leadingSlash = body.startsWith('/');
+        if (leadingSlash)
             body = body.slice(1);
+        // gitignore(5): a slash ANYWHERE (not just leading) anchors the pattern to
+        // the root — `src/fixtures` matches `src/fixtures` but NOT `a/src/fixtures`.
+        // Only a slash-free pattern (`dir`, `*.ext`) matches at any depth.
+        const anchored = leadingSlash || body.includes('/');
         const re = new RegExp('^' + globToRegExp(body) + (dirOnly ? '(/|$)' : '($|/)'));
         return { negate, anchored, re };
     });

package/v3/@swarmdo/cli/dist/src/permissions/audit.d.ts

@@ -0,0 +1,50 @@
+/**
+ * permissions/audit.ts — static analyzer for Claude Code permission rules (#80).
+ *
+ * Claude Code reads `permissions.allow` / `deny` / `ask` arrays from
+ * `.claude/settings.json` (+ `settings.local.json` + `~/.claude/settings.json`),
+ * each entry a `Tool` or `Tool(specifier)` rule, with precedence deny > ask >
+ * allow. Users hand-edit these and get them wrong: a rule in both allow and deny
+ * (silently dead), a specific allow already covered by a broader one, or an
+ * over-broad `Bash(*)` that re-grants what deny was fencing off.
+ *
+ * This is the PURE rule layer — parse + set logic, no fs/network — so the whole
+ * analysis is unit-testable; the command reads the settings files.
+ */
+export type PermSeverity = 'error' | 'warn' | 'info';
+export interface PermFinding {
+    severity: PermSeverity;
+    /** kebab-case finding type */
+    rule: string;
+    message: string;
+    /** the rule string(s) the finding is about */
+    subjects: string[];
+}
+export interface ParsedRule {
+    tool: string;
+    /** undefined = a bare tool rule (grants the whole tool) */
+    specifier?: string;
+}
+export type ParseResult = ParsedRule | {
+    error: string;
+};
+export interface PermissionSets {
+    allow?: string[];
+    deny?: string[];
+    ask?: string[];
+}
+/** Parse one `Tool` or `Tool(specifier)` rule. */
+export declare function parseRule(raw: string): ParseResult;
+/**
+ * Does `broad` grant everything `specific` grants (same tool)? A bare tool or a
+ * `*` specifier covers anything on that tool; otherwise the broad specifier is
+ * glob-matched against the specific one (exact equality included).
+ */
+export declare function covers(broad: ParsedRule, specific: ParsedRule): boolean;
+/**
+ * Analyze a merged permission ruleset. Reports: allow↔deny conflicts (dead allow
+ * rules), allow rules shadowed by a broader allow, over-broad whole-tool grants,
+ * exact duplicates, and malformed rules. Order: errors, then warns, then infos.
+ */
+export declare function auditPermissions(perms: PermissionSets): PermFinding[];
+//# sourceMappingURL=audit.d.ts.map

package/v3/@swarmdo/cli/dist/src/permissions/audit.js

@@ -0,0 +1,127 @@
+/**
+ * permissions/audit.ts — static analyzer for Claude Code permission rules (#80).
+ *
+ * Claude Code reads `permissions.allow` / `deny` / `ask` arrays from
+ * `.claude/settings.json` (+ `settings.local.json` + `~/.claude/settings.json`),
+ * each entry a `Tool` or `Tool(specifier)` rule, with precedence deny > ask >
+ * allow. Users hand-edit these and get them wrong: a rule in both allow and deny
+ * (silently dead), a specific allow already covered by a broader one, or an
+ * over-broad `Bash(*)` that re-grants what deny was fencing off.
+ *
+ * This is the PURE rule layer — parse + set logic, no fs/network — so the whole
+ * analysis is unit-testable; the command reads the settings files.
+ */
+/** Parse one `Tool` or `Tool(specifier)` rule. */
+export function parseRule(raw) {
+    const s = (raw ?? '').trim();
+    if (!s)
+        return { error: 'empty rule' };
+    const open = s.indexOf('(');
+    if (open === -1) {
+        // Bare tool, e.g. `Bash` or `WebFetch`.
+        if (!/^[A-Za-z_][\w-]*$/.test(s))
+            return { error: 'invalid tool name' };
+        return { tool: s };
+    }
+    if (!s.endsWith(')'))
+        return { error: 'unbalanced parentheses' };
+    const tool = s.slice(0, open);
+    if (!tool)
+        return { error: 'missing tool name' };
+    if (!/^[A-Za-z_][\w-]*$/.test(tool))
+        return { error: 'invalid tool name' };
+    const specifier = s.slice(open + 1, s.length - 1);
+    if (specifier.trim() === '')
+        return { error: 'empty specifier' };
+    return { tool, specifier };
+}
+function isParsed(r) {
+    return r.tool !== undefined;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Turn a specifier glob (`*` = any run) into an anchored matcher. */
+function specifierMatches(broadSpec, target) {
+    const re = new RegExp('^' + broadSpec.split('*').map(escapeRegex).join('.*') + '$');
+    return re.test(target);
+}
+/**
+ * Does `broad` grant everything `specific` grants (same tool)? A bare tool or a
+ * `*` specifier covers anything on that tool; otherwise the broad specifier is
+ * glob-matched against the specific one (exact equality included).
+ */
+export function covers(broad, specific) {
+    if (broad.tool !== specific.tool)
+        return false;
+    if (broad.specifier === undefined)
+        return true; // bare tool grants all
+    if (broad.specifier === '*')
+        return true;
+    if (specific.specifier === undefined)
+        return false; // broad is scoped, specific is the whole tool
+    return specifierMatches(broad.specifier, specific.specifier);
+}
+/** True for a rule that grants an entire tool (`Bash` or `Bash(*)`). */
+function isWholeTool(r) {
+    return r.specifier === undefined || r.specifier === '*';
+}
+/**
+ * Analyze a merged permission ruleset. Reports: allow↔deny conflicts (dead allow
+ * rules), allow rules shadowed by a broader allow, over-broad whole-tool grants,
+ * exact duplicates, and malformed rules. Order: errors, then warns, then infos.
+ */
+export function auditPermissions(perms) {
+    const findings = [];
+    const parsed = { allow: [], deny: [], ask: [] };
+    for (const list of ['allow', 'deny', 'ask']) {
+        for (const raw of perms[list] ?? []) {
+            const r = parseRule(raw);
+            if (!isParsed(r)) {
+                findings.push({ severity: 'error', rule: 'malformed-rule', message: `${list} rule "${raw}" is malformed: ${r.error}`, subjects: [raw] });
+            }
+            else {
+                parsed[list].push({ raw, parsed: r });
+            }
+        }
+    }
+    // conflict: an allow rule that some deny rule covers is dead (deny wins).
+    for (const a of parsed.allow) {
+        const killer = parsed.deny.find((d) => covers(d.parsed, a.parsed));
+        if (killer) {
+            findings.push({ severity: 'error', rule: 'conflict', message: `allow "${a.raw}" is dead — deny "${killer.raw}" overrides it (deny wins)`, subjects: [a.raw, killer.raw] });
+        }
+    }
+    // over-broad: an allow rule granting a whole tool defeats scoped denies.
+    for (const a of parsed.allow) {
+        if (isWholeTool(a.parsed)) {
+            findings.push({ severity: 'warn', rule: 'over-broad', message: `allow "${a.raw}" grants every ${a.parsed.tool} call — narrow it or a scoped deny can't fence it off`, subjects: [a.raw] });
+        }
+    }
+    // exact duplicates within a list.
+    for (const list of ['allow', 'deny', 'ask']) {
+        const seen = new Set();
+        const dupped = new Set();
+        for (const e of parsed[list]) {
+            if (seen.has(e.raw))
+                dupped.add(e.raw);
+            else
+                seen.add(e.raw);
+        }
+        for (const raw of dupped) {
+            findings.push({ severity: 'info', rule: 'duplicate', message: `${list} rule "${raw}" is listed more than once`, subjects: [raw] });
+        }
+    }
+    // shadowed-allow: a scoped allow rule already covered by a broader, different allow.
+    for (const a of parsed.allow) {
+        if (isWholeTool(a.parsed))
+            continue; // whole-tool grants are flagged as over-broad, not shadowed
+        const broader = parsed.allow.find((b) => b.raw !== a.raw && covers(b.parsed, a.parsed));
+        if (broader) {
+            findings.push({ severity: 'info', rule: 'shadowed-allow', message: `allow "${a.raw}" is redundant — already covered by "${broader.raw}"`, subjects: [a.raw, broader.raw] });
+        }
+    }
+    const order = { error: 0, warn: 1, info: 2 };
+    return findings.sort((x, y) => order[x.severity] - order[y.severity]);
+}
+//# sourceMappingURL=audit.js.map

package/v3/@swarmdo/cli/dist/src/plugins/store/search.js

@@ -60,7 +60,7 @@ export function searchPlugins(registry, options = {}) {
     }
     // Security audit filter
     if (options.hasSecurityAudit !== undefined) {
-        plugins = plugins.filter(p => options.hasSecurityAudit ? p.securityAudit !== undefined : true);
+        plugins = plugins.filter(p => options.hasSecurityAudit ? p.securityAudit !== undefined : p.securityAudit === undefined);
     }
     // Sort
     const sortBy = options.sortBy || 'downloads';

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

@@ -44,20 +44,37 @@ export const RULES = [
  * Keyword set mirrors gitleaks' reference `generic-api-key` rule (adds bare
  * `key`, `credential`, `creds` so `PRIVATE_KEY=`/`ENCRYPTION_KEY=`/`DB_CREDENTIAL=`
  * secrets reach the entropy check). The `[:=]` immediately after the keyword
- * anchors it, so `keyboard=`/`monkey_val=` don't match; the entropy + length
- * gates keep low-entropy values (paths, short flags) from being flagged.
+ * anchors it, so `keyboard=`/`monkey_val=` don't match. A `(?<![A-Za-z])` guard
+ * requires the keyword NOT be glued to a preceding letter, so a common word that
+ * merely ENDS in a keyword — `monkey=`/`donkey=`/`whiskey=`/`turkey=` (end in
+ * `key`), `compass=`/`bypass=` (end in `pass`) — is no longer flagged as a
+ * secret, while a `_`/`-`-separated name (`PRIVATE_KEY`, `x-api-key`) still
+ * matches (`_`/`-` aren't letters). The entropy + length gates keep low-entropy
+ * values (paths, short flags) out. The value class also stops at the URL/query
+ * delimiters `&`, `?`, `#` (absent from base64/base64url/hex token alphabets):
+ * otherwise a query-string secret like `client_secret=…&api_key=…` over-captures
+ * past the `&` into the next secret, and that inflated span — overlapping a range
+ * the high-confidence RULES pass already claimed — gets dropped entirely, leaving
+ * the first secret unredacted.
  */
-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;
+const ASSIGNMENT_RE = /(?<![A-Za-z])(?: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)
         return 0;
+    // Iterate AND normalize by code points, not UTF-16 code units. `for..of` /
+    // spread yield one symbol per code point, but `s.length` counts an astral
+    // char (emoji, CJK Ext-B, math alphanumerics) as 2 units — so dividing the
+    // per-symbol counts by s.length made the probabilities sum to <1 and
+    // under-counted entropy up to ~2×, letting a high-entropy secret with astral
+    // chars fall under the threshold and pass through UN-redacted (#95).
+    const cps = [...s];
     const freq = new Map();
-    for (const ch of s)
+    for (const ch of cps)
         freq.set(ch, (freq.get(ch) ?? 0) + 1);
     let bits = 0;
     for (const n of freq.values()) {
-        const p = n / s.length;
+        const p = n / cps.length;
         bits -= p * Math.log2(p);
     }
     return bits;

package/v3/@swarmdo/cli/dist/src/redact/sarif.d.ts

@@ -0,0 +1,28 @@
+/**
+ * sarif.ts — render redact secret-scan findings as a SARIF 2.1.0 document.
+ *
+ * SARIF (Static Analysis Results Interchange Format) is a ratified OASIS
+ * standard that GitHub code-scanning ingests via `github/codeql-action/
+ * upload-sarif`. Emit it from `redact --scan` in CI and leaked-secret findings
+ * surface as alerts in the Security tab + PR annotations instead of dying in
+ * the build log — the same thing gitleaks/trufflehog/ggshield do with their
+ * `--report-format sarif`.
+ *
+ * Pure + deterministic: findings in, JSON string out. No fs/network.
+ */
+import type { Finding } from './redact.js';
+export interface SarifOptions {
+    /** SARIF tool.driver.name (default 'swarmdo-redact') */
+    toolName?: string;
+    /** SARIF tool.driver.version — omitted from the document when not given */
+    toolVersion?: string;
+    /**
+     * URI for the artifact each finding lives in. `redact --scan` reads a STREAM
+     * (stdin / wrapped output), so there is no committed file by default; pass
+     * this (e.g. from `--source <path>`) to anchor the alerts onto a repo path.
+     */
+    artifactUri?: string;
+}
+/** Render `findings` as a SARIF 2.1.0 document string. Pure + deterministic. */
+export declare function toSarif(findings: Finding[], opts?: SarifOptions): string;
+//# sourceMappingURL=sarif.d.ts.map

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

@@ -0,0 +1,53 @@
+/**
+ * sarif.ts — render redact secret-scan findings as a SARIF 2.1.0 document.
+ *
+ * SARIF (Static Analysis Results Interchange Format) is a ratified OASIS
+ * standard that GitHub code-scanning ingests via `github/codeql-action/
+ * upload-sarif`. Emit it from `redact --scan` in CI and leaked-secret findings
+ * surface as alerts in the Security tab + PR annotations instead of dying in
+ * the build log — the same thing gitleaks/trufflehog/ggshield do with their
+ * `--report-format sarif`.
+ *
+ * Pure + deterministic: findings in, JSON string out. No fs/network.
+ */
+const SARIF_SCHEMA = 'https://json.schemastore.org/sarif-2.1.0.json';
+const INFO_URI = 'the upstream project (see NOTICE)';
+/** Render `findings` as a SARIF 2.1.0 document string. Pure + deterministic. */
+export function toSarif(findings, opts = {}) {
+    const toolName = opts.toolName ?? 'swarmdo-redact';
+    // One rule descriptor per distinct ruleId, in first-seen order. Findings
+    // carry their own description, so the entropy fallback (not in RULES) is
+    // covered too — every result.ruleId is guaranteed to appear in rules[].
+    const ruleIndex = new Map();
+    const rules = [];
+    for (const f of findings) {
+        if (ruleIndex.has(f.ruleId))
+            continue;
+        ruleIndex.set(f.ruleId, rules.length);
+        rules.push({ id: f.ruleId, name: f.ruleId, shortDescription: { text: f.description } });
+    }
+    const results = findings.map((f) => {
+        const physicalLocation = {
+            region: { startLine: f.line, startColumn: f.column },
+        };
+        if (opts.artifactUri)
+            physicalLocation.artifactLocation = { uri: opts.artifactUri };
+        return {
+            ruleId: f.ruleId,
+            ruleIndex: ruleIndex.get(f.ruleId),
+            level: 'error',
+            message: { text: `Possible secret: ${f.description}` },
+            locations: [{ physicalLocation }],
+        };
+    });
+    const driver = { name: toolName, informationUri: INFO_URI, rules };
+    if (opts.toolVersion)
+        driver.version = opts.toolVersion;
+    const doc = {
+        $schema: SARIF_SCHEMA,
+        version: '2.1.0',
+        runs: [{ tool: { driver }, results }],
+    };
+    return JSON.stringify(doc, null, 2);
+}
+//# sourceMappingURL=sarif.js.map

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

@@ -69,4 +69,23 @@ export declare const DOC_FILES: string[];
 export declare function planRelease(input: ReleaseInput): ReleasePlan;
 /** One-line human rendering of a step (for the dry-run plan). */
 export declare function renderStep(s: ReleaseStep): string;
+export interface SiteIdentity {
+    name: string;
+    email: string;
+}
+/**
+ * Resolve the committer identity for the throwaway swarmdo.com clone. That
+ * clone inherits no identity, and a machine may have only a *local* (per-repo)
+ * git user — so `git commit` there dies with "Author identity unknown" unless
+ * we inject one. Prefer the operator's configured identity; fall back to the
+ * Swarmdo bot so the site deploy never fails on a missing global git config.
+ * `readConfig` is injected (real: `git -C <root> config <key>`) so this stays
+ * pure and unit-testable.
+ */
+export declare function resolveSiteIdentity(readConfig: (key: string) => string | undefined): SiteIdentity;
+/**
+ * `git commit` argv for the site sync — injects the identity via `-c` so the
+ * commit succeeds without a global git user, and keeps the bot co-author trailer.
+ */
+export declare function siteCommitArgs(version: string, id: SiteIdentity): string[];
 //# sourceMappingURL=release.d.ts.map

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

@@ -49,7 +49,7 @@ export function planRelease(input) {
     for (const f of TRIO_FILES)
         steps.push({ kind: 'bump-json', file: f, version: next });
     steps.push({ kind: 'bump-lock', file: LOCK_FILE, version: next });
-    steps.push({ kind: 'sync-docs', version: next, files: DOC_FILES });
+    steps.push({ kind: 'sync-docs', version: next, files: [...DOC_FILES] }); // copy — a pure plan must not alias the module constant
     steps.push({ kind: 'exec', title: 'commit release', cmd: 'git', args: ['commit', '-am', `release: ${tag}`], cwd: root });
     steps.push({ kind: 'exec', title: 'push main', cmd: 'git', args: ['push', 'origin', 'main'], cwd: root });
     if (!input.skipPublish) {
@@ -83,4 +83,32 @@ export function renderStep(s) {
         case 'deploy-site': return `deploy website → SwarmDo/swarmdo.com (copy working copy, push, curl-verify swarmdo.com serves ${s.version})`;
     }
 }
+/**
+ * Resolve the committer identity for the throwaway swarmdo.com clone. That
+ * clone inherits no identity, and a machine may have only a *local* (per-repo)
+ * git user — so `git commit` there dies with "Author identity unknown" unless
+ * we inject one. Prefer the operator's configured identity; fall back to the
+ * Swarmdo bot so the site deploy never fails on a missing global git config.
+ * `readConfig` is injected (real: `git -C <root> config <key>`) so this stays
+ * pure and unit-testable.
+ */
+export function resolveSiteIdentity(readConfig) {
+    const name = (readConfig('user.name') || '').trim();
+    const email = (readConfig('user.email') || '').trim();
+    return {
+        name: name || 'Swarmdo',
+        email: email || 'maintainers@swarmdo.com',
+    };
+}
+/**
+ * `git commit` argv for the site sync — injects the identity via `-c` so the
+ * commit succeeds without a global git user, and keeps the bot co-author trailer.
+ */
+export function siteCommitArgs(version, id) {
+    return [
+        '-c', `user.name=${id.name}`,
+        '-c', `user.email=${id.email}`,
+        'commit', '-m', `release: sync site for v${version}\n\nCo-Authored-By: Swarmdo <maintainers@swarmdo.com>`,
+    ];
+}
 //# sourceMappingURL=release.js.map

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

@@ -30,6 +30,8 @@ interface NpmLockEntry {
     license?: unknown;
     dev?: boolean;
     optional?: boolean;
+    /** npm workspace symlink — a local monorepo package, not a registry dependency. */
+    link?: boolean;
 }
 interface NpmLock {
     name?: string;

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

@@ -58,6 +58,11 @@ export function componentsFromNpmLock(lock, opts = {}) {
             continue; // the root project entry
         if (!key.includes('node_modules/'))
             continue;
+        // Skip workspace symlinks (`link:true`, no version) — they're the project's
+        // own local packages, not third-party components; emitting them fabricates a
+        // phantom `@name@0.0.0` purl that pollutes vuln scanners / regulators.
+        if (entry.link)
+            continue;
         if (opts.productionOnly && entry.dev)
             continue;
         const name = nameFromKey(key);

package/v3/@swarmdo/cli/dist/src/swarmvector/semantic-router.js

@@ -31,8 +31,13 @@ export class SemanticRouter {
                 throw new Error(`Embedding must be Float32Array of length ${this.dimension}`);
             }
         }
-        // Normalize embeddings for cosine similarity
-        const normalizedEmbeddings = embeddings.map(emb => this.normalize(emb));
+        // Normalize ONLY for cosine (cosine = dot product of unit vectors). The
+        // dotProduct and euclidean metrics are magnitude-sensitive, so they must
+        // keep the raw vectors — normalizing them unconditionally silently turned
+        // both into cosine and could flip the ranking.
+        const normalizedEmbeddings = this.metric === 'cosine'
+            ? embeddings.map(emb => this.normalize(emb))
+            : embeddings.map(emb => Float32Array.from(emb));
         this.intents.set(name, {
             name,
             embeddings: normalizedEmbeddings,
@@ -47,7 +52,7 @@ export class SemanticRouter {
         if (!(embedding instanceof Float32Array) || embedding.length !== this.dimension) {
             throw new Error(`Embedding must be Float32Array of length ${this.dimension}`);
         }
-        const normalizedQuery = this.normalize(embedding);
+        const normalizedQuery = this.metric === 'cosine' ? this.normalize(embedding) : embedding;
         const scores = [];
         // Calculate best score for each intent
         for (const [intentName, intent] of this.intents) {

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

@@ -97,8 +97,15 @@ export function parseJUnit(xml) {
         const suite = attrs.classname ?? attrs.suite ?? '';
         if (attrs.time)
             durationMs += Math.round(parseFloat(attrs.time) * 1000) || 0;
-        const fail = body.match(/<(failure|error)\b([^>]*?)(?:\/>|>([\s\S]*?)<\/\1>)/);
-        const isSkipped = /<skipped\b[^>]*\/?>/.test(body);
+        // Strip captured stdout/stderr before scanning for failure/skip markers: their
+        // text (pytest/jest-junit/gotestsum embed logs, often in CDATA) can contain
+        // literal <failure…>/<error…>-looking content that must NOT be read as a real
+        // failure element on an otherwise-passing test.
+        const scanBody = body
+            .replace(/<system-(out|err)\b[^>]*>[\s\S]*?<\/system-\1>/g, '')
+            .replace(/<system-(out|err)\b[^>]*\/>/g, '');
+        const fail = scanBody.match(/<(failure|error)\b([^>]*?)(?:\/>|>([\s\S]*?)<\/\1>)/);
+        const isSkipped = /<skipped\b[^>]*\/?>/.test(scanBody);
         if (fail) {
             failed++;
             const fAttrs = parseAttrs(fail[2]);

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

@@ -141,6 +141,7 @@ export function summarizeFile(fs_stat) {
     let firstPrompt = '';
     try {
         const content = fs.readFileSync(fs_stat.file, 'utf8');
+        const lines = [];
         for (const raw of content.split('\n')) {
             if (!raw.trim())
                 continue;
@@ -151,17 +152,20 @@ export function summarizeFile(fs_stat) {
             catch {
                 continue;
             }
+            lines.push(line);
             if (line.type && !RENDERABLE.has(line.type))
                 continue;
-            const role = line.message?.role;
-            if (role === 'user' || role === 'assistant')
-                turns++;
-            if (!firstPrompt && role === 'user') {
+            if (!firstPrompt && line.message?.role === 'user') {
                 const txt = cleanUserText(contentToText(line.message?.content) || (typeof line.message?.content === 'string' ? line.message.content : ''));
                 if (txt)
                     firstPrompt = txt.replace(/\s+/g, ' ').slice(0, 100);
             }
         }
+        // Count turns EXACTLY as exportSession does — render, then count role
+        // headings — so `transcript list` and `transcript export` can never disagree
+        // (#70). A pure tool-result carrier line renders no heading, so it's not a
+        // turn; the old raw per-line count inflated `list` for any session with tools.
+        turns = countRenderedTurns(renderTranscriptMarkdown(lines));
     }
     catch { /* unreadable */ }
     return { sessionId: sessionIdFromFile(fs_stat.file), file: fs_stat.file, project: fs_stat.project, turns, firstPrompt, mtimeMs: fs_stat.mtimeMs, sizeBytes: fs_stat.sizeBytes };

package/v3/@swarmdo/cli/dist/src/update/checker.d.ts

@@ -23,6 +23,7 @@ export interface UpdateConfig {
     exclude: string[];
 }
 declare const DEFAULT_CONFIG: UpdateConfig;
+export declare function getUpdateType(current: string, latest: string): 'major' | 'minor' | 'patch' | 'none';
 export declare function getInstalledVersion(packageName: string): string | null;
 export declare function checkForUpdates(config?: UpdateConfig): Promise<{
     results: UpdateCheckResult[];

package/v3/@swarmdo/cli/dist/src/update/checker.js

@@ -45,11 +45,16 @@ async function fetchPackageInfo(packageName) {
         return null;
     }
 }
-function getUpdateType(current, latest) {
+export function getUpdateType(current, latest) {
     if (!semver.valid(current) || !semver.valid(latest)) {
         return 'none';
     }
-    if (semver.eq(current, latest)) {
+    // Only a strictly-NEWER latest is an update. Without this guard the
+    // per-field comparisons below misclassify a same-or-OLDER latest: e.g.
+    // current 1.30.2 vs latest 1.29.5 has patch 5 > 2, so it would report
+    // 'patch' and auto-update could DOWNGRADE. `gt` also subsumes the equality
+    // case (eq → not gt → 'none'). (#79)
+    if (!semver.gt(latest, current)) {
         return 'none';
     }
     if (semver.major(latest) > semver.major(current)) {

package/v3/@swarmdo/cli/dist/src/usage/model-efficiency.d.ts

@@ -0,0 +1,29 @@
+/**
+ * model-efficiency.ts — rank models by their EFFECTIVE cost per unit of useful
+ * output in your actual usage.
+ *
+ * A model's list output price is fixed, but what you really pay per output token
+ * also carries the input + cache cost of every request amortized over the output
+ * it produced. A model driven with huge contexts can effectively cost far more
+ * per output token than its sticker price — this surfaces that, per model, from
+ * the same aggregation the `usage models` view already computes.
+ *
+ * Pure: it folds already-summed per-model totals, no transcripts, no clock.
+ */
+import type { UsageTotals } from './transcript-usage.js';
+export interface ModelEfficiency {
+    model: string;
+    costUsd: number;
+    outputTokens: number;
+    /** effective $ per 1,000,000 output tokens (cost / output × 1e6) */
+    costPerMOutput: number;
+}
+/**
+ * Effective cost per 1M output tokens per model, cheapest first. Models with no
+ * cost or no output are dropped (no meaningful ratio). Pure.
+ */
+export declare function computeModelEfficiency(models: Array<{
+    key: string;
+    totals: UsageTotals;
+}>): ModelEfficiency[];
+//# sourceMappingURL=model-efficiency.d.ts.map

package/v3/@swarmdo/cli/dist/src/usage/model-efficiency.js

@@ -0,0 +1,28 @@
+/**
+ * model-efficiency.ts — rank models by their EFFECTIVE cost per unit of useful
+ * output in your actual usage.
+ *
+ * A model's list output price is fixed, but what you really pay per output token
+ * also carries the input + cache cost of every request amortized over the output
+ * it produced. A model driven with huge contexts can effectively cost far more
+ * per output token than its sticker price — this surfaces that, per model, from
+ * the same aggregation the `usage models` view already computes.
+ *
+ * Pure: it folds already-summed per-model totals, no transcripts, no clock.
+ */
+/**
+ * Effective cost per 1M output tokens per model, cheapest first. Models with no
+ * cost or no output are dropped (no meaningful ratio). Pure.
+ */
+export function computeModelEfficiency(models) {
+    return models
+        .filter((m) => m.totals.costUsd > 0 && m.totals.outputTokens > 0)
+        .map((m) => ({
+        model: m.key,
+        costUsd: m.totals.costUsd,
+        outputTokens: m.totals.outputTokens,
+        costPerMOutput: (m.totals.costUsd / m.totals.outputTokens) * 1_000_000,
+    }))
+        .sort((a, b) => a.costPerMOutput - b.costPerMOutput || (a.model < b.model ? -1 : 1));
+}
+//# sourceMappingURL=model-efficiency.js.map

package/v3/@swarmdo/cli/dist/src/usage/reflect-html.js

@@ -81,6 +81,7 @@ ${stat('Avg / active day', usd(r.avgCostPerActiveDay))}
 ${stat('Longest streak', `${r.longestStreak} day${r.longestStreak === 1 ? '' : 's'}`)}
 ${stat('Peak hour', peak)}
 ${stat('Cache read', pct(r.cacheReadPct))}
+${r.cacheSavingsUsd > 0 ? stat('Cache saved', usd(r.cacheSavingsUsd)) : ''}
 ${stat('Busiest day', busiest)}
 ${stat('Trend', `${arrow} ${pct(r.trend.firstHalfCost > 0 ? (r.trend.secondHalfCost - r.trend.firstHalfCost) / r.trend.firstHalfCost : 0)}`)}
 ${opts.delegation && opts.delegation.toolCalls > 0 ? stat('Delegation', pct(opts.delegation.ratio)) : ''}