genesis-compiler 1.2.18 → 1.2.20

package/README.md

@@ -261,26 +261,27 @@ Python, Java, C#, C/C++, PHP, Go, Rust, Ruby, Kotlin, and Shell. A future techno
 adds its adapter through its Stack piece rather than teaching Genesis prompts
 to parse that language.
 
-At the end of a turn that changed Git-visible project files, the Stop hook asks
-Codex for bounded follow-up turns. When the selected Stack contributes
-`Post-change` work, all contributions compose deterministically into one
-optional code-changing turn. Genesis then reconciles the Blueprint and affected
-Program explanations from the complete changed-path set and actual Git diff,
-and refreshes both City projections. A focused, behavior-preserving Deslop pass
-runs before both Cities are refreshed again. Genesis then requests one concise
-user-facing summary using conversation context only; that final phase is not
-Stack-configurable and cannot schedule more cleanup. A project with no selected
-Stack uses only the `genesis-deslop` skill. Selected Stack components enrich
-Post-change work, reconciliation, and cleanup with general Guidance, and enrich
-cleanup further with technology-specific Deslop guidance.
+Before changing project files for a user-requested implementation, Codex runs
+`genesis hook authorize`. At the end of an authorized turn that changed
+Git-visible project files, the Stop hook asks Codex for bounded follow-up turns.
+Unmarked turns finish normally even if another process changes the same
+checkout. When the selected Stack contributes `Post-change` work, all
+contributions compose deterministically into one optional code-changing turn.
+Genesis then reconciles the Blueprint and affected Program explanations from
+the complete changed-path set and actual Git diff, and refreshes both City
+projections. A focused, behavior-preserving Deslop pass runs before both Cities
+are refreshed again; its response is the concise user-facing completion. A
+project with no selected Stack uses only the `genesis-deslop` skill. Selected
+Stack components enrich Post-change work, reconciliation, and cleanup with
+general Guidance, and enrich cleanup further with technology-specific Deslop
+guidance.
 
 The hook never starts another Codex process. Its small per-session phase is
 limited to `implementation -> optional post-change -> reconcile -> deslop ->
-summary -> done`, so it cannot keep continuing recursively. The summary prompt
-forbids repository inspection, tools, commands, tests, and edits, and the next
-Stop always clears the sequence rather than scheduling more work. Empty
-Post-change content is skipped rather than producing an empty turn.
-Question-only and unchanged turns finish normally.
+done`, so it cannot keep continuing recursively. The Stop after Deslop clears
+the sequence rather than scheduling another model turn. Empty Post-change
+content is skipped rather than producing an empty turn. Question, explanation,
+review, diagnosis-only, and unchanged turns finish normally.
 
 Projects can customize a selected technology through its matching file, such
 as `genesis/stack/jskit.md`:

package/docs/prompt-integration.md

@@ -77,20 +77,21 @@ command itself and follows its returned prompt in the same conversation. Other
 hosts can call `adoptProject()` and send its `prompt` directly.
 
 Codex can instead use the project-local hooks installed by `genesis init`.
-Those hooks inject a short operating guide, record whether the current turn
-changed project files, then request bounded continuations. Selected
+Those hooks inject a short operating guide and record the Git-visible state when
+each user prompt begins. Before editing for an explicit user implementation
+request, Codex marks that turn with `genesis hook authorize`. Only an authorized
+turn whose project files changed can request bounded continuations; unmarked
+turns finish normally even if another process changes the checkout. Selected
 `Post-change` contributions compose into one optional code-changing turn;
 Genesis then reconciles Blueprint and affected Program explanations from the
-complete Git-visible change set and Deslops the implementation. One final
-summary prompt then asks for a concise user-facing account from conversation
-context only, forbids tools and edits, and cannot schedule more cleanup. The
-hooks invoke the same Genesis project operations and never start another agent
-process. A per-session phase permits only `implementation -> optional
-post-change -> reconcile -> deslop -> summary -> done`. Empty Post-change
-content skips that phase. Genesis refreshes both City projections after
-reconciliation so Deslop sees the current explanation and function inventory,
-then refreshes them again after Deslop in case cleanup changed the
-implementation map.
+complete Git-visible change set and Deslops the implementation. The Deslop
+response is the concise user-facing completion. The hooks invoke the same
+Genesis project operations and never start another agent process. A per-session
+phase permits only `implementation -> optional post-change -> reconcile ->
+deslop -> done`. Empty Post-change content skips that phase. Genesis refreshes
+both City projections after reconciliation so Deslop sees the current
+explanation and function inventory, then refreshes them again after Deslop in
+case cleanup changed the implementation map.
 
 Once Codex identifies relevant source, `genesis context <path...>` returns only
 Program modules citing those paths plus the effective engineering approach and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.18",
+  "version": "1.2.20",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
   "repository": {
@@ -31,7 +31,6 @@
     "prompts/adopt.txt",
     "prompts/describe.txt",
     "prompts/deslop.txt",
-    "prompts/final-summary.txt",
     "prompts/program.txt",
     "prompts/reconcile.txt",
     "prompts/review.txt",

package/plugins/genesis/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.2.18",
+  "version": "1.2.20",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/prompts/deslop.txt

@@ -1,4 +1,6 @@
-Read and follow `.agents/skills/genesis-deslop/SKILL.md` completely.
+For every repository listed in the task, read and follow that repository's
+`.agents/skills/genesis-deslop/SKILL.md` completely. Review and clean every
+listed repository before responding.
 
 This is a dedicated behavior-preserving cleanup task, separate from
 implementation. Review the requested scope, or otherwise the ordinary Git diff
@@ -19,3 +21,8 @@ changed path or appears related to the preceding implementation.
 
 Do not broaden the product change. Run focused checks when useful and summarize
 what became simpler, files changed, and checks actually run.
+
+Your response from this turn is the final user-facing answer for the original
+request. Make it concise and self-contained. Lead with the outcome, include the
+important implemented behavior and any genuine blocker or unfinished work, and
+do not mention automatic phases, hooks, or these instructions.

package/prompts/reconcile.txt

@@ -1,5 +1,6 @@
-Read and follow `.agents/skills/genesis-program/SKILL.md` completely, operating
-in focused post-change reconciliation mode.
+For every repository listed in the task, read and follow that repository's
+`.agents/skills/genesis-program/SKILL.md` completely, operating in focused
+post-change reconciliation mode.
 
 Use the preceding implementation turn, listed changed paths, actual Git diff or
 history, and relevant tests. Update Blueprint only for intentional observable

package/src/cli.js

@@ -19,6 +19,7 @@ import {
   verify,
 } from './index.js';
 import {
+  authorizeCodexTurn,
   codexAdoptionRecommendation,
   codexSessionContext,
   completeCodexTurn,
@@ -131,8 +132,8 @@ function parseCommand(argv) {
         'Command inspect requires environment or section <name>.',
       );
     }
-  } else if (command === 'hook' && (operands.length !== 1 || !['begin', 'discover', 'end', 'session', 'stop'].includes(operands[0]))) {
-    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session, begin, stop, end.');
+  } else if (command === 'hook' && (operands.length !== 1 || !['authorize', 'begin', 'discover', 'end', 'session', 'stop'].includes(operands[0]))) {
+    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session, begin, authorize, stop, end.');
   } else if (!['adopt', 'context', 'hook', 'index', 'inspect', 'prompt'].includes(command) && operands.length > 0) {
     fail('CLI_EXTRA_ARGUMENT', `Command ${command} accepts no arguments.`);
   }
@@ -256,6 +257,7 @@ function writeResult(command, result) {
   }
   if (command === 'hook') {
     if (['discover', 'session'].includes(result.kind) && result.output) line(process.stdout, result.output);
+    else if (result.kind === 'authorize') line(process.stdout, `authorize: ${result.status}`);
     else if (result.kind === 'stop') line(process.stdout, JSON.stringify(result.output));
     return;
   }
@@ -373,6 +375,9 @@ async function execute({ command, operands, options }, { signal } = {}) {
     if (operands[0] === 'session') {
       return { kind: 'session', ...await codexSessionContext({ projectRoot }) };
     }
+    if (operands[0] === 'authorize') {
+      return { kind: 'authorize', ...await authorizeCodexTurn({ projectRoot }) };
+    }
     const input = await hookInput();
     if (operands[0] === 'begin') {
       return { kind: 'begin', ...await recordCodexTurn({ input, projectRoot }) };

package/src/index/assets.js

@@ -8,7 +8,6 @@ const assets = {
   describe: new URL('prompts/describe.txt', root),
   reconcile: new URL('prompts/reconcile.txt', root),
   deslop: new URL('prompts/deslop.txt', root),
-  finalSummary: new URL('prompts/final-summary.txt', root),
   program: new URL('prompts/program.txt', root),
   blueprint: new URL('prompts/blueprint.txt', root),
   review: new URL('prompts/review.txt', root),

package/src/index/codex-hooks.js

@@ -1,4 +1,5 @@
 import { readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { readInstalledAsset } from './assets.js';
@@ -13,6 +14,7 @@ import { normalizeRelative, pathState, sha256, stableJson, writeFileAtomic } fro
 
 const HOOKS_PATH = '.codex/hooks.json';
 const HOOK_STATE_SCHEMA_VERSION = 2;
+const HOOK_LOCATOR_SCHEMA_VERSION = 1;
 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`;
