@vibe-agent-toolkit/cli 0.2.0-rc.10 → 0.2.0-rc.12

package/dist/commands/cache/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAA0B,MAAM,YAAY,CAAC;AAGvE,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC,KAAK;SACF,WAAW,CAAC,iEAAiE,CAAC;SAC9E,WAAW,CAAC,KAAK,CAAC;SAClB,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;CAwBL,CACI,CAAC;IAEJ,KAAK;SACF,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gEAAgE,CAAC;SAC7E,MAAM,CAAC,KAAK;QACX,MAAM,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAuB,CAAC,CAAC;IACvE,CAAC,CAAC;SACD,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCL,CACI,CAAC;IAEJ,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAA0B,MAAM,YAAY,CAAC;AAGvE,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC,KAAK;SACF,WAAW,CAAC,iEAAiE,CAAC;SAC9E,WAAW,CAAC,KAAK,CAAC;SAClB,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;CAwBL,CACI,CAAC;IAEJ,KAAK;SACF,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gEAAgE,CAAC;SAC7E,MAAM,CAAC,KAAK;QACX,MAAM,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAuB,CAAC,CAAC;IACvE,CAAC,CAAC;SACD,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CL,CACI,CAAC;IAEJ,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/commands/claude/claude-config.d.ts

@@ -1,20 +1,37 @@
 /**
  * Shared config loading utilities for `vat claude` subcommands.
  */
-import { type ClaudeConfig } from '@vibe-agent-toolkit/resources';
+import type { ClaudeConfig, ProjectConfig } from '@vibe-agent-toolkit/resources';
 export interface LoadedClaudeConfig {
     configPath: string;
     configDir: string;
     claudeConfig: ClaudeConfig;
 }
 /**
- * Find, parse, and return the claude: section of the project config.
- * Throws if the config file cannot be found or parsed.
- * Returns null for claudeConfig when the claude: section is absent.
+ * Find, parse, and return the project config for a `vat claude` verb.
+ * Refuses `CONFIG_INVALID` when no config file is found; a config that cannot
+ * be read or does not parse throws the loader's coded error.
+ *
+ * Parsed by the CLI's `loadConfig` — the reader `claude plugin build` hands
+ * on to the marketplace build — so a verb that loads here and builds there
+ * reads the file once and warns about an unknown key once. It used to parse
+ * through `parseConfigFile` as well, and printed the same warning twice.
+ * `claudeConfig` is undefined when the `claude:` section is absent.
  */
-export declare function loadClaudeProjectConfig(): Promise<{
+export declare function loadClaudeProjectConfig(): {
     configPath: string;
     configDir: string;
+    projectConfig: ProjectConfig | undefined;
     claudeConfig: ClaudeConfig | undefined;
-}>;
+};
+/**
+ * Refuse a `--marketplace <name>` the config does not declare — the
+ * invocation's mistake, like an undeclared `--collection`. A declared
+ * marketplace the verb then has nothing to do with is not this refusal.
+ *
+ * @param requested - The `--marketplace` value, when one was passed
+ * @param declared - The names under `claude.marketplaces`
+ * @throws {CommandRefusalError} `USAGE_INVALID` naming the declared marketplaces
+ */
+export declare function assertMarketplaceDeclared(requested: string | undefined, declared: readonly string[]): void;
 //# sourceMappingURL=claude-config.d.ts.map

package/dist/commands/claude/claude-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-config.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGnF,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;CACxC,CAAC,CAiBD"}
+{"version":3,"file":"claude-config.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAMjF,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC;IACzC,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;CACxC,CAUA;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAM1G"}

package/dist/commands/claude/claude-config.js

@@ -2,27 +2,41 @@
  * Shared config loading utilities for `vat claude` subcommands.
  */
 import { dirname } from 'node:path';
-import { parseConfigFile } from '@vibe-agent-toolkit/resources';
 import { findConfigFile } from '@vibe-agent-toolkit/utils';
