@productbrain/cli 0.1.0-beta.47 → 0.1.0-beta.4721

package/dist/__tests__/verify-formatter.test.js

@@ -0,0 +1,85 @@
+/**
+ * formatVerifyReceipt — honest qualifier on verify receipts (WP-A T8).
+ * Chain: attestation-model spec §5 (connectors never re-derive), §11 (rollout: optional fields).
+ */
+import { describe, it, expect } from 'vitest';
+import { formatVerifyReceipt } from '../formatters/verify.js';
+describe('formatVerifyReceipt', () => {
+    it('shows the honest qualifier', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: false,
+            verifiedBy: 'agent for Randy Hereman',
+            attestation: { strength: 'delegated' },
+        })).toBe('Verified TEN-1 — by agent for Randy Hereman (delegated).');
+    });
+    it('already-verified names the standing record', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: true,
+            verifiedBy: 'Randy Hereman',
+            attestation: { strength: 'human-direct' },
+        })).toBe('TEN-1 is already verified — by Randy Hereman (human-direct).');
+    });
+    it('falls back to the bare form when the server has no attestation data (old server, spec §11)', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: false,
+        })).toBe('Verified TEN-1.');
+    });
+    it('bare already-verified form when attestation data is absent', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: true,
+        })).toBe('TEN-1 is already verified.');
+    });
+    // Finding 1 (PR #341 review): a non-'attested' basis (the pre-branch legacy corpus)
+    // must render as a qualifier, never as "— by <legacy string>" — the shipped
+    // verifiedBy is already the resolved legacy string ("legacy — unclassified"), and
+    // rendering it after "by" reintroduces the misleading "by <person>" phrasing that
+    // formatEntry (formatters/entry.ts) explicitly avoids for legacy bases.
+    it('renders the honest legacy qualifier when basis is not attested', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: false,
+            verifiedBy: 'legacy — unclassified',
+            attestation: { strength: 'delegated', basis: 'legacy-unclassified' },
+        })).toBe('Verified TEN-1 (legacy — unclassified).');
+    });
+    it('already-verified legacy basis renders the same qualifier form', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: true,
+            verifiedBy: 'legacy — unclassified',
+            attestation: { strength: 'delegated', basis: 'legacy-unclassified' },
+        })).toBe('TEN-1 is already verified (legacy — unclassified).');
+    });
+    // Finding 2 (PR #341 review): verifiedBy is a server-provided string that may carry
+    // a workspace member's displayName/email — sanitize it the same way every other
+    // user-controlled string reaching the terminal is sanitized (BET-269 C3).
+    it('strips control/ANSI chars from verifiedBy before printing', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: false,
+            verifiedBy: 'Evil\x1b[31mName',
+            attestation: { strength: 'human-direct' },
+        })).toBe('Verified TEN-1 — by EvilName (human-direct).');
+    });
+    it('strips control/ANSI chars from the legacy verifiedBy qualifier too', () => {
+        expect(formatVerifyReceipt({
+            entryId: 'TEN-1',
+            verificationStatus: 'verified',
+            alreadyVerified: false,
+            verifiedBy: 'legacy\x1b[31m — unclassified',
+            attestation: { strength: 'delegated', basis: 'legacy-unclassified' },
+        })).toBe('Verified TEN-1 (legacy — unclassified).');
+    });
+});
+//# sourceMappingURL=verify-formatter.test.js.map

package/dist/__tests__/verify-formatter.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-formatter.test.js","sourceRoot":"","sources":["../../src/__tests__/verify-formatter.test.ts"],"names":[],"mappings":"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"}

