@haposoft/cafekit 0.16.0-rc.6 → 0.16.0-rc.8

package/bin/__tests__/develop-contract.test.js

@@ -27,6 +27,7 @@ const TEST_SKILL = path.join(PACKAGE_ROOT, 'src/claude/skills/test/SKILL.md');
 const SYNC_SKILL = path.join(PACKAGE_ROOT, 'src/claude/skills/sync/SKILL.md');
 const CODE_REVIEW_SKILL = path.join(PACKAGE_ROOT, 'src/claude/skills/code-review/SKILL.md');
 const PARALLEL_WAVES = path.join(PACKAGE_ROOT, 'src/claude/skills/develop/references/parallel-waves.md');
+const SYNC_PROTOCOLS = path.join(PACKAGE_ROOT, 'src/claude/skills/sync/references/sync-protocols.md');
 const PROVENANCE = path.join(PACKAGE_ROOT, '../../docs/provenance.md');
 const RUNTIME_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-policy-runtime-'));
 const RUNTIME_SPEC = path.join(RUNTIME_ROOT, 'specs', 'demo', 'spec.json');
@@ -75,28 +76,62 @@ function installClaudeRuntimeClosure(fixtureRoot, entry = 'hooks/spec-gate.cjs')
   return path.join(destinationRoot, entry);
 }
 
-function markdownSection(content, heading) {
-  const marker = `## ${heading}`;
-  const start = content.indexOf(marker);
-  assert.notEqual(start, -1, `missing section ${heading}`);
-  const rest = content.slice(start + marker.length);
-  const end = rest.search(/\n## /);
-  return end === -1 ? rest : rest.slice(0, end);
+function markdownLegacyRegions(content) {
+  const headings = [];
+  const primaryLines = [];
+  const legacyLines = [];
+  const hierarchy = [];
+
+  for (const [index, line] of content.split('\n').entries()) {
+    const heading = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+    if (heading) {
+      const level = heading[1].length;
+      while (hierarchy.at(-1)?.level >= level) hierarchy.pop();
+      const entry = { level, text: heading[2], line: index + 1 };
+      hierarchy.push(entry);
+      headings.push(entry);
+    }
+
+    const target = hierarchy.some(({ text }) => /legacy/i.test(text))
+      ? legacyLines
+      : primaryLines;
+    target.push({ line: index + 1, text: line });
+  }
+
+  return {
+    headings,
+    primary: primaryLines.map(({ text }) => text).join('\n'),
+    legacy: legacyLines.map(({ text }) => text).join('\n'),
+    primaryLines,
+  };
 }
 
-function markdownTable(section, firstHeader) {
-  const lines = section.split('\n').filter((line) => line.trim().startsWith('|'));
-  const cells = (line) => line.split('|').slice(1, -1).map((cell) => cell.trim());
-  const headerIndex = lines.findIndex((line) => cells(line)[0] === firstHeader);
-  assert.notEqual(headerIndex, -1, `missing table headed by ${firstHeader}`);
-  const headers = cells(lines[headerIndex]);
-  const rows = {};
-  for (const line of lines.slice(headerIndex + 2)) {
-    const values = cells(line);
-    if (values.length !== headers.length) break;
-    rows[values[0].replaceAll('`', '')] = Object.fromEntries(headers.map((header, index) => [header, values[index]]));
+function assertVocabularyIsLegacyOnly(filePath, regions) {
+  const vocabulary = [
+    ['v2.1', /\bv2\.1\b/i],
+    ['spec.json', /\bspec\.json\b/i],
+    ['semantic_model', /\bsemantic[-_]model\b/i],
+    ['machine authority', /\bmachine authority\b/i],
+    ['task_registry', /\btask_registry\b/i],
+    ['workflow_policy', /\bworkflow_policy\b/i],
+    ['planning_depth', /\bplanning_depth\b/i],
+    ['assurance_level', /\bassurance_level\b/i],
+    ['execution_tier', /\bexecution_tier\b/i],
+    ['classified_minimum', /\bclassified_minimum\b/i],
+    ['coordination.boundaries', /\bcoordination\.boundaries\b/i],
+    ['lane', /\blane\b/i],
+  ];
+  const violations = [];
+  for (const { line, text } of regions.primaryLines) {
+    for (const [term, pattern] of vocabulary) {
+      if (pattern.test(text)) violations.push(`${line}:${term}`);
+    }
   }
-  return rows;
+  assert.deepEqual(
+    violations,
+    [],
+    `${path.relative(PACKAGE_ROOT, filePath)} has v2.1 vocabulary outside a Legacy heading`,
+  );
 }
 
 function runNode(root, script, args) {
@@ -305,11 +340,16 @@ test('CLI rejects flash and parallel before any mutation', () => {
   }
 });
 
-test('develop pre-state guard names executable policy contract', () => {
+test('develop flags retain their process-v3 contracts', () => {
   const develop = read(DEVELOP);
   assert.match(develop, /node \.claude\/scripts\/workflow-policy\.cjs --flash --parallel --json/);
-  assert.match(develop, /No spec state, task receipt, worktree, subagent, or commit was created/);
-  assert.match(develop, /flash\+parallel fail-fast/i);
+  assert.match(develop, /exits `2` before a task edit, receipt, worktree, subagent, or commit/i);
+  assert.match(develop, /--notes` is opt-in/i);
+  assert.match(develop, /implementation-notes-template\.html/);
+  assert.match(develop, /Never create it by default/i);
+  assert.match(develop, /--parallel \[N\][\s\S]*parallel-waves\.md[\s\S]*isolated worktrees[\s\S]*one controller writer/i);
+  assert.match(develop, /--flash[\s\S]*Status: in_progress[\s\S]*FLASH_UNVERIFIED[\s\S]*awaiting \/hapo:test <feature>/i);
+  assert.match(develop, /FLASH_UNVERIFIED[\s\S]*do not unblock dependents[\s\S]*sync-finalize path/i);
 });
 
 test('delegation plan consumes legacy tiers as obligations without an agent chain', () => {
@@ -674,7 +714,7 @@ test('approval schema fails closed for explicit null, array, empty, and malforme
   assert.throws(() => POLICY.approvalState({ schema_version: '1.0' }), /schema_version/);
 });
 
-test('CLI exposes a derived lane and Develop consumes independent canonical policy axes', () => {
+test('CLI exposes a derived lane without making it primary Develop authority', () => {
   const cli = spawnSync(process.execPath, [
     POLICY_PATH,
     '--classify-lane',
@@ -687,18 +727,17 @@ test('CLI exposes a derived lane and Develop consumes independent canonical poli
   assert.equal(payload.classification.lane, 'Direct');
   assert.equal(payload.policy.requiresSpec, false);
   const develop = read(DEVELOP);
+  const regions = markdownLegacyRegions(develop);
   assert.doesNotMatch(develop, /DO NOT write implementation code until an approved spec exists/i);
-  const policySection = develop.split('## Policy authority')[1]?.split('\n## ')[0] || '';
-  for (const authorityTerm of ['planning_depth', 'assurance_level', 'Risk', 'derived']) {
-    assert.ok(policySection.includes(authorityTerm), `policy authority missing ${authorityTerm}`);
-  }
-  for (const compatibilityView of ['**Direct**', '**Standard**', '**Critical**']) {
-    assert.ok(policySection.includes(compatibilityView), `missing derived view ${compatibilityView}`);
-  }
-  assert.ok(policySection.includes('derived Strict view'));
-  assert.ok(policySection.includes('Legacy approval fields'));
-  assert.ok(policySection.replace(/\s+/g, ' ').includes('zero authority'));
-  assert.match(develop, /Classify lane[\s\S]*test receipt[\s\S]*docs-impact sync/i);
+  assert.doesNotMatch(regions.primary, /planning_depth|assurance_level|execution_tier|\blane\b/i);
+  assert.match(regions.legacy, /planning_depth/);
+  assert.match(regions.legacy, /assurance_level/);
+  assert.match(regions.legacy, /execution_tier/);
+  assert.match(regions.legacy, /derived lane/i);
+  assert.match(regions.primary, /specs\/<feature>\/plan\.md[\s\S]*task-NN-\*\.md/i);
+  assert.match(regions.primary, /one unblocked task at a time/i);
+  assert.match(regions.primary, /Verification Plan/);
+  assert.match(regions.primary, /inline Receipt/i);
   assert.doesNotMatch(develop, /D2\[Step 3/);
   assert.match(develop, /--notes.*opt-in/i);
   assert.doesNotMatch(develop, /--no-notes/);
@@ -717,30 +756,67 @@ test('CLI exposes a derived lane and Develop consumes independent canonical poli
   assert.notDeepEqual(fullRoutine.proof_obligations, compactStrict.proof_obligations);
 });
 
-test('artifact router keeps optional expansion bound to uncertainty and typed topology', () => {
-  const router = markdownSection(read(SPECS), 'Artifact router');
-  const rows = markdownTable(router, 'Depth');
-  assert.deepEqual(Object.keys(rows), ['None', 'Compact', 'Full']);
-  assert.equal(rows.None['Durable core'], 'none');
-  for (const depth of ['Compact', 'Full']) {
-    assert.deepEqual(
-      rows[depth]['Durable core'].match(/`[^`]+`/g),
-      ['`spec.json`', '`requirements.md`', '`design.md`'],
-      `${depth} must share the canonical three-file core`,
-    );
-    assert.equal(rows[depth]['Research route'], 'only on a research trigger');
-    assert.equal(rows[depth]['Task route'], 'only on a typed topology trigger');
-  }
-  assert.notEqual(rows.Compact['Design expansion'], rows.Full['Design expansion']);
-  for (const falseTrigger of ['Requirement count', 'size', 'planning depth', 'assurance level', 'risk label', 'architectural layers']) {
-    assert.ok(router.includes(falseTrigger), `router must name inert trigger ${falseTrigger}`);
-  }
-  for (const boundary of ['ownership', 'dependency', 'transition', 'proof', 'parallel']) {
-    assert.ok(router.includes(boundary), `router must name typed topology ${boundary}`);
+test('Specs primary output is a flat process-first packet with isolated legacy compatibility', () => {
+  const specs = read(SPECS);
+  const regions = markdownLegacyRegions(specs);
+  const legacyHeadings = regions.headings.filter(({ text }) => /legacy/i.test(text));
+  assert.equal(legacyHeadings.length, 1);
+  assert.match(regions.primary, /specs\/<feature>\/[\s\S]*plan\.md[\s\S]*task-01-<slug>\.md[\s\S]*task-02-<slug>\.md/i);
+  assert.match(regions.primary, /Task files are flat beside `plan\.md`/i);
+  assert.match(regions.primary, /one task at a time/i);
+  assert.match(regions.primary, /inline `## Receipt`/i);
+  assert.match(regions.primary, /C1 — Scope[\s\S]*C2 — Findings[\s\S]*C3 — Done/i);
+  assert.match(regions.legacy, /spec\.json/i);
+  assert.match(regions.legacy, /never requires the legacy kernel/i);
+  assertVocabularyIsLegacyOnly(SPECS, regions);
+});
+
+test('R7 Develop and Sync surfaces teach process-v3 and isolate hierarchical Legacy sections', () => {
+  const surfaces = [
+    ['develop', DEVELOP],
+    ['parallel waves', PARALLEL_WAVES],
+    ['sync', SYNC_SKILL],
+    ['sync protocols', SYNC_PROTOCOLS],
+  ];
+  const regionsByName = new Map();
+  let legacyCorpus = '';
+
+  for (const [name, filePath] of surfaces) {
+    const regions = markdownLegacyRegions(read(filePath));
+    const legacyHeadings = regions.headings.filter(({ text }) => /legacy/i.test(text));
+    assert.equal(legacyHeadings.length, 1, `${name} must have exactly one Legacy heading`);
+    assert.match(regions.primary, /inline (?:`## )?Receipts?/i, `${name} must teach inline Receipts`);
+    assert.match(regions.legacy, /spec\.json/i, `${name} must retain the spec.json adapter`);
+    assert.match(regions.legacy, /task_registry/i, `${name} must retain task_registry compatibility`);
+    assertVocabularyIsLegacyOnly(filePath, regions);
+    regionsByName.set(name, regions);
+    legacyCorpus += `\n${regions.legacy}`;
   }
-  assert.ok(router.includes('unresolved material uncertainty'));
-  assert.ok(router.includes('external-current fact'));
-  assert.ok(router.includes('explicit user request'));
+
+  const develop = regionsByName.get('develop').primary;
+  assert.match(develop, /`specs\/<feature>\/plan\.md` plus flat `task-NN-\*\.md`/i);
+  assert.match(develop, /selects one unblocked task at a time/i);
+  assert.match(develop, /Outcome and Acceptance/i);
+  assert.match(develop, /Verification Plan/);
+  assert.match(develop, /final `## Receipt`/i);
+
+  const sync = regionsByName.get('sync').primary;
+  assert.match(sync, /<task-NN-slug\.md>/i);
+  assert.match(sync, /specs\/<feature>\/task-\*\.md` beside `plan\.md`/i);
+  assert.match(sync, /Acceptance[\s\S]*Verification Plan/i);
+  assert.match(sync, /current inline Receipt/i);
+
+  const waves = regionsByName.get('parallel waves').primary;
+  assert.match(waves, /plan task table[\s\S]*flat task's[\s\S]*`## Dependencies`/i);
+  assert.match(waves, /acceptance, Verification Plan/i);
+  assert.match(waves, /one file has one writer per wave/i);
+  assert.match(waves, /writes inline Receipts and Status updates one task at a\s+time/i);
+
+  const protocols = regionsByName.get('sync protocols').primary;
+  assert.match(protocols, /`plan\.md` and flat `task-\*\.md` files/i);
+  assert.match(protocols, /acceptance IDs/i);
+  assert.match(protocols, /current inline Receipt/i);
+  assert.match(legacyCorpus, /sync-finalize/i);
 });
 
 test('canonical verdict adapter handles completion and unfinished decisions', () => {
@@ -896,11 +972,9 @@ test('auto authoring reaches readiness only after promotion, validation, groundi
     const specs = read(SPECS);
     const executableBlocks = [...specs.matchAll(/```bash\n([\s\S]*?)```/g)].map((match) => match[1]);
     assert.ok(executableBlocks.every((block) => !/hapo:?develop/i.test(block)), 'Specs must never execute Develop');
-    const handoff = markdownSection(specs, 'Platform acceptance and handoff');
-    assert.ok(handoff.includes('After readiness'));
-    assert.ok(handoff.includes('/hapo:develop <feature>'));
-    assert.ok(handoff.includes('$hapo-develop <feature>'));
-    assert.ok(handoff.includes('must stop in Specs'));
+    assert.match(specs, /An implementation workflow owns execution/i);
+    assert.match(specs, /selects one unblocked task[\s\S]*runs\s+the task's verification[\s\S]*inline `## Receipt`/i);
+    assert.match(specs, /The user decides\s+at C3 whether the feature is done/i);
   } finally {
     fs.rmSync(fixture.root, { recursive: true, force: true });
   }
@@ -1519,18 +1593,29 @@ test('flash selective promotion - only specific task is promoted, not blanket',
 });
 
 test('parallel waves require immutable provenance receipts and safe recovery', () => {
-  const waves = read(PARALLEL_WAVES);
+  const waves = markdownLegacyRegions(read(PARALLEL_WAVES)).primary;
+  assert.match(waves, /only for explicit parallel execution/i);
+  assert.match(waves, /worktree isolation[\s\S]*fall back to the sequential loop/i);
+  assert.match(waves, /Clamp `--parallel N` to 1\.\.5; default to 3/i);
+  assert.match(waves, /clean destination[\s\S]*base_sha[\s\S]*base compatibility/i);
+  assert.match(waves, /parallel consent[\s\S]*worker commits[\s\S]*controller cherry-picks/i);
   for (const field of ['base_sha', 'head_sha', 'branch', 'worktree_path', 'commit_range']) {
     assert.match(waves, new RegExp(`\\b${field}\\b`));
   }
   assert.match(waves, /git diff(?: --stat)? [^\\n]*(?:BASE_SHA|base_sha)[^\\n]*(?:HEAD_SHA|head_sha)/i);
   assert.match(waves, /new commit|new commits|Every fix is a new commit/i);
-  assert.match(waves, /destination tree must be clean/i);
-  assert.match(waves, /compatible with the selected base/i);
-  assert.match(waves, /consent.*commit|commit.*consent/i);
-  assert.match(waves, /retention.*retained|retained.*worktree/i);
-  assert.match(waves, /cleanup_authorization|explicit discard/i);
-  assert.match(waves, /directory overlap|lockfiles|manifests|export barrels|migrations|registries|generated artifacts|shared state writers/i);
+  assert.match(waves, /plan task table[\s\S]*flat task's[\s\S]*Dependencies/i);
+  for (const sharedSurface of ['registry', 'lockfile', 'manifest', 'generated output', 'migration', 'export barrel']) {
+    assert.match(waves, new RegExp(sharedSurface, 'i'));
+  }
+  assert.match(waves, /One file has one writer per wave/i);
+  assert.match(waves, /controller owns[\s\S]*state and evidence synchronization/i);
+  assert.match(waves, /authorization covers worker commits/i);
+  assert.match(waves, /blocked or failed worker keeps[\s\S]*worktree and branch/i);
+  assert.match(waves, /Never[\s\S]*force-delete[\s\S]*merge success or explicit discard authorization/i);
+  assert.match(waves, /git cherry-pick <worker-commit>/i);
+  assert.match(waves, /On conflict, abort the cherry-pick[\s\S]*retain its[\s\S]*worktree\/branch/i);
+  assert.match(waves, /cleanup_authorization: merged-release/i);
   assert.match(waves, /affected integration|final.*integration/i);
   for (const category of ['baseline', 'environment', 'spec', 'code']) {
     assert.match(waves, new RegExp(`\\b${category}\\b`));
@@ -2635,17 +2720,11 @@ test('P0 regression: safeTaskFile fail-closed on realpath error and single autho
   // Single authority: Claude hook should delegate to POLICY, not duplicate parser
   assert.match(specGateSrc, /POLICY\.validateCanonicalReceipt/);
   assert.doesNotMatch(specGateSrc, /const EXPLICIT_FAILURE/);
-  // Codex and OpenCode should delegate to shared workflow-policy
+  // Codex should delegate to shared workflow-policy
   const codexSrc = fs2.readFileSync(path2.join(PACKAGE_ROOT, 'src/codex/hooks/lib/spec-receipt.cjs'), 'utf8');
   assert.match(codexSrc, /getSharedValidate/);
   assert.match(codexSrc, /workflow-policy\.cjs/);
   assert.doesNotMatch(codexSrc, /const PLACEHOLDER_TOKENS/);
-  const opencodeSrc = fs2.readFileSync(path2.join(PACKAGE_ROOT, 'src/opencode/plugins/spec-gate.ts'), 'utf8');
-  assert.match(opencodeSrc, /getSharedValidate/);
-  assert.match(opencodeSrc, /workflow-policy\.cjs/);
-  // The parser should only exist in workflow-policy, not in adapters (check that adapter does not define full validate logic)
-  const opencodeValidateCount = (opencodeSrc.match(/function validateCanonicalReceipt/g) || []).length;
-  assert.equal(opencodeValidateCount, 1, 'OpenCode should have only delegating validate, not duplicate parser');
   // safeTaskFile fail-closed: simulate realpathSync throwing
   const tmp = fs2.mkdtempSync(path2.join(os2.tmpdir(), 'cafekit-realpath-'));
   try {

package/bin/__tests__/installer-safety.test.js

@@ -8,10 +8,6 @@ const { spawnSync } = require('node:child_process');
 const { test } = require('node:test');
 
 const backup = require('../lib/backup');
-const {
-  copyOpenCodeAgentsMdFile,
-  normalizeOpenCodeBody
-} = require('../lib/opencode-install');
 const {
   commandFailureReason,
   resolvePackageCommand
@@ -34,8 +30,6 @@ const SHARED_TEMPLATE = fs.readFileSync(path.join(__dirname, '../../src/common/A
 const INSTALLER = path.join(__dirname, '../install.js');
 const CODEX_START = '<!-- CAFEKIT CODEX START -->';
 const CODEX_END = '<!-- CAFEKIT CODEX END -->';
-const OPENCODE_START = '<!-- CAFEKIT OPENCODE START -->';
-const OPENCODE_END = '<!-- CAFEKIT OPENCODE END -->';
 
 function managedBody(content, start, end) {
   const startIndex = content.indexOf(start);
@@ -47,7 +41,7 @@ function managedBody(content, start, end) {
 function runCombinedInstaller(root, extraArgs = []) {
   return spawnSync(
     process.execPath,
-    [INSTALLER, '--platform', 'claude,codex,opencode', '--yes', ...extraArgs],
+    [INSTALLER, '--platform', 'claude,codex', '--yes', ...extraArgs],
     { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } }
   );
 }
@@ -118,7 +112,7 @@ test('legacy managed root gitignore migrates A13 plan patterns and preserves use
       '.cafekit-backup/',
       '.cafekit.lock',
       '.claude/',
-      '.opencode/',
+      '.legacy-runtime/',
       '.codex/',
       '.agents/',
       '',
@@ -150,7 +144,7 @@ test('legacy managed root gitignore migrates A13 plan patterns and preserves use
       '.cafekit-backup/',
       '.cafekit.lock',
       '.claude/',
-      '.opencode/',
+      '.legacy-runtime/',
       '.codex/',
       '.agents/'
     ]);
@@ -188,8 +182,7 @@ test('legacy managed root gitignore migrates A13 plan patterns and preserves use
 test('malformed managed marker topology fails transactionally and preserves exact bytes', () => {
   const markers = {
     claude: ['<!-- CAFEKIT CORE START -->', '<!-- CAFEKIT CORE END -->'],
-    codex: ['<!-- CAFEKIT CODEX START -->', '<!-- CAFEKIT CODEX END -->'],
-    opencode: ['<!-- CAFEKIT OPENCODE START -->', '<!-- CAFEKIT OPENCODE END -->']
+    codex: ['<!-- CAFEKIT CODEX START -->', '<!-- CAFEKIT CODEX END -->']
   };
   const topologies = (start, end) => [
     `user\n${end}\n`,
@@ -227,37 +220,31 @@ test('combined install keeps CORE neutral and records native shared-root trade-o
     const claude = fs.readFileSync('CLAUDE.md', 'utf8');
     const core = managedBody(agents, CORE_START, CORE_END);
     const codex = managedBody(agents, CODEX_START, CODEX_END);
-    const opencode = managedBody(agents, OPENCODE_START, OPENCODE_END);
     const claudeBlock = managedBody(claude, START, END);
 
     for (const [content, marker] of [
       [agents, CORE_START],
       [claude, START],
-      [agents, CODEX_START],
-      [agents, OPENCODE_START]
+      [agents, CODEX_START]
     ]) assert.equal((content.match(new RegExp(marker, 'g')) || []).length, 1);
 
-    assert.doesNotMatch(core, /Claude|Codex|OpenCode|\.claude|\.codex|\.opencode|\/hapo:|\$hapo-/i);
-    assert.doesNotMatch(claudeBlock, /Codex|OpenCode|\.codex|\.opencode|\$hapo-/i);
+    assert.doesNotMatch(core, /Claude|Codex|\.claude|\.codex|\/hapo:|\$hapo-/i);
+    assert.doesNotMatch(claudeBlock, /Codex|\.codex|\$hapo-/i);
     assert.match(codex, /native project instruction surface is root `AGENTS\.md`/);
-    assert.match(opencode, /native project instruction surface is root `AGENTS\.md`/);
     assert.match(agents, /shared-root trade-off is intentional/);
     // H5 remediation: ownership/ignore contract must be explicit — not just marker presence
     assert.match(core, /runtime-neutral/i);
     assert.match(core, /fail-safe/i);
     assert.match(core, /Ignore managed blocks not owned by your runtime/i);
     assert.match(codex, /owned by Codex/i);
-    assert.match(codex, /ignore this entire Codex block/i);
+    assert.match(codex, /If you are Claude Code or any other runtime, ignore this entire Codex block/i);
+    assert.doesNotMatch(codex, /If you are Codex CLI or any other runtime, ignore this entire Codex block/i);
     assert.match(codex, /fail-safe/i);
-    assert.match(opencode, /owned by OpenCode/i);
-    assert.match(opencode, /ignore this entire OpenCode block/i);
-    assert.match(opencode, /fail-safe/i);
     // CORE must not contain runtime-specific directives that would leak
     assert.doesNotMatch(core, /\$hapo-|hapo:/i);
     // No cross-runtime directive leakage: Claude block must not contain foreign runtime directives
-    assert.doesNotMatch(claudeBlock, /<!-- CAFEKIT (CODEX|OPENCODE) /);
-    assert.doesNotMatch(codex, /<!-- CAFEKIT (CORE|OPENCODE) /);
-    assert.doesNotMatch(opencode, /<!-- CAFEKIT (CORE|CODEX) /);
+    assert.doesNotMatch(claudeBlock, /<!-- CAFEKIT CODEX /);
+    assert.doesNotMatch(codex, /<!-- CAFEKIT CORE /);
 
     const userAgents = '\n## User-owned combined note\nKeep this exact.\n';
     const userClaude = '\n## User-owned Claude note\nKeep this exact.\n';
@@ -271,17 +258,15 @@ test('combined install keeps CORE neutral and records native shared-root trade-o
     assert.match(afterClaude, /User-owned Claude note\nKeep this exact\./);
     assert.equal((afterAgents.match(new RegExp(CORE_START, 'g')) || []).length, 1);
     assert.equal((afterAgents.match(new RegExp(CODEX_START, 'g')) || []).length, 1);
-    assert.equal((afterAgents.match(new RegExp(OPENCODE_START, 'g')) || []).length, 1);
     assert.equal((afterClaude.match(new RegExp(START, 'g')) || []).length, 1);
     assert.equal(afterAgents.slice(-userAgents.length), userAgents);
     assert.equal(afterClaude.slice(-userClaude.length), userClaude);
     // Ownership contract must survive rerun
     const afterCore = managedBody(afterAgents, CORE_START, CORE_END);
     const afterCodex = managedBody(afterAgents, CODEX_START, CODEX_END);
-    const afterOpenCode = managedBody(afterAgents, OPENCODE_START, OPENCODE_END);
     assert.match(afterCore, /runtime-neutral/i);
-    assert.match(afterCodex, /ignore this entire Codex block/i);
-    assert.match(afterOpenCode, /ignore this entire OpenCode block/i);
+    assert.match(afterCodex, /If you are Claude Code or any other runtime, ignore this entire Codex block/i);
+    assert.doesNotMatch(afterCodex, /If you are Codex CLI or any other runtime, ignore this entire Codex block/i);
   });
 });
 
@@ -289,7 +274,7 @@ test('combined locale stays in CORE and addressing stays in each native managed
   inTempProject((root) => {
     const result = spawnSync(
       process.execPath,
-      [INSTALLER, '--platform', 'claude,codex,opencode', '--yes', '--lang', 'vi'],
+      [INSTALLER, '--platform', 'claude,codex', '--yes', '--lang', 'vi'],
       { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } }
     );
     assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
@@ -301,18 +286,17 @@ test('combined locale stays in CORE and addressing stays in each native managed
     assert.equal((claude.match(/## Language Consistency <!-- cafekit:lang -->/g) || []).length, 0);
 
     configureAddressing({
-      platforms: ['claude', 'codex', 'opencode'],
+      platforms: ['claude', 'codex'],
       ui: { success() {}, warn() {} },
       t: () => 'updated'
     }, 'anh');
 
     const addressedAgents = fs.readFileSync('AGENTS.md', 'utf8');
     const addressedClaude = fs.readFileSync('CLAUDE.md', 'utf8');
-    assert.equal((addressedAgents.match(/## Addressing \(Context Overflow Indicator\)/g) || []).length, 2);
+    assert.equal((addressedAgents.match(/## Addressing \(Context Overflow Indicator\)/g) || []).length, 1);
     assert.equal((addressedClaude.match(/## Addressing \(Context Overflow Indicator\)/g) || []).length, 1);
     assert.equal((managedBody(addressedAgents, CORE_START, CORE_END).match(/## Addressing \(Context Overflow Indicator\)/g) || []).length, 0);
     assert.match(managedBody(addressedAgents, CODEX_START, CODEX_END), /Codex CLI always addresses the user as "anh"/);
-    assert.match(managedBody(addressedAgents, OPENCODE_START, OPENCODE_END), /OpenCode always addresses the user as "anh"/);
     assert.match(managedBody(addressedClaude, START, END), /Claude Code always addresses the user as "anh"/);
   });
 });
@@ -359,11 +343,10 @@ test('fresh no-lang install leaves locale unset and rules hook silent', () => {
   });
 });
 
-test('obsolete agent pruning is ownership-aware across Claude, Codex, and OpenCode', () => {
+test('obsolete agent pruning is ownership-aware across Claude and Codex', () => {
   const cases = {
     claude: ['agents/god-developer.md', '.claude'],
-    codex: ['agents/god_developer.toml', '.codex'],
-    opencode: ['agents/god-developer.md', '.opencode']
+    codex: ['agents/god_developer.toml', '.codex']
   };
   for (const [platformKey, [relative, folder]] of Object.entries(cases)) {
     for (const state of ['pristine', 'modified', 'untracked']) {
@@ -523,39 +506,7 @@ test('addressing appends when template has no section without entering shared CO
   });
 });
 
-test('OpenCode force refresh preserves user and Codex AGENTS blocks', () => {
-  inTempProject(() => {
-    const userContent = '# User instructions\n\nKeep this exact.\n';
-    const codexBlock = '<!-- CAFEKIT CODEX START -->\nCodex managed\n<!-- CAFEKIT CODEX END -->\n';
-    fs.writeFileSync('AGENTS.md', `${userContent}\n${codexBlock}`);
-    const results = { copied: 0, updated: 0, skipped: 0, missingDependencies: 0 };
-
-    copyOpenCodeAgentsMdFile('opencode', results, { upgrade: true });
-
-    const content = fs.readFileSync('AGENTS.md', 'utf8');
-    assert.ok(content.startsWith(userContent));
-    assert.ok(content.includes(codexBlock.trim()));
-    assert.equal((content.match(/<!-- CAFEKIT OPENCODE START -->/g) || []).length, 1);
-    assert.equal(results.updated, 1);
-  });
-});
-
-test('legacy unmarked OpenCode AGENTS content is wrapped without duplication', () => {
-  inTempProject(() => {
-    const source = path.join(__dirname, '../../src/opencode/AGENTS.md');
-    const legacy = normalizeOpenCodeBody(fs.readFileSync(source, 'utf8'));
-    const codexBlock = '<!-- CAFEKIT CODEX START -->\nCodex managed\n<!-- CAFEKIT CODEX END -->\n';
-    fs.writeFileSync('AGENTS.md', `${legacy}\n${codexBlock}`);
-    const results = { copied: 0, updated: 0, skipped: 0, missingDependencies: 0 };
-
-    copyOpenCodeAgentsMdFile('opencode', results, { upgrade: true });
 
-    const content = fs.readFileSync('AGENTS.md', 'utf8');
-    assert.equal((content.match(/<!-- CAFEKIT OPENCODE START -->/g) || []).length, 1);
-    assert.ok(content.includes('## OpenCode Runtime Mapping'));
-    assert.ok(content.includes(codexBlock.trim()));
-  });
-});
 
 test('locale patch does not claim ownership of a preserved user runtime', () => {
   inTempProject(() => {
@@ -737,9 +688,7 @@ test('managed Claude Addressing survives force refresh when template drops it',
 
 test('managed Codex block Addressing survives upsert with the current template', () => {
   inTempProject(() => {
-    const codexTemplate = normalizeCodexBody(
-      fs.readFileSync(path.join(__dirname, '../../src/codex/AGENTS.md'), 'utf8')
-    );
+    const codexTemplate = fs.readFileSync(path.join(__dirname, '../../src/codex/AGENTS.md'), 'utf8');
     const userTop = '# User codex notes\n\n';
     const userBottom = '\n\n## User section\nKeep me.\n';
     const configuredAddressing = '## Addressing (Context Overflow Indicator)\n\nThe AI always addresses the user as "bro" throughout the conversation.';
@@ -757,28 +706,6 @@ test('managed Codex block Addressing survives upsert with the current template',
   });
 });
 
-test('managed OpenCode block Addressing survives force refresh with the current template', () => {
-  inTempProject(() => {
-    const userContent = '# User instructions\n\nKeep this exact.\n';
-    const codexBlock = '<!-- CAFEKIT CODEX START -->\nCodex managed\n<!-- CAFEKIT CODEX END -->\n';
-    const configuredAddressing = '## Addressing (Context Overflow Indicator)\n\nThe AI always addresses the user as "anh" throughout the conversation.';
-    fs.writeFileSync(
-      'AGENTS.md',
-      `${userContent}<!-- CAFEKIT OPENCODE START -->\nOpenCode runtime line.\n\n${configuredAddressing}\n<!-- CAFEKIT OPENCODE END -->\n${codexBlock}`
-    );
-    const results = { copied: 0, updated: 0, skipped: 0, missingDependencies: 0 };
-
-    copyOpenCodeAgentsMdFile('opencode', results, { upgrade: true });
-
-    const content = fs.readFileSync('AGENTS.md', 'utf8');
-    assert.ok(content.startsWith(userContent));
-    assert.ok(content.includes(codexBlock.trim()));
-    assert.equal((content.match(/## Addressing \(Context Overflow Indicator\)/g) || []).length, 1);
-    assert.ok(content.includes('The AI always addresses the user as "anh"'));
-    assert.equal((content.match(/<!-- CAFEKIT OPENCODE START -->/g) || []).length, 1);
-    assert.equal(results.updated, 1);
-  });
-});
 
 test('copyRecursive skips generated artifacts while copying normal files', () => {
   inTempProject(() => {
@@ -799,65 +726,3 @@ test('copyRecursive skips generated artifacts while copying normal files', () =>
     assert.equal(fs.existsSync('dest/extra/bundle.pyo'), false);
   });
 });
-
-test('OpenCode gate uses a real before-hook block and documents the host boundary', () => {
-  const opencodeAgents = fs.readFileSync(path.join(__dirname, '../../src/opencode/AGENTS.md'), 'utf8');
-  const assertOpenCodeBoundary = (content) => {
-    assert.match(content, /tool\.execute\.before/);
-    assert.match(content, /hard-block supported completion\/state tools/);
-    assert.match(content, /`task`, `taskupdate`, and `todowrite`/);
-    assert.match(content, /CAFEKIT_SPEC_GATE_BLOCKED/);
-    assert.match(content, /`session\.idle`\/Stop/);
-    assert.match(content, /final assistant-turn cancellation boundary/);
-    assert.match(content, /observational only/);
-    assert.match(content, /full-turn parity with Claude\/Codex/);
-    assert.doesNotMatch(content, /tool\.execute\.after/);
-    assert.doesNotMatch(content, /best-effort/);
-    assert.doesNotMatch(content, /tier-2/);
-    assert.doesNotMatch(content, /\badvisory\b/i);
-  };
-  assertOpenCodeBoundary(opencodeAgents);
-
-  const pluginPath = path.join(__dirname, '../../src/opencode/plugins/spec-gate.ts');
-  assert.equal(fs.existsSync(pluginPath), true, 'OpenCode spec-gate plugin must exist');
-  const plugin = fs.readFileSync(pluginPath, 'utf8');
-  assert.match(plugin, /completion_gate/);
-  assert.match(plugin, /tool\.execute\.before/);
-  assert.match(plugin, /CAFEKIT_SPEC_GATE_BLOCKED/);
-  assert.match(plugin, /throw createBlockError/);
-  assert.match(plugin, /session\.idle/);
-  assert.match(plugin, /final assistant message[\s\S]*outside this adapter's boundary/);
-  assert.doesNotMatch(plugin, /advisory/i);
-  assert.doesNotMatch(plugin, /fail-open/i);
-  // JSDoc-safe wording: must not contain block-comment-closing pattern specs/*/spec.json
-  assert.doesNotMatch(plugin, /specs\/\*\/spec\.json/);
-  // Traversal check must be sibling-prefix safe (resolve + relative, not simple startsWith).
-  assert.match(plugin, /relative\s*\(\s*resolvedFeatureDir/);
-  assert.match(plugin, /isAbsolute/);
-  assert.doesNotMatch(plugin, /if \(!abs\.startsWith\(featureDir\)\)/);
-  // Single executable authorities: OpenCode delegates both validation and resolution.
-  assert.match(plugin, /workflow-policy\.cjs/);
-  assert.match(plugin, /spec-resolver\.cjs/);
-  assert.match(plugin, /getSharedValidate|validateCanonicalReceipt/);
-  assert.doesNotMatch(plugin, /const hasBase\s*&&\s*hasHead/);
-  assert.doesNotMatch(plugin, /PLACEHOLDER_TOKENS/);
-
-  const installerDocs = fs.readFileSync(path.join(__dirname, '../../../../docs/installer-architecture.md'), 'utf8');
-  assert.doesNotMatch(installerDocs, /OpenCode.*hard.*completion gate/i);
-
-  // Combined install must copy the plugin and both shared authorities.
-  inTempProject((root) => {
-    const result = spawnSync(process.execPath, [INSTALLER, '--platform', 'opencode', '--yes'], { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    assert.equal(fs.existsSync(path.join(root, '.opencode/plugins/spec-gate.ts')), true);
-    assert.equal(fs.existsSync(path.join(root, '.opencode/scripts/workflow-policy.cjs')), true);
-    assert.equal(fs.existsSync(path.join(root, '.opencode/scripts/spec-resolver.cjs')), true);
-    const installedAgents = fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8');
-    assertOpenCodeBoundary(managedBody(installedAgents, OPENCODE_START, OPENCODE_END));
-    const installed = fs.readFileSync(path.join(root, '.opencode/plugins/spec-gate.ts'), 'utf8');
-    assert.match(installed, /tool\.execute\.before/);
-    assert.match(installed, /CAFEKIT_SPEC_GATE_BLOCKED/);
-    assert.match(installed, /workflow-policy\.cjs/);
-    assert.match(installed, /spec-resolver\.cjs/);
-  });
-});