genesis-compiler 1.2.19 → 1.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.19",
+  "version": "1.2.20",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
   "repository": {

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

@@ -1,6 +1,6 @@
 {
   "name": "genesis",
-  "version": "1.2.19",
+  "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

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

@@ -257,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;
   }

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,7 +159,8 @@ 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 changing project files for a user-requested implementation, run `genesis hook authorize`. Never authorize answer, explanation, review, or diagnosis-only turns.',
+      '- 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 an authorized code-changing turn, Genesis may request separate post-change, explanation, and cleanup turns.',
       `Engineering profile: ${engineering.profile?.id || 'invalid; run \`genesis check\`'}.`,
@@ -236,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 });
 }
@@ -247,14 +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',
     implementationAuthorized: false,
-    snapshot: await repositorySnapshot(root),
+    repositories,
+    snapshot: repositories.length > 0 && existing?.snapshot
+      ? existing.snapshot
+      : await repositorySnapshot(root),
   };
   await writeTurnState(statePath, state);
+  await writeHookLocator(input, root);
   return { status: 'recorded' };
 }
 
@@ -265,6 +285,41 @@ 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,
@@ -275,15 +330,52 @@ export async function authorizeCodexTurn({
       'genesis hook authorize requires the current Codex session.',
     );
   }
+  const input = { session_id: sessionId };
   const root = (await gitContext(projectRoot)).repositoryRoot;
-  const statePath = await hookStatePath(root, { session_id: sessionId });
+  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') {
-    return { status: 'not-applicable' };
+    throw new GenesisError(
+      'CODEX_HOOK_TURN_UNAVAILABLE',
+      'No active Genesis implementation turn is available. Start from the session repository and authorize before editing.',
+    );
   }
-  if (state.implementationAuthorized === true) return { status: 'unchanged' };
-  await writeTurnState(statePath, { ...state, implementationAuthorized: true });
-  return { status: 'authorized' };
+  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) {
@@ -329,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',
+    'REPOSITORIES AND CHANGED PROJECT PATHS',
     '',
-    ...changedPathLines(changedPaths),
-    '',
-    'COMPOSED STACK POST-CHANGE WORK',
+    ...changedRepositoryLines(repositories),
     '',
-    stack.postChange,
+    'REPOSITORY GUIDANCE AND POST-CHANGE WORK',
     '',
-    'ENGINEERING APPROACH',
-    '',
-    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',
     '',
@@ -405,6 +542,10 @@ async function deslopContinuation(projectRoot, changedPaths) {
   ].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);
@@ -412,93 +553,98 @@ export async function completeCodexTurn({ input, projectRoot } = {}) {
   if (!state || state.schemaVersion !== HOOK_STATE_SCHEMA_VERSION) return {};
 
   if (state.implementationAuthorized !== true) {
-    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: '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 rm(statePath, { force: true });
+    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' };
 }