@haposoft/cafekit 0.16.0-rc.2 → 0.16.0-rc.4

package/src/codex/hooks/lib/hook-context.cjs

@@ -5,11 +5,27 @@ const fs = require('fs');
 const path = require('path');
 
 // Installed layout: <project>/.codex/hooks/lib/hook-context.cjs
-const PROJECT_ROOT = path.resolve(__dirname, '..', '..', '..');
+// Canonicalize installed project root via realpath where available; lexical fallback keeps source-tree tests working.
+// This ensures a symlink project root (e.g., /tmp/link -> /real/project) is resolved to its real location,
+// keeping assertConfiguredSpecsPath and state paths consistent with resolveSessionCwd's realpath.
+// Installed-root authority stays PROJECT_ROOT (now canonical); do not change without updating state/approval paths.
+const PROJECT_ROOT = (() => {
+  const lexical = path.resolve(__dirname, '..', '..', '..');
+  try {
+    return fs.realpathSync(lexical);
+  } catch {
+    return lexical;
+  }
+})();
 
 function readPayload() {
   const raw = fs.readFileSync(0, 'utf8').trim();
-  return raw ? JSON.parse(raw) : null;
+  if (!raw) throw new Error('hook payload is empty');
+  const payload = JSON.parse(raw);
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('hook payload must be a JSON object');
+  }
+  return payload;
 }
 
 function resolveSessionCwd(payload) {
@@ -35,11 +51,45 @@ function readRuntime(projectRoot = PROJECT_ROOT) {
   }
 }
 
+function assertConfiguredSpecsPath(projectRoot, runtime) {
+  const configured = runtime?.paths?.specs;
+  if (configured !== undefined && (typeof configured !== 'string' || configured.trim() === '')) {
+    throw new Error('runtime.paths.specs must be a non-empty path');
+  }
+  const requested = configured || 'specs';
+  const root = path.resolve(projectRoot);
+  const resolved = path.resolve(root, requested);
+  const relative = path.relative(root, resolved);
+  if (relative !== '' && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) {
+    throw new Error('configured specs root escapes project root');
+  }
+  let probe = resolved;
+  try {
+    while (!fs.existsSync(probe)) {
+      const parent = path.dirname(probe);
+      if (parent === probe) break;
+      probe = parent;
+    }
+    const rootReal = fs.realpathSync(root);
+    const probeReal = fs.realpathSync(probe);
+    const canonicalRelative = path.relative(rootReal, probeReal);
+    if (canonicalRelative !== '' && (canonicalRelative === '..' || canonicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(canonicalRelative))) {
+      throw new Error('configured specs root traverses outside project root');
+    }
+  } catch (error) {
+    if (/configured specs root/.test(error.message)) throw error;
+    throw new Error(`configured specs root cannot be validated (${error.message})`);
+  }
+  return resolved;
+}
+
 function getHookContext(payload) {
+  const runtime = readRuntime(PROJECT_ROOT);
+  assertConfiguredSpecsPath(PROJECT_ROOT, runtime);
   return {
     projectRoot: PROJECT_ROOT,
     sessionCwd: resolveSessionCwd(payload),
-    runtime: readRuntime(PROJECT_ROOT)
+    runtime
   };
 }
 
