genesis-compiler 1.2.24 → 1.2.25

package/README.md

@@ -108,10 +108,10 @@ empty or already-adopted project.
 
 `genesis init` creates an empty Blueprint, a focused engineering approach, an
 empty optional Stack, the current `genesis/version`, three project Agent Skills,
-and project-local Codex hooks. The skills are ordinary
+and one project-local Codex guidance hook. The skills are ordinary
 [Agent Skills](https://agentskills.io): `genesis-project`, `genesis-program`,
 and `genesis-deslop`, each with standard `SKILL.md` and `agents/openai.yaml`
-metadata. Open `/hooks` once in Codex to review and trust the hooks. After
+metadata. Open `/hooks` once in Codex to review and trust the guidance hook. After
 that, use Codex normally. No technology is assumed until you explicitly select
 Stack components:
 
@@ -182,7 +182,7 @@ People may edit `## Project requirements` to name obligations the presets do
 not capture, including a specific organizational, compliance, cryptographic,
 or scale constraint. `genesis engineering set` changes only the profile and
 preserves those requirements. Generated prompts, path-focused context, Codex
-session guidance, Post-change work, and Deslop all receive the effective
+session guidance, implementation Post-change work, and Deslop all receive the effective
 approach. A project upgraded from an older Genesis release safely uses
 `focused.v1` until `genesis init` or `genesis engineering set focused.v1`
 records the file.
@@ -263,27 +263,19 @@ 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.
 
-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 ->
-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.
+The project Codex hook injects a short operating guide at startup, resume,
+clear, and compaction. It records no turn state, blocks no Stop, and requests no
+follow-up turn. Implementation prompts compose selected Stack `Post-change`
+guidance into the original implementation turn, and the project skill keeps
+intentional Blueprint and affected Program changes aligned there.
+
+Deslop runs only when explicitly requested. With no stated scope it reviews the
+latest commit; “the last N commits” reviews the net surviving first-parent
+range, and a named commit or range is honored exactly. It requires a clean
+worktree and leaves ordinary uncommitted cleanup for review rather than
+amending history. Genesis supplies the behavior-preserving boundary and Git
+scope rules. Selected Stack components add technology-specific Deslop guidance
+without weakening or broadening that contract.
 
 Projects can customize a selected technology through its matching file, such
 as `genesis/stack/jskit.md`:
@@ -303,7 +295,7 @@ Additional project-specific context about how JSKIT is used here.
 
 ### Post-change
 
-- Additional project-specific work to perform once after implementation.
+- Additional project-specific work to perform before the implementation turn completes.
 
 ### Deslop
 
@@ -321,7 +313,7 @@ A replacement for the installed JSKIT description.
 
 ### Post-change
 
-- Replacement installed post-change work.
+- Replacement installed post-change work for the implementation turn.
 
 ### Deslop
 
@@ -357,8 +349,9 @@ genesis prompt                                      # implementation work
 genesis prompt --task start                        # open a new or existing project conversation
 genesis prompt --task adopt                        # import an existing project's complete contract
 genesis prompt "Add filtering by note title"
-genesis prompt --task deslop                        # explicit cleanup
-genesis prompt --task deslop "Only review billing"
+genesis prompt --task deslop                        # clean up the latest commit
+genesis prompt --task deslop "Deslop the last 5 commits"
+genesis prompt --task deslop "Deslop commit a1b2c3d"
 genesis prompt --task program                       # refresh explanation
 genesis prompt --task blueprint "Start on notes"   # update product intent
 genesis prompt --task describe                      # create/refresh Blueprint and complete Program
@@ -377,8 +370,9 @@ The eight task types are deliberately explicit:
 - `work` implements the Blueprint and optional request using current code,
   Program, the selected engineering approach, selected Stack context, and
   progressively loaded Agent Skills.
-- `deslop` requests cleanup explicitly. Codex projects also receive a bounded
-  automatic Deslop turn after their separate explanatory reconciliation turn.
+- `deslop` requests behavior-preserving cleanup of committed work explicitly.
+  It defaults to the latest commit, accepts a first-parent commit count or exact
+  commit/range, requires a clean worktree, and leaves its result uncommitted.
 - `program` edits only `genesis/program/` to explain the code that exists, with
   selected Stack guidance available for technology-specific correctness.
 - `blueprint` edits only `genesis/blueprint.md` from explicit user intent. It
@@ -418,19 +412,20 @@ Components may contribute:
 
 - a concise description and supplemental Guidance used across relevant tasks;
 - existing-project Adoption requirements used only while importing a codebase;
-- optional Post-change work composed once after a code-changing implementation;
+- optional Post-change work composed into the original implementation turn;
 - one authoritative Agent Skill directory when the component owns one;
 - generic external-resource requirements;
-- cleanup advice used by explicit and automatic Deslop prompts;
+- cleanup advice composed on top of the core explicit Deslop contract;
 - structural code indexers used by Machine City and function lookup;
 - default verification commands.
 
 Technology-specific supplemental rules intentionally remain in Stack pieces.
 General `Guidance` enriches implementation, review, Program, description, and
-cleanup tasks; `Adoption` adds import-only requirements; `Post-change` composes
-one optional code-changing continuation before explanation; `Deslop` adds
-cleanup-only rules. None shadows an official generic technology skill or
-assumes that an upstream skill contains every rule Genesis needs.
+cleanup tasks; `Adoption` adds import-only requirements; `Post-change` adds
+work to finish in the original implementation turn; `Deslop` adds
+technology-specific cleanup rules to Genesis's invariant behavior-preserving
+contract. None shadows an official generic technology skill or assumes that an
+upstream skill contains every rule Genesis needs.
 
 Genesis core contains no Stack pieces and no database, framework, language, or
 platform dependency. See [Stack components](docs/stack-components.md).

package/docs/assurance-model.md

@@ -34,8 +34,7 @@ project. It creates ordinary project files with mode `0666`, directories and
 executable skill files with mode `0777`, and lets the invoking process umask
 and the destination directory's inherited ACL establish the effective mode and
 group. Atomic replacements are created beside their destination so they inherit
-the same filesystem policy before becoming visible. Private hook continuation
-state remains explicitly `0600`.
+the same filesystem policy before becoming visible.
 
 This keeps ordinary single-user projects conventional while allowing a managed
 host to require shared-group writes and no access for other users. The host is

package/docs/prompt-integration.md

@@ -77,22 +77,19 @@ does not perform adoption automatically. If the user accepts, Codex runs the
 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 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. 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.
+Codex can instead use the project-local hook installed by `genesis init`.
+That hook injects a short operating guide at startup, resume, clear, and
+compaction. It does not record user turns, authorize edits, intercept Stop, or
+request another model turn. Selected `Post-change` contributions are included
+in the original implementation prompt, whose project skill also keeps
+intentional Blueprint and affected Program changes aligned.
+
+Deslop is an explicit prompt task available to any host or command-line user.
+It resolves the latest commit by default, a requested first-parent count, or an
+exact commit/range; requires a clean worktree; and leaves cleanup as ordinary
+uncommitted work. Genesis owns that invariant contract. Selected Stack
+`Deslop` prose and applicable technology skills enrich the cleanup without
+changing its scope or behavior-preserving boundary.
 
 Once Codex identifies relevant source, `genesis context <path...>` returns only
 Program modules citing those paths plus the effective engineering approach and
@@ -113,7 +110,6 @@ user-installed generic technology skills independent.
 Matching files under `genesis/stack/<component>.md` may add to or override that
 selected component's Description, Guidance, Adoption, Post-change, and Deslop
 fields. Effective Guidance is used by work, review, Program, describe, Deslop,
-and path-context generation. The Codex continuation flow also carries it into
-Post-change work, reconciliation, and cleanup; effective Post-change work runs
-once before reconciliation, while Deslop guidance remains cleanup-only. Effective Adoption
-guidance is included only in the adoption workflow.
+and path-context generation. Effective Post-change work is composed into the
+implementation prompt, while Deslop guidance remains cleanup-only. Effective
+Adoption guidance is included only in the adoption workflow.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.24",
+  "version": "1.2.25",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
   "repository": {
@@ -32,7 +32,6 @@
     "prompts/describe.txt",
     "prompts/deslop.txt",
     "prompts/program.txt",
-    "prompts/reconcile.txt",
     "prompts/review.txt",
     "prompts/start.txt",
     "prompts/work.txt",

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

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

package/prompts/deslop.txt

@@ -1,29 +1,14 @@
-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.
+Read and follow `.agents/skills/genesis-deslop/SKILL.md` completely.
 
-This is a dedicated behavior-preserving cleanup task, separate from
-implementation. Review the requested scope, or otherwise the ordinary Git diff
-and immediately related code. Apply every selected Stack cleanup instruction
-supplied below and load applicable official technology skills for additional
-language and framework context.
+This is an explicitly requested behavior-preserving cleanup of committed work.
+Resolve the commit or first-parent commit range from USER REQUEST exactly; when
+no scope is stated, use the latest commit. Require a clean worktree before
+editing and leave the cleanup as ordinary uncommitted work for review.
 
-Use `.genesis/machine-city.json` and the Genesis `index <name-or-path>` operation
-to find existing public and internal functions. Remove or consolidate genuine
-repeated helpers, but confirm behavior and call sites in source before changing
-them.
+Apply the selected Stack cleanup guidance and applicable technology skills in
+addition to the Genesis Deslop contract. Stack guidance may improve
+technology-specific cleanup, but it cannot broaden the resolved Git scope,
+weaken behavior preservation, or turn this into another implementation pass.
 
-The changed paths and nearby code are a location boundary, not permission to
-implement other behavior found there. Deslop may reorganize behavior already
-present; it may not complete, correct, or extend behavior. If review reveals a
-defect, missing behavior, contract mismatch, or test gap, report it as a
-follow-up finding and leave it unchanged in this pass, even when it is inside a
-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.
+Report the resolved range, what became simpler, files changed, checks actually
+run, and any defect or gap deliberately left for follow-up.

package/prompts/work.txt

@@ -8,15 +8,18 @@ Before adding a helper or public operation, query the Genesis
 `index <name-or-path>` operation and reuse an existing function when it already
 owns the behavior.
 
-This is the implementation turn. Do not edit the Blueprint, Program, or
-`.genesis/`; the separate reconciliation turn owns explanatory changes. Keep
-applicable consumer-owned Stack sections aligned when the implementation changes
-facts governed by those contracts. Follow the selected technology skill and the
-section's own schema; Genesis only transports the section and does not interpret
-or execute it. Never put an environment value or secret in Stack. Never invent
-missing external-resource values. Preserve useful work and report a genuinely
-missing resource instead of constructing a parallel fallback.
+Keep the Blueprint and affected Program modules aligned in this turn when the
+implementation intentionally changes observable product behavior. Private
+restructuring may require only corrected source citations or no explanatory
+edit. Keep applicable consumer-owned Stack sections aligned when implementation
+changes facts governed by those contracts. Follow the selected technology skill
+and the section's own schema; Genesis only transports the section and does not
+interpret or execute it. Never put an environment value or secret in Stack.
+Never invent missing external-resource values. Preserve useful work and report
+a genuinely missing resource instead of constructing a parallel fallback.
 
+Apply any supplied Stack Post-change guidance before reporting completion. It
+belongs to this implementation turn and does not request a follow-up agent turn.
 Run focused checks when useful. Summarize files changed, checks actually run,
 and anything still requiring attention.
 

package/skills/genesis-deslop/SKILL.md

@@ -1,13 +1,12 @@
 ---
 name: genesis-deslop
-description: Perform a separate behavior-preserving cleanup pass after implementation. Use when asked to Deslop, simplify, remove repeated helpers, clarify ownership, or align changed code with established project and technology patterns.
+description: Deslop committed work through an explicit behavior-preserving cleanup pass. Use when asked to Deslop a commit or recent commits, simplify completed work, remove repeated helpers, clarify ownership, or align changed code with established project and technology patterns.
 ---
 
 # Genesis Deslop
 
-Review and simplify the current local codebase without changing product
-behavior. Start with the requested scope, or otherwise the ordinary Git diff
-and the code immediately around it.
+Review and simplify committed work without changing product behavior. Deslop is
+explicit: never run it merely because implementation finished.
 
 When this repository is Genesis itself or has `genesis-compiler` installed
 locally, invoke every Genesis CLI operation through the project-pinned package:
@@ -16,6 +15,28 @@ package. Otherwise use `genesis <arguments>` only when that executable is
 already available on `PATH`. Never install or update Genesis merely to satisfy
 a workflow instruction.
 
+## Resolve the committed scope
+
+Before reading or editing the selected change, require a clean worktree and
+index with `git status --short`. Stop and report the existing paths when it is
+not clean; do not stash, commit, discard, or mix them into Deslop.
+
+Resolve the user's scope as follows:
+
+- With no stated scope, use the latest commit.
+- “The last N commits” means the net surviving change from the first parent
+  before those N commits through `HEAD`.
+- A named commit means that commit against its first parent.
+- An explicit commit range means exactly that range.
+- A root commit uses Git's root-diff form because it has no parent.
+
+Inspect the resolved commit identities and changed paths before editing. Review
+the committed diff, current source, direct call sites, relevant tests, and the
+affected Program and Stack context. Do not substitute the ordinary working-tree
+diff for the selected committed scope.
+
+## Apply the cleanup contract
+
 Apply the engineering approach supplied with the task. If this skill is invoked
 directly, read `genesis/engineering.md` as well as the relevant project context.
 Cleanup must reduce or preserve complexity, never introduce unapproved
@@ -26,7 +47,7 @@ operation to find existing public and internal functions before introducing or
 consolidating an abstraction. Confirm every apparent duplicate in source and
 its call sites.
 
-Within the preceding implementation's intended behavior and scope, leave no
+Within the selected commits' intended behavior and scope, leave no
 repeated helpers, no code that is unclear or hard to reason about, and no code
 that goes against established patterns in the codebase. Remove unnecessary
 wrappers, abandoned scaffolding, parallel framework plumbing, and speculative
@@ -34,7 +55,7 @@ abstractions. Consolidate ownership where one clear module is enough. Do not
 optimize for tiny files or indirection; optimize for a small, obvious design
 that a junior programmer can follow.
 
-Cleanup is not a second implementation pass. A changed path limits where cleanup
+Cleanup is not a second implementation pass. A committed path limits where cleanup
 may occur; it does not authorize different behavior in that file. Deslop may
 reorganize behavior already present; it may not complete, correct, or extend
 behavior. If review reveals a defect, missing behavior, contract mismatch, or
@@ -43,15 +64,22 @@ is inside a changed path or appears related to the preceding implementation. Do
 not implement the finding or alter tests to accommodate it during Deslop.
 
 Apply every technology-specific Deslop instruction supplied by the selected
-Stack. Load applicable official technology skills for additional framework and
-language context, but do not expect them to contain Genesis's cleanup policy.
+Stack and load applicable official technology skills for framework and language
+context. Stack guidance enriches this contract; it cannot weaken the
+behavior-preserving boundary, change the selected Git scope, or authorize
+unrelated implementation.
 
 You may edit or delete implementation and test files when that is the clearest
-behavior-preserving cleanup. Do not edit `genesis/`, `.genesis/`, Git metadata,
-dependency directories, generated build output, retained migration history, or
-external resources. Do not weaken tests, public behavior, or data guarantees.
-Do not create a second architecture or perform unrelated rewrites.
-
-Run focused checks when useful. Final declared checks remain available through
-the Genesis `verify` operation. Summarize what became simpler, files changed,
-and checks actually run.
+behavior-preserving cleanup. If moving or renaming selected source makes an
+affected Program citation stale, update only that citation or informational
+Implementation map. Do not change the Blueprint or a Program public contract to
+excuse cleanup behavior. Do not edit `.genesis/`, Git metadata, dependency
+directories, generated build output, retained migration history, or external
+resources. Do not weaken tests, public behavior, or data guarantees. Do not
+create a second architecture or perform unrelated rewrites.
+
+Leave the cleanup as ordinary uncommitted work for review and a later normal
+commit. Never amend or rewrite the selected commits. Run focused checks when
+useful. Final declared checks remain available through the Genesis `verify`
+operation. Summarize the resolved commit range, what became simpler, files
+changed, checks actually run, and follow-up findings left unchanged.

package/skills/genesis-deslop/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Genesis Deslop"
-  short_description: "Simplify changed code without behavior drift"
-  default_prompt: "Use $genesis-deslop for a separate behavior-preserving cleanup pass over the current changes."
+  short_description: "Clean up committed work without behavior drift"
+  default_prompt: "Use $genesis-deslop to Deslop the latest commit."

package/skills/genesis-project/SKILL.md

@@ -65,19 +65,25 @@ Neither is authority or proof; both may be regenerated with the Genesis
   tradeoff. Never silently override the engineering approach.
 - Work directly in the current Git tree and leave useful edits visible in the
   ordinary diff.
-- Do not edit the Blueprint, Program, or `.genesis/` during implementation; the
-  separate reconciliation turn owns explanatory updates. Keep exact
+- Keep the Blueprint and affected Program modules aligned in this same turn
+  when implementation intentionally changes observable product behavior.
+  Private restructuring may require only corrected Sources or an informational
+  Implementation map, and may require no explanatory edit. Keep exact
   consumer-owned operation declarations, such as Vibe64 `## Outputs`, aligned
   when implementation intentionally changes the corresponding commands or
   capabilities. Record only capability metadata and environment-variable names
   there, never values or secrets; do not infer or execute the section as
-  Genesis behavior.
+  Genesis behavior. Treat `.genesis/` as replaceable derived navigation data,
+  not authored product intent.
 - Follow established project and technology seams instead of creating parallel
   frameworks, persistence layers, transports, validators, or UI systems.
 - Never invent unavailable external-resource values or pass literal
   environment-variable names as data. Report the missing resource and preserve
   useful work.
-- Keep the implementation direct and cohesive. Run focused checks when useful.
+- Keep the implementation direct and cohesive. Apply any supplied Stack
+  Post-change guidance before reporting completion; it is part of this
+  implementation turn, not a request for another agent turn. Run focused checks
+  when useful.
 
 ## Verify and report
 

package/src/cli.js

@@ -20,12 +20,8 @@ import {
   verify,
 } from './index.js';
 import {
-  authorizeCodexTurn,
   codexAdoptionRecommendation,
   codexSessionContext,
-  completeCodexTurn,
-  discardCodexTurn,
-  recordCodexTurn,
 } from './index/codex-hooks.js';
 import { engineeringProfile, readEngineeringBaseline } from './index/engineering.js';
 import { asDiagnostic, fail } from './index/errors.js';
@@ -138,8 +134,8 @@ function parseCommand(argv) {
         'Command inspect requires environment or section <name>.',
       );
     }
-  } 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 (command === 'hook' && (operands.length !== 1 || !['discover', 'session'].includes(operands[0]))) {
+    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session.');
   } else if (!['adopt', 'context', 'hook', 'index', 'inspect', 'prompt'].includes(command) && operands.length > 0) {
     fail('CLI_EXTRA_ARGUMENT', `Command ${command} accepts no arguments.`);
   }
@@ -266,8 +262,6 @@ 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;
   }
   if (command === 'stack' && Array.isArray(result.pieces)) {
@@ -292,20 +286,6 @@ function writeResult(command, result) {
   line(process.stdout, `${command}: ${result.status}`);
 }
 
-async function hookInput() {
-  if (process.stdin.isTTY) fail('CODEX_HOOK_INPUT_INVALID', 'Codex hook input must be supplied on stdin.');
-  const chunks = [];
-  let bytes = 0;
-  for await (const chunk of process.stdin) {
-    bytes += chunk.length;
-    if (bytes > 1024 * 1024) fail('CODEX_HOOK_INPUT_INVALID', 'Codex hook input exceeds 1 MiB.');
-    chunks.push(chunk);
-  }
-  try { return JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch (error) {
-    fail('CODEX_HOOK_INPUT_INVALID', `Codex hook input is invalid JSON: ${error.message}.`);
-  }
-}
-
 async function execute({ command, operands, options }, { signal } = {}) {
   const projectRoot = options.projectRoot || process.cwd();
   const stackPackages = options.stackPackages || [];
@@ -382,20 +362,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
     if (operands[0] === 'discover') {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
     }
-    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 }) };
-    }
-    if (operands[0] === 'end') {
-      return { kind: 'end', ...await discardCodexTurn({ input, projectRoot }) };
-    }
-    return { kind: 'stop', status: 'ready', output: await completeCodexTurn({ input, projectRoot }) };
+    return { kind: 'session', ...await codexSessionContext({ projectRoot }) };
   }
   if (command === 'verify') {
     return verify({

package/src/index/assets.js

@@ -6,7 +6,6 @@ const assets = {
   adopt: new URL('prompts/adopt.txt', root),
   work: new URL('prompts/work.txt', root),
   describe: new URL('prompts/describe.txt', root),
-  reconcile: new URL('prompts/reconcile.txt', root),
   deslop: new URL('prompts/deslop.txt', root),
   program: new URL('prompts/program.txt', root),
   blueprint: new URL('prompts/blueprint.txt', root),

package/src/index/codex-hooks.js

@@ -1,82 +1,62 @@
-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 { runGit } from './process.js';
 import { readStack } from './stack.js';
-import { normalizeRelative, pathState, sha256, stableJson, writeFileAtomic } from './utils.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|resume|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,13 +81,9 @@ 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);
@@ -131,7 +107,6 @@ async function optionalEngineering(projectRoot) {
         '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',
     };
   }
 }
@@ -150,21 +125,14 @@ export async function codexSessionContext({ projectRoot } = {}) {
     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.',
+      '- Read `genesis/blueprint.md`, `genesis/engineering.md`, and `genesis/stack.md` for product intent, engineering approach, and selected technology.',
+      '- Use the relevant project Agent Skills below `.agents/skills/`.',
+      '- After locating source, run `genesis context <path...>`; before adding a helper or public operation, run `genesis index <name-or-path...>` and reuse an existing owner.',
       '- 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'}.`,
+      '- Keep Blueprint and affected Program explanations aligned with intentional observable product behavior in the same implementation turn. Private restructuring may need only source citations or no explanatory change.',
+      '- Deslop only when explicitly requested. Genesis defines its behavior-preserving committed scope; selected Stack components may add technology-specific cleanup guidance.',
+      '- This guidance refreshes after startup, resume, clear, and compaction. Continue the active request without restarting completed work.',
+      `Engineering profile: ${engineering.profile?.id || 'invalid; run the Genesis `check` operation'}.`,
       `Selected Stack components: ${stackStatus}.`,
       '',
       'ENGINEERING APPROACH',
@@ -174,6 +142,10 @@ export async function codexSessionContext({ projectRoot } = {}) {
   };
 }
 
+function zeroPaths(buffer) {
+  return [...new Set(buffer.toString('utf8').split('\0').map(normalizeRelative).filter(Boolean))];
+}
+
 export async function codexAdoptionRecommendation({ projectRoot = process.cwd() } = {}) {
   let root;
   try { root = (await gitContext(projectRoot)).repositoryRoot; } catch { return { status: 'not-applicable', output: '' }; }
@@ -197,512 +169,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' };
-}

package/src/index/init.js

@@ -54,12 +54,12 @@ export async function initializeProject({ projectRoot, stackPackages = [] } = {}
   return {
     status: changedFiles.length > 0 ? 'updated' : 'unchanged',
     summary: changedFiles.length > 0
-      ? 'Initialized Genesis, Agent Skills, and project Codex hooks.'
-      : 'Genesis, its Agent Skills, and project Codex hooks are already initialized.',
+      ? 'Initialized Genesis, Agent Skills, and the project Codex guidance hook.'
+      : 'Genesis, its Agent Skills, and the project Codex guidance hook are already initialized.',
     changedFiles,
     diagnostics: skills.diagnostics,
     guidance: [
-      'Open Codex and use /hooks to review and trust the project hooks.',
+      'Open Codex and use /hooks to review and trust the project guidance hook.',
       'Genesis workflow skills are available in .agents/skills/.',
       'Describe product intent in genesis/blueprint.md.',
       'Choose the project engineering approach with genesis engineering set <profile>.',

package/src/index/prompt.js

@@ -25,7 +25,7 @@ const DEFAULT_REQUEST = {
   start: 'Start a conversation about this project.',
   adopt: 'Import the existing project into a truthful Genesis project contract.',
   work: 'Implement the product intent expressed by the current Blueprint.',
-  deslop: 'Simplify the current Git-visible work without making unrelated changes.',
+  deslop: 'Deslop the latest commit.',
   program: 'Refresh the complete useful Program for the code that exists now.',
   describe: 'Create or refresh the complete Blueprint and useful Program for the codebase that exists now.',
   review: 'Review the complete useful relationship between Blueprint, code, Program, and tests.',
@@ -107,6 +107,7 @@ function renderPrompt({
   skills = '',
   guidance = '',
   cleanup = '',
+  postChange = '',
   adoption = '',
   engineeringGuidance = '',
 }) {
@@ -126,6 +127,7 @@ function renderPrompt({
     ...(guidance ? ['', 'SELECTED STACK GUIDANCE', '', guidance] : []),
     ...(adoption ? ['', 'SELECTED STACK ADOPTION GUIDANCE', '', adoption] : []),
     ...(skills ? ['', 'AVAILABLE AGENT SKILLS', '', skills] : []),
+    ...(postChange ? ['', 'SELECTED STACK POST-CHANGE GUIDANCE', '', postChange] : []),
     ...(cleanup ? ['', 'SELECTED STACK CLEANUP GUIDANCE', '', cleanup] : []),
     '',
   ].join('\n');
@@ -451,6 +453,7 @@ export async function generateProjectPrompt({
     engineeringGuidance: engineering.guidance,
     guidance: stack.guidance,
     skills: renderAgentSkillCatalog(projectSkills.skills),
+    postChange: task === 'work' ? stack.postChange : '',
     cleanup: task === 'deslop' ? stack.deslop : '',
   });
   return {

package/prompts/reconcile.txt

@@ -1,13 +0,0 @@
-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
-product behavior. Update only affected Program modules. Private restructuring
-may require only Sources or an informational Implementation map, and may require
-no explanatory edit at all.
-
-Do not simplify or edit implementation, tests, configuration, dependencies,
-Stack, or `.genesis/` during this turn. Do not run Deslop yet. Summarize every
-explanatory change and genuine ambiguity.