package/dist/__tests__/vocabulary-leak.test.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Vocabulary leak test — WP-436 S2 + TEN-2053 S2 (PAT-229, DEC-1021).
+ *
+ * Asserts two classes of regression are absent from user-facing CLI/MCP output:
+ *
+ *   1. **Workspace-vocab leaks** (`bet`/`BET`) — caught when the workspace
+ *      vocabulary is overridden to non-bet labels. Any literal "bet"/"BET"
+ *      outside stored entry IDs means a label resolver was bypassed.
+ *
+ *   2. **Stale governance-ID leaks** (TEN-2053 S2) — bare governance-ID
+ *      prefixes without digits (e.g. typo'd "STD-" with no number, or
+ *      "DEC-foo"). Stored entry IDs (`STD-113`, `DEC-1021`, etc.) are
+ *      stripped BEFORE the leak check, so legitimate IDs don't false-
+ *      positive. We do NOT treat Product Brain Method vocabulary as a leak
+ *      (`Chain`, `Constellation`, `SSOT`, `shaping`, `handoff`, `gates`,
+ *      `verdict`, `blocking`, `advisory` are the product — not jargon).
+ *      The real leak class is OUR entry IDs (specific to our team's chain)
+ *      surfacing in customer-facing output.
+ *
+ * Coverage:
+ *   ALL_FIXTURES × { formatOrient, formatOrientBrief, formatSearchResults,
+ *                    formatCaptureReceipt, formatAudit (PASS/FAIL/verbose) }
+ *   plus runOrient end-to-end command wiring.
+ *
+ * MCP-side note: the MCP markdown response in
+ * `packages/mcp-server/src/tools/audit.ts:handleAuditRun` is structurally
+ * identical to `formatAudit` here — kept in sync by manual review; no
+ * dedicated MCP audit test currently exists (`find packages/mcp-server -name
+ * "*.test.ts" -path "*audit*"` returns empty as of TEN-2053 S2).
+ *
+ * Whitelist: stored entry IDs matching /\b[A-Z]+-\d+\b/ (e.g. WP-436, BET-42,
+ * DEC-1021) are stripped before the leak check — they're stable database
+ * references, not vocabulary labels.
+ *
+ * Perf: fixture workspaces are seeded purely in-memory (no Convex, no HTTP).
+ * BET-241: no fixture has >100 entries.
+ */
+export {};
+//# sourceMappingURL=vocabulary-leak.test.d.ts.map

package/dist/__tests__/vocabulary-leak.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabulary-leak.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/vocabulary-leak.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG"}

package/dist/__tests__/vocabulary-leak.test.js

@@ -0,0 +1,539 @@
+/**
+ * Vocabulary leak test — WP-436 S2 + TEN-2053 S2 (PAT-229, DEC-1021).
+ *
+ * Asserts two classes of regression are absent from user-facing CLI/MCP output:
+ *
+ *   1. **Workspace-vocab leaks** (`bet`/`BET`) — caught when the workspace
+ *      vocabulary is overridden to non-bet labels. Any literal "bet"/"BET"
+ *      outside stored entry IDs means a label resolver was bypassed.
+ *
+ *   2. **Stale governance-ID leaks** (TEN-2053 S2) — bare governance-ID
+ *      prefixes without digits (e.g. typo'd "STD-" with no number, or
+ *      "DEC-foo"). Stored entry IDs (`STD-113`, `DEC-1021`, etc.) are
+ *      stripped BEFORE the leak check, so legitimate IDs don't false-
+ *      positive. We do NOT treat Product Brain Method vocabulary as a leak
+ *      (`Chain`, `Constellation`, `SSOT`, `shaping`, `handoff`, `gates`,
+ *      `verdict`, `blocking`, `advisory` are the product — not jargon).
+ *      The real leak class is OUR entry IDs (specific to our team's chain)
+ *      surfacing in customer-facing output.
+ *
+ * Coverage:
+ *   ALL_FIXTURES × { formatOrient, formatOrientBrief, formatSearchResults,
+ *                    formatCaptureReceipt, formatAudit (PASS/FAIL/verbose) }
+ *   plus runOrient end-to-end command wiring.
+ *
+ * MCP-side note: the MCP markdown response in
+ * `packages/mcp-server/src/tools/audit.ts:handleAuditRun` is structurally
+ * identical to `formatAudit` here — kept in sync by manual review; no
+ * dedicated MCP audit test currently exists (`find packages/mcp-server -name
+ * "*.test.ts" -path "*audit*"` returns empty as of TEN-2053 S2).
+ *
+ * Whitelist: stored entry IDs matching /\b[A-Z]+-\d+\b/ (e.g. WP-436, BET-42,
+ * DEC-1021) are stripped before the leak check — they're stable database
+ * references, not vocabulary labels.
+ *
+ * Perf: fixture workspaces are seeded purely in-memory (no Convex, no HTTP).
+ * BET-241: no fixture has >100 entries.
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { formatOrient, formatOrientBrief } from '../formatters/orient.js';
+import { formatSearchResults } from '../formatters/search.js';
+import { formatCaptureReceipt } from '../formatters/capture.js';
+import { formatAudit } from '../formatters/audit.js';
+import { clearVocabCache } from '../lib/workspaceVocabCache.js';
+// ─── Fixture workspace vocabulary contexts ────────────────────────────────────
+/**
+ * Fixture A — Generic Item workspace.
+ * work_package.singular = "Item", plural = "Items".
+ * Any "bet"/"BET" in output (outside stored IDs) is a leak.
+ */
+const GENERIC_ITEM_CTX = {
+    collectionLabels: {
+        work_package: {
+            singular: 'Item',
+            plural: 'Items',
+            verb_start: 'create',
+            verb_commit: 'commit',
+            verb_complete: 'archive',
+        },
+    },
+};
+/**
+ * Fixture B — Linear Project workspace.
+ * work_package.singular = "Project", plural = "Projects".
+ */
+const LINEAR_PROJECT_CTX = {
+    collectionLabels: {
+        work_package: {
+            singular: 'Project',
+            plural: 'Projects',
+            verb_start: 'start',
+            verb_commit: 'commit',
+            verb_complete: 'complete',
+        },
+    },
+};
+/**
+ * Fixture C — Initiative workspace.
+ * work_package.singular = "Initiative", plural = "Initiatives".
+ */
+const INITIATIVE_CTX = {
+    collectionLabels: {
+        work_package: {
+            singular: 'Initiative',
+            plural: 'Initiatives',
+            verb_start: 'launch',
+            verb_commit: 'commit',
+            verb_complete: 'close',
+        },
+    },
+};
+/**
+ * Fixture D — Defaults-only workspace (Layer 2 regression guard).
+ * NO collectionLabels (no workspace override). Only collectionDefaults
+ * populated — mirrors what a real workspace looks like AFTER the
+ * seedCollectionLabels migration but BEFORE any methodology preset.
+ *
+ * INS-1446: this fixture catches the class of regression where consumers
+ * drop collectionDefaults from the vocab response and Layer 2 goes dead.
+ */
+const DEFAULTS_ONLY_CTX = {
+    collectionDefaults: {
+        work_package: {
+            singular: 'Bet',
+            plural: 'Bets',
+            verb_start: 'shape',
+            verb_commit: 'commit',
+            verb_complete: 'ship',
+        },
+    },
+};
+/**
+ * skipLeakCheck: true — fixture labels themselves contain "bet" (correct resolved
+ * output), so assertNoBetLeak would false-positive. These fixtures still exercise
+ * the positive label resolution check; leak tests are covered by the separate
+ * "defaults-only" command-level tests below.
+ */
+const ALL_FIXTURES = [
+    { name: 'Generic Item', ctx: GENERIC_ITEM_CTX },
+    { name: 'Linear Project', ctx: LINEAR_PROJECT_CTX },
+    { name: 'Initiative', ctx: INITIATIVE_CTX },
+    { name: 'Defaults-only (Bet)', ctx: DEFAULTS_ONLY_CTX, skipLeakCheck: true },
+];
+// ─── Shared test fixtures ─────────────────────────────────────────────────────
+/** Typical orient view with some active work packages. Perf: <100 entries (BET-241). */
+const ORIENT_VIEW = {
+    stage: 'grounded',
+    strategicContext: {
+        vision: 'Build the best product knowledge system',
+        purpose: 'Make knowledge work for everyone',
+        activeBetCount: 2,
+        currentWorkPackage: 'WP-100',
+        activeTensionCount: 1,
+        productAreas: ['Growth'],
+        productAreaCount: 1,
+    },
+    activeWorkPackages: [
+        { entryId: 'WP-100', name: 'Ship vocabulary foundation', collectionSlug: 'work-packages', status: 'active' },
+        { entryId: 'WP-101', name: 'Build orient view', collectionSlug: 'work-packages', status: 'active' },
+    ],
+    governance: {
+        principles: [],
+        standards: [],
+        businessRules: [],
+    },
+    tensions: [],
+    architectureNotes: [],
+    proposals: [],
+    absenceSignals: [],
+    plannedWork: {
+        uncommittedDrafts: [],
+        inProgressEntries: [],
+        openTensions: [],
+    },
+    priorSessions: [],
+    recoveryBlock: null,
+};
+// ─── Leak detection utility ───────────────────────────────────────────────────
+/**
+ * Strip stored entry IDs from output before checking for leaks.
+ * Whitelist: /\b[A-Z]+-\d+\b/ (e.g. WP-100, BET-42, DEC-1021).
+ * These are stable DB references, not vocabulary labels.
+ */
+function stripStoredIds(output) {
+    return output.replace(/\b[A-Z]+-\d+\b/g, '<<ENTRYID>>');
+}
+/**
+ * Assert no literal bet/BET in output (outside stored entry IDs).
+ * We check both lowercase `bet` and uppercase `BET` as word-boundary matches.
+ */
+function assertNoBetLeak(output, fixture, surface) {
+    const stripped = stripStoredIds(output);
+    const hasBetLeak = /\bbet\b/i.test(stripped);
+    if (hasBetLeak) {
+        // Find the first match for a helpful error message
+        const match = stripped.match(/\bbet\b/i);
+        const idx = match?.index ?? 0;
+        const context = stripped.slice(Math.max(0, idx - 30), idx + 50);
+        throw new Error(`[vocabulary-leak] Literal "bet" found in "${fixture}" workspace, "${surface}" surface.\n` +
+            `Context: ...${context}...\n` +
+            `Full output (stripped IDs):\n${stripped}`);
+    }
+}
+/**
+ * Stale governance-ID leak patterns (TEN-2053 S2).
+ *
+ * After `stripStoredIds()` replaces /\b[A-Z]+-\d+\b/ with <<ENTRYID>>, the
+ * only residue we treat as a leak is a bare governance prefix WITHOUT digits
+ * — i.e. someone wrote `STD-foo` or `DEC-something` in free-form text, not
+ * a real entry reference. Real IDs (STD-113, DEC-1021) are stripped before
+ * this check.
+ *
+ * PBM concepts (Chain, Constellation, SSOT, shaping, handoff, gates, verdict)
+ * are intentionally NOT treated as leaks — they are the product's vocabulary.
+ * Workspace-vocab values (bet/Bet/work_package) are covered by
+ * `assertNoBetLeak` above.
+ */
+const GOVERNANCE_LEAK_PATTERNS = [
+    // Bare governance prefix not followed by a digit (catches typos like "STD-foo"
+    // or "DEC- something"). Stripped IDs (<<ENTRYID>>) are already replaced and
+    // won't match this pattern.
+    { name: 'bare governance prefix', re: /\b(STD|DEC|INS|TEN|BET|WP|BR|PRI|FEAT|PAT|ARCH|KR)-(?!\d)/ },
+];
+/**
+ * Assert no governance-vocab leak in output (after stripping stored IDs).
+ * Tests every pattern and throws with the FIRST match's context on failure.
+ */
+function assertNoGovernanceLeak(output, fixture, surface) {
+    const stripped = stripStoredIds(output);
+    for (const { name, re } of GOVERNANCE_LEAK_PATTERNS) {
+        const match = stripped.match(re);
+        if (match) {
+            const idx = match.index ?? 0;
+            const context = stripped.slice(Math.max(0, idx - 30), idx + 50);
+            throw new Error(`[vocabulary-leak] Governance vocab "${name}" (matched: "${match[0]}") found in "${fixture}" fixture, "${surface}" surface.\n` +
+                `Context: ...${context}...\n` +
+                `Full output (stripped IDs):\n${stripped}`);
+        }
+    }
+}
+// ─── Captured search result fixture ──────────────────────────────────────────
+/** Minimal search result that matches the formatSearchResults expected shape. */
+const SEARCH_RESULTS = [
+    { entryId: 'WP-100', name: 'Ship vocabulary foundation', collectionSlug: 'work-packages', status: 'active' },
+    { entryId: 'DEC-42', name: 'Resolver architecture decision', collectionSlug: 'decisions', status: 'published' },
+];
+// ─── Capture receipt fixture ──────────────────────────────────────────────────
+/** Minimal capture receipt that exercises the formatter. */
+const CAPTURE_RECEIPT = {
+    entryId: 'WP-200',
+    status: 'draft',
+    collection: 'work-packages',
+    name: 'New vocabulary test entry',
+    classification: {
+        collection: 'work-packages',
+        confidence: 0.9,
+        tier: 'high',
+    },
+};
+// ─── Test suites ──────────────────────────────────────────────────────────────
+describe('vocabulary-leak: orient formatters', () => {
+    for (const { name, ctx, skipLeakCheck } of ALL_FIXTURES) {
+        it(`${name}: formatOrient contains no literal "bet" outside stored IDs`, () => {
+            const output = formatOrient(ORIENT_VIEW, ctx);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb orient (full)');
+            // Governance-vocab assertion applies to ALL fixtures (including BET-label).
+            assertNoGovernanceLeak(output, name, 'pb orient (full)');
+            // Also verify the resolved label appears (positive check)
+            const expectedLabel = ctx.collectionLabels?.work_package?.plural ?? ctx.collectionDefaults?.work_package?.plural ?? 'work_package';
+            expect(output).toContain(expectedLabel);
+        });
+        it(`${name}: formatOrientBrief contains no literal "bet" outside stored IDs`, () => {
+            const output = formatOrientBrief(ORIENT_VIEW, ctx);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb orient --brief');
+            assertNoGovernanceLeak(output, name, 'pb orient --brief');
+            // Also verify the resolved label appears in the count line
+            const expectedLabel = ctx.collectionLabels?.work_package?.plural ?? ctx.collectionDefaults?.work_package?.plural ?? 'work_package';
+            expect(output).toContain(expectedLabel);
+        });
+    }
+});
+describe('vocabulary-leak: search formatter', () => {
+    for (const { name, skipLeakCheck } of ALL_FIXTURES) {
+        const titleSuffix = skipLeakCheck
+            ? '[skipLeakCheck — label is "Bet"; surface does not render vocab labels anyway]'
+            : 'contains no literal "bet" outside stored IDs';
+        it(`${name}: formatSearchResults ${titleSuffix}`, () => {
+            // formatSearchResults renders entry names and slugs — none should contain "bet"
+            // since our fixtures use work-packages (not bets) as the slug.
+            const output = formatSearchResults(SEARCH_RESULTS);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb search');
+            // Governance-vocab assertion applies universally.
+            assertNoGovernanceLeak(output, name, 'pb search');
+        });
+    }
+});
+describe('vocabulary-leak: capture formatter', () => {
+    for (const { name, skipLeakCheck } of ALL_FIXTURES) {
+        const titleSuffix = skipLeakCheck
+            ? '[skipLeakCheck — label is "Bet"; surface does not render vocab labels anyway]'
+            : 'contains no literal "bet" outside stored IDs';
+        it(`${name}: formatCaptureReceipt ${titleSuffix}`, () => {
+            const output = formatCaptureReceipt(CAPTURE_RECEIPT);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb capture');
+            assertNoGovernanceLeak(output, name, 'pb capture');
+        });
+    }
+});
+// ─── pb audit fixtures (TEN-2053 S2) ─────────────────────────────────────────
+//
+// formatAudit is workspace-vocab-agnostic (no vocabCtx parameter) — it renders
+// gate detail/fix/hint strings produced upstream by chain.auditBet. The test
+// runs the same AuditResult through every fixture so we exercise the matrix
+// even though `bet` leaks aren't reachable through formatAudit by design.
+//
+// PASS_AUDIT_RESULT: success path (count summary). No gate jargon in detail.
+// FAIL_AUDIT_RESULT: exercises fix/hint strings — the riskiest leak vector.
+const PASS_AUDIT_RESULT = {
+    entryId: 'WP-100',
+    entryName: 'Ship vocabulary foundation',
+    phase: 'shaping',
+    clean: true,
+    verdict: 'pass',
+    gates: [
+        {
+            gate: 'intentional-relations',
+            status: 'pass',
+            blocking: true,
+            detail: '3 intentional relation(s) found. No duplicates detected.',
+        },
+        {
+            gate: 'strategic-anchor',
+            status: 'pass',
+            blocking: true,
+            detail: 'Linked to a strategic parent.',
+        },
+        {
+            gate: 'field-completeness',
+            status: 'pass',
+            blocking: true,
+            detail: 'All required fields populated.',
+        },
+    ],
+    summary: { total: 3, passed: 3, failed: 0, warned: 0 },
+    elapsed_ms: 42,
+};
+const FAIL_AUDIT_RESULT = {
+    entryId: 'WP-200',
+    entryName: 'Incomplete work item',
+    phase: 'shaping',
+    clean: false,
+    verdict: 'fail',
+    gates: [
+        {
+            gate: 'intentional-relations',
+            status: 'fail',
+            blocking: true,
+            detail: '0 intentional relations.',
+            fix: "Set field 'problem' to 'needs definition'.",
+            fixType: 'exact',
+        },
+        {
+            gate: 'strategic-anchor',
+            status: 'pass',
+            blocking: true,
+            detail: 'Linked to a strategic parent.',
+        },
+        {
+            gate: 'field-completeness',
+            status: 'fail',
+            blocking: true,
+            detail: 'Missing: appetite, doneWhen.',
+            fix: "Update the entry to populate: appetite, doneWhen.",
+            fixType: 'exact',
+            hint: 'Required fields per the field schema.',
+        },
+    ],
+    summary: { total: 3, passed: 1, failed: 2, warned: 0 },
+    elapsed_ms: 55,
+};
+describe('vocabulary-leak: audit formatter', () => {
+    for (const { name, skipLeakCheck } of ALL_FIXTURES) {
+        // formatAudit is vocab-agnostic, but we still skip the bet-leak check on the
+        // "Bet" label fixture per the existing skipLeakCheck convention.
+        it(`${name}: formatAudit (PASS verdict) contains no governance vocab`, () => {
+            const output = formatAudit(PASS_AUDIT_RESULT);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb audit (PASS)');
+            assertNoGovernanceLeak(output, name, 'pb audit (PASS)');
+        });
+        it(`${name}: formatAudit (FAIL verdict) contains no governance vocab`, () => {
+            const output = formatAudit(FAIL_AUDIT_RESULT);
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb audit (FAIL)');
+            assertNoGovernanceLeak(output, name, 'pb audit (FAIL)');
+        });
+        it(`${name}: formatAudit (--verbose) contains no governance vocab`, () => {
+            const output = formatAudit(FAIL_AUDIT_RESULT, { verbose: true });
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb audit (verbose)');
+            assertNoGovernanceLeak(output, name, 'pb audit (verbose)');
+        });
+    }
+});
+// ─── Command-level leak tests (Gap 2) ────────────────────────────────────────
+//
+// These tests invoke `runOrient` from the actual CLI command module to prove
+// the command SUPPLIES vocabCtx to formatOrient/formatOrientBrief — not just
+// that the formatters work when given ctx directly.
+//
+// Mocking strategy (mirrors orient.test.ts):
+//   - kernelCall is mocked at module level
+//   - getConfigOrGuide returns { apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' }
+//   - runCliCommand is mocked to call fn() + formatPretty() and write to stdout
+//   - chain.getVocabulary returns the fixture vocabCtx
+//   - chain.getOrientView returns ORIENT_VIEW
+//
+// The vocab cache is cleared before each test to ensure fresh fetches.
+const kernelCallMock = vi.fn();
+vi.mock('../lib/client.js', () => ({
+    kernelCall: (...args) => kernelCallMock(...args),
+}));
+vi.mock('../lib/config.js', () => ({
+    getConfig: vi.fn(() => ({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
+    getConfigOrGuide: vi.fn(() => Promise.resolve({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
+}));
+vi.mock('../lib/runner.js', () => ({
+    runCliCommand: vi.fn(async ({ fn, formatPretty }) => {
+        const data = await fn();
+        process.stdout.write(formatPretty(data) + '\n');
+    }),
+    isJsonMode: vi.fn(() => false),
+}));
+vi.mock('../lib/strip.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        stripConvexInternals: (v) => v,
+    };
+});
+// WP-479 E3 stage 2 (TEN-2654): runOrient now feature-detects the local session marker. These
+// tests don't exercise session threading — no active session, same as the zero-config default.
+vi.mock('../lib/session.js', () => ({
+    readSession: vi.fn(() => null),
+}));
+// Install a no-op global fetch so fire-and-forget byte reports don't fail.
+function installFetchMock() {
+    globalThis.fetch = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
+}
+describe('vocabulary-leak: runOrient command (end-to-end vocab wiring)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Clear vocab cache so each test fetches fresh via chain.getVocabulary mock.
+        clearVocabCache();
+        installFetchMock();
+    });
+    for (const { name, ctx, skipLeakCheck } of ALL_FIXTURES) {
+        it(`${name}: runOrient stdout contains no literal "bet" outside stored IDs`, async () => {
+            // Wire kernelCallMock: differentiate chain.getVocabulary from chain.getOrientView.
+            kernelCallMock.mockImplementation((fn) => {
+                if (fn === 'chain.getVocabulary') {
+                    return Promise.resolve({
+                        collectionLabels: ctx.collectionLabels,
+                        collectionDefaults: ctx.collectionDefaults,
+                    });
+                }
+                // Default: return the orient view for chain.getOrientView
+                return Promise.resolve(ORIENT_VIEW);
+            });
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            const { runOrient } = await import('../commands/orient.js');
+            await runOrient();
+            const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+            writeSpy.mockRestore();
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb orient (command)');
+            assertNoGovernanceLeak(output, name, 'pb orient (command)');
+            // Positive check: resolved label should appear in output.
+            const expectedLabel = ctx.collectionLabels?.work_package?.plural ?? ctx.collectionDefaults?.work_package?.plural ?? 'work_package';
+            expect(output).toContain(expectedLabel);
+        });
+        it(`${name}: runOrient --brief stdout contains no literal "bet" outside stored IDs`, async () => {
+            kernelCallMock.mockImplementation((fn) => {
+                if (fn === 'chain.getVocabulary') {
+                    return Promise.resolve({
+                        collectionLabels: ctx.collectionLabels,
+                        collectionDefaults: ctx.collectionDefaults,
+                    });
+                }
+                return Promise.resolve(ORIENT_VIEW);
+            });
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            const { runOrient } = await import('../commands/orient.js');
+            await runOrient({ brief: true });
+            const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+            writeSpy.mockRestore();
+            if (!skipLeakCheck)
+                assertNoBetLeak(output, name, 'pb orient --brief (command)');
+            assertNoGovernanceLeak(output, name, 'pb orient --brief (command)');
+            // Positive check: resolved label should appear in the count line.
+            const expectedLabel = ctx.collectionLabels?.work_package?.plural ?? ctx.collectionDefaults?.work_package?.plural ?? 'work_package';
+            expect(output).toContain(expectedLabel);
+        });
+    }
+    it('fallback: runOrient uses work_package literal when both collectionLabels AND collectionDefaults are null', async () => {
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary') {
+                return Promise.resolve({ collectionLabels: null, collectionDefaults: null });
+            }
+            return Promise.resolve(ORIENT_VIEW);
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const { runOrient } = await import('../commands/orient.js');
+        await runOrient({ brief: true });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        // Layer 4 fallback: resolver emits the canonicalKey literal 'work_package'
+        expect(output).toContain('work_package');
+    });
+    it('defaults-only: runOrient resolves from collectionDefaults when collectionLabels is null (INS-1446 regression guard)', async () => {
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary') {
+                return Promise.resolve({
+                    collectionLabels: null,
+                    collectionDefaults: { work_package: { singular: 'Bet', plural: 'Bets' } },
+                });
+            }
+            return Promise.resolve(ORIENT_VIEW);
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const { runOrient } = await import('../commands/orient.js');
+        await runOrient({ brief: true });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        // Layer 2 defaults: resolver uses collectionDefaults, NOT the literal
+        expect(output).toContain('Bets');
+        expect(output).not.toContain('work_package');
+    });
+    it('fail-open: runOrient still renders when chain.getVocabulary throws', async () => {
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary') {
+                return Promise.reject(new Error('simulated 404'));
+            }
+            return Promise.resolve(ORIENT_VIEW);
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const { runOrient } = await import('../commands/orient.js');
+        await expect(runOrient({ brief: true })).resolves.toBeUndefined();
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        // Output should still render (fallback to canonicalKey literal)
+        expect(output.length).toBeGreaterThan(0);
+        expect(output).toContain('work_package');
+    });
+});
+//# sourceMappingURL=vocabulary-leak.test.js.map