@haposoft/cafekit 0.18.0 → 0.18.2

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

@@ -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',
@@ -265,6 +260,99 @@ function parseGeneratedTomlString(content, key) {
   return JSON.parse(match[1]);
 }
 
+test('installed Codex instructions reference all ten runtime rules', () => {
+  inTempProject(root => {
+    const result = install(root);
+    assert.equal(result.status, 0, result.stderr);
+    const instructions = fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8');
+    const rules = ['workflow', 'ai-dev-rules', 'orchestrator', 'manage-docs', 'skill-workflow-routing', 'skill-domain-routing', 'review-audit-self-decision', 'process-management', 'state-sync', 'hook-protocols'];
+    for (const rule of rules) {
+      assert.ok(instructions.includes(`.codex/rules/${rule}.md`), rule);
+      assert.ok(fs.existsSync(path.join(root, '.codex/rules', `${rule}.md`)), rule);
+    }
+  });
+});
+
+test('installed Codex orchestrator describes high reasoning on the session model', () => {
+  inTempProject(root => {
+    const source = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/rules/orchestrator.md'));
+    const result = install(root);
+    assert.equal(result.status, 0, result.stderr);
+    const content = fs.readFileSync(path.join(root, '.codex/rules/orchestrator.md'), 'utf8');
+    assert.doesNotMatch(content, /strongest|below[^\n]*fable/);
+    assert.match(content, /high reasoning effort/);
+    assert.match(content, /session model unless[^.]*configur/i);
+    assert.deepEqual(fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/rules/orchestrator.md')), source);
+  });
+});
+
+test('installed hook protocols share malformed-output handling and Codex receipt guidance', () => {
+  inTempProject(root => {
+    const result = installPlatforms(root, ['claude', 'codex']);
+    assert.equal(result.status, 0, result.stderr);
+    const sentence = 'If hook output is malformed, stop and report the exact failure instead of guessing.';
+    for (const runtime of ['.claude', '.codex']) {
+      const content = fs.readFileSync(path.join(root, runtime, 'rules/hook-protocols.md'), 'utf8');
+      assert.ok(content.includes(sentence), runtime);
+    }
+    assert.match(fs.readFileSync(path.join(root, '.codex/rules/hook-protocols.md'), 'utf8'), /state-sync\.md/);
+  });
+});
+
+test('installed Claude ignore rules preserve env samples and ignore temporary files', () => {
+  inTempProject(root => {
+    const result = installPlatforms(root, ['claude']);
+    assert.equal(result.status, 0, result.stderr);
+    const lines = fs.readFileSync(path.join(root, '.claude/.gitignore'), 'utf8').split(/\r?\n/);
+    for (const line of ['!.env.sample', '!.env.template', '*.tmp']) assert.ok(lines.includes(line), line);
+  });
+});
+
+const READ_ONLY_ROLE_SUFFIX = '\n\n## Read-only role\n\nRead-only role: never create, never edit, and never delete files, and never run commands that write to disk; return findings in your reply.';
+
+function assertInstalledAgentFields(content, name) {
+  const source = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/agents', `${name.replace(/_/g, '-')}.md`), 'utf8');
+  const { frontmatter, body } = require('../lib/codex-frontmatter').splitFrontmatter(source);
+  for (const key of ['name', 'description', 'developer_instructions']) {
+    assert.equal((content.match(new RegExp(`^${key} =`, 'gm')) || []).length, 1);
+  }
+  assert.equal(parseGeneratedTomlString(content, 'name'), name);
+  assert.equal(parseGeneratedTomlString(content, 'description'), normalizeCodexBody(frontmatter.description));
+  const suffix = ['brainstormer', 'code_auditor', 'inspector', 'researcher'].includes(name)
+    ? READ_ONLY_ROLE_SUFFIX : '';
+  const expectedBody = name === 'git_ops'
+    ? body.slice(0, body.indexOf('When instantiated as a team member'))
+      + body.split('\n').find(line => line.includes('NEVER arbitrarily use `force push`')).replace(/^3\. /, '- ') + '\n'
+    : body;
+  assert.equal(parseGeneratedTomlString(content, 'developer_instructions'), normalizeCodexBody(expectedBody).trim() + suffix);
+}
+
+for (const name of ['brainstormer', 'code_auditor', 'inspector', 'researcher']) {
+  test(`installed ${name} agent has exactly one read-only sandbox setting`, () => {
+    inTempProject(root => {
+      const result = install(root);
+      assert.equal(result.status, 0, result.stderr);
+      const content = fs.readFileSync(path.join(root, '.codex/agents', `${name}.toml`), 'utf8');
+      assert.deepEqual(content.match(/^sandbox_mode\s*=.*$/gm) || [], ['sandbox_mode = "read-only"']);
+      assert.ok(parseGeneratedTomlString(content, 'developer_instructions').endsWith(READ_ONLY_ROLE_SUFFIX));
+      assertInstalledAgentFields(content, name);
+    });
+  });
+}
+
+test('installed implementation agents retain their sandbox defaults', () => {
+  inTempProject(root => {
+    const result = install(root);
+    assert.equal(result.status, 0, result.stderr);
+    for (const name of ['implementer', 'test_runner', 'debugger', 'git_ops']) {
+      const content = fs.readFileSync(path.join(root, '.codex/agents', `${name}.toml`), 'utf8');
+      assert.doesNotMatch(content, /^sandbox_mode\s*=/m);
+      assert.doesNotMatch(parseGeneratedTomlString(content, 'developer_instructions'), /## Read-only role/);
+      assertInstalledAgentFields(content, name);
+    }
+  });
+});
+
 function replaceGeneratedTomlString(content, key, value) {
   const pattern = new RegExp(`^${key} = .+$`, 'gm');
   const matches = [...content.matchAll(pattern)];
@@ -272,64 +360,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}`);
@@ -879,7 +909,7 @@ function brainstormProjectionIssues(files) {
   }
   if (!skill.includes('Persist only approved decisions and semantics, only with user authority')
     || !skill.includes('redact live secrets, credentials, private keys, access tokens, and unnecessary PII;')
-    || !framework.includes('Do not write "user selected" unless direct user text or the native input tool confirms it.')) {
+    || !framework.includes('Do not write "user selected" unless direct user text or the question in the turn\'s final answer confirms it.')) {
     issues.add('approval-persistence');
   }
   for (const [issue, clause] of Object.entries(adaptiveClauses)) {
@@ -887,9 +917,9 @@ function brainstormProjectionIssues(files) {
   }
   const visible = `${skill}\n${framework}\n${agent}`;
   if (/\bAskUserQuestion\b/.test(visible)
-    || /\b(?:a|an|one|each|every|another|this|that|the|[0-9]+)\s+a structured user-input request\b/i.test(visible)
-    || /\ban structured user-input request\b/i.test(visible)
-    || /\ba structured user-input request\s+(?:calls|batches)\b/i.test(visible)) {
+    || /\b(?:a|an|one|each|every|another|this|that|the|[0-9]+)\s+a question in the turn\'s final answer\b/i.test(visible)
+    || /\ban question in the turn\'s final answer\b/i.test(visible)
+    || /\ba question in the turn\'s final answer\s+(?:calls|batches)\b/i.test(visible)) {
     issues.add('projection-grammar');
   }
   return [...issues].sort();
@@ -1442,26 +1472,26 @@ test('Codex payload transform emits native skill and subagent syntax', () => {
 
 test('Codex payload transform keeps structured user-input grammar across determiners', () => {
   const cases = [
-    ['standalone bare token', 'AskUserQuestion', 'a structured user-input request'],
-    ['standalone code token', '`AskUserQuestion`', 'a structured user-input request'],
-    ['standalone multi-backtick token', '``AskUserQuestion``', 'a structured user-input request'],
-    ['standalone padded multi-backtick token', '`` AskUserQuestion ``', 'a structured user-input request'],
-    ['one', 'one AskUserQuestion call', 'one structured user-input request call'],
-    ['one multi-backtick', 'one ``AskUserQuestion`` call', 'one structured user-input request call'],
-    ['one padded multi-backtick', 'one `` AskUserQuestion `` call', 'one structured user-input request call'],
-    ['each', 'each AskUserQuestion call', 'each structured user-input request call'],
-    ['every', 'every AskUserQuestion batch', 'every structured user-input request batch'],
-    ['another', 'another AskUserQuestion call', 'another structured user-input request call'],
-    ['this', 'this AskUserQuestion call', 'this structured user-input request call'],
-    ['that', 'that AskUserQuestion call', 'that structured user-input request call'],
-    ['a', 'a AskUserQuestion call', 'a structured user-input request call'],
-    ['an', 'an AskUserQuestion call', 'a structured user-input request call'],
-    ['capitalized each', 'Each AskUserQuestion call', 'Each structured user-input request call'],
-    ['capitalized an', 'An AskUserQuestion call', 'A structured user-input request call'],
-    ['the', 'the AskUserQuestion call', 'the structured user-input request call'],
-    ['numeric', '27 AskUserQuestion calls', '27 structured user-input request calls'],
-    ['plural calls', 'AskUserQuestion calls', 'structured user-input request calls'],
-    ['plural batches', 'AskUserQuestion batches', 'structured user-input request batches']
+    ['standalone bare token', 'AskUserQuestion', 'a question in the turn\'s final answer'],
+    ['standalone code token', '`AskUserQuestion`', 'a question in the turn\'s final answer'],
+    ['standalone multi-backtick token', '``AskUserQuestion``', 'a question in the turn\'s final answer'],
+    ['standalone padded multi-backtick token', '`` AskUserQuestion ``', 'a question in the turn\'s final answer'],
+    ['one', 'one AskUserQuestion call', 'one question in the turn\'s final answer call'],
+    ['one multi-backtick', 'one ``AskUserQuestion`` call', 'one question in the turn\'s final answer call'],
+    ['one padded multi-backtick', 'one `` AskUserQuestion `` call', 'one question in the turn\'s final answer call'],
+    ['each', 'each AskUserQuestion call', 'each question in the turn\'s final answer call'],
+    ['every', 'every AskUserQuestion batch', 'every question in the turn\'s final answer batch'],
+    ['another', 'another AskUserQuestion call', 'another question in the turn\'s final answer call'],
+    ['this', 'this AskUserQuestion call', 'this question in the turn\'s final answer call'],
+    ['that', 'that AskUserQuestion call', 'that question in the turn\'s final answer call'],
+    ['a', 'a AskUserQuestion call', 'a question in the turn\'s final answer call'],
+    ['an', 'an AskUserQuestion call', 'a question in the turn\'s final answer call'],
+    ['capitalized each', 'Each AskUserQuestion call', 'Each question in the turn\'s final answer call'],
+    ['capitalized an', 'An AskUserQuestion call', 'A question in the turn\'s final answer call'],
+    ['the', 'the AskUserQuestion call', 'the question in the turn\'s final answer call'],
+    ['numeric', '27 AskUserQuestion calls', '27 question in the turn\'s final answer calls'],
+    ['plural calls', 'AskUserQuestion calls', 'question in the turn\'s final answer calls'],
+    ['plural batches', 'AskUserQuestion batches', 'question in the turn\'s final answer batches']
   ];
 
   for (const [name, input, expected] of cases) {
@@ -1469,27 +1499,27 @@ test('Codex payload transform keeps structured user-input grammar across determi
     assert.equal(actual, expected, name);
     assert.equal(normalizeCodexBody(actual, '/fixture/instructions.md'), expected, `${name} idempotence`);
     assert.doesNotMatch(actual, /\bAskUserQuestion\b/, `${name} Claude-only token`);
-    assert.doesNotMatch(actual, /\ban structured user-input request\b/i, `${name} incompatible article`);
+    assert.doesNotMatch(actual, /\ban question in the turn\'s final answer\b/i, `${name} incompatible article`);
     assert.doesNotMatch(
       actual,
-      /\b(?:a|an|one|each|every|another|this|that|the|[0-9]+)\s+a structured user-input request\b/i,
+      /\b(?:a|an|one|each|every|another|this|that|the|[0-9]+)\s+a question in the turn\'s final answer\b/i,
       `${name} doubled article`
     );
   }
 
   assert.equal(
     normalizeCodexBody('one\nAskUserQuestion call', '/fixture/instructions.md'),
-    'one\nstructured user-input request call',
+    'one\nquestion in the turn\'s final answer call',
     'a single Markdown soft break must preserve its determiner relationship'
   );
   assert.equal(
     normalizeCodexBody('AskUserQuestion\nCalls', '/fixture/instructions.md'),
-    'structured user-input request\nCalls',
+    'question in the turn\'s final answer\nCalls',
     'a single Markdown soft break must preserve a plural relationship'
   );
   assert.equal(
     normalizeCodexBody('one\n\nAskUserQuestion call', '/fixture/instructions.md'),
-    'one\n\na structured user-input request call',
+    'one\n\na question in the turn\'s final answer call',
     'a paragraph break must not bind a prior determiner'
   );
   assert.equal(
@@ -1567,9 +1597,9 @@ test('Codex structured-input corpus oracle stays differential and production-awa
   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/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']
+    ['src/claude/skills/git/SKILL.md', 'Present options via a question in the turn\'s final answer — header'],
+    ['src/claude/skills/scout/SKILL.md', '**Fallback to a question in the turn\'s final answer:**'],
+    ['src/claude/skills/sync/references/rebind-and-audit.md', 'End by asking with a question in the turn\'s final answer when the host has']
   ]);
   for (const [relativePath, expectedSnippet] of instructionExpectedSnippets) {
     const sourcePath = path.join(PACKAGE_ROOT, relativePath);
@@ -1578,7 +1608,7 @@ test('Codex structured-input corpus oracle stays differential and production-awa
     const withSentinel = source.replace(/`?\bAskUserQuestion\b`?/g, sentinel);
     assert.notEqual(withSentinel, source, `${relativePath} differential control must replace a token`);
     const expected = normalizeCodexBody(withSentinel, sourcePath)
-      .replaceAll(sentinel, 'a structured user-input request');
+      .replaceAll(sentinel, 'a question in the turn\'s final answer');
     const actual = normalizeCodexBody(source, sourcePath);
     assert.equal(actual, expected, `${relativePath} independent differential oracle`);
     assert.match(actual, new RegExp(expectedSnippet.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
@@ -1587,7 +1617,7 @@ test('Codex structured-input corpus oracle stays differential and production-awa
   const specMaker = fs.readFileSync(SPEC_MAKER_SOURCE_PATH, 'utf8');
   const convertedAgent = convertCodexAgentContent(specMaker, path.basename(SPEC_MAKER_SOURCE_PATH));
   assert.doesNotMatch(convertedAgent, /\bAskUserQuestion\b/);
-  assert.doesNotMatch(convertedAgent, /structured user-input request/);
+  assert.doesNotMatch(convertedAgent, /question in the turn\'s final answer/);
 
   const sessionPath = path.join(PACKAGE_ROOT, 'src/claude/hooks/session.cjs');
   const session = normalizeCodexBody(fs.readFileSync(sessionPath, 'utf8'), sessionPath);
@@ -2059,6 +2089,45 @@ function sessionLauncher(projectRoot) {
   return { config, command: config.hooks.SessionStart[0].hooks[0].command };
 }
 
+test('parity regression: moved Codex checkout rebinds both launcher fields and preserves metadata', () => {
+  inTempProject((root) => {
+    const oldRoot = path.join(root, "old ' quoted project"), newRoot = path.join(root, "new ' quoted project");
+    fs.mkdirSync(oldRoot);
+    assert.equal(install(oldRoot).status, 0);
+    const configPath = path.join(oldRoot, '.codex/hooks.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    config.hooks.SessionStart[0].matcher = 'custom-startup';
+    config.hooks.SessionStart[0].hooks[0].timeout = 41;
+    fs.writeFileSync(configPath, JSON.stringify(config));
+    fs.renameSync(oldRoot, newRoot);
+    const movedConfig = path.join(newRoot, '.codex/hooks.json');
+    const before = fs.readFileSync(movedConfig, 'utf8');
+    assert.equal(install(newRoot, ['--dry-run']).status, 0);
+    assert.equal(fs.readFileSync(movedConfig, 'utf8'), before, 'dry run modified launchers');
+    const upgraded = install(newRoot);
+    assert.equal(upgraded.status, 0, `${upgraded.stdout}\n${upgraded.stderr}`);
+    const rebound = sessionLauncher(newRoot);
+    assert.equal(rebound.config.hooks.SessionStart[0].matcher, 'custom-startup');
+    assert.equal(rebound.config.hooks.SessionStart[0].hooks[0].timeout, 41);
+    const launched = runPosixLauncher(rebound.command, newRoot);
+    assert.equal(launched.status, 0, launched.stderr);
+    assert.match(launched.stdout, /Session startup\./);
+    const windowsCommand = rebound.config.hooks.SessionStart[0].hooks[0].commandWindows.replace(/^node /, `"${process.execPath}" `);
+    const launchedWindows = spawnSync(windowsCommand, { cwd: newRoot, encoding: 'utf8', input: JSON.stringify({ session_id: 'moved-windows', hook_event_name: 'SessionStart', source: 'startup', cwd: newRoot }), shell: true });
+    assert.equal(launchedWindows.status, 0, launchedWindows.stderr);
+    assert.match(launchedWindows.stdout, /Session startup\./);
+    for (const { handler } of allHookLaunchers(rebound.config)) {
+      const encoded = handler.commandWindows.match(/\s([A-Za-z0-9_-]+)$/)?.[1];
+      assert.ok(encoded);
+      const target = Buffer.from(encoded, 'base64url').toString('utf8');
+      assert.equal(path.dirname(target), fs.realpathSync(path.join(newRoot, '.codex/hooks')));
+    }
+    const stable = fs.readFileSync(movedConfig, 'utf8');
+    assert.equal(install(newRoot).status, 0);
+    assert.equal(fs.readFileSync(movedConfig, 'utf8'), stable, 'reinstall changed stable hooks config');
+  });
+});
+
 test('Codex POSIX hook launchers run without Git and outside the repository root', () => {
   inTempProject((root) => {
     // A launcher that asks Git for its root gets nothing here and the outer root one
@@ -2160,22 +2229,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'),
@@ -2191,22 +2250,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'
@@ -2217,7 +2260,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']
       ]) {
@@ -2338,7 +2380,7 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     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.
+    // Untracked obsolete files and edited current skills both stay on refresh.
     const obsoleteSpecsRule = path.join(
       root, '.agents', 'skills', 'specs', 'rules', 'design-principles.md'
     );
@@ -2352,13 +2394,14 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     assert.equal(
       fs.existsSync(obsoleteSpecsRule),
       true,
-      'known limitation: Codex refresh does not prune obsolete skill files'
+      'Codex refresh preserves untracked 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}`);
@@ -2367,8 +2410,10 @@ test('Codex installed Specs and spec-maker reject adaptive coverage mutations',
     assert.equal(
       fs.existsSync(obsoleteSpecsRule),
       true,
-      'known limitation: Codex upgrade does not prune obsolete skill files'
+      'Codex upgrade preserves untracked obsolete skill files'
     );
+    assert.match(sameVersion.stdout + sameVersion.stderr, /Preserved 1 obsolete runtime/);
+    assert.match(upgrade.stdout + upgrade.stderr, /Preserved 1 obsolete runtime/);
     assert.ok(fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8').startsWith(userInstructions));
 
     const forced = install(root, ['--force-overwrite']);
@@ -2598,7 +2643,7 @@ test('Codex installed Brainstorm skill reference and agent preserve proportional
       {
         name: 'decision-provenance-removed',
         source: 'framework',
-        from: 'Do not write "user selected" unless direct user text or the native input tool\n  confirms it.',
+        from: 'Do not write "user selected" unless direct user text or the question in the turn\'s final answer\n  confirms it.',
         to: 'Write "user selected" for inferred defaults.',
         expected: ['approval-persistence']
       },
@@ -2606,7 +2651,7 @@ test('Codex installed Brainstorm skill reference and agent preserve proportional
         name: 'installed-grammar-corruption',
         source: 'skill',
         from: '## Completion bar',
-        to: 'one a structured user-input request call\n\n## Completion bar',
+        to: 'one a question in the turn\'s final answer call\n\n## Completion bar',
         expected: ['projection-grammar']
       }
     ];
@@ -3136,8 +3181,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');
 
@@ -3170,23 +3213,54 @@ test('Codex installed code_auditor carries no Strict attestation marker', () =>
   });
 });
 
