@haposoft/cafekit 0.16.7 → 0.18.1

package/src/codex/AGENTS.md

@@ -10,17 +10,19 @@
 - For skill selection, read `.codex/rules/skill-workflow-routing.md` and
   `.codex/rules/skill-domain-routing.md`. When capability presence is uncertain,
   run `node .codex/scripts/generate-skill-catalog.cjs --skills`; its Codex-bound
-  root is `.agents/skills`. Use `$cf-route` only for ambiguous, multi-step,
-  multi-domain, or risk-elevated work; explicit, obvious, and factual intents
-  stay direct.
+  root is `.agents/skills`. Explicit, obvious, and factual intents stay
+  direct; compose a short chain only for ambiguous, multi-step, multi-domain, or
+  risk-elevated work.
 - Consult `.codex/rules/review-audit-self-decision.md` before applying audit
   feedback, reversing a verified or user decision, or cutting scope, and
   `.codex/rules/process-management.md` whenever a task starts, reuses, or ends
   long-running processes.
+- Read `.codex/rules/state-sync.md` before changing a task `Status:` or Receipt,
+  and `.codex/rules/hook-protocols.md` when a hook blocks or asks.
 - Project hooks live in `.codex/hooks.json`; review trusted hooks with `/hooks`.
-- New Specs work uses the process-first flow. `$cf-specs` opens C1, writes
+- New Specs work uses the process-first flow. `$cf-specs` opens GATE-SCOPE, writes
   `specs/<feature>/plan.md` with flat `task-NN-*.md` files beside it, then opens
-  C2 after adversarial review. It never starts implementation.
+  GATE-REVIEW after adversarial review. It never starts implementation.
 - Start implementation only through a new explicit `$cf-develop` invocation.
   Execute one unblocked task at a time; each task has exactly one `Status:`
   field and the controller is its sole state-and-proof writer.
@@ -28,16 +30,9 @@
   requires a canonical final inline `## Receipt` with the exact command,
   `Exit: 0`, `Verification: PASS`, runtime-derived Base and Head values, and
   non-empty fenced current output.
-- At C3, show current receipts and unresolved limitations. The user decides
+- At GATE-DONE, show current receipts and unresolved limitations. The user decides
   completion; no command, review, or host state may invent approval or proof.
 
-### Legacy Specs compatibility
-
-Existing packets containing `spec.json`, nested tasks, or legacy kernel
-artifacts keep their installed adapter, `task_registry`, `semantic_model`,
-`planning_depth`, lane, `execution_tier`, machine authority, separate receipts,
-and closeout contract. Do not migrate them during unrelated process-first work.
-
 ## Codex caveats
 
 - Custom agents use snake_case names and `fork_turns: "none"` for explicit delegation.

package/src/codex/hooks/agent.cjs