@@ -65,7 +115,10 @@ function atomicWrite(file, content, mode = 0o600) {
 
 function logCrash(hook, error) {
   try {
-    const dir = path.join(PROJECT_ROOT, '.codex', 'hooks', '.logs');
+    const isSourceTree = PROJECT_ROOT.includes(`${path.sep}packages${path.sep}spec${path.sep}src`);
+    const dir = isSourceTree
+      ? path.join(require('os').tmpdir(), 'cafekit-hook-logs', 'codex', hook)
+      : path.join(PROJECT_ROOT, '.codex', 'hooks', '.logs');
     fs.mkdirSync(dir, { recursive: true });
     fs.appendFileSync(
       path.join(dir, 'hook-log.jsonl'),
@@ -88,6 +141,7 @@ module.exports = {
   logCrash,
   readPayload,
   readRuntime,
+  assertConfiguredSpecsPath,
   resolveProjectPath,
   resolveSessionCwd
 };

package/src/codex/hooks/lib/privacy-command-analysis.cjs

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../../../claude/hooks/lib/privacy-command-analysis.cjs');

package/src/codex/hooks/lib/privacy-state.cjs

@@ -3,12 +3,31 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const PATH_SAFETY = require('./runtime-path-safety.cjs');
 
 const TTL_MS = 5 * 60 * 1000;
 const APPROVAL_PREFIX = 'APPROVE CAFEKIT PRIVACY ';
 function stateDir(projectRoot) {
   return path.join(projectRoot, '.codex', 'hooks', '.privacy');
 }
+function secureStateDir(projectRoot, create = false) {
+  const root = PATH_SAFETY.canonicalDirectory(projectRoot, 'privacy project root');
+  const hooks = path.join(root, '.codex', 'hooks');
+  try { PATH_SAFETY.assertComponentPath(root, hooks); }
+  catch (error) {
+    if (!create && error.code === 'ENOENT') return null;
+    throw error;
+  }
+  const dir = path.join(hooks, '.privacy');
+  if (create && !fs.existsSync(dir)) fs.mkdirSync(dir, { mode: 0o700 });
+  try { PATH_SAFETY.assertComponentPath(root, dir); }
+  catch (error) {
+    if (!create && error.code === 'ENOENT') return null;
+    throw error;
+  }
+  if (!fs.lstatSync(dir).isDirectory()) throw new Error('privacy state must be a regular directory');
+  return dir;
+}
 function hash(value) {
   return crypto.createHash('sha256').update(String(value)).digest('hex');
 }
@@ -44,16 +63,16 @@ function displayNames(filePaths) {
     : `${names.slice(0, 3).join(', ')} (+${names.length - 3} more)`;
 }
 
-function atomicWrite(file, payload) {
-  const dir = path.dirname(file);
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+function atomicWrite(dir, file, payload) {
+  PATH_SAFETY.assertComponentPath(dir, path.dirname(file));
   const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
   fs.writeFileSync(temp, `${JSON.stringify(payload)}\n`, { encoding: 'utf8', mode: 0o600 });
   fs.renameSync(temp, file);
 }
 
-function readJson(file) {
+function readJson(dir, file) {
   try {
+    PATH_SAFETY.assertComponentPath(dir, file);
     return JSON.parse(fs.readFileSync(file, 'utf8'));
   } catch {
     return null;
@@ -61,12 +80,12 @@ function readJson(file) {
 }
 
 function cleanup(projectRoot, now = Date.now()) {
-  const dir = stateDir(projectRoot);
-  if (!fs.existsSync(dir)) return;
+  const dir = secureStateDir(projectRoot);
+  if (!dir) return;
   for (const name of fs.readdirSync(dir)) {
     if (!/^(pending|token)-[a-f0-9]+\.json$/.test(name)) continue;
     const file = path.join(dir, name);
-    const record = readJson(file);
+    const record = readJson(dir, file);
     if (!record || Number(record.expiresAt) <= now) {
       try {
         fs.unlinkSync(file);
@@ -78,9 +97,9 @@ function cleanup(projectRoot, now = Date.now()) {
 }
 
 function clearState(projectRoot) {
-  const dir = stateDir(projectRoot);
   try {
-    if (!fs.existsSync(dir)) return;
+    const dir = secureStateDir(projectRoot);
+    if (!dir) return;
     for (const name of fs.readdirSync(dir)) {
       if (/^(pending|token)-[a-f0-9]+\.json$/.test(name)) {
         try { fs.unlinkSync(path.join(dir, name)); } catch { /* concurrently consumed */ }
@@ -113,7 +132,8 @@ function createPending({
     toolName: String(toolName || ''),
     expiresAt: Date.now() + TTL_MS
   };
-  atomicWrite(path.join(stateDir(projectRoot), `pending-${requestId}.json`), record);
+  const dir = secureStateDir(projectRoot, true);
+  atomicWrite(dir, path.join(dir, `pending-${requestId}.json`), record);
   return record;
 }
 
@@ -122,8 +142,10 @@ function approvePending({ projectRoot, sessionId, requestId }) {
   if (!sessionId) return { ok: false, reason: 'session' };
   if (!/^[a-f0-9]{24}$/.test(requestId)) return { ok: false, reason: 'invalid' };
 
-  const pendingFile = path.join(stateDir(projectRoot), `pending-${requestId}.json`);
-  const record = readJson(pendingFile);
+  const dir = secureStateDir(projectRoot);
+  if (!dir) return { ok: false, reason: 'missing' };
+  const pendingFile = path.join(dir, `pending-${requestId}.json`);
+  const record = readJson(dir, pendingFile);
   if (!record) return { ok: false, reason: 'missing' };
   if (record.sessionId !== String(sessionId || '')) return { ok: false, reason: 'session' };
   if (Number(record.expiresAt) <= Date.now()) return { ok: false, reason: 'expired' };
@@ -134,7 +156,7 @@ function approvePending({ projectRoot, sessionId, requestId }) {
     return { ok: false, reason: 'consumed' };
   }
 
-  atomicWrite(path.join(stateDir(projectRoot), `token-${requestId}.json`), {
+  atomicWrite(dir, path.join(dir, `token-${requestId}.json`), {
     version: 2,
     requestId,
     sessionId: record.sessionId,
@@ -155,8 +177,8 @@ function consumeToken({
 }) {
   cleanup(projectRoot);
   if (!sessionId) return false;
-  const dir = stateDir(projectRoot);
-  if (!fs.existsSync(dir)) return false;
+  const dir = secureStateDir(projectRoot);
+  if (!dir) return false;
   const paths = requestPaths(filePaths, filePath);
   if (paths.length === 0) return false;
   const expectedPaths = requestPathKeys(paths, sessionCwd);
@@ -164,7 +186,7 @@ function consumeToken({
   for (const name of fs.readdirSync(dir)) {
     if (!/^token-[a-f0-9]{24}\.json$/.test(name)) continue;
     const tokenFile = path.join(dir, name);
-    const token = readJson(tokenFile);
+    const token = readJson(dir, tokenFile);
     if (
       !token ||
       token.sessionId !== String(sessionId || '') ||

package/src/codex/hooks/lib/runtime-path-safety.cjs

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../../../claude/hooks/lib/runtime-path-safety.cjs');

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

@@ -3,129 +3,100 @@
 const fs = require('fs');
 const path = require('path');
 
-const EVIDENCE_NAMES = [
-  'Evidence',
-  'Task Test Plan & Verification Evidence',
-  'Verification & Evidence'
-];
-const PASS_MARKER = /^\s*Verification:\s*PASS\s*$/m;
-const LEGACY_SUCCESS = /^\s*(?:PASS(?:ED)?|✓)(?:\s*:|$)|exit\s+code\s*[:=]?\s*0\b/im;
-const EXPLICIT_FAILURE = /\bFAIL(?:ED|URE|URES|ING)?\b|tests?\s+failed|exit\s+code\s*[:=]?\s*[1-9]\d*|\b0\s+tests?\b/i;
-
-function evidenceBody(text) {
-  const lines = text.split('\n');
-  let start = -1;
-  let level = 0;
-  for (let index = 0; index < lines.length; index += 1) {
-    const match = lines[index].match(/^(#{2,3})\s+(.+?)\s*$/);
-    if (match && EVIDENCE_NAMES.includes(match[2])) {
-      start = index + 1;
-      level = match[1].length;
-      break;
-    }
-  }
-  if (start < 0) return null;
-  let end = lines.length;
-  for (let index = start; index < lines.length; index += 1) {
-    const heading = lines[index].match(/^(#{1,6})\s+/);
-    if (heading && heading[1].length <= level) {
-      end = index;
-      break;
-    }
+function loadModule(installedName, sourceName, validate, missingMessage) {
+  const installed = path.join(__dirname, '../../scripts', installedName);
+  const source = path.join(__dirname, '../../../claude/scripts', sourceName);
+  const candidates = fs.existsSync(installed) ? [installed] : [source];
+  let lastError = new Error(missingMessage);
+  for (const candidate of candidates) {
+    try {
+      const value = require(candidate);
+      validate(value);
+      return { value, error: null, path: candidate };
+    } catch (error) { lastError = error; }
   }
-  return lines.slice(start, end).join('\n');
+  return { value: null, error: lastError, path: candidates[0] };
 }
 
-function safeTaskFile(featureDir, taskPath) {
-  const target = path.resolve(featureDir, taskPath);
-  const relative = path.relative(featureDir, target);
-  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return null;
-  return target;
+function loadSharedPolicy() {
+  const loaded = loadModule(
+    'workflow-policy.cjs',
+    'workflow-policy.cjs',
+    (policy) => {
+      if (typeof policy?.validateCanonicalReceipt !== 'function') {
+        throw new Error('shared workflow policy has no validateCanonicalReceipt function');
+      }
+    },
+    'shared workflow policy is missing'
+  );
+  return { policy: loaded.value, error: loaded.error, path: loaded.path };
 }
 
-function validateCanonicalReceipt(body) {
-  const failures = [];
-  if (!/^\s*Verification:\s*PASS\s*$/m.test(body)) {
-    failures.push('verification_state');
-  }
-  if (!/^\s*Command(?:\(s\))?\s*:/m.test(body)) {
-    failures.push('command');
-  }
-  if (!/^\s*Exit\s*:|exit\s+code\s*[:=]|\bResult\s*:\s*PASS\b/im.test(body)) {
-    failures.push('exit_result');
-  }
-  const hasBase = /^\s*Base[ \t]*:[ \t]*\S/im.test(body);
-  const hasHead = /^\s*Head[ \t]*:[ \t]*\S/im.test(body);
-  const hasBaseSha = /\bbase_sha[ \t]*:[ \t]*\S/im.test(body);
-  const hasHeadSha = /\bhead_sha[ \t]*:[ \t]*\S/im.test(body);
-  if (!((hasBase && hasHead) || (hasBaseSha && hasHeadSha))) {
-    failures.push('provenance');
-  }
-  if (/\bartifact\b/i.test(body) && !/sha256:/i.test(body)) {
-    failures.push('artifact_hash');
-  }
-  return failures;
+function loadSharedReceipt() {
+  const loaded = loadModule(
+    'spec-receipt.cjs',
+    'spec-receipt.cjs',
+    (receipt) => {
+      if (typeof receipt?.checkTaskReceipt !== 'function') {
+        throw new Error('shared spec receipt helper has no checkTaskReceipt function');
+      }
+    },
+    'shared spec receipt helper is missing'
+  );
+  return { receipt: loaded.value, error: loaded.error, path: loaded.path };
 }
 
-function checkReceipt(featureDir, taskPath, task) {
-  const failures = [];
-  const file = safeTaskFile(featureDir, taskPath);
-  if (!file || !fs.existsSync(file)) return ['a'];
-  let text = '';
-  try { text = fs.readFileSync(file, 'utf8'); } catch { return ['a']; }
+function getSharedPolicy() { return loadSharedPolicy().policy; }
+function getSharedValidate() { return getSharedPolicy()?.validateCanonicalReceipt || null; }
 
-  const status = text.split('\n')
-    .find((line) => /^\s*(?:\*\*)?Status(?:\*\*)?\s*:/i.test(line));
-  if (!status || !/\bdone\b/i.test(status)) failures.push('a');
-
-  const body = evidenceBody(text);
-  if (body === null) {
-    failures.push('b');
-  } else if (
-    /\{\{[^}]+\}\}/.test(body)
-    || EXPLICIT_FAILURE.test(body)
-    || !(PASS_MARKER.test(body) || LEGACY_SUCCESS.test(body))
-  ) {
-    failures.push('c');
-  } else {
-    // Canonical receipt requirements: command, exit/result, provenance, unambiguous PASS
-    // For done tasks, require canonical fields. If missing, add e/f/g.
-    const canonical = validateCanonicalReceipt(body);
-    // Map canonical failures to letters e,f,g,h for backward compat checks
-    // Use detailed names but also add letters for gate reporting
-    const map = {
-      verification_state: 'c', // already covers but keep distinct
-      command: 'e',
-      exit_result: 'f',
-      provenance: 'g',
-      artifact_hash: 'h',
-    };
-    for (const fail of canonical) {
-      const letter = map[fail];
-      // Avoid duplicating c if already failed, but add specific
-      if (fail === 'verification_state' && failures.includes('c')) continue;
-      if (fail === 'verification_state') {
-        // This should have been caught by c, but if PASS present via legacy, still need strict PASS
-        if (!PASS_MARKER.test(body)) failures.push('c');
-        continue;
-      }
-      if (letter && !failures.includes(letter)) failures.push(letter);
-    }
-    // Additional strict check: legacy success alone is not sufficient for canonical
-    // If body contains only legacy PASS but not canonical Verification: PASS, c already would have caught if no PASS_MARKER?
-    // But we allow legacy for backward compat in c, but canonical requires PASS_MARKER, so we must enforce.
-    if (!PASS_MARKER.test(body)) {
-      if (!failures.includes('c')) failures.push('c');
-    }
-  }
+function receiptHelper() {
+  const loaded = loadSharedReceipt();
+  if (!loaded.receipt) throw loaded.error;
+  return loaded.receipt;
+}
 
-  const completedAt = task?.completed_at;
-  if (
-    typeof completedAt !== 'string'
-    || !/^\d{4}-\d{2}-\d{2}T/.test(completedAt)
-    || Number.isNaN(Date.parse(completedAt))
-  ) failures.push('d');
-  return failures;
+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;
+}
+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 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 readTaskProof(featureDir, taskPath) {
+  return receiptHelper().readTaskProof(featureDir, taskPath, getSharedPolicy() || {});
 }
 
-module.exports = { checkReceipt, evidenceBody, safeTaskFile, validateCanonicalReceipt };
+module.exports = {
+  checkFeatureReceipt,
+  checkReceipt,
+  checkReceiptDetails,
+  evidenceBody,
+  getSharedPolicy,
+  getSharedValidate,
+  loadSharedPolicy,
+  loadSharedReceipt,
+  readTaskProof,
+  safeTaskFile,
+  validateCanonicalReceipt,
+};

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

@@ -2,49 +2,126 @@
 
 const fs = require('fs');
 const path = require('path');
-const { resolveProjectPath } = require('./hook-context.cjs');
+const PATH_SAFETY = require('./runtime-path-safety.cjs');
+
+// Save original fs methods at load time to avoid being affected by test monkey patches
+// that simulate runtime canonicalization failures for spec paths. Resolver discovery
+// must use these originals, while spec resolution uses the (possibly patched) fs.
+const originalLstatSync = fs.lstatSync;
+
+// Installed Codex hooks use .codex/scripts; source tests use the Claude-side
+// source path. If an installed resolver exists but is malformed, do not fall
+// back to another copy: the shared authority is unavailable.
+const RESOLVER_CANDIDATES = [
+  {
+    file: path.join(__dirname, '../../scripts/spec-resolver.cjs'),
+    root: path.resolve(__dirname, '../..'),
+  },
+  {
+    file: path.join(__dirname, '../../../claude/scripts/spec-resolver.cjs'),
+    root: path.resolve(__dirname, '../../..'),
+  },
+];
+
+function canonicalRealpath(candidate) {
+  try {
+    return PATH_SAFETY.canonicalRegularFile(candidate.root, candidate.file, 'shared spec resolver');
+  } catch (error) {
+    throw new Error(`${error.message} (${candidate.file})`);
+  }
+}
+
+function findCandidate() {
+  // Fail closed if preferred installed resolver exists but is invalid; never silently fall back to source.
+  const primary = RESOLVER_CANDIDATES[0];
+  let primaryExists = false;
+  try {
+    originalLstatSync(primary.file);
+    primaryExists = true;
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw new Error(`resolver check failed: ${e.message} (${primary.file})`);
+  }
+  if (primaryExists) {
+    canonicalRealpath(primary);
+    return primary;
+  }
+  const secondary = RESOLVER_CANDIDATES[1];
+  let secondaryExists = false;
+  try {
+    originalLstatSync(secondary.file);
+    secondaryExists = true;
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw new Error(`resolver check failed: ${e.message} (${secondary.file})`);
+  }
+  if (secondaryExists) {
+    canonicalRealpath(secondary);
+    return secondary;
+  }
+  return null;
+}
+
+function sharedResolver() {
+  const candidate = findCandidate() || RESOLVER_CANDIDATES[0];
+  try {
+    // 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');
+    }
+    return resolver;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message} (${candidate.file})`);
+  }
+}
 
 function specsDirectory(projectRoot, runtime) {
-  return resolveProjectPath(
+  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.paths?.specs,
-    'specs'
-  );
+    runtime,
+    explicitFeature,
+    explicitPath,
+  });
 }
 
 function findActiveSpec(projectRoot, runtime) {
-  const specsDir = specsDirectory(projectRoot, runtime);
-  if (!fs.existsSync(specsDir)) return null;
-  const entries = fs.readdirSync(specsDir, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .sort((left, right) => left.name.localeCompare(right.name));
-
-  for (const entry of entries) {
-    const file = path.join(specsDir, entry.name, 'spec.json');
-    if (!fs.existsSync(file)) continue;
-    try {
-      const spec = JSON.parse(fs.readFileSync(file, 'utf8'));
-      if (spec.status === 'in_progress' || spec.status === 'in-progress') {
-        return { featureName: entry.name, spec, specsDir };
-      }
-    } catch {
-      // Ignore an unrelated malformed spec and continue discovery.
-    }
-  }
-  return null;
+  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'
-    ])
+      task?.status || 'pending',
+    ]),
   );
 }
 
 module.exports = {
   findActiveSpec,
+  findAllActiveSpecs,
+  findAllSpecCandidates,
+  resolveActiveSpec,
   specsDirectory,
-  taskStatusMap
+  taskStatusMap,
 };

package/src/codex/hooks/privacy-approval.cjs

@@ -24,7 +24,7 @@ try {
   const data = readPayload();
   if (!data) process.exit(0);
   const { projectRoot } = getHookContext(data);
-  const prompt = String(data.prompt || '').trim();
+  const prompt = String(data.prompt || '');
   cleanup(projectRoot);
 
   if (!prompt.startsWith(APPROVAL_PREFIX)) process.exit(0);