@haposoft/cafekit 0.16.7 → 0.18.1

package/bin/__tests__/runtime-dir.test.js

@@ -143,9 +143,6 @@ test('advice names the directory the hook lives in', () => {
       const rt = installTreeAs(project, folder);
       fs.mkdirSync(path.join(project, 'specs', 'demo'), { recursive: true });
       fs.writeFileSync(path.join(rt, 'runtime.json'), '{}');
-      // task-scaffold-guard: a raw Write into a nested task path is refused with scaffold advice
-      const guard = runHook(rt, 'task-scaffold-guard.cjs', { tool_name: 'Write', tool_input: { file_path: path.join(project, 'specs', 'demo', 'tasks', 'task-R0-01-x.md'), content: '# x' }, cwd: project });
-      assert.match(guard.out, new RegExp(`node ${folder.replace('.', '\\.')}/scripts/spec-scaffold\\.cjs`), `scaffold advice must name ${folder}`);
       // inspect-block: header hint names the runtime file (static check on the installed copy)
       const src = fs.readFileSync(path.join(rt, 'hooks', 'inspect-block.cjs'), 'utf8');
       assert.match(src, /<runtime>\/runtime\.json/, 'the disable hint no longer hardcodes a platform');

package/bin/__tests__/runtime-schema.test.js

@@ -86,8 +86,9 @@ test('every documented property carries a description a reader can act on', () =
 test('keys the runtime does not honour are marked deprecated, not documented as working', () => {
   // develop.parallel and the hooks toggle map are still shipped for compatibility, but
   // nothing reads them. The schema must say so rather than imply they work.
-  for (const dead of ['hooks', 'develop']) {
-    const node = SCHEMA.properties[dead];
+  for (const dead of ['hooks', 'develop', 'usage', 'spec.scaffold_guard']) {
+    // A dotted path walks nested `properties`: `spec.scaffold_guard` is spec.properties.scaffold_guard.
+    const node = dead.split('.').reduce((schema, key) => schema && schema.properties && schema.properties[key], SCHEMA);
     assert.ok(node, `${dead} is shipped in runtime.json and must appear in the schema`);
     assert.equal(node.deprecated, true, `${dead} is not honoured and must be marked deprecated`);
     assert.match(node.description, /[Nn]ot honoured/, `${dead} must say plainly that it does nothing`);

package/bin/__tests__/skill-routing-source.test.js

@@ -58,7 +58,7 @@ test('skill routing consumes live catalog without fixed optional commands', () =
     installScanner(SCANNER, claudeScript);
     installScanner(SCANNER, codexScript, (content) => normalizeCodexBody(content, SCANNER));
 
-    writeSkill(path.join(root, '.claude/skills'), 'question', {
+    writeSkill(path.join(root, '.claude/skills'), 'ask', {
       name: 'cf:ask', description: 'Answer with evidence.', when: 'Use for factual questions.',
       category: 'utilities', keywords: ['answer', 'evidence'],
     });
@@ -66,7 +66,7 @@ test('skill routing consumes live catalog without fixed optional commands', () =
       name: 'cf:docs', description: 'Work with docs.', when: 'Use for documentation.',
       category: 'documents', keywords: ['docs'],
     });
-    writeSkill(path.join(root, '.agents/skills'), 'question', {
+    writeSkill(path.join(root, '.agents/skills'), 'ask', {
       name: 'cf-ask', description: 'Answer with evidence.', when: 'Use for factual questions.',
       category: 'utilities', keywords: ['answer', 'evidence'],
     });
@@ -84,8 +84,8 @@ test('skill routing consumes live catalog without fixed optional commands', () =
   const domain = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/rules/skill-domain-routing.md'), 'utf8');
   const codexEntry = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/codex/AGENTS.md'), 'utf8');
   assert.match(workflow, /user names a valid installed skill[\s\S]*one obvious low-risk[\s\S]*direct factual conversation/);
-  assert.match(workflow, /do not invoke Route or agents for ceremony/);
-  assert.match(workflow.replace(/\s+/g, ' '), /numeric optimization capability remains explicit-only/);
+  assert.match(workflow, /do not spawn agents for ceremony/);
+  assert.doesNotMatch(`${workflow}\n${domain}`, /numeric optimization capability/);
   assert.match(domain, /examples below are intent hints, not a copied installed inventory/);
   assert.match(domain, /document\/artifact work \| use only a matching installed optional capability/);
   assert.doesNotMatch(domain, /\/cf:(?:docs|docx|pdf|pptx|xlsx|ai-multimodal)/);
@@ -96,17 +96,19 @@ test('skill routing consumes live catalog without fixed optional commands', () =
 test('skill catalog exposes discriminating routing metadata', () => {
   withTempRoot((root) => {
     const skills = path.join(root, 'skills');
-    writeSkill(skills, 'route', {
-      name: 'cf:route', description: 'Choose a bounded chain.',
+    writeSkill(skills, 'triage', {
+      name: 'cf:triage', description: 'Choose a bounded chain.',
       when: 'Use for ambiguous multi-step work.', category: 'utilities',
       keywords: ['routing', 'risk'],
     });
+    // An upgrade can leave a user-modified retired directory beside its replacement; both carry the
+    // same public name, and only the retired one may drop out.
     writeSkill(skills, 'question', {
-      name: 'cf:ask', description: 'First duplicate.', when: 'Use for questions.',
+      name: 'cf:ask', description: 'User-modified retired copy.', when: 'Use for questions.',
       category: 'utilities', keywords: ['answer'],
     });
     writeSkill(skills, 'ask', {
-      name: 'cf:ask', description: 'Second duplicate.', when: 'Use for questions.',
+      name: 'cf:ask', description: 'Answer with evidence.', when: 'Use for questions.',
       category: 'utilities', keywords: ['answer'],
     });
     writeSkill(skills, 'missing-description', { name: 'cf:missing-description' });
@@ -132,15 +134,16 @@ test('skill catalog exposes discriminating routing metadata', () => {
     });
 
     const catalog = runCatalog(SCANNER, root, ['--json', '--root', skills]);
-    assert.deepEqual(catalog.skills.map((skill) => skill.public_id), ['cf:route']);
-    assert.deepEqual(catalog.skills[0], {
-      name: 'cf:route', public_id: 'cf:route', directory: 'route',
+    assert.deepEqual(catalog.skills.map((skill) => skill.public_id), ['cf:ask', 'cf:triage']);
+    assert.deepEqual(catalog.skills.find((skill) => skill.public_id === 'cf:triage'), {
+      name: 'cf:triage', public_id: 'cf:triage', directory: 'triage',
       description: 'Choose a bounded chain.', when_to_use: 'Use for ambiguous multi-step work.',
       category: 'utilities', keywords: ['routing', 'risk'], user_invocable: true,
       has_references: false, has_scripts: false,
     });
     const codes = catalog.diagnostics.map((item) => item.code);
-    assert.equal(codes.filter((code) => code === 'duplicate_public_name').length, 2);
+    assert.equal(codes.filter((code) => code === 'duplicate_public_name').length, 0);
+    assert.ok(catalog.diagnostics.some((item) => item.directory === 'question' && item.code === 'retired_skill'));
     for (const required of [
       'folder_name_mismatch', 'malformed_frontmatter', 'missing_routing_metadata', 'retired_skill',
     ]) assert.ok(codes.includes(required), required);
@@ -157,10 +160,19 @@ test('skill catalog exposes discriminating routing metadata', () => {
   const sourceCatalog = runCatalog(SCANNER, PACKAGE_ROOT);
   const retiredDiagnostics = sourceCatalog.diagnostics
     .filter((item) => item.code === 'retired_skill').map((item) => item.directory).sort();
-  assert.deepEqual(retiredDiagnostics, [...MANIFEST.obsolete.skills].sort());
+  // Retired skills kept in the source tree must be flagged; renamed ones were moved, so they are
+  // absent from the source and only matter to an upgrade over an older install.
+  const sourceSkills = path.join(PACKAGE_ROOT, 'src/claude/skills');
+  const keptRetired = MANIFEST.obsolete.skills.filter((name) => fs.existsSync(path.join(sourceSkills, name)));
+  assert.deepEqual(retiredDiagnostics, [...keptRetired].sort());
+  for (const renamed of ['inspect', 'hotfix', 'question']) {
+    assert.ok(MANIFEST.obsolete.skills.includes(renamed), renamed);
+    assert.equal(fs.existsSync(path.join(sourceSkills, renamed)), false, renamed);
+  }
   assert.equal(sourceCatalog.skills.some((skill) => MANIFEST.obsolete.skills.includes(skill.directory)), false);
-  const route = sourceCatalog.skills.find((skill) => skill.public_id === 'cf:route');
-  assert.ok(route?.description && route.when_to_use && route.category && route.keywords.length > 0);
+  assert.equal(sourceCatalog.skills.some((skill) => skill.public_id === 'cf:route'), false);
+  const ask = sourceCatalog.skills.find((skill) => skill.public_id === 'cf:ask');
+  assert.ok(ask?.description && ask.when_to_use && ask.category && ask.keywords.length > 0);
 });
 
 test('skill catalog rejects a missing root value before path resolution', () => {

package/bin/__tests__/spec-narrowing.test.js

@@ -1,11 +1,9 @@
 'use strict';
 
-// Two Stop hooks ask two different questions about the same repository, so they narrow an
-// ambiguous scan differently. The gate asks which packet still has unfinished work, so it
-// can validate that packet's receipts. Closeout approval asks which packet is claiming
-// closeout, so it can demand a one-time approval for it. Counting finished history as
-// ambiguity is what left a repository of accumulated features permanently blocked, with
-// the documented escape — an explicit feature target — unavailable.
+// The Stop gate narrows an ambiguous scan by asking which packet still has unfinished
+// work, so it can validate that packet's receipts. Counting finished history as ambiguity
+// is what left a repository of accumulated features permanently blocked, with the
+// documented escape — an explicit feature target — unavailable.
 
 const assert = require('node:assert/strict');
 const { spawnSync } = require('node:child_process');
@@ -38,7 +36,7 @@ function legacyPacket(root, name, { status, phase, taskStatus = 'done' } = {}) {
 }
 
 /** A process-first packet: plan.md plus one flat task file. */
-function workflowPacket(root, name, taskStatus) {
+function workflowPacket(root, name, taskStatus, nextStatus = null) {
   const dir = path.join(root, 'specs', name);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(path.join(dir, 'plan.md'), '# Plan\nSpecs-Contract: process-first-ready-v1\n');
@@ -46,6 +44,12 @@ function workflowPacket(root, name, taskStatus) {
     path.join(dir, 'task-01-x.md'),
     `# Task 01\n\nStatus: ${taskStatus}\n\n## Dependencies\n- none\n`
   );
+  if (nextStatus) {
+    fs.writeFileSync(
+      path.join(dir, 'task-02-y.md'),
+      `# Task 02\n\nStatus: ${nextStatus}\n\n## Dependencies\n- none\n`
+    );
+  }
 }
 
 function recordActiveFeature(root, contents) {
@@ -63,34 +67,19 @@ function gateResolution(root) {
 
 // ── The gate: which packet still has work ───────────────────────────────────────────
 
-test('a legacy repository resolves its one unfinished packet', () => {
+test('a leftover legacy packet creates no ambiguity for the gate', () => {
   withProject((root) => {
     for (let index = 1; index <= 3; index += 1) {
-      legacyPacket(root, `done-${index}`, { status: 'done', phase: 'closeout' });
+      legacyPacket(root, `history-${index}`, { status: 'in_progress', phase: 'execution', taskStatus: 'pending' });
     }
-    legacyPacket(root, 'active-now', { status: 'in_progress', phase: 'execution', taskStatus: 'pending' });
+    workflowPacket(root, 'active-now', 'pending');
     const resolved = gateResolution(root);
     assert.equal(resolved.error, undefined, `expected a resolution, got ${resolved.error}`);
     assert.equal(resolved.featureName, 'active-now');
+    assert.deepEqual(RESOLVER.findLegacyPackets(root, {}), ['history-1', 'history-2', 'history-3']);
   });
 });
 
-test('a legacy registry written with the older vocabulary counts as finished', () => {
-  // Issue #79's repository was upgraded from an older release whose task_registry used
-  // `completed`. Today's validator allows only pending/in_progress/blocked/done, so
-  // narrowing read those packets as unfinished and the block survived the fix that was
-  // supposed to clear it. Measured on the reported shape before this: 18 candidates.
-  for (const status of ['done', 'completed', 'complete']) {
-    withProject((root) => {
-      for (let index = 1; index <= 3; index += 1) {
-        legacyPacket(root, `history-${index}`, { taskStatus: status });
-      }
-      legacyPacket(root, 'active-now', { status: 'in_progress', phase: 'execution', taskStatus: 'pending' });
-      assert.equal(gateResolution(root).featureName, 'active-now', `task status ${status} must read as finished`);
-    });
-  }
-});
-
 test('a process-first packet keeps the strict task vocabulary', () => {
   // The widened set is legacy-only. A process-first task saying `completed` is malformed,
   // not finished, and must not be silently read as done.
@@ -102,20 +91,6 @@ test('a process-first packet keeps the strict task vocabulary', () => {
   });
 });
 
-test('a legacy candidate never reaches the bulk branch', () => {
-  // The bulk branch exits before the semantic-digest, FLASH_UNVERIFIED, feature-receipt
-  // and completion-policy layers, so a legacy packet reaching it would turn a block into
-  // a silent pass. With every legacy packet finished there is nothing to narrow to, and
-  // the existing ambiguity must stand rather than the set being audited.
-  withProject((root) => {
-    legacyPacket(root, 'done-1', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'done-2', { status: 'done', phase: 'closeout' });
-    const resolved = gateResolution(root);
-    assert.notEqual(resolved.layoutKind, 'process-v3-completed-set');
-    assert.ok(resolved.error, 'an all-legacy finished set must stay ambiguous');
-  });
-});
-
 test('a process-first set still reaches the bulk branch', () => {
   withProject((root) => {
     workflowPacket(root, 'done-1', 'done');
@@ -132,116 +107,21 @@ test('one unfinished process-first packet still narrows', () => {
   });
 });
 
-// ── Closeout approval: which packet is claiming closeout ────────────────────────────
-
-test('one packet claiming closeout among finished ones resolves', () => {
-  withProject((root) => {
-    legacyPacket(root, 'shipped', { status: 'in_progress', phase: 'execution', taskStatus: 'done' });
-    legacyPacket(root, 'closing', { status: 'done', phase: 'closeout' });
-    const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    assert.equal(resolved.error, undefined);
-    assert.equal(resolved.featureName, 'closing');
-  });
-});
-
-test('a lone finished packet still resolves', () => {
-  // Four existing cases depend on this: closeout approval is claimed against a finished
-  // spec, so a single packet must resolve whatever its status.
-  for (const status of ['done', 'completed']) {
-    withProject((root) => {
-      legacyPacket(root, 'only', { status });
-      const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-      assert.equal(resolved.featureName, 'only', `status ${status} must still resolve`);
-    });
-  }
-});
-
-test('a lone packet mid-execution still resolves', () => {
-  // The closeout filter would drop this one, so the single-candidate return above it is
-  // what keeps a repository holding exactly one in-flight packet resolvable. Without it
-  // the hook goes silent for that repository instead of checking the packet.
-  withProject((root) => {
-    legacyPacket(root, 'solo', { status: 'in_progress', phase: 'implementation', taskStatus: 'pending' });
-    const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    assert.equal(resolved.featureName, 'solo');
-  });
-});
-
-test('no packet claiming closeout resolves to null', () => {
-  // null means nothing is in flight and the hook stays silent; an error would keep
-  // blocking a repository where no closeout is being claimed at all.
-  withProject((root) => {
-    legacyPacket(root, 'a', { status: 'in_progress', phase: 'execution' });
-    legacyPacket(root, 'b', { status: 'in_progress', phase: 'execution' });
-    assert.equal(RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} }), null);
-  });
-});
-
-test('several packets claiming closeout stay ambiguous and name only those', () => {
-  withProject((root) => {
-    legacyPacket(root, 'closing-a', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'closing-b', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'working', { status: 'in_progress', phase: 'execution' });
-    const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    assert.equal(resolved.error, 'multiple_persisted');
-    assert.deepEqual(resolved.candidates, ['closing-a', 'closing-b']);
-  });
-});
-
-test('codex resolveCandidate agrees with the shared resolver', () => {
-  // Codex kept its own candidate count, reachable because spec-utils did not export the
-  // shared function. A Claude-only change would leave every Codex turn blocked.
-  const codexCheck = require(path.join(PACKAGE_ROOT, 'src/codex/hooks/completion-authority-check.cjs'));
-  const utils = require(path.join(PACKAGE_ROOT, 'src/codex/hooks/lib/spec-utils.cjs'));
-  assert.equal(typeof utils.resolvePersistedSpec, 'function', 'the wrapper must be exported');
-  withProject((root) => {
-    legacyPacket(root, 'shipped', { status: 'in_progress', phase: 'execution', taskStatus: 'done' });
-    legacyPacket(root, 'closing', { status: 'done', phase: 'closeout' });
-    const shared = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    const viaCodex = codexCheck.resolveCandidate({ projectRoot: root, runtime: {}, payload: {} });
-    assert.equal(viaCodex.featureName, shared.featureName);
-  });
-});
-
 // ── The recorded active feature: the escape the block told users to take ────────────
 
-test('a recorded active feature resolves two packets claiming closeout', () => {
-  withProject((root) => {
-    legacyPacket(root, 'closing-a', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'closing-b', { status: 'done', phase: 'closeout' });
-    assert.equal(RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} }).error, 'multiple_persisted');
-    recordActiveFeature(root, '{"featureName": "closing-b"}\n');
-    const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    assert.equal(resolved.error, undefined, `expected a resolution, got ${resolved.error}`);
-    assert.equal(resolved.featureName, 'closing-b');
-  });
-});
-
-test('a payload target beats the recorded file', () => {
-  withProject((root) => {
-    legacyPacket(root, 'alpha', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'beta', { status: 'done', phase: 'closeout' });
-    recordActiveFeature(root, '{"featureName": "alpha"}\n');
-    const resolved = RESOLVER.resolvePersistedSpec({
-      projectRoot: root, runtime: {}, target: { featureName: 'beta' },
-    });
-    assert.equal(resolved.featureName, 'beta', 'the caller must win');
-  });
-});
-
 test('a blank recorded feature is ignored rather than malformed', () => {
   // explicitTargetValue turns a blank into null, and a null target becomes an
   // explicit_malformed error that blocks. The reader must return null instead, or every
   // project holding a stray file would be blocked by the very escape hatch.
   for (const contents of ['{"featureName": "   "}', '{"featureName": 42}', '{}', 'not json', '[]']) {
     withProject((root) => {
-      legacyPacket(root, 'only', { status: 'done', phase: 'closeout' });
+      workflowPacket(root, 'only', 'pending');
       recordActiveFeature(root, contents);
       assert.equal(
         RESOLVER.readActiveFeatureTarget({ projectRoot: root, runtime: {} }), null,
         `${contents} must be invisible`
       );
-      assert.equal(RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} }).featureName, 'only');
+      assert.equal(RESOLVER.resolveWorkflowCandidate({ projectRoot: root, runtime: {} }).featureName, 'only');
     });
   }
 });
@@ -249,11 +129,12 @@ test('a blank recorded feature is ignored rather than malformed', () => {
 test('a recorded feature cannot escape the specs root', () => {
   // The reader adds no trust: the value goes through the resolver's existing checks.
   withProject((root) => {
-    legacyPacket(root, 'a', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'b', { status: 'done', phase: 'closeout' });
+    workflowPacket(root, 'a', 'pending');
+    workflowPacket(root, 'b', 'pending');
     recordActiveFeature(root, '{"featureName": "../../etc"}');
-    const resolved = RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} });
-    assert.ok(resolved.error, 'an escaping name must produce the existing error, not a resolution');
+    const target = RESOLVER.readActiveFeatureTarget({ projectRoot: root, runtime: {} });
+    const resolved = RESOLVER.resolveWorkflowCandidate({ projectRoot: root, runtime: {}, target });
+    assert.equal(resolved.error, 'explicit_malformed', 'an escaping name must produce the existing error, not a resolution');
     assert.notEqual(resolved.featureName, '../../etc');
   });
 });
@@ -263,7 +144,7 @@ test('a symlinked recorded feature is refused', () => {
   // project does not contain. The repository already refuses symlinked runtime
   // dependencies elsewhere; this reader follows the same rule.
   withProject((root) => {
-    legacyPacket(root, 'only', { status: 'done', phase: 'closeout' });
+    workflowPacket(root, 'only', 'pending');
     const outside = path.join(root, 'outside.json');
     fs.writeFileSync(outside, '{"featureName": "only"}');
     const dir = path.join(root, 'specs', '_shared');
@@ -275,32 +156,20 @@ test('a symlinked recorded feature is refused', () => {
 
 test('an absent file leaves every project exactly as it was', () => {
   withProject((root) => {
-    legacyPacket(root, 'only', { status: 'in_progress', phase: 'execution' });
+    workflowPacket(root, 'only', 'pending');
     assert.equal(RESOLVER.readActiveFeatureTarget({ projectRoot: root, runtime: {} }), null);
-    assert.equal(RESOLVER.resolvePersistedSpec({ projectRoot: root, runtime: {} }).featureName, 'only');
+    assert.equal(RESOLVER.resolveWorkflowCandidate({ projectRoot: root, runtime: {} }).featureName, 'only');
   });
 });
 
-test('the approval prompt names its feature', () => {
-  // Without the name a user types a bare nonce and cannot tell which closeout they are
-  // approving, while the recorded file can influence which packet resolves.
-  for (const runtimeDir of ['claude', 'codex']) {
-    const hook = fs.readFileSync(
-      path.join(PACKAGE_ROOT, 'src', runtimeDir, 'hooks', 'completion-authority.cjs'), 'utf8'
-    );
-    assert.match(hook, /const feature = result\.candidate\?\.featureName;/, `${runtimeDir} must read the name`);
-    assert.match(hook, /closeout approval is required for \$\{feature \?/, `${runtimeDir} must print it`);
-  }
-});
-
 test('the shared workflow resolver ignores the recorded file', () => {
   // resolveWorkflowCandidate has five consumers, including spec-state.cjs and
   // precompact.cjs. Reading the file inside it would retarget hooks that never asked,
   // so the two gates apply it at their own call sites instead. Neither of those suites
   // writes the file, so nothing else pins this containment.
   withProject((root) => {
-    legacyPacket(root, 'alpha', { status: 'done', phase: 'closeout' });
-    legacyPacket(root, 'beta', { status: 'done', phase: 'closeout' });
+    workflowPacket(root, 'alpha', 'done');
+    workflowPacket(root, 'beta', 'done');
     recordActiveFeature(root, '{"featureName": "beta"}');
     const resolved = RESOLVER.resolveWorkflowCandidate({
       projectRoot: root, runtime: {}, target: null, includeCompleted: true,
@@ -315,7 +184,7 @@ test('the codex gate consults the file only after its payload', () => {
   assert.equal(typeof utils.readActiveFeatureTarget, 'function', 'the wrapper must be exported');
   assert.equal(typeof utils.extractExplicitTarget, 'function', 'the gate needs the payload extractor');
   withProject((root) => {
-    legacyPacket(root, 'alpha', { status: 'done', phase: 'closeout' });
+    workflowPacket(root, 'alpha', 'done');
     recordActiveFeature(root, '{"featureName": "alpha"}');
     assert.deepEqual(
       utils.extractExplicitTarget({ featureName: 'beta' }) || utils.readActiveFeatureTarget({ projectRoot: root, runtime: {} }),
@@ -365,8 +234,8 @@ for (const [runtimeName, hook] of [['claude', 'src/claude/hooks/spec-gate.cjs']]
     // identity complaint whose stated remedy nothing could supply; naming the feature
     // makes the gate resolve it and report the violation that was there all along.
     gitProject((dir) => {
-      legacyPacket(dir, 'alpha', { status: 'done', phase: 'closeout' });
-      legacyPacket(dir, 'beta', { status: 'done', phase: 'closeout' });
+      workflowPacket(dir, 'alpha', 'done', 'pending');
+      workflowPacket(dir, 'beta', 'done', 'pending');
 
       const blocked = runGate(hook, dir);
       assert.match(blocked, /multiple active specs detected/, 'the reported block must reproduce');