@haposoft/cafekit 0.16.7 → 0.18.1

package/src/claude/scripts/spec-resolver.cjs

@@ -58,10 +58,6 @@ function assertSpecsRootContained(projectRoot, specsDir) {
   }
 }
 
-function isPlainObject(value) {
-  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
-
 function candidateError(reason, code = 'malformed') {
   const error = new Error(reason);
   error.code = code;
@@ -221,10 +217,6 @@ function inspectWorkflowFeature(specsDir, canonicalSpecs, requestedName) {
   }
 
   const featureName = path.basename(canonicalFeature);
-  if (fs.existsSync(path.join(canonicalFeature, 'spec.json'))) {
-    return { legacyPresent: true, featureName, featureDir: canonicalFeature };
-  }
-
   const planFile = path.join(canonicalFeature, 'plan.md');
   let planLstat;
   try {
@@ -289,210 +281,6 @@ function inspectWorkflowFeature(specsDir, canonicalSpecs, requestedName) {
   };
 }
 
-// Legacy registries written before the current vocabulary use `completed`, which today's
-// validator rejects but which exists in upgraded repositories. Reading it as finished is
-// what lets those packets stop competing for the gate's attention; `spec-final-state.cjs`
-// already reads spec status the same way. Process-first packets keep the strict set.
-const LEGACY_TASK_DONE = new Set(['done', 'completed', 'complete']);
-
-function normalizeLegacyWorkflowCandidate(candidate) {
-  const registry = candidate.spec?.task_registry || {};
-  const tasks = Object.entries(registry).map(([taskPath, task]) => ({
-    path: taskPath,
-    status: task?.status || 'pending',
-  }));
-  return {
-    ...candidate,
-    layoutKind: 'legacy-spec',
-    stateFile: candidate.specFile,
-    phase: candidate.spec?.current_phase || candidate.spec?.phase || 'unknown',
-    taskRegistry: registry,
-    tasks,
-    allTasksDone: tasks.length > 0 && tasks.every((task) => LEGACY_TASK_DONE.has(task.status)),
-  };
-}
-
-function inspectFeature(specsDir, canonicalSpecs, requestedName) {
-  const featureDir = path.join(specsDir, requestedName);
-  let featureLstat;
-  try {
-    featureLstat = fs.lstatSync(featureDir);
-  } catch (e) {
-    if (isMissingError(e)) return { missing: true };
-    throw candidateError(`feature lstat error: ${e.message}`);
-  }
-
-  let canonicalFeature;
-  try {
-    canonicalFeature = fs.realpathSync(featureDir);
-    if (!fs.statSync(featureDir).isDirectory()) {
-      throw candidateError('feature entry must be a directory');
-    }
-  } catch (e) {
-    if (e && e.code) throw e;
-    throw candidateError(`feature canonicalization error: ${e.message}`);
-  }
-  if (canonicalFeature !== canonicalSpecs && !isPathInside(canonicalSpecs, canonicalFeature)) {
-    throw candidateError('feature symlink escapes specs root');
-  }
-  if (path.dirname(canonicalFeature) !== canonicalSpecs) {
-    throw candidateError('feature directory must resolve to a direct child of specs root');
-  }
-
-  const featureName = path.basename(canonicalFeature);
-  const specFile = path.join(featureDir, 'spec.json');
-  let specLstat;
-  try {
-    specLstat = fs.lstatSync(specFile);
-  } catch (e) {
-    if (isMissingError(e)) return { missingSpec: true, featureName, featureDir, canonicalFeature, specFile };
-    throw candidateError(`spec.json lstat error: ${e.message}`);
-  }
-
-  let canonicalSpecFile;
-  try {
-    canonicalSpecFile = fs.realpathSync(specFile);
-    if (!fs.statSync(specFile).isFile()) {
-      throw candidateError('spec.json must be a regular file');
-    }
-  } catch (e) {
-    if (e && e.code) throw e;
-    throw candidateError(`spec.json canonicalization error: ${e.message}`);
-  }
-  if (canonicalSpecFile !== canonicalSpecs && !isPathInside(canonicalSpecs, canonicalSpecFile)) {
-    throw candidateError('spec file symlink escapes specs root');
-  }
-  const expectedSpecFile = path.join(canonicalFeature, 'spec.json');
-  if (canonicalSpecFile !== expectedSpecFile) {
-    throw candidateError(`spec.json does not belong to feature directory ${featureName}`);
-  }
-
-  let spec;
-  try {
-    spec = JSON.parse(fs.readFileSync(canonicalSpecFile, 'utf8'));
-  } catch (e) {
-    throw candidateError(e.message);
-  }
-  if (!isPlainObject(spec)) throw candidateError('spec.json must contain a JSON object');
-  if (typeof spec.feature_name !== 'string' || spec.feature_name.trim() !== featureName) {
-    throw candidateError(`spec.json.feature_name must equal canonical feature name ${featureName}`);
-  }
-
-  return {
-    featureName,
-    spec,
-    specsDir,
-    featureDir: canonicalFeature,
-    specFile: canonicalSpecFile,
-    canonicalFeature,
-    canonicalSpecFile,
-    featureLstat,
-    specLstat,
-  };
-}
-
-function scanSpecs(specsDir) {
-  let canonicalSpecs;
-  let specsLstat = null;
-  try {
-    specsLstat = fs.lstatSync(specsDir);
-  } catch (e) {
-    if (isMissingError(e)) return { active: [], candidates: [], invalid: [], canonicalSpecs: path.resolve(specsDir) };
-    return { active: [], candidates: [], invalid: [{ featureName: '<specs>', reason: `specs lstat error: ${e.message}`, specFile: specsDir }], canonicalSpecs: path.resolve(specsDir) };
-  }
-  try {
-    canonicalSpecs = fs.realpathSync(specsDir);
-  } catch (e) {
-    return { active: [], candidates: [], invalid: [{ featureName: '<specs>', reason: `specs root canonicalization error: ${e.message}`, specFile: specsDir }], canonicalSpecs: path.resolve(specsDir) };
-  }
-
-  let entries;
-  try {
-    entries = fs.readdirSync(specsDir, { withFileTypes: true });
-  } catch (e) {
-    return { active: [], candidates: [], invalid: [{ featureName: '<specs>', reason: `specs directory read error: ${e.message}`, specFile: specsDir }], canonicalSpecs };
-  }
-  const active = [];
-  const candidates = [];
-  const invalid = [];
-  const seenCanonicalFeatures = new Set();
-  const sorted = entries.sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of sorted) {
-    try {
-      const candidate = inspectFeature(specsDir, canonicalSpecs, entry.name);
-      if (candidate.missing) {
-        invalid.push({
-          featureName: entry.name,
-          reason: 'feature entry disappeared during scan',
-          specFile: path.join(specsDir, entry.name, 'spec.json'),
-        });
-        continue;
-      }
-      if (candidate.missingSpec) {
-        continue;
-      }
-      if (seenCanonicalFeatures.has(candidate.canonicalFeature)) continue;
-      seenCanonicalFeatures.add(candidate.canonicalFeature);
-      candidates.push(candidate);
-      if (candidate.spec.status === 'in_progress' || candidate.spec.status === 'in-progress') {
-        active.push(candidate);
-      }
-    } catch (e) {
-      invalid.push({
-        featureName: entry.name,
-        reason: e.message,
-        specFile: path.join(specsDir, entry.name, 'spec.json'),
-      });
-    }
-  }
-  return { active, candidates, invalid, canonicalSpecs };
-}
-
-function findAllSpecCandidates(projectRoot, runtime) {
-  let specsDir;
-  try {
-    specsDir = specsDirectory(projectRoot, runtime);
-  } catch (error) {
-    const wrapped = new Error(`Invalid spec candidates: <specs>: ${error.message}`);
-    wrapped.code = 'INVALID_SPECS';
-    wrapped.invalid = [{ featureName: '<specs>', reason: error.message, specFile: path.resolve(projectRoot, 'specs') }];
-    throw wrapped;
-  }
-  const scanned = scanSpecs(specsDir);
-  if (scanned.invalid.length > 0) {
-    const error = new Error(`Invalid spec candidates: ${scanned.invalid.map((item) => `${item.featureName}: ${item.reason}`).join('; ')}`);
-    error.code = 'INVALID_SPECS';
-    error.invalid = scanned.invalid;
-    throw error;
-  }
-  return scanned.candidates.sort((left, right) => left.featureName.localeCompare(right.featureName));
-}
-
-function findAllActiveSpecs(projectRoot, runtime) {
-  let specsDir;
-  try {
-    specsDir = specsDirectory(projectRoot, runtime);
-  } catch (error) {
-    const wrapped = new Error(`Invalid spec candidates: <specs>: ${error.message}`);
-    wrapped.code = 'INVALID_SPECS';
-    wrapped.invalid = [{ featureName: '<specs>', reason: error.message, specFile: path.resolve(projectRoot, 'specs') }];
-    throw wrapped;
-  }
-  const { active, invalid } = scanSpecs(specsDir);
-  if (invalid.length > 0) {
-    const error = new Error(`Invalid spec candidates: ${invalid.map((item) => `${item.featureName}: ${item.reason}`).join('; ')}`);
-    error.code = 'INVALID_SPECS';
-    error.invalid = invalid;
-    throw error;
-  }
-  return active;
-}
-
-function isPathInsideLegacy(parent, child) {
-  const rel = path.relative(parent, child);
-  return rel !== '' && !rel.startsWith('..' + path.sep) && rel !== '..' && !path.isAbsolute(rel);
-}
-
 function explicitTargetValue(value) {
   return typeof value === 'string' ? value.trim() : value;
 }
@@ -535,7 +323,39 @@ function readActiveFeatureTarget({ projectRoot, runtime } = {}) {
   const value = parsed.featureName;
   if (typeof value !== 'string' || /[\r\n]/.test(value)) return null;
   const trimmed = value.trim();
-  return trimmed ? { explicitFeature: trimmed } : null;
+  if (!trimmed) return null;
+  // A recorded target naming a legacy spec.json packet is ignored rather than turned into
+  // a Stop block: CafeKit no longer reads those packets. A missing directory still reaches
+  // the resolver and fails as explicit_not_found; a name that is not a plain directory
+  // segment is left for the resolver to reject before anything outside specs is touched.
+  if (SAFE_PACKET_NAME.test(trimmed) && isLegacyPacketDir(path.join(specsDir, trimmed))) return null;
+  return { explicitFeature: trimmed };
+}
+
+// Names printed back to the model are limited to plain directory segments.
+const SAFE_PACKET_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+// A legacy packet is a direct specs/<x>/ directory holding spec.json and no plan.md.
+// A directory with both files is read as a process-first packet.
+function isLegacyPacketDir(featureDir) {
+  const info = lstatOptional(featureDir);
+  if (!info.exists || info.isSymlink || !info.stat.isDirectory()) return false;
+  return fs.existsSync(path.join(featureDir, 'spec.json'))
+    && !fs.existsSync(path.join(featureDir, 'plan.md'));
+}
+
+function findLegacyPackets(projectRoot, runtime) {
+  let specsDir;
+  try {
+    specsDir = specsDirectory(projectRoot, runtime || {});
+    return fs.readdirSync(specsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && SAFE_PACKET_NAME.test(entry.name)
+        && isLegacyPacketDir(path.join(specsDir, entry.name)))
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
 }
 
 /**
@@ -583,212 +403,6 @@ function lstatOptional(p) {
   }
 }
 
-function resolveActiveSpec({ projectRoot, runtime, explicitFeature, explicitPath, target } = {}) {
-  if (!projectRoot) throw new TypeError('projectRoot required');
-  const rt = runtime || {};
-  const normalizedTarget = extractExplicitTarget(target);
-  if (explicitFeature === undefined && normalizedTarget
-    && Object.prototype.hasOwnProperty.call(normalizedTarget, 'explicitFeature')) {
-    explicitFeature = normalizedTarget.explicitFeature;
-  }
-  if (explicitPath === undefined && normalizedTarget
-    && Object.prototype.hasOwnProperty.call(normalizedTarget, 'explicitPath')) {
-    explicitPath = normalizedTarget.explicitPath;
-  }
-  const hasExplicitFeature = explicitFeature !== undefined && explicitFeature !== null;
-  const hasExplicitPath = explicitPath !== undefined && explicitPath !== null;
-  const hasExplicitTarget = hasExplicitFeature || hasExplicitPath;
-  let specsDir;
-  try {
-    specsDir = specsDirectory(projectRoot, rt);
-  } catch (error) {
-    return {
-      error: hasExplicitTarget ? 'explicit_malformed' : 'invalid_specs',
-      candidates: ['<specs>'],
-      explicitFeature,
-      explicitPath,
-      reason: error.message,
-    };
-  }
-  let canonicalSpecs;
-  const specsLstat = lstatOptional(specsDir);
-  if (specsLstat.error) {
-    if (hasExplicitTarget) {
-      return { error: 'explicit_malformed', explicitFeature, explicitPath, reason: `specs lstat error: ${specsLstat.error.message}` };
-    }
-    return { error: 'invalid_specs', candidates: ['<specs>'], invalid: [{ featureName: '<specs>', reason: `specs lstat error: ${specsLstat.error.message}`, specFile: specsDir }], reason: `Invalid spec JSON: <specs>: specs lstat error: ${specsLstat.error.message}` };
-  }
-  if (!specsLstat.exists) {
-    canonicalSpecs = path.resolve(specsDir);
-  } else {
-    try {
-      canonicalSpecs = fs.realpathSync(specsDir);
-    } catch (e) {
-      if (hasExplicitTarget) {
-        return { error: 'explicit_malformed', explicitFeature, explicitPath, reason: `specs root canonicalization error: ${e.message}` };
-      }
-      return { error: 'invalid_specs', candidates: ['<specs>'], invalid: [{ featureName: '<specs>', reason: `specs root canonicalization error: ${e.message}`, specFile: specsDir }], reason: `Invalid spec JSON: <specs>: specs root canonicalization error: ${e.message}` };
-    }
-  }
-
-  if (hasExplicitFeature) {
-    if (typeof explicitFeature !== 'string' || explicitFeature.trim() === '' || explicitFeature.includes('/') || explicitFeature.includes('\\') || explicitFeature.includes('..')) {
-      return { error: 'explicit_malformed', explicitFeature, reason: `malformed feature name: ${explicitFeature}` };
-    }
-    const featureDir = path.join(specsDir, explicitFeature);
-    const resolvedFeature = path.resolve(featureDir);
-    if (!isPathInsideLegacy(path.resolve(specsDir), resolvedFeature) && resolvedFeature !== path.resolve(specsDir)) {
-      return { error: 'explicit_malformed', explicitFeature, reason: 'feature path escapes specs root' };
-    }
-    if (path.relative(path.resolve(specsDir), resolvedFeature) !== explicitFeature) {
-      return { error: 'explicit_malformed', explicitFeature, reason: 'feature name does not canonicalize inside specs root' };
-    }
-    try {
-      const candidate = inspectFeature(specsDir, canonicalSpecs, explicitFeature);
-      if (candidate.missing || candidate.missingSpec) {
-        return { error: 'explicit_not_found', explicitFeature, reason: `spec not found for feature ${explicitFeature}` };
-      }
-      if (candidate.featureName !== explicitFeature) {
-        return {
-          error: 'explicit_malformed',
-          explicitFeature,
-          reason: `feature directory resolves to canonical feature ${candidate.featureName}`,
-        };
-      }
-      return candidate;
-    } catch (e) {
-      return { error: 'explicit_malformed', explicitFeature, reason: e.message };
-    }
-  }
-
-  if (hasExplicitPath) {
-    if (typeof explicitPath !== 'string' || explicitPath.trim() === '') {
-      return { error: 'explicit_malformed', explicitPath, reason: 'empty explicit path' };
-    }
-    let specFile = explicitPath;
-    if (!path.isAbsolute(specFile)) {
-      specFile = path.resolve(projectRoot, specFile);
-    } else {
-      specFile = path.resolve(specFile);
-    }
-    try {
-      const st = fs.lstatSync(specFile);
-      if (st.isDirectory()) {
-        specFile = path.join(specFile, 'spec.json');
-      } else if (st.isSymbolicLink()) {
-        try {
-          if (fs.statSync(specFile).isDirectory()) specFile = path.join(specFile, 'spec.json');
-        } catch (e) {
-          if (!isMissingError(e)) throw e;
-        }
-      }
-    } catch (e) {
-      if (!isMissingError(e)) {
-        return { error: 'explicit_malformed', explicitPath, reason: `explicit path stat error: ${e.message}` };
-      }
-      // If lstat is missing, the candidate is handled as an explicit not-found below.
-    }
-    const featureDir = path.dirname(specFile);
-    if (!isPathInsideLegacy(path.resolve(specsDir), path.resolve(featureDir)) && path.resolve(featureDir) !== path.resolve(specsDir)) {
-      return { error: 'explicit_malformed', explicitPath, reason: 'explicit path escapes specs root' };
-    }
-    const rel = path.relative(path.resolve(specsDir), path.resolve(specFile));
-    const segs = rel.split(path.sep);
-    if (segs.length !== 2 || segs[1] !== 'spec.json') {
-      return { error: 'explicit_malformed', explicitPath, reason: 'explicit path must be <specs>/<feature>/spec.json or <specs>/<feature>' };
-    }
-    try {
-      const candidate = inspectFeature(specsDir, canonicalSpecs, segs[0]);
-      if (candidate.missing || candidate.missingSpec) {
-        return { error: 'explicit_not_found', explicitPath, reason: `spec not found at ${explicitPath}` };
-      }
-      if (candidate.featureName !== segs[0]) {
-        return {
-          error: 'explicit_malformed',
-          explicitPath,
-          reason: `explicit path resolves to canonical feature ${candidate.featureName}, not ${segs[0]}`,
-        };
-      }
-      return candidate;
-    } catch (e) {
-      return { error: 'explicit_malformed', explicitPath, reason: e.message };
-    }
-  }
-
-  const { active, invalid } = scanSpecs(specsDir);
-  if (invalid.length > 0) {
-    return {
-      error: 'invalid_specs',
-      candidates: invalid.map((i) => i.featureName),
-      invalid,
-      reason: `Invalid spec JSON: ${invalid.map((i) => `${i.featureName}: ${i.reason}`).join('; ')}`,
-    };
-  }
-  active.sort((left, right) => left.featureName.localeCompare(right.featureName));
-  if (active.length === 0) return null;
-  if (active.length === 1) return active[0];
-  return {
-    error: 'multiple_active',
-    candidates: active.map((a) => a.featureName),
-    active,
-    reason: `Multiple active specs found: ${active.map((a) => a.featureName).join(', ')}. Provide explicit feature.`,
-  };
-}
-
-/**
- * Resolve one persisted feature identity. Explicit host targets are inspected
- * directly and never scan siblings; only the no-target path performs a global
- * persisted-candidate scan and therefore owns ambiguity/invalid-sibling errors.
- */
-function resolvePersistedSpec({ projectRoot, runtime, explicitFeature, explicitPath, target } = {}) {
-  const normalized = extractExplicitTarget(
-    target,
-    explicitFeature !== undefined ? { explicitFeature } : null,
-    explicitPath !== undefined ? { explicitPath } : null,
-  );
-  if (normalized) {
-    const value = Object.prototype.hasOwnProperty.call(normalized, 'explicitFeature')
-      ? normalized.explicitFeature
-      : normalized.explicitPath;
-    if (value === null || value === undefined) {
-      return { error: 'explicit_malformed', ...normalized, reason: 'explicit target must be a non-empty string' };
-    }
-    return resolveActiveSpec({ projectRoot, runtime, ...normalized });
-  }
-  // Only now, with the caller having named nothing: a recorded target must never
-  // redirect a hook that already knows which feature its turn is about.
-  const recorded = readActiveFeatureTarget({ projectRoot, runtime });
-  if (recorded) return resolveActiveSpec({ projectRoot, runtime, ...recorded });
-  try {
-    const candidates = findAllSpecCandidates(projectRoot, runtime);
-    if (candidates.length === 0) return null;
-    // One packet resolves on its own terms. Closeout approval is claimed against a
-    // finished spec, so status must never decide identity here.
-    if (candidates.length === 1) return candidates[0];
-    // This path serves closeout approval, so only a packet actually claiming closeout is
-    // a real rival. Counting finished history as ambiguity is what made the gate
-    // unsatisfiable in a repository that had simply accumulated features.
-    const { isDurableCloseout } = require('./spec-final-state.cjs');
-    const claiming = candidates.filter((candidate) => isDurableCloseout(candidate.spec));
-    if (claiming.length === 1) return claiming[0];
-    if (claiming.length === 0) return null;
-    return {
-      error: 'multiple_persisted',
-      candidates: claiming.map((candidate) => candidate.featureName),
-      reason: `Multiple persisted specs found: ${claiming.map((candidate) => candidate.featureName).join(', ')}. Provide explicit feature.`,
-    };
-  } catch (error) {
-    return {
-      error: 'invalid_specs',
-      candidates: Array.isArray(error.invalid)
-        ? error.invalid.map((entry) => entry.featureName)
-        : ['<specs>'],
-      invalid: error.invalid || [],
-      reason: error.message,
-    };
-  }
-}
-
 function scanWorkflowFeatures(specsDir) {
   let canonicalSpecs;
   try {
@@ -807,7 +421,7 @@ function scanWorkflowFeatures(specsDir) {
   for (const entry of entries) {
     try {
       const candidate = inspectWorkflowFeature(canonicalSpecs, canonicalSpecs, entry.name);
-      if (candidate.missing || candidate.missingWorkflow || candidate.legacyPresent) continue;
+      if (candidate.missing || candidate.missingWorkflow) continue;
       candidates.push(candidate);
       if (!candidate.allTasksDone) active.push(candidate);
     } catch (error) {
@@ -859,9 +473,8 @@ function explicitWorkflowFeatureName({ projectRoot, specsDir, explicitFeature, e
 }
 
 /**
- * Resolve the authoring/execution workflow visible to prompt and Stop hooks.
- * Persisted spec resolution remains unchanged; process-v3 is an additive adapter
- * and never becomes completion-authority input by way of findAllSpecCandidates.
+ * Resolve the process-first packet (plan.md plus flat task files) visible to prompt
+ * and Stop hooks.
  */
 function resolveWorkflowCandidate({ projectRoot, runtime, explicitFeature, explicitPath, target, includeCompleted = false } = {}) {
   if (!projectRoot) throw new TypeError('projectRoot required');
@@ -884,20 +497,14 @@ function resolveWorkflowCandidate({ projectRoot, runtime, explicitFeature, expli
   }
 
   if (hasExplicit) {
-    const legacyDirect = resolveActiveSpec({ projectRoot, runtime, explicitFeature, explicitPath });
-    if (legacyDirect && !legacyDirect.error) return normalizeLegacyWorkflowCandidate(legacyDirect);
     const identity = explicitWorkflowFeatureName({ projectRoot, specsDir, explicitFeature, explicitPath });
     if (identity.error) return identity;
 
-    const legacy = resolveActiveSpec({ projectRoot, runtime, explicitFeature: identity.featureName });
-    if (legacy && !legacy.error) return normalizeLegacyWorkflowCandidate(legacy);
-    if (legacy && legacy.error !== 'explicit_not_found') return legacy;
-
     let canonicalSpecs;
     try {
       canonicalSpecs = fs.realpathSync(specsDir);
       const candidate = inspectWorkflowFeature(specsDir, canonicalSpecs, identity.featureName);
-      if (candidate.missing || candidate.missingWorkflow || candidate.legacyPresent) {
+      if (candidate.missing || candidate.missingWorkflow) {
         return { error: 'explicit_not_found', explicitFeature: identity.featureName, explicitPath, reason: `workflow not found for feature ${identity.featureName}` };
       }
       return candidate;
@@ -906,20 +513,6 @@ function resolveWorkflowCandidate({ projectRoot, runtime, explicitFeature, expli
     }
   }
 
-  let legacyActive;
-  try {
-    const legacyCandidates = includeCompleted
-      ? findAllSpecCandidates(projectRoot, runtime || {})
-      : findAllActiveSpecs(projectRoot, runtime || {});
-    legacyActive = legacyCandidates.map(normalizeLegacyWorkflowCandidate);
-  } catch (error) {
-    return {
-      error: 'invalid_specs',
-      candidates: Array.isArray(error.invalid) ? error.invalid.map((entry) => entry.featureName) : ['<specs>'],
-      invalid: error.invalid || [],
-      reason: error.message,
-    };
-  }
   const workflow = scanWorkflowFeatures(specsDir);
   if (workflow.invalid.length > 0) {
     return {
@@ -930,7 +523,7 @@ function resolveWorkflowCandidate({ projectRoot, runtime, explicitFeature, expli
     };
   }
   const workflowCandidates = includeCompleted ? workflow.candidates : workflow.active;
-  const active = [...legacyActive, ...workflowCandidates]
+  const active = [...workflowCandidates]
     .sort((left, right) => left.featureName.localeCompare(right.featureName));
   if (active.length === 0) return null;
   if (active.length === 1) return active[0];
@@ -943,8 +536,7 @@ function resolveWorkflowCandidate({ projectRoot, runtime, explicitFeature, expli
 }
 
 /**
- * Narrow a Stop-gate ambiguity without changing legacy persisted-spec rules.
- * A single unfinished process-v3 packet is the current workflow; completed
+ * Narrow a Stop-gate ambiguity. A single unfinished process-v3 packet is the current workflow; completed
  * packets are historical. If every process-v3 packet is complete, return the
  * set so the gate can revalidate all receipts instead of blocking on identity.
  */
@@ -955,9 +547,7 @@ function refineWorkflowGateResolution(resolved) {
   const candidates = resolved.active;
   if (candidates.length === 0) return resolved;
 
-  // Which packet still has work decides this, not which layout it uses: a repository of
-  // legacy packets was permanently ambiguous only because the check below used to sit
-  // here and reject the whole set on sight.
+  // Which packet still has work decides this.
   const unfinished = candidates.filter((candidate) => !candidate.allTasksDone);
   if (unfinished.length === 1) return unfinished[0];
   if (unfinished.length > 1) {
@@ -969,10 +559,6 @@ function refineWorkflowGateResolution(resolved) {
       reason: `Multiple active workflows found: ${unfinished.map((candidate) => candidate.featureName).join(', ')}. Provide explicit feature.`,
     };
   }
-  // The bulk-audit branch exits before the semantic-digest, FLASH_UNVERIFIED,
-  // feature-receipt, and completion-policy layers that the single-candidate path runs, so
-  // only process-first packets may reach it. Anything else keeps the existing ambiguity.
-  if (candidates.some((candidate) => candidate.layoutKind !== 'process-v3')) return resolved;
   return {
     layoutKind: 'process-v3-completed-set',
     candidates,
@@ -983,13 +569,10 @@ function refineWorkflowGateResolution(resolved) {
 
 module.exports = {
   annotatedMarkdownLines,
+  findLegacyPackets,
   specsDirectory,
-  findAllActiveSpecs,
-  findAllSpecCandidates,
   extractExplicitTarget,
-  resolveActiveSpec,
   readActiveFeatureTarget,
-  resolvePersistedSpec,
   resolveWorkflowCandidate,
   refineWorkflowGateResolution,
 };