genesis-compiler 1.2.24 → 1.2.26

package/src/index/codex-hooks.js

@@ -1,82 +1,60 @@
-import { readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import { readInstalledAsset } from './assets.js';
-import { buildProjectIndex } from './code-index.js';
-import { readEngineering, readEngineeringBaseline } from './engineering.js';
 import { GenesisError } from './errors.js';
 import { gitContext } from './git.js';
 import { isProjectContentPath } from './paths.js';
-import { runGit, runGitText } from './process.js';
-import { readStack } from './stack.js';
-import { normalizeRelative, pathState, sha256, stableJson, writeFileAtomic } from './utils.js';
+import { runGit } from './process.js';
+import { normalizeRelative, pathState, writeFileAtomic } from './utils.js';
 
 const HOOKS_PATH = '.codex/hooks.json';
-const HOOK_STATE_SCHEMA_VERSION = 2;
-const HOOK_LOCATOR_SCHEMA_VERSION = 1;
+const PROJECT_HOOK_ACTIONS = ['session', 'begin', 'stop', 'end'];
+
 function hookCommand(action) {
   const local = `const {runCli}=await import('genesis-compiler/cli');process.exitCode=await runCli(['hook','${action}'])`;
   return `if command -v genesis >/dev/null 2>&1; then genesis hook ${action}; else node --input-type=module --eval "${local}"; fi`;
 }
 
-const HOOK_SPECS = [
-  {
-    event: 'SessionStart',
-    command: hookCommand('session'),
-    group: {
-      matcher: '^(startup|resume|clear|compact)$',
-      hooks: [{
-        type: 'command',
-        command: hookCommand('session'),
-        commandWindows: 'genesis hook session',
-        timeout: 5,
-        statusMessage: 'Loading Genesis guidance',
-        additionalContextLimit: 4000,
-      }],
-    },
-  },
-  {
-    event: 'UserPromptSubmit',
-    command: hookCommand('begin'),
-    group: {
-      hooks: [{
-        type: 'command',
-        command: hookCommand('begin'),
-        commandWindows: 'genesis hook begin',
-        timeout: 10,
-      }],
-    },
-  },
-  {
-    event: 'Stop',
-    command: hookCommand('stop'),
-    group: {
-      hooks: [{
-        type: 'command',
-        command: hookCommand('stop'),
-        commandWindows: 'genesis hook stop',
-        timeout: 30,
-        statusMessage: 'Checking whether Genesis follow-up work is needed',
-      }],
-    },
+const SESSION_HOOK = {
+  event: 'SessionStart',
+  group: {
+    matcher: '^(startup|clear|compact)$',
+    hooks: [{
+      type: 'command',
+      command: hookCommand('session'),
+      commandWindows: 'genesis hook session',
+      timeout: 5,
+      statusMessage: 'Loading Genesis guidance',
+      additionalContextLimit: 4000,
+    }],
   },
-  {
-    event: 'SessionEnd',
-    command: hookCommand('end'),
-    group: {
-      hooks: [{
-        type: 'command',
-        command: hookCommand('end'),
-        commandWindows: 'genesis hook end',
-        timeout: 3,
-      }],
-    },
-  },
-];
+};
+
+const OBSOLETE_PROJECT_HOOK_COMMANDS = new Set(PROJECT_HOOK_ACTIONS.flatMap((action) => [
+  hookCommand(action),
+  `genesis hook ${action}`,
+]));
 
-function genesisHookInstalled(groups, command) {
-  return groups.some((group) => group?.hooks?.some((hook) => hook?.command === command));
+function genesisProjectHook(hook) {
+  return hook && (
+    OBSOLETE_PROJECT_HOOK_COMMANDS.has(hook.command)
+    || OBSOLETE_PROJECT_HOOK_COMMANDS.has(hook.commandWindows)
+  );
+}
+
+function removeGenesisProjectHooks(hooks) {
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) {
+      throw new GenesisError('CODEX_HOOKS_INVALID', `${HOOKS_PATH} hooks.${event} must be an array.`);
+    }
+    const retained = groups.flatMap((group) => {
+      if (!Array.isArray(group?.hooks)) return [group];
+      const groupHooks = group.hooks.filter((hook) => !genesisProjectHook(hook));
+      return groupHooks.length > 0 ? [{ ...group, hooks: groupHooks }] : [];
+    });
+    if (retained.length > 0) hooks[event] = retained;
+    else delete hooks[event];
+  }
 }
 
 async function installedHooksSource(location) {
@@ -101,77 +79,17 @@ export async function installCodexHooks({ projectRoot } = {}) {
   const location = path.join(root, HOOKS_PATH);
   const { source, value } = await installedHooksSource(location);
   value.hooks ||= {};
-  for (const spec of HOOK_SPECS) {
-    const groups = value.hooks[spec.event] ||= [];
-    if (!Array.isArray(groups)) {
-      throw new GenesisError('CODEX_HOOKS_INVALID', `${HOOKS_PATH} hooks.${spec.event} must be an array.`);
-    }
-    if (!genesisHookInstalled(groups, spec.command)) groups.push(spec.group);
-  }
+  removeGenesisProjectHooks(value.hooks);
+  const groups = value.hooks[SESSION_HOOK.event] ||= [];
+  groups.push(SESSION_HOOK.group);
   const rendered = `${JSON.stringify(value, null, 2)}\n`;
   if (source === rendered) return { status: 'unchanged', changedFiles: [] };
   await writeFileAtomic(location, rendered);
   return { status: 'updated', changedFiles: [HOOKS_PATH] };
 }
 
-async function optionalStack(projectRoot) {
-  try { return await readStack(projectRoot); } catch { return null; }
-}
-
-async function optionalEngineering(projectRoot) {
-  try {
-    return await readEngineering(projectRoot);
-  } catch {
-    return {
-      guidance: [
-        '## Universal complexity gate',
-        '',
-        await readEngineeringBaseline(),
-        '',
-        'The project engineering profile is invalid. Do not infer a replacement; run the Genesis `check` operation and ask the user before implementation if the selected approach matters.',
-      ].join('\n'),
-      profile: null,
-      status: 'invalid',
-    };
-  }
-}
-
-export async function codexSessionContext({ projectRoot } = {}) {
-  const root = (await gitContext(projectRoot)).repositoryRoot;
-  const [stack, engineering] = await Promise.all([
-    optionalStack(root),
-    optionalEngineering(root),
-  ]);
-  const selected = stack?.components.map(({ id }) => id) || [];
-  const stackStatus = stack
-    ? (selected.length > 0 ? selected.join(', ') : 'none')
-    : 'unavailable; run the Genesis `check` operation';
-  return {
-    status: 'ready',
-    output: [
-      'This is a Genesis-enriched project.',
-      '- `genesis/blueprint.md` describes non-technical product intent.',
-      '- `genesis/engineering.md` selects the project engineering approach and any project-specific requirements.',
-      '- `genesis/stack.md` selects optional technology guidance and verification.',
-      '- `genesis/program/<subsystem>/` explains public operations and useful internal seams.',
-      '- Project Agent Skills live in `.agents/skills/`; load applicable skills progressively.',
-      '- When this repository is Genesis itself or has local `genesis-compiler`, run every Genesis CLI operation as `npm exec --no -- genesis <arguments>` so the project-pinned version is used without fetching another package. Otherwise use `genesis <arguments>` only when that executable is already available on `PATH`. Never install or update Genesis merely to run a workflow instruction.',
-      '- After locating relevant source files, run the Genesis `context <path...>` operation to load their Program and selected Stack material.',
-      '- Before creating a helper or public operation, run the Genesis `index <name-or-path>` operation and reuse an existing function when it already owns the behavior.',
-      '- `.genesis/machine-city.json` is the detailed code/function map; `.genesis/program-city.json` is the simpler subsystem/operation map.',
-      '- Program is fallible explanation; code, tests, and runtime behavior remain evidence.',
-      '- Before the first project-file edit in a user-requested implementation turn, silently run the Genesis `hook authorize` operation once in every Git repository you will edit. This is internal Genesis bookkeeping, not a request for user permission: do not ask the user, announce successful authorization, or include it in progress or final summaries. Mention it only if the command fails.',
-      '- Authorization is turn-scoped. Run it again for a later code-changing turn after a user follow-up or interruption, but not again within the same active turn after it succeeds. The command must report `authorize: authorized` or `authorize: unchanged`; otherwise stop before editing. Never authorize answer, explanation, review, diagnosis-only, reconciliation, or Deslop turns.',
-      '- Apply the engineering approach below to implementation and cleanup; the Stop hook owns optional Stack Post-change work, Blueprint/Program reconciliation, and Deslop turns.',
-      '- After an authorized code-changing turn, Genesis may request separate post-change, explanation, and cleanup turns.',
-      `Engineering profile: ${engineering.profile?.id || 'invalid; run the Genesis \`check\` operation'}.`,
-      `Selected Stack components: ${stackStatus}.`,
-      '',
-      'ENGINEERING APPROACH',
-      '',
-      engineering.guidance,
-    ].join('\n'),
-  };
+function zeroPaths(buffer) {
+  return [...new Set(buffer.toString('utf8').split('\0').map(normalizeRelative).filter(Boolean))];
 }
 
 export async function codexAdoptionRecommendation({ projectRoot = process.cwd() } = {}) {
@@ -197,512 +115,3 @@ export async function codexAdoptionRecommendation({ projectRoot = process.cwd()
     ].join('\n'),
   };
 }
-
-function hookId(input, field) {
-  const value = input?.[field];
-  if (typeof value !== 'string' || !value || value.length > 512) {
-    throw new GenesisError('CODEX_HOOK_INPUT_INVALID', `Codex hook input requires ${field}.`);
-  }
-  return value;
-}
-
-function normalizedPaths(values = []) {
-  return [...new Set(values.map(normalizeRelative).filter(Boolean))];
-}
-
-function zeroPaths(buffer) {
-  return normalizedPaths(buffer.toString('utf8').split('\0'));
-}
-
-function projectPathStates(projectRoot, files) {
-  return Promise.all(files.map(async (file) => ({
-    path: file,
-    state: await pathState(path.join(projectRoot, file)),
-  })));
-}
-
-async function repositorySnapshot(projectRoot) {
-  const head = await runGitText(projectRoot, ['rev-parse', '--verify', 'HEAD']).catch(() => null);
-  const results = await Promise.all([
-    runGit(projectRoot, ['diff', '--no-ext-diff', '--no-renames', '--name-only', '-z']),
-    runGit(projectRoot, ['diff', '--cached', '--no-ext-diff', '--no-renames', '--name-only', '-z']),
-    runGit(projectRoot, ['ls-files', '-z', '--others', '--exclude-standard']),
-    runGit(projectRoot, ['ls-files', '-z', '--deleted']),
-  ]);
-  const dirty = [...new Set(results.flatMap(({ stdout }) => zeroPaths(stdout)))]
-    .filter(isProjectContentPath)
-    .sort();
-  return {
-    head,
-    dirty: await projectPathStates(projectRoot, dirty),
-  };
-}
-
-async function hookStatePath(projectRoot, input) {
-  const key = sha256(hookId(input, 'session_id')).slice('sha256:'.length);
-  const gitPath = await runGitText(projectRoot, ['rev-parse', '--git-path', `genesis/hooks/${key}.json`]);
-  return path.resolve(projectRoot, gitPath);
-}
-
-function hookLocatorPath(input) {
-  const key = sha256(hookId(input, 'session_id')).slice('sha256:'.length);
-  const user = typeof process.getuid === 'function' ? process.getuid() : 'user';
-  return path.join(tmpdir(), `genesis-codex-hook-${user}-${key}.json`);
-}
-
-function writeTurnState(statePath, state) {
-  return writeFileAtomic(statePath, stableJson(state), { mode: 0o600 });
-}
-
-async function refreshProjectIndex(projectRoot) {
-  await buildProjectIndex({ projectRoot }).catch(() => null);
-}
-
-export async function recordCodexTurn({ input, projectRoot } = {}) {
-  const root = (await gitContext(projectRoot || input?.cwd)).repositoryRoot;
-  const statePath = await hookStatePath(root, input);
-  const turnId = hookId(input, 'turn_id');
-  const existing = await readTurnState(statePath);
-  if (existing?.schemaVersion === HOOK_STATE_SCHEMA_VERSION && existing.turnId === turnId) {
-    await writeHookLocator(input, root);
-    return { status: 'preserved' };
-  }
-  const repositories = registeredRepositories(existing || {}, root);
-  const state = {
-    schemaVersion: HOOK_STATE_SCHEMA_VERSION,
-    turnId,
-    phase: 'implementation',
-    implementationAuthorized: false,
-    repositories,
-    snapshot: repositories.length > 0 && existing?.snapshot
-      ? existing.snapshot
-      : await repositorySnapshot(root),
-  };
-  await writeTurnState(statePath, state);
-  await writeHookLocator(input, root);
-  return { status: 'recorded' };
-}
-
-async function readTurnState(statePath) {
-  try { return JSON.parse(await readFile(statePath, 'utf8')); } catch (error) {
-    if (['ENOENT', 'ENOTDIR'].includes(error?.code)) return null;
-    throw error;
-  }
-}
-
-async function readHookLocator(input) {
-  try { return JSON.parse(await readFile(hookLocatorPath(input), 'utf8')); } catch (error) {
-    if (['ENOENT', 'ENOTDIR'].includes(error?.code)) return null;
-    throw error;
-  }
-}
-
-function writeHookLocator(input, coordinatorRoot) {
-  return writeFileAtomic(hookLocatorPath(input), stableJson({
-    schemaVersion: HOOK_LOCATOR_SCHEMA_VERSION,
-    coordinatorRoot,
-  }), { mode: 0o600 });
-}
-
-async function removeTurnState(statePath, input) {
-  await Promise.all([
-    rm(statePath, { force: true }),
-    rm(hookLocatorPath(input), { force: true }),
-  ]);
-}
-
-function registeredRepositories(state, coordinatorRoot) {
-  if (Array.isArray(state.repositories) && state.repositories.length > 0) {
-    return state.repositories;
-  }
-  if (state.implementationAuthorized === true && state.snapshot) {
-    return [{
-      projectRoot: coordinatorRoot,
-      snapshot: state.snapshot,
-      changedPaths: normalizedPaths(state.changedPaths || []).sort(),
-    }];
-  }
-  return [];
-}
-
-export async function authorizeCodexTurn({
-  projectRoot = process.cwd(),
-  sessionId = process.env.CODEX_SESSION_ID,
-} = {}) {
-  if (!sessionId) {
-    throw new GenesisError(
-      'CODEX_SESSION_ID_MISSING',
-      'genesis hook authorize requires the current Codex session.',
-    );
-  }
-  const input = { session_id: sessionId };
-  const root = (await gitContext(projectRoot)).repositoryRoot;
-  const locator = await readHookLocator(input);
-  if (locator && (
-    locator.schemaVersion !== HOOK_LOCATOR_SCHEMA_VERSION
-    || typeof locator.coordinatorRoot !== 'string'
-    || !locator.coordinatorRoot
-  )) {
-    throw new GenesisError(
-      'CODEX_HOOK_COORDINATOR_INVALID',
-      'The current Codex turn has invalid Genesis coordination state.',
-    );
-  }
-  const coordinatorRoot = locator
-    ? (await gitContext(locator.coordinatorRoot)).repositoryRoot
-    : root;
-  const statePath = await hookStatePath(coordinatorRoot, input);
-  const state = await readTurnState(statePath);
-  if (!state || state.schemaVersion !== HOOK_STATE_SCHEMA_VERSION || state.phase !== 'implementation') {
-    throw new GenesisError(
-      'CODEX_HOOK_TURN_UNAVAILABLE',
-      'No active Genesis implementation turn is available. Start from the session repository and authorize before editing.',
-    );
-  }
-  const repositories = registeredRepositories(state, coordinatorRoot);
-  const registered = repositories.some((repository) => repository.projectRoot === root);
-  if (!registered) {
-    repositories.push({
-      projectRoot: root,
-      snapshot: root === coordinatorRoot && state.snapshot
-        ? state.snapshot
-        : await repositorySnapshot(root),
-      changedPaths: [],
-    });
-  }
-  await writeTurnState(statePath, {
-    ...state,
-    implementationAuthorized: true,
-    repositories,
-  });
-  await writeHookLocator(input, coordinatorRoot);
-  return {
-    status: registered && state.implementationAuthorized === true
-      ? 'unchanged'
-      : 'authorized',
-  };
-}
-
-async function committedPaths(projectRoot, before, after) {
-  if (before === after) return [];
-  if (!after) return ['repository history changed'];
-  try {
-    const args = before
-      ? ['diff', '--no-renames', '--name-only', '-z', before, after]
-      : ['diff-tree', '--root', '--no-commit-id', '--no-renames', '--name-only', '-r', '-z', after];
-    return zeroPaths((await runGit(projectRoot, args)).stdout).filter(isProjectContentPath);
-  } catch {
-    return ['repository history changed'];
-  }
-}
-
-async function changedProjectPaths(projectRoot, before, after) {
-  const previous = new Map(before.dirty.map(({ path: file, state }) => [file, state]));
-  const current = new Map(after.dirty.map(({ path: file, state }) => [file, state]));
-  const dirtyChanges = [...new Set([...previous.keys(), ...current.keys()])].filter((file) => (
-    stableJson(previous.get(file)) !== stableJson(current.get(file))
-  ));
-  const candidates = [...new Set([
-    ...dirtyChanges,
-    ...await committedPaths(projectRoot, before.head, after.head),
-  ])].sort();
-  const changed = await Promise.all(candidates.map(async (file) => {
-    if (!previous.has(file)) return file;
-    // Moving pre-turn file bytes into HEAD is a save operation, not new implementation.
-    const finalState = current.has(file)
-      ? current.get(file)
-      : await pathState(path.join(projectRoot, file));
-    return stableJson(previous.get(file)) === stableJson(finalState) ? null : file;
-  }));
-  return changed.filter(Boolean);
-}
-
-function changedPathLines(changedPaths) {
-  const shown = changedPaths.slice(0, 50);
-  const omitted = changedPaths.length - shown.length;
-  return [
-    ...shown.map((file) => `- ${file}`),
-    ...(omitted > 0 ? [`- ... and ${omitted} more`] : []),
-  ];
-}
-
-function changedRepositoryLines(repositories) {
-  return repositories.flatMap(({ projectRoot, changedPaths, driftedPaths = [] }) => [
-    `## Repository: \`${projectRoot}\``,
-    '',
-    ...changedPathLines(changedPaths),
-    ...(driftedPaths.length > 0 ? [
-      '',
-      '### Concurrent changes excluded from cleanup',
-      '',
-      'These paths changed after the implementation scope was frozen. Report them, but do not edit them:',
-      '',
-      ...changedPathLines(driftedPaths),
-    ] : []),
-    '',
-  ]);
-}
-
-async function changedRepositories(repositories, { snapshotField = 'snapshot' } = {}) {
-  return (await Promise.all(repositories.map(async (repository) => {
-    const currentPaths = await changedProjectPaths(
-      repository.projectRoot,
-      repository[snapshotField] || repository.snapshot,
-      await repositorySnapshot(repository.projectRoot),
-    );
-    const changedPaths = normalizedPaths([
-      ...(repository.changedPaths || []),
-      ...currentPaths,
-    ]).sort();
-    return changedPaths.length > 0 ? { ...repository, changedPaths } : null;
-  }))).filter(Boolean);
-}
-
-async function freezeChangedRepositories(repositories, { startPostChange = false } = {}) {
-  return Promise.all(repositories.map(async (repository) => {
-    const changedPaths = normalizedPaths(repository.changedPaths || []).sort();
-    const [pathStates, phaseSnapshot] = await Promise.all([
-      projectPathStates(repository.projectRoot, changedPaths),
-      startPostChange ? repositorySnapshot(repository.projectRoot) : null,
-    ]);
-    const frozen = {
-      ...repository,
-      changedPaths,
-      pathStates,
-    };
-    delete frozen.driftedPaths;
-    delete frozen.phaseSnapshot;
-    if (phaseSnapshot) frozen.phaseSnapshot = phaseSnapshot;
-    return frozen;
-  }));
-}
-
-async function cleanupScopeRepositories(repositories) {
-  return (await Promise.all(repositories.map(async (repository) => {
-    const ownedPaths = normalizedPaths(repository.changedPaths || []).sort();
-    if (ownedPaths.length === 0) return null;
-    const expected = new Map((repository.pathStates || [])
-      .map(({ path: file, state }) => [file, state]));
-    const changedPaths = [];
-    const driftedPaths = [];
-    for (const { path: file, state } of await projectPathStates(repository.projectRoot, ownedPaths)) {
-      const destination = expected.has(file) && stableJson(expected.get(file)) !== stableJson(state)
-        ? driftedPaths
-        : changedPaths;
-      destination.push(file);
-    }
-    return {
-      ...repository,
-      changedPaths,
-      driftedPaths,
-    };
-  }))).filter(Boolean);
-}
-
-async function repositoryContexts(repositories) {
-  return Promise.all(repositories.map(async (repository) => {
-    const [stack, engineering] = await Promise.all([
-      optionalStack(repository.projectRoot),
-      optionalEngineering(repository.projectRoot),
-    ]);
-    return { ...repository, stack, engineering };
-  }));
-}
-
-function repositoryGuidanceLines({ projectRoot, stack, engineering }, {
-  deslop = false,
-  postChange = false,
-} = {}) {
-  return [
-    `## Repository: \`${projectRoot}\``,
-    '',
-    'ENGINEERING APPROACH',
-    '',
-    engineering.guidance,
-    ...(stack?.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
-    ...(postChange && stack?.postChange
-      ? ['', 'COMPOSED STACK POST-CHANGE WORK', '', stack.postChange]
-      : []),
-    ...(deslop && stack?.deslop
-      ? ['', 'SELECTED STACK CLEANUP GUIDANCE', '', stack.deslop]
-      : []),
-    '',
-  ];
-}
-
-async function reconciliationContinuation(repositories, knownContexts) {
-  const [instructions, contexts] = await Promise.all([
-    readInstalledAsset('reconcile'),
-    knownContexts || repositoryContexts(repositories),
-  ]);
-  return [
-    'This is the automatic Genesis explanation turn for the preceding implementation turn.',
-    'Use the same conversation context and the Git-visible changes below in every listed repository. Do not perform Deslop yet.',
-    '',
-    'REPOSITORIES AND CHANGED PROJECT PATHS',
-    '',
-    ...changedRepositoryLines(repositories),
-    '',
-    instructions.trim(),
-    '',
-    'REPOSITORY GUIDANCE',
-    '',
-    ...contexts.flatMap((context) => repositoryGuidanceLines(context)),
-  ].join('\n');
-}
-
-function postChangeContinuation(repositories, contexts) {
-  return [
-    'This is the one automatic Stack Post-change turn for the preceding implementation.',
-    'Use the same conversation context and the Git-visible changes below in every listed repository.',
-    'Perform only the composed Post-change work. Do not broaden the task, reconcile Genesis explanations, or perform Deslop yet.',
-    'Do not repeat or schedule another Post-change turn. If none of the configured work applies, make no changes and respond minimally.',
-    '',
-    'REPOSITORIES AND CHANGED PROJECT PATHS',
-    '',
-    ...changedRepositoryLines(repositories),
-    '',
-    'REPOSITORY GUIDANCE AND POST-CHANGE WORK',
-    '',
-    ...contexts.flatMap((context) => repositoryGuidanceLines(context, { postChange: true })),
-  ].join('\n');
-}
-
-async function deslopContinuation(repositories) {
-  const [instructions, contexts] = await Promise.all([
-    readInstalledAsset('deslop'),
-    repositoryContexts(repositories),
-  ]);
-  return [
-    'This is the final automatic Genesis Deslop turn for the preceding implementation.',
-    'Review every listed repository and only that work and the paths listed below. Do not broaden the task.',
-    '',
-    'REPOSITORIES AND CHANGED PROJECT PATHS',
-    '',
-    ...changedRepositoryLines(repositories),
-    '',
-    instructions.trim(),
-    '',
-    'REPOSITORY GUIDANCE',
-    '',
-    ...contexts.flatMap((context) => repositoryGuidanceLines(context, { deslop: true })),
-    '',
-    'PROGRAM CITATION MAINTENANCE',
-    '',
-    'If this cleanup renames or moves a source or helper cited by an affected Program module,',
-    'update only that module\'s Sources or informational Implementation map. This narrow',
-    'exception overrides the default prohibition on editing `genesis/`; never change the',
-    'Blueprint or a Program public contract to excuse cleanup behavior.',
-  ].join('\n');
-}
-
-async function refreshProjectIndexes(repositories) {
-  await Promise.all(repositories.map(({ projectRoot }) => refreshProjectIndex(projectRoot)));
-}
-
-export async function completeCodexTurn({ input, projectRoot } = {}) {
-  const root = (await gitContext(projectRoot || input?.cwd)).repositoryRoot;
-  const statePath = await hookStatePath(root, input);
-  const state = await readTurnState(statePath);
-  if (!state || state.schemaVersion !== HOOK_STATE_SCHEMA_VERSION) return {};
-
-  if (state.implementationAuthorized !== true) {
-    const repositories = await changedRepositories(registeredRepositories(state, root));
-    if (repositories.length === 0) {
-      await removeTurnState(statePath, input);
-      return {};
-    }
-    await writeTurnState(statePath, {
-      ...state,
-      phase: 'implementation',
-      repositories,
-    });
-    return {};
-  }
-
-  if (state.phase === 'implementation') {
-    if (input?.stop_hook_active === true || state.turnId !== hookId(input, 'turn_id')) {
-      await removeTurnState(statePath, input);
-      return {};
-    }
-    const changed = await changedRepositories(registeredRepositories(state, root));
-    if (changed.length === 0) {
-      await removeTurnState(statePath, input);
-      return {};
-    }
-    const contexts = await repositoryContexts(changed);
-    const postChange = contexts.some(({ stack }) => Boolean(stack?.postChange?.trim()));
-    const repositories = await freezeChangedRepositories(changed, { startPostChange: postChange });
-    await writeTurnState(statePath, {
-      ...state,
-      phase: postChange ? 'post-change' : 'reconcile',
-      repositories,
-    });
-    return {
-      decision: 'block',
-      reason: postChange
-        ? postChangeContinuation(repositories, contexts)
-        : await reconciliationContinuation(repositories, contexts),
-    };
-  }
-
-  if (input?.stop_hook_active !== true) {
-    await removeTurnState(statePath, input);
-    return {};
-  }
-
-  if (state.phase === 'post-change') {
-    const changed = await changedRepositories(registeredRepositories(state, root), {
-      snapshotField: 'phaseSnapshot',
-    });
-    if (changed.length === 0) {
-      await removeTurnState(statePath, input);
-      return {};
-    }
-    const repositories = await freezeChangedRepositories(changed);
-    await writeTurnState(statePath, {
-      ...state,
-      phase: 'reconcile',
-      repositories,
-    });
-    return {
-      decision: 'block',
-      reason: await reconciliationContinuation(repositories),
-    };
-  }
-
-  if (state.phase === 'reconcile') {
-    const registered = registeredRepositories(state, root);
-    const repositories = await cleanupScopeRepositories(registered);
-    if (repositories.length === 0) {
-      await refreshProjectIndexes(registered);
-      await removeTurnState(statePath, input);
-      return {};
-    }
-    await refreshProjectIndexes(repositories);
-    await writeTurnState(statePath, {
-      ...state,
-      phase: 'deslop',
-      repositories,
-    });
-    return {
-      decision: 'block',
-      reason: await deslopContinuation(repositories),
-    };
-  }
-
-  if (state.phase === 'deslop') {
-    await refreshProjectIndexes(registeredRepositories(state, root));
-    await removeTurnState(statePath, input);
-    return {};
-  }
-
-  await removeTurnState(statePath, input);
-  return {};
-}
-
-export async function discardCodexTurn({ input, projectRoot } = {}) {
-  const root = (await gitContext(projectRoot || input?.cwd)).repositoryRoot;
-  await removeTurnState(await hookStatePath(root, input), input);
-  return { status: 'discarded' };
-}