@productbrain/cli 0.1.0-beta.72 → 0.1.0-beta.7204

package/dist/__tests__/orient.test.js

@@ -1,10 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { runOrient } from '../commands/orient.js';
+import { runOrient, normalizeView } from '../commands/orient.js';
+import { clearVocabCache } from '../lib/workspaceVocabCache.js';
 const kernelCallMock = vi.fn();
+const fetchMock = vi.fn();
+const discardSessionMock = 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', () => ({
@@ -12,19 +16,55 @@ vi.mock('../lib/runner.js', () => ({
         const data = await fn();
         process.stdout.write(formatPretty(data) + '\n');
     }),
+    // WP-376 α.3: tests render in pretty mode (formatPretty is invoked above) so byte
+    // measurement uses the formatted text, not JSON.
+    isJsonMode: vi.fn(() => false),
 }));
+vi.mock('../lib/strip.js', () => ({
+    stripConvexInternals: (v) => v,
+    // WP-622 follow-up (Copilot review PR #603): orientDirection.ts's buildVisionPurposeLines now
+    // calls stripControlChars too (imported via the same '../lib/strip.js' path) — this mock must
+    // define it or every formatOrient/formatOrientBrief call in this suite throws.
+    stripControlChars: (v) => v,
+}));
+// WP-479 E3 stage 2 (TEN-2654): orient now feature-detects the local session marker to thread
+// sessionId/conversationId. Default to "no active session" (null) so the existing byte-identical
+// no-session assertions below keep passing; individual tests override via mockReturnValueOnce.
+const readSessionMock = vi.fn(
+// Accept (and ignore) forwarded args — the passthrough below spreads its args in,
+// and a parameterless vi.fn() signature fails typecheck on that spread (TS2556).
+(..._args) => null);
+vi.mock('../lib/session.js', () => ({
+    readSession: (...args) => readSessionMock(...args),
+    discardSession: (...args) => discardSessionMock(...args),
+}));
+// WP-486 Slice 1 (FEAT-1371): stub out real git shell-outs — deterministic and fast. Defaults to
+// no signals (empty) so the existing exact-match kernelCallMock assertions below only need
+// `invocationPath: 'manual-orient'` added, not a variable-shaped `startupSignals` object.
+// `startup-signals.test.ts` covers `collectCliStartupSignals` itself in isolation.
+const collectCliStartupSignalsMock = vi.fn((..._args) => ({}));
+vi.mock('../lib/startup-signals.js', () => ({
+    collectCliStartupSignals: (...args) => collectCliStartupSignalsMock(...args),
+}));
+// Install a global fetch mock so the fire-and-forget byte report can be observed.
+function installFetchMock() {
+    fetchMock.mockReset();
+    fetchMock.mockResolvedValue(new Response(null, { status: 200 }));
+    globalThis.fetch = fetchMock;
+}
 const orientView = {
     stage: 'grounded',
     strategicContext: {
         vision: 'Make Chain startup reliable',
         purpose: 'Surface the right governance at the right time',
-        activeBetCount: 1,
-        currentBet: 'BET-63',
+        activeBetCount: 1, activeWorkPackageCount: 1,
+        currentWorkPackage: 'BET-63',
         activeTensionCount: 1,
         productAreas: ['Governance'],
         productAreaCount: 1,
     },
-    activeBets: [],
+    strategicSpine: { order: ['purpose', 'vision', 'strategy', 'product', 'objectives', 'keyResults'], objectives: [], orphanKeyResults: [], truncationReasons: [], fetchFailed: false },
+    activeWorkPackages: [],
     governance: {
         principles: [{ entryId: 'PRI-1', name: 'Use live governance', collectionSlug: 'principles', status: 'published', preview: 'Load constraints from the Chain' }],
         standards: [{ entryId: 'STD-101', name: 'Single source of truth', collectionSlug: 'standards', status: 'published', preview: 'Derive from the live source' }],
@@ -48,7 +88,6 @@ const orientView = {
         supportingContext: [{ entryId: 'DEC-12', name: 'Actor boundary', collectionSlug: 'decisions', score: 4, hop: 1 }],
         taskProfile: {
             workType: 'implementation',
-            domain: 'auth',
             keywords: ['harden', 'auth', 'startup', 'flow'],
         },
     },
@@ -82,28 +121,87 @@ const orientViewTaskOnly = {
         },
     },
 };
+const orientViewDomainUnresolved = {
+    ...orientView,
+    retrievalMiss: {
+        served: 'miss',
+        kind: 'domain-unresolved',
+        confidence: 1,
+        rubricVersion: 'rcrt-miss/v1@live-dirty',
+    },
+    startup: {
+        ...orientView.startup,
+        groundingStatus: 'missing',
+        confidence: 'low',
+        totalFound: 0,
+        seeds: [],
+        bindingGovernance: {
+            principles: [],
+            standards: [],
+            businessRules: [],
+        },
+        steeringContext: [],
+        supportingContext: [],
+        taskProfile: {
+            workType: 'review',
+            keywords: ['review', 'sign-off'],
+        },
+    },
+    taskContext: {
+        seeds: [],
+        context: [],
+        totalFound: 0,
+        confidence: 'low',
+    },
+};
 describe('runOrient', () => {
     beforeEach(() => {
         vi.clearAllMocks();
-        kernelCallMock.mockResolvedValue(orientViewWithoutTask);
+        // WP-436 S2: clear the vocab cache so each test gets a fresh chain.getVocabulary call.
+        clearVocabCache();
+        installFetchMock();
+        // Route kernelCall by fn name: chain.getVocabulary returns no labels (fallback);
+        // chain.getOrientView returns the default orient view. Tests override via
+        // kernelCallMock.mockImplementationOnce when they need a specific orient view.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientViewWithoutTask);
+        });
     });
     it('calls chain.getOrientView without task by default', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runOrient();
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
-        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {});
+        // DEC-NEW: surface forwards tier by key omission; kernel resolves default.
+        // WP-479 review fix (Codex): the interactive (non-json, non-brief) path now declares
+        // renderMode: 'pretty' explicitly so the server never infers json from "non-brief".
+        // WP-486 Slice 1 review fix (Codex, PR #369): NO `invocationPath` here — a task-less base
+        // orient must stay unattributed (kernel/telemetry/contextServed.ts's established contract),
+        // never defaulted to 'manual-orient', which is a TASK-SHAPED orient's signal only.
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
+            renderMode: 'pretty',
+        });
         expect(output).toContain('Task grounding required');
         expect(output).toContain('pb orient --task');
     });
     it('passes task through to chain.getOrientView and renders task context', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        kernelCallMock.mockResolvedValueOnce(orientView);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientView);
+        });
         await runOrient({ task: 'harden auth startup flow' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
+        // DEC-NEW: task-scoped call omits tier; kernel defaults to 'summary'.
         expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
             task: 'harden auth startup flow',
+            renderMode: 'pretty',
+            invocationPath: 'manual-orient',
         });
         expect(output).toContain('## Task grounding');
         expect(output).toContain('Status: grounded');
@@ -111,27 +209,209 @@ describe('runOrient', () => {
         expect(output).toContain('## Supporting context');
         expect(output).toContain('STD-101');
     });
+    it('WP-479 E3 stage 2 (TEN-2654): threads sessionId/conversationId when a local session marker is active', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-abc123', conversationId: 'conv-xyz789' });
+        await runOrient();
+        // WP-486 Slice 1 review fix (Codex, PR #369): no task → no invocationPath (see above).
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
+            renderMode: 'pretty',
+            sessionId: 'sess-abc123',
+            conversationId: 'conv-xyz789',
+        });
+        // Codex P2 (PR #372): a bare orient carries no task grounding, so it must NOT complete
+        // the orientation transition — orientation unlocks server-gated writes, and MCP only
+        // marks oriented when the orient was task-grounded (hasTaskGrounding).
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('Codex P2 (PR #372): a task-grounded orient with an active session marks the session oriented', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-grounded', conversationId: 'conv-grounded' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented')
+                return Promise.resolve(undefined);
+            return Promise.resolve(orientView);
+        });
+        await runOrient({ task: 'harden auth startup flow' });
+        expect(kernelCallMock).toHaveBeenCalledWith('agent.markOriented', {
+            sessionId: 'sess-grounded',
+        });
+    });
+    it('Codex P2 (PR #372): a task orient whose grounding came back empty stays unoriented — mirrors MCP hasTaskGrounding', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-ungrounded', conversationId: 'conv-ungrounded' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            // orientViewDomainUnresolved serves taskContext.context: [] — no real grounding.
+            return Promise.resolve(orientViewDomainUnresolved);
+        });
+        await runOrient({ task: 'review sign-off' });
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('WP-479 E3 stage 2 (TEN-2654): omits sessionId/conversationId entirely with no active session marker (feature-detect, not required)', async () => {
+        // readSessionMock defaults to null (no active session) via the module mock above.
+        await runOrient();
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
+            renderMode: 'pretty',
+        });
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('returns the orient view and discards an expired local marker when marking oriented rejects it', async () => {
+        // Codex P2 (PR #372): markOriented now only fires on a task-grounded orient, so the
+        // stale-marker recovery path is exercised with a grounded task orient.
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-expired', conversationId: 'conv-expired' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented') {
+                const error = new Error('Agent session has expired (8-hour maximum exceeded)');
+                error.name = 'McpError';
+                error.code = 'MCP_GATEWAY_CLIENT';
+                return Promise.reject(error);
+            }
+            return Promise.resolve(orientView);
+        });
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await expect(runOrient({ task: 'harden auth startup flow' })).resolves.toBeUndefined();
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('## Task grounding');
+        expect(discardSessionMock).toHaveBeenCalledWith('conv-expired');
+    });
+    it('does not hide non-lifecycle failures from marking the session oriented', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-wrong-workspace', conversationId: 'conv-1' });
+        const error = new Error('Session workspace does not match API key workspace.');
+        error.name = 'McpError';
+        error.code = 'MCP_GATEWAY_CLIENT';
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented')
+                return Promise.reject(error);
+            return Promise.resolve(orientView);
+        });
+        await expect(runOrient({ task: 'harden auth startup flow' })).rejects.toBe(error);
+        expect(discardSessionMock).not.toHaveBeenCalled();
+    });
+    it('WP-486 Slice 1 (FEAT-1371, TEN-2724): sends a non-empty startupSignals when the worktree has uncommitted changes — closes the CLI-side signal gap', async () => {
+        collectCliStartupSignalsMock.mockReturnValueOnce({
+            changedPaths: ['convex/agentKnowledge/orientView.ts'],
+            branchName: 'ontology-r4-r5-signal-envelope',
+            worktreeName: 'ontology-r4-r5-signal-envelope',
+        });
+        await runOrient({ task: 'harden auth startup flow' });
+        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {
+            task: 'harden auth startup flow',
+            renderMode: 'pretty',
+            invocationPath: 'manual-orient',
+            startupSignals: {
+                changedPaths: ['convex/agentKnowledge/orientView.ts'],
+                branchName: 'ontology-r4-r5-signal-envelope',
+                worktreeName: 'ontology-r4-r5-signal-envelope',
+            },
+        });
+    });
+    it('WP-486 Slice 1: omits startupSignals entirely (not an empty object) when nothing was collected', async () => {
+        collectCliStartupSignalsMock.mockReturnValueOnce({});
+        await runOrient();
+        const call = kernelCallMock.mock.calls.find((c) => c[0] === 'chain.getOrientView');
+        expect(call?.[1]).not.toHaveProperty('startupSignals');
+    });
+    it('WP-486 Slice 1 review fix (Codex, PR #369): a base orient (no --task) never stamps invocationPath, even when the worktree has real changedPaths', async () => {
+        // Real signals present — proves the omission is task-gated, not merely "nothing collected".
+        collectCliStartupSignalsMock.mockReturnValueOnce({
+            changedPaths: ['convex/agentKnowledge/orientView.ts'],
+            branchName: 'ontology-r4-r5-signal-envelope',
+        });
+        await runOrient();
+        const call = kernelCallMock.mock.calls.find((c) => c[0] === 'chain.getOrientView');
+        expect(call?.[1]).not.toHaveProperty('invocationPath');
+    });
+    it('renders dynamic binding governance collection buckets when provided', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        const customBindingView = {
+            ...orientView,
+            startup: {
+                ...orientView.startup,
+                bindingGovernance: {
+                    principles: [],
+                    standards: [],
+                    businessRules: [],
+                    byCollection: [
+                        {
+                            collectionSlug: 'tenets',
+                            collectionName: 'Tenets',
+                            canonicalKey: 'principle',
+                            entries: [{ entryId: 'TENET-1', name: 'Use domain language', collectionSlug: 'tenets' }],
+                        },
+                        {
+                            collectionSlug: 'quality-bars',
+                            collectionName: 'Quality Bars',
+                            canonicalKey: 'standard',
+                            entries: [{ entryId: 'QBAR-1', name: 'Claims review requires an owner', collectionSlug: 'quality-bars' }],
+                        },
+                    ],
+                },
+            },
+        };
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(customBindingView);
+        });
+        await runOrient({ task: 'review custom governance' });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Tenets:');
+        expect(output).toContain('TENET-1');
+        expect(output).toContain('Quality Bars:');
+        expect(output).toContain('QBAR-1');
+    });
     it('renders task context even when governance buckets are empty', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        kernelCallMock.mockResolvedValueOnce(orientViewTaskOnly);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientViewTaskOnly);
+        });
         await runOrient({ task: 'trace supporting context only' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
         expect(output).toContain('## Task grounding');
         expect(output).toContain('2 relevant entries (high confidence)');
     });
+    it('renders retrieval miss loudly', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientViewDomainUnresolved);
+        });
+        await runOrient({ task: 'review sign-off notes' });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('## ⚠ RETRIEVAL MISS — domain-unresolved');
+        expect(output).not.toContain('## Binding governance');
+    });
     it('brief mode shows stage/count line and task grounding required without full headings', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         await runOrient({ brief: true });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
-        expect(output).toContain('grounded | 1 bets | 1 tensions');
+        // WP-436 S2: "bets" → resolver label (work_package fallback when no vocab ctx).
+        expect(output).toContain('grounded | 1 work_package | 1 tensions');
         expect(output).toContain('Task grounding required');
         expect(output).not.toContain('## Active bets');
     });
     it('brief mode with task context renders startup grounding line', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        kernelCallMock.mockResolvedValueOnce(orientView);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientView);
+        });
         await runOrient({ brief: true, task: 'harden auth startup flow' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
@@ -139,5 +419,203 @@ describe('runOrient', () => {
         expect(output).toContain('2 relevant entries');
         expect(output).not.toContain('## Active bets');
     });
+    it('brief mode renders retrieval miss when startup resolution is unresolved', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve(orientViewDomainUnresolved);
+        });
+        await runOrient({ brief: true, task: 'review sign-off notes' });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('RETRIEVAL MISS — domain-unresolved');
+    });
+    it('WP-376 α.3: fires agent.reportOrientMetric with rendered bytes after orient renders', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        await runOrient({ brief: true });
+        // Allow the fire-and-forget microtask to flush.
+        await Promise.resolve();
+        await Promise.resolve();
+        writeSpy.mockRestore();
+        const reportCalls = fetchMock.mock.calls.filter((c) => typeof c[1]?.body === 'string' && c[1].body.includes('agent.reportOrientMetric'));
+        expect(reportCalls.length).toBeGreaterThanOrEqual(1);
+        const body = JSON.parse(reportCalls[0][1].body);
+        expect(body.fn).toBe('agent.reportOrientMetric');
+        expect(body.args.bytes).toBeGreaterThan(0);
+        expect(body.args.truncated).toBe(false);
+    });
+    it('WP-376 α.3: passes truncated=true when the orient view exposes _truncated', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({ ...orientViewWithoutTask, _truncated: true });
+        });
+        await runOrient({ brief: true });
+        await Promise.resolve();
+        await Promise.resolve();
+        writeSpy.mockRestore();
+        const reportCalls = fetchMock.mock.calls.filter((c) => typeof c[1]?.body === 'string' && c[1].body.includes('agent.reportOrientMetric'));
+        expect(reportCalls.length).toBeGreaterThanOrEqual(1);
+        const body = JSON.parse(reportCalls[reportCalls.length - 1][1].body);
+        expect(body.args.truncated).toBe(true);
+    });
+    it('DEC-NEW: passes truncated=true from _budget.truncated when _truncated is absent (summary-tier cap)', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        // Summary-tier section dropping is reported via _budget.truncated only — the
+        // legacy _truncated input-scan flag stays absent. Metric must still read true.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({
+                ...orientViewWithoutTask,
+                _budget: { bytes: 10_240, truncated: true, truncationReasons: ['summary-cap'], overflowed: false },
+            });
+        });
+        await runOrient({ task: 'review auth flow' });
+        await Promise.resolve();
+        await Promise.resolve();
+        writeSpy.mockRestore();
+        const reportCalls = fetchMock.mock.calls.filter((c) => typeof c[1]?.body === 'string' && c[1].body.includes('agent.reportOrientMetric'));
+        expect(reportCalls.length).toBeGreaterThanOrEqual(1);
+        const body = JSON.parse(reportCalls[reportCalls.length - 1][1].body);
+        expect(body.args.truncated).toBe(true);
+    });
+    it('WP-381 S5: renders a TTY budget header when orient carries warning budget', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({
+                ...orientViewWithoutTask,
+                _budget: {
+                    warning: true,
+                    truncated: false,
+                    breachTier: 'warning',
+                    queryName: 'chain.getOrientView',
+                },
+            });
+        });
+        await runOrient({ brief: true });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('[WARN] chain.getOrientView is near its query budget.');
+    });
+    it('WP-381 S5: renders a TTY capped header when orient carries emergency budget', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        // WP-436 S2: route by fn — getVocabulary first (fallback), then getOrientView.
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({
+                ...orientViewWithoutTask,
+                _budget: {
+                    emergencyCapped: true,
+                    truncated: true,
+                    breachTier: 'emergency',
+                    queryName: 'chain.getOrientView',
+                },
+            });
+        });
+        await runOrient({ brief: true });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('[ERROR] chain.getOrientView was capped; some non-binding lists or counts may be incomplete.');
+    });
+    it('WP-376 α.3: fire-and-forget swallows fetch errors — runOrient resolves cleanly', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        fetchMock.mockReset();
+        // Both the kernel-call fetch (in the kernelCall mock) and our raw call go through fetch.
+        // Make every fetch reject — the kernel-call mock doesn't use fetch (mocked at module level),
+        // so only our reportOrientCliBytes raw fetch hits this. It must not propagate.
+        fetchMock.mockRejectedValue(new Error('simulated network failure'));
+        await expect(runOrient({ brief: true })).resolves.toBeUndefined();
+        await Promise.resolve();
+        await Promise.resolve();
+        writeSpy.mockRestore();
+    });
+    // DEC-NEW (AC #5): CLI forwards tier by key omission unless --full is passed.
+    describe('surface forwarding — tier key omission (DEC-NEW, AC #5)', () => {
+        const getOrientCall = () => kernelCallMock.mock.calls.find((c) => c[0] === 'chain.getOrientView');
+        it('omits tier from kernel args when --full not passed (task supplied)', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await runOrient({ task: 'Implement BET-X slice 2' });
+            writeSpy.mockRestore();
+            const call = getOrientCall();
+            expect(call).toBeDefined();
+            const args = call[1];
+            expect('tier' in args).toBe(false);
+            expect(args.task).toBe('Implement BET-X slice 2');
+        });
+        it('omits tier from kernel args when --full not passed (no task)', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await runOrient();
+            writeSpy.mockRestore();
+            const args = getOrientCall()[1];
+            expect('tier' in args).toBe(false);
+        });
+        it('sends tier=full when --full passed', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await runOrient({ full: true, task: 'X' });
+            writeSpy.mockRestore();
+            const args = getOrientCall()[1];
+            expect(args.tier).toBe('full');
+        });
+    });
+    // WP-480 S3 (FEAT-1360): the byte-report consumes the SERVED resolvedTier +
+    // taskMeaningful off the orient payload — the local predicate mirror is deleted.
+    describe('WP-480 S3: report consumes served resolvedTier/taskMeaningful', () => {
+        const lastReportArgs = async () => {
+            await Promise.resolve();
+            await Promise.resolve();
+            const reportCalls = fetchMock.mock.calls.filter((c) => typeof c[1]?.body === 'string' && c[1].body.includes('agent.reportOrientMetric'));
+            expect(reportCalls.length).toBeGreaterThanOrEqual(1);
+            return JSON.parse(reportCalls[reportCalls.length - 1][1].body).args;
+        };
+        it('served fields drive the report — even when a local predicate would disagree (no task passed locally)', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            kernelCallMock.mockImplementation((fn) => {
+                if (fn === 'chain.getVocabulary')
+                    return Promise.resolve({});
+                return Promise.resolve({ ...orientViewWithoutTask, resolvedTier: 'summary', taskMeaningful: true });
+            });
+            await runOrient(); // no local task; served payload says summary/true
+            const args = await lastReportArgs();
+            writeSpy.mockRestore();
+            expect(args.tier).toBe('summary');
+            expect(args.taskProvided).toBe(true);
+        });
+        it('old-deploy fallback: fields absent → explicit --full still wins, taskProvided=false', async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await runOrient({ full: true, task: 'real meaningful task' });
+            const args = await lastReportArgs();
+            writeSpy.mockRestore();
+            expect(args.tier).toBe('full');
+            // Degraded honestly: absent field ≠ re-derived from a local predicate copy.
+            expect(args.taskProvided).toBe(false);
+        });
+        it("old-deploy fallback: fields absent, no --full → 'standard'", async () => {
+            const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+            await runOrient({ task: 'real meaningful task' });
+            const args = await lastReportArgs();
+            writeSpy.mockRestore();
+            expect(args.tier).toBe('standard');
+        });
+    });
+});
+describe('WP-560/TEN-2532 post-merge review (Codex P1): normalizeView preserves shapeAdvisorySummary', () => {
+    it('the JSON-mode agent surface (`...raw` pass-through) carries shapeAdvisorySummary through unchanged, even though it is not an explicitly-named field on the normalized view', () => {
+        const shapeAdvisorySummary = {
+            windowDays: 14, compoundTotal: 4, pendingCount: 1, pendingRate: 0.25,
+            precisionAgent: 0.6667, precisionAgentN: 3, precisionHuman: null, precisionHumanN: 0,
+            precisionHumanNote: 'no human verdicts yet (n=0)', candidateRateBySource: { cli: 0.5 }, scanTruncated: false,
+        };
+        const raw = { ...orientViewWithoutTask, shapeAdvisorySummary };
+        const view = normalizeView(raw);
+        expect(view.shapeAdvisorySummary).toEqual(shapeAdvisorySummary);
+    });
 });
 //# sourceMappingURL=orient.test.js.map