-test('Codex scaffold resolver rejects symlink template', () => {
+test('reinstall preserves untracked Codex runtime files while omp keeps its cleanup policy', () => {
+  for (const platform of ['codex', 'omp']) inTempProject(root => {
+    const first = installPlatforms(root, ['codex', 'omp']);
+    assert.equal(first.status, 0, `${first.stdout}\n${first.stderr}`);
+    const runtime = `.${platform}`;
+    const retired = ['change-firewall.cjs', 'spec-final-state.cjs'];
+    for (const name of retired) fs.writeFileSync(path.join(root, runtime, 'scripts', name), 'legacy\n');
+    const retiredSkillFiles = platform === 'codex'
+      ? ['code-review/references/verification-gate.md', 'specs/references/archive-workflow.md'] : [];
+    for (const rel of retiredSkillFiles) {
+      const target = path.join(root, '.agents/skills', rel);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, 'legacy\n');
+    }
+    const again = installPlatforms(root, [platform], ['--force-overwrite']);
+    assert.equal(again.status, 0, `${again.stdout}\n${again.stderr}`);
+    const preserved = platform === 'codex';
+    for (const rel of retiredSkillFiles) assert.equal(fs.existsSync(path.join(root, '.agents/skills', rel)), preserved, rel);
+    for (const name of retired) assert.equal(fs.existsSync(path.join(root, runtime, 'scripts', name)), preserved, name);
+    if (preserved) assert.match(again.stdout + again.stderr, /Preserved 4 obsolete runtime/);
+    assert.equal(fs.existsSync(path.join(root, '.agents/skills/code-review/SKILL.md')), true);
+    assert.equal(fs.existsSync(path.join(root, runtime, 'scripts/spec-resolver.cjs')), true);
+  });
+});
+
+test('reinstall removes the retired spec.json templates from Claude and Codex but a dry run keeps them', () => {
   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, ['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`);
+    }
   });
 });
 
@@ -3282,4 +3356,3 @@ test('Claude and Codex installed rules preserve the ported review and process gu
     }
   });
 });
-