@haposoft/cafekit 0.16.7 → 0.18.1

package/bin/__tests__/codex-native.test.js

@@ -69,7 +69,7 @@ const DOCS_ADAPTIVE_BUNDLE = [
   'references/update-workflow.md',
   'references/standard-docs-workflow.md'
 ];
-const HOTFIX_SOURCE_ROOT = path.join(PACKAGE_ROOT, 'src/claude/skills/hotfix');
+const HOTFIX_SOURCE_ROOT = path.join(PACKAGE_ROOT, 'src/claude/skills/fix');
 const HOTFIX_BUNDLE = [
   'SKILL.md',
   'references/diagnosis-protocol.md',
@@ -111,7 +111,7 @@ function boundaryTableHasRequiredRows(table) {
 }
 
 const IMPLEMENTATION_READINESS_CLAUSES = {
-  noInvention: 'Before implementation handoff, apply the **no-invention gate**: if two implementations conform to the packet text yet can produce different externally observable output, state, error, security, or compatibility behavior, surface the missing choice as an explicit C1 or C2 question and block handoff.',
+  noInvention: 'Before implementation handoff, apply the **no-invention gate**: if two implementations conform to the packet text yet can produce different externally observable output, state, error, security, or compatibility behavior, surface the missing choice as an explicit GATE-SCOPE or GATE-REVIEW question and block handoff.',
   materialDefinition: 'A boundary is material when the task creates, changes, or depends on it and a different choice changes an external observation, security, durable data, compatibility, or proof reachability. Require only the matching material row; omit nonmaterial categories.',
   exactBoundaryChoices: 'For every required row, name each listed choice exactly; labels such as “JSON”, “local path”, “locked”, or “timestamped” alone remain unresolved.',
   proofPlanLines: [
@@ -130,11 +130,11 @@ const IMPLEMENTATION_READINESS_CLAUSES = {
   disposableReviewControls: 'Run mutation or destructive negative controls only on disposable copies below a verified temporary root, never tracked worktree or canonical source bytes.',
   failureSemantics: '`Crash` means abrupt unhandled termination before the claimed catch point; a catchable failure returns/raises an error or exits nonzero. Never use them interchangeably.',
   privacyIdentifiers: 'Any privacy/security claim names the exact identifier surface at risk, such as an env var, header, path, token class, or field name; generic “sensitive data” is insufficient.',
-  freshReplay: 'After applying an accepted C2 finding, a fresh-context closure pass records and freshly replays its original counterexample after the repair under this exact review-log header:',
+  freshReplay: 'After applying an accepted GATE-REVIEW finding, a fresh-context closure pass records and freshly replays its original counterexample after the repair under this exact review-log header:',
   distinctRepairProof: '`Repaired at` cites the repair edit; `Proved at` must cite distinct evidence from the fresh replay, never the repair-edit citation.',
   closureTransition: 'An accepted finding transitions `accepted → repaired → PASS|FAIL|UNKNOWN`.',
   unknownBlocks: 'Only `PASS` closes it; `FAIL` remains open for the remaining paper-review round; `UNKNOWN` blocks implementation handoff.',
-  scopeReturnsToC1: 'A repair that adds user semantics or scope returns to C1.'
+  scopeReturnsToC1: 'A repair that adds user semantics or scope returns to GATE-SCOPE.'
 };
 const ADAPTIVE_COVERAGE_PROFILE_HEADER = [
   'ID', 'Outcome', 'Change kinds', 'Material surfaces', 'Ambiguity/action',
@@ -148,7 +148,7 @@ const ADAPTIVE_COVERAGE_AMBIGUITY_ROWS = [
   ['State', 'Required action'],
   ['`none`', 'proceed'],
   ['`examples-needed`', 'add two or three examples only for an already decided rule; promote to `decision-needed` if an example changes observable behavior'],
-  ['`decision-needed`', 'ask the user at C1/C2 and keep affected tasks blocked'],
+  ['`decision-needed`', 'ask the user at GATE-SCOPE/GATE-REVIEW and keep affected tasks blocked'],
   ['`design-needed`', 'after user-owned decisions settle, route material competing technical designs through Brainstorm']
 ];
 const ADAPTIVE_REVIEWER_ROWS = [
@@ -169,12 +169,12 @@ const ADAPTIVE_COVERAGE_CLAUSES = {
   openKinds: 'Change kinds are multi-valued (`add`, `modify`, `fix`, `refactor`, `remove`, `migrate`, `integrate`), and unfamiliar kinds or surfaces use `other:<verbatim>` rather than disappearing.',
   scopedUnion: 'Each task references its CP IDs; authoring, review, edge, and proof obligations union only inside affected rows/tasks.',
   profileRederivation: 'Rederive affected CP rows after any accepted scope, outcome, criteria, ownership, dependency, risk, or proof delta before task status.',
-  plannedProof: '`Required proof` is a planned level set, not execution\nevidence: known but unrun proof may be `pending`; `UNKNOWN` reachability blocks\n`pending`; missing, failed, or unavailable required evidence blocks `done`/C3.',
+  plannedProof: '`Required proof` is a planned level set, not execution\nevidence: known but unrun proof may be `pending`; `UNKNOWN` reachability blocks\n`pending`; missing, failed, or unavailable required evidence blocks `done`/GATE-DONE.',
   proofSeparation: 'Levels stay separate and never promote one another.',
   liveLimit: 'Source/static checks prove the written contract, not live-model adherence.',
   specMakerAuthority: 'they are the canonical risk and coverage authority. Do not duplicate\ntheir taxonomy here.',
   specMakerAmbiguity: 'Apply the canonical ambiguity action; examples never decide observable behavior.',
-  specMakerRoute: 'Apply their risk-first route before C1 and stop when the\nrequest qualifies for direct work; hand off when it requires Brainstorm-only exploration.',
+  specMakerRoute: 'Apply their risk-first route before GATE-SCOPE and stop when the\nrequest qualifies for direct work; hand off when it requires Brainstorm-only exploration.',
   reviewRisk: 'Keep Fact Checker as the baseline. Assign every remaining material CP risk to a\nnamed reviewer lens; a critical row includes both relevant security-adversary and\nfailure-mode coverage, and nonmaterial lenses are not added.',
   reviewCapacity: 'Reviewer count is fixed by the table, not lens count. Give each reviewer a distinct primary lens; when material lenses exceed reviewers, combine related named lenses on one reviewer and keep every material lens assigned.'
 };
@@ -182,12 +182,7 @@ const V3_SPECS_BUNDLE = [
   'SKILL.md',
   'references/review.md',
   'references/templates.md',
-  'templates/design.md',
-  'templates/requirements-init.md',
-  'templates/requirements.md',
-  'templates/research.md',
-  'templates/spec-state.json',
-  'templates/task.md'
+  'templates/research.md'
 ];
 const OBSOLETE_SPECS_FILES = [
   'references/archive-workflow.md',
@@ -272,64 +267,6 @@ function replaceGeneratedTomlString(content, key, value) {
   return content.replace(pattern, `${key} = ${JSON.stringify(value)}`);
 }
 
-function renderCanonicalVerificationExample(template) {
-  const values = new Map([
-    ['SUBJECT_REQ', '1'],
-    ['X', '1'],
-    ['PROOF_REQ', '1'],
-    ['Y', '2'],
-    ['exact command', 'node --test test/installed.test.js'],
-    ['exact anchored target', 'src/installed.js#entry'],
-    ['exact/repository/entrypoint', 'src/installed.js'],
-    ['observable result', 'the subject behavior and verifier proof both pass'],
-    ['concrete observable result and proof', 'the subject behavior and verifier proof both pass'],
-    ['concrete rejected or recovery case', 'invalid input remains rejected and observable'],
-    ['real entrypoint/caller and grounded anchor expectation', 'the installed entrypoint reaches A-D-01'],
-  ]);
-  return template.replace(/\{\{([^}]+)\}\}/g, (placeholder, name) => (
-    values.has(name) ? values.get(name) : placeholder
-  ));
-}
-
-function assertInstalledVerificationModel(grounderPath, designTemplate) {
-  const { parseVerificationDefinitions } = require(grounderPath);
-  assert.equal(typeof parseVerificationDefinitions, 'function');
-  const concreteDesign = renderCanonicalVerificationExample(designTemplate);
-  const errors = [];
-  const definitions = parseVerificationDefinitions(concreteDesign, errors);
-  assert.deepEqual(errors, []);
-  assert.equal(definitions.size, 1);
-  const definition = definitions.get('V1');
-  assert.ok(definition);
-  assert.deepEqual(definition.subject_criteria, ['R1.1']);
-  assert.deepEqual(definition.proof_criteria, []);
-  assert.equal(definition.proof_owner, null);
-  assert.equal(definition.evidence_anchor, null);
-  assert.deepEqual(definition.decision_refs, ['D1', 'I1', 'C1']);
-  for (const field of [
-    'subject_criteria', 'subject_owner', 'decision_refs', 'method', 'expected',
-    'negative', 'reachability'
-  ]) {
-    const value = definition[field];
-    assert.ok(
-      Array.isArray(value)
-        ? value.length > 0
-        : (typeof value === 'string' ? value.trim() !== '' : value && Object.keys(value).length > 0)
-    );
-  }
-  for (const mutation of [
-    concreteDesign.replace('- **V1**:', '### V1 —'),
-    concreteDesign.replace('- **V1**:', '| V1 |'),
-    concreteDesign.replace('; Expected ', '\nExpected '),
-    concreteDesign.replace('Decision refs ', 'Decisions '),
-  ]) {
-    const mutationErrors = [];
-    const mutated = parseVerificationDefinitions(mutation, mutationErrors);
-    assert.ok(mutationErrors.length > 0);
-    assert.equal(mutated.has('V1'), false);
-  }
-}
-
 function markdownSection(content, heading) {
   const lines = String(content).split('\n');
   const start = lines.findIndex((line) => line.trim() === `## ${heading}`);
@@ -558,7 +495,7 @@ function authoringProjectionIssues(files) {
     || !files.templates.includes('task-NN-<slug>.md')) {
     issues.push('flat-layout-template');
   }
-  for (const gate of ['C1 — Scope', 'C2 — Findings', 'C3 — Done']) {
+  for (const gate of ['GATE-SCOPE', 'GATE-REVIEW', 'GATE-DONE']) {
     if (!files.skill.includes(gate)) issues.push(`human-gate-${gate.slice(0, 2).toLowerCase()}`);
   }
   if (!files.review.includes('fresh-context red team')
@@ -596,7 +533,7 @@ function authoringProjectionIssues(files) {
   }
   if (!files.codex.includes('flat `task-NN-*.md` files')
     || !files.codex.includes('inline `## Receipt`')
-    || !files.codex.includes('C1') || !files.codex.includes('C2') || !files.codex.includes('C3')) {
+    || !files.codex.includes('GATE-SCOPE') || !files.codex.includes('GATE-REVIEW') || !files.codex.includes('GATE-DONE')) {
     issues.push('codex-process-v3');
   }
   return [...new Set(issues)].sort();
@@ -1203,8 +1140,8 @@ function assertInstalledAuthoringProjection(root, installedRoot) {
       name: 'fresh-original-counterexample-replay',
       issue: 'repair-closure',
       relative: 'references/review.md',
-      from: 'After applying an accepted C2 finding, a fresh-context closure pass records and\nfreshly replays its original counterexample after the repair under this exact review-log header:',
-      to: 'After applying an accepted C2 finding, record the repair under this review-log header:'
+      from: 'After applying an accepted GATE-REVIEW finding, a fresh-context closure pass records and\nfreshly replays its original counterexample after the repair under this exact review-log header:',
+      to: 'After applying an accepted GATE-REVIEW finding, record the repair under this review-log header:'
     },
     {
       name: 'distinct-repair-and-proof-evidence',
@@ -1313,7 +1250,7 @@ function assertInstalledAuthoringProjection(root, installedRoot) {
     ['stale-profile-after-c2', 'templates', ADAPTIVE_COVERAGE_CLAUSES.profileRederivation,
       'Keep existing coverage rows after accepted plan changes.', ['profile-lifecycle']],
     ['planned-proof-blocks-start', 'templates', ADAPTIVE_COVERAGE_CLAUSES.plannedProof,
-      '`Required proof` is execution evidence: known but unrun proof blocks `pending`; `UNKNOWN` may proceed; missing evidence may still reach `done`/C3.', ['proof-lifecycle']],
+      '`Required proof` is execution evidence: known but unrun proof blocks `pending`; `UNKNOWN` may proceed; missing evidence may still reach `done`/GATE-DONE.', ['proof-lifecycle']],
     ['source-promotes-live', 'templates', ADAPTIVE_COVERAGE_CLAUSES.proofSeparation,
       'Source proof may promote installed and live proof.', ['proof-lifecycle']],
     ['unmapped-proof-level', 'templates', IMPLEMENTATION_READINESS_CLAUSES.proofLevelMapping,
@@ -1327,7 +1264,7 @@ function assertInstalledAuthoringProjection(root, installedRoot) {
     ['spec-maker-examples-decide', 'specMaker', ADAPTIVE_COVERAGE_CLAUSES.specMakerAmbiguity,
       'Use examples to settle every ambiguous observable behavior.', ['spec-maker-authority']],
     ['spec-maker-skips-brainstorm', 'specMaker', ADAPTIVE_COVERAGE_CLAUSES.specMakerRoute,
-      'Apply the risk-first route before C1 and stop only for direct work.', ['spec-maker-authority']],
+      'Apply the risk-first route before GATE-SCOPE and stop only for direct work.', ['spec-maker-authority']],
     ['static-proves-live', 'skill', ADAPTIVE_COVERAGE_CLAUSES.liveLimit,
       'Source/static checks prove live-model adherence.', ['proof-lifecycle']]
   ];
@@ -1561,13 +1498,15 @@ test('Codex structured-input corpus oracle stays differential and production-awa
     'src/claude/agents/spec-maker.md',
     'src/claude/hooks/session.cjs',
     'src/claude/skills/git/SKILL.md',
-    'src/claude/skills/inspect/SKILL.md'
+    'src/claude/skills/scout/SKILL.md',
+    'src/claude/skills/sync/references/rebind-and-audit.md'
   ];
   assert.deepEqual(actualPaths, expectedPaths, 'every source occurrence needs an explicit projection oracle');
 
   const instructionExpectedSnippets = new Map([
     ['src/claude/skills/git/SKILL.md', 'Present options via a structured user-input request — header'],
-    ['src/claude/skills/inspect/SKILL.md', '**Fallback to a structured user-input request:**']
+    ['src/claude/skills/scout/SKILL.md', '**Fallback to a structured user-input request:**'],
+    ['src/claude/skills/sync/references/rebind-and-audit.md', 'End by asking with a structured user-input request when the host has']
   ]);
   for (const [relativePath, expectedSnippet] of instructionExpectedSnippets) {
     const sourcePath = path.join(PACKAGE_ROOT, relativePath);
@@ -1983,8 +1922,7 @@ test('Codex Windows hook launchers stay project-bound without Git from nested cw
     );
     const launchers = allHookLaunchers(config);
     assert.ok(launchers.length > 0, 'installed Codex config must register hook launchers');
-    const semanticReviewEvents = [];
-    for (const { event, handler } of launchers) {
+    for (const { handler } of launchers) {
       assert.doesNotMatch(handler.commandWindows, /\$\(/);
       assert.doesNotMatch(handler.commandWindows, /\bgit\b/i);
       assert.doesNotMatch(handler.commandWindows, /process\.cwd\(\)|existsSync/);
@@ -1997,11 +1935,7 @@ test('Codex Windows hook launchers stay project-bound without Git from nested cw
         true,
         `missing installed hook: ${path.basename(target)}`
       );
-      if (path.basename(target) === 'semantic-review-authority.cjs') {
-        semanticReviewEvents.push(event);
-      }
     }
-    assert.deepEqual(semanticReviewEvents, ['SubagentStop']);
 
     const nested = path.join(projectRoot, 'nested', 'workspace');
     fs.mkdirSync(nested, { recursive: true });
@@ -2163,22 +2097,12 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
       '.codex/rules/state-sync.md',
       '.codex/rules/review-audit-self-decision.md',
       '.codex/rules/process-management.md',
-      '.codex/scripts/spec-ground.cjs',
-      '.codex/scripts/validate-spec-output.cjs',
       '.agents/.gitignore',
       ...V3_SPECS_BUNDLE.map((file) => `.agents/skills/specs/${file}`)
     ]) {
       assert.equal(fs.existsSync(path.join(root, relative)), true, `missing ${relative}`);
     }
 
-    const installedDesign = fs.readFileSync(
-      path.join(root, '.agents/skills/specs/templates/design.md'), 'utf8'
-    );
-    assert.equal((installedDesign.match(/^## Verification Definitions$/gm) || []).length, 1);
-    assertInstalledVerificationModel(
-      path.join(root, '.codex/scripts/spec-ground.cjs'),
-      installedDesign
-    );
     const installedSpecsRoot = path.join(root, '.agents/skills/specs');
     assert.throws(
       () => installedAuthoringProjectionIssues(root, '.agents/skills/specs'),
@@ -2194,22 +2118,6 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     );
     assertInstalledAuthoringProjection(root, installedSpecsRoot);
 
-    const installedTask = fs.readFileSync(
-      path.join(root, '.agents/skills/specs/templates/task.md'), 'utf8'
-    );
-    assert.deepEqual(
-      [...installedTask.matchAll(/^## (.+)$/gm)].map((match) => match[1]),
-      ['Outcome', 'Scope', 'Anchors and Ownership', 'Changes', 'Acceptance', 'Dependencies', 'Verification Plan']
-    );
-    assert.match(installedTask, /^- \*\*Task role:\*\*/m);
-
-    const installedState = JSON.parse(fs.readFileSync(
-      path.join(root, '.agents/skills/specs/templates/spec-state.json'), 'utf8'
-    ));
-    assert.deepEqual(Object.keys(installedState.workflow_policy).sort(), [
-      'assurance_level', 'classified_minimum', 'planning_depth', 'risks', 'version'
-    ]);
-
     const agentsGitignore = fs.readFileSync(
       path.join(root, '.agents', '.gitignore'),
       'utf8'
@@ -2220,7 +2128,6 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
 
     if (process.platform !== 'win32') {
       for (const [sourceRelative, installedRelative] of [
-        ['src/claude/scripts/validate-spec-output.cjs', '.codex/scripts/validate-spec-output.cjs'],
         ['src/claude/skills/chrome-devtools/scripts/install.sh', '.agents/skills/chrome-devtools/scripts/install.sh'],
         ['src/claude/skills/ai-multimodal/scripts/check_setup.py', '.agents/skills/ai-multimodal/scripts/check_setup.py']
       ]) {
@@ -2260,24 +2167,24 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     assert.ok(skillNames.every((name) => /^[a-z0-9-]+$/.test(name)));
 
     const scoutSkill = fs.readFileSync(
-      path.join(root, '.agents', 'skills', 'inspect', 'SKILL.md'),
+      path.join(root, '.agents', 'skills', 'scout', 'SKILL.md'),
       'utf8'
     );
     assert.match(scoutSkill, /^name:\s*cf-scout$/m);
     assert.equal(
-      fs.existsSync(path.join(root, '.agents', 'skills', 'scout')),
+      fs.existsSync(path.join(root, '.agents', 'skills', 'inspect')),
       false,
-      'public Scout rename must keep the manifest-owned inspect directory'
+      'Scout lives in the scout directory; the retired inspect directory must not be installed'
     );
     const askSkill = fs.readFileSync(
-      path.join(root, '.agents', 'skills', 'question', 'SKILL.md'),
+      path.join(root, '.agents', 'skills', 'ask', 'SKILL.md'),
       'utf8'
     );
     assert.match(askSkill, /^name:\s*cf-ask$/m);
     assert.equal(
-      fs.existsSync(path.join(root, '.agents', 'skills', 'ask')),
+      fs.existsSync(path.join(root, '.agents', 'skills', 'question')),
       false,
-      'public Ask rename must keep the manifest-owned question directory'
+      'Ask lives in the ask directory; the retired question directory must not be installed'
     );
 
     const catalog = spawnSync(
@@ -2338,10 +2245,10 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
       (key.startsWith('.codex/') || key.startsWith('.agents/')) && !key.includes('../')
     )));
 
-    const questionSkill = path.join(root, '.agents', 'skills', 'question', 'SKILL.md');
+    const questionSkill = path.join(root, '.agents', 'skills', 'ask', 'SKILL.md');
     fs.appendFileSync(questionSkill, '\nUSER-CODEX-SENTINEL\n');
     // Fresh installs are exact. Refresh/upgrade intentionally documents the
-    // current Codex limitation: removed skill paths are not pruned.
+    // A skill file the manifest lists as obsolete is removed on refresh; edited skills stay.
     const obsoleteSpecsRule = path.join(
       root, '.agents', 'skills', 'specs', 'rules', 'design-principles.md'
     );
@@ -2354,14 +2261,15 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     assert.match(fs.readFileSync(questionSkill, 'utf8'), /USER-CODEX-SENTINEL/);
     assert.equal(
       fs.existsSync(obsoleteSpecsRule),
-      true,
-      'known limitation: Codex refresh does not prune obsolete skill files'
+      false,
+      'Codex refresh removes obsolete skill files'
     );
 
     const metadataPath = path.join(root, '.codex', 'cafekit.json');
     const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
     metadata.version = '0.14.1';
     fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`);
+    fs.writeFileSync(obsoleteSpecsRule, 'LEGACY-CODEX-ORPHAN\n');
 
     const upgrade = install(root);
     assert.equal(upgrade.status, 0, `${upgrade.stdout}\n${upgrade.stderr}`);
@@ -2369,8 +2277,8 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     assert.match(fs.readFileSync(questionSkill, 'utf8'), /USER-CODEX-SENTINEL/);
     assert.equal(
       fs.existsSync(obsoleteSpecsRule),
-      true,
-      'known limitation: Codex upgrade does not prune obsolete skill files'
+      false,
+      'Codex upgrade removes obsolete skill files'
     );
     assert.ok(fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8').startsWith(userInstructions));
 
@@ -2426,7 +2334,7 @@ test('Codex installed Brainstorm skill reference and agent preserve proportional
     const mutations = [
       {
         name: 'adaptive-direct-precedence-removed', source: 'skill',
-        from: 'Route Direct first, then\napply controls only to requests that remain in Brainstorm.',
+        from: 'Route Direct first, then apply controls only to requests that remain in Brainstorm.',
         to: 'Apply controls before Direct classification.', expected: ['adaptive-direct-precedence']
       },
       {
@@ -2441,37 +2349,37 @@ test('Codex installed Brainstorm skill reference and agent preserve proportional
       },
       {
         name: 'adaptive-failure-isolation-removed', source: 'skill',
-        from: 'failure isolation for partial or cascading failure\nacross boundaries',
+        from: 'failure isolation for partial or cascading failure across boundaries',
         to: 'generic failure notes', expected: ['adaptive-lens-trigger-skip']
       },
       {
         name: 'adaptive-evidence-fallback-removed', source: 'skill',
-        from: 'Missing evidence\nforces feasibility `unknown` and confidence `low`.',
+        from: 'Missing evidence forces feasibility `unknown` and confidence `low`.',
         to: 'Missing evidence permits a confident guess.', expected: ['adaptive-evidence-semantics']
       },
       {
         name: 'adaptive-numeric-evidence-removed', source: 'skill',
-        from: 'A numeric estimate requires\nrange, unit, basis, evidence, and assumptions; otherwise report `unknown`.',
+        from: 'A numeric estimate requires range, unit, basis, evidence, and assumptions; otherwise report `unknown`.',
         to: 'A numeric estimate may be a best-effort number.', expected: ['adaptive-numeric-estimates']
       },
       {
         name: 'adaptive-pre-tool-redaction-removed', source: 'skill',
-        from: 'Before an\nexternal visual tool or adviser handoff, minimize context and redact secrets,\ncredentials, private keys, access tokens, and unnecessary PII.',
+        from: 'Before an external visual tool or adviser handoff, minimize context and redact secrets, credentials, private keys, access tokens, and unnecessary PII.',
         to: 'Forward full context to every external tool and adviser.', expected: ['adaptive-pre-tool-redaction']
       },
       {
         name: 'adaptive-adviser-gate-removed', source: 'skill',
-        from: '`--advice` invokes\n`brainstormer` only after the material-choice gate;',
+        from: '`--advice` invokes `brainstormer` only after the material-choice gate;',
         to: '`--advice` invokes `brainstormer` before routing;', expected: ['adaptive-adviser-gate']
       },
       {
         name: 'adaptive-decision-freshness-removed', source: 'skill',
-        from: 'The first section records target\nidentity, current source revision and worktree state or `[UNVERIFIED]`, an\nevidence-as-of value, and what change invalidates the brief.',
+        from: 'The first section records target identity, current source revision and worktree state or `[UNVERIFIED]`, an evidence-as-of value, and what change invalidates the brief.',
         to: 'The handoff has no revision or freshness binding.', expected: ['adaptive-decision-freshness']
       },
       {
         name: 'adaptive-overlay-authority-removed', source: 'skill',
-        from: 'Neither overlay\nwrites, approves, persists, dispatches, or completes work.',
+        from: 'Neither overlay writes, approves, persists, dispatches, or completes work.',
         to: 'Overlays may persist, approve, dispatch, and complete work.', expected: ['adaptive-non-authority']
       },
       {
@@ -2491,7 +2399,7 @@ test('Codex installed Brainstorm skill reference and agent preserve proportional
       {
         name: 'exploration-stop-removed',
         source: 'skill',
-        from: 'Do not request design approval, persist a report, or\n   invoke another workflow without a new explicit request.',
+        from: 'Do not request design approval, persist a report, or invoke another workflow without a new explicit request.',
         to: 'Request approval, persist a report, and invoke another workflow.',
         expected: ['exploration-stop']
       },
@@ -2841,7 +2749,7 @@ function hotfixProjectionIssues(files) {
   }
   if (!parallel.includes('Diagnosis still starts only')
     || !parallel.includes('after the required scout outputs are synthesized')
-    || !parallel.includes('Research begins only after Step 2 diagnosis')
+    || !parallel.includes('Research begins only after diagnosis')
     || parallel.includes('scout + diagnose + research together')
     || parallel.includes("You don't need to wait for scouting")) {
     issues.add('scout-before-diagnosis');
@@ -2858,9 +2766,9 @@ test('Codex installed Fix preserves the adaptive repair contract', () => {
     const result = install(root);
     assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
 
-    const installedRoot = path.join(root, '.agents/skills/hotfix');
-    assert.equal(fs.existsSync(path.join(root, '.agents/skills/fix')), false,
-      'public Fix rename must keep the manifest-owned hotfix directory');
+    const installedRoot = path.join(root, '.agents/skills/fix');
+    assert.equal(fs.existsSync(path.join(root, '.agents/skills/hotfix')), false,
+      'Fix lives in the fix directory; the retired hotfix directory must not be installed');
     for (const relative of HOTFIX_BUNDLE) {
       const sourcePath = path.join(HOTFIX_SOURCE_ROOT, relative);
       assert.equal(
@@ -2952,7 +2860,7 @@ test('Codex installed Fix preserves the adaptive repair contract', () => {
       },
       {
         name: 'research-starts-before-diagnosis', file: 'references/parallel-patterns.md',
-        from: 'Research begins only after Step 2 diagnosis', to: 'Research may begin before Step 2 diagnosis',
+        from: 'Research begins only after diagnosis', to: 'Research may begin before diagnosis',
         expected: ['scout-before-diagnosis']
       }
     ];
@@ -3139,8 +3047,6 @@ test('Codex install on top of existing Claude installation preserves content and
     assert.equal(fs.existsSync(path.join(root, '.codex', 'runtime.json')), true, '.codex/runtime.json should exist');
     assert.equal(fs.existsSync(path.join(root, '.codex', 'hooks', 'privacy-block.cjs')), true, '.codex/hooks/privacy-block.cjs should exist');
     assert.equal(fs.existsSync(path.join(root, '.codex', 'rules', 'workflow.md')), true, '.codex/rules/workflow.md should exist');
-    assert.equal(fs.existsSync(path.join(root, '.codex', 'scripts', 'spec-ground.cjs')), true, '.codex/scripts/spec-ground.cjs should exist');
-    assert.equal(fs.existsSync(path.join(root, '.codex', 'scripts', 'validate-spec-output.cjs')), true, '.codex/scripts/validate-spec-output.cjs should exist');
     assert.equal(fs.existsSync(path.join(root, '.agents', '.gitignore')), true, '.agents/.gitignore should exist');
     assert.equal(fs.existsSync(path.join(root, '.agents', 'skills', 'specs', 'SKILL.md')), true, '.agents/skills/specs/SKILL.md should exist');
 
@@ -3162,59 +3068,76 @@ test('Codex install on top of existing Claude installation preserves content and
   });
 });
 
-test('Codex installed code_auditor contains Strict conditional marker', () => {
+test('Codex installed code_auditor carries no Strict attestation marker', () => {
   inTempProject((root) => {
     const result = install(root);
     assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
     const toml = fs.readFileSync(path.join(root, '.codex', 'agents', 'code_auditor.toml'), 'utf8');
-    assert.match(toml, /Strict Semantic Review Attestation/);
-    assert.match(toml, /CAFEKIT_SEMANTIC_REVIEW_ATTESTATION/);
-    assert.match(toml, /MAC-protected host-hook observation/);
-    assert.doesNotMatch(toml, /host-signed/);
-    assert.match(toml, /specs\/<feature>\/spec\.json/);
+    assert.doesNotMatch(toml, /CAFEKIT_SEMANTIC_REVIEW_ATTESTATION/);
+    assert.doesNotMatch(toml, /Strict Semantic Review Attestation/);
+    assert.doesNotMatch(toml, /MAC-protected host-hook observation/);
   });
 });
 
-test('Codex scaffold resolver rejects symlink template', () => {
+test('reinstall removes obsolete scripts and skill files from Codex and omp installs', () => {
   inTempProject((root) => {
-    const result = install(root);
-    assert.equal(result.status, 0);
-    const template = path.join(root, '.agents', 'skills', 'specs', 'templates', 'task.md');
-    const target = path.join(root, 'outside.md');
-    fs.writeFileSync(target, 'evil');
-    const original = fs.readFileSync(template);
-    fs.unlinkSync(template);
-    fs.symlinkSync(target, template);
-    const scaffold = path.join(root, '.codex', 'scripts', 'spec-scaffold.cjs');
-    const out = spawnSync(process.execPath, [scaffold, 'symlink-test', '--tasks', 'R1-01-foo,R1-02-bar', '--boundaries', '[{"id":"B-OWN","type":"ownership","tasks":["R1-01","R1-02"],"write_sets":{"R1-01":["src/a.js"],"R1-02":["src/b.js"]}}]'], { cwd: root, encoding: 'utf8' });
-    // Should fail because template is symlink and resolver rejects it
-    assert.notEqual(out.status, 0, 'scaffold should reject symlink template');
-    assert.match(`${out.stdout}\n${out.stderr}`, /template not found|symlink/i);
-    fs.unlinkSync(template);
-    fs.writeFileSync(template, original);
+    const first = installPlatforms(root, ['codex', 'omp']);
+    assert.equal(first.status, 0, `${first.stdout}\n${first.stderr}`);
+    const retired = ['change-firewall.cjs', 'spec-final-state.cjs'];
+    for (const runtime of ['.codex', '.omp']) {
+      for (const name of retired) fs.writeFileSync(path.join(root, runtime, 'scripts', name), 'legacy\n');
+    }
+    const retiredSkillFiles = ['code-review/references/verification-gate.md', 'specs/references/archive-workflow.md'];
+    for (const rel of retiredSkillFiles) fs.writeFileSync(path.join(root, '.agents', 'skills', rel), 'legacy\n');
+    const again = installPlatforms(root, ['codex', 'omp'], ['--force-overwrite']);
+    assert.equal(again.status, 0, `${again.stdout}\n${again.stderr}`);
+    for (const rel of retiredSkillFiles) {
+      assert.equal(fs.existsSync(path.join(root, '.agents', 'skills', rel)), false, `.agents/skills/${rel} must be removed`);
+    }
+    assert.equal(fs.existsSync(path.join(root, '.agents', 'skills', 'code-review', 'SKILL.md')), true, 'the code-review skill stays');
+    for (const runtime of ['.codex', '.omp']) {
+      for (const name of retired) {
+        assert.equal(fs.existsSync(path.join(root, runtime, 'scripts', name)), false, `${runtime}/scripts/${name} must be removed`);
+      }
+      assert.equal(fs.existsSync(path.join(root, runtime, 'scripts', 'spec-resolver.cjs')), true, `${runtime} keeps the resolver`);
+    }
   });
 });
 
-test('Claude and Codex installed Route preserve proportional live-catalog semantics', () => {
+test('reinstall removes the retired spec.json templates from Claude and Codex but a dry run keeps them', () => {
+  inTempProject((root) => {
+    const first = installPlatforms(root, ['claude', 'codex']);
+    assert.equal(first.status, 0, `${first.stdout}\n${first.stderr}`);
+    const templateDirs = ['.claude/skills/specs/templates', '.agents/skills/specs/templates'];
+    const retired = ['design.md', 'task.md', 'requirements.md', 'requirements-init.md', 'spec-state.json'];
+    for (const dir of templateDirs) {
+      for (const name of retired) fs.writeFileSync(path.join(root, dir, name), 'legacy\n');
+    }
+
+    const dry = installPlatforms(root, ['claude', 'codex'], ['--force-overwrite', '--dry-run']);
+    assert.equal(dry.status, 0, `${dry.stdout}\n${dry.stderr}`);
+    for (const dir of templateDirs) {
+      for (const name of retired) {
+        assert.equal(fs.existsSync(path.join(root, dir, name)), true, `dry run removed ${dir}/${name}`);
+      }
+    }
+
+    const again = installPlatforms(root, ['claude', 'codex'], ['--force-overwrite']);
+    assert.equal(again.status, 0, `${again.stdout}\n${again.stderr}`);
+    for (const dir of templateDirs) {
+      assert.deepEqual(fs.readdirSync(path.join(root, dir)), ['research.md'], `${dir} keeps only research.md`);
+    }
+  });
+});
+
+test('Claude and Codex installed routing rules preserve the live-catalog semantics and install no Route', () => {
   inTempProject((root) => {
     const result = installPlatforms(root, ['claude', 'codex']);
     assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const sourceRoot = path.join(PACKAGE_ROOT, 'src/claude/skills/route');
-    const expectedFiles = [
-      'SKILL.md', 'references/task-taxonomy.md',
-      'references/chaining-patterns.md', 'references/agent-timing.md'
-    ];
     const expectedRules = ['skill-workflow-routing.md', 'skill-domain-routing.md'];
     for (const runtime of ['claude', 'codex']) {
       const installedRoot = path.join(root, runtime === 'codex' ? '.agents/skills/route' : '.claude/skills/route');
-      for (const relative of expectedFiles) {
-        const source = fs.readFileSync(path.join(sourceRoot, relative), 'utf8');
-        const installed = fs.readFileSync(path.join(installedRoot, relative), 'utf8');
-        const expected = runtime === 'codex'
-          ? normalizeCodexBody(source, path.join(sourceRoot, relative))
-          : source;
-        assert.equal(installed, expected, `${runtime}:${relative}`);
-      }
+      assert.equal(fs.existsSync(installedRoot), false, `${runtime} still installs Route`);
       for (const relative of expectedRules) {
         const sourcePath = path.join(PACKAGE_ROOT, 'src/claude/rules', relative);
         const source = fs.readFileSync(sourcePath, 'utf8');
@@ -3224,12 +3147,8 @@ test('Claude and Codex installed Route preserve proportional live-catalog semant
         const expected = runtime === 'codex' ? normalizeCodexBody(source, sourcePath) : source;
         assert.equal(installed, expected, `${runtime}:rules/${relative}`);
       }
-      const route = fs.readFileSync(path.join(installedRoot, 'SKILL.md'), 'utf8');
-      assert.match(route, /names a valid installed skill[\s\S]*one installed skill clearly covers[\s\S]*Direct factual conversation/);
-      assert.match(route, /highest-link[\s\S]*risk[\s\S]*number of material domains/);
-      assert.match(route, /never expand it/);
       const catalog = installedCatalog(root, runtime);
-      assert.ok(catalog.skills.some((skill) => skill.public_id === 'cf:route'));
+      assert.equal(catalog.skills.some((skill) => skill.public_id === 'cf:route'), false);
       assert.equal(catalog.skills.some((skill) => skill.public_id === 'cf:docs'), false);
     }
   });
@@ -3304,24 +3223,3 @@ test('Claude and Codex installed rules preserve the ported review and process gu
   });
 });
 
-test('installed Route degrades safely when an agent is absent', () => {
-  inTempProject((root) => {
-    const result = installPlatforms(root, ['claude', 'codex']);
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const cases = [
-      ['claude', '.claude/agents/researcher.md', '.claude/skills/route'],
-      ['codex', '.codex/agents/researcher.toml', '.agents/skills/route'],
-    ];
-    for (const [runtime, agentRelative, routeRelative] of cases) {
-      fs.rmSync(path.join(root, agentRelative), { force: true });
-      assert.equal(fs.existsSync(path.join(root, agentRelative)), false);
-      const timing = fs.readFileSync(path.join(root, routeRelative, 'references/agent-timing.md'), 'utf8');
-      const route = fs.readFileSync(path.join(root, routeRelative, 'SKILL.md'), 'utf8');
-      const normalizedRoute = route.replace(/\s+/g, ' ');
-      assert.match(timing, /If the preferred agent is absent[\s\S]*never synthesize a role/);
-      assert.match(normalizedRoute, /continue inline when safe or return the named gap/);
-      assert.match(normalizedRoute, /Never synthesize an unavailable agent/);
-      assert.doesNotMatch(`${timing}\n${route}`, /researcher(?:\.md|\.toml)/i, runtime);
-    }
-  });
-});