@@ -26,6 +26,7 @@ try {
   const thinkLang = runtime.locale?.thinkingLanguage || (respondLang ? 'en' : '');
   const plansPath = resolveProjectPath(projectRoot, runtime.paths?.plans, 'plans');
   const docsPath = resolveProjectPath(projectRoot, runtime.paths?.docs, 'docs');
+  const specsPath = resolveProjectPath(projectRoot, runtime.paths?.specs, 'specs');
   const venv = resolveVenv(projectRoot);
   const lines = [
     `## Subagent: ${payload.agent_type || 'unknown'}`,
@@ -44,7 +45,7 @@ try {
 
   lines.push(
     '## Rules',
-    `- Plans → ${plansPath}/ | Docs → ${docsPath}/`,
+    `- Specs → ${specsPath}/ | Plans → ${plansPath}/ | Docs → ${docsPath}/`,
     '- YAGNI · KISS · DRY',
     '- Be concise. List unresolved questions at end.'
   );

package/src/codex/hooks/lib/spec-receipt.cjs

@@ -37,8 +37,8 @@ function loadSharedReceipt() {
     'spec-receipt.cjs',
     'spec-receipt.cjs',
     (receipt) => {
-      if (typeof receipt?.checkTaskReceipt !== 'function') {
-        throw new Error('shared spec receipt helper has no checkTaskReceipt function');
+      if (typeof receipt?.checkWorkflowTaskReceipt !== 'function') {
+        throw new Error('shared spec receipt helper has no checkWorkflowTaskReceipt function');
       }
     },
     'shared spec receipt helper is missing'
@@ -55,7 +55,6 @@ function receiptHelper() {
   return loaded.receipt;
 }
 
-function evidenceBody(text) { return receiptHelper().evidenceBody(text, getSharedPolicy() || {}); }
 function safeTaskFile(featureDir, taskPath) {
   const result = receiptHelper().safeRead(featureDir, taskPath);
   return result.status === 'ok' ? result.path : null;
@@ -64,11 +63,6 @@ function validateCanonicalReceipt(body, options = {}) {
   const validate = getSharedValidate();
   return validate ? validate(body, options) : ['shared_validator'];
 }
-function checkReceiptDetails(featureDir, taskPath, task, runtimeContext) {
-  const policy = getSharedPolicy();
-  if (!policy) return { failures: ['shared_validator'], status: 'missing' };
-  return receiptHelper().checkTaskReceipt(featureDir, taskPath, task, runtimeContext, policy);
-}
 function checkWorkflowReceiptDetails(featureDir, taskPath, runtimeContext) {
   const policy = getSharedPolicy();
   const receipt = receiptHelper();
@@ -85,40 +79,18 @@ function checkWorkflowReceiptSet(candidates, projectRoot, runtimeSession) {
   }
   return receipt.checkWorkflowReceiptSet(candidates, projectRoot, runtimeSession, policy);
 }
-function checkReceipt(featureDir, taskPath, task, runtimeContext) {
-  const map = {
-    unsafe_path: 'a', missing_receipt: 'b', task_status: 'a', completed_at: 'd',
-    verification_state: 'c', placeholder: 'c', validator_unavailable: 'c',
-    command: 'e', command_identity: 'e', exit_result: 'f', provenance: 'g',
-    artifact_hash: 'h', artifact_declaration: 'h',
-  };
-  return [...new Set(checkReceiptDetails(featureDir, taskPath, task, runtimeContext).failures.map((failure) => map[failure] || failure))];
-}
-function checkFeatureReceipt(featureDir, runtimeContext) {
-  const policy = getSharedPolicy();
-  if (!policy) return { failures: ['shared_validator'], status: 'missing' };
-  return receiptHelper().checkFeatureReceipt(featureDir, runtimeContext, policy);
-}
-function receiptFixHint(failures) {
+function receiptFixHint(failures, body) {
   const helper = receiptHelper();
-  return typeof helper.receiptFixHint === 'function' ? helper.receiptFixHint(failures) : null;
-}
-function readTaskProof(featureDir, taskPath) {
-  return receiptHelper().readTaskProof(featureDir, taskPath, getSharedPolicy() || {});
+  return typeof helper.receiptFixHint === 'function' ? helper.receiptFixHint(failures, body) : null;
 }
 
 module.exports = {
-  checkFeatureReceipt,
-  checkReceipt,
-  checkReceiptDetails,
   checkWorkflowReceiptDetails,
   checkWorkflowReceiptSet,
-  evidenceBody,
   getSharedPolicy,
   getSharedValidate,
   loadSharedPolicy,
   loadSharedReceipt,
-  readTaskProof,
   receiptFixHint,
   safeTaskFile,
   validateCanonicalReceipt,

package/src/codex/hooks/lib/spec-utils.cjs

@@ -66,8 +66,8 @@ function sharedResolver() {
     // Use canonical realpath for require to avoid symlink hijack
     const realCandidate = canonicalRealpath(candidate);
     const resolver = require(realCandidate);
-    if (typeof resolver?.resolveActiveSpec !== 'function') {
-      throw new Error('shared spec resolver has no resolveActiveSpec function');
+    if (typeof resolver?.resolveWorkflowCandidate !== 'function') {
+      throw new Error('shared spec resolver has no resolveWorkflowCandidate function');
     }
     return resolver;
   } catch (error) {
@@ -80,31 +80,13 @@ function specsDirectory(projectRoot, runtime) {
   return sharedResolver().specsDirectory(projectRoot, runtime);
 }
 
-function findAllActiveSpecs(projectRoot, runtime) {
-  return sharedResolver().findAllActiveSpecs(projectRoot, runtime);
-}
-
-function findAllSpecCandidates(projectRoot, runtime) {
-  return sharedResolver().findAllSpecCandidates(projectRoot, runtime);
-}
-
-function resolveActiveSpec(projectRoot, runtime, explicitFeature, explicitPath) {
-  if (projectRoot && typeof projectRoot === 'object') {
-    return sharedResolver().resolveActiveSpec(projectRoot);
-  }
-  return sharedResolver().resolveActiveSpec({
-    projectRoot,
-    runtime,
-    explicitFeature,
-    explicitPath,
-  });
+function findLegacyPackets(projectRoot, runtime) {
+  const resolver = sharedResolver();
+  return typeof resolver.findLegacyPackets === 'function' ? resolver.findLegacyPackets(projectRoot, runtime) : [];
 }
 
 function resolveWorkflowCandidate(projectRoot, runtime, explicitFeature, explicitPath) {
   const resolver = sharedResolver();
-  if (typeof resolver.resolveWorkflowCandidate !== 'function') {
-    return resolveActiveSpec(projectRoot, runtime, explicitFeature, explicitPath);
-  }
   if (projectRoot && typeof projectRoot === 'object') {
     return resolver.resolveWorkflowCandidate(projectRoot);
   }
@@ -123,23 +105,6 @@ function refineWorkflowGateResolution(resolved) {
     : resolved;
 }
 
-function findActiveSpec(projectRoot, runtime) {
-  const resolved = resolveActiveSpec(projectRoot, runtime);
-  if (!resolved) return null;
-  if (resolved.error === 'multiple_active' || resolved.error === 'invalid_specs') return resolved;
-  if (resolved.error) return null;
-  return resolved;
-}
-
-function taskStatusMap(spec) {
-  return Object.fromEntries(
-    Object.entries(spec.task_registry || {}).map(([taskPath, task]) => [
-      taskPath,
-      task?.status || 'pending',
-    ]),
-  );
-}
-
 function extractExplicitTarget(...sources) {
   const resolver = sharedResolver();
   if (typeof resolver.extractExplicitTarget !== 'function') return null;
@@ -152,22 +117,11 @@ function readActiveFeatureTarget(options) {
   return resolver.readActiveFeatureTarget(options);
 }
 
-function resolvePersistedSpec(options) {
-  const resolver = sharedResolver();
-  if (typeof resolver.resolvePersistedSpec !== 'function') return null;
-  return resolver.resolvePersistedSpec(options);
-}
-
 module.exports = {
-  findActiveSpec,
   extractExplicitTarget,
+  findLegacyPackets,
   readActiveFeatureTarget,
-  resolvePersistedSpec,
-  findAllActiveSpecs,
-  findAllSpecCandidates,
-  resolveActiveSpec,
   resolveWorkflowCandidate,
   refineWorkflowGateResolution,
   specsDirectory,
-  taskStatusMap,
 };

package/src/codex/hooks/rules.cjs

@@ -79,6 +79,7 @@ try {
   const thinkLang = runtime.locale?.thinkingLanguage || (respondLang ? 'en' : '');
   const plansPath = resolveProjectPath(projectRoot, runtime.paths?.plans, 'plans');
   const docsPath = resolveProjectPath(projectRoot, runtime.paths?.docs, 'docs');
+  const specsPath = resolveProjectPath(projectRoot, runtime.paths?.specs, 'specs');
   const lines = [];
 
   if ((thinkLang && thinkLang !== respondLang) || respondLang) {
@@ -92,7 +93,7 @@ try {
 
   lines.push(
     '## Rules',
-    `- Markdown: Plans → "${plansPath}/" | Docs → "${docsPath}/"`,
+    `- Markdown: Specs → "${specsPath}/" | Plans → "${plansPath}/" | Docs → "${docsPath}/"`,
     '- Do not create markdown outside those directories unless explicitly asked.',
     `- docs.maxLoc: ${runtime.docs?.maxLoc || 800} lines per doc file`
   );

package/src/codex/hooks/session.cjs

@@ -10,7 +10,6 @@ const {
   readPayload
 } = require('./lib/hook-context.cjs');
 const { clearState } = require('./lib/privacy-state.cjs');
-const { clearState: clearCompletionState } = require('./completion-authority-state.cjs');
 
 function readPackage(projectRoot) {
   try {
@@ -89,7 +88,6 @@ try {
 
   // Approval tokens never survive a session boundary or compaction.
   clearState(projectRoot);
-  clearCompletionState(projectRoot, payload.session_id);
 
   // Orca (onorca.dev) sets ORCA_PANE_KEY in every pane; it is a presence marker, not a
   // secret. ORCA_AGENT_HOOK_TOKEN and ORCA_AGENT_LAUNCH_TOKEN live in the same

package/src/codex/hooks/spec-gate.cjs

@@ -11,15 +11,11 @@ const {
   readPayload
 } = require('./lib/hook-context.cjs');
 const {
-  checkFeatureReceipt,
-  checkReceiptDetails,
   checkWorkflowReceiptDetails,
   checkWorkflowReceiptSet,
   loadSharedPolicy,
   receiptFixHint,
 } = require('./lib/spec-receipt.cjs');
-const { taskStatusMap } = require('./lib/spec-utils.cjs');
-const FINAL_STATE = require('./completion-authority-check.cjs');
 
 function emitBlock(reason) {
   process.stdout.write(`${JSON.stringify({ decision: 'block', reason })}\n`);
@@ -46,7 +42,7 @@ try {
   }
   const POLICY = loaded.policy;
   const { projectRoot, runtime } = getHookContext(payload);
-  if (typeof POLICY.completionDecisionForSpec !== 'function') {
+  if (typeof POLICY.deriveRuntimeContext !== 'function') {
     throw new Error('shared workflow policy lacks completion authority functions');
   }
   const resolver = require('./lib/spec-utils.cjs');
@@ -54,9 +50,7 @@ try {
   // the payload leaves, which is what made the block unescapable on this runtime too.
   const target = resolver.extractExplicitTarget(payload)
     || resolver.readActiveFeatureTarget({ projectRoot, runtime });
-  let resolved = typeof resolver.resolveWorkflowCandidate === 'function'
-    ? resolver.resolveWorkflowCandidate({ projectRoot, runtime, target, includeCompleted: true })
-    : FINAL_STATE.resolveCandidate({ resolver, projectRoot, runtime, payload });
+  let resolved = resolver.resolveWorkflowCandidate({ projectRoot, runtime, target, includeCompleted: true });
   if (typeof resolver.refineWorkflowGateResolution === 'function') {
     resolved = resolver.refineWorkflowGateResolution(resolved);
   }
@@ -76,7 +70,7 @@ try {
     const lines = [`Completion gate: ${checked.failures.length} done task(s) lack a verification receipt.`];
     for (const failure of checked.failures) {
       lines.push(`- \`${failure.featureName}/${failure.taskPath}\`: failed check(s) ${failure.failures.join(', ')}`);
-      lines.push(`  In \`specs/${failure.featureName}/${failure.taskPath}\`: ${receiptFixHint(failure.failures) || 'write a runtime-bound `## Receipt` with the planned command'}.`);
+      lines.push(`  In \`specs/${failure.featureName}/${failure.taskPath}\`: ${receiptFixHint(failure.failures, failure.body) || 'write a runtime-bound `## Receipt` with the planned command'}.`);
     }
     emitBlock(lines.slice(0, 8).join('\n'));
     process.exit(0);
@@ -91,7 +85,7 @@ try {
   if (resolved.error === 'invalid_specs') {
     process.stdout.write(`${JSON.stringify({
       decision: 'block',
-      reason: `Completion gate: invalid spec JSON detected (${resolved.candidates.join(', ')}): ${resolved.reason}. Fix or remove malformed spec.json before completing tasks.`
+      reason: `Completion gate: invalid workflow packet detected (${resolved.candidates.join(', ')}): ${resolved.reason}. Fix the packet's plan.md or task files before completing tasks.`
     })}\n`);
     process.exit(0);
   }
@@ -104,28 +98,10 @@ try {
   }
   if (resolved.error) process.exit(0);
   const active = resolved;
-  const activeSpec = active.spec || {};
-  const processWorkflow = active.layoutKind === 'process-v3';
-  const lifecyclePhase = activeSpec.current_phase || activeSpec.phase;
-  const explicitCloseout = ['done', 'completed', 'complete'].includes(activeSpec.status)
-    || ['closeout', 'completion', 'completed', 'complete'].includes(lifecyclePhase);
-  if (!processWorkflow && activeSpec.schema_version === '2.1') {
-    const finalState = FINAL_STATE.evaluateCloseout({
-      policy: POLICY,
-      projectRoot,
-      runtime,
-      payload: { ...payload, session_id: sessionIdentity(payload) },
-    });
-    if (!finalState.ok) {
-      emitBlock(`Completion gate: ${finalState.reason}`);
-      process.exit(0);
-    }
-    if (finalState.active) process.exit(0);
-  }
   const runtimeContext = POLICY.deriveRuntimeContext({
     projectRoot,
     specsRoot: active.specsDir,
-    specFile: active.stateFile || active.specFile || path.join(active.specsDir, active.featureName, 'spec.json'),
+    specFile: active.stateFile,
     featureName: active.featureName,
     runtimeSession: sessionIdentity(payload),
   });
@@ -134,10 +110,10 @@ try {
     emitBlock('Completion gate: runtime.spec.completion_gate is a worker-writable flag, not an authorization; no completion-gate bypass is supported. Remove the flag and satisfy the gate.');
     process.exit(0);
   }
-  const registry = active.taskRegistry || activeSpec.task_registry || {};
-  const currentStatuses = processWorkflow
-    ? Object.fromEntries(Object.entries(registry).map(([taskPath, task]) => [taskPath, task?.status || 'pending']))
-    : taskStatusMap(activeSpec);
+  const registry = active.taskRegistry || {};
+  const currentStatuses = Object.fromEntries(
+    Object.entries(registry).map(([taskPath, task]) => [taskPath, task?.status || 'pending']),
+  );
   const cacheFile = path.join(hookStateDir(projectRoot), 'spec-gate-last.json');
   const cacheExists = fs.existsSync(cacheFile);
   let cache = {};
@@ -163,16 +139,6 @@ try {
   const previous = cacheExists && cacheEntries[runtimeContext.context_id]
     ? cacheEntries[runtimeContext.context_id].tasks || {}
     : {};
-  const staleFlashTasks = processWorkflow ? [] : Object.entries(registry)
-    .filter(([, task]) => POLICY.isStaleFlashDone(task))
-    .map(([taskPath]) => taskPath);
-  if (staleFlashTasks.length > 0) {
-    process.stdout.write(`${JSON.stringify({
-      decision: 'block',
-      reason: `Completion gate: ${staleFlashTasks.length} task(s) marked done with FLASH_UNVERIFIED (${staleFlashTasks.join(', ')}). Run /cf:test, then use explicit sync-finalize.`
-    })}\n`);
-    process.exit(0);
-  }
   const allDoneTasks = Object.keys(registry).filter((taskPath) => (
     currentStatuses[taskPath] === 'done'
   ));
@@ -180,9 +146,7 @@ try {
   const receiptBodies = new Map();
   const failures = allDoneTasks
     .map((taskPath) => {
-      const proof = processWorkflow
-        ? checkWorkflowReceiptDetails(featureDir, taskPath, runtimeContext)
-        : checkReceiptDetails(featureDir, taskPath, registry[taskPath], runtimeContext);
+      const proof = checkWorkflowReceiptDetails(featureDir, taskPath, runtimeContext);
       if (proof.body) receiptBodies.set(taskPath, proof.body);
       return {
         taskPath,
@@ -191,52 +155,20 @@ try {
     })
     .filter((result) => result.failures.length);
 
-  const featureCloseoutRequired = !processWorkflow && explicitCloseout && allDoneTasks.length > 0;
-  const featureReceipt = featureCloseoutRequired
-    ? checkFeatureReceipt(featureDir, runtimeContext)
-    : null;
-  if (featureReceipt && featureReceipt.failures.length) {
-    failures.push({ taskPath: 'feature-receipt.md', failures: featureReceipt.failures });
-  }
-  const completion = featureCloseoutRequired && featureReceipt?.failures.length === 0
-    && Object.prototype.hasOwnProperty.call(active.spec, 'workflow_policy')
-    ? POLICY.completionDecisionForSpec(active.spec, {
-      runtimeContext,
-      executionReceipt: featureReceipt.body,
-      taskContext: {},
-    })
-    : null;
-
   const next = { ...previous, ...currentStatuses };
   for (const result of failures) {
     if (previous[result.taskPath] === undefined) delete next[result.taskPath];
     else next[result.taskPath] = previous[result.taskPath];
   }
   atomicWrite(cacheFile, `${JSON.stringify({
-    schema_version: '2',
     entries: { ...cacheEntries, [runtimeContext.context_id]: { identity: cacheIdentity, tasks: next } },
   })}\n`);
 
-  const completionBlocked = completion && completion.completion !== 'complete' && completion.completion !== 'not_applicable';
-  if (!failures.length && !completionBlocked) process.exit(0);
-  const lines = [
-    failures.length > 0
-      ? `Completion gate: ${failures.length} done task(s) lack a verification receipt.`
-      : 'Completion gate: workflow completion proof is incomplete.'
-  ];
+  if (!failures.length) process.exit(0);
+  const lines = [`Completion gate: ${failures.length} done task(s) lack a verification receipt.`];
   for (const result of failures) {
     lines.push(`- \`${result.taskPath}\`: failed check(s) ${result.failures.join(', ')}`);
-    lines.push(result.taskPath === 'feature-receipt.md'
-      ? `  Run final integration proof, then write \`specs/${active.featureName}/feature-receipt.md\`.`
-      : processWorkflow
-        ? `  In \`specs/${active.featureName}/${path.posix.basename(result.taskPath)}\`: ${receiptFixHint(result.failures) || 'write a runtime-bound `## Receipt` with command output'}.`
-        : `  Write canonical proof to \`specs/${active.featureName}/receipts/${path.posix.basename(result.taskPath)}\`; legacy \`## Evidence\` remains read-compatible.`);
-  }
-  if (completionBlocked) {
-    lines.push(`- Completion decision unfinished: ${completion.blocker || 'required workflow proof is missing.'}`);
-    if (Array.isArray(completion.missingProof) && completion.missingProof.length > 0) {
-      lines.push(`  Missing proof: ${completion.missingProof.join(', ')}`);
-    }
+    lines.push(`  In \`specs/${active.featureName}/${path.posix.basename(result.taskPath)}\`: ${receiptFixHint(result.failures, result.body) || 'write a runtime-bound `## Receipt` with command output'}.`);
   }
   process.stdout.write(`${JSON.stringify({
     decision: 'block',

package/src/codex/hooks/spec-state.cjs

@@ -40,7 +40,28 @@ try {
   const RECEIPT = receiptLoaded.receipt;
   const { projectRoot, runtime } = getHookContext(payload);
   if (runtime.spec?.tollgate === false) process.exit(0);
-  const { resolveWorkflowCandidate } = require('./lib/spec-utils.cjs');
+  const { findLegacyPackets, resolveWorkflowCandidate } = require('./lib/spec-utils.cjs');
+  const sessionId = payload.session_id || payload.sessionId || payload.sessionID || payload.session?.id;
+  // A legacy packet (a specs/<x>/ directory without plan.md that the old flow left
+  // behind) is no longer read. Say so once per session instead of on every prompt.
+  const legacyPackets = findLegacyPackets(projectRoot, runtime);
+  if (legacyPackets.length > 0) {
+    const noticeFile = sessionId
+      ? path.join(hookStateDir(projectRoot), `legacy-notice-${crypto.createHash('sha256').update(String(sessionId)).digest('hex').slice(0, 16)}.json`)
+      : null;
+    let noticed = [];
+    if (noticeFile) {
+      try { noticed = JSON.parse(fs.readFileSync(noticeFile, 'utf8')); } catch { noticed = []; }
+      if (!Array.isArray(noticed)) noticed = [];
+    }
+    const fresh = legacyPackets.filter((name) => !noticed.includes(name));
+    for (const name of fresh) {
+      process.stdout.write(`> ⚠️ \`specs/${name}\` is a legacy Specs packet without plan.md; CafeKit no longer reads it. Move ongoing work to a process-first plan.md packet.\n`);
+    }
+    if (noticeFile && fresh.length > 0) {
+      try { atomicWrite(noticeFile, `${JSON.stringify([...noticed, ...fresh].sort())}\n`); } catch { /* repeats the notice */ }
+    }
+  }
   const explicitFeature = payload.featureName || payload.feature || payload.explicitFeature || null;
   const explicitPath = payload.specPath || payload.spec_path || payload.featurePath || null;
   const resolved = resolveWorkflowCandidate(projectRoot, runtime, explicitFeature, explicitPath);
@@ -50,7 +71,7 @@ try {
     process.exit(0);
   }
   if (resolved.error === 'invalid_specs') {
-    process.stdout.write(`> ⚠️ Invalid spec JSON detected: ${resolved.candidates.join(', ')}. ${resolved.reason}. Fix or remove malformed spec.json. Tollgate paused.\n`);
+    process.stdout.write(`> ⚠️ Invalid workflow packet detected: ${resolved.candidates.join(', ')}. ${resolved.reason}. Fix the packet's plan.md or task files. Tollgate paused.\n`);
     process.exit(0);
   }
   if (resolved.error === 'explicit_not_found' || resolved.error === 'explicit_malformed') {
@@ -60,18 +81,16 @@ try {
   }
   if (resolved.error) process.exit(0);
   const active = resolved;
-  const processWorkflow = active.layoutKind === 'process-v3';
   const runtimeContext = POLICY.deriveRuntimeContext({
     projectRoot,
     specsRoot: active.specsDir,
-    specFile: active.stateFile || active.specFile || path.join(active.specsDir, active.featureName, 'spec.json'),
+    specFile: active.stateFile,
     featureName: active.featureName,
-    runtimeSession: payload.session_id || payload.sessionId || payload.sessionID || payload.session?.id,
+    runtimeSession: sessionId,
   });
 
-  const phase = active.phase || active.spec?.current_phase || active.spec?.phase || 'unknown';
-  const taskRegistry = active.taskRegistry || active.spec?.task_registry || {};
-  const flashTasks = POLICY.flashState(taskRegistry);
+  const phase = active.phase || 'unknown';
+  const taskRegistry = active.taskRegistry || {};
   const tasks = Object.entries(taskRegistry);
   const counts = tasks.reduce((result, [, task]) => {
     const status = task?.status || 'pending';
@@ -79,13 +98,7 @@ try {
     return result;
   }, {});
   const featureDir = path.join(active.specsDir, active.featureName);
-  const statuses = new Map(tasks.map(([taskPath, task]) => [
-    taskPath,
-    task?.status || 'pending'
-  ]));
-  const dependencyProof = processWorkflow
-    ? RECEIPT.workflowDependencyProofState(featureDir, taskRegistry, runtimeContext, POLICY)
-    : {};
+  const dependencyProof = RECEIPT.workflowDependencyProofState(featureDir, taskRegistry, runtimeContext, POLICY);
   const taskState = tasks.map(([taskPath, task]) => [
     taskPath,
     task?.status || 'pending',
@@ -101,12 +114,8 @@ try {
   const next = tasks.find(([, task]) => (
     active.queueReady !== false
     && (task?.status || 'pending') === 'pending'
-    && (task?.dependencies || []).every((dependency) => (
-      processWorkflow ? dependencyProof[dependency]?.eligible === true : statuses.get(dependency) === 'done'
-    ))
+    && (task?.dependencies || []).every((dependency) => dependencyProof[dependency]?.eligible === true)
   ));
-  const featureReceiptPresent = !processWorkflow
-    && RECEIPT.safeRead(featureDir, 'feature-receipt.md').status === 'ok';
   const stateKey = JSON.stringify({
     project_root: runtimeContext.project_root,
     specs_root: runtimeContext.specs_root,
@@ -124,14 +133,13 @@ try {
     proof_state: proofState,
     done: counts.done || 0,
     total: tasks.length,
-    feature_receipt_present: featureReceiptPresent,
   });
   const cache = cacheFile(projectRoot, runtimeContext.runtime_session);
   let previous = '';
   try { previous = fs.readFileSync(cache, 'utf8').trim(); } catch { /* first run */ }
 
   if (previous === stateKey) {
-    const migration = processWorkflow && active.queueReady === false
+    const migration = active.queueReady === false
       ? ' Add `Specs-Contract: process-first-ready-v1` after the plan title before tasks can enter Next.'
       : '';
     process.stdout.write(
@@ -147,26 +155,14 @@ try {
     `- Phase: \`${phase}\` | Tasks: ${counts.done || 0} done / ${tasks.length} total`
   ];
   if (next) lines.push(`- Next unblocked: \`${next[0]}\``);
-  if (flashTasks.length > 0) {
-    lines.push(`- Flash verification pending: ${flashTasks.map((taskPath) => `\`${taskPath}\``).join(', ')}. A PASS proof keeps the persisted task in_progress until explicit sync-finalize.`);
-  }
-  if (processWorkflow) {
-    if (active.queueReady === false) {
-      lines.push('- Migration required: add `Specs-Contract: process-first-ready-v1` after the plan title before tasks can enter Next.');
-    }
-    lines.push(
-      '- Sync each flat task `Status:` only after verified work; task proof belongs in that task\'s inline `## Receipt`.',
-      `- Workflow source: \`specs/${active.featureName}/plan.md\`; Stop re-checks every done receipt, binding Base/Head to the runtime only while a committed task file no longer matches its committed bytes.`,
-      '- Hooks revalidate receipt bytes but never grant approval.'
-    );
-  } else {
-    lines.push(
-      '- Sync `spec.json` and task Markdown status only after verified work; task proof belongs in `receipts/<task-basename>.md`.',
-      `- Create \`feature-receipt.md\` once after final integration proof${featureReceiptPresent ? ' (present)' : ' (not required before closeout)'}.`,
-      `- Validate with \`node .codex/scripts/validate-spec-output.cjs specs/${active.featureName}\`.`,
-      '- Hooks revalidate receipt bytes but never grant approval.'
-    );
+  if (active.queueReady === false) {
+    lines.push('- Migration required: add `Specs-Contract: process-first-ready-v1` after the plan title before tasks can enter Next.');
   }
+  lines.push(
+    '- Sync each flat task `Status:` only after verified work; task proof belongs in that task\'s inline `## Receipt`.',
+    `- Workflow source: \`specs/${active.featureName}/plan.md\`; Stop re-checks every done receipt, binding Base/Head to the runtime only while a committed task file no longer matches its committed bytes.`,
+    '- Hooks revalidate receipt bytes but never grant approval.'
+  );
   process.stdout.write(`${lines.join('\n')}\n`);
 } catch (error) {
   logCrash('spec-state', error);

package/src/codex/hooks.json

@@ -48,11 +48,6 @@
             "command": "node \".codex/hooks/privacy-approval.cjs\"",
             "commandWindows": "node \".codex/hooks/privacy-approval.cjs\""
           },
-          {
-            "type": "command",
-            "command": "node \".codex/hooks/completion-authority.cjs\"",
-            "commandWindows": "node \".codex/hooks/completion-authority.cjs\""
-          },
           {
             "type": "command",
             "command": "node \".codex/hooks/rules.cjs\"",
@@ -79,11 +74,6 @@
             "type": "command",
             "command": "node \".codex/hooks/inspect-block.cjs\"",
             "commandWindows": "node \".codex/hooks/inspect-block.cjs\""
-          },
-          {
-            "type": "command",
-            "command": "node \".codex/hooks/task-scaffold-guard.cjs\"",
-            "commandWindows": "node \".codex/hooks/task-scaffold-guard.cjs\""
           }
         ]
       }
@@ -108,11 +98,6 @@
             "command": "node \".codex/hooks/spec-gate.cjs\"",
             "commandWindows": "node \".codex/hooks/spec-gate.cjs\""
           },
-          {
-            "type": "command",
-            "command": "node \".codex/hooks/completion-authority.cjs\"",
-            "commandWindows": "node \".codex/hooks/completion-authority.cjs\""
-          },
           {
             "type": "command",
             "command": "node \".codex/hooks/state.cjs\"",
@@ -125,11 +110,6 @@
       {
         "matcher": "*",
         "hooks": [
-          {
-            "type": "command",
-            "command": "node \".codex/hooks/semantic-review-authority.cjs\"",
-            "commandWindows": "node \".codex/hooks/semantic-review-authority.cjs\""
-          },
           {
             "type": "command",
             "command": "node \".codex/hooks/state.cjs\"",

package/src/codex/rules/state-sync.md

@@ -51,19 +51,10 @@ proves only the boundary it executed.
 
 ## Human gates and workflow ownership
 
-- C1 records the user's scope decision before the plan is written.
-- C2 records the user's disposition of deduplicated adversarial findings.
+- GATE-SCOPE records the user's scope decision before the plan is written.
+- GATE-REVIEW records the user's disposition of deduplicated adversarial findings.
 - Develop starts only after a new explicit user invocation and executes one
   unblocked task at a time.
 - Sync changes only observed file state and never starts implementation.
-- C3 occurs after current receipts and limitations are shown; the user decides
+- GATE-DONE occurs after current receipts and limitations are shown; the user decides
   whether the requested feature is complete.
-
-## Legacy compatibility
-
-Existing packets containing `spec.json`, nested `tasks/task-R*.md`, or other
-legacy kernel artifacts stay on their installed adapters. Preserve their
-`task_registry`, `semantic_model`, `planning_depth`, lane,
-`execution_tier`, typed topology, separate receipts, and feature closeout
-contract. Do not migrate that machine authority or storage shape while syncing
-an unrelated process-first packet.