continuous-improvement 3.9.2 → 3.11.0

package/bin/check-scripts-citation-drift.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Scripts-Citation-Drift Invariant Check
+ *
+ * Locks the inventory-citation contract stated in scripts/README.md:
+ *
+ *   "When a new script lands here, add a row to this table in the same PR
+ *    and cite the script from at least one skill — otherwise the script is
+ *    dead code on arrival."
+ *
+ * Three sides of the contract are enforced as one invariant:
+ *
+ *   Side A — every file in scripts/ (excluding README.md) must appear in the
+ *            Inventory table's Script column.
+ *   Side B — for every Inventory row, every `skills/<name>.md` token in the
+ *            Cited by cell must reference a file whose body contains the
+ *            literal substring `scripts/<script-filename>` for at least one
+ *            of the row's scripts.
+ *   Side C — every skills/*.md that mentions `scripts/<filename>` for an
+ *            inventoried script must appear in that script's row's Cited by
+ *            cell.
+ *
+ * Origin: ongoing composability refactor (PRs #144–#148, #149) extracts
+ * shared primitives into scripts/. Without enforcement, the inventory and
+ * citations drift the first time a script lands without README + skill
+ * plumbing. The lint locks the contract in CI on every PR.
+ *
+ * Usage:
+ *   node bin/check-scripts-citation-drift.mjs              # Check the current repo
+ *   node bin/check-scripts-citation-drift.mjs <repo-root>  # Check a specific repo root
+ *
+ * Exit codes:
+ *   0 — all three sides reconciled
+ *   1 — at least one drift on at least one side
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, posix, sep } from "node:path";
+import { argv, cwd, exit } from "node:process";
+const SCRIPTS_DIR = "scripts";
+const SCRIPTS_README = "scripts/README.md";
+const SKILLS_DIR = "skills";
+const TABLE_HEADER_LINE = "| Script | Purpose | Cited by |";
+export function parseInventoryTable(readmeContent) {
+    const lines = readmeContent.split(/\r?\n/);
+    const headerIdx = lines.findIndex((l) => l.trim() === TABLE_HEADER_LINE);
+    if (headerIdx === -1)
+        return [];
+    const rows = [];
+    for (let i = headerIdx + 2; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|"))
+            break;
+        if (trimmed === "")
+            break;
+        const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+        if (cells.length < 3)
+            continue;
+        const scriptCell = cells[0] ?? "";
+        const citedByCell = cells[2] ?? "";
+        const scripts = [...scriptCell.matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? "");
+        const skills = [...citedByCell.matchAll(/`(skills\/[^`]+)`/g)].map((m) => m[1] ?? "");
+        rows.push({ scripts, skills, raw: trimmed });
+    }
+    return rows;
+}
+function listScriptFiles(repoRoot) {
+    const dir = join(repoRoot, SCRIPTS_DIR);
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return [];
+    return readdirSync(dir)
+        .filter((entry) => {
+        if (entry === "README.md")
+            return false;
+        try {
+            return statSync(join(dir, entry)).isFile();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+}
+function listSkillFiles(repoRoot) {
+    const dir = join(repoRoot, SKILLS_DIR);
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return [];
+    return readdirSync(dir)
+        .filter((entry) => entry.endsWith(".md"))
+        .map((entry) => `${SKILLS_DIR}/${entry}`)
+        .sort();
+}
+function toPosix(relPath) {
+    return relPath.split(sep).join(posix.sep);
+}
+export function checkRepo(repoRoot) {
+    const sideA = [];
+    const sideB = [];
+    const sideC = [];
+    const scriptFiles = listScriptFiles(repoRoot);
+    const readmePath = join(repoRoot, SCRIPTS_README);
+    const readmeContent = existsSync(readmePath) ? readFileSync(readmePath, "utf8") : "";
+    const rows = parseInventoryTable(readmeContent);
+    const inventoryScripts = new Set();
+    for (const row of rows) {
+        for (const s of row.scripts)
+            inventoryScripts.add(s);
+    }
+    for (const file of scriptFiles) {
+        if (!inventoryScripts.has(file)) {
+            sideA.push(file);
+        }
+    }
+    let citationCount = 0;
+    const rowsByScript = new Map();
+    for (const row of rows) {
+        for (const s of row.scripts) {
+            if (!rowsByScript.has(s))
+                rowsByScript.set(s, row);
+        }
+    }
+    for (const row of rows) {
+        for (const skillPath of row.skills) {
+            citationCount += 1;
+            const fullSkill = join(repoRoot, skillPath);
+            let skillBody = "";
+            try {
+                skillBody = readFileSync(fullSkill, "utf8");
+            }
+            catch {
+                sideB.push(`${skillPath} — file does not exist (referenced by row "${row.scripts.join(", ")}")`);
+                continue;
+            }
+            const anyCited = row.scripts.some((script) => skillBody.includes(`scripts/${script}`));
+            if (!anyCited) {
+                const claimedScripts = row.scripts.map((s) => `scripts/${s}`).join(" or ");
+                sideB.push(`${skillPath} does not contain "${claimedScripts}" (claimed by row "${row.scripts.join(" + ")}")`);
+            }
+        }
+    }
+    const skillFiles = listSkillFiles(repoRoot);
+    for (const skillPath of skillFiles) {
+        let body = "";
+        try {
+            body = readFileSync(join(repoRoot, skillPath), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const inventoryScript of inventoryScripts) {
+            const needle = `scripts/${inventoryScript}`;
+            if (!body.includes(needle))
+                continue;
+            const row = rowsByScript.get(inventoryScript);
+            if (!row)
+                continue;
+            if (!row.skills.includes(skillPath)) {
+                sideC.push(`${skillPath} cites "${needle}" but is not listed in that script's Cited by cell`);
+            }
+        }
+    }
+    return {
+        sideA,
+        sideB,
+        sideC,
+        scriptCount: scriptFiles.length,
+        citationCount,
+    };
+}
+function main() {
+    const repoRoot = argv[2] ?? cwd();
+    const result = checkRepo(repoRoot);
+    const totalViolations = result.sideA.length + result.sideB.length + result.sideC.length;
+    if (totalViolations === 0) {
+        console.log(`OK scripts-citation-drift: ${result.scriptCount} script(s), ${result.citationCount} skill citation(s), all three sides reconciled.`);
+        exit(0);
+    }
+    console.error(`FAIL scripts-citation-drift: ${totalViolations} drift(s) across the inventory-citation contract.`);
+    if (result.sideA.length > 0) {
+        console.error("");
+        console.error("Side A — script files missing from scripts/README.md inventory table:");
+        for (const v of result.sideA) {
+            console.error(`  ${toPosix(v)}`);
+        }
+    }
+    if (result.sideB.length > 0) {
+        console.error("");
+        console.error("Side B — inventory rows claim a citation the skill body does not contain:");
+        for (const v of result.sideB) {
+            console.error(`  ${toPosix(v)}`);
+        }
+    }
+    if (result.sideC.length > 0) {
+        console.error("");
+        console.error("Side C — skill cites a real inventoried script but is not listed in that script's Cited by cell:");
+        for (const v of result.sideC) {
+            console.error(`  ${toPosix(v)}`);
+        }
+    }
+    console.error("");
+    console.error("Fix: update scripts/README.md inventory (Side A/C) or correct the skill citation (Side B).");
+    exit(1);
+}
+const scriptPathFromArgv = argv[1];
+const isMainModule = scriptPathFromArgv !== undefined &&
+    (import.meta.url.endsWith(scriptPathFromArgv.replace(/\\/g, "/")) ||
+        scriptPathFromArgv.endsWith("check-scripts-citation-drift.mjs"));
+if (isMainModule) {
+    main();
+}

package/bin/check-skill-count.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Skill Count Check
+ *
+ * The plugin's user-facing description strings claim a bundled-skill count
+ * ("N bundled skills"). That number is hand-maintained inside
+ * src/lib/plugin-metadata.mts (SHARED_PLUGIN_DESCRIPTION) and package.json,
+ * and it drifts every time a skill is added without the count being bumped.
+ *
+ * Origin: the plugin-flow stress-test (2026-05-14) found marketplace.json and
+ * plugin.json both claiming "13 enforcement skills" while the bundle shipped
+ * 20. This lint locks the claim to the actual source-of-truth count so the
+ * marketplace card can never undersell (or oversell) the bundle again.
+ *
+ * Source of truth: skill directories under `plugins/continuous-improvement/skills/`
+ * (one `<name>/SKILL.md` per skill). This is the literal bundled-skill set —
+ * `npm run build` mirrors each `skills/<name>.md` standalone source (plus the
+ * core skill, whose standalone source is the repo-root `SKILL.md`) into it, and
+ * `verify:skill-mirror` already guarantees parity. Counting the bundle is the
+ * honest reading of the phrase "N bundled skills".
+ *
+ * Checked files (each must contain the literal `<count> bundled skills`):
+ *   - .claude-plugin/marketplace.json
+ *   - plugins/continuous-improvement/.claude-plugin/plugin.json
+ *   - package.json
+ *   - llms.txt
+ *
+ * Usage:
+ *   node bin/check-skill-count.mjs              # Check the current repo
+ *   node bin/check-skill-count.mjs <repo-root>  # Check a specific repo root
+ *
+ * Exit codes:
+ *   0 — every checked file states the correct bundled-skill count
+ *   1 — at least one file states a stale or missing count
+ */
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { argv, cwd, exit } from "node:process";
+const BUNDLE_SKILLS_DIR = "plugins/continuous-improvement/skills";
+const CHECKED_FILES = [
+    ".claude-plugin/marketplace.json",
+    "plugins/continuous-improvement/.claude-plugin/plugin.json",
+    "package.json",
+    "llms.txt",
+];
+export function countSkills(repoRoot) {
+    const skillsDir = join(repoRoot, BUNDLE_SKILLS_DIR);
+    const entries = readdirSync(skillsDir);
+    return entries.filter((entry) => {
+        try {
+            return statSync(join(skillsDir, entry)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).length;
+}
+function checkFile(repoRoot, relPath, expected) {
+    let content;
+    try {
+        content = readFileSync(join(repoRoot, relPath), "utf8");
+    }
+    catch {
+        return { file: relPath, reason: "missing" };
+    }
+    // Non-digit boundary before the count so "3 bundled skills" does not match
+    // inside "13 bundled skills".
+    const expectedPattern = new RegExp(`(?<!\\d)${expected} bundled skills`);
+    if (expectedPattern.test(content))
+        return null;
+    const staleMatch = content.match(/(\d+) bundled skills/);
+    return {
+        file: relPath,
+        reason: staleMatch ? "stale" : "missing",
+        found: staleMatch ? staleMatch[0] : undefined,
+    };
+}
+function main() {
+    const repoRoot = argv[2] ?? cwd();
+    const expected = countSkills(repoRoot);
+    const violations = [];
+    for (const file of CHECKED_FILES) {
+        const v = checkFile(repoRoot, file, expected);
+        if (v)
+            violations.push(v);
+    }
+    if (violations.length === 0) {
+        console.log(`OK skill-count: all ${CHECKED_FILES.length} description string(s) state "${expected} bundled skills" (matches skills/ source-of-truth).`);
+        exit(0);
+    }
+    console.error(`FAIL skill-count: ${violations.length} description string(s) do not state the actual bundled-skill count of ${expected}.`);
+    console.error(`Source of truth is ${expected} kebab-case *.md file(s) under skills/. Each checked file must contain the literal "${expected} bundled skills".`);
+    console.error("");
+    for (const v of violations) {
+        if (v.reason === "stale") {
+            console.error(`  ${v.file} — states "${v.found}", expected "${expected} bundled skills"`);
+        }
+        else {
+            console.error(`  ${v.file} — no "<count> bundled skills" phrase found`);
+        }
+    }
+    console.error("");
+    console.error("Fix: update SHARED_PLUGIN_DESCRIPTION in src/lib/plugin-metadata.mts and the");
+    console.error("package.json description, then re-run `npm run build` to regenerate manifests.");
+    exit(1);
+}
+const invokedDirectly = argv[1] !== undefined && import.meta.url.endsWith(argv[1].replace(/\\/g, "/"));
+if (invokedDirectly || argv[1]?.endsWith("check-skill-count.mjs")) {
+    main();
+}

package/bin/check-test-imports-only.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Test-Imports-Only Invariant Check
+ *
+ * Enforces the test-isolation discipline that emerged from the composability
+ * refactor train (PRs #144–#148): every test file's non-`node:*` import must
+ * resolve to exactly one of `../bin/<x>.mjs` or `../lib/<x>.mjs`.
+ *
+ * Catches:
+ *   - cross-test coupling (one test importing another test or shared helper)
+ *   - bare npm specifiers leaking into the test surface
+ *   - reach-through into `hooks/`, `scripts/`, `src/`, or deeper paths under
+ *     `bin/` or `lib/`
+ *
+ * Baseline: all 50 `src/test/*.test.mts` files pass today.
+ *
+ * Usage:
+ *   node bin/check-test-imports-only.mjs              # Check the current repo
+ *   node bin/check-test-imports-only.mjs <repo-root>  # Check a specific repo root
+ *
+ * Exit codes:
+ *   0 — every scanned test file imports only from node:* or ../bin/*.mjs or ../lib/*.mjs
+ *   1 — at least one scanned test file imports something outside the allow-list
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, posix, sep } from "node:path";
+import { argv, cwd, exit } from "node:process";
+const TEST_SOURCE_DIR = "src/test";
+const ORPHAN_TESTS = [];
+const ALLOWED_PRODUCTION_PATH = /^\.\.\/(bin|lib)\/[A-Za-z0-9._-]+\.mjs$/;
+export function isAllowedSpecifier(specifier) {
+    if (specifier.startsWith("node:"))
+        return true;
+    if (ALLOWED_PRODUCTION_PATH.test(specifier))
+        return true;
+    return false;
+}
+export function extractImports(content) {
+    const lines = content.split(/\r?\n/);
+    const fromClause = /\bfrom\s+["']([^"']+)["']/;
+    const importStart = /^\s*import\b/;
+    const out = [];
+    let inImport = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (!inImport) {
+            if (!importStart.test(line))
+                continue;
+            const m = fromClause.exec(line);
+            if (m && m[1] !== undefined) {
+                out.push({ line: i + 1, specifier: m[1] });
+                // single-line import resolved; stay in 'searching'
+            }
+            else {
+                inImport = true;
+            }
+        }
+        else {
+            const m = fromClause.exec(line);
+            if (m && m[1] !== undefined) {
+                out.push({ line: i + 1, specifier: m[1] });
+                inImport = false;
+            }
+        }
+    }
+    return out;
+}
+function discoverTestFiles(repoRoot) {
+    const found = [];
+    const dir = join(repoRoot, TEST_SOURCE_DIR);
+    if (existsSync(dir) && statSync(dir).isDirectory()) {
+        for (const entry of readdirSync(dir)) {
+            if (entry.endsWith(".test.mts")) {
+                found.push(join(TEST_SOURCE_DIR, entry));
+            }
+        }
+    }
+    for (const orphan of ORPHAN_TESTS) {
+        if (existsSync(join(repoRoot, orphan))) {
+            found.push(orphan);
+        }
+    }
+    return found.sort();
+}
+function toPosix(relPath) {
+    return relPath.split(sep).join(posix.sep);
+}
+function main() {
+    const repoRoot = argv[2] ?? cwd();
+    const files = discoverTestFiles(repoRoot);
+    const violations = [];
+    let productionImports = 0;
+    for (const relPath of files) {
+        const content = readFileSync(join(repoRoot, relPath), "utf8");
+        const imports = extractImports(content);
+        for (const { line, specifier } of imports) {
+            if (!isAllowedSpecifier(specifier)) {
+                violations.push({ file: toPosix(relPath), line, specifier });
+            }
+            else if (!specifier.startsWith("node:")) {
+                productionImports += 1;
+            }
+        }
+    }
+    if (violations.length === 0) {
+        console.log(`OK test-imports-only: ${files.length} test file(s), ${productionImports} production import(s), all within node:* or ../bin/*.mjs or ../lib/*.mjs.`);
+        exit(0);
+    }
+    console.error(`FAIL test-imports-only: ${violations.length} non-node import(s) outside the allow-list.`);
+    console.error("");
+    for (const v of violations) {
+        console.error(`  ${v.file}:${v.line} — imports "${v.specifier}"`);
+    }
+    console.error("");
+    console.error("Allow-list: node:* builtins, ../bin/<name>.mjs, ../lib/<name>.mjs.");
+    console.error("Fix: replace the offending import with a node:* equivalent, an allowed");
+    console.error("production import, or a `spawnSync` of the compiled `.mjs`.");
+    exit(1);
+}
+const scriptPathFromArgv = argv[1];
+const isMainModule = scriptPathFromArgv !== undefined &&
+    (import.meta.url.endsWith(scriptPathFromArgv.replace(/\\/g, "/")) ||
+        scriptPathFromArgv.endsWith("check-test-imports-only.mjs"));
+if (isMainModule) {
+    main();
+}

package/bin/companion-preference-status.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * /companion-preference status — read & aggregate hook telemetry.
+ *
+ * Reads ~/.claude/instincts/<project-hash>/companion-preference.jsonl
+ * (or an explicit path via --path), groups events by ci_skill within the
+ * configured window (default 7 days), and prints a summary report with
+ * per-skill totals, action breakdown, and companion_installed%.
+ *
+ * Usage:
+ *   node bin/companion-preference-status.mjs              # last 7 days, human
+ *   node bin/companion-preference-status.mjs --days 30    # 30-day window
+ *   node bin/companion-preference-status.mjs --all        # whole file, no window
+ *   node bin/companion-preference-status.mjs --json       # machine-readable JSON
+ *   node bin/companion-preference-status.mjs --path <p>   # override JSONL path
+ *
+ * Exit codes:
+ *   0 — report rendered (including the "no telemetry recorded yet" case)
+ *   1 — argument parse error or unexpected runtime failure
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { argv, exit, stdout } from "node:process";
+const ACTIONS = [
+    "observation",
+    "advisory",
+    "block",
+    "block-not-installed",
+];
+function parseArgs(args) {
+    const out = { days: 7, all: false, json: false, path: null };
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--days") {
+            const v = Number(args[++i]);
+            if (!Number.isFinite(v) || v <= 0) {
+                process.stderr.write(`--days requires a positive integer (got ${args[i]})\n`);
+                exit(1);
+            }
+            out.days = v;
+        }
+        else if (a === "--all") {
+            out.all = true;
+            out.days = null;
+        }
+        else if (a === "--json") {
+            out.json = true;
+        }
+        else if (a === "--path") {
+            out.path = args[++i] ?? null;
+            if (!out.path) {
+                process.stderr.write(`--path requires a value\n`);
+                exit(1);
+            }
+        }
+        else if (a === "--help" || a === "-h") {
+            printHelp();
+            exit(0);
+        }
+        else if (a !== undefined) {
+            process.stderr.write(`unknown argument: ${a}\n`);
+            exit(1);
+        }
+    }
+    return out;
+}
+function printHelp() {
+    stdout.write([
+        "Usage: companion-preference-status [options]",
+        "",
+        "Options:",
+        "  --days N       Only count events from the last N days (default 7)",
+        "  --all          Ignore the window; count every row in the file",
+        "  --json         Emit a machine-readable JSON report",
+        "  --path <file>  Override the default JSONL path (testing)",
+        "  -h, --help     Print this help",
+        "",
+    ].join("\n"));
+}
+function resolveProjectRoot() {
+    const fromEnv = process.env.CLAUDE_PROJECT_DIR;
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (root)
+            return root;
+    }
+    catch {
+        // not in a git repo
+    }
+    return "global";
+}
+function defaultJsonlPath() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+    const hash = createHash("sha256")
+        .update(resolveProjectRoot())
+        .digest("hex")
+        .slice(0, 12);
+    return join(home, ".claude", "instincts", hash, "companion-preference.jsonl");
+}
+function parseJsonl(raw) {
+    const rows = [];
+    let parseErrors = 0;
+    for (const line of raw.split(/\r?\n/)) {
+        if (line.trim().length === 0)
+            continue;
+        try {
+            rows.push(JSON.parse(line));
+        }
+        catch {
+            parseErrors += 1;
+        }
+    }
+    return { rows, parseErrors };
+}
+function aggregate(rows) {
+    const bySkill = {};
+    const byMode = {};
+    const installedYes = {};
+    for (const row of rows) {
+        const stats = (bySkill[row.ci_skill] ??= {
+            total: 0,
+            actions: {},
+            installed_pct: null,
+        });
+        stats.total += 1;
+        stats.actions[row.action] = (stats.actions[row.action] ?? 0) + 1;
+        if (row.companion_installed) {
+            installedYes[row.ci_skill] = (installedYes[row.ci_skill] ?? 0) + 1;
+        }
+        byMode[row.mode] = (byMode[row.mode] ?? 0) + 1;
+    }
+    for (const [skill, stats] of Object.entries(bySkill)) {
+        stats.installed_pct =
+            stats.total > 0
+                ? Math.round(((installedYes[skill] ?? 0) * 100) / stats.total)
+                : null;
+    }
+    return { bySkill, byMode };
+}
+function pad(s, width) {
+    return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function rpad(n, width) {
+    const s = String(n);
+    return s.length >= width ? s : " ".repeat(width - s.length) + s;
+}
+function formatHuman(report) {
+    const lines = [];
+    const windowLabel = report.window_days === null ? "all-time" : `last ${report.window_days} days`;
+    lines.push(`Companion-preference telemetry — ${windowLabel}`);
+    lines.push(`File:   ${report.file}`);
+    if (report.since)
+        lines.push(`Window: ${report.since} to ${new Date().toISOString()}`);
+    lines.push("");
+    if (report.total_events === 0) {
+        lines.push("No events in window.");
+    }
+    else {
+        const skillWidth = Math.max(8, ...Object.keys(report.by_skill).map((k) => k.length));
+        const header = pad("ci_skill", skillWidth) +
+            "  " +
+            ["total", "observation", "advisory", "block", "block-not-installed", "installed%"]
+                .map((h) => rpad(h, h.length))
+                .join("  ");
+        lines.push(header);
+        for (const [skill, stats] of Object.entries(report.by_skill).sort((a, b) => b[1].total - a[1].total)) {
+            const cells = [
+                rpad(stats.total, "total".length),
+                rpad(stats.actions.observation ?? 0, "observation".length),
+                rpad(stats.actions.advisory ?? 0, "advisory".length),
+                rpad(stats.actions.block ?? 0, "block".length),
+                rpad(stats.actions["block-not-installed"] ?? 0, "block-not-installed".length),
+                rpad(stats.installed_pct === null ? "—" : `${stats.installed_pct}`, "installed%".length),
+            ].join("  ");
+            lines.push(pad(skill, skillWidth) + "  " + cells);
+        }
+    }
+    lines.push("");
+    const modeEntries = Object.entries(report.by_mode);
+    if (modeEntries.length > 0) {
+        lines.push(`Mode totals: ${modeEntries.map(([k, v]) => `${k} ${v}`).join(", ")}`);
+    }
+    lines.push(`Total events: ${report.total_events}`);
+    if (report.parse_errors > 0)
+        lines.push(`Parse errors (skipped): ${report.parse_errors}`);
+    return lines.join("\n") + "\n";
+}
+function main() {
+    const args = parseArgs(argv.slice(2));
+    const filePath = args.path ?? defaultJsonlPath();
+    if (!existsSync(filePath)) {
+        stdout.write(`Companion-preference telemetry: no telemetry recorded yet at ${filePath}\n`);
+        exit(0);
+    }
+    const raw = readFileSync(filePath, "utf8");
+    const { rows, parseErrors } = parseJsonl(raw);
+    const cutoff = args.all || args.days === null
+        ? null
+        : new Date(Date.now() - args.days * 24 * 3600 * 1000).toISOString();
+    const filtered = cutoff === null ? rows : rows.filter((r) => r.ts >= cutoff);
+    const { bySkill, byMode } = aggregate(filtered);
+    const report = {
+        file: filePath,
+        window_days: args.all ? null : args.days,
+        since: cutoff,
+        total_events: filtered.length,
+        parse_errors: parseErrors,
+        by_skill: bySkill,
+        by_mode: byMode,
+    };
+    if (args.json) {
+        stdout.write(JSON.stringify(report, null, 2) + "\n");
+    }
+    else {
+        stdout.write(formatHuman(report));
+    }
+    exit(0);
+}
+const invokedDirectly = argv[1]?.endsWith("companion-preference-status.mjs");
+if (invokedDirectly) {
+    main();
+}
+export { ACTIONS, aggregate, parseArgs, parseJsonl, };