@vibe-agent-toolkit/cli 0.2.0-rc.1 → 0.2.0-rc.3

package/dist/commands/claude/budget.js

@@ -0,0 +1,412 @@
+/**
+ * `vat claude budget [paths...]` — is the always-loaded context at a working
+ * location over its budget?
+ *
+ * ## Why this is a command and not a check inside `vat resources validate`
+ *
+ * It used to be one: default-on, with a `--no-context-budget` opt-out. That is
+ * gone, in both directions — `vat resources validate` has no knowledge of the
+ * budget at all any more, not a flag, not a default. The ruling behind the move
+ * is short: *a validation run must not emit findings nobody asked for.* An
+ * `info` finding attached to a lane people run for link and anchor errors is a
+ * finding they scroll past, and a check people scroll past is a check they
+ * eventually silence.
+ *
+ * ## The sibling split: `context` QUERIES, `budget` CHECKS
+ *
+ * `vat claude context` answers a question and
+ * never gates — totals, admissions, the declared limits, no verdict, always
+ * exit 0. This command is the other half of that pair: it applies a THRESHOLD,
+ * produces findings with severities an adopter can configure, and lets an
+ * adopter who promotes the code to `error` fail their build with it. Two verbs
+ * because they are two acts, and folding a verdict into the query would make
+ * the query's number a number people learn to stop reading.
+ *
+ * ## Everything below is orchestration — deliberately
+ *
+ * Which directories exist, what each pays, and whether that is over budget are
+ * all decided in `@vibe-agent-toolkit/resources` (`buildClaudeContextPopulation`
+ * and `sweepAlwaysLoadedBudgets`); the wording and grouping of the findings in
+ * `utils/context-budget-issues.ts`; severity resolution in the two shared
+ * filters every other lane runs. This module populates one tree, calls them in
+ * order, and renders. It decides nothing about context loading of its own,
+ * which is the CLI-stays-dumb rule applied to the lane where the temptation is
+ * strongest.
+ *
+ * ⛔ The threshold is never re-spelled here. It is a MEASURED quantity that
+ * lives beside the detector (`DEFAULT_ALWAYS_LOADED_CONTEXT_TOKENS`), and a
+ * literal in this package would be a second source of truth that nothing
+ * compares.
+ *
+ * ## The stated bounds ride ONCE on the REPORT, in every format
+ *
+ * The sibling query publishes 23 stated limits; this command applies a threshold
+ * to the same measurement, so it publishes {@link ALWAYS_LOADED_BUDGET_LIMITS}
+ * and {@link CLAUDE_CONTEXT_BOUNDS_STATEMENT} beside its verdict — the half that
+ * GATES is the half whose bounds a reader most needs. Both are imported, never
+ * restated: the sentence is domain content owned beside the list it frames.
+ *
+ * ⛔ They belong to the REPORT, never to a finding. A per-finding copy is the
+ * defect this lane already shipped once on the query side, and it is invisible to
+ * any assertion that checks presence rather than counting occurrences.
+ */
+import { ALWAYS_LOADED_BUDGET_LIMITS, buildClaudeContextPopulation, CLAUDE_CONTEXT_BOUNDS_STATEMENT, DEFAULT_ALWAYS_LOADED_CONTEXT_TOKENS, sweepAlwaysLoadedBudgets, } from '@vibe-agent-toolkit/resources';
+import { applyAllowFilter, calculateValidationStatus, countBySeverity, } from '@vibe-agent-toolkit/schema';
+import { findProjectRoot } from '@vibe-agent-toolkit/utils';
+import { Command, Option } from 'commander';
+import { handleCommandError } from '../../utils/command-error.js';
+import { loadConfig } from '../../utils/config-loader.js';
+import { contextBudgetIssues, scopeSweepToPaths } from '../../utils/context-budget-issues.js';
+import { targetPathWithin } from '../../utils/corpus-target.js';
+import { resolveIssueSeverity } from '../../utils/issue-severity.js';
+import { createLogger } from '../../utils/logger.js';
+import { writeJsonOutput, writeStdoutSync, writeYamlOutput } from '../../utils/output.js';
+import { populationWiring } from '../../utils/population-wiring.js';
+import { withPopulationCache } from '../../utils/projection-store.js';
+import { gitTrackerForProjectRoot } from '../audit/distributed-tree.js';
+/** How this command names itself in a refusal. */
+const COMMAND_NAME = 'vat claude budget';
+/** Soft wrap width for the printed limit statements. */
+const WRAP_COLUMNS = 96;
+/**
+ * Create the `vat claude budget [paths...]` command.
+ *
+ * @returns The configured Commander command
+ */
+export function createBudgetCommand() {
+    const command = new Command('budget');
+    command
+        .description('Check whether the always-loaded context at a working location exceeds its budget')
+        .argument('[paths...]', 'Directories to check, with everything beneath them (default: the whole tree)')
+        .addOption(new Option('--format <format>', 'Output format: text (default), yaml, or json').choices([
+        'text',
+        'yaml',
+        'json',
+    ]).default('text'))
+        .option('--debug', 'Verbose logging to stderr')
+        .action(claudeBudgetCommand)
+        .addHelpText('after', `
+Description:
+  Reports ALWAYS_LOADED_CONTEXT_BUDGET for each instruction chain whose
+  always-loaded context exceeds the budget. The measured chain is the
+  repo-root CLAUDE.md, every CLAUDE.md on the path down to the working
+  location, one level of @ imports from each, and any unscoped rules file in
+  the root .claude/rules/. An AGENTS.md is measured only where a CLAUDE.md
+  imports it (@AGENTS.md) — Claude Code does not load it by name, so a repo
+  standardised on AGENTS.md alone has nothing here to measure. Path-scoped
+  rules (a paths: list) are excluded: they load when the agent touches a
+  matching file, not at launch.
+
+  ONE finding per chain, not per directory: directories loading the same files
+  share a finding, which names how many working locations pay it. Naming paths
+  narrows WHICH chains are reported; the payer count stays the whole tree's,
+  because that is the number that was measured.
+
+  This is the CHECK. 'vat claude context' is the QUERY — same lane, no
+  threshold and no verdict.
+
+Configuration (vibe-agent-toolkit.config.yaml):
+  resources.validation.thresholds.alwaysLoadedContextTokens moves the budget
+  (default ${String(DEFAULT_ALWAYS_LOADED_CONTEXT_TOKENS)}). resources.validation.severity.ALWAYS_LOADED_CONTEXT_BUDGET
+  silences it (ignore) or promotes it to warning/error. A project with no
+  config file is checked at the same default budget.
+
+Output:
+  - threshold:          the budget every chain was measured against
+  - scope/unmatchedScope: what was asked about, and what matched nothing
+  - status/issueCounts: the worst actionable severity, plus every severity
+  - workingLocations, distinctChains, skippedUnknownLocations: whole-tree
+                        facts, so an empty findings list is legible
+  - findings:           one per over-budget chain, ascending by directory
+  - limits/boundsStatement: what this verdict does not settle, signed
+                        over-report or under-report. On the REPORT, never on a
+                        finding — they bound the method, not any one chain, so
+                        they are stated exactly once however many chains flag
+
+  Text to stdout by default; --format yaml|json for a program. Diagnostics
+  and blob-stage refusals go to stderr.
+
+Exit Codes:
+  0 - Reported (findings at the default info severity do not gate)
+  1 - A finding resolved to error severity via config
+  2 - System error (a path outside the corpus root, unreadable tree)
+
+Example:
+  $ vat claude budget packages/cli      # is it over budget where I work?
+`);
+    return command;
+}
+/**
+ * Action handler for `vat claude budget [paths...]`.
+ *
+ * @param pathArgs - Directories to check; empty means the whole tree
+ * @param options - The command's flags
+ */
+export async function claudeBudgetCommand(pathArgs, options) {
+    const logger = createLogger(options.debug === true ? { debug: true } : {});
+    const startTime = Date.now();
+    try {
+        const root = findProjectRoot(process.cwd()) ?? process.cwd();
+        // 🔑 Every argument is resolved BEFORE the population. A path outside the
+        // corpus is a usage error, and finding it afterwards would charge the caller
+        // a full population — minutes on a cold cache — to be told they mistyped.
+        const scope = scopeWithin(root, pathArgs);
+        const config = loadConfig(root);
+        const validation = config?.resources?.validation;
+        const threshold = validation?.thresholds?.alwaysLoadedContextTokens
+            ?? DEFAULT_ALWAYS_LOADED_CONTEXT_TOKENS;
+        const sweep = await sweepBudgets(root, threshold, logger);
+        const scoped = scopeSweepToPaths(sweep, scope);
+        // The same two shared mechanisms every other lane uses, in the same order:
+        // `validation.allow` suppresses by path glob, then `validation.severity`
+        // resolves — BOTH directions, so an adopter promoting this code to `error`
+        // gets an error, which is the case that gets forgotten.
+        const findings = resolveIssueSeverity(applyAllowFilter(contextBudgetIssues(scoped.sweep), validation ?? {}).emitted, validation);
+        warnUnmatched(scoped.unmatchedScope, logger);
+        const report = buildReport({ root, threshold, scope, sweep, scoped, findings });
+        emit(report, options.format ?? 'text');
+        // Only `error` gates. At the code's `info` default this is always 0, so the
+        // budget cannot fail a build unless an adopter asked it to.
+        process.exit(report.issueCounts.errors > 0 ? 1 : 0);
+    }
+    catch (error) {
+        handleCommandError(error, logger, startTime, 'claude budget');
+    }
+}
+/**
+ * Assemble the report from the run's parts.
+ *
+ * ⛔ The counters come from the UNSCOPED sweep. They answer "what was measured",
+ * and a scope changes only what is reported — sourcing them from the narrowed
+ * view would let `vat claude budget docs` claim the tree has one chain.
+ *
+ * ⛔ This is the ONE place the stated bounds enter the machine-readable output,
+ * and keeping it a single assignment is what makes "stated once" structural
+ * rather than a habit: there is no per-finding site left where a copy could be
+ * reintroduced. They are attached unconditionally — a run that flagged nothing
+ * used the same method, and a reader acting on "within budget" needs them most.
+ *
+ * ⛔ Exported so it can be TESTED. What has to be pinned is a COUNT — that the
+ * block appears exactly once across a MULTI-finding report — and a presence
+ * check passes identically with a copy per finding.
+ *
+ * @param input - The run's parts
+ * @returns The report, ready to serialize
+ */
+export function buildReport(input) {
+    const { root, threshold, scope, sweep, scoped, findings } = input;
+    return {
+        root,
+        threshold,
+        scope,
+        unmatchedScope: scoped.unmatchedScope,
+        status: calculateValidationStatus(findings),
+        issueCounts: countBySeverity(findings),
+        workingLocations: sweep.evaluatedDirectories,
+        distinctChains: sweep.queriedDirectories,
+        skippedUnknownLocations: sweep.skippedUnknownLocations,
+        findings,
+        boundsStatement: CLAUDE_CONTEXT_BOUNDS_STATEMENT,
+        limits: ALWAYS_LOADED_BUDGET_LIMITS,
+    };
+}
+/**
+ * Resolve the requested scope, defaulting to the whole tree.
+ *
+ * ⚠️ No arguments means the WHOLE TREE, not the current directory — the
+ * opposite of `vat claude context`'s default, and deliberately so. This is a
+ * check: the useful bare invocation is "tell me about everything", the way a
+ * linter run from a subdirectory still lints the project. Naming a directory is
+ * how a caller asks the narrower question.
+ *
+ * @param root - The discovered project root
+ * @param pathArgs - The path arguments, possibly empty
+ * @returns Root-relative directories; `['']` for the whole tree
+ */
+function scopeWithin(root, pathArgs) {
+    if (pathArgs.length === 0)
+        return [''];
+    return pathArgs.map((pathArg) => targetPathWithin(root, pathArg, COMMAND_NAME));
+}
+/**
+ * Say so, loudly, when a requested path named no working location.
+ *
+ * ⛔ `warn` (stderr), never `debug`. Such a scope produces zero findings, which
+ * is byte-identical to a clean bill of health — and a default run that stayed
+ * silent about it would publish that confusion rather than the fact behind it.
+ *
+ * @param unmatched - The requested paths that matched nothing
+ * @param logger - Where the warning goes
+ */
+function warnUnmatched(unmatched, logger) {
+    if (unmatched.length === 0)
+        return;
+    logger.warn(`Warning: no working location matched ${unmatched.join(', ')} — nothing was checked there.`
+        + ' This is NOT a report that those paths are within budget.');
+}
+/**
+ * Populate the Claude-context lane for one tree and sweep every location.
+ *
+ * ⚠️ Roots at the discovered project root and NOWHERE else, whatever paths were
+ * named. A budget is a property of a position in the directory tree, and rooting
+ * a population at a subdirectory would compute one against a corpus whose
+ * ancestors are missing — a confidently wrong number.
+ *
+ * @param root - The absolute corpus root; the ONLY tree populated
+ * @param threshold - The always-loaded token budget
+ * @param logger - Where blob-stage refusals go. **stderr**, never stdout: this
+ *   command's stdout is the document a caller parses
+ * @returns Every working location's budget
+ */
+async function sweepBudgets(root, threshold, logger) {
+    const projection = await withPopulationCache({ root }, async (cache) => {
+        const gitTracker = await gitTrackerForProjectRoot(root);
+        return buildClaudeContextPopulation({ root, ...populationWiring(logger, gitTracker, cache) });
+    });
+    return sweepAlwaysLoadedBudgets(projection, threshold);
+}
+/**
+ * Write the report in the requested format.
+ *
+ * @param report - The report
+ * @param format - The selected format
+ */
+function emit(report, format) {
+    if (format === 'json') {
+        writeJsonOutput(report);
+        return;
+    }
+    if (format === 'yaml') {
+        writeYamlOutput(report);
+        return;
+    }
+    writeStdoutSync(renderReportText(report));
+}
+/**
+ * Render the report for a person.
+ *
+ * ⛔ Exported so the "stated once" property can be pinned in TEXT as well as in
+ * json. The two renderings are separate code paths and this lane has already
+ * shipped a defect where they disagreed while each looked right alone.
+ *
+ * @param report - The report
+ * @returns The text rendering, newline-terminated
+ */
+export function renderReportText(report) {
+    const lines = [
+        `Always-loaded context budget at ${report.root}`,
+        `  budget ${count(report.threshold)} tokens`
+            + ` · ${count(report.workingLocations)} working locations`
+            + ` · ${count(report.distinctChains)} distinct chains`
+            + ` · ${count(report.skippedUnknownLocations)} unrealized`,
+        '',
+        ...findingLines(report.findings),
+        ...unmatchedLines(report.unmatchedScope),
+        ...limitLines(report),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+/**
+ * The stated bounds, printed once at the foot of the report.
+ *
+ * ⛔ Never omitted, and never per finding. A clean report is subject to exactly
+ * the same signed bounds as a flagged one — more so, since "within budget" is the
+ * verdict a reader is most likely to act on without reading further.
+ *
+ * The sibling `vat claude context` prints a section of the same shape from its
+ * own list. They are deliberately NOT sharing a renderer: two commands, two
+ * report types, and the query additionally prints the modelled-behaviour
+ * citations that no bound of this verdict rests on.
+ *
+ * @param report - The report carrying the bounds
+ * @returns The section's lines
+ */
+function limitLines(report) {
+    const lines = ['What this verdict does not settle', ...wrapped(report.boundsStatement, '  '), ''];
+    for (const limit of report.limits) {
+        lines.push(`  ${limit.direction}: ${limit.id}`);
+        lines.push(...wrapped(limit.statement, '    '));
+    }
+    return lines;
+}
+/**
+ * Soft-wrap a statement under a fixed indent.
+ *
+ * The statements run to several sentences and are the part of this output a
+ * reader has to actually read; unwrapped they arrive as one 500-column line that
+ * a terminal breaks mid-word. A word longer than the width overflows its own line
+ * rather than being split — no character of a statement is ever dropped.
+ *
+ * @param text - The statement
+ * @param indent - Leading whitespace for every produced line
+ * @returns One or more indented lines
+ */
+function wrapped(text, indent) {
+    const width = Math.max(WRAP_COLUMNS - indent.length, 24);
+    const lines = [];
+    let pending = '';
+    for (const word of text.split(' ')) {
+        const candidate = pending === '' ? word : `${pending} ${word}`;
+        if (pending !== '' && candidate.length > width) {
+            lines.push(indent + pending);
+            pending = word;
+        }
+        else {
+            pending = candidate;
+        }
+    }
+    if (pending !== '')
+        lines.push(indent + pending);
+    return lines;
+}
+/**
+ * The findings, or the sentence that says there were none.
+ *
+ * ⛔ The empty case is a SENTENCE, not blank output. A command that prints
+ * nothing is indistinguishable from one that failed to run.
+ *
+ * @param findings - The reported findings
+ * @returns The lines, blank-terminated
+ */
+function findingLines(findings) {
+    if (findings.length === 0)
+        return ['Every instruction chain checked is within budget.', ''];
+    const lines = [];
+    for (const finding of findings) {
+        lines.push(`${finding.severity} ${finding.code} at ${finding.location ?? '<corpus root>'}`);
+        lines.push(`  ${finding.message}`);
+        if (finding.fix !== undefined)
+            lines.push(`  Fix: ${finding.fix}`);
+        lines.push('');
+    }
+    return lines;
+}
+/**
+ * The unmatched-scope notice, printed in the document as well as on stderr.
+ *
+ * @param unmatched - The requested paths that matched nothing
+ * @returns The lines, or none
+ */
+function unmatchedLines(unmatched) {
+    if (unmatched.length === 0)
+        return [];
+    return [
+        `Matched no working location: ${unmatched.join(', ')}`,
+        '  Nothing was checked there — this is not a report that they are within budget.',
+        '',
+    ];
+}
+/**
+ * A count as a reader reads it.
+ *
+ * Pinned to `en-US` rather than left to the host locale, so the same run renders
+ * byte-identically on two developers' machines — the same rule the findings
+ * themselves follow in `utils/context-budget-issues.ts`.
+ *
+ * @param value - The number
+ * @returns Its thousands-separated form
+ */
+function count(value) {
+    return value.toLocaleString('en-US');
+}
+//# sourceMappingURL=budget.js.map

package/dist/commands/claude/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../../../src/commands/claude/budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EACL,2BAA2B,EAC3B,4BAA4B,EAC5B,+BAA+B,EAC/B,oCAAoC,EACpC,wBAAwB,GAGzB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,eAAe,GAGhB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC9F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAe,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAExE,kDAAkD;AAClD,MAAM,YAAY,GAAG,mBAAmB,CAAC;AAEzC,wDAAwD;AACxD,MAAM,YAAY,GAAG,EAAE,CAAC;AAkDxB;;;;GAIG;AACH,MAAM,UAAU,mBAAmB;IACjC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;IACtC,OAAO;SACJ,WAAW,CAAC,kFAAkF,CAAC;SAC/F,QAAQ,CACP,YAAY,EACZ,8EAA8E,CAC/E;SACA,SAAS,CACR,IAAI,MAAM,CAAC,mBAAmB,EAAE,8CAA8C,CAAC,CAAC,OAAO,CAAC;QACtF,MAAM;QACN,MAAM;QACN,MAAM;KACP,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CACnB;SACA,MAAM,CAAC,SAAS,EAAE,2BAA2B,CAAC;SAC9C,MAAM,CAAC,mBAAmB,CAAC;SAC3B,WAAW,CAAC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;aAsBb,MAAM,CAAC,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BxD,CAAC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,QAA2B,EAC3B,OAA4B;IAE5B,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3E,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAC7D,0EAA0E;QAC1E,6EAA6E;QAC7E,0EAA0E;QAC1E,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAChC,MAAM,UAAU,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;QACjD,MAAM,SAAS,GAAG,UAAU,EAAE,UAAU,EAAE,yBAAyB;eAC9D,oCAAoC,CAAC;QAE1C,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QAC1D,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC/C,2EAA2E;QAC3E,yEAAyE;QACzE,2EAA2E;QAC3E,wDAAwD;QACxD,MAAM,QAAQ,GAAG,oBAAoB,CACnC,gBAAgB,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,UAAU,IAAI,EAAE,CAAC,CAAC,OAAO,EAC7E,UAAU,CACX,CAAC;QACF,aAAa,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;QAE7C,MAAM,MAAM,GAAG,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;QAChF,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,CAAC;QACvC,4EAA4E;QAC5E,4DAA4D;QAC5D,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;IAChE,CAAC;AACH,CAAC;AAYD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CAAC,KAAkB;IAC5C,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;IAClE,OAAO;QACL,IAAI;QACJ,SAAS;QACT,KAAK;QACL,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,MAAM,EAAE,yBAAyB,CAAC,QAAQ,CAAC;QAC3C,WAAW,EAAE,eAAe,CAAC,QAAQ,CAAC;QACtC,gBAAgB,EAAE,KAAK,CAAC,oBAAoB;QAC5C,cAAc,EAAE,KAAK,CAAC,kBAAkB;QACxC,uBAAuB,EAAE,KAAK,CAAC,uBAAuB;QACtD,QAAQ;QACR,eAAe,EAAE,+BAA+B;QAChD,MAAM,EAAE,2BAA2B;KACpC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,WAAW,CAAC,IAAY,EAAE,QAA2B;IAC5D,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IACvC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,aAAa,CAAC,SAA4B,EAAE,MAAc;IACjE,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACnC,MAAM,CAAC,IAAI,CACT,wCAAwC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,+BAA+B;UACzF,2DAA2D,CAC9D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,KAAK,UAAU,YAAY,CACzB,IAAY,EACZ,SAAiB,EACjB,MAAc;IAEd,MAAM,UAAU,GAAG,MAAM,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACrE,MAAM,UAAU,GAAG,MAAM,wBAAwB,CAAC,IAAI,CAAC,CAAC;QACxD,OAAO,4BAA4B,CAAC,EAAE,IAAI,EAAE,GAAG,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IAChG,CAAC,CAAC,CAAC;IACH,OAAO,wBAAwB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AACzD,CAAC;AAED;;;;;GAKG;AACH,SAAS,IAAI,CAAC,MAAoB,EAAE,MAA0B;IAC5D,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,eAAe,CAAC,MAAM,CAAC,CAAC;QACxB,OAAO;IACT,CAAC;IACD,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;QACtB,eAAe,CAAC,MAAM,CAAC,CAAC;QACxB,OAAO;IACT,CAAC;IACD,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAoB;IACnD,MAAM,KAAK,GAAG;QACZ,mCAAmC,MAAM,CAAC,IAAI,EAAE;QAChD,YAAY,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS;cAC1C,MAAM,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,oBAAoB;cACxD,MAAM,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,kBAAkB;cACpD,MAAM,KAAK,CAAC,MAAM,CAAC,uBAAuB,CAAC,aAAa;QAC1D,EAAE;QACF,GAAG,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC;QAChC,GAAG,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC;QACxC,GAAG,UAAU,CAAC,MAAM,CAAC;KACtB,CAAC;IACF,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;AACjC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,UAAU,CAAC,MAAoB;IACtC,MAAM,KAAK,GAAG,CAAC,mCAAmC,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAClG,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClC,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,OAAO,CAAC,IAAY,EAAE,MAAc;IAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACzD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,MAAM,SAAS,GAAG,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC;QAC/D,IAAI,OAAO,KAAK,EAAE,IAAI,SAAS,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;YAC/C,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC;YAC7B,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,SAAS,CAAC;QACtB,CAAC;IACH,CAAC;IACD,IAAI,OAAO,KAAK,EAAE;QAAE,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC;IACjD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAC,QAAoC;IACxD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,mDAAmD,EAAE,EAAE,CAAC,CAAC;IAC5F,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,KAAK,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,OAAO,OAAO,CAAC,QAAQ,IAAI,eAAe,EAAE,CAAC,CAAC;QAC5F,KAAK,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACnC,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS;YAAE,KAAK,CAAC,IAAI,CAAC,UAAU,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QACnE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,SAA4B;IAClD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACtC,OAAO;QACL,gCAAgC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QACtD,iFAAiF;QACjF,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,KAAK,CAAC,KAAa;IAC1B,OAAO,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC"}

package/dist/commands/claude/context.d.ts

@@ -0,0 +1,211 @@
+/**
+ * `vat claude context [path]` — what loads into an agent's context here, and
+ * what it costs.
+ *
+ * The first ANALYSIS verb under `vat claude`, which until now held only
+ * management verbs (plugins, marketplaces, org administration). It answers a
+ * question, changes nothing, and never gates: there is no threshold anywhere in
+ * this file, and the only non-zero exit is {@link handleCommandError}'s 2 for a
+ * system failure. A number that fails a build teaches people to stop reading it.
+ *
+ * ## Everything below is orchestration and formatting — deliberately
+ *
+ * Which files load, why, and what they cost are all decided in
+ * `@vibe-agent-toolkit/resources` (`whatLoadsAt` and `account`). This module
+ * populates, calls them, and renders. It computes nothing about context loading
+ * of its own, which is the CLI-stays-dumb rule applied to a lane where the
+ * temptation is strong: the totals are right there and a "just one more derived
+ * field" would put a second, unowned model of the vendor's behaviour in the
+ * package no other package can depend on.
+ *
+ * ## The limits ride WITH the run — ONCE — in every format
+ *
+ * Spec §11 puts the stated limits in the command's own output rather than in a
+ * doc, because a limit a reader has to go and find is a limit that never reaches
+ * the person acting on the number. So {@link CLAUDE_CONTEXT_LIMITS} and
+ * {@link CLAUDE_CONTEXT_MODELLED_BEHAVIOURS} are fields of the yaml/json
+ * ENVELOPE and a printed section of the text rendering, and
+ * {@link CLAUDE_CONTEXT_BOUNDS_STATEMENT} — *neither a floor nor a ceiling* —
+ * appears in all three. All three are imported, never restated: the sentence is
+ * domain content owned beside the list it frames, so every other consumer of the
+ * list reaches it too.
+ *
+ * ⛔ They belong to the ENVELOPE, never to an answer, and both renderings obey
+ * that identically — see {@link ContextEnvelope} for why. Attaching them per
+ * answer was not a formatting preference: on a `--all` sweep of this repository
+ * (6,224 answers) `--format json` measured 76,877,016 bytes and measures
+ * 6,581,468 with the block hoisted — 70.3 MB of ONE byte-identical paragraph,
+ * repeated. That is the JSON spelling of the very burial
+ * {@link renderEnvelopeText} refuses to do in text.
+ *
+ * ⛔ Nothing here may read as "complete". Many of the stated limits are signed
+ * `over-report`/`under-report` and apply whether or not `unknownTokenRows`,
+ * `skippedOversizeRows` and `prunedRows` are all zero, so zeroed counters are not
+ * a licence for the words "total cost", "full" or "all context".
+ *
+ * ⛔ A `null` token or byte count is an UNKNOWN SIZE and is never rendered as 0 —
+ * see {@link chargeText}. A confident zero is indistinguishable from a measured
+ * one, and the same reasoning is why an unrealized path answers `unknown` rather
+ * than an empty table.
+ */
+import { type AccountedRow, type ContextTotals, type DiscoverableContext, type GradedCondition, type LoadedContextAnswer, type ModelledBehaviour, type Projection, type StatedLimit } from '@vibe-agent-toolkit/resources';
+import { Command } from 'commander';
+/** How the answer is rendered. `text` is for a person; the other two are for a program. */
+export type ContextOutputFormat = 'text' | 'yaml' | 'json';
+/** Flags `vat claude context` accepts. */
+export interface ClaudeContextOptions {
+    format?: ContextOutputFormat;
+    debug?: boolean;
+    all?: boolean;
+    discoverable?: boolean;
+}
+/**
+ * The envelope every run emits, however many paths were asked about.
+ *
+ * ⛔ `answers` is an array **even for one path**, so a consumer never branches on
+ * arity. The single-path shape is the N=1 case of the sweep, not a different
+ * document — a caller that special-cased "one path means a bare object" is the
+ * defect this shape exists to prevent, and pre-1.0 is when to pay for it.
+ *
+ * `root` rides here rather than on each answer because it is a property of the
+ * POPULATION, and one run populates exactly one tree. Repeating it per answer
+ * would invite a reader to believe two answers could carry different roots.
+ *
+ * ⛔ The three limit fields ride here for the SAME reason, and it is the reason
+ * {@link renderEnvelopeText} already prints them once: they bound the
+ * MEASUREMENT METHOD, not any one path. An answer carrying its own copy reads
+ * as though that path had caveats of its own — and repeated across a sweep it
+ * is pure duplication, byte-identical every time.
+ */
+export interface ContextEnvelope {
+    readonly root: string;
+    readonly answers: readonly (ContextAnswerDocument | ContextUnknownDocument)[];
+    /** What these answers do not settle, in either direction. Stated once. */
+    readonly boundsStatement: string;
+    /** The signed over/under-report bounds on the method. Stated once. */
+    readonly limits: readonly StatedLimit[];
+    /** The vendor behaviours modelled, each cited. Stated once. */
+    readonly modelledBehaviours: readonly ModelledBehaviour[];
+}
+/**
+ * The yaml/json document for a path the projection realizes.
+ *
+ * `rows` are `AccountedRow`s verbatim rather than a narrowed projection of them:
+ * re-shaping the rows here would be the CLI deciding which of the accounting
+ * module's facts a consumer is allowed to see, and `resourceId` and `bytes` are
+ * exactly what a consumer joining this answer to another projection query needs.
+ */
+export interface ContextAnswerDocument {
+    readonly kind: 'answer';
+    readonly input: string;
+    readonly directory: string;
+    readonly file: string | null;
+    readonly totals: ContextTotals;
+    readonly rows: readonly AccountedRow[];
+    readonly conditions: readonly GradedCondition[];
+    readonly overBudgetRules: readonly string[];
+    readonly unattributedImports: readonly string[];
+    /**
+     * What the loaded set POINTS AT in one hop and the harness does not load, or
+     * null when `--discoverable` was not asked for.
+     *
+     * ⛔ `null` rather than an empty object, and the difference is the whole
+     * reason the field is nullable: an empty `rows` array means "nothing here
+     * links anywhere", and a run that never looked must not be readable as that.
+     * The same distinction {@link ContextUnknownDocument} exists to draw, one
+     * level down.
+     *
+     * ⛔ Its tokens are NEVER added to `totals`. A markdown link is voluntary —
+     * nothing loads it — so folding it into a context-budget figure would charge
+     * a session for documents it may never open.
+     */
+    readonly discoverable: DiscoverableContext | null;
+}
+/**
+ * The yaml/json document for a path the projection never realized.
+ *
+ * ⛔ Structurally different from an answer, and that is the point: it carries no
+ * `totals` and no `rows`, so a consumer cannot accidentally read "VAT never
+ * looked at this path" as "nothing loads here". `explanation` says the same thing
+ * to a person who is reading the document rather than switching on `kind`.
+ */
+export interface ContextUnknownDocument {
+    readonly kind: 'unknown';
+    readonly input: string;
+    readonly reason: 'path-not-realized';
+    readonly explanation: string;
+}
+/**
+ * Create the `vat claude context [path]` command.
+ *
+ * @returns The configured Commander command
+ */
+export declare function createContextCommand(): Command;
+/**
+ * Action handler for `vat claude context [path]`.
+ *
+ * @param pathArg - The path to answer for, or undefined for the current directory
+ * @param options - The command's flags
+ */
+export declare function claudeContextCommand(pathArgs: readonly string[], options: ClaudeContextOptions): Promise<void>;
+/**
+ * The answer document for one query.
+ *
+ * Split from the handler so the handler stays a straight line: the accounting
+ * call needs the `claude-md` identity set, and threading that through the
+ * handler body put three statements between the query and its document.
+ *
+ * Returns the document alone — rendering moved to {@link renderEnvelopeText},
+ * which needs every document at once to print the limits exactly once, and the
+ * limits themselves are attached by {@link contextEnvelope}, never here.
+ *
+ * ⛔ Exported so it can be TESTED. What has to be pinned is an ABSENCE — that no
+ * limit field is on the returned document — and an absence is only observable by
+ * calling the function that would have added it.
+ *
+ * @param answer - The query's answer
+ * @param projection - The populated projection, for the `claude-md` tag rows
+ * @param discoverable - Whether to compute the one-hop reachable set
+ * @returns The answer document
+ */
+export declare function answerDocument(answer: LoadedContextAnswer, projection: Projection, discoverable: boolean): ContextAnswerDocument;
+/**
+ * Wrap the run's documents in the envelope, with the limits attached ONCE.
+ *
+ * The one place {@link CLAUDE_CONTEXT_LIMITS} and its two companions enter the
+ * machine-readable output. Keeping that a single assignment is what makes the
+ * "stated once" property structural rather than a habit: there is no per-answer
+ * site left where a copy could be reintroduced.
+ *
+ * ⛔ Exported so it can be TESTED alongside {@link answerDocument} — the
+ * regression this guards (an answer growing its own copy of the block) is a
+ * property of the two functions TOGETHER, and a test that can reach only one of
+ * them cannot see it.
+ *
+ * @param root - The corpus root that was enumerated
+ * @param answers - One document per requested path, in the order requested
+ * @returns The envelope, ready to serialize
+ */
+export declare function contextEnvelope(root: string, answers: readonly (ContextAnswerDocument | ContextUnknownDocument)[]): ContextEnvelope;
+/**
+ * What one row costs, or why it costs nothing.
+ *
+ * ⛔ A null token count renders as "size unknown", never as `0`. The `charged`
+ * branch cannot be reached with a null — `chargeOf` classifies those
+ * `unknown-size` first — but the check is written as a value test rather than a
+ * `?? 0`, so if that ever changed the output would say what it knows instead of
+ * asserting a measurement it does not have.
+ *
+ * **Exported solely so that rule can be pinned by a test that would FAIL if a
+ * `?? 0` were introduced.** The property lives in the RENDERER and nowhere else:
+ * an assertion over the json rows only re-states what `account` already
+ * guarantees, and on any real tree every row carries a blob, so such an
+ * assertion compares `false === false` and passes without ever reaching the code
+ * that could print a zero. It is not part of this module's command surface and
+ * nothing outside its own test may call it.
+ *
+ * @param row - The accounted row
+ * @returns The cost phrase
+ */
+export declare function chargeText(row: AccountedRow): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/commands/claude/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/context.ts"],"names":[],"mappings":"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"}