@productbrain/cli 0.1.0-beta.99 → 0.1.0-beta.9904

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,24 +16,53 @@ 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 = {
+    taskMeaningful: true,
     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: [],
-    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' }],
-        businessRules: [{ entryId: 'BR-178', name: 'Do not use provider IDs directly', collectionSlug: 'business-rules', status: 'published', preview: 'Permissions must derive from actor context' }],
     },
+    activeWorkPackages: [],
     tensions: [],
     architectureNotes: [],
     proposals: [],
@@ -48,7 +81,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'],
         },
     },
@@ -68,6 +100,7 @@ const orientView = {
 };
 const orientViewWithoutTask = {
     ...orientView,
+    taskMeaningful: false,
     startup: undefined,
     taskContext: undefined,
 };
@@ -82,56 +115,328 @@ 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');
-        expect(output).toContain('## Binding governance');
         expect(output).toContain('## Supporting context');
         expect(output).toContain('STD-101');
+        // TASK-556 (DEC-1889): the served binding-governance buckets reach no render.
+        expect(output).not.toContain('## Binding governance');
+        expect(output).not.toContain('Do not use provider IDs directly');
+        expect(output).not.toContain('Derive from the live source');
+    });
+    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 asks no task, so it must NOT complete the
+        // orientation transition — only a task-shaped orient unlocks server-gated writes (TASK-534).
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('Codex P2 (PR #372): a task 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('TASK-534 (WP-791, TEN-4261): a task orient whose grounding came back empty still marks the session oriented', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-ungrounded', conversationId: 'conv-ungrounded' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented')
+                return Promise.resolve(undefined);
+            // orientViewDomainUnresolved serves taskContext.context: [] — the Chain had nothing to say.
+            return Promise.resolve(orientViewDomainUnresolved);
+        });
+        await runOrient({ task: 'review sign-off' });
+        expect(kernelCallMock).toHaveBeenCalledWith('agent.markOriented', { sessionId: 'sess-ungrounded' });
+    });
+    it('TASK-534 review: a task the server judges not meaningful does not mark the session oriented', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-blank', conversationId: 'conv-blank' });
+        kernelCallMock.mockImplementation((fn) => Promise.resolve(fn === 'chain.getVocabulary' ? {} : { ...orientView, taskMeaningful: false }));
+        await runOrient({ task: '\u200B' });
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('TASK-534 review: a degraded gather preload is not a zero-match and does not mark the session oriented', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-degraded', conversationId: 'conv-degraded' });
+        kernelCallMock.mockImplementation((fn) => Promise.resolve(fn === 'chain.getVocabulary' ? {} : { ...orientView, degradedPreloads: ['gather'] }));
+        await runOrient({ task: 'harden auth startup flow' });
+        expect(kernelCallMock).not.toHaveBeenCalledWith('agent.markOriented', expect.anything());
+    });
+    it('TASK-534 review: a rejected governance load keeps writes locked; a capped one unlocks', async () => {
+        for (const [degraded, expectMark] of [[['governanceLoad', 'governanceLoadRejected'], false], [['governanceLoad'], true]]) {
+            kernelCallMock.mockReset();
+            readSessionMock.mockReturnValueOnce({ sessionId: 'sess-gov', conversationId: 'conv-gov' });
+            kernelCallMock.mockImplementation((fn) => Promise.resolve(fn === 'chain.getVocabulary' ? {} : { ...orientView, degradedPreloads: [...degraded] }));
+            await runOrient({ task: 'harden auth startup flow' });
+            if (expectMark)
+                expect(kernelCallMock).toHaveBeenCalledWith('agent.markOriented', { sessionId: 'sess-gov' });
+            else
+                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('TASK-556 (DEC-1889): does not render binding-governance collection buckets', 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).not.toContain('Tenets:');
+        expect(output).not.toContain('TENET-1');
+        expect(output).not.toContain('Quality Bars:');
+        expect(output).not.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('brief mode shows stage/count line and task grounding required without full headings', async () => {
+    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 the 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).
+        // TASK-435 (C4c): the readiness stage label is deleted from served text — no "grounded |"
+        // prefix any more.
+        expect(output).toContain('1 work_package | 1 tensions');
+        expect(output).not.toContain('grounded |');
         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 +444,218 @@ 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);
+    });
+    // TASK-556 (WP-777, DEC-1889): the capped header fires only when a served rule list was cut.
+    const servedRuleLists = (truncated, withTeam) => ({
+        everyone: { rows: [{ entryId: 'RULE-1', bucket: 'everyone', name: 'Scope reads' }], overCap: 0 },
+        team: withTeam ? { rows: [], overCap: 0 } : null,
+        role: { rows: [], overCap: 0 },
+        unassigned: 0,
+        truncated,
+    });
+    it.each([
+        ['a capped orient budget alone', { emergencyCapped: true, truncated: true, breachTier: 'emergency', queryName: 'chain.getOrientView' }, servedRuleLists(false, true)],
+        ['a near-budget warning alone', { warning: true, truncated: false, breachTier: 'warning', queryName: 'chain.getOrientView' }, servedRuleLists(false, true)],
+    ])('TASK-556: %s raises no header', async (_label, budget, ruleLists) => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({ ...orientViewWithoutTask, _budget: budget, ruleLists });
+        });
+        await runOrient({ brief: true });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).not.toContain('[ERROR]');
+        expect(output).not.toContain('[WARN]');
+        // Round 1 (PRRT_kwDORS4ils6ovQu3): a capped section is still disclosed, in one plain line.
+        if (budget.truncated)
+            expect(output).toContain('Context truncated to fit the tier budget. Use --full for the complete payload.');
+        else
+            expect(output).not.toContain('Context truncated');
+    });
+    it('TASK-556 round 1: a capped section names what was cut', async () => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({ ...orientView, _budget: { bytes: 10_240, truncated: true, truncationReasons: ['tensions', 'architectureNotes'], overflowed: false } });
+        });
+        await runOrient({ task: 'harden auth startup flow' });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain('Context truncated to fit the tier budget: tensions, architectureNotes. Use --full for the complete payload.');
+        expect(output).not.toContain('[ERROR]');
+    });
+    it.each([
+        [true, '[ERROR] The Everyone, Team and Role rule lists were cut: the rule read hit its cap, so a rule that binds you may be missing.'],
+        [false, '[ERROR] The Everyone and Role rule lists were cut: the rule read hit its cap, so a rule that binds you may be missing.'],
+    ])('TASK-556: a cut rule read raises the header naming the served lists (team list served: %s)', async (withTeam, header) => {
+        const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            return Promise.resolve({ ...orientView, ruleLists: servedRuleLists(true, withTeam) });
+        });
+        await runOrient({ task: 'harden auth startup flow' });
+        const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
+        writeSpy.mockRestore();
+        expect(output).toContain(header);
+    });
+    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