@haposoft/cafekit 0.16.7 → 0.18.1

package/bin/__tests__/package-inventory.test.js

@@ -39,7 +39,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: [
@@ -58,11 +58,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 = [
@@ -77,7 +77,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 = [
@@ -98,12 +98,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.',
 };
@@ -114,31 +114,17 @@ const REQUIRED_PAYLOAD = [
   'src/claude/scripts/workflow-policy.cjs',
   'src/claude/scripts/provenance.cjs',
   'src/claude/scripts/spec-receipt.cjs',
-  'src/claude/scripts/spec-ground.cjs',
-  'src/claude/scripts/spec-final-state.cjs',
-  'src/claude/scripts/spec-readiness.cjs',
-  'src/claude/scripts/spec-semantic-model.cjs',
-  'src/claude/scripts/validate-spec-output.cjs',
-  'src/claude/scripts/spec-authoring-validation.cjs',
-  'src/claude/scripts/spec-authoring-digest.cjs',
   'src/claude/scripts/generate-skill-catalog.cjs',
   'src/claude/rules/process-management.md',
   'src/claude/rules/review-audit-self-decision.md',
   'src/claude/rules/skill-domain-routing.md',
   'src/claude/rules/skill-workflow-routing.md',
-  'src/claude/skills/route/SKILL.md',
-  'src/claude/skills/route/references/task-taxonomy.md',
-  'src/claude/skills/route/references/chaining-patterns.md',
-  'src/claude/skills/route/references/agent-timing.md',
   'src/claude/skills/orca/SKILL.md',
   'src/claude/skills/brainstorm/SKILL.md',
   'src/claude/skills/brainstorm/references/question-framework.md',
   'src/claude/agents/brainstormer.md',
   'src/claude/skills/research/SKILL.md',
   'src/claude/agents/researcher.md',
-  'src/claude/skills/loop/SKILL.md',
-  'src/claude/skills/loop/references/bounded-loop-protocol.md',
-  'src/claude/skills/loop/references/metric-and-guard-contract.md',
   'src/claude/skills/docs/SKILL.md',
   'src/claude/skills/docx/SKILL.md',
   'src/claude/skills/pdf/SKILL.md',
@@ -179,20 +165,17 @@ const BRAINSTORM_SOURCE_RELATIVES = {
   framework: 'src/claude/skills/brainstorm/references/question-framework.md',
   agent: 'src/claude/agents/brainstormer.md',
 };
-const RESEARCH_LOOP_SOURCE_RELATIVES = {
+const RESEARCH_SOURCE_RELATIVES = {
   research: 'src/claude/skills/research/SKILL.md',
   agent: 'src/claude/agents/researcher.md',
-  loop: 'src/claude/skills/loop/SKILL.md',
-  protocol: 'src/claude/skills/loop/references/bounded-loop-protocol.md',
-  metric: 'src/claude/skills/loop/references/metric-and-guard-contract.md',
   workflow: 'src/claude/rules/skill-workflow-routing.md',
   domain: 'src/claude/rules/skill-domain-routing.md',
 };
 const HOTFIX_SOURCE_RELATIVES = {
-  skill: 'src/claude/skills/hotfix/SKILL.md',
-  review: 'src/claude/skills/hotfix/references/review-cycle.md',
-  parallel: 'src/claude/skills/hotfix/references/parallel-patterns.md',
-  specialized: 'src/claude/skills/hotfix/references/workflow-specialized.md',
+  skill: 'src/claude/skills/fix/SKILL.md',
+  review: 'src/claude/skills/fix/references/review-cycle.md',
+  parallel: 'src/claude/skills/fix/references/parallel-patterns.md',
+  specialized: 'src/claude/skills/fix/references/workflow-specialized.md',
 };
 const REQUIRED_ADAPTIVE_BRAINSTORM_GROUPS = [
   'adviser-gate-fallback',
@@ -208,7 +191,7 @@ const REQUIRED_ADAPTIVE_BRAINSTORM_GROUPS = [
 ];
 const ADAPTIVE_BRAINSTORM_INSTALLED_RULES = [
   { group: 'direct-precedence', mutations: [
-    { from: 'Route Direct first, then\napply controls only to requests that remain in Brainstorm.', to: 'Apply controls before Direct classification.', clause: 'Route Direct first, then apply 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.', clause: 'Route Direct first, then apply controls only to requests that remain in Brainstorm.' },
   ] },
   { group: 'ordered-depth', mutations: [
     { from: 'With no Deep signal, use Standard.', to: 'Deep is always the default.', clause: 'With no Deep signal, use Standard. `--deep` raises Standard to Deep.' },
@@ -216,32 +199,32 @@ const ADAPTIVE_BRAINSTORM_INSTALLED_RULES = [
   { group: 'leading-flags', mutations: [
     { from: 'Parse controls only from the leading consecutive token segment.', to: 'Parse flag-like tokens anywhere.', clause: 'Parse controls only from the leading consecutive token segment.' },
     { from: '`--deep`, `--visual`, and `--advice` in any order, each at most once.', to: '`--deep`, `--visual`, and `--advice` may repeat.', clause: '`--deep`, `--visual`, and `--advice` in any order, each at most once.' },
-    { from: '`--` ends\nthe control segment.', to: '`--` is treated as another control.', clause: '`--` ends the control segment.' },
+    { from: '`--` ends the control segment.', to: '`--` is treated as another control.', clause: '`--` ends the control segment.' },
     { from: 'An unknown or duplicate `--*` inside the leading segment returns usage', to: 'An unknown or duplicate `--*` is ignored', clause: 'An unknown or duplicate `--*` inside the leading segment returns usage and performs no scout, question, tool call, write, or workflow action.' },
   ] },
   { group: 'lens-trigger-skip', mutations: [
-    { from: 'failure isolation for partial or cascading failure\nacross boundaries', to: 'generic failure notes', clause: 'failure isolation for partial or cascading failure across boundaries' },
+    { from: 'failure isolation for partial or cascading failure across boundaries', to: 'generic failure notes', clause: 'failure isolation for partial or cascading failure across boundaries' },
   ] },
   { group: 'evidence-semantics', mutations: [
-    { from: 'Missing evidence\nforces feasibility `unknown` and confidence `low`.', to: 'Missing evidence permits a confident guess.', clause: 'Missing evidence forces feasibility `unknown` and confidence `low`.' },
+    { from: 'Missing evidence forces feasibility `unknown` and confidence `low`.', to: 'Missing evidence permits a confident guess.', clause: 'Missing evidence forces feasibility `unknown` and confidence `low`.' },
   ] },
   { group: 'numeric-estimates', mutations: [
-    { from: 'A numeric estimate requires\nrange, unit, basis, evidence, and assumptions; otherwise report `unknown`.', to: 'A numeric estimate may be a best-effort number.', clause: 'A numeric estimate requires range, 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.', clause: 'A numeric estimate requires range, unit, basis, evidence, and assumptions; otherwise report `unknown`.' },
   ] },
   { group: 'pre-tool-authority-redaction', mutations: [
-    { from: 'Before an\nexternal visual tool or adviser handoff, minimize context and redact secrets,\ncredentials, private keys, access tokens, and unnecessary PII.', to: 'Forward full context to every external tool and adviser.', clause: 'Before an external visual tool or adviser handoff, minimize context and redact secrets, credentials, private keys, access tokens, and unnecessary PII.' },
-    { from: '`--visual` may present inline Mermaid or ASCII for any non-direct analysis and\nfalls back to equivalent text when rendering is unavailable.', to: '`--visual` fails when rendering is unavailable.', clause: '`--visual` may present inline Mermaid or ASCII for any non-direct analysis and falls back to equivalent text when rendering is unavailable.' },
-    { from: 'Durable or external\nrendering requires explicit user authority before invocation.', to: 'Durable or external rendering may run without consent.', clause: 'Durable or external rendering requires explicit user authority before invocation.' },
+    { 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.', clause: 'Before an external visual tool or adviser handoff, minimize context and redact secrets, credentials, private keys, access tokens, and unnecessary PII.' },
+    { from: '`--visual` may present inline Mermaid or ASCII for any non-direct analysis and falls back to equivalent text when rendering is unavailable.', to: '`--visual` fails when rendering is unavailable.', clause: '`--visual` may present inline Mermaid or ASCII for any non-direct analysis and falls back to equivalent text when rendering is unavailable.' },
+    { from: 'Durable or external rendering requires explicit user authority before invocation.', to: 'Durable or external rendering may run without consent.', clause: 'Durable or external rendering requires explicit user authority before invocation.' },
   ] },
   { group: 'adviser-gate-fallback', mutations: [
-    { from: '`--advice` invokes\n`brainstormer` only after the material-choice gate;', to: '`--advice` invokes `brainstormer` before routing;', clause: '`--advice` invokes `brainstormer` only after the material-choice gate;' },
-    { from: 'if advice is unavailable or\nfails, label it unavailable and continue with controller analysis.', to: 'if advice is unavailable, stop the workflow.', clause: 'if advice is unavailable or fails, label it unavailable and continue with controller analysis.' },
+    { from: '`--advice` invokes `brainstormer` only after the material-choice gate;', to: '`--advice` invokes `brainstormer` before routing;', clause: '`--advice` invokes `brainstormer` only after the material-choice gate;' },
+    { from: 'if advice is unavailable or fails, label it unavailable and continue with controller analysis.', to: 'if advice is unavailable, stop the workflow.', clause: 'if advice is unavailable or fails, label it unavailable and continue with controller analysis.' },
   ] },
   { group: 'decision-brief', mutations: [
-    { 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.', to: 'The handoff has no revision or freshness binding.', clause: '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.' },
+    { 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.', clause: '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.' },
   ] },
   { group: 'no-persistence-dispatch', mutations: [
-    { from: 'Neither overlay\nwrites, approves, persists, dispatches, or completes work.', to: 'Overlays may persist, approve, dispatch, and complete work.', clause: 'Neither overlay writes, 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.', clause: 'Neither overlay writes, approves, persists, dispatches, or completes work.' },
   ] },
 ];
 
@@ -342,20 +325,15 @@ function runInstaller(installer, root, platforms, lang, extraArgs = []) {
   return result;
 }
 
-function installedRouteFiles(project, platform) {
+function installedRoutingRuleFiles(project, platform) {
   const runtimeRoot = platform === 'codex' ? '.codex' : '.claude';
-  const root = path.join(project, platform === 'codex' ? '.agents/skills/route' : '.claude/skills/route');
   return {
-    skill: path.join(root, 'SKILL.md'),
-    taxonomy: path.join(root, 'references/task-taxonomy.md'),
-    chaining: path.join(root, 'references/chaining-patterns.md'),
-    timing: path.join(root, 'references/agent-timing.md'),
     workflow: path.join(project, runtimeRoot, 'rules/skill-workflow-routing.md'),
     domain: path.join(project, runtimeRoot, 'rules/skill-domain-routing.md'),
   };
 }
 
-function routeProjectionIssues(files) {
+function routingRuleIssues(files) {
   const text = Object.fromEntries(Object.entries(files).map(([key, file]) => [
     key, fs.readFileSync(file, 'utf8').replace(/\s+/g, ' '),
   ]));
@@ -363,56 +341,10 @@ function routeProjectionIssues(files) {
   const requires = (issue, clauses) => {
     if (clauses.some(([source, clause]) => !text[source].includes(clause))) issues.add(issue);
   };
-  requires('direct-path', [
-    ['skill', 'invoke that skill directly'],
-    ['skill', 'use it directly without constructing a chain'],
-    ['skill', 'Do not create a route chain or spawn agents merely to answer it'],
-  ]);
-  requires('classification', [
-    ['skill', 'final deliverable'], ['skill', 'highest-link risk'],
-    ['skill', 'number of material domains'],
-  ]);
-  requires('link-contract', [
-    ['chaining', '**Entry:**'], ['chaining', '**Exit:**'], ['chaining', '**Owner:** exactly one'],
-  ]);
-  requires('failure-stop', [
-    ['chaining', '(link, owner, normalized cause)'],
-    ['chaining', 'Two failures with the same failure key stop the chain'],
-    ['chaining', 'Different normalized causes do not share a key'],
-  ]);
-  requires('collapse-and-detour', [
-    ['skill', 'remove every link whose output is already evidenced'],
-    ['chaining', 'preserve its valid exit evidence, normalize the root cause, and choose one bounded detour'],
-  ]);
-  requires('delegation-contract', [
-    ['timing', '**Outcome** — observable result'],
-    ['timing', '**Scope** — owned files, systems, or questions'],
-    ['timing', '**Inputs** — current evidence and prerequisite artifacts'],
-    ['timing', '**Constraints** — safety, compatibility, authority, and non-goals'],
-    ['timing', '**Acceptance** — proof required for completion'],
-    ['timing', '**Handoff** — expected returned artifact and destination'],
-    ['timing', '**Status vocabulary** — `DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT`'],
-  ]);
-  requires('agent-fallback', [
-    ['timing', 'If the preferred agent is absent'],
-    ['timing', 'never synthesize a role'],
-    ['timing', 'DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT'],
-  ]);
-  requires('authority', [
-    ['skill', 'never expand it'],
-    ['skill', 'diagnosis does not authorize repair'],
-    ['skill', 'does not authorize commit, push, deploy, publish, or release'],
-  ]);
-  requires('risk-gates', [
-    ['skill', 'require independent review and user confirmation before advancing past the high-risk gate'],
-  ]);
-  requires('proof-boundary', [
-    ['skill', 'remains `[UNPROVEN]` until a separate host run observes it'],
-  ]);
   requires('rule-direct-path', [
     ['workflow', 'If the user names a valid installed skill, use it directly'],
     ['workflow', 'If one obvious low-risk installed skill covers the intent, use it directly'],
-    ['workflow', 'do not invoke Route or agents for ceremony'],
+    ['workflow', 'do not spawn agents for ceremony'],
   ]);
   requires('rule-live-catalog', [
     ['workflow', 'Resolve every abstract link against the current runtime catalog'],
@@ -774,30 +706,24 @@ function assertPackedBrainstormParity(project, platform) {
   }
 }
 
-function packedResearchLoopPaths(project, platform) {
+function packedResearchPaths(project, platform) {
   return platform === 'codex'
     ? {
         research: path.join(project, '.agents/skills/research/SKILL.md'),
         agent: path.join(project, '.codex/agents/researcher.toml'),
-        loop: path.join(project, '.agents/skills/loop/SKILL.md'),
-        protocol: path.join(project, '.agents/skills/loop/references/bounded-loop-protocol.md'),
-        metric: path.join(project, '.agents/skills/loop/references/metric-and-guard-contract.md'),
         workflow: path.join(project, '.codex/rules/skill-workflow-routing.md'),
         domain: path.join(project, '.codex/rules/skill-domain-routing.md'),
       }
     : {
         research: path.join(project, '.claude/skills/research/SKILL.md'),
         agent: path.join(project, '.claude/agents/researcher.md'),
-        loop: path.join(project, '.claude/skills/loop/SKILL.md'),
-        protocol: path.join(project, '.claude/skills/loop/references/bounded-loop-protocol.md'),
-        metric: path.join(project, '.claude/skills/loop/references/metric-and-guard-contract.md'),
         workflow: path.join(project, '.claude/rules/skill-workflow-routing.md'),
         domain: path.join(project, '.claude/rules/skill-domain-routing.md'),
       };
 }
 
-function readPackedResearchLoop(project, platform) {
-  const paths = packedResearchLoopPaths(project, platform);
+function readPackedResearch(project, platform) {
+  const paths = packedResearchPaths(project, platform);
   const values = Object.fromEntries(Object.entries(paths).map(([key, target]) => [
     key, fs.readFileSync(target, 'utf8'),
   ]));
@@ -807,13 +733,12 @@ function readPackedResearchLoop(project, platform) {
   return values;
 }
 
-function packedResearchLoopIssues(project, platform) {
-  const values = Object.fromEntries(Object.entries(readPackedResearchLoop(project, platform)).map(
+function packedResearchIssues(project, platform) {
+  const values = Object.fromEntries(Object.entries(readPackedResearch(project, platform)).map(
     ([key, value]) => [key, value.replace(/\s+/g, ' ').trim()]
   ));
   const issues = new Set();
   const publicResearch = platform === 'codex' ? 'name: cf-research' : 'name: cf:research';
-  const publicLoop = platform === 'codex' ? 'name: cf-loop' : 'name: cf:loop';
   if (!values.research.includes(publicResearch)
     || !values.research.includes('Choose the smallest depth that can support the decision:')
     || !values.research.includes('Use delegated researchers only as optional acceleration')
@@ -826,35 +751,15 @@ function packedResearchLoopIssues(project, platform) {
     || !values.agent.includes('owns any authorized persistence.')) {
     issues.add('research-agent-boundary');
   }
-  if (!values.loop.includes(publicLoop)
-    || !values.loop.includes('Loop is explicit-only. Never auto-route ordinary implementation, debugging, or research into Loop.')
-    || !values.loop.includes('Reject dirty in-scope state; record but never import or clean out-of-scope dirt.')
-    || !values.loop.includes('separately approved external realpath')
-    || !values.loop.includes('complete detached-worktree tracked/untracked manifest')
-    || !values.loop.includes('Live-agent adherence to this written contract is `[UNPROVEN]` without a host run.')) {
-    issues.add('loop-safety');
-  }
-  if (!values.metric.includes('Guard is mandatory, fixed before baseline, and distinct from Metric.')
-    || !values.metric.includes('`numeric_format`: exactly IEEE-754 binary64')
-    || !values.metric.includes('nonzero exit')
-    || !values.metric.includes('require median, noise, improvement, and required delta to remain finite.')) {
-    issues.add('metric-guard');
-  }
-  if (!values.protocol.includes('do not clean. Preserve the exact path, PID/process evidence, and ownership marker; return `BLOCKED`')
-    || !values.protocol.includes('`base_oid`;')
-    || !values.protocol.includes('patch byte length and lowercase SHA-256')) {
-    issues.add('failure-handoff');
-  }
-  if (!values.workflow.includes('numeric optimization capability remains explicit-only and must never be auto-routed.')
-    || !values.domain.includes('explicit-only numeric optimization capability unless the user invokes it with its required bounded metric/guard contract.')) {
-    issues.add('explicit-routing');
+  if (/numeric optimization capability/.test(`${values.workflow}\n${values.domain}`)) {
+    issues.add('loop-removed');
   }
   return [...issues].sort();
 }
 
-function assertPackedResearchLoopParity(project, platform) {
-  const installed = packedResearchLoopPaths(project, platform);
-  for (const [key, relative] of Object.entries(RESEARCH_LOOP_SOURCE_RELATIVES)) {
+function assertPackedResearchParity(project, platform) {
+  const installed = packedResearchPaths(project, platform);
+  for (const [key, relative] of Object.entries(RESEARCH_SOURCE_RELATIVES)) {
     const sourcePath = path.join(PACKAGE_ROOT, relative);
     const source = fs.readFileSync(sourcePath, 'utf8');
     const expected = platform === 'codex'
@@ -866,12 +771,15 @@ function assertPackedResearchLoopParity(project, platform) {
   }
   const manifest = JSON.parse(fs.readFileSync(path.join(project, RUNTIMES[platform].manifest), 'utf8'));
   const prefixes = platform === 'codex'
-    ? ['.agents/skills/research/', '.agents/skills/loop/']
-    : ['skills/research/', 'skills/loop/'];
+    ? ['.agents/skills/research/']
+    : ['skills/research/'];
   for (const prefix of prefixes) {
     assert.ok(Object.keys(manifest.files).some((entry) => entry.startsWith(prefix)), `${platform} manifest missing ${prefix}`);
   }
-  assert.deepEqual(packedResearchLoopIssues(project, platform), []);
+  const removedLoop = platform === 'codex' ? '.agents/skills/loop/' : 'skills/loop/';
+  assert.equal(Object.keys(manifest.files).some((entry) => entry.startsWith(removedLoop)), false, `${platform} manifest still lists ${removedLoop}`);
+  assert.equal(fs.existsSync(path.join(project, platform === 'codex' ? '.agents/skills/loop' : '.claude/skills/loop')), false, `${platform} still installs Loop`);
+  assert.deepEqual(packedResearchIssues(project, platform), []);
 }
 
 function packedBrainstormInstalledPaths(project, platform) {
@@ -1316,8 +1224,8 @@ function assertInstalledReadinessMutationsDetected(tempRoot, project, platform)
     },
     {
       name: 'fresh-original-counterexample-replay', issue: 'repair-closure', source: 'review',
-      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', issue: 'repair-closure', source: 'review',
@@ -1423,7 +1331,7 @@ function assertInstalledAdaptiveMutationsDetected(tempRoot, project, platform) {
     ['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,
@@ -1437,7 +1345,7 @@ function assertInstalledAdaptiveMutationsDetected(tempRoot, project, platform) {
     ['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']],
   ];
@@ -1607,69 +1515,15 @@ function assertInstalledProvenance(root, platform, fixture) {
   const policy = path.join(scripts, 'workflow-policy.cjs');
   const resolver = path.join(scripts, 'spec-resolver.cjs');
   const receipt = path.join(scripts, 'spec-receipt.cjs');
-  const finalState = path.join(scripts, 'spec-final-state.cjs');
-  const readiness = path.join(scripts, 'spec-readiness.cjs');
   const gate = path.join(
     root,
     platform === 'claude' ? '.claude/hooks/spec-gate.cjs' : '.codex/hooks/spec-gate.cjs'
   );
-  const authorityDir = path.join(root, platform === 'claude' ? '.claude/hooks' : '.codex/hooks');
-  const authority = path.join(authorityDir, 'completion-authority.cjs');
-  const authorityCheck = path.join(authorityDir, 'completion-authority-check.cjs');
-  const authorityState = path.join(authorityDir, 'completion-authority-state.cjs');
-  const semanticAuthority = path.join(authorityDir, 'semantic-review-authority.cjs');
-  for (const file of [helper, policy, resolver, receipt, finalState, readiness]) {
+  for (const file of [helper, policy, resolver, receipt]) {
     assert.equal(fs.existsSync(file), true, `${platform} installed file missing: ${file}`);
   }
   assert.equal(fs.existsSync(gate), true, `${platform} installed gate missing: ${gate}`);
 
-  for (const file of [authority, authorityCheck, authorityState, semanticAuthority]) {
-    assert.equal(fs.existsSync(file), true, `${platform} installed completion authority missing: ${file}`);
-  }
-  const finalStateBytes = fs.readFileSync(finalState);
-  fs.rmSync(finalState);
-  const missingFinalState = spawnSync(process.execPath, [authority, '--stop'], {
-    cwd: root,
-    env: { ...process.env, PROJECT_ROOT: root },
-    input: JSON.stringify({ cwd: root, session_id: fixture.session, hook_event_name: 'Stop' }),
-    encoding: 'utf8',
-  });
-  assert.equal(JSON.parse(missingFinalState.stdout).decision, 'block', `${platform} missing final-state closure must fail closed`);
-  const escapedFinalState = path.join(root, 'escaped-spec-final-state.cjs');
-  fs.writeFileSync(escapedFinalState, finalStateBytes);
-  fs.symlinkSync(escapedFinalState, finalState);
-  const symlinkFinalState = spawnSync(process.execPath, [authority, '--stop'], {
-    cwd: root,
-    env: { ...process.env, PROJECT_ROOT: root },
-    input: JSON.stringify({ cwd: root, session_id: fixture.session, hook_event_name: 'Stop' }),
-    encoding: 'utf8',
-  });
-  assert.equal(JSON.parse(symlinkFinalState.stdout).decision, 'block', `${platform} symlinked final-state closure must fail closed`);
-  fs.rmSync(finalState);
-  fs.writeFileSync(finalState, finalStateBytes);
-  fs.rmSync(escapedFinalState);
-  const authorityCheckBytes = fs.readFileSync(authorityCheck);
-  fs.writeFileSync(authorityCheck, 'module.exports = {};\n');
-  const malformedAuthority = spawnSync(process.execPath, [authority, '--stop'], {
-    cwd: root,
-    env: { ...process.env, PROJECT_ROOT: root },
-    input: JSON.stringify({ cwd: root, session_id: fixture.session, hook_event_name: 'Stop' }),
-    encoding: 'utf8',
-  });
-  assert.equal(malformedAuthority.status, 0, `${platform} malformed authority must fail closed`);
-  assert.equal(JSON.parse(malformedAuthority.stdout).decision, 'block');
-  fs.writeFileSync(authorityCheck, authorityCheckBytes);
-  fs.rmSync(authorityCheck);
-  const missingAuthority = spawnSync(process.execPath, [authority, '--stop'], {
-    cwd: root,
-    env: { ...process.env, PROJECT_ROOT: root },
-    input: JSON.stringify({ cwd: root, session_id: fixture.session, hook_event_name: 'Stop' }),
-    encoding: 'utf8',
-  });
-  assert.equal(missingAuthority.status, 0, `${platform} missing authority dependency must fail closed`);
-  assert.equal(JSON.parse(missingAuthority.stdout).decision, 'block');
-  fs.writeFileSync(authorityCheck, authorityCheckBytes);
-
   const helperRun = spawnSync(process.execPath, provenanceCliArgs(helper, root, fixture), {
     cwd: root,
     encoding: 'utf8',
@@ -1797,26 +1651,13 @@ function assertInstalledScripts(root, platform) {
   const scripts = path.join(root, RUNTIMES[platform].root, 'scripts');
   const policy = path.join(scripts, 'workflow-policy.cjs');
   const scanner = path.join(scripts, 'scan-staged-secrets.cjs');
-  const grounder = path.join(scripts, 'spec-ground.cjs');
-  const finalState = path.join(scripts, 'spec-final-state.cjs');
-  const readiness = path.join(scripts, 'spec-readiness.cjs');
-  const validator = path.join(scripts, 'validate-spec-output.cjs');
   assert.ok(fs.existsSync(policy), `installed policy missing: ${policy}`);
   assert.ok(fs.existsSync(scanner), `installed scanner missing: ${scanner}`);
-  assert.ok(fs.existsSync(grounder), `installed validator dependency missing: ${grounder}`);
-  assert.ok(fs.existsSync(finalState), `installed final-state dependency missing: ${finalState}`);
-  assert.ok(fs.existsSync(readiness), `installed readiness finalizer missing: ${readiness}`);
-  assert.ok(fs.existsSync(validator), `installed validator missing: ${validator}`);
 
   const policyRun = spawnSync(process.execPath, [policy, '--json'], { cwd: root, encoding: 'utf8' });
   assert.equal(policyRun.status, 0, `${policyRun.stdout}\n${policyRun.stderr}`);
   assert.equal(JSON.parse(policyRun.stdout).contract, 'execution-policy');
 
-  const validatorRun = spawnSync(process.execPath, [validator], { cwd: root, encoding: 'utf8' });
-  assert.equal(validatorRun.status, 2, `${validatorRun.stdout}\n${validatorRun.stderr}`);
-  assert.match(validatorRun.stderr, /Usage: .*validate-spec-output\.cjs/);
-  assert.doesNotMatch(validatorRun.stderr, /MODULE_NOT_FOUND|Cannot find module/);
-
   const safe = path.join(root, 'safe.txt');
   fs.writeFileSync(safe, 'mode=safe\n');
   spawnSync('git', ['init', '-q'], { cwd: root });
@@ -1826,458 +1667,10 @@ function assertInstalledScripts(root, platform) {
   assert.match(scannerRun.stdout, /No staged secrets found/);
 }
 
-function installedSemanticPaths(root, platform) {
-  const runtimeRoot = path.join(root, RUNTIMES[platform].root);
-  const skillRoot = platform === 'codex'
-    ? path.join(root, '.agents', 'skills')
-    : path.join(runtimeRoot, 'skills');
-  const paths = {
-    policy: path.join(runtimeRoot, 'scripts', 'workflow-policy.cjs'),
-    scaffold: path.join(runtimeRoot, 'scripts', 'spec-scaffold.cjs'),
-    validator: path.join(runtimeRoot, 'scripts', 'validate-spec-output.cjs'),
-    authoringValidator: path.join(runtimeRoot, 'scripts', 'spec-authoring-validation.cjs'),
-    authoringDigest: path.join(runtimeRoot, 'scripts', 'spec-authoring-digest.cjs'),
-    grounder: path.join(runtimeRoot, 'scripts', 'spec-ground.cjs'),
-    finalState: path.join(runtimeRoot, 'scripts', 'spec-final-state.cjs'),
-    readiness: path.join(runtimeRoot, 'scripts', 'spec-readiness.cjs'),
-    semanticModel: path.join(runtimeRoot, 'scripts', 'spec-semantic-model.cjs'),
-    resolver: path.join(runtimeRoot, 'scripts', 'spec-resolver.cjs'),
-    provenance: path.join(runtimeRoot, 'scripts', 'provenance.cjs'),
-    completion: path.join(runtimeRoot, 'hooks', 'completion-authority-check.cjs'),
-    semanticAuthority: path.join(runtimeRoot, 'hooks', 'semantic-review-authority.cjs'),
-    stateTemplate: path.join(skillRoot, 'specs', 'templates', 'spec-state.json'),
-  };
-  for (const [name, target] of Object.entries(paths)) {
-    assert.equal(fs.existsSync(target), true, `${platform} installed ${name} missing: ${target}`);
-    assert.equal(path.relative(root, target).startsWith('..'), false, `${platform} ${name} escaped install root`);
-  }
-  return paths;
-}
-
-function runInstalled(script, args, root, expected = 0) {
-  const result = spawnSync(process.execPath, [script, ...args], { cwd: root, encoding: 'utf8' });
-  assert.equal(result.status, expected, `${script}\n${result.stdout}\n${result.stderr}`);
-  return result;
-}
-
 function writeJson(target, value) {
   fs.writeFileSync(target, `${JSON.stringify(value, null, 2)}\n`);
 }
 
-function materializeSpecState(paths, root, feature, { strict = false } = {}) {
-  const featureDir = path.join(root, 'specs', feature);
-  runInstalled(paths.scaffold, [feature], root);
-  const state = JSON.parse(fs.readFileSync(path.join(featureDir, 'spec.json'), 'utf8'));
-  state.scope_lock.in_scope = [`${feature} behavior`];
-  state.scope_lock.out_of_scope = ['unrelated behavior'];
-  if (strict) {
-    state.workflow_policy.assurance_level = 'Strict';
-    state.workflow_policy.classified_minimum.assurance_level = 'Strict';
-    state.workflow_policy.risks = ['auth'];
-  }
-  writeJson(path.join(featureDir, 'spec.json'), state);
-  return { featureDir, specFile: path.join(featureDir, 'spec.json'), state };
-}
-
-function requirementsProjection({ proof = false } = {}) {
-  return `# Requirements
-
-## Requirements
-
-### Requirement 1: Installed behavior
-
-- **R1.1**: The CommonJS entrypoint \`src/entry.js\` shall return an object containing only status \`enabled\` when its sole \`valid\` argument is the boolean \`true\`; it shall return an object containing only status \`rejected\` for \`false\`, a missing argument, or any non-boolean value.${proof ? '\n- **R1.2**: The installed verifier shall prove the observed entry behavior through its grounded evidence boundary.' : ''}
-`;
-}
-
-const TYPED_ANCHOR_COLUMNS = ['ID', 'Type', 'Target', 'Role', 'Access', 'Action'];
-
-function typedAnchorTable(rows) {
-  assert.ok(Array.isArray(rows) && rows.length > 0, 'typed anchor projection requires rows');
-  const header = `| ${TYPED_ANCHOR_COLUMNS.join(' | ')} |`;
-  const separator = `|${TYPED_ANCHOR_COLUMNS.map(() => '---').join('|')}|`;
-  const body = rows.map((row) => {
-    assert.deepEqual(Object.keys(row), ['id', 'type', 'target', 'role', 'access', 'action']);
-    assert.ok(Object.values(row).every((value) => typeof value === 'string' && value.trim() !== ''));
-    return `| ${row.id} | ${row.type} | \`${row.target}\` | ${row.role} | ${row.access} | ${row.action} |`;
-  });
-  return [header, separator, ...body].join('\n');
-}
-
-function designProjection({
-  expected = 'exit 0; boolean true returns the exact enabled object; false, undefined, null, `"true"`, 1, and an object return the exact rejected object',
-  taskful = false,
-} = {}) {
-  const anchors = typedAnchorTable([{
-    id: 'A-D-01', type: 'file', target: taskful ? 'src/design-boundary.js' : 'src/entry.js',
-    role: taskful ? 'existing design boundary for the entrypoint' : 'existing runtime entrypoint and contract owner',
-    access: 'read', action: 'read',
-  }]);
-  const reachabilityAnchors = taskful ? 'A-R1-01-01, A-R1-02-02' : 'A-D-01';
-  return `# Design
-
-## Boundary
-
-- **Owns:** The exact return contract of the CommonJS function exported by \`src/entry.js\`.
-- **Reads:** One \`valid\` argument; only the boolean \`true\` is valid.
-- **Writes/exposes:** Exactly one status field whose value is \`enabled\` or \`rejected\`.
-- **Outside boundary:** Unrelated runtime behavior.
-
-## Typed Anchors
-
-${anchors}
-
-## Decisions and Invariants
-
-### D1 — Installed result decision
-
-- **Decision:** \`valid === true\` returns an object containing only status \`enabled\`; every other value returns an object containing only status \`rejected\`.
-- **Rejects ambiguity:** Truthy non-booleans such as \`"true"\` never count as valid.
-- **Negative path:** \`false\`, \`undefined\`, \`null\`, strings, numbers, and objects return rejected.
-- **Anchors:** A-D-01
-
-### I1 — Rejection invariant
-
-Any input other than the boolean \`true\` never returns enabled.
-
-### C1 — Result contract
-
-- **Owner:** A-D-01
-- **Consumers:** \`test/entry.test.js\` and callers of the CommonJS export.
-- **Shape/behavior:** The result is an object with exactly one \`status\` field set to \`enabled\` or \`rejected\`.
-- **Compatibility:** The strict boolean discriminator, exact object shape, and two status values remain stable.
-
-## Verification Definitions
-
-- **V1**: Criteria R1.1; Owner ${taskful ? 'R1-01' : 'A-D-01'}; ${taskful ? 'Proof criteria R1.2; Proof owner R1-02; Evidence anchor A-R1-02-02; ' : ''}Decision refs D1, I1, C1; Method command \`node --test test/entry.test.js\`; Expected ${expected}; Negative/failure \`false\`, missing input, \`null\`, and truthy non-booleans all return the exact rejected object; Reachability/grounding entrypoint \`src/entry.js\` via ${reachabilityAnchors}.
-`;
-}
-
-function completeSemanticReview(paths, root, fixture, counterexamples) {
-  // C16/D13: only the installed spec-authoring-validation.cjs coordinator may
-  // flip authoring.* to validated and write the matching receipt (I21/R3.9) —
-  // run it over the fixture's current bytes instead of hand-writing the enum.
-  // Lifecycle order (I15/R3.7): authoring -> coordinator -> semantic review ->
-  // readiness, never the reverse.
-  runInstalled(paths.scaffold, [fixture.state.feature_name, '--sync-semantic-model'], root);
-  runInstalled(paths.authoringValidator, [fixture.featureDir], root);
-  const state = JSON.parse(fs.readFileSync(fixture.specFile, 'utf8'));
-  fixture.reviewResult = {
-    verdict: 'PASS',
-    findings: [],
-    unresolved_decisions: [],
-    graph_coverage: [
-      'criterion_local', 'cross_criterion', 'runtime_path',
-      'assumption_provenance', 'compatibility_migration',
-    ].map((surface) => ({
-      surface, covered: true,
-      notes: 'The review covers this semantic surface against the canonical model.',
-    })),
-    reviewed_criteria: counterexamples.map(({ criterion }) => criterion),
-    counterexamples,
-    reviewer_evidence: null,
-  };
-  if (state.workflow_policy.assurance_level === 'Strict') {
-    const digest = runInstalled(paths.validator, [fixture.featureDir, '--semantic-digest'], root).stdout.trim();
-    assert.match(digest, /^sha256:[a-f0-9]{64}$/);
-    return digest;
-  }
-  const reviewFile = path.join(fixture.featureDir, '.review-result.json');
-  writeJson(reviewFile, fixture.reviewResult);
-  runInstalled(paths.readiness, [fixture.featureDir, '--review-result', reviewFile], root);
-  fs.unlinkSync(reviewFile);
-  runInstalled(paths.validator, [fixture.featureDir], root);
-  runInstalled(paths.grounder, [fixture.featureDir, '--root', root], root);
-  return JSON.parse(fs.readFileSync(fixture.specFile, 'utf8')).validation.semantic_review.semantic_digest;
-}
-
-function createTasklessFixture(paths, root, feature, options = {}) {
-  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'test'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'src', 'entry.js'), 'module.exports = (valid) => ({ status: valid === true ? "enabled" : "rejected" });\n');
-  fs.writeFileSync(path.join(root, 'src', 'design-boundary.js'), 'module.exports = { entry: "src/entry.js" };\n');
-  fs.writeFileSync(path.join(root, 'test', 'entry.test.js'), `const test = require('node:test');
-const assert = require('node:assert/strict');
-const entry = require('../src/entry.js');
-
-test('entry accepts only the boolean true discriminator', () => {
-  assert.deepEqual(entry(true), { status: 'enabled' });
-  for (const invalid of [false, undefined, null, 'true', 1, {}]) {
-    assert.deepEqual(entry(invalid), { status: 'rejected' });
-  }
-});
-`);
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ scripts: { test: 'node --test' } }));
-  const fixture = materializeSpecState(paths, root, feature, options);
-  fs.writeFileSync(path.join(fixture.featureDir, 'requirements.md'), requirementsProjection());
-  fs.writeFileSync(path.join(fixture.featureDir, 'design.md'), designProjection());
-  fixture.digest = completeSemanticReview(paths, root, fixture, [{
-    criterion: 'R1.1', case_kind: 'failure',
-    scenario: 'The installed entry receives input without the required discriminator.',
-    expected: 'The installed entry returns rejected and never returns enabled.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }]);
-  return fixture;
-}
-
-function taskProjection({ id, title, ownedPath, criterion, verificationRef, role, artifact = false }) {
-  const artifactPath = `artifacts/${id}.json`;
-  const anchors = typedAnchorTable([
-    { id: `A-${id}-01`, type: 'file', target: ownedPath, role: 'owner', access: 'write', action: 'modify' },
-    ...(artifact ? [{
-      id: `A-${id}-02`, type: 'artifact', target: artifactPath,
-      role: 'verifier', access: 'write', action: 'create',
-    }] : []),
-    {
-      id: `A-${id}-${artifact ? '03' : '02'}`, type: 'command',
-      target: 'node --test test/entry.test.js', role: 'verifier', access: 'read', action: 'read',
-    },
-  ]);
-  return `# Task ${id}: ${title}
-**Status:** pending
-
-## Outcome
-
-Deliver observable ${title.toLowerCase()} behavior through the installed entrypoint.
-
-## Scope
-
-- **In scope:** Exact behavior owned at ${ownedPath}.
-- **Out of scope:** Unrelated runtime behavior.
-
-## Anchors and Ownership
-
-${anchors}
-
-## Changes
-
-- [ ] Implement the exact owned behavior. _Requirements: ${criterion.slice(1)}_
-
-## Acceptance
-
-- **${criterion}:** The installed command returns the criterion-specific observable state.
-
-## Dependencies
-
-- none
-
-## Verification Plan
-
-- **Verification ref:** ${verificationRef}
-- **Task role:** ${role}
-- **Command:** \`node --test test/entry.test.js\`
-- **Expected:** Exit code 0 and the criterion-specific state is observed.${artifact ? ` The artifact \`${artifactPath}\` must exist, and SHA-256 over its current bytes must match the recorded digest.` : ''}
-- **Negative path:** Invalid input returns the named rejected state.
-- **Reachability:** \`src/entry.js\` is reached by the installed test command.
-`;
-}
-
-function createTaskFixture(paths, root, feature) {
-  fs.mkdirSync(path.join(root, 'artifacts'), { recursive: true });
-  const fixture = materializeSpecState(paths, root, feature);
-  fs.writeFileSync(path.join(fixture.featureDir, 'requirements.md'), requirementsProjection({ proof: true }));
-  fs.writeFileSync(path.join(fixture.featureDir, 'design.md'), designProjection({
-    expected: 'exit 0, status enabled, and verifier artifact `artifacts/R1-02.json` whose SHA-256 over current bytes matches the recorded digest',
-    taskful: true,
-  }));
-  const taskOne = 'tasks/task-R1-01-implement.md';
-  const taskTwo = 'tasks/task-R1-02-verify.md';
-  fs.mkdirSync(path.join(fixture.featureDir, 'tasks'), { recursive: true });
-  fs.writeFileSync(path.join(fixture.featureDir, taskOne), taskProjection({
-    id: 'R1-01', title: 'Implement behavior', ownedPath: 'src/entry.js', criterion: 'R1.1',
-    verificationRef: 'V1', role: 'subject implements R1.1',
-  }));
-  fs.writeFileSync(path.join(fixture.featureDir, taskTwo), taskProjection({
-    id: 'R1-02', title: 'Verify behavior', ownedPath: 'test/entry.test.js', criterion: 'R1.2',
-    verificationRef: 'V1', role: 'verifier verifies V1 through separately owned R1.2 proof', artifact: true,
-  }));
-  const state = fixture.state;
-  state.authoring.tasks = 'draft';
-  state.task_files = [taskOne, taskTwo];
-  state.task_registry = Object.fromEntries([
-    [taskOne, { id: 'R1-01', title: 'Implement behavior', status: 'pending', dependencies: [], blocker: null, started_at: null, completed_at: null, last_updated_at: null }],
-    [taskTwo, { id: 'R1-02', title: 'Verify behavior', status: 'pending', dependencies: [], blocker: null, started_at: null, completed_at: null, last_updated_at: null }],
-  ]);
-  state.coordination.boundaries = [{
-    id: 'B-OWN', type: 'ownership', tasks: ['R1-01', 'R1-02'],
-    write_sets: { 'R1-01': ['src/entry.js'], 'R1-02': ['test/entry.test.js', 'artifacts/R1-02.json'] },
-  }, {
-    id: 'B-PROOF', type: 'proof', subject: 'R1-01', verifier: 'R1-02',
-    verification_ref: 'V1', artifact_anchor: 'A-R1-02-02',
-  }];
-  writeJson(fixture.specFile, state);
-  fixture.digest = completeSemanticReview(paths, root, fixture, [{
-    criterion: 'R1.1', case_kind: 'failure',
-    scenario: 'Invalid input reaches the installed implementation boundary.',
-    expected: 'The implementation returns rejected and never reports enabled.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }, {
-    criterion: 'R1.2', case_kind: 'failure',
-    scenario: 'The verification command completes without producing its proof artifact.',
-    expected: 'The verification criterion remains unsatisfied until `artifacts/R1-02.json` exists and its SHA-256 over current bytes matches the recorded digest.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }]);
-  return fixture;
-}
-
-function initializeGit(root) {
-  fs.writeFileSync(path.join(root, '.gitignore'), `${'node_' + 'modules'}/\n`);
-  for (const args of [
-    ['init', '-q'], ['config', 'user.name', 'CafeKit Packed E2E'],
-    ['config', 'user.email', 'packed-e2e@example.invalid'],
-    ['add', '--', '.gitignore', 'src/entry.js', 'src/design-boundary.js', 'test/entry.test.js', 'package.json'],
-    ['commit', '--no-gpg-sign', '-qm', 'packed semantic fixture'],
-  ]) {
-    const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
-    assert.equal(result.status, 0, `${args.join(' ')}\n${result.stdout}\n${result.stderr}`);
-  }
-}
-
-function assertInstalledCompletion(paths, root, platform, fixture) {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-completion-home-'));
-  const code = `
-const fs = require('fs');
-const path = require('path');
-const policy = require(process.argv[1]);
-const provenance = require(process.argv[2]);
-const checker = require(process.argv[3]);
-const resolver = require(process.argv[4]);
-const root = process.argv[5];
-const feature = process.argv[6];
-const specFile = path.join(root, 'specs', feature, 'spec.json');
-const state = JSON.parse(fs.readFileSync(specFile, 'utf8'));
-state.status = 'done';
-fs.writeFileSync(specFile, JSON.stringify(state, null, 2) + '\\n');
-const context = provenance.deriveRuntimeContext({ projectRoot: root, specsRoot: path.join(root, 'specs'), specFile, featureName: feature, runtimeSession: 'packed-session' });
-fs.writeFileSync(path.join(root, 'specs', feature, 'feature-receipt.md'), ['Verification: PASS','Command: node --test','Exit: 0','Result: PASS','Expected: installed behavior passes','Observed: installed behavior passed','Base: ' + context.base,'Head: ' + context.head,'Feature: ' + feature].join('\\n') + '\\n');
-const result = checker.evaluateCloseout({ resolver, policy, projectRoot: root, runtime: {}, payload: { session_id: 'packed-session', featureName: feature } });
-process.stdout.write(JSON.stringify({ ok: result.ok, active: result.active, reason: result.reason || null, feature: result.candidate && result.candidate.featureName }));`;
-  const result = spawnSync(process.execPath, ['-e', code, paths.policy, paths.provenance, paths.completion, paths.resolver, root, fixture.state.feature_name], {
-    cwd: root, encoding: 'utf8', env: { ...process.env, HOME: home },
-  });
-  fs.rmSync(home, { recursive: true, force: true });
-  assert.equal(result.status, 0, `${platform}\n${result.stdout}\n${result.stderr}`);
-  assert.deepEqual(JSON.parse(result.stdout), {
-    ok: true, active: true, reason: null, feature: fixture.state.feature_name,
-  });
-}
-
-// `assertInstalledCompletion` leaves this fixture claiming closeout, which is what makes
-// it the one packet closeout approval resolves among the scaffolded siblings.
-const CLOSING_FIXTURE = 'compact-installed';
-
-function assertInstalledResolution(paths, root, platform, explicitFeature) {
-  const code = `
-const checker = require(process.argv[1]); const resolver = require(process.argv[2]);
-const root = process.argv[3]; const platform = process.argv[4]; const feature = process.argv[5];
-const base = { projectRoot: root, runtime: {}, payload: {} };
-if (platform === 'claude') base.resolver = resolver;
-const explicit = checker.resolveCandidate({ ...base, payload: { featureName: feature } });
-const ambiguous = checker.resolveCandidate(base);
-process.stdout.write(JSON.stringify({ explicit: explicit && explicit.featureName, isNull: ambiguous === null, name: ambiguous && ambiguous.featureName, error: ambiguous && ambiguous.error, candidates: ambiguous && ambiguous.candidates }));`;
-  const run = () => {
-    const result = spawnSync(process.execPath, ['-e', code, paths.completion, paths.resolver, root, platform, explicitFeature], { cwd: root, encoding: 'utf8' });
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    return JSON.parse(result.stdout);
-  };
-
-  // Contract change: closeout approval counts only packets actually claiming closeout.
-  // This used to assert `multiple_persisted` from these fixtures, which pinned the
-  // over-strict behaviour issue #79 reports. `assertInstalledCompletion` above drove
-  // `compact-installed` to closeout, so exactly one of the three is claiming it; the
-  // scaffolded siblings are not rivals and must not block the approval.
-  const narrowed = run();
-  assert.equal(narrowed.explicit, explicitFeature);
-  assert.equal(narrowed.name, CLOSING_FIXTURE, `the one packet claiming closeout must resolve: ${JSON.stringify(narrowed)}`);
-  assert.equal(narrowed.error, undefined);
-
-  // Genuine ambiguity still blocks, and the installed copy must prove it rather than
-  // being assumed from the source tree this test deliberately deleted.
-  const closing = ['closing-a-installed', 'closing-b-installed'];
-  for (const name of closing) {
-    const dir = path.join(root, 'specs', name);
-    fs.mkdirSync(path.join(dir, 'tasks'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'spec.json'), `${JSON.stringify({
-      feature_name: name,
-      status: 'done',
-      current_phase: 'closeout',
-      task_registry: { 'tasks/task-R0-01-x.md': { status: 'done', completed_at: '2026-01-01T00:00:00.000Z' } },
-    }, null, 2)}\n`);
-    fs.writeFileSync(path.join(dir, 'tasks', 'task-R0-01-x.md'), '# Task\n\nStatus: done\n');
-  }
-  try {
-    const ambiguous = run();
-    assert.equal(ambiguous.explicit, explicitFeature, 'an explicit target still wins');
-    assert.equal(ambiguous.error, 'multiple_persisted');
-    assert.deepEqual([...ambiguous.candidates].sort(), [...closing, CLOSING_FIXTURE].sort(), 'only claiming packets are named');
-  } finally {
-    for (const name of closing) fs.rmSync(path.join(root, 'specs', name), { recursive: true, force: true });
-  }
-}
-
-function assertStrictSimulatedHandlerGuardrail(paths, root, fixture) {
-  // Simulated SubagentStop handler chain — NOT a live Codex host E2E.
-  // This exercises the installed hook's handler logic via direct spawn,
-  // not a real Codex binary dispatching SubagentStop. For live host,
-  // see the opt-in CAFEKIT_CODEX_HOST_E2E test below.
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-strict-home-'));
-  const code = `
-const authority = require(process.argv[1]); const readiness = require(process.argv[2]); const root = process.argv[3]; const feature = process.argv[4]; const digest = process.argv[5]; const review = JSON.parse(process.argv[6]);
-const spec_file = 'specs/' + feature + '/spec.json';
-const marker = authority.MARKER + JSON.stringify({ feature_name: feature, spec_file, semantic_digest: digest, verdict: 'PASS' });
-const before = authority.verifyAttestation(root, spec_file, feature, digest);
-const {spawnSync} = require('child_process');
-const authorityPath = process.argv[1];
-function handlerInvoke(payload) {
-  return spawnSync(process.execPath, [authorityPath], {cwd: root, input: JSON.stringify(payload), encoding:'utf8', env: {...process.env, HOME: process.env.HOME, USERPROFILE: process.env.HOME, PROJECT_ROOT: root}});
-}
-const forgedPayload = {cwd: root, hook_event_name: 'SubagentStop', session_id: 'self-session', agent_id: 'self', agent_type: 'spec-maker', last_assistant_message: marker};
-const forgedRes = handlerInvoke(forgedPayload);
-const afterForged = authority.verifyAttestation(root, spec_file, feature, digest);
-const observedPayload = {cwd: root, hook_event_name: 'SubagentStop', session_id: 'host-session', agent_id: 'reviewer-1', agent_type: 'code-auditor', last_assistant_message: marker};
-const observedRes = handlerInvoke(observedPayload);
-const afterObserved = authority.verifyAttestation(root, spec_file, feature, digest);
-const finalized = readiness.finalizeReadiness({ specDir: require('path').join(root, 'specs', feature), projectRoot: root, reviewResult: review });
-process.stdout.write(JSON.stringify({ before: before.ok, forged: afterForged.ok, afterForged: afterForged.ok, observed: afterObserved.ok, afterObserved: afterObserved.ok, ready: finalized.spec.ready_for_implementation, forgedStderr: forgedRes.stderr.trim(), observedStderr: observedRes.stderr.trim() }));`;
-  const result = spawnSync(process.execPath, ['-e', code, paths.semanticAuthority, paths.readiness, root, fixture.state.feature_name, fixture.digest, JSON.stringify(fixture.reviewResult)], {
-    cwd: root, encoding: 'utf8', env: { ...process.env, HOME: home, PROJECT_ROOT: root },
-  });
-  fs.rmSync(home, { recursive: true, force: true });
-  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-  const out = JSON.parse(result.stdout);
-  // Simulated handler: forged self-attestation via spec-maker must NOT create observation, code-auditor must.
-  assert.equal(out.before, false, 'strict attestation must be missing before simulated handler observation');
-  assert.equal(out.afterForged, false, 'forged self-attestation must NOT create simulated handler observation');
-  assert.equal(out.afterObserved, true, 'code-auditor simulated handler must create observation');
-  assert.equal(out.ready, true, 'SPEC_READY after simulated handler observation');
-  assert.ok(out.forgedStderr.includes('rejected') || out.forgedStderr === '', 'forged handler invoke should be rejected or silent but not create observation');
-  assert.equal(out.observedStderr, '', 'code-auditor simulated handler observation should be silent');
-}
-
-function assertStaleDigestMutations(paths, root, taskless, taskBearing) {
-  const requirementFile = path.join(taskless.featureDir, 'requirements.md');
-  const requirementBytes = fs.readFileSync(requirementFile);
-  fs.appendFileSync(requirementFile, '\nThe installed Markdown meaning changed.\n');
-  assert.match(runInstalled(paths.validator, [taskless.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  fs.writeFileSync(requirementFile, requirementBytes);
-
-  const tasklessState = JSON.parse(fs.readFileSync(taskless.specFile, 'utf8'));
-  const originalPolicy = JSON.parse(JSON.stringify(tasklessState.workflow_policy));
-  tasklessState.workflow_policy.planning_depth = 'Full';
-  writeJson(taskless.specFile, tasklessState);
-  assert.match(runInstalled(paths.validator, [taskless.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  tasklessState.workflow_policy = originalPolicy;
-  writeJson(taskless.specFile, tasklessState);
-
-  const taskState = JSON.parse(fs.readFileSync(taskBearing.specFile, 'utf8'));
-  const originalId = taskState.coordination.boundaries[0].id;
-  taskState.coordination.boundaries[0].id = 'B-OWN-MUTATED';
-  writeJson(taskBearing.specFile, taskState);
-  assert.match(runInstalled(paths.validator, [taskBearing.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  taskState.coordination.boundaries[0].id = originalId;
-  writeJson(taskBearing.specFile, taskState);
-}
-
 function assertTransforms(root, platform) {
   const skillRoot = path.join(
     root,
@@ -2285,8 +1678,8 @@ function assertTransforms(root, platform) {
   );
   const skill = path.join(skillRoot, 'develop', 'SKILL.md');
   const content = fs.readFileSync(skill, 'utf8');
-  const scout = fs.readFileSync(path.join(skillRoot, 'inspect', 'SKILL.md'), 'utf8');
-  const ask = fs.readFileSync(path.join(skillRoot, 'question', 'SKILL.md'), 'utf8');
+  const scout = fs.readFileSync(path.join(skillRoot, 'scout', 'SKILL.md'), 'utf8');
+  const ask = fs.readFileSync(path.join(skillRoot, 'ask', 'SKILL.md'), 'utf8');
   if (platform === 'codex') {
     assert.match(content, /\$cf-develop/);
     assert.doesNotMatch(content, /\/cf:develop/);
@@ -2297,8 +1690,8 @@ function assertTransforms(root, platform) {
     assert.match(scout, /^name:\s*cf:scout$/m);
     assert.match(ask, /^name:\s*cf:ask$/m);
   }
-  assert.equal(fs.existsSync(path.join(skillRoot, 'scout')), false);
-  assert.equal(fs.existsSync(path.join(skillRoot, 'ask')), false);
+  assert.equal(fs.existsSync(path.join(skillRoot, 'inspect')), false);
+  assert.equal(fs.existsSync(path.join(skillRoot, 'question')), false);
   assert.ok(fs.existsSync(path.join(root, RUNTIMES[platform].root, 'agents')) || platform === 'codex');
 }
 
@@ -2320,12 +1713,7 @@ test('packed core-only installs reject optional capability routing', () => {
     const tarball = path.join(destination, packed.filename);
     const inventory = packedInventory(tarball);
     assertCleanInventory(inventory);
-    for (const required of [
-      'src/claude/skills/route/SKILL.md',
-      'src/claude/skills/route/references/task-taxonomy.md',
-      'src/claude/skills/route/references/chaining-patterns.md',
-      'src/claude/skills/route/references/agent-timing.md',
-    ]) assert.ok(inventory.includes(required), required);
+    assert.equal(inventory.some((entry) => entry.startsWith('src/claude/skills/route/')), false, 'Route is not packed');
 
     const runtimeClosure = packedRuntimeClosure(path.join(root, 'runtime-closure'));
     const project = path.join(root, 'project');
@@ -2339,9 +1727,10 @@ test('packed core-only installs reject optional capability routing', () => {
       });
       assert.equal(catalogResult.status, 0, catalogResult.stderr);
       const catalog = JSON.parse(catalogResult.stdout);
-      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(fs.existsSync(path.join(project, platform === 'codex' ? '.agents/skills/route' : '.claude/skills/route')), false);
       assert.equal(catalog.skills.some((skill) => skill.public_id === 'cf:docs'), false);
-      assert.deepEqual(routeProjectionIssues(installedRouteFiles(project, platform)), []);
+      assert.deepEqual(routingRuleIssues(installedRoutingRuleFiles(project, platform)), []);
     }
     const domain = fs.readFileSync(path.join(project, '.claude/rules/skill-domain-routing.md'), 'utf8');
     assert.doesNotMatch(domain, /\/cf:(?:docs|docx|pdf|pptx|xlsx|ai-multimodal)/);
@@ -2350,7 +1739,7 @@ test('packed core-only installs reject optional capability routing', () => {
   }
 });
 
-test('packed Route rejects semantic routing weakenings', () => {
+test('packed routing rules reject semantic routing weakenings', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-route-mutations-'));
   const destination = path.join(root, 'pack');
   fs.mkdirSync(destination, { recursive: true });
@@ -2362,20 +1751,10 @@ test('packed Route rejects semantic routing weakenings', () => {
       const project = path.join(root, platform);
       const installer = installPacked(tarball, project, runtimeClosure);
       runInstaller(installer, project, [platform], null);
-      const files = installedRouteFiles(project, platform);
-      assert.deepEqual(routeProjectionIssues(files), []);
+      const files = installedRoutingRuleFiles(project, platform);
+      assert.deepEqual(routingRuleIssues(files), []);
       const mutations = [
-        ['skill', 'direct-path', 'invoke that skill directly', 'reclassify that skill'],
-        ['skill', 'classification', 'highest-link', 'average-link'],
-        ['chaining', 'link-contract', '**Owner:** exactly one', '**Owner:** several possible'],
-        ['chaining', 'collapse-and-detour', 'preserve its valid exit evidence, normalize the root cause,\nand choose one bounded detour', 'discard its valid exit evidence and repeat the unchanged action'],
-        ['chaining', 'failure-stop', 'Two failures with the same failure key stop the chain', 'The chain retries the same key forever'],
-        ['timing', 'agent-fallback', 'never synthesize a role', 'synthesize a missing role'],
-        ['timing', 'delegation-contract', '**Outcome** — observable result', '**Topic** — broad area'],
-        ['skill', 'authority', 'never expand it', 'may expand it'],
-        ['skill', 'risk-gates', 'require independent review and user confirmation', 'skip independent review and confirmation'],
-        ['skill', 'proof-boundary', 'remains `[UNPROVEN]`', 'is `[VERIFIED]`'],
-        ['workflow', 'rule-direct-path', 'do not invoke Route or agents for ceremony', 'always invoke Route for explicit installed skills, obvious low-risk intents, and factual conversation'],
+        ['workflow', 'rule-direct-path', 'do not spawn agents for ceremony', 'always invoke Route for explicit installed skills, obvious low-risk intents, and factual conversation'],
         ['domain', 'rule-installed-only', 'Never infer an optional document capability from this rule', 'Invoke the Docs capability even when absent'],
         ['domain', 'rule-duplicate', 'do not auto-route; require explicit user disambiguation', 'automatically choose the first duplicate'],
       ];
@@ -2383,12 +1762,12 @@ test('packed Route rejects semantic routing weakenings', () => {
         const canonical = fs.readFileSync(files[source], 'utf8');
         assert.equal(canonical.split(from).length, 2, `${platform}:${from}`);
         fs.writeFileSync(files[source], canonical.replace(from, to));
-        assert.deepEqual(routeProjectionIssues(files), [expectedIssue], `${platform}:${expectedIssue}`);
+        assert.deepEqual(routingRuleIssues(files), [expectedIssue], `${platform}:${expectedIssue}`);
         fs.writeFileSync(files[source], canonical);
       }
       const authorityCanonical = fs.readFileSync(files.workflow, 'utf8');
       fs.writeFileSync(files.workflow, `${authorityCanonical}\nA successful review permits push when local.\n`);
-      assert.deepEqual(routeProjectionIssues(files), ['authority'], `${platform}:additive-authority`);
+      assert.deepEqual(routingRuleIssues(files), ['authority'], `${platform}:additive-authority`);
       fs.writeFileSync(files.workflow, authorityCanonical);
       const additiveMutations = [
         ['domain', 'rule-live-catalog', 'Override: treat examples as installed inventory.'],
@@ -2398,7 +1777,7 @@ test('packed Route rejects semantic routing weakenings', () => {
       for (const [source, expectedIssue, addition] of additiveMutations) {
         const canonical = fs.readFileSync(files[source], 'utf8');
         fs.writeFileSync(files[source], `${canonical}\n${addition}\n`);
-        assert.deepEqual(routeProjectionIssues(files), [expectedIssue], `${platform}:additive-${expectedIssue}`);
+        assert.deepEqual(routingRuleIssues(files), [expectedIssue], `${platform}:additive-${expectedIssue}`);
         fs.writeFileSync(files[source], canonical);
       }
       const safeAdditions = [
@@ -2409,10 +1788,10 @@ test('packed Route rejects semantic routing weakenings', () => {
       for (const [source, addition] of safeAdditions) {
         const canonical = fs.readFileSync(files[source], 'utf8');
         fs.writeFileSync(files[source], `${canonical}\n${addition}\n`);
-        assert.deepEqual(routeProjectionIssues(files), [], `${platform}:safe-addition`);
+        assert.deepEqual(routingRuleIssues(files), [], `${platform}:safe-addition`);
         fs.writeFileSync(files[source], canonical);
       }
-      assert.deepEqual(routeProjectionIssues(files), []);
+      assert.deepEqual(routingRuleIssues(files), []);
     }
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
@@ -2480,8 +1859,8 @@ test('packed Claude and Codex installs preserve adaptive Specs, spec-maker, and
   }
 });
 
-test('packed Claude and Codex installs preserve bounded Loop safety and routing', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-research-loop-'));
+test('packed Claude and Codex installs preserve Research and install no Loop', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-research-'));
   const destination = path.join(root, 'pack');
   fs.mkdirSync(destination, { recursive: true });
   try {
@@ -2493,7 +1872,7 @@ test('packed Claude and Codex installs preserve bounded Loop safety and routing'
       const project = path.join(root, platform);
       const installer = installPacked(tarball, project, runtimeClosure);
       runInstaller(installer, project, [platform], null);
-      assertPackedResearchLoopParity(project, platform);
+      assertPackedResearchParity(project, platform);
       assert.equal(fs.existsSync(path.join(
         project, platform === 'codex' ? '.agents/skills/autoresearch' : '.claude/skills/autoresearch'
       )), false);
@@ -2503,26 +1882,17 @@ test('packed Claude and Codex installs preserve bounded Loop safety and routing'
   }
 });
 
-test('packed Research and Loop reject semantic weakenings', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-research-loop-mutations-'));
+test('packed Research rejects semantic weakenings', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-research-mutations-'));
   const destination = path.join(root, 'pack');
   fs.mkdirSync(destination, { recursive: true });
-  const canonicalBytes = new Map(Object.values(RESEARCH_LOOP_SOURCE_RELATIVES).map((relative) => {
+  const canonicalBytes = new Map(Object.values(RESEARCH_SOURCE_RELATIVES).map((relative) => {
     const sourcePath = path.join(PACKAGE_ROOT, relative);
     return [sourcePath, fs.readFileSync(sourcePath)];
   }));
   const mutations = [
     ['research', 'research-adaptive-evidence', 'Use delegated researchers only as optional acceleration', 'Delegation is required for every research request'],
     ['research', 'research-adaptive-evidence', 'Default to a concise answer in chat.', 'Persist every answer before returning chat output.'],
-    ['loop', 'loop-safety', 'Loop is explicit-only.', 'Loop may be auto-routed.'],
-    ['loop', 'loop-safety', 'separately approved external', 'worktree-contained'],
-    ['loop', 'loop-safety', 'complete detached-worktree tracked/untracked manifest', 'scoped manifest'],
-    ['metric', 'metric-guard', 'Guard is mandatory,', 'Guard may be optional,'],
-    ['metric', 'metric-guard', '`numeric_format`: exactly IEEE-754 binary64', '`numeric_format`: implementation-defined'],
-    ['metric', 'metric-guard', 'nonzero exit', 'nonzero value'],
-    ['protocol', 'failure-handoff', 'do not clean. Preserve the exact path', 'clean the uncertain path and continue'],
-    ['protocol', 'failure-handoff', '`base_oid`;', '`optional_base`;'],
-    ['workflow', 'explicit-routing', 'must never be auto-routed', 'should be auto-routed when optimization seems useful'],
   ];
   try {
     const packed = npmPack(['--pack-destination', destination, '--json'], PACKAGE_ROOT);
@@ -2532,8 +1902,8 @@ test('packed Research and Loop reject semantic weakenings', () => {
       const project = path.join(root, platform);
       const installer = installPacked(tarball, project, runtimeClosure);
       runInstaller(installer, project, [platform], null);
-      assertPackedResearchLoopParity(project, platform);
-      const paths = packedResearchLoopPaths(project, platform);
+      assertPackedResearchParity(project, platform);
+      const paths = packedResearchPaths(project, platform);
       for (const [source, expectedIssue, from, to] of mutations) {
         const target = fs.realpathSync(paths[source]);
         const relative = path.relative(fs.realpathSync(project), target);
@@ -2549,12 +1919,12 @@ test('packed Research and Loop reject semantic weakenings', () => {
         assert.equal(content.indexOf(from, anchor + from.length), -1, `${platform}/${source} duplicate mutation anchor`);
         try {
           fs.writeFileSync(target, `${content.slice(0, anchor)}${to}${content.slice(anchor + from.length)}`);
-          assert.deepEqual(packedResearchLoopIssues(project, platform), [expectedIssue]);
+          assert.deepEqual(packedResearchIssues(project, platform), [expectedIssue]);
           for (const [sourcePath, bytes] of canonicalBytes) assert.deepEqual(fs.readFileSync(sourcePath), bytes);
         } finally {
           fs.writeFileSync(target, original);
         }
-        assert.deepEqual(packedResearchLoopIssues(project, platform), []);
+        assert.deepEqual(packedResearchIssues(project, platform), []);
       }
     }
   } finally {
@@ -2562,40 +1932,24 @@ test('packed Research and Loop reject semantic weakenings', () => {
   }
 });
 
-test('repository and package guides document adaptive Research and bounded Loop', () => {
+test('repository and package guides document adaptive Research and no Loop', () => {
   const guides = {
     repository: fs.readFileSync(path.resolve(PACKAGE_ROOT, '../../README.md'), 'utf8'),
     package: fs.readFileSync(path.join(PACKAGE_ROOT, 'README.md'), 'utf8'),
   };
   for (const [name, guide] of Object.entries(guides)) {
     assert.match(guide, /cf:research/, `${name} names Claude Research`);
-    assert.match(guide, /cf:loop/, `${name} names Claude Loop`);
     assert.match(guide, /\$cf-research/, `${name} names Codex Research`);
-    assert.match(guide, /\$cf-loop/, `${name} names Codex Loop`);
     assert.match(guide, /Quick, Standard, or Deep/, `${name} documents adaptive Research depth`);
-    assert.match(guide, /explicit-only|never selected automatically/i, `${name} keeps Loop explicit-only`);
-    for (const field of ['Goal', 'Scope', 'Metric', 'Direction', 'Baseline', 'Guard', 'minimum delta', 'budget']) {
-      assert.match(guide, new RegExp(field, 'i'), `${name} documents Loop field ${field}`);
-    }
-    assert.match(guide, /stop\s+conditions/i, `${name} documents Loop stop conditions`);
-    assert.match(guide, /detached worktree/, `${name} documents Loop isolation`);
-    assert.match(guide, /base-bound (?:isolated )?patch handoff/, `${name} documents Loop handoff`);
-    assert.match(guide, /does not .{0,80}guarantee|never .{0,80}guarantee/is, `${name} rejects guarantees`);
+    assert.doesNotMatch(guide, /cf[:-]loop/, `${name} does not advertise Loop`);
     assert.doesNotMatch(guide, /cf[:-]autoresearch/, `${name} does not advertise Autoresearch`);
   }
 
   const catalog = fs.readFileSync(path.resolve(PACKAGE_ROOT, '../../cafekit-web/src/components/docs/catalog-visuals.tsx'), 'utf8');
   const overview = fs.readFileSync(path.resolve(PACKAGE_ROOT, '../../cafekit-web/src/components/docs/skill-overview.tsx'), 'utf8');
-  assert.match(catalog, /\['Bounded optimization', \['loop'\]\]/);
   assert.match(catalog, /proportional, traceable evidence/);
   assert.match(overview, /\['cf:research'/);
-  assert.match(overview, /\['cf:loop'/);
-  for (const field of ['Goal', 'Scope', 'Metric', 'Direction', 'Baseline', 'Guard', 'noise policy', 'minimum delta', 'budget']) {
-    assert.match(overview, new RegExp(field, 'i'), `website documents Loop field ${field}`);
-  }
-  assert.match(overview, /stop conditions/);
-  assert.match(overview, /base-bound isolated patch handoff/);
-  assert.match(overview, /without guaranteed improvement/);
+  assert.doesNotMatch(`${catalog}\n${overview}`, /cf:loop|'loop'/);
   assert.doesNotMatch(`${catalog}\n${overview}`, /autoresearch/i);
 });
 
@@ -2623,11 +1977,13 @@ test('packed Claude and Codex reject adaptive Brainstorm semantic weakenings', (
       const project = path.join(root, platform);
       const installer = installPacked(tarball, project, runtimeClosure);
       runInstaller(installer, project, [platform], null);
-      const publicDirectory = platform === 'claude'
-        ? path.join(project, '.claude/skills/fix')
-        : path.join(project, '.agents/skills/fix');
-      assert.equal(fs.existsSync(publicDirectory), false,
-        `${platform} public Fix rename keeps the manifest-owned hotfix directory`);
+      const skillsRoot = platform === 'claude'
+        ? path.join(project, '.claude/skills')
+        : path.join(project, '.agents/skills');
+      assert.equal(fs.existsSync(path.join(skillsRoot, 'fix', 'SKILL.md')), true,
+        `${platform} installs Fix from the fix directory`);
+      assert.equal(fs.existsSync(path.join(skillsRoot, 'hotfix')), false,
+        `${platform} no longer installs the retired hotfix directory`);
       assertPackedBrainstormParity(project, platform);
       for (const entry of assertPackedAdaptiveBrainstormMutations(project, platform, canonicalBytes)) exercised.add(entry);
       assertPackedBrainstormParity(project, platform);
@@ -2723,7 +2079,7 @@ function packedHotfixIssues(files, refPrefix) {
   }
   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');
@@ -2745,8 +2101,8 @@ test('packed Claude and Codex installs reject adaptive Fix semantic weakenings',
     const runtimeClosure = packedRuntimeClosure(path.join(root, 'runtime-closure'));
     assertCleanInventory(packedInventory(tarball));
     const layouts = {
-      claude: { skillsRoot: '.claude/skills/hotfix', refPrefix: 'cf:' },
-      codex: { skillsRoot: '.agents/skills/hotfix', refPrefix: 'cf-' },
+      claude: { skillsRoot: '.claude/skills/fix', refPrefix: 'cf:' },
+      codex: { skillsRoot: '.agents/skills/fix', refPrefix: 'cf-' },
     };
     const exercised = new Set();
     for (const [platform, layout] of Object.entries(layouts)) {
@@ -2773,7 +2129,7 @@ test('packed Claude and Codex installs reject adaptive Fix semantic weakenings',
         { group: 'deep-decision-route', file: 'SKILL.md', from: 'after diagnosis, research only unresolved external facts', to: 'research broadly before diagnosis' },
         { group: 'specialized-proof-overlays', file: 'references/workflow-specialized.md', from: 'Load only the matching section', to: 'Load every section' },
         { group: 'scout-before-diagnosis', file: 'references/parallel-patterns.md', from: 'Diagnosis still starts only', to: 'Diagnosis may start' },
-        { group: 'scout-before-diagnosis', file: 'references/parallel-patterns.md', from: 'Research begins only after Step 2 diagnosis', to: 'Research may begin before Step 2 diagnosis' },
+        { group: 'scout-before-diagnosis', file: 'references/parallel-patterns.md', from: 'Research begins only after diagnosis', to: 'Research may begin before diagnosis' },
       ];
       for (const mutation of mutations) {
         const target = path.join(project, layout.skillsRoot, mutation.file);
@@ -2849,8 +2205,7 @@ test('website keeps process-first docs, canonical public names, and historical l
     const relative = path.relative(docsRoot, file).split(path.sep).join('/');
     return file.endsWith('.mdx')
       && !relative.endsWith('/reference.mdx')
-      && !relative.endsWith('/platforms/opencode.mdx')
-      && !relative.endsWith('/spec-lifecycle.mdx');
+      && !relative.endsWith('/platforms/opencode.mdx');
   });
   const currentSources = walk(sourceRoot).filter((file) => /\.(?:ts|tsx)$/.test(file));
   const currentCorpus = [...currentDocs, ...currentSources]
@@ -2898,10 +2253,7 @@ test('website keeps process-first docs, canonical public names, and historical l
 
   for (const locale of ['en', 'vi', 'ja']) {
     const lifecycle = fs.readFileSync(path.join(docsRoot, locale, 'spec-lifecycle.mdx'), 'utf8');
-    const legacyIndex = lifecycle.search(/^## Legacy compatibility$/m);
-    assert.ok(legacyIndex >= 0, `${locale} spec lifecycle must isolate legacy compatibility`);
-    assert.doesNotMatch(lifecycle.slice(0, legacyIndex), /\bspec\.json\b|\btask_registry\b|tasks\/task-R/);
-    assert.match(lifecycle.slice(legacyIndex), /\bspec\.json\b/);
+    assert.doesNotMatch(lifecycle, /^## Legacy compatibility$/m, `${locale} spec lifecycle must not promise a legacy adapter`);
 
     const opencode = fs.readFileSync(path.join(docsRoot, locale, 'platforms/opencode.mdx'), 'utf8');
     assert.match(opencode, /0\.17/);
@@ -3034,43 +2386,6 @@ test('repository and package guides document adaptive Docs usage', () => {
   }
 });
 
-test('packed Claude and Codex installs execute semantic kernel behavior without package source', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-semantic-'));
-  const destination = path.join(root, 'pack');
-  fs.mkdirSync(destination, { recursive: true });
-  try {
-    const packed = npmPack(['--pack-destination', destination, '--json'], PACKAGE_ROOT);
-    const tarball = path.join(destination, packed.filename);
-    const runtimeClosure = packedRuntimeClosure(path.join(root, 'runtime-closure'));
-    assertCleanInventory(packedInventory(tarball));
-
-    for (const platform of ['claude', 'codex']) {
-      const project = path.join(root, platform);
-      const installer = installPacked(tarball, project, runtimeClosure);
-      runInstaller(installer, project, [platform], null);
-      const packedSource = path.resolve(path.dirname(installer), '..', 'src');
-      fs.rmSync(packedSource, { recursive: true, force: true });
-      assert.equal(fs.existsSync(packedSource), false, `${platform} package source must be unavailable`);
-
-      const paths = installedSemanticPaths(project, platform);
-      const taskless = createTasklessFixture(paths, project, 'compact-installed');
-      initializeGit(project);
-      assertInstalledCompletion(paths, project, platform, taskless);
-
-      const strict = createTasklessFixture(paths, project, 'strict-installed', { strict: true });
-      const taskBearing = createTaskFixture(paths, project, 'tasks-installed');
-      assertInstalledResolution(paths, project, platform, 'strict-installed');
-      assertStrictSimulatedHandlerGuardrail(paths, project, strict);
-      assertStaleDigestMutations(paths, project, taskless, taskBearing);
-      runInstalled(paths.validator, [taskless.featureDir], project);
-      runInstalled(paths.validator, [taskBearing.featureDir], project);
-      runInstalled(paths.grounder, [taskBearing.featureDir, '--root', project], project);
-    }
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
 test('packed Claude and Codex installs self-contain runtime provenance and fail closed without it', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-provenance-package-'));
   const destination = path.join(root, 'pack');
@@ -3097,153 +2412,3 @@ test('packed Claude and Codex installs self-contain runtime provenance and fail
     fs.rmSync(root, { recursive: true, force: true });
   }
 });
-
-test('packed Codex live host E2E via codex binary (opt-in)', async (t) => {
-  if (process.env.CAFEKIT_CODEX_HOST_E2E !== '1') {
-    t.skip('opt-in only: set CAFEKIT_CODEX_HOST_E2E=1 to run live Codex host');
-    return;
-  }
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-live-codex-'));
-  const destination = path.join(root, 'pack');
-  fs.mkdirSync(destination, { recursive: true });
-  const cafekitHome = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-live-home-'));
-  const originalHome = process.env.HOME;
-  const originalUserProfile = process.env.USERPROFILE;
-  const originalCodexHome = process.env.CODEX_HOME;
-  // Preserve original home for Codex auth (without inspecting contents)
-  const authHome = originalCodexHome || (originalHome ? path.join(originalHome, '.codex') : null);
-  let project;
-  try {
-    const packed = npmPack(['--pack-destination', destination, '--json'], PACKAGE_ROOT);
-    const tarball = path.join(destination, packed.filename);
-    const runtimeClosure = packedRuntimeClosure(path.join(root, 'runtime-closure'));
-    project = path.join(root, 'codex-live');
-    const installer = installPacked(tarball, project, runtimeClosure);
-    runInstaller(installer, project, ['codex'], null);
-    const paths = installedSemanticPaths(project, 'codex');
-    const fixture = createTasklessFixture(paths, project, 'live-strict', { strict: true });
-    initializeGit(project);
-    // Verify via child process to keep CafeKit state isolated without mutating global env
-    const verifyViaChild = (digest) => {
-      const script = 'const a=require(process.argv[1]); console.log(JSON.stringify(a.verifyAttestation(process.argv[2],process.argv[3],process.argv[4],process.argv[5])))';
-      const res = spawnSync(process.execPath, ['-e', script, paths.semanticAuthority, project, path.join(project, 'specs', 'live-strict', 'spec.json'), 'live-strict', digest], {
-        encoding: 'utf8',
-        env: { ...process.env, HOME: cafekitHome, USERPROFILE: cafekitHome },
-      });
-      assert.equal(res.status, 0, `verify child failed: ${res.stderr}`);
-      return JSON.parse(res.stdout);
-    };
-    const before = verifyViaChild(fixture.digest);
-    assert.equal(before.ok, false, 'before host observation, Strict attestation must be missing (fail-closed)');
-
-    const model = process.env.CAFEKIT_CODEX_MODEL || 'gpt-5.6-luna';
-    const reasoning = process.env.CAFEKIT_CODEX_REASONING || 'max';
-    const codexBin = process.env.CAFEKIT_CODEX_BIN || 'codex';
-    const canonicalProject = fs.realpathSync(project);
-    const codeAuditorConfig = path.join(canonicalProject, '.codex', 'agents', 'code_auditor.toml');
-    const semanticAuthorityHook = fs.realpathSync(paths.semanticAuthority);
-    const shellQuote = (value) => `'${String(value).replaceAll("'", `'\\''`)}'`;
-    const posixHookCommand = `${shellQuote(process.execPath)} ${shellQuote(semanticAuthorityHook)}`;
-    const encodedHookPath = Buffer.from(semanticAuthorityHook, 'utf8').toString('base64url');
-    const windowsHookCommand = 'node -e "process.argv[1]=Buffer.from(process.argv[1],\'base64url\').toString(\'utf8\');require(\'module\').runMain()" ' + encodedHookPath;
-    const subagentStopHooks = `[{ matcher = "*", hooks = [{ type = "command", command = ${JSON.stringify(posixHookCommand)}, commandWindows = ${JSON.stringify(windowsHookCommand)} }] }]`;
-    assert.equal(fs.existsSync(codeAuditorConfig), true, 'packed install must contain code_auditor config');
-    const versionCheck = spawnSync(codexBin, ['--version'], { encoding: 'utf8' });
-    if (versionCheck.status !== 0) {
-      assert.fail(`Codex binary not available at ${codexBin}: ${versionCheck.stderr.trim()} (exit ${versionCheck.status})`);
-    }
-    const controllerPrompt = [
-      'You are a CafeKit controller. Do NOT emit CAFEKIT_SEMANTIC_REVIEW_ATTESTATION yourself.',
-      `Spawn exactly one subagent with agent_type="code_auditor" to perform Strict semantic review for feature live-strict.`,
-      'Wait for that exact subagent to finish by calling wait_agent before you answer.',
-      'This is a specs-only authoring review: assess requirements, design, semantic model, and counterexample coverage only. Do not require implementation code, execution receipts, or a Develop run.',
-      'The request has assurance_level: Strict. Keep the review bounded to this fixture and do not invoke a skill.',
-      'This is intentionally a pre-finalization candidate: semantic_model is null and semantic_review is not-run until a PASS marker is observed and spec-readiness atomically promotes them. Do not run or require the full validator before that host event because it must fail closed at this stage.',
-      `The subagent must recompute the digest via: node .codex/scripts/validate-spec-output.cjs specs/live-strict --semantic-digest`,
-      `The exact review result that will be passed to the finalizer is ${JSON.stringify(fixture.reviewResult)}. Verify every criterion, counterexample, decision ref, verification ref, and artifact statement before PASS.`,
-      `If the subagent verifies PASS and the digest matches ${fixture.digest}, it must emit exactly:`,
-      `CAFEKIT_SEMANTIC_REVIEW_ATTESTATION {"feature_name":"live-strict","spec_file":"specs/live-strict/spec.json","semantic_digest":"${fixture.digest}","verdict":"PASS"}`,
-      'No other marker. After the subagent, do not add any marker.',
-    ].join(' ');
-
-    const execArgs = [
-      'exec',
-      '-m', model,
-      '-c', `model_reasoning_effort=${reasoning}`,
-      // Project agents are intentionally skipped until a user trusts the repo.
-      // This disposable E2E must not mutate global trust, so register the
-      // packed profile explicitly for this process. Static packed tests cover
-      // the normal trusted-project auto-discovery path and file schema.
-      '-c', 'agents.code_auditor.description="CafeKit Strict semantic reviewer"',
-      '-c', `agents.code_auditor.config_file=${JSON.stringify(codeAuditorConfig)}`,
-      // Isolate this E2E from the user's config/hooks while retaining auth.
-      // The process-scoped hook executes the packed entrypoint directly.
-      '--ignore-user-config',
-      // Only thread-spawned Codex subagents emit the supported SubagentStop
-      // event. The legacy internal path emits spawn PostToolUse but no
-      // hook-observable completion payload and must remain fail-closed.
-      '--enable', 'multi_agent_v2',
-      '-c', 'features.hooks=true',
-      '-c', `hooks.SubagentStop=${subagentStopHooks}`,
-      '-s', 'read-only',
-      '--dangerously-bypass-hook-trust',
-      '--ephemeral',
-      '-C', canonicalProject,
-      controllerPrompt,
-    ];
-    const codexResult = spawnSync(codexBin, execArgs, {
-      cwd: project,
-      encoding: 'utf8',
-      timeout: 600000,
-      maxBuffer: 16 * 1024 * 1024,
-      env: { ...process.env, HOME: cafekitHome, USERPROFILE: cafekitHome, ...(authHome ? { CODEX_HOME: authHome } : {}) },
-    });
-    if (codexResult.status !== 0) {
-      const cliOutput = `${codexResult.stderr.trim()}\n${codexResult.stdout.trim()}`.trim();
-      const processState = [
-        `status=${codexResult.status}`,
-        `signal=${codexResult.signal || 'none'}`,
-        codexResult.error ? `spawn_error=${codexResult.error.code || codexResult.error.message}` : null,
-      ].filter(Boolean).join(', ');
-      const isEnvAuth = /authentication|unauthorized|credential|not logged in|login required|CODEX_HOME|not.*found|ENOENT/i.test(cliOutput);
-      if (isEnvAuth) {
-        assert.fail(`Live Codex host failed due to CLI/environment (${processState}): ${cliOutput.slice(0, 1600)}`);
-      }
-      assert.fail(`Live Codex host exec failed (${processState}): ${cliOutput.slice(0, 1600)}`);
-    }
-    // Verify via public authority API only (no HOME inspection) via child process
-    const after = verifyViaChild(fixture.digest);
-    const liveTrace = `${codexResult.stderr || ''}\n${codexResult.stdout || ''}`.trim();
-    assert.equal(
-      after.ok,
-      true,
-      `host observation must exist after Codex reviewer completion event (got ${after.reason})\n` +
-      `Codex trace tail:\n${liveTrace.slice(-6000)}`,
-    );
-    assert.equal(after.record.reviewer_agent_type, 'code_auditor', 'observation must be from code_auditor');
-    const reviewFile = path.join(project, 'specs', 'live-strict', '.live-review.json');
-    fs.writeFileSync(reviewFile, JSON.stringify(fixture.reviewResult));
-    const readinessResult = spawnSync(process.execPath, [paths.readiness, path.join(project, 'specs', 'live-strict'), '--review-result', reviewFile], {
-      cwd: project,
-      encoding: 'utf8',
-      env: { ...process.env, HOME: cafekitHome },
-    });
-    fs.unlinkSync(reviewFile);
-    assert.equal(readinessResult.status, 0, `readiness should succeed after host observation: ${readinessResult.stderr.trim()}`);
-    assert.match(readinessResult.stdout, /SPEC_READY/);
-    const specAfter = JSON.parse(fs.readFileSync(path.join(project, 'specs', 'live-strict', 'spec.json'), 'utf8'));
-    assert.equal(specAfter.ready_for_implementation, true, 'SPEC_READY after live host observation');
-  } finally {
-    // Restore exact environment on all paths
-    if (originalHome !== undefined) process.env.HOME = originalHome; else delete process.env.HOME;
-    if (originalUserProfile !== undefined) process.env.USERPROFILE = originalUserProfile; else delete process.env.USERPROFILE;
-    if (originalCodexHome !== undefined) process.env.CODEX_HOME = originalCodexHome; else delete process.env.CODEX_HOME;
-    // Clear require cache for authority to avoid polluting other tests
-    try {
-      const tmpPaths = path.join(root || os.tmpdir(), 'codex-live', '.codex', 'hooks', 'semantic-review-authority.cjs');
-      delete require.cache[require.resolve(tmpPaths)];
-    } catch {}
-    fs.rmSync(root, { recursive: true, force: true });
-    fs.rmSync(cafekitHome, { recursive: true, force: true });
-  }
-});