@haposoft/cafekit 0.18.0 → 0.18.2

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

@@ -4,6 +4,7 @@ const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const PATH_SAFETY = require('./runtime-path-safety.cjs');
+const { displayNames } = require('./privacy-paths.cjs');
 
 // Codex cannot raise an interactive prompt from a hook -- PreToolUse honours no
 // "ask" decision -- so approval costs a full round trip: the agent has to relay
@@ -61,13 +62,6 @@ function samePathKeys(left, right) {
     && left.every((value, index) => value === right[index]);
 }
 
-function displayNames(filePaths) {
-  const names = [...new Set(filePaths.map((filePath) => path.basename(filePath)))].sort();
-  return names.length <= 3
-    ? names.join(', ')
-    : `${names.slice(0, 3).join(', ')} (+${names.length - 3} more)`;
-}
-
 function atomicWrite(dir, file, payload) {
   PATH_SAFETY.assertComponentPath(dir, path.dirname(file));
   const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
@@ -84,14 +78,81 @@ function readJson(dir, file) {
   }
 }
 
+function validPending(record, sessionId, requestId, now = Date.now()) {
+  return record?.requestId === requestId && record.sessionId === sessionId
+    && Number.isFinite(record.expiresAt) && record.expiresAt > now
+    && typeof record.displayName === 'string' && record.displayName.length > 0
+    && Array.isArray(record.pathKeys) && record.pathKeys.length > 0
+    && record.pathKeys.every(key => typeof key === 'string' && /^[a-f0-9]{64}$/.test(key));
+}
+
+function writeShortMarker(dir, record) {
+  const { requestId, sessionId, expiresAt } = record;
+  fs.writeFileSync(path.join(dir, `short-${hash(sessionId)}-${requestId}.json`),
+    `${JSON.stringify({ requestId, sessionId, expiresAt })}\n`,
+    { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+}
+
+/** Each prompt owns only markers it successfully renamed, never a shared mutable flag. */
+function claimShortMarkers(projectRoot, sessionId) {
+  const requestIds = [];
+  if (typeof sessionId !== 'string' || !sessionId.trim()) return { ok: true, requestIds };
+  const dir = secureStateDir(projectRoot);
+  if (!dir) return { ok: true, requestIds };
+  const prefix = `short-${hash(sessionId)}-`;
+  let ok = true;
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.startsWith(prefix) || !name.endsWith('.json')) continue;
+    const file = path.join(dir, name);
+    const claimed = path.join(dir, `claim-${crypto.randomBytes(12).toString('hex')}.tmp`);
+    const requestId = name.slice(prefix.length, -'.json'.length);
+    let moved = false;
+    try {
+      PATH_SAFETY.assertComponentPath(dir, file);
+      fs.renameSync(file, claimed);
+      moved = true;
+      requestIds.push(requestId);
+      PATH_SAFETY.assertComponentPath(dir, claimed);
+      const marker = JSON.parse(fs.readFileSync(claimed, 'utf8'));
+      if (!/^[a-f0-9]{24}$/.test(requestId) || marker.requestId !== requestId
+        || marker.sessionId !== sessionId || !Number.isFinite(marker.expiresAt)
+        || marker.expiresAt <= Date.now()) throw new Error('Invalid short approval marker');
+    } catch {
+      ok = false;
+      if (!moved) {
+        // A failed claim cancels the shortcut; deletion never counts as ownership.
+        try { fs.unlinkSync(file); }
+        catch {
+          let descriptor;
+          try {
+            PATH_SAFETY.canonicalRegularFile(dir, file, 'short approval marker');
+            descriptor = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW);
+            fs.ftruncateSync(descriptor, 0);
+          } catch { /* no permission follows a failed invalidation */ }
+          finally {
+            if (descriptor !== undefined) {
+              try { fs.closeSync(descriptor); } catch { /* already rejected */ }
+            }
+          }
+        }
+      }
+    } finally {
+      if (moved) {
+        try { fs.unlinkSync(claimed); } catch { ok = false; }
+      }
+    }
+  }
+  return { ok, requestIds };
+}
+
 function cleanup(projectRoot, now = Date.now()) {
   const dir = secureStateDir(projectRoot);
   if (!dir) return;
   for (const name of fs.readdirSync(dir)) {
-    if (!/^(pending|token)-[a-f0-9]+\.json$/.test(name)) continue;
+    if (!/^(?:(?:pending|token)-[a-f0-9]+|short-[a-f0-9]{64}-[a-f0-9]{24})\.json$/.test(name)) continue;
     const file = path.join(dir, name);
     const record = readJson(dir, file);
-    if (!record || Number(record.expiresAt) <= now) {
+    if (!record || !Number.isFinite(record.expiresAt) || record.expiresAt <= now) {
       try {
         fs.unlinkSync(file);
       } catch {
@@ -101,13 +162,20 @@ function cleanup(projectRoot, now = Date.now()) {
   }
 }
 
-function clearState(projectRoot) {
+function clearState(projectRoot, sessionId) {
   try {
+    if (typeof sessionId !== 'string' || !sessionId.trim()) return;
     const dir = secureStateDir(projectRoot);
     if (!dir) return;
     for (const name of fs.readdirSync(dir)) {
+      if (name.startsWith(`short-${hash(sessionId)}-`) && name.endsWith('.json')) {
+        try { fs.unlinkSync(path.join(dir, name)); } catch { /* concurrently claimed */ }
+        continue;
+      }
       if (/^(pending|token)-[a-f0-9]+\.json$/.test(name)) {
-        try { fs.unlinkSync(path.join(dir, name)); } catch { /* concurrently consumed */ }
+        const file = path.join(dir, name);
+        if (readJson(dir, file)?.sessionId !== sessionId) continue;
+        try { fs.unlinkSync(file); } catch { /* concurrently consumed */ }
       }
     }
   } catch {
@@ -123,26 +191,38 @@ function createPending({
   filePath
 }) {
   cleanup(projectRoot);
-  if (!sessionId) throw new Error('A Codex session ID is required');
+  if (typeof sessionId !== 'string' || !sessionId.trim()) throw new Error('A Codex session ID is required');
   const paths = requestPaths(filePaths, filePath);
   if (paths.length === 0) throw new Error('At least one sensitive path is required');
+  const pathKeys = requestPathKeys(paths, sessionCwd);
+  const dir = secureStateDir(projectRoot, true);
+  for (const name of fs.readdirSync(dir)) {
+    const match = name.match(/^pending-([a-f0-9]{24})\.json$/);
+    if (!match) continue;
+    const pending = readJson(dir, path.join(dir, name));
+    if (validPending(pending, sessionId, match[1]) && samePathKeys(pending.pathKeys, pathKeys)) {
+      try { writeShortMarker(dir, pending); }
+      catch (error) { if (error.code !== 'EEXIST') throw error; }
+      return pending;
+    }
+  }
   const requestId = crypto.randomBytes(12).toString('hex');
   const record = {
     version: 2,
     requestId,
     sessionId: String(sessionId || ''),
-    pathKeys: requestPathKeys(paths, sessionCwd),
+    pathKeys,
     displayName: displayNames(paths),
     expiresAt: Date.now() + TTL_MS
   };
-  const dir = secureStateDir(projectRoot, true);
   atomicWrite(dir, path.join(dir, `pending-${requestId}.json`), record);
+  writeShortMarker(dir, record);
   return record;
 }
 
 function approvePending({ projectRoot, sessionId, requestId }) {
   cleanup(projectRoot);
-  if (!sessionId) return { ok: false, reason: 'session' };
+  if (typeof sessionId !== 'string' || !sessionId.trim()) return { ok: false, reason: 'session' };
   if (!/^[a-f0-9]{24}$/.test(requestId)) return { ok: false, reason: 'invalid' };
 
   const dir = secureStateDir(projectRoot);
@@ -152,6 +232,7 @@ function approvePending({ projectRoot, sessionId, requestId }) {
   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' };
+  if (!validPending(record, sessionId, requestId)) return { ok: false, reason: 'invalid' };
 
   try {
     fs.unlinkSync(pendingFile);
@@ -218,5 +299,6 @@ module.exports = {
   approvePending,
   hasGrant,
   cleanup,
-  clearState
+  clearState,
+  claimShortMarkers
 };

package/src/codex/hooks/lib/rules-reservation.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { hookStateDir } = require('./hook-context.cjs');
+
+function reservationFile(projectRoot, sessionId) {
+  const key = crypto.createHash('sha256')
+    .update(String(sessionId || 'unknown'))
+    .digest('hex')
+    .slice(0, 16);
+  return path.join(hookStateDir(projectRoot), `rules-${key}.json`);
+}
+
+/** Reserve one injection slot per session. Returns null on reservation errors. */
+function reserveSession(projectRoot, sessionId) {
+  if (!sessionId) return null;
+  try {
+    const file = reservationFile(projectRoot, sessionId);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ sessionId: String(sessionId) }), {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o600
+    });
+    return true;
+  } catch (error) {
+    return error.code === 'EEXIST' ? false : null;
+  }
+}
+
+function clearSessionReservation(projectRoot, sessionId) {
+  if (!sessionId) return;
+  try { fs.rmSync(reservationFile(projectRoot, sessionId), { force: true }); } catch { /* fail-open */ }
+}
+
+module.exports = { reserveSession, clearSessionReservation };

package/src/codex/hooks/lib/secret-keywords.cjs

@@ -0,0 +1 @@
+module.exports = require('../../../claude/hooks/lib/secret-keywords.cjs');

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, body) {
   const helper = receiptHelper();
   return typeof helper.receiptFixHint === 'function' ? helper.receiptFixHint(failures, body) : null;
 }
-function readTaskProof(featureDir, taskPath) {
-  return receiptHelper().readTaskProof(featureDir, taskPath, getSharedPolicy() || {});
-}
 
 module.exports = {
-  checkFeatureReceipt,
-  checkReceipt,
-  checkReceiptDetails,
   checkWorkflowReceiptDetails,
   checkWorkflowReceiptSet,
-  evidenceBody,
   getSharedPolicy,
   getSharedValidate,
   loadSharedPolicy,
   loadSharedReceipt,
-  readTaskProof,
   receiptFixHint,
   safeTaskFile,
   validateCanonicalReceipt,

package/src/codex/hooks/lib/spec-session-touch.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { packetAt, namedPackets, explicitFailure } = require('./spec-touch.cjs');
+const { atomicWrite, assertConfiguredSpecsPath, hookStateDir } = require('./hook-context.cjs');
+
+function sessionIdentity(payload) {
+  return [payload.session_id, payload.sessionId, payload.sessionID, payload.session?.id]
+    .find((value) => typeof value === 'string' && value.trim()) || null;
+}
+
+function patchPaths(command) {
+  if (typeof command !== 'string') return [];
+  const lines = command.trim().split(/\r?\n/);
+  if (lines.shift() !== '*** Begin Patch' || lines.pop() !== '*** End Patch') return [];
+  const paths = [];
+  let operation = null;
+  let body = false;
+  for (const line of lines) {
+    const header = line.match(/^\*\*\* (Add|Update|Delete) File: (.+)$/);
+    if (header) {
+      if (operation && operation !== 'Delete' && !body) return [];
+      operation = header[1]; body = operation === 'Delete';
+      paths.push(header[2]);
+    } else if (/^\*\*\* Move to: .+/.test(line) && operation === 'Update' && !body) {
+      paths.push(line.slice('*** Move to: '.length));
+    } else if (operation === 'Add' && /^\+/.test(line)) {
+      body = true;
+    } else if (operation === 'Update' && /^(?:@@|[ +\-]|\*\*\* End of File$)/.test(line)) {
+      body = true;
+    } else {
+      return [];
+    }
+  }
+  return operation && body ? paths : [];
+}
+
+function responseText(response) {
+  if (typeof response === 'string') return response;
+  if (!response || typeof response !== 'object') return '';
+  const value = response.output ?? response.result ?? response.message ?? response.content;
+  if (typeof value === 'string') return value;
+  return Array.isArray(value) ? value.map((item) => item?.text || '').join('\n') : '';
+}
+
+function successfulMutation(payload) {
+  const response = payload.tool_response;
+  if (payload.hook_event_name !== 'PostToolUse' || explicitFailure(payload) || response == null) return false;
+  const text = responseText(response).trim();
+  if (/^(?:error\b|failed\b|failure\b|apply_patch verification failed)/im.test(text)) return false;
+  // Contract: github.com/openai/codex/blob/main/codex-rs/core/src/tools/context.rs
+  // Native ApplyPatchToolOutput emits a string summary to PostToolUse, whereas its
+  // code-mode return is {}. Unknown/empty output is not observed successful mutation.
+  const nativeSuccess = /^Success\. Updated the following files:\r?\n[AMD] .+/m.test(text);
+  if (payload.tool_name === 'apply_patch') return nativeSuccess;
+  return nativeSuccess || response?.ok === true || response?.success === true
+    || /^(?:success\b|.*\bupdated successfully[.!]?\s*$)/i.test(text);
+}
+
+function mutationPaths(payload) {
+  if (!successfulMutation(payload)) return [];
+  const input = payload.tool_input || {};
+  if (payload.tool_name === 'apply_patch') return patchPaths(input.command);
+  if (!['Edit', 'Write', 'MultiEdit'].includes(payload.tool_name)) return [];
+  return [input.file_path, input.path, ...(Array.isArray(input.edits) ? input.edits.map((edit) => edit?.file_path || edit?.path) : [])]
+    .filter((value) => typeof value === 'string');
+}
+
+function touchSession(payload, context) {
+  const sessionId = sessionIdentity(payload);
+  const specsRoot = assertConfiguredSpecsPath(context.projectRoot, context.runtime);
+  if (!sessionId) return { sessionId, names: [], touched: [], specsRoot };
+  const key = crypto.createHash('sha256').update(`${context.projectRoot}\0${sessionId}`).digest('hex');
+  const file = path.join(hookStateDir(context.projectRoot), `spec-touched-${key}.json`);
+  let previous = [];
+  try { previous = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { /* first touch */ }
+  const touched = new Set(Array.isArray(previous) ? previous.filter((name) => typeof name === 'string') : []);
+  let names;
+  if (payload.hook_event_name === 'PostToolUse') {
+    names = mutationPaths(payload).map((value) => packetAt(value, specsRoot, context.sessionCwd)).filter(Boolean);
+  } else {
+    let packets = [];
+    try { packets = fs.readdirSync(specsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name); } catch { /* absent root */ }
+    names = namedPackets(payload.prompt || payload.user_prompt, packets, specsRoot, context.projectRoot);
+    const feature = payload.explicitFeature ?? payload.featureName ?? payload.feature;
+    if (typeof feature === 'string' && feature.trim() && !/[\\/]/.test(feature) && !['.', '..', '_shared'].includes(feature)) names.push(feature);
+    const explicitPath = payload.explicitPath ?? payload.specPath ?? payload.spec_path ?? payload.featurePath;
+    const fromPath = packetAt(explicitPath, specsRoot, context.projectRoot);
+    if (fromPath) names.push(fromPath);
+  }
+  for (const name of names) touched.add(name);
+  if (names.length) {
+    try { atomicWrite(file, `${JSON.stringify([...touched].sort())}\n`); } catch { /* no shared fallback */ }
+  }
+  return { sessionId, names: [...new Set(names)], touched: [...touched], specsRoot };
+}
+
+module.exports = { touchSession, sessionIdentity };

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

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

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;
@@ -153,14 +118,10 @@ function readActiveFeatureTarget(options) {
 }
 
 module.exports = {
-  findActiveSpec,
   extractExplicitTarget,
+  findLegacyPackets,
   readActiveFeatureTarget,
-  findAllActiveSpecs,
-  findAllSpecCandidates,
-  resolveActiveSpec,
   resolveWorkflowCandidate,
   refineWorkflowGateResolution,
   specsDirectory,
-  taskStatusMap,
 };

package/src/codex/hooks/lib/update-check.cjs

@@ -0,0 +1 @@
+module.exports = require('../../../claude/hooks/lib/update-check.cjs');

package/src/codex/hooks/precompact.cjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { PROJECT_ROOT, atomicWrite, hookStateDir, logCrash, readPayload } = require('./lib/hook-context.cjs');
+
+function gitLine(args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: PROJECT_ROOT, encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim() || null;
+  } catch { return null; }
+}
+
+try {
+  const payload = readPayload();
+  if (!payload) process.exit(0);
+  const sessionId = [payload.session_id, payload.sessionId, payload.sessionID, payload.session?.id]
+    .find(value => typeof value === 'string' && value.trim());
+  if (!sessionId) process.exit(0);
+  const status = gitLine(['status', '--porcelain']);
+  // These anchors are re-derivable facts, never proof or authorization.
+  const record = {
+    captured_at: new Date().toISOString(),
+    session_id: sessionId,
+    trigger: typeof payload.trigger === 'string' ? payload.trigger : null,
+    project_root: PROJECT_ROOT,
+    branch: gitLine(['rev-parse', '--abbrev-ref', 'HEAD']),
+    head: gitLine(['rev-parse', '--short', 'HEAD']),
+    dirty_count: status === null ? null : status.split('\n').filter(line => line.trim()).length,
+  };
+  const key = crypto.createHash('sha256').update(sessionId).digest('hex');
+  atomicWrite(path.join(hookStateDir(PROJECT_ROOT), `compact-recovery-${key}.json`), `${JSON.stringify(record)}\n`);
+} catch (error) {
+  if (error.message === 'hook payload is empty') process.exit(0);
+  logCrash('precompact', error);
+}

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

@@ -1,16 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-const {
-  APPROVAL_PREFIX,
-  approvePending,
-  cleanup
-} = require('./lib/privacy-state.cjs');
-const {
-  getHookContext,
-  readPayload
-} = require('./lib/hook-context.cjs');
-
 function context(message) {
   process.stdout.write(`${JSON.stringify({
     hookSpecificOutput: {
@@ -20,10 +10,20 @@ function context(message) {
   })}\n`);
 }
 
+let projectRoot, sessionId, state;
 try {
+  const { PROJECT_ROOT, readPayload } = require('./lib/hook-context.cjs');
   const data = readPayload();
   if (!data) process.exit(0);
-  const { projectRoot } = getHookContext(data);
+  projectRoot = PROJECT_ROOT;
+  sessionId = data.session_id;
+  let claimed = { ok: false, requestIds: [] };
+  try {
+    state = require('./lib/privacy-state.cjs');
+    claimed = state.claimShortMarkers(projectRoot, sessionId);
+  } catch { /* the outer catch retries invalidation, never approval */ }
+  if (!claimed.ok) throw new Error('Short approval markers could not be claimed safely');
+  const { APPROVAL_PREFIX, approvePending, cleanup } = state;
   // A pasted prompt arrives with whatever whitespace the terminal added around
   // it. Rejecting on a trailing newline made the approval look broken while the
   // id it named was still perfectly valid; the exactness that matters is the
@@ -31,20 +31,25 @@ try {
   const prompt = String(data.prompt || '').trim();
   cleanup(projectRoot);
 
-  if (!prompt.startsWith(APPROVAL_PREFIX)) process.exit(0);
-  if (!data.session_id) {
+  const shortApproval = new Set(['y', 'yes', 'có']).has(prompt.normalize('NFC').toLowerCase());
+  if (!shortApproval && !prompt.startsWith(APPROVAL_PREFIX)) process.exit(0);
+  if (typeof sessionId !== 'string' || !sessionId.trim()) {
     context('CafeKit privacy approval rejected: this hook invocation had no Codex session ID.');
     process.exit(0);
   }
-  const requestId = prompt.slice(APPROVAL_PREFIX.length);
-  if (`${APPROVAL_PREFIX}${requestId}` !== prompt || !/^[a-f0-9]{24}$/.test(requestId)) {
+  let requestId;
+  if (shortApproval) {
+    if (claimed.requestIds.length !== 1) process.exit(0);
+    requestId = claimed.requestIds[0];
+  } else requestId = prompt.slice(APPROVAL_PREFIX.length);
+  if (!/^[a-f0-9]{24}$/.test(requestId)) {
     context('CafeKit privacy approval rejected: the prompt did not exactly match a pending request.');
     process.exit(0);
   }
 
   const result = approvePending({
     projectRoot,
-    sessionId: data.session_id,
+    sessionId,
     requestId
   });
   if (!result.ok) {
@@ -54,10 +59,16 @@ try {
 
   context(
     `User approved the pending sensitive access (${result.displayName}). ` +
-    `The grant is session-bound, bound to exactly those paths, and expires in one hour.`
+    `The grant is session-bound, bound to exactly those paths, and expires in one hour. ` +
+    `Tell the user which paths were just granted (${result.displayName}) before reading them.`
   );
   process.exit(0);
 } catch {
+  try {
+    if (projectRoot && typeof sessionId === 'string' && sessionId.trim()) {
+      (state || require('./lib/privacy-state.cjs')).claimShortMarkers(projectRoot, sessionId);
+    }
+  } catch { /* no approval follows an invalidation failure */ }
   context('CafeKit privacy approval failed safely; no token was issued.');
   process.exit(0);
 }