+import { CommandRefusalError } from '../../utils/command-refusal.js';
+import { loadConfig } from '../../utils/config-loader.js';
 /**
- * Find, parse, and return the claude: section of the project config.
- * Throws if the config file cannot be found or parsed.
- * Returns null for claudeConfig when the claude: section is absent.
+ * Find, parse, and return the project config for a `vat claude` verb.
+ * Refuses `CONFIG_INVALID` when no config file is found; a config that cannot
+ * be read or does not parse throws the loader's coded error.
+ *
+ * Parsed by the CLI's `loadConfig` — the reader `claude plugin build` hands
+ * on to the marketplace build — so a verb that loads here and builds there
+ * reads the file once and warns about an unknown key once. It used to parse
+ * through `parseConfigFile` as well, and printed the same warning twice.
+ * `claudeConfig` is undefined when the `claude:` section is absent.
  */
-export async function loadClaudeProjectConfig() {
-    // findConfigFile from utils is synchronous; await of a non-promise is a no-op.
+export function loadClaudeProjectConfig() {
     const configPath = findConfigFile(process.cwd());
     if (!configPath) {
-        throw new Error('No vibe-agent-toolkit.config.yaml found. Run from a project directory.');
+        throw new CommandRefusalError('CONFIG_INVALID', 'No vibe-agent-toolkit.config.yaml found. Run from a project directory.');
     }
-    // No `onUnknownKeys` argument: `parseConfigFile` already DEFAULTS to writing
-    // the warning to stderr, which is exactly what this lane needs — unknown keys
-    // are a warning rather than a refusal, and stderr keeps the YAML document on
-    // stdout machine-readable. Passing a callback byte-identical to the default
-    // said "this command has an opinion here" while changing nothing, so a later
-    // reader would have to diff it against the default to learn it was dead.
-    const config = await parseConfigFile(configPath);
     const configDir = dirname(configPath);
-    return { configPath, configDir, claudeConfig: config.claude };
+    const projectConfig = loadConfig(configDir, 'source');
+    return { configPath, configDir, projectConfig, claudeConfig: projectConfig?.claude };
+}
+/**
+ * Refuse a `--marketplace <name>` the config does not declare — the
+ * invocation's mistake, like an undeclared `--collection`. A declared
+ * marketplace the verb then has nothing to do with is not this refusal.
+ *
+ * @param requested - The `--marketplace` value, when one was passed
+ * @param declared - The names under `claude.marketplaces`
+ * @throws {CommandRefusalError} `USAGE_INVALID` naming the declared marketplaces
+ */
+export function assertMarketplaceDeclared(requested, declared) {
+    if (requested === undefined || declared.includes(requested))
+        return;
+    throw new CommandRefusalError('USAGE_INVALID', `Marketplace "${requested}" is not declared in claude.marketplaces (declared: ${declared.length === 0 ? 'none' : declared.join(', ')}).`);
 }
 //# sourceMappingURL=claude-config.js.map

package/dist/commands/claude/claude-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude-config.js","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAqB,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAQ3D;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB;IAK3C,+EAA+E;IAC/E,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;IAC5F,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,6EAA6E;IAC7E,yEAAyE;IACzE,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEtC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAChE,CAAC"}
+{"version":3,"file":"claude-config.js","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ1D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB;IAMrC,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,wEAAwE,CAAC,CAAC;IAC5H,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,aAAa,GAAG,UAAU,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAEtD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,CAAC;AACvF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CAAC,SAA6B,EAAE,QAA2B;IAClG,IAAI,SAAS,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO;IACpE,MAAM,IAAI,mBAAmB,CAC3B,eAAe,EACf,gBAAgB,SAAS,uDAAuD,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CACzI,CAAC;AACJ,CAAC"}

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

@@ -5,8 +5,19 @@
  * 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.
+ * this file, and the only non-zero exit is a refusal's 2. A number that fails a
+ * build teaches people to stop reading it.
+ *
+ * ## The one legacy document — interim, until wave C replaces the verb
+ *
+ * Its answer is not the `Report<T>` envelope; it is the registry's one
+ * remaining `legacy` entry, published through the writer's
+ * `writeLegacyDocument` (the only serializer a legacy verb may use) and ended on
+ * `ExitCode.OK`. A refusal IS the envelope's error branch — `refusalReport`,
+ * with the code {@link refusalCodeOf} reads off the throw (a path outside the
+ * corpus is `USAGE_INVALID`, a missing projection backend `BACKEND_UNAVAILABLE`,
+ * VAT's own defect `INTERNAL_ERROR`) — written the same way and ended on the
+ * code it derives. Wave C replaces the verb, and this path with it.
  *
  * ## Everything below is orchestration and formatting — deliberately
  *
@@ -237,6 +248,18 @@ export declare function createContextCommand(): Command;
  * @param options - The command's flags
  */
 export declare function claudeContextCommand(pathArgs: readonly string[], options: ClaudeContextOptions): Promise<void>;
+/**
+ * The paths a run answers for, checked before anything is populated.
+ *
+ * `--all` answers the whole tree and emits no per-path document, so a path or
+ * `--discoverable` beside it would be silently dropped: refused instead.
+ *
+ * @param root - The corpus root
+ * @param pathArgs - The path arguments, possibly empty
+ * @param options - The command's flags
+ * @returns The root-relative targets; empty under `--all`
+ */
+declare function requestedTargets(root: string, pathArgs: readonly string[], options: ClaudeContextOptions): string[];
 /**
  * The answer document for one query.
  *
@@ -293,6 +316,21 @@ export declare function contextEnvelope(root: string, answers: readonly (Context
  * @returns The envelope, ready to serialize
  */
 export declare function costMapEnvelope(root: string, costMap: ContextCostMap): ContextCostMapEnvelope;
+/**
+ * Render every answer for a person, with the limits stated exactly once.
+ *
+ * ⛔ The limits are printed ONCE, after the last answer, rather than per answer.
+ * They are properties of the MEASUREMENT METHOD, not of any one path, so
+ * repeating them per path would read as though each answer carried its own
+ * caveats — and across a many-path run would bury the answers under identical
+ * paragraphs. A run with no answered path prints no limits at all, for the same
+ * reason {@link unknownDocumentFor} omits them: nothing was measured, so there is
+ * no measurement to bound.
+ *
+ * @param documents - The answers, in requested order
+ * @returns The text rendering, newline-terminated
+ */
+export declare function renderEnvelopeText(documents: readonly (ContextAnswerDocument | ContextUnknownDocument)[]): string;
 /**
  * Render the `--all` cost map for a person: where in this tree it is expensive
  * to work.
@@ -316,6 +354,35 @@ export declare function costMapEnvelope(root: string, costMap: ContextCostMap):
  * @returns The text rendering, newline-terminated
  */
 export declare function renderCostMapText(map: ContextCostMap): string;
+/**
+ * The non-answer, spelled so it cannot be mistaken for an empty answer.
+ *
+ * ⛔ **A non-answer publishes no measurement, in every format.** No `totals`, no
+ * `rows`: nothing was measured here, so anything readable as a figure would
+ * assert that a measurement happened, which is the exact confusion `kind:
+ * 'unknown'` exists to prevent. The limits are one level up on the ENVELOPE and
+ * bound the run's method, not this path — a sweep whose every path was
+ * unrealized still measured nothing, and the `explanation` carries the only
+ * caveat that applies to a non-answer, which is that there is no answer.
+ *
+ * @param input - The path that was asked about
+ * @param root - The corpus root that was enumerated
+ * @returns The unknown document
+ */
+declare function unknownDocumentFor(input: string, root: string): ContextUnknownDocument;
+/**
+ * Render the non-answer for a person.
+ *
+ * @param document - The unknown document
+ * @returns The text rendering, newline-terminated
+ */
+declare function renderUnknownText(document: ContextUnknownDocument): string;
+/** Test seam: the non-answer's document and its text rendering. */
+export declare const __internal: {
+    renderUnknownText: typeof renderUnknownText;
+    requestedTargets: typeof requestedTargets;
+    unknownDocumentFor: typeof unknownDocumentFor;
+};
 /**
  * What one row costs, or why it costs nothing.
  *
@@ -337,4 +404,22 @@ export declare function renderCostMapText(map: ContextCostMap): string;
  * @returns The cost phrase
  */
 export declare function chargeText(row: AccountedRow): string;
+/**
+ * One condition — the compact `severity code at location: message` line, an
+ * indented `subject:` naming the refused or escaping TARGET when one differs
+ * from `location` (never for `CLOSURE_REFERENCE_UNRESOLVED`, which has none),
+ * an indented `why:` explaining which harness loader rule makes it so, and,
+ * when {@link GradedCondition.affects} names one, a `reached from:` line
+ * tracing the import chain that reaches it.
+ *
+ * Exported for `context-condition-line.test.ts`, the same reason
+ * {@link chargeText} is: the only code that renders these lines, so it is what
+ * a unit test pins rather than a system assertion over a real tree's own
+ * conditions (which may carry none of the shapes this needs to distinguish).
+ *
+ * @param condition - The graded condition
+ * @returns The lines, newline-joined — one {@link listSection} entry
+ */
+export declare function conditionLine(condition: GradedCondition): string;
+export {};
 //# sourceMappingURL=context.d.ts.map

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

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

package/dist/commands/claude/context.js

@@ -5,8 +5,19 @@
  * 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.
+ * this file, and the only non-zero exit is a refusal's 2. A number that fails a
+ * build teaches people to stop reading it.
+ *
+ * ## The one legacy document — interim, until wave C replaces the verb
+ *
+ * Its answer is not the `Report<T>` envelope; it is the registry's one
+ * remaining `legacy` entry, published through the writer's
+ * `writeLegacyDocument` (the only serializer a legacy verb may use) and ended on
+ * `ExitCode.OK`. A refusal IS the envelope's error branch — `refusalReport`,
+ * with the code {@link refusalCodeOf} reads off the throw (a path outside the
+ * corpus is `USAGE_INVALID`, a missing projection backend `BACKEND_UNAVAILABLE`,
+ * VAT's own defect `INTERNAL_ERROR`) — written the same way and ended on the
+ * code it derives. Wave C replaces the verb, and this path with it.
  *
  * ## Everything below is orchestration and formatting — deliberately
  *
@@ -59,21 +70,22 @@
  * one, and the same reasoning is why an unrealized path answers `unknown` rather
  * than an empty table.
  */
-import { account, buildClaudeContextPopulation, buildContextCostMap, CLAUDE_CONTEXT_BOUNDS_STATEMENT, CLAUDE_CONTEXT_LIMITS, CLAUDE_CONTEXT_MODELLED_BEHAVIOURS, CLAUDE_MD_TAG, discoverableFrom, whatLoadsAt, } from '@vibe-agent-toolkit/resources';
-import { ExitCode } from '@vibe-agent-toolkit/schema';
+import { account, buildClaudeContextPopulation, buildContextCostMap, CLAUDE_CONTEXT_BOUNDS_STATEMENT, CLAUDE_CONTEXT_LIMITS, CLAUDE_CONTEXT_MODELLED_BEHAVIOURS, discoverableFrom, whatLoadsAt, } from '@vibe-agent-toolkit/resources';
+import { ExitCode, exitCodeForReport } 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 { CommandRefusalError, refusalCodeOf } from '../../utils/command-refusal.js';
 import { targetPathWithin } from '../../utils/corpus-target.js';
+import { NOTHING_FINISHED, refusalReport, writeLegacyDocument } from '../../utils/document-writer.js';
 import { createLogger } from '../../utils/logger.js';
-import { writeJsonOutput, writeStdoutSync, writeYamlOutput } from '../../utils/output.js';
-import { populationWiring } from '../../utils/population-wiring.js';
+import { populateAndReport } from '../../utils/population-wiring.js';
 import { withPopulationCache } from '../../utils/projection-store.js';
-import { gitTrackerForProjectRoot } from '../audit/distributed-tree.js';
 /** Soft wrap width for the printed limit statements. */
 const WRAP_COLUMNS = 96;
 /** How this command names itself in a refusal. */
 const COMMAND_NAME = 'vat claude context';
+/** `vat claude context` never gates: there is no `--strict`, and no threshold to apply one to. */
+const CLAUDE_CONTEXT_GATE = { strict: false };
 /**
  * How many rows each RANKED section of the `--all` cost map prints.
  *
@@ -155,8 +167,8 @@ Description:
   the TOTAL of that launch floor and what fires on demand there (a path-scoped
   rule fires for some directories and not others, so the on-demand half is
   never borrowed from a region-mate). Directories are ranked by that total. It
-  emits no per-path documents; name paths for those. --discoverable applies to
-  named paths only.
+  emits no per-path documents; name paths for those. --all with a path or
+  with --discoverable (which applies to named paths only) is refused.
 
 Output:
   - kind:    context-answers for named paths, context-cost-map for --all —
@@ -182,10 +194,22 @@ Output:
   A path the projection never realized answers kind: unknown — never zero.
   Diagnostics and blob-stage refusals go to stderr; stdout is the document.
 
+  A refusal publishes the report envelope's error branch (status: error,
+  error: { code, message }, gate) in the requested format (text renders it
+  as YAML), with the message on stderr.
+
 Exit Codes:
   0 - An answer was produced (there is no threshold and no gate)
-  1 - Invalid usage (unknown option, or an unsupported --format value)
-  2 - System error (a path outside the corpus root, unreadable tree)
+  2 - Invalid usage rejected before the verb runs (an unknown option, or an
+      unsupported --format value: Commander's message on stderr, no document),
+      or refused: error.code USAGE_INVALID (a path outside the corpus root,
+      or --all with a path or --discoverable),
+      BACKEND_UNAVAILABLE (the projection store's optional backend is not
+      installed), INPUT_UNREADABLE (a tree the OS will not read, including
+      one file in a git repository the OS will not let git read — the
+      message names it), or
+      INTERNAL_ERROR (a VAT bug, e.g. a memory file reached with no derived
+      harness facts — its stack goes to stderr)
 
 Example:
   $ vat claude context src/index.ts docs/ README.md   # one scan, three answers
@@ -206,17 +230,16 @@ Example:
  */
 export async function claudeContextCommand(pathArgs, options) {
     const logger = createLogger(options.debug === true ? { debug: true } : {});
-    const startTime = Date.now();
     const sweep = options.all === true;
+    const format = options.format ?? 'text';
     try {
         const root = findProjectRoot(process.cwd()) ?? process.cwd();
         // 🔑 Every argument is resolved BEFORE the population, not inside the map.
         // 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. `--all` has no arguments to check.
-        const requested = sweep ? [] : targetsWithin(root, pathArgs);
+        // be told they mistyped.
+        const requested = requestedTargets(root, pathArgs, options);
         const projection = await populateContext(root, logger);
-        const format = options.format ?? 'text';
         if (sweep) {
             // Every number in the map is decided in `@vibe-agent-toolkit/resources`.
             // This branch calls one function and formats what it returns.
@@ -230,16 +253,40 @@ export async function claudeContextCommand(pathArgs, options) {
             const answers = requested.map((target) => documentFor(target, projection, root, options.discoverable === true));
             emit(contextEnvelope(root, answers), renderEnvelopeText(answers), format);
         }
-        // ⛔ Always 0. There is no threshold in this command and there is not going
-        // to be one — a number that fails a build is a number people learn to stop
-        // reading. The explicit exit matches every other leaf here and guarantees the
-        // process ends rather than waiting on whatever the population left behind.
+        // ⛔ Always 0 for an answer. There is no threshold in this command and there
+        // is not going to be one — a number that fails a build is a number people
+        // learn to stop reading. The explicit exit guarantees the process ends rather
+        // than waiting on whatever the population left behind.
         process.exit(ExitCode.OK);
     }
     catch (error) {
-        handleCommandError(error, logger, startTime, 'claude context', options.format);
+        // Coded at the cause, read here — never relabelled by where it was thrown.
+        const report = refusalReport(refusalCodeOf(error), error, CLAUDE_CONTEXT_GATE, NOTHING_FINISHED);
+        writeLegacyDocument('claude context', report, format, undefined);
+        process.exit(exitCodeForReport(report));
     }
 }
+/**
+ * The paths a run answers for, checked before anything is populated.
+ *
+ * `--all` answers the whole tree and emits no per-path document, so a path or
+ * `--discoverable` beside it would be silently dropped: refused instead.
+ *
+ * @param root - The corpus root
+ * @param pathArgs - The path arguments, possibly empty
+ * @param options - The command's flags
+ * @returns The root-relative targets; empty under `--all`
+ */
+function requestedTargets(root, pathArgs, options) {
+    if (options.all !== true)
+        return targetsWithin(root, pathArgs);
+    const ignored = [...pathArgs, ...(options.discoverable === true ? ['--discoverable'] : [])];
+    if (ignored.length > 0) {
+        throw new CommandRefusalError('USAGE_INVALID', `--all reports the whole tree and answers no named path, so it cannot take ${ignored.join(', ')}.`
+            + ' Drop --all to answer for named paths (with --discoverable if wanted), or drop the rest for the cost map.');
+    }
+    return [];
+}
 /**
  * The answer document for one query.
  *
@@ -261,12 +308,9 @@ export async function claudeContextCommand(pathArgs, options) {
  * @returns The answer document
  */
 export function answerDocument(answer, projection, discoverable) {
-    // The cliff and root discovery read ONE vocabulary: these are the ids the
-    // shipped `classifyPath` tagged, not a second basename rule invented here.
-    const claudeMdIds = new Set(projection.resourceTags
-        .filter((tag) => tag.tag === CLAUDE_MD_TAG)
-        .map((tag) => tag.resourceId));
-    const accounted = account(answer, claudeMdIds);
+    // The cliff applies to every memory file the harness reads, so the
+    // accounting needs no tag vocabulary from here.
+    const accounted = account(answer);
     // 🔑 `conditions`, `overBudgetRules` and `unattributedImports` live on the
     // ORIGINAL answer — `AccountedContext` is `{rows, totals}` and nothing else.
     // Reading them off the accounting result silently drops every warning.
@@ -386,7 +430,7 @@ function documentFor(target, projection, root, discoverable) {
  * @param documents - The answers, in requested order
  * @returns The text rendering, newline-terminated
  */
-function renderEnvelopeText(documents) {
+export function renderEnvelopeText(documents) {
     const bodies = documents.map((document) => document.kind === 'unknown' ? renderUnknownText(document) : renderAnswerText(document));
     const measured = documents.some((document) => document.kind === 'answer');
     if (!measured)
@@ -688,34 +732,26 @@ function groupDigits(value) {
  * Populate the Claude-context lane for one tree.
  *
  * @param root - The absolute corpus root
- * @param logger - Where blob-stage refusals go. **stderr**, never stdout: this
- *   command's stdout is the document a caller parses, and a diagnostic in the
- *   middle of it breaks every consumer
+ * @param logger - Where the population's refused content is reported. **stderr**,
+ *   never stdout: this command's stdout is the document a caller parses
  * @returns The populated projection
  */
-async function populateContext(root, logger) {
+function populateContext(root, logger) {
     return withPopulationCache({ root }, async (cache) => {
-        const gitTracker = await gitTrackerForProjectRoot(root);
-        return buildClaudeContextPopulation({ root, ...populationWiring(logger, gitTracker, cache, root) });
+        const { projection } = await populateAndReport({ root, cache, logger, population: 'claude-context' }, (wiring) => buildClaudeContextPopulation({ root, ...wiring }), (result) => result.projection);
+        return projection;
     });
 }
 /**
- * Write the document in the requested format.
+ * Publish the answer through the writer's one legacy serializer: the text
+ * rendering under `--format text`, the document itself otherwise.
  *
  * @param document - The yaml/json payload
  * @param text - The text rendering of the same answer
  * @param format - The selected format
  */
 function emit(document, text, format) {
-    if (format === 'json') {
-        writeJsonOutput(document);
-        return;
-    }
-    if (format === 'yaml') {
-        writeYamlOutput(document);
-        return;
-    }
-    writeStdoutSync(text);
+    writeLegacyDocument('claude context', document, format, text);
 }
 /**
  * The non-answer, spelled so it cannot be mistaken for an empty answer.
@@ -756,6 +792,8 @@ function renderUnknownText(document) {
         '',
     ].join('\n');
 }
+/** Test seam: the non-answer's document and its text rendering. */
+export const __internal = { renderUnknownText, requestedTargets, unknownDocumentFor };
 /**
  * Render the answer for a person.
  *
@@ -769,7 +807,7 @@ function renderAnswerText(document) {
         ...rowSection('Loaded at launch (always)', document.rows, 'always'),
         ...rowSection('Loaded on demand', document.rows, 'on-demand'),
         ...listSection('Conditions', document.conditions.map(conditionLine)),
-        ...listSection('Rules whose paths: list exceeded the vendor pattern budget', document.overBudgetRules),
+        ...listSection('Rules with a paths: pattern the vendor expansion budget refused (their other patterns still apply)', document.overBudgetRules),
         ...listSection('Imported files no importer could be attributed to', document.unattributedImports),
         ...discoverySection(document.discoverable),
     ];
@@ -856,6 +894,11 @@ function estimateLines(totals) {
         'Token estimate',
         `  always-loaded         ${groupDigits(totals.alwaysTokens)} tokens`,
         `  on-demand             ${groupDigits(totals.onDemandTokens)} tokens`,
+        // Already folded into the two lines above — every row's own header, and the
+        // once-per-launch preamble on top of them — printed separately so a reader
+        // sees how much of the total is RENDERING rather than content.
+        `  of which: headers     ${groupDigits(totals.headerTokens)} tokens`
+            + ` · preamble ${groupDigits(totals.preambleTokens)} tokens (both already counted above)`,
         // ⛔ UNCONDITIONAL here, unlike a region's — see {@link quietCounterLines}.
         // A single-path answer has no tree-level roll-up to fall back on, so these
         // three lines are its only statement that the rows were counted at all.
@@ -968,28 +1011,44 @@ function describeImport(admission) {
         + ` (closure rooted at ${admission.rootPath})`;
 }
 /**
- * One condition, in the compact `severity code at location: message` shape.
+ * One condition — the compact `severity code at location: message` line, an
+ * indented `subject:` naming the refused or escaping TARGET when one differs
+ * from `location` (never for `CLOSURE_REFERENCE_UNRESOLVED`, which has none),
+ * an indented `why:` explaining which harness loader rule makes it so, and,
+ * when {@link GradedCondition.affects} names one, a `reached from:` line
+ * tracing the import chain that reaches it.
+ *
+ * Exported for `context-condition-line.test.ts`, the same reason
+ * {@link chargeText} is: the only code that renders these lines, so it is what
+ * a unit test pins rather than a system assertion over a real tree's own
+ * conditions (which may carry none of the shapes this needs to distinguish).
  *
  * @param condition - The graded condition
- * @returns The line
+ * @returns The lines, newline-joined — one {@link listSection} entry
  */
-function conditionLine(condition) {
-    const reference = condition.sourceRef === null ? '' : ` [${condition.sourceRef}]`;
-    return `  ${condition.severity.padEnd(7)} ${condition.code}`
-        + ` at ${conditionLocation(condition)}${reference}: ${condition.message}`;
+export function conditionLine(condition) {
+    const reference = condition.ref === null ? '' : ` [${condition.ref}]`;
+    const lines = [
+        `  ${condition.severity.padEnd(7)} ${condition.code}`
+            + ` at ${conditionLocation(condition)}${reference}: ${condition.message}`,
+    ];
+    if (condition.subject !== null) {
+        lines.push(`      subject: ${condition.subject}`);
+    }
+    lines.push(`      why: ${condition.why}`);
+    if (condition.affects !== null) {
+        lines.push(`      reached from: ${condition.affects.chain.join(' → ')} (hop ${condition.affects.hop})`);
+    }
+    return lines.join('\n');
 }
 /**
- * Where a condition points, using the most specific provenance it carries.
+ * Where a condition points.
  *
  * @param condition - The graded condition
  * @returns A path, or a `path:line`
  */
 function conditionLocation(condition) {
-    if (condition.sourcePath === null)
-        return condition.path;
-    if (condition.sourceLine === null)
-        return condition.sourcePath;
-    return `${condition.sourcePath}:${condition.sourceLine}`;
+    return condition.line === null ? condition.path : `${condition.path}:${condition.line}`;
 }
 /**
  * A heading plus its lines, or nothing at all when there are none.