roster-cli 0.1.3 → 0.3.0

package/README.md

@@ -25,21 +25,73 @@ npx roster-cli audit <dir>
 
 ## Usage
 
+roster is one binary with three commands: `audit`, `doccheck`, and `usage`.
+
 ```sh
 roster audit <dir>
 roster audit <dir> --user
 roster audit <dir> --repo owner/name
 roster audit <dir> --html report.html
+roster audit --plugin --enabled-only
+roster doccheck README.md
+roster usage --days 14 --user
 ```
 
-Full flag surface:
+Full flag surface for `audit`:
 
 ```
 roster audit <dir> [--json] [--html <out>] [--user] [--plugin [name]]
-                    [--repo <owner/name[@ref]>] [--top <n>]
+                    [--enabled-only] [--repo <owner/name[@ref]>] [--top <n>]
                     [--fail-above <s>] [--no-fail]
 ```
 
+`--enabled-only` (with `--plugin`) restricts the plugin-cache source to entries
+active for the current project.[^enabled-only]
+
+[^enabled-only]: Activation is judged purely by installation **scope**
+    (user-scope entries are always active; local/project-scope entries are
+    active only when the cwd is inside the pinning project). It does not read
+    per-project enable/disable state from `settings.json`.
+
+## doccheck
+
+```sh
+roster doccheck README.md
+roster doccheck docs/
+roster doccheck            # defaults to README.md + docs/**/*.md
+```
+
+Scans fenced `sh`/`bash`/`shell` code blocks in markdown docs for commands
+that would fail if a reader copy-pasted them: dead relative paths, missing
+`npm run <script>` scripts, and scripts that exist on disk but lack the
+executable bit.
+
+To keep false positives at zero, it skips anything it can't verify cheaply:
+absolute paths (`/plugin ...`), `npx ...` invocations, and bare global
+binaries (`node`, `git`, ...) with no path separator.
+
+Exits `1` if any finding is reported, `0` otherwise (`--json` for machine-
+readable output).
+
+## usage
+
+```sh
+roster usage
+roster usage --days 14
+roster usage --user
+roster usage --plugin --json
+```
+
+Aggregates how often each `subagent_type` was invoked (via the Agent/Task
+tool) across Claude Code transcript files under `~/.claude` (override with
+`ROSTER_CLAUDE_DIR`), within the last `--days` (default `30`).
+
+Joining with `--user` and/or `--plugin` also reports:
+- **unused** — agents present in the roster with zero observed invocations
+- **ghosts** — invoked `subagent_type` values that don't match any roster agent
+
+Always exits `0` — this is a reporting tool, not a gate.
+
 ## Rules
 
 | Rule | Description | Status |
@@ -55,11 +107,21 @@ roster audit <dir> [--json] [--html <out>] [--user] [--plugin [name]]
 `roster audit --repo` run against well-known public agent rosters (SHA-pinned,
 reproducible via `scripts/bench.sh`). Full reports: `docs/benchmarks/`.
 
-| roster | agents | top overlap pair (score) | no-tools % | fixed cost (est. tokens/turn) |
+A weekly cron re-runs the benchmark suite against each roster's latest
+upstream HEAD and opens a refresh PR with any changes.[^leaderboard-cron]
+
+<!-- bench:start -->
+| Repo | Agents | Top overlap pair | No-tools % | Fixed cost |
 | --- | --- | --- | --- | --- |
-| [msitarzewski/agency-agents](./docs/benchmarks/msitarzewski--agency-agents.md) | 277 | Backend Architect ↔ Backend Architect (0.878) | 93.9% | ~14024 |
-| [wshobson/agents](./docs/benchmarks/wshobson--agents.md) | 691 | api-scaffolding-backend-architect ↔ backend-api-security-backend-architect (1.000) | 97.8% | ~24853 |
-| [contains-studio/agents](./docs/benchmarks/contains-studio--agents.md) | 37 | content-creator ↔ instagram-curator (0.565) | 16.2% | ~8421 |
+| [contains-studio/agents](https://github.com/contains-studio/agents) | 37 | content-creator <-> instagram-curator (0.565) | 16.2% | ~8421 tokens/turn |
+| [msitarzewski/agency-agents](https://github.com/msitarzewski/agency-agents) | 277 | Backend Architect <-> Backend Architect (0.878) | 93.9% | ~14024 tokens/turn |
+| [wshobson/agents](https://github.com/wshobson/agents) | 691 | api-scaffolding-backend-architect <-> backend-api-security-backend-architect (1.000) | 97.8% | ~24853 tokens/turn |
+<!-- bench:end -->
+
+[^leaderboard-cron]: Runs every Monday via `.github/workflows/leaderboard.yml`.
+    GitHub automatically disables scheduled workflows after 60 days of repo
+    inactivity — re-enable with a manual `workflow_dispatch` run if that
+    happens.
 
 Several top pairs score at or near 1.000 similarity (e.g. wshobson/agents has
 five pairs at a perfect 1.000) — these are near-duplicate agent files (same
@@ -82,12 +144,21 @@ Once installed:
 - **`roster-audit` skill** — triggers when you ask to audit an agent roster
   (overlap, missing harness/tools, routing ambiguity, cost); runs the bundled
   CLI and explains how to read the findings.
-- **`roster-drift.sh` hook** (`SessionStart`) — on each session, diffs
-  `.claude/agents/` against a cached snapshot and emits a short advisory if
-  agents were added/removed/changed (`ROSTER_DRIFT_DISABLE=1` to opt out).
-  The advisory goes to both Claude's session context (so it can offer an
-  audit proactively) and stderr (so you see it in the terminal). Advisory
-  only — never blocks a session.
+- **`roster-cleanup` skill** — triggers when you ask to clean up, prune, or
+  merge agents. Audits, classifies findings into concrete actions (delete /
+  move / merge / rename / uninstall / narrow tools), asks you to approve each
+  destructive step, executes only what you approved, then re-audits and
+  reports the delta.
+- **`roster-drift.sh` hook** (`SessionStart`) — on each session, diffs the
+  watched agent-md dir(s) against a cached snapshot and emits a short
+  advisory if agents were added/removed/changed
+  (`ROSTER_DRIFT_DISABLE=1` to opt out). By default it watches
+  `.claude/agents` plus, in a plugin-layout repo (one with a top-level
+  `.claude-plugin/plugin.json`), the root `agents/` dir; override with
+  `ROSTER_DRIFT_DIR` (colon-separated dir list). The advisory goes to both
+  Claude's session context (so it can offer an audit proactively) and
+  stderr (so you see it in the terminal). Advisory only — never blocks a
+  session.
 
 ## Contributing
 

package/dist/cli.js

@@ -3,13 +3,21 @@ import { writeFileSync } from 'node:fs';
 import { sources } from './sources/index.js';
 import { rules } from './rules/index.js';
 import { renderers } from './render/index.js';
-const HELP_TEXT = `Usage: roster audit [<dir>] [options]
+import { run as runDoccheck } from './doccheck.js';
+import { run as runUsage } from './usage.js';
+const HELP_TEXT = `Usage: roster <command> [<dir>] [options]
+
+Commands:
+  audit                       Audit a roster for overlaps and issues
+  doccheck                    Check docs for drift (not yet implemented)
+  usage                       Report agent usage stats (not yet implemented)
 
 Options:
   --json                      Output machine-readable JSON
   --html <out>                Write an HTML report to <out>
   --user                      Load agents from the user-level agent directory
   --plugin [name]             Load agents from the plugin cache
+  --enabled-only              With --plugin, only include entries active for the current project
   --repo <owner/name[@ref]>   Load agents from a GitHub repo
   --top <n>                   Number of top overlapping pairs to report (default 10)
   --fail-above <score>        Mark overlap findings above <score> as critical
@@ -22,6 +30,7 @@ function parseArgs(argv) {
         user: false,
         plugin: false,
         noFail: false,
+        enabledOnly: false,
         help: false,
     };
     let i = 0;
@@ -71,6 +80,10 @@ function parseArgs(argv) {
                 result.noFail = true;
                 i += 1;
                 break;
+            case '--enabled-only':
+                result.enabledOnly = true;
+                i += 1;
+                break;
             default:
                 if (result.dir === undefined && !arg.startsWith('--')) {
                     result.dir = arg;
@@ -82,11 +95,15 @@ function parseArgs(argv) {
     return result;
 }
 export async function main(argv) {
-    if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
         console.log(HELP_TEXT);
         return 0;
     }
     const [cmd, ...rest] = argv;
+    if (cmd === 'doccheck')
+        return runDoccheck(rest);
+    if (cmd === 'usage')
+        return runUsage(rest);
     if (cmd !== 'audit') {
         console.error(`unknown command: ${cmd}`);
         console.error(HELP_TEXT);
@@ -111,6 +128,9 @@ export async function main(argv) {
         console.error('audit requires a <dir> argument or one of --user / --plugin / --repo');
         return 1;
     }
+    if (parsed.enabledOnly && !parsed.plugin) {
+        console.error('--enabled-only has no effect without --plugin');
+    }
     let rendererId = 'cli';
     if (parsed.json)
         rendererId = 'json';
@@ -141,7 +161,12 @@ export async function main(argv) {
             console.error(`not implemented: source '${sourceId}'`);
             return 2;
         }
-        agents.push(...(await source.load({ dir: parsed.dir, pluginName: parsed.pluginName, repo: parsed.repo })));
+        agents.push(...(await source.load({
+            dir: parsed.dir,
+            pluginName: parsed.pluginName,
+            repo: parsed.repo,
+            enabledOnly: parsed.enabledOnly,
+        })));
     }
     const findings = [];
     for (const rule of Object.values(rules)) {

package/dist/doccheck.js

@@ -0,0 +1,215 @@
+import { accessSync, constants, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+const SHELL_LANGS = new Set(['sh', 'bash', 'shell']);
+const FENCE_OPEN_RE = /^\s*(`{3,}|~{3,})\s*([A-Za-z0-9_+-]*)\s*$/;
+const HELP_TEXT = `Usage: roster doccheck [<file|dir> ...] [options]
+
+Scans fenced sh/bash/shell code blocks in markdown docs for commands that
+would fail if run: dead relative paths, missing npm run scripts, and
+scripts that exist but lack the executable bit.
+
+Arguments:
+  <file|dir> ...   Markdown files or directories to scan (directories are
+                   scanned recursively for *.md). Defaults to README.md and
+                   docs/**/*.md, whichever exist, when omitted.
+
+Options:
+  --json           Output findings as JSON: { findings: [...] }
+  --help, -h       Show this help text
+`;
+export async function run(argv) {
+    if (argv.includes('--help') || argv.includes('-h')) {
+        console.log(HELP_TEXT);
+        return 0;
+    }
+    const jsonMode = argv.includes('--json');
+    const positional = argv.filter((a) => a !== '--json');
+    const targets = resolveTargets(positional);
+    const scripts = loadPackageScripts();
+    const findings = [];
+    for (const target of targets) {
+        findings.push(...checkFile(target, scripts));
+    }
+    if (jsonMode) {
+        console.log(JSON.stringify({ findings }));
+    }
+    else if (findings.length === 0) {
+        console.log('doccheck: no findings');
+    }
+    else {
+        for (const f of findings) {
+            console.log(`${f.file}:${f.line}  ${f.command}  ${f.reason}`);
+        }
+        console.log(`doccheck: ${findings.length} finding(s)`);
+    }
+    return findings.length > 0 ? 1 : 0;
+}
+function resolveTargets(positional) {
+    if (positional.length === 0) {
+        const targets = [];
+        if (isFile('README.md'))
+            targets.push('README.md');
+        if (isDir('docs'))
+            targets.push(...collectMarkdownFiles('docs'));
+        return targets;
+    }
+    const targets = [];
+    for (const target of positional) {
+        if (isDir(target)) {
+            targets.push(...collectMarkdownFiles(target));
+        }
+        else if (isFile(target)) {
+            targets.push(target);
+        }
+    }
+    return targets;
+}
+function collectMarkdownFiles(dir) {
+    const result = [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return result;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            result.push(...collectMarkdownFiles(full));
+        }
+        else if (entry.isFile() && path.extname(entry.name).toLowerCase() === '.md') {
+            result.push(full);
+        }
+    }
+    return result;
+}
+function loadPackageScripts() {
+    try {
+        const raw = readFileSync(path.join(process.cwd(), 'package.json'), 'utf8');
+        const pkg = JSON.parse(raw);
+        return new Set(Object.keys(pkg.scripts ?? {}));
+    }
+    catch {
+        return new Set();
+    }
+}
+function checkFile(filePath, scripts) {
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const findings = [];
+    for (const block of extractShellBlocks(content)) {
+        for (const { text, lineNumber } of block) {
+            const reason = checkCommandLine(text, scripts);
+            if (reason) {
+                findings.push({ file: filePath, line: lineNumber, command: text.trim(), reason });
+            }
+        }
+    }
+    return findings;
+}
+function extractShellBlocks(content) {
+    const lines = content.split(/\r?\n/);
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const openMatch = FENCE_OPEN_RE.exec(lines[i]);
+        if (!openMatch) {
+            i += 1;
+            continue;
+        }
+        const fenceChar = openMatch[1][0];
+        const fenceLen = openMatch[1].length;
+        const lang = openMatch[2].toLowerCase();
+        const closeRe = new RegExp(`^\\s*[${fenceChar}]{${fenceLen},}\\s*$`);
+        let j = i + 1;
+        while (j < lines.length && !closeRe.test(lines[j])) {
+            j += 1;
+        }
+        if (SHELL_LANGS.has(lang)) {
+            const blockLines = [];
+            for (let k = i + 1; k < j; k += 1) {
+                blockLines.push({ text: lines[k], lineNumber: k + 1 });
+            }
+            blocks.push(blockLines);
+        }
+        i = j + 1;
+    }
+    return blocks;
+}
+function checkCommandLine(rawLine, scripts) {
+    const trimmed = rawLine.trim();
+    if (trimmed === '' || trimmed.startsWith('#'))
+        return null;
+    let tokens = trimmed.split(/\s+/).filter(Boolean);
+    while (tokens.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=\S*$/.test(tokens[0])) {
+        tokens = tokens.slice(1);
+    }
+    if (tokens.length === 0)
+        return null;
+    const cmd = tokens[0];
+    if (cmd === 'npm') {
+        if (tokens[1] === 'run' && tokens[2]) {
+            const scriptName = tokens[2];
+            if (!scripts.has(scriptName)) {
+                return `npm script not found: ${scriptName}`;
+            }
+        }
+        return null;
+    }
+    if (cmd === 'npx')
+        return null;
+    if (cmd.startsWith('/'))
+        return null; // absolute path or a slash-command like /plugin
+    if (cmd.startsWith('./') || cmd.includes('/')) {
+        const resolved = path.join(process.cwd(), cmd);
+        if (!pathExists(resolved)) {
+            return `relative path not found: ${cmd}`;
+        }
+        if (!isExecutable(resolved)) {
+            return `not executable: ${cmd}`;
+        }
+        return null;
+    }
+    // No path separator and not npm/npx/absolute — treat as a global binary, skip.
+    return null;
+}
+function isFile(p) {
+    try {
+        return statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function pathExists(p) {
+    try {
+        statSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isExecutable(p) {
+    try {
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sources/plugin-cache.js

@@ -38,7 +38,18 @@ function pickPreferred(a, b, cwd) {
         return aUser ? a : b;
     return compareVersions(a.version, b.version) >= 0 ? a : b;
 }
-function resolveActivePlugins(data, cwd) {
+// --enabled-only: user-scope (or scope absent) entries are always active; a
+// local/project-scope entry is only active for the project that pinned it —
+// i.e. cwd is that project's directory or a subdirectory of it.
+function passesEnabledOnly(entry, cwd) {
+    if (entry.scope !== 'local' && entry.scope !== 'project')
+        return true;
+    if (!entry.projectPath)
+        return false;
+    const projectPath = path.resolve(entry.projectPath);
+    return cwd === projectPath || cwd.startsWith(projectPath + path.sep);
+}
+function resolveActivePlugins(data, cwd, enabledOnly) {
     const byName = new Map();
     const skipped = [];
     for (const [key, entries] of Object.entries(data.plugins ?? {})) {
@@ -48,6 +59,8 @@ function resolveActivePlugins(data, cwd) {
         for (const entry of entries) {
             if (!entry.installPath)
                 continue;
+            if (enabledOnly && !passesEnabledOnly(entry, cwd))
+                continue;
             const candidate = {
                 name,
                 marketplace,
@@ -122,7 +135,8 @@ export const pluginCacheSource = {
         }
         const cwd = path.resolve(opts?.cwd ?? process.cwd());
         const pluginNameFilter = opts?.pluginName;
-        const activePlugins = resolveActivePlugins(data, cwd).filter((p) => !pluginNameFilter || p.name === pluginNameFilter);
+        const enabledOnly = opts?.enabledOnly ?? false;
+        const activePlugins = resolveActivePlugins(data, cwd, enabledOnly).filter((p) => !pluginNameFilter || p.name === pluginNameFilter);
         const agentLists = await Promise.all(activePlugins.map(async (plugin) => {
             const agentsDir = path.join(plugin.installPath, 'agents');
             if (!(await dirExists(agentsDir)))

package/dist/usage.js

@@ -0,0 +1,224 @@
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import os from 'node:os';
+import path from 'node:path';
+import { sources } from './sources/index.js';
+const HELP_TEXT = `Usage: roster usage [options]
+
+Reports how often each subagent_type has been invoked (via the Agent/Task
+tool) across Claude Code transcript files.
+
+Options:
+  --days <n>       Only count invocations from the last <n> days (default 30)
+  --json           Output machine-readable JSON
+  --user           Join against the user-level agent roster (~/.claude/agents)
+  --plugin         Join against the installed plugin-cache roster
+  --help, -h       Show this help text
+
+Env:
+  ROSTER_CLAUDE_DIR   Transcripts root (default ~/.claude)
+`;
+function parseArgs(argv) {
+    const result = {
+        days: 30,
+        json: false,
+        user: false,
+        plugin: false,
+        help: false,
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--help':
+            case '-h':
+                result.help = true;
+                i += 1;
+                break;
+            case '--json':
+                result.json = true;
+                i += 1;
+                break;
+            case '--user':
+                result.user = true;
+                i += 1;
+                break;
+            case '--plugin':
+                result.plugin = true;
+                i += 1;
+                break;
+            case '--days': {
+                const n = Number(argv[i + 1]);
+                if (Number.isFinite(n) && n > 0)
+                    result.days = n;
+                i += 2;
+                break;
+            }
+            default:
+                i += 1;
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Pure join between observed invocation counts and a roster's agent names.
+ * - unused: in the roster, but zero observed invocations.
+ * - ghosts: observed invocations for a subagent_type that isn't in the roster.
+ */
+export function computeJoin(counts, rosterNames) {
+    const rosterSet = new Set(rosterNames);
+    const unused = rosterNames.filter((name) => !counts[name]);
+    const ghosts = Object.keys(counts).filter((name) => !rosterSet.has(name));
+    return { unused, ghosts };
+}
+async function findJsonlFiles(root) {
+    const projectsDir = path.join(root, 'projects');
+    let projectEntries;
+    try {
+        projectEntries = await readdir(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const projectEntry of projectEntries) {
+        if (!projectEntry.isDirectory())
+            continue;
+        const projectDir = path.join(projectsDir, projectEntry.name);
+        let fileEntries;
+        try {
+            fileEntries = await readdir(projectDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const fileEntry of fileEntries) {
+            if (fileEntry.isFile() && fileEntry.name.endsWith('.jsonl')) {
+                files.push(path.join(projectDir, fileEntry.name));
+            }
+        }
+    }
+    return files;
+}
+async function countAgentInvocations(filePath, cutoff, counts) {
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: 'utf8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof record !== 'object' || record === null)
+            continue;
+        const obj = record;
+        const timestamp = obj.timestamp;
+        if (typeof timestamp !== 'string')
+            continue;
+        const ts = new Date(timestamp);
+        if (Number.isNaN(ts.getTime()) || ts < cutoff)
+            continue;
+        if (obj.type !== 'assistant')
+            continue;
+        const message = obj.message;
+        const content = message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block &&
+                typeof block === 'object' &&
+                block.type === 'tool_use' &&
+                (block.name === 'Agent' || block.name === 'Task')) {
+                const input = block.input;
+                const subagentType = input?.subagent_type;
+                if (typeof subagentType === 'string') {
+                    counts[subagentType] = (counts[subagentType] ?? 0) + 1;
+                }
+            }
+        }
+    }
+}
+async function loadRosterNames(user, plugin) {
+    const names = new Set();
+    if (user) {
+        const agents = await sources.user.load();
+        for (const agent of agents)
+            names.add(agent.name);
+    }
+    if (plugin) {
+        const agents = await sources['plugin-cache'].load();
+        for (const agent of agents)
+            names.add(agent.name);
+    }
+    return [...names];
+}
+function renderHuman(days, counts, unused, ghosts) {
+    const lines = [];
+    const rows = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    if (rows.length === 0) {
+        lines.push(`No agent invocations found in the last ${days} day(s).`);
+    }
+    else {
+        lines.push(`Agent usage (last ${days} day(s)):`);
+        for (const [name, count] of rows) {
+            lines.push(`  ${count}\t${name}`);
+        }
+    }
+    if (unused.length > 0) {
+        lines.push('Unused (in roster, 0 invocations):');
+        for (const name of unused)
+            lines.push(`  ${name}`);
+    }
+    if (ghosts.length > 0) {
+        lines.push('Ghost subagent_type (invoked, not in roster):');
+        for (const name of ghosts)
+            lines.push(`  ${name}`);
+    }
+    return lines.join('\n');
+}
+export async function run(argv) {
+    const parsed = parseArgs(argv);
+    if (parsed.help) {
+        console.log(HELP_TEXT);
+        return 0;
+    }
+    const root = process.env.ROSTER_CLAUDE_DIR ?? path.join(os.homedir(), '.claude');
+    const cutoff = new Date(Date.now() - parsed.days * 24 * 60 * 60 * 1000);
+    const files = await findJsonlFiles(root);
+    const counts = {};
+    for (const filePath of files) {
+        let stats;
+        try {
+            stats = await stat(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (stats.mtime < cutoff)
+            continue;
+        await countAgentInvocations(filePath, cutoff, counts);
+    }
+    let unused = [];
+    let ghosts = [];
+    if (parsed.user || parsed.plugin) {
+        const rosterNames = await loadRosterNames(parsed.user, parsed.plugin);
+        const joined = computeJoin(counts, rosterNames);
+        unused = joined.unused;
+        ghosts = joined.ghosts;
+    }
+    if (parsed.json) {
+        console.log(JSON.stringify({ days: parsed.days, counts, unused, ghosts }));
+    }
+    else {
+        console.log(renderHuman(parsed.days, counts, unused, ghosts));
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roster-cli",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Zero-runtime-dep static auditor for Claude Code agent rosters \u2014 overlap, harness gaps, routing, cost.",
   "type": "module",
   "bin": {