@@ -157,8 +159,10 @@ export async function codexSessionContext({ projectRoot } = {}) {
       '- Before creating a helper or public operation, run `genesis index <name-or-path>` 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 `genesis hook authorize` 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 a code-changing turn, Genesis may request separate post-change, explanation, cleanup, and final-summary turns.',
+      '- After an authorized code-changing turn, Genesis may request separate post-change, explanation, and cleanup turns.',
       `Engineering profile: ${engineering.profile?.id || 'invalid; run \`genesis check\`'}.`,
       `Selected Stack components: ${stackStatus}.`,
       '',
@@ -235,6 +239,12 @@ async function hookStatePath(projectRoot, input) {
   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 });
 }
@@ -246,13 +256,25 @@ async function refreshProjectIndex(projectRoot) {
 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: hookId(input, 'turn_id'),
+    turnId,
     phase: 'implementation',
-    snapshot: await repositorySnapshot(root),
+    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' };
 }
 
@@ -263,6 +285,99 @@ async function readTurnState(statePath) {
   }
 }
 
+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'];
@@ -306,72 +421,117 @@ function changedPathLines(changedPaths) {
   ];
 }
 
-async function reconciliationContinuation(projectRoot, changedPaths) {
-  const [instructions, stack, engineering] = await Promise.all([
+function changedRepositoryLines(repositories) {
+  return repositories.flatMap(({ projectRoot, changedPaths }) => [
+    `## Repository: \`${projectRoot}\``,
+    '',
+    ...changedPathLines(changedPaths),
+    '',
+  ]);
+}
+
+async function changedRepositories(repositories) {
+  return (await Promise.all(repositories.map(async (repository) => {
+    const currentPaths = await changedProjectPaths(
+      repository.projectRoot,
+      repository.snapshot,
+      await repositorySnapshot(repository.projectRoot),
+    );
+    const changedPaths = normalizedPaths([
+      ...(repository.changedPaths || []),
+      ...currentPaths,
+    ]).sort();
+    return changedPaths.length > 0 ? { ...repository, changedPaths } : null;
+  }))).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'),
-    optionalStack(projectRoot),
-    optionalEngineering(projectRoot),
+    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. Do not perform Deslop yet.',
+    'Use the same conversation context and the Git-visible changes below in every listed repository. Do not perform Deslop yet.',
     '',
-    'CHANGED PROJECT PATHS',
+    'REPOSITORIES AND CHANGED PROJECT PATHS',
     '',
-    ...changedPathLines(changedPaths),
+    ...changedRepositoryLines(repositories),
     '',
     instructions.trim(),
     '',
-    'ENGINEERING APPROACH',
+    'REPOSITORY GUIDANCE',
     '',
-    engineering.guidance,
-    ...(stack?.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
+    ...contexts.flatMap((context) => repositoryGuidanceLines(context)),
   ].join('\n');
 }
 
-function postChangeContinuation(changedPaths, stack, engineering) {
+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.',
+    '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.',
     '',
-    'CHANGED PROJECT PATHS',
-    '',
-    ...changedPathLines(changedPaths),
-    '',
-    'COMPOSED STACK POST-CHANGE WORK',
+    'REPOSITORIES AND CHANGED PROJECT PATHS',
     '',
-    stack.postChange,
+    ...changedRepositoryLines(repositories),
     '',
-    'ENGINEERING APPROACH',
+    'REPOSITORY GUIDANCE AND POST-CHANGE WORK',
     '',
-    engineering.guidance,
-    ...(stack.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
+    ...contexts.flatMap((context) => repositoryGuidanceLines(context, { postChange: true })),
   ].join('\n');
 }
 
-async function deslopContinuation(projectRoot, changedPaths) {
-  const [instructions, stack, engineering] = await Promise.all([
+async function deslopContinuation(repositories) {
+  const [instructions, contexts] = await Promise.all([
     readInstalledAsset('deslop'),
-    optionalStack(projectRoot),
-    optionalEngineering(projectRoot),
+    repositoryContexts(repositories),
   ]);
   return [
     'This is the final automatic Genesis Deslop turn for the preceding implementation.',
-    'Review only that work and the paths listed below. Do not broaden the task.',
+    'Review every listed repository and only that work and the paths listed below. Do not broaden the task.',
     '',
-    'CHANGED PROJECT PATHS',
+    'REPOSITORIES AND CHANGED PROJECT PATHS',
     '',
-    ...changedPathLines(changedPaths),
+    ...changedRepositoryLines(repositories),
     '',
     instructions.trim(),
     '',
-    'ENGINEERING APPROACH',
+    'REPOSITORY GUIDANCE',
     '',
-    engineering.guidance,
-    ...(stack?.guidance ? ['', 'SELECTED STACK GUIDANCE', '', stack.guidance] : []),
-    ...(stack?.deslop ? ['', 'SELECTED STACK CLEANUP GUIDANCE', '', stack.deslop] : []),
+    ...contexts.flatMap((context) => repositoryGuidanceLines(context, { deslop: true })),
     '',
     'PROGRAM CITATION MAINTENANCE',
     '',
@@ -382,8 +542,8 @@ async function deslopContinuation(projectRoot, changedPaths) {
   ].join('\n');
 }
 
-async function finalSummaryContinuation() {
-  return (await readInstalledAsset('finalSummary')).trim();
+async function refreshProjectIndexes(repositories) {
+  await Promise.all(repositories.map(({ projectRoot }) => refreshProjectIndex(projectRoot)));
 }
 
 export async function completeCodexTurn({ input, projectRoot } = {}) {
@@ -392,95 +552,99 @@ export async function completeCodexTurn({ input, projectRoot } = {}) {
   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 rm(statePath, { force: true });
+      await removeTurnState(statePath, input);
       return {};
     }
-    const changedPaths = await changedProjectPaths(root, state.snapshot, await repositorySnapshot(root));
-    if (changedPaths.length === 0) {
-      await rm(statePath, { force: true });
+    const repositories = await changedRepositories(registeredRepositories(state, root));
+    if (repositories.length === 0) {
+      await removeTurnState(statePath, input);
       return {};
     }
-    const [stack, engineering] = await Promise.all([
-      optionalStack(root),
-      optionalEngineering(root),
-    ]);
-    const postChange = Boolean(stack?.postChange?.trim());
+    const contexts = await repositoryContexts(repositories);
+    const postChange = contexts.some(({ stack }) => Boolean(stack?.postChange?.trim()));
     await writeTurnState(statePath, {
       ...state,
       phase: postChange ? 'post-change' : 'reconcile',
-      changedPaths,
+      repositories,
     });
     return {
       decision: 'block',
       reason: postChange
-        ? postChangeContinuation(changedPaths, stack, engineering)
-        : await reconciliationContinuation(root, changedPaths),
+        ? postChangeContinuation(repositories, contexts)
+        : await reconciliationContinuation(repositories, contexts),
     };
   }
 
   if (input?.stop_hook_active !== true) {
-    await rm(statePath, { force: true });
+    await removeTurnState(statePath, input);
     return {};
   }
 
   if (state.phase === 'post-change') {
-    const currentPaths = await changedProjectPaths(root, state.snapshot, await repositorySnapshot(root));
-    const changedPaths = normalizedPaths([...state.changedPaths, ...currentPaths]).sort();
-    if (changedPaths.length === 0) {
-      await rm(statePath, { force: true });
+    const repositories = await changedRepositories(registeredRepositories(state, root));
+    if (repositories.length === 0) {
+      await removeTurnState(statePath, input);
       return {};
     }
     await writeTurnState(statePath, {
       ...state,
       phase: 'reconcile',
-      changedPaths,
+      repositories,
     });
     return {
       decision: 'block',
-      reason: await reconciliationContinuation(root, changedPaths),
+      reason: await reconciliationContinuation(repositories),
     };
   }
 
   if (state.phase === 'reconcile') {
-    const currentPaths = await changedProjectPaths(root, state.snapshot, await repositorySnapshot(root));
-    const changedPaths = normalizedPaths([...state.changedPaths, ...currentPaths]).sort();
-    if (changedPaths.length === 0) {
-      await refreshProjectIndex(root);
-      await rm(statePath, { force: true });
+    const registered = registeredRepositories(state, root);
+    const repositories = await changedRepositories(registered);
+    if (repositories.length === 0) {
+      await refreshProjectIndexes(registered);
+      await removeTurnState(statePath, input);
       return {};
     }
-    await refreshProjectIndex(root);
+    await refreshProjectIndexes(repositories);
     await writeTurnState(statePath, {
       ...state,
       phase: 'deslop',
-      changedPaths,
+      repositories,
     });
     return {
       decision: 'block',
-      reason: await deslopContinuation(root, changedPaths),
+      reason: await deslopContinuation(repositories),
     };
   }
 
   if (state.phase === 'deslop') {
-    await refreshProjectIndex(root);
-    await writeTurnState(statePath, {
-      ...state,
-      phase: 'summary',
-    });
-    return {
-      decision: 'block',
-      reason: await finalSummaryContinuation(),
-    };
+    await refreshProjectIndexes(registeredRepositories(state, root));
+    await removeTurnState(statePath, input);
+    return {};
   }
 
-  await rm(statePath, { force: true });
+  await removeTurnState(statePath, input);
   return {};
 }
 
 export async function discardCodexTurn({ input, projectRoot } = {}) {
   const root = (await gitContext(projectRoot || input?.cwd)).repositoryRoot;
-  await rm(await hookStatePath(root, input), { force: true });
+  await removeTurnState(await hookStatePath(root, input), input);
   return { status: 'discarded' };
 }

package/prompts/final-summary.txt

@@ -1,12 +0,0 @@
-This is the final automatic user-facing summary for the original request.
-
-Use only the existing conversation context from the implementation and its
-follow-up turns. Do not inspect the repository or codebase, call tools, run
-commands or tests, edit files, reconcile explanations, or perform cleanup.
-
-Write one concise, self-contained answer to the user. Lead with the outcome.
-Include the important behavior that changed, checks that were actually run,
-useful human verification steps, and any genuine blocker or unfinished work.
-Do not mention automatic phases, hooks, internal follow-up turns, or these
-instructions. Do not claim checks, commits, pushes, or deployments that are not
-already established in the conversation. After the answer, stop.