genesis-compiler 1.2.18 → 1.2.19

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.19",
   "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.19",
   "description": "Makes Codex aware of optional Genesis adoption for existing projects.",
   "author": {
     "name": "Mobily Enterprises"

package/prompts/deslop.txt

@@ -19,3 +19,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/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.`);
   }
@@ -373,6 +374,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

@@ -157,8 +157,9 @@ 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.',
       '- 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}.`,
       '',
@@ -250,6 +251,7 @@ export async function recordCodexTurn({ input, projectRoot } = {}) {
     schemaVersion: HOOK_STATE_SCHEMA_VERSION,
     turnId: hookId(input, 'turn_id'),
     phase: 'implementation',
+    implementationAuthorized: false,
     snapshot: await repositorySnapshot(root),
   };
   await writeTurnState(statePath, state);
@@ -263,6 +265,27 @@ async function readTurnState(statePath) {
   }
 }
 
+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 root = (await gitContext(projectRoot)).repositoryRoot;
+  const statePath = await hookStatePath(root, { session_id: sessionId });
+  const state = await readTurnState(statePath);
+  if (!state || state.schemaVersion !== HOOK_STATE_SCHEMA_VERSION || state.phase !== 'implementation') {
+    return { status: 'not-applicable' };
+  }
+  if (state.implementationAuthorized === true) return { status: 'unchanged' };
+  await writeTurnState(statePath, { ...state, implementationAuthorized: true });
+  return { status: 'authorized' };
+}
+
 async function committedPaths(projectRoot, before, after) {
   if (before === after) return [];
   if (!after) return ['repository history changed'];
@@ -382,16 +405,17 @@ async function deslopContinuation(projectRoot, changedPaths) {
   ].join('\n');
 }
 
-async function finalSummaryContinuation() {
-  return (await readInstalledAsset('finalSummary')).trim();
-}
-
 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) {
+    await rm(statePath, { force: true });
+    return {};
+  }
+
   if (state.phase === 'implementation') {
     if (input?.stop_hook_active === true || state.turnId !== hookId(input, 'turn_id')) {
       await rm(statePath, { force: true });
@@ -465,14 +489,8 @@ export async function completeCodexTurn({ input, projectRoot } = {}) {
 
   if (state.phase === 'deslop') {
     await refreshProjectIndex(root);
-    await writeTurnState(statePath, {
-      ...state,
-      phase: 'summary',
-    });
-    return {
-      decision: 'block',
-      reason: await finalSummaryContinuation(),
-    };
+    await rm(statePath, { force: true });
+    return {};
   }
 
   await rm(statePath, { force: true });

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.