oh-my-codex 0.16.3 → 0.17.0

package/dist/planning/__tests__/context-pack-status.test.js

@@ -68,6 +68,25 @@ async function writeContextPack(slug, prdPath, testSpecPath, roles) {
         })),
     }, null, 2));
 }
+async function writeContextPackWithEntries(slug, prdPath, testSpecPath, entries) {
+    const packPath = join(tempDir, canonicalContextPackRelativePath(slug));
+    const prdActual = await readFile(prdPath, 'utf-8');
+    const testSpecActual = await readFile(testSpecPath, 'utf-8');
+    await writeFile(packPath, JSON.stringify({
+        slug,
+        basis: {
+            prd: {
+                path: relativeToRepo(prdPath),
+                sha1: computeGitBlobSha1(prdActual),
+            },
+            testSpecs: [{
+                    path: relativeToRepo(testSpecPath),
+                    sha1: computeGitBlobSha1(testSpecActual),
+                }],
+        },
+        entries,
+    }, null, 2));
+}
 describe('context pack handoff status', () => {
     beforeEach(async () => { await setup(); });
     afterEach(async () => { await cleanup(); });
@@ -126,6 +145,8 @@ describe('context pack handoff status', () => {
         assert.equal(status.contextPackStatus, 'plan-only');
         assert.equal(status.baselineState, 'present');
         assert.equal(status.outcomeState, 'absent');
+        assert.equal(status.declarationState, 'unknown');
+        assert.equal(status.contextPackRoleRefs, null);
         assert.equal(status.roleCoverage, 'unknown');
         assert.deepEqual(status.missingRequiredContextPackRoles, []);
         assert.deepEqual(status.contextPackIssues, []);
@@ -143,11 +164,313 @@ describe('context pack handoff status', () => {
         assert.deepEqual(status.contextPack, { path: packPath });
         assert.equal(status.contextPackStatus, 'ready');
         assert.equal(status.packState, 'valid');
+        assert.equal(status.declarationState, 'matching');
         assert.equal(status.roleCoverage, 'covered');
         assert.equal(status.basisState, 'fresh');
+        assert.deepEqual(status.contextPackRoleRefs, {
+            scope: ['src/scope-0.ts'],
+            build: ['src/build-1.ts'],
+            verify: ['src/verify-2.ts'],
+        });
         assert.deepEqual(status.missingRequiredContextPackRoles, []);
         assert.deepEqual(status.contextPackIssues, []);
     });
+    it('keeps the handoff state machine invariant under private metadata variations and counterfactuals', async () => {
+        const cases = [
+            {
+                slug: 'ready-valid-private-metadata',
+                entries: [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    {
+                        path: 'src/build.ts',
+                        roles: ['build'],
+                        label: 'Runtime Contract',
+                        tags: ['runtime', 'build'],
+                        selector: { type: 'heading', value: '## Runtime Contract', maxWords: 120 },
+                        relationPath: [
+                            { tag: 'plan', target: 'ready-valid-private-metadata' },
+                            { tag: 'implements', target: 'src/build.ts#runtime-contract' },
+                        ],
+                    },
+                    {
+                        path: 'src/verify.ts',
+                        roles: ['verify'],
+                        selector: { type: 'lines', start: 2, end: 4 },
+                    },
+                ],
+                expected: {
+                    status: 'ready',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'covered',
+                    roleRefs: {
+                        scope: ['src/scope.ts'],
+                        build: ['src/build.ts'],
+                        verify: ['src/verify.ts'],
+                    },
+                },
+            },
+            {
+                slug: 'ready-invalid-private-metadata',
+                entries: [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    {
+                        path: 'src/build.ts',
+                        roles: ['build'],
+                        selector: { type: 'heading', value: 'Runtime Contract', maxWords: 20 },
+                    },
+                    { path: 'src/verify.ts', roles: ['verify'] },
+                ],
+                expected: {
+                    status: 'ready',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'covered',
+                    roleRefs: {
+                        scope: ['src/scope.ts'],
+                        build: ['src/build.ts'],
+                        verify: ['src/verify.ts'],
+                    },
+                },
+            },
+            {
+                slug: 'incomplete-invalid-private-metadata',
+                entries: [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    {
+                        path: 'src/build.ts',
+                        roles: ['build'],
+                        relationPath: [
+                            { tag: 'plan', target: 'alpha' },
+                            { tag: 'evidence', target: 'beta' },
+                            { tag: 'implements', target: 'gamma' },
+                            { tag: 'dependency', target: 'delta' },
+                            { tag: 'bounds', target: 'epsilon' },
+                            { tag: 'verifies', target: 'zeta' },
+                        ],
+                    },
+                ],
+                expected: {
+                    status: 'incomplete',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'missing-required-roles',
+                    roleRefs: null,
+                    missingRoles: ['verify'],
+                },
+            },
+            {
+                slug: 'invalid-stale-private-metadata',
+                entries: [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    {
+                        path: 'src/build.ts',
+                        roles: ['build'],
+                        tags: ['runtime', '', 'verify'],
+                    },
+                    { path: 'src/verify.ts', roles: ['verify'] },
+                ],
+                mutate: async ({ testSpecPath }) => {
+                    await writeFile(testSpecPath, '# Drifted Test Spec\n');
+                },
+                expected: {
+                    status: 'invalid',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'covered',
+                    roleRefs: null,
+                    issue: 'basis test-spec hash',
+                },
+            },
+        ];
+        for (const testCase of cases) {
+            const fixture = await writeApprovedPlan(testCase.slug, [
+                '# PRD',
+                '',
+                buildContextPackOutcome(canonicalContextPackRelativePath(testCase.slug)),
+                '',
+                `Launch via omx ralph ${JSON.stringify(`Execute ${testCase.slug} plan`)}`,
+            ]);
+            await writeContextPackWithEntries(testCase.slug, fixture.prdPath, fixture.testSpecPath, testCase.entries);
+            if (testCase.mutate) {
+                await testCase.mutate(fixture);
+            }
+            const status = readContextPackHandoffStatus(tempDir, fixture.prdPath);
+            assert.equal(status.contextPackStatus, testCase.expected.status, `status mismatch for ${testCase.slug}`);
+            assert.equal(status.packState, testCase.expected.packState, `packState mismatch for ${testCase.slug}`);
+            assert.equal(status.declarationState, testCase.expected.declarationState, `declarationState mismatch for ${testCase.slug}`);
+            assert.equal(status.basisState, testCase.expected.basisState, `basisState mismatch for ${testCase.slug}`);
+            assert.equal(status.roleCoverage, testCase.expected.roleCoverage, `roleCoverage mismatch for ${testCase.slug}`);
+            assert.deepEqual(status.contextPackRoleRefs, testCase.expected.roleRefs, `role refs mismatch for ${testCase.slug}`);
+            assert.deepEqual(status.missingRequiredContextPackRoles, testCase.expected.missingRoles ?? [], `missing roles mismatch for ${testCase.slug}`);
+            if (testCase.expected.issue) {
+                assert.ok(status.contextPackIssues.some((issue) => issue.includes(testCase.expected.issue ?? '')), `expected issue containing ${testCase.expected.issue} for ${testCase.slug}`);
+            }
+            else {
+                assert.deepEqual(status.contextPackIssues, [], `issues should stay empty for ${testCase.slug}`);
+            }
+        }
+    });
+    it('keeps the public handoff state machine invariant across exhaustive private metadata modes', async () => {
+        const metadataVariants = [
+            {
+                name: 'none',
+                buildMetadata: () => ({}),
+            },
+            {
+                name: 'valid-heading',
+                buildMetadata: (slug) => ({
+                    label: 'Runtime Contract',
+                    tags: ['runtime', 'build'],
+                    selector: { type: 'heading', value: ' ## Runtime Contract ', maxWords: 120 },
+                    relationPath: [
+                        { tag: 'Plan', target: ` ${slug} ` },
+                        { tag: 'Implements', target: ' src/build.ts#runtime-contract ' },
+                    ],
+                }),
+            },
+            {
+                name: 'valid-lines',
+                buildMetadata: (slug) => ({
+                    label: 'Verify Slice',
+                    selector: { type: 'lines', start: 2, end: 5 },
+                    relationPath: [
+                        { tag: 'Plan', target: ` ${slug} ` },
+                        { tag: 'Verifies', target: ' src/build.ts:2-5 ' },
+                    ],
+                }),
+            },
+            {
+                name: 'invalid-label',
+                buildMetadata: () => ({ label: '---' }),
+            },
+            {
+                name: 'invalid-tags',
+                buildMetadata: () => ({ tags: ['runtime', '', 'verify'] }),
+            },
+            {
+                name: 'invalid-selector-extra-key',
+                buildMetadata: () => ({
+                    selector: { type: 'heading', value: 'Runtime Contract', extra: true },
+                }),
+            },
+            {
+                name: 'invalid-relation-too-many-steps',
+                buildMetadata: () => ({
+                    relationPath: [
+                        { tag: 'plan', target: 'alpha' },
+                        { tag: 'evidence', target: 'beta' },
+                        { tag: 'dependency', target: 'gamma' },
+                        { tag: 'links-to', target: 'delta' },
+                        { tag: 'bounds', target: 'epsilon' },
+                        { tag: 'verifies', target: 'zeta' },
+                    ],
+                }),
+            },
+            {
+                name: 'invalid-relation-step-extra-key',
+                buildMetadata: () => ({
+                    relationPath: [{ tag: 'plan', target: 'alpha', extra: true }],
+                }),
+            },
+            {
+                name: 'invalid-entry-extra-key',
+                buildMetadata: () => ({ unexpected: true }),
+            },
+        ];
+        const scenarios = [
+            {
+                name: 'ready',
+                buildEntries: (metadata) => [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    { path: 'src/build.ts', roles: ['build'], ...metadata },
+                    { path: 'src/verify.ts', roles: ['verify'] },
+                ],
+                expected: {
+                    status: 'ready',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'covered',
+                    roleRefs: {
+                        scope: ['src/scope.ts'],
+                        build: ['src/build.ts'],
+                        verify: ['src/verify.ts'],
+                    },
+                },
+            },
+            {
+                name: 'incomplete',
+                buildEntries: (metadata) => [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    { path: 'src/build.ts', roles: ['build'], ...metadata },
+                ],
+                expected: {
+                    status: 'incomplete',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'missing-required-roles',
+                    roleRefs: null,
+                    missingRoles: ['verify'],
+                },
+            },
+            {
+                name: 'stale',
+                buildEntries: (metadata) => [
+                    { path: 'src/scope.ts', roles: ['scope'] },
+                    { path: 'src/build.ts', roles: ['build'], ...metadata },
+                    { path: 'src/verify.ts', roles: ['verify'] },
+                ],
+                mutate: async ({ testSpecPath }) => {
+                    await writeFile(testSpecPath, '# Drifted Test Spec\n');
+                },
+                expected: {
+                    status: 'invalid',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'covered',
+                    roleRefs: null,
+                    issue: 'basis test-spec hash',
+                },
+            },
+        ];
+        for (const scenario of scenarios) {
+            for (const metadataVariant of metadataVariants) {
+                const slug = `${scenario.name}-${metadataVariant.name}`;
+                const fixture = await writeApprovedPlan(slug, [
+                    '# PRD',
+                    '',
+                    buildContextPackOutcome(canonicalContextPackRelativePath(slug)),
+                    '',
+                    `Launch via omx ralph ${JSON.stringify(`Execute ${slug} plan`)}`,
+                ]);
+                await writeContextPackWithEntries(slug, fixture.prdPath, fixture.testSpecPath, scenario.buildEntries(metadataVariant.buildMetadata(slug)));
+                if (scenario.mutate) {
+                    await scenario.mutate(fixture);
+                }
+                const status = readContextPackHandoffStatus(tempDir, fixture.prdPath);
+                assert.equal(status.contextPackStatus, scenario.expected.status, `status mismatch for ${slug}`);
+                assert.equal(status.packState, scenario.expected.packState, `packState mismatch for ${slug}`);
+                assert.equal(status.declarationState, scenario.expected.declarationState, `declarationState mismatch for ${slug}`);
+                assert.equal(status.basisState, scenario.expected.basisState, `basisState mismatch for ${slug}`);
+                assert.equal(status.roleCoverage, scenario.expected.roleCoverage, `roleCoverage mismatch for ${slug}`);
+                assert.deepEqual(status.contextPackRoleRefs, scenario.expected.roleRefs, `role refs mismatch for ${slug}`);
+                assert.deepEqual(status.missingRequiredContextPackRoles, scenario.expected.missingRoles ?? [], `missing roles mismatch for ${slug}`);
+                if (scenario.expected.issue) {
+                    assert.ok(status.contextPackIssues.some((issue) => issue.includes(scenario.expected.issue ?? '')), `expected issue containing ${scenario.expected.issue} for ${slug}`);
+                }
+                else {
+                    assert.deepEqual(status.contextPackIssues, [], `issues should stay empty for ${slug}`);
+                }
+            }
+        }
+    });
     it('reports incomplete when the declared pack omits required execution roles', async () => {
         const { prdPath, testSpecPath } = await writeApprovedPlan('gamma', [
             '# PRD',
@@ -159,6 +482,9 @@ describe('context pack handoff status', () => {
         await writeContextPack('gamma', prdPath, testSpecPath, ['scope']);
         const status = readContextPackHandoffStatus(tempDir);
         assert.equal(status.contextPackStatus, 'incomplete');
+        assert.equal(status.roleCoverage, 'missing-required-roles');
+        assert.equal(status.contextPackRoleRefs, null);
+        assert.equal(status.roleCoverage, 'missing-required-roles');
         assert.deepEqual(status.missingRequiredContextPackRoles, ['build', 'verify']);
     });
     it('reports invalid when the declared pack basis drifts from the approved test spec', async () => {
@@ -174,6 +500,9 @@ describe('context pack handoff status', () => {
         const status = readContextPackHandoffStatus(tempDir);
         assert.equal(status.contextPackStatus, 'invalid');
         assert.equal(status.roleCoverage, 'covered');
+        assert.equal(status.basisState, 'stale');
+        assert.equal(status.contextPackRoleRefs, null);
+        assert.equal(status.basisState, 'stale');
         assert.deepEqual(status.missingRequiredContextPackRoles, []);
         assert.ok(status.contextPackIssues.some((issue) => issue.includes('basis test-spec hash')));
     });
@@ -190,6 +519,7 @@ describe('context pack handoff status', () => {
         const status = readContextPackHandoffStatus(tempDir);
         assert.equal(status.contextPackStatus, 'invalid');
         assert.equal(status.roleCoverage, 'missing-required-roles');
+        assert.equal(status.contextPackRoleRefs, null);
         assert.deepEqual(status.missingRequiredContextPackRoles, ['build', 'verify']);
         assert.ok(status.contextPackIssues.some((issue) => issue.includes('basis test-spec hash')));
     });
@@ -205,6 +535,7 @@ describe('context pack handoff status', () => {
         const status = readContextPackHandoffStatus(tempDir);
         assert.equal(status.contextPackStatus, 'invalid');
         assert.equal(status.packState, 'invalid');
+        assert.equal(status.contextPackRoleRefs, null);
         assert.equal(status.roleCoverage, 'unknown');
         assert.deepEqual(status.missingRequiredContextPackRoles, []);
         assert.ok(status.contextPackIssues.some((issue) => issue.includes('invalid JSON')));
@@ -225,6 +556,97 @@ describe('context pack handoff status', () => {
         assert.equal(status.contextPackStatus, 'plan-only');
         assert.equal(status.outcomeState, 'absent');
     });
+    it('ignores indented outcome declarations and keeps the plan in plan-only status', async () => {
+        await writeApprovedPlan('epsilon-indented', [
+            '# PRD',
+            '',
+            '    ## Context Pack Outcome',
+            '',
+            `    - pack: created \`${canonicalContextPackRelativePath('epsilon-indented')}\``,
+            '',
+            'Launch via omx ralph "Execute epsilon indented plan"',
+        ]);
+        const status = readContextPackHandoffStatus(tempDir);
+        assert.equal(status.contextPackStatus, 'plan-only');
+        assert.equal(status.outcomeState, 'absent');
+    });
+    it('ignores commented outcome declarations and keeps the plan in plan-only status', async () => {
+        await writeApprovedPlan('epsilon-commented', [
+            '# PRD',
+            '',
+            '<!--',
+            '## Context Pack Outcome',
+            '',
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-commented-hidden')}\``,
+            '<!--',
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-commented-hidden-deeper')}\``,
+            '-->',
+            '-->',
+            '',
+            'Launch via omx ralph "Execute epsilon commented plan"',
+        ]);
+        const status = readContextPackHandoffStatus(tempDir);
+        assert.equal(status.contextPackStatus, 'plan-only');
+        assert.equal(status.outcomeState, 'absent');
+    });
+    it('ignores adversarial hidden outcome declarations and still reads the visible declaration', async () => {
+        const { prdPath, testSpecPath } = await writeApprovedPlan('epsilon-adversarial', [
+            '# PRD',
+            '',
+            '```md',
+            '## Context Pack Outcome',
+            '',
+            `- pack: created \`${canonicalContextPackRelativePath('sample-hidden')}\``,
+            '    ```',
+            '```still-open',
+            '~~~',
+            '## Context Pack Outcome',
+            '',
+            `- pack: created \`${canonicalContextPackRelativePath('other-hidden')}\``,
+            '```',
+            '',
+            buildContextPackOutcome(canonicalContextPackRelativePath('epsilon-adversarial')),
+            '',
+            'Launch via omx ralph "Execute epsilon adversarial plan"',
+        ]);
+        await writeContextPack('epsilon-adversarial', prdPath, testSpecPath, ['scope', 'build', 'verify']);
+        const status = readContextPackHandoffStatus(tempDir);
+        assert.equal(status.contextPackStatus, 'ready');
+        assert.equal(status.outcomeState, 'declared');
+        assert.deepEqual(status.contextPack, {
+            path: join(tempDir, canonicalContextPackRelativePath('epsilon-adversarial')),
+        });
+        assert.deepEqual(status.contextPackIssues, []);
+    });
+    it('keeps the visible outcome section valid when nested hidden blocks appear inside it', async () => {
+        const { prdPath, testSpecPath } = await writeApprovedPlan('epsilon-inner-hidden', [
+            '# PRD',
+            '',
+            '## Context Pack Outcome',
+            '',
+            '<!--',
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-inner-hidden-comment')}\``,
+            '<!--',
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-inner-hidden-comment-deeper')}\``,
+            '-->',
+            '-->',
+            '```md',
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-inner-hidden-fenced')}\``,
+            '```',
+            `    - pack: created \`${canonicalContextPackRelativePath('epsilon-inner-hidden-indented')}\``,
+            `- pack: created \`${canonicalContextPackRelativePath('epsilon-inner-hidden')}\``,
+            '',
+            'Launch via omx ralph "Execute epsilon inner hidden plan"',
+        ]);
+        await writeContextPack('epsilon-inner-hidden', prdPath, testSpecPath, ['scope', 'build', 'verify']);
+        const status = readContextPackHandoffStatus(tempDir);
+        assert.equal(status.contextPackStatus, 'ready');
+        assert.equal(status.outcomeState, 'declared');
+        assert.deepEqual(status.contextPack, {
+            path: join(tempDir, canonicalContextPackRelativePath('epsilon-inner-hidden')),
+        });
+        assert.deepEqual(status.contextPackIssues, []);
+    });
     it('rejects nested outcome paths that are not canonical context-pack files', async () => {
         await writeApprovedPlan('eta', [
             '# PRD',
@@ -249,6 +671,7 @@ describe('context pack handoff status', () => {
         const status = readContextPackHandoffStatus(tempDir);
         assert.equal(status.contextPackStatus, 'invalid');
         assert.equal(status.outcomeState, 'declared');
+        assert.equal(status.declarationState, 'mismatched');
         assert.equal(status.packState, 'invalid');
         assert.ok(status.contextPackIssues.some((issue) => issue.includes('does not match approved plan slug theta')));
     });
@@ -267,5 +690,106 @@ describe('context pack handoff status', () => {
         assert.equal(status.outcomeState, 'ambiguous');
         assert.ok(status.contextPackIssues.some((issue) => issue.includes('multiple Context Pack Outcome sections')));
     });
+    it('distinguishes missing, unreadable, invalid, stale, mismatched, and missing-role handoffs', async () => {
+        const cases = [
+            {
+                slug: 'missing-pack',
+                mutate: async () => { },
+                expected: {
+                    status: 'incomplete',
+                    packState: 'missing',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'unknown',
+                    issue: 'file is missing',
+                },
+            },
+            {
+                slug: 'unreadable-pack',
+                mutate: async ({ packPath }) => { await mkdir(packPath, { recursive: true }); },
+                expected: {
+                    status: 'invalid',
+                    packState: 'unreadable',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'unknown',
+                    issue: 'could not be read',
+                },
+            },
+            {
+                slug: 'invalid-pack',
+                mutate: async ({ packPath }) => { await writeFile(packPath, '{bad json'); },
+                expected: {
+                    status: 'invalid',
+                    packState: 'invalid',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'unknown',
+                    issue: 'invalid JSON',
+                },
+            },
+            {
+                slug: 'stale-basis',
+                mutate: async ({ prdPath, testSpecPath }) => {
+                    await writeContextPack('stale-basis', prdPath, testSpecPath, ['scope', 'build', 'verify']);
+                    await writeFile(testSpecPath, '# Drifted Test Spec\n');
+                },
+                expected: {
+                    status: 'invalid',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'stale',
+                    roleCoverage: 'covered',
+                    issue: 'basis test-spec hash',
+                },
+            },
+            {
+                slug: 'missing-role',
+                mutate: async ({ prdPath, testSpecPath }) => {
+                    await writeContextPack('missing-role', prdPath, testSpecPath, ['scope']);
+                },
+                expected: {
+                    status: 'incomplete',
+                    packState: 'valid',
+                    declarationState: 'matching',
+                    basisState: 'fresh',
+                    roleCoverage: 'missing-required-roles',
+                    missingRoles: ['build', 'verify'],
+                },
+            },
+        ];
+        for (const testCase of cases) {
+            const fixture = await writeApprovedPlan(testCase.slug, [
+                '# PRD',
+                '',
+                buildContextPackOutcome(canonicalContextPackRelativePath(testCase.slug)),
+                '',
+                `Launch via omx ralph "Execute ${testCase.slug} plan"`,
+            ]);
+            await testCase.mutate(fixture);
+            const status = readContextPackHandoffStatus(tempDir, fixture.prdPath);
+            assert.equal(status.contextPackStatus, testCase.expected.status);
+            assert.equal(status.packState, testCase.expected.packState);
+            assert.equal(status.declarationState, testCase.expected.declarationState);
+            assert.equal(status.basisState, testCase.expected.basisState);
+            assert.equal(status.roleCoverage, testCase.expected.roleCoverage);
+            assert.deepEqual(status.missingRequiredContextPackRoles, testCase.expected.missingRoles ?? []);
+            if (testCase.expected.issue) {
+                assert.ok(status.contextPackIssues.some((issue) => issue.includes(testCase.expected.issue ?? '')), `expected issue containing ${testCase.expected.issue}`);
+            }
+        }
+        const mismatch = await writeApprovedPlan('declared-mismatch', [
+            '# PRD',
+            '',
+            buildContextPackOutcome(canonicalContextPackRelativePath('other')),
+            '',
+            'Launch via omx ralph "Execute mismatch plan"',
+        ]);
+        const mismatchStatus = readContextPackHandoffStatus(tempDir, mismatch.prdPath);
+        assert.equal(mismatchStatus.contextPackStatus, 'invalid');
+        assert.equal(mismatchStatus.declarationState, 'mismatched');
+        assert.equal(mismatchStatus.packState, 'invalid');
+        assert.ok(mismatchStatus.contextPackIssues.some((issue) => issue.includes('does not match approved plan slug')));
+    });
 });
 //# sourceMappingURL=context-pack-status.test.js.map