@productbrain/cli 0.1.0-beta.1428 → 0.1.0-beta.14295

package/dist/__tests__/orient.test.js

@@ -3,8 +3,11 @@ import { runOrient } from '../commands/orient.js';
 import { clearVocabCache } from '../lib/workspaceVocabCache.js';
 const kernelCallMock = vi.fn();
 const fetchMock = vi.fn();
+const discardSessionMock = vi.fn();
+const clearSessionMock = vi.fn();
 vi.mock('../lib/client.js', () => ({
     kernelCall: (...args) => kernelCallMock(...args),
+    gatewayHeaders: (apiKey) => ({ 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}`, 'x-pb-source': 'cli', 'x-pb-command': 'cmd-test' }),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfig: vi.fn(() => ({ apiKey: 'pb_sk_test', siteUrl: 'https://test.convex.site' })),
@@ -21,7 +24,32 @@ vi.mock('../lib/runner.js', () => ({
 }));
 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),
+    clearSession: (...args) => clearSessionMock(...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),
+}));
+vi.mock('../lib/boundScope.js', async (actual) => ({ ...(await actual()), readBoundScope: async () => null })); // TASK-1638: no lane in this run
 // Install a global fetch mock so the fire-and-forget byte report can be observed.
 function installFetchMock() {
     fetchMock.mockReset();
@@ -29,22 +57,15 @@ function installFetchMock() {
     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,
-        currentWorkPackage: 'BET-63',
+        activeBetCount: 1, activeWorkPackageCount: 1,
         activeTensionCount: 1,
-        productAreas: ['Governance'],
-        productAreaCount: 1,
     },
     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' }],
-        businessRules: [{ entryId: 'BR-178', name: 'Do not use provider IDs directly', collectionSlug: 'business-rules', status: 'published', preview: 'Permissions must derive from actor context' }],
-    },
     tensions: [],
     architectureNotes: [],
     proposals: [],
@@ -63,13 +84,11 @@ 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'],
         },
     },
     plannedWork: {
         uncommittedDrafts: [],
-        inProgressEntries: [],
         openTensions: [],
     },
     priorSessions: [],
@@ -83,6 +102,7 @@ const orientView = {
 };
 const orientViewWithoutTask = {
     ...orientView,
+    taskMeaningful: false,
     startup: undefined,
     taskContext: undefined,
 };
@@ -99,6 +119,12 @@ const orientViewTaskOnly = {
 };
 const orientViewDomainUnresolved = {
     ...orientView,
+    retrievalMiss: {
+        served: 'miss',
+        kind: 'domain-unresolved',
+        confidence: 1,
+        rubricVersion: 'rcrt-miss/v1@live-dirty',
+    },
     startup: {
         ...orientView.startup,
         groundingStatus: 'missing',
@@ -110,18 +136,10 @@ const orientViewDomainUnresolved = {
             standards: [],
             businessRules: [],
         },
-        domainRetrieval: {
-            state: 'domain-unresolved',
-            fallbackReason: 'No explicit scope, dereferenced artifact, changed path, or task text resolved to an authority domain.',
-            fallbackAction: 'Provide a scope, artifact ref, changed path, or more specific task.',
-            evidenceGap: 'Startup resolver had no domain evidence.',
-            activeSource: 'general',
-        },
         steeringContext: [],
         supportingContext: [],
         taskProfile: {
             workType: 'review',
-            domain: 'general',
             keywords: ['review', 'sign-off'],
         },
     },
@@ -153,7 +171,14 @@ describe('runOrient', () => {
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
         // DEC-NEW: surface forwards tier by key omission; kernel resolves default.
-        expect(kernelCallMock).toHaveBeenCalledWith('chain.getOrientView', {});
+        // 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');
     });
@@ -171,14 +196,223 @@ describe('runOrient', () => {
         // 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('renders dynamic binding governance collection buckets when provided', async () => {
+    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 governance marker without the rejection marker 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());
+    });
+    // The reader keys on the code; an old ended-session sentence without one is no longer recovered.
+    it('surfaces the old expired sentence without a session code instead of recovering it, and leaves the marker alone', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-expired', conversationId: 'conv-expired' });
+        const error = new Error('Agent session has expired (8-hour maximum exceeded)');
+        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();
+        expect(clearSessionMock).not.toHaveBeenCalled();
+    });
+    it('returns the orient view and removes the marker, leaving no closed marker, when the server never had the session', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-gone', conversationId: 'conv-gone' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented') {
+                const error = new Error('Agent session not found');
+                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-gone');
+        expect(clearSessionMock).not.toHaveBeenCalled();
+    });
+    // The server now sends the state as its code; the reader keys on the code, whatever the line says.
+    it.each([
+        ['SESSION_ORPHANED', 'Session [sess-stale] stopped and is closed. Start a new session.'],
+        ['SESSION_EXPIRED', 'Session [sess-stale] reached its eight-hour limit and is closed. Start a new session.'],
+        ['SESSION_CLOSED', 'Session [sess-stale] is closed. Start a new session.'],
+    ])('returns the orient view and leaves a closed marker, so the next start resumes linked, when marking oriented answers %s', async (code, line) => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-stale', conversationId: 'conv-stale' }).mockReturnValueOnce({ sessionId: 'sess-stale', conversationId: 'conv-stale' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented') {
+                const error = new Error(line);
+                error.name = 'McpError';
+                error.code = code;
+                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(clearSessionMock).toHaveBeenCalledWith('conv-stale');
+        expect(discardSessionMock).not.toHaveBeenCalled();
+    });
+    it('leaves the marker alone when another command replaced it while orient ran', async () => {
+        readSessionMock.mockReturnValueOnce({ sessionId: 'sess-stale', conversationId: 'conv-stale' }).mockReturnValueOnce({ sessionId: 'sess-newer', conversationId: 'conv-stale' });
+        kernelCallMock.mockImplementation((fn) => {
+            if (fn === 'chain.getVocabulary')
+                return Promise.resolve({});
+            if (fn === 'agent.markOriented') {
+                const error = new Error('Session [sess-stale] is closed. Start a new session.');
+                error.name = 'McpError';
+                error.code = 'SESSION_CLOSED';
+                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();
+        writeSpy.mockRestore();
+        expect(clearSessionMock).not.toHaveBeenCalled();
+        expect(discardSessionMock).not.toHaveBeenCalled();
+    });
+    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,
@@ -213,10 +447,10 @@ describe('runOrient', () => {
         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');
+        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);
@@ -232,7 +466,7 @@ describe('runOrient', () => {
         expect(output).toContain('## Task grounding');
         expect(output).toContain('2 relevant entries (high confidence)');
     });
-    it('renders DOMAIN UNRESOLVED loudly with reason and next action', async () => {
+    it('renders retrieval miss loudly', async () => {
         const writeSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
         kernelCallMock.mockImplementation((fn) => {
             if (fn === 'chain.getVocabulary')
@@ -242,19 +476,19 @@ describe('runOrient', () => {
         await runOrient({ task: 'review sign-off notes' });
         const output = writeSpy.mock.calls.map((call) => String(call[0])).join('');
         writeSpy.mockRestore();
-        expect(output).toContain('## DOMAIN UNRESOLVED');
-        expect(output).toContain('No explicit scope, dereferenced artifact, changed path, or task text resolved to an authority domain.');
-        expect(output).toContain('Provide a scope, artifact ref, changed path, or more specific task.');
-        expect(output).toContain('Domain retrieval: domain-unresolved');
+        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 () => {
+    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();
         // WP-436 S2: "bets" → resolver label (work_package fallback when no vocab ctx).
-        expect(output).toContain('grounded | 1 work_package | 1 tensions');
+        // 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');
     });
@@ -273,7 +507,7 @@ describe('runOrient', () => {
         expect(output).toContain('2 relevant entries');
         expect(output).not.toContain('## Active bets');
     });
-    it('brief mode renders DOMAIN UNRESOLVED when startup resolution is unresolved', async () => {
+    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')
@@ -283,8 +517,7 @@ describe('runOrient', () => {
         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('DOMAIN UNRESOLVED');
-        expect(output).toContain('No explicit scope, dereferenced artifact, changed path, or task text resolved to an authority domain.');
+        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);
@@ -338,47 +571,62 @@ describe('runOrient', () => {
         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 () => {
+    // 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);
-        // 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',
-                },
-            });
+            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).toContain('[WARN] chain.getOrientView is near its query budget.');
+        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('WP-381 S5: renders a TTY capped header when orient carries emergency budget', async () => {
+    it('TASK-556 round 1: a capped section names what was cut', 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',
-                },
-            });
+            return Promise.resolve({ ...orientView, _budget: { bytes: 10_240, truncated: true, truncationReasons: ['tensions', 'architectureNotes'], overflowed: false } });
         });
-        await runOrient({ brief: true });
+        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('[ERROR] chain.getOrientView was capped; some non-binding lists or counts may be incomplete.');
+        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);
@@ -420,5 +668,45 @@ describe('runOrient', () => {
             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');
+        });
+    });
 });
 //# sourceMappingURL=orient.test.js.map