genesis-compiler 1.7.3 → 1.7.5

package/README.md

@@ -34,6 +34,7 @@ genesis/
   genesis-*          Genesis workflow skills
   <technology>/      authoritative skills installed by selected Stack pieces
 .codex/hooks.json    project-local Codex lifecycle integration
+.claude/settings.json project-local Claude Code lifecycle integration
 .opencode/plugins/   project-local OpenCode lifecycle integration
 .genesis/
   machine-city.json  derived detailed source and function map
@@ -82,7 +83,7 @@ The catalog is static Markdown and contains the complete curated set of
 language, database, UI, and framework pieces. A host may supply another catalog
 through the same contract.
 
-### Try a new project with Codex or OpenCode
+### Try a new project with Codex, Claude Code or OpenCode
 
 Create an ordinary empty Git repository:
 
@@ -93,7 +94,7 @@ git init
 genesis init
 ```
 
-Start Codex or OpenCode in that directory. For a useful discovery test, begin
+Start Codex, Claude Code or OpenCode in that directory. For a useful discovery test, begin
 with a deliberately incomplete request:
 
 > I want to build something with JSKIT.
@@ -180,11 +181,11 @@ 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 guidance adapters for Codex and OpenCode. The skills are ordinary
+and project-local guidance adapters for Codex, Claude Code and OpenCode. 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 guidance hook;
-OpenCode discovers its local project plugin automatically. Both use the same
+Claude Code loads its project hooks and OpenCode discovers its local project plugin automatically. All three use the same
 Genesis-owned operating guide for new sessions and after compaction. When the
 optional first-party catalog is installed beside Genesis, that guide includes
 only its current component ids. If a named technology exactly matches an
@@ -236,7 +237,7 @@ files alone does not refresh its existing context.
 
 | Command | What it does |
 | --- | --- |
-| `genesis init` | Initializes Genesis files, workflow skills, code indexes, and local Codex/OpenCode guidance in a new or current-format project. It selects no technology. |
+| `genesis init` | Initializes Genesis files, workflow skills, code indexes, and local Codex/Claude Code/OpenCode guidance in a new or current-format project. It selects no technology. |
 | `genesis adopt [guidance...]` | Initializes an existing codebase and prints the prompt for describing its real product and operational contracts without moving or modernizing source. |
 | `genesis codex install` | Installs the optional Codex discovery plugin that recommends adoption for nonempty projects without Genesis. |
 | `genesis engineering list` | Lists the installed engineering profiles. |
@@ -310,7 +311,7 @@ conversation is created or refreshed. They may then generate task prompts with
 `sessionContextInstalled: true`, preventing the stable Collaboration and
 Engineering guidance from being repeated in each task. A host can supply one
 explicit session/turn driver; Genesis performs no driver discovery and labels
-turn output untrusted. If the project-local Codex or OpenCode adapter runs in a
+turn output untrusted. If the project-local Codex, Claude Code or OpenCode adapter runs in a
 separate process, the host may set `GENESIS_HOST_CONTEXT_RESOLVER` to one
 executable and optionally supply opaque JSON in
 `GENESIS_HOST_CONTEXT_RESOLVER_DATA`. Session and turn hooks pass only the
@@ -461,7 +462,7 @@ 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.
 
-The project Codex hook and OpenCode plugin use the same short operating guide
+The project Codex and Claude Code hooks and OpenCode plugin use the same short operating guide
 for a new session and after compaction. They record no conversation message,
 block no completion, and request no follow-up turn. Implementation prompts
 compose selected Stack `Post-change` guidance into the original implementation

package/docs/prompt-integration.md

@@ -61,7 +61,7 @@ native placement. The driver never receives or rewrites `userMessage`, and
 Genesis supports only the one explicitly supplied driver—there is no discovery
 or plugin registry.
 
-When the project-local Codex or OpenCode adapter runs in a separate process,
+When the project-local Codex, Claude Code or OpenCode adapter runs in a separate process,
 the host can configure that same one-driver boundary without adding another
 prompt compositor:
 
@@ -82,12 +82,12 @@ JSON on stdin:
 ```
 
 For `genesis hook turn`, the input has the same shape with `scope: "turn"`.
-The executable returns only the requested host contribution as text. Codex's
+The executable returns only the requested host contribution as text. Codex and Claude Code
 hook input and OpenCode's transform callbacks supply the native session id;
 Genesis extracts that id but does not understand the host registry or the
-provider's prompt-placement rules. The Codex prompt hook and OpenCode message
+provider's prompt-placement rules. The Codex and Claude prompt hooks and OpenCode message
 transform place a nonempty turn result separately from authored user text. If
-no resolver is configured, both turn paths are empty and the adapters render
+no resolver is configured, all turn paths are empty and the adapters render
 ordinary Genesis session context exactly as before.
 
 A host that has no turn contribution can set `GENESIS_TURN_CONTEXT_ENABLED=0`.
@@ -108,13 +108,15 @@ in `GENESIS_HOST_CONTEXT_INPUT` for host command shims. The resolver still
 receives the actual child's `providerSessionId`; Genesis does not interpret a
 host's ownership rules.
 
-After updating Genesis, hosts can inspect the generated adapter with
-`inspectOpenCodePlugin({ projectRoot })` and call `syncOpenCodePlugin({ projectRoot })`
-from `genesis-compiler` under their ordinary source-write admission. It updates
-only `.opencode/plugins/genesis-project-guidance.js`, returns `status` and
-`changedFiles`, and leaves authored project files and other plugins alone.
-Reload the provider instance to use an adapter that was already loaded. The
-existing `genesis migrate` command also refreshes this generated adapter.
+After updating Genesis, hosts can inspect all generated integrations with
+`inspectAgentIntegrations({ projectRoot })` and refresh them with
+`syncAgentIntegrations({ projectRoot })` under ordinary source-write admission.
+These finite operations cover Codex hooks, Claude settings and the OpenCode
+plugin. Synchronization preserves unrelated settings and hooks and returns
+`status` and `changedFiles`; it does not migrate authored project contracts.
+The individual OpenCode inspection/sync exports remain available to callers
+that own only that integration. A running provider picks up changes through its
+native reload lifecycle. `genesis init` and migration install all three adapters.
 
 Tasks are `start`, `adopt`, `work`, `deslop`, `program`, `blueprint`, `describe`, and `review`.
 `start` is the host-independent first conversation: it classifies an initialized
@@ -191,11 +193,29 @@ 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 and OpenCode can use the project-local adapters installed by `genesis
-init`. Both receive the same short operating guide for a new session and after
-compaction. Codex uses `SessionStart` for startup, clear, and compact events.
+Codex, Claude Code and OpenCode can use the project-local adapters installed by `genesis
+init`. All receive the same short operating guide for a new session and after
+compaction. The Codex session hook sets `additionalContextLimit: 0` so native
+truncation cannot remove part of the bounded guide or host contribution.
+Codex and Claude Code use `SessionStart` for startup, resume, clear, and compact events.
+Claude's generated session hooks use `genesis hook session --claude-part <1-4>`.
+Claude caps each hook output at 10,000 characters, so four hooks deliver the
+unchanged guide in numbered parts below that limit. Empty parts emit nothing.
+A guide above 36,000 characters delivers an explicit guidance-unavailable
+warning instead of a partial guide. Claude does not enforce startup hook stop
+requests; this warning instructs the model to report the problem before work,
+and is not a runtime admission control. Turn guidance is already bounded at 512
+bytes and uses the ordinary turn command. This is provider transport only;
+composition and the host bridge remain shared.
+Claude settings preserve unrelated hooks and configuration. The common operating
+guide lists installed project skills and their canonical `.agents/skills/` paths;
+an agent reads the relevant skill before following its workflow. Genesis exposes
+the canonical skill directories to Claude through relative `.claude/skills/`
+links, so native skill commands use the same files. Skills synchronization adds
+new links and removes only its exact dangling links; existing native Claude
+skills are preserved and reported as overrides.
 OpenCode renders once per session, keeps that value active in its stateless
-model requests, and rerenders after its `session.compacted` event. Neither
+model requests, and rerenders after its `session.compacted` event. No
 adapter records a user message, authorizes edits, intercepts completion, or
 requests another model turn. Selected `Post-change` contributions are included
 in the original implementation prompt, whose project skill also keeps

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {

package/src/cli.js

@@ -88,6 +88,7 @@ Options:
   --directory <path>     Parser cache directory (parsers commands only)
   --all                  Select every parser (parsers install/verify only)
   --json                 Emit one machine-readable result
+  --claude-part <1-4>    Emit one bounded Claude session-hook part
   -h, --help             Show this help
 
 Genesis generates prompts; it never starts or manages an AI agent. Give the
@@ -111,6 +112,7 @@ function parseCommand(argv) {
       strict: true,
       options: {
         json: { type: 'boolean', default: false },
+        'claude-part': { type: 'string' },
         all: { type: 'boolean', default: false },
         directory: { type: 'string' },
         'project-root': { type: 'string' },
@@ -124,6 +126,7 @@ function parseCommand(argv) {
   }
   const options = {
     json: parsed.values.json,
+    claudePart: parsed.values['claude-part'],
     all: parsed.values.all,
     directory: parsed.values.directory,
     projectRoot: parsed.values['project-root'],
@@ -138,6 +141,9 @@ function parseCommand(argv) {
     task: parsed.values.task,
   };
   const operands = parsed.positionals;
+  if (options.claudePart !== undefined && (command !== 'hook' || operands[0] !== 'session' || !/^[1-4]$/u.test(options.claudePart) || options.json)) {
+    fail('CLI_OPTION_NOT_APPLICABLE', 'Option --claude-part requires hook session, a part from 1 to 4, and no --json.');
+  }
   if (command !== 'parsers' && (options.all || options.directory !== undefined)) {
     fail('CLI_OPTION_NOT_APPLICABLE', 'Options --all and --directory apply only to parsers commands.');
   }
@@ -665,9 +671,24 @@ export async function runCli(argv = process.argv.slice(2)) {
       projectFormat,
       formatDiagnostic,
     );
-    if (options.json) line(process.stdout, JSON.stringify(result));
-    else {
-      writeResult(parsed.command, result);
+    if (options.claudePart !== undefined) {
+      // Claude spills each hook output over 10,000 characters to a file.
+      // Four native hooks deliver the exact text in bounded parts instead.
+      if (result.output.length > 36000) {
+        if (options.claudePart === '1') line(process.stdout,
+          'GENESIS GUIDANCE UNAVAILABLE: The session guide exceeds the Claude hook capacity of 36,000 characters. The guide was not delivered. Tell the user before doing project work. Shorten the project guidance and restart the conversation to load it completely.');
+        return 0;
+      }
+      let start = (Number(options.claudePart) - 1) * 9000;
+      let end = start + 9000;
+      // Keep UTF-16 surrogate pairs together at the shared part boundaries.
+      if (/[\uDC00-\uDFFF]/u.test(result.output[start] || '')) start--;
+      if (/[\uDC00-\uDFFF]/u.test(result.output[end] || '')) end--;
+      const part = result.output.slice(start, end);
+      if (part) process.stdout.write(`Genesis session guidance, part ${options.claudePart} of ${Math.ceil(result.output.length / 9000)} (read in numeric order):\n${part}`);
+    } else if (options.json) line(process.stdout, JSON.stringify(result));
+    else writeResult(parsed.command, result);
+    if (!options.json) {
       for (const warning of result.warnings || []) {
         if (warning.code !== formatDiagnostic?.code) line(process.stderr, `WARNING: ${warning.code}: ${warning.message}`);
       }

package/src/index/agent-integrations.js

@@ -0,0 +1,24 @@
+import { inspectClaudeHooks, installClaudeHooks } from './claude-hooks.js';
+import { inspectCodexHooks, installCodexHooks } from './codex-hooks.js';
+import { inspectOpenCodePlugin, installOpenCodePlugin } from './opencode-plugin.js';
+
+export async function inspectAgentIntegrations(options = {}) {
+  const [codex, claude, opencode] = await Promise.all([
+    inspectCodexHooks(options), inspectClaudeHooks(options), inspectOpenCodePlugin(options),
+  ]);
+  const integrations = { codex, claude, opencode };
+  const states = Object.values(integrations).map(({ status }) => status);
+  return {
+    status: states.includes('missing') ? 'missing' : states.includes('outdated') ? 'outdated' : 'current',
+    integrations,
+  };
+}
+
+export async function syncAgentIntegrations(options = {}) {
+  const results = await Promise.all([
+    installCodexHooks(options), installClaudeHooks(options), installOpenCodePlugin(options),
+  ]);
+  const changedFiles = results.flatMap(({ changedFiles }) => changedFiles).sort();
+  const warnings = results.flatMap((result) => result.warnings || []);
+  return { status: changedFiles.length ? 'updated' : 'unchanged', changedFiles, ...(warnings.length ? { warnings } : {}) };
+}

package/src/index/agent-skills.js

@@ -16,6 +16,7 @@ import { fromMarkdown } from 'mdast-util-from-markdown';
 import { parse as parseYaml } from 'yaml';
 
 import { asDiagnostic, GenesisError } from './errors.js';
+import { claudeSkillLinks } from './claude-hooks.js';
 import { sha256, stableJson, writeFileAtomic } from './utils.js';
 
 const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
@@ -482,6 +483,9 @@ export async function syncProjectSkills({ projectRoot, stack } = {}) {
     await writeFileAtomic(manifest.location, rendered);
     changedFiles.push(MANIFEST_PATH);
   }
+  const links = await claudeSkillLinks(projectRoot, true);
+  changedFiles.push(...links.changedFiles);
+  diagnostics.push(...(links.warnings || []));
   return {
     status: changedFiles.length > 0 ? 'updated' : 'unchanged',
     changedFiles: [...new Set(changedFiles)].sort(),

package/src/index/claude-hooks.js

@@ -0,0 +1,104 @@
+import { mkdir, readFile, readdir, readlink, rm, symlink } from 'node:fs/promises';
+import path from 'node:path';
+
+import { GenesisError } from './errors.js';
+import { gitContext } from './git.js';
+import { genesisHookCommand } from './hook-command.js';
+import { writeFileAtomic } from './utils.js';
+
+const SETTINGS_PATH = '.claude/settings.json';
+const SESSION_COMMANDS = [1, 2, 3, 4].map((claudePart) => genesisHookCommand('session', { claudePart }));
+const TURN_COMMAND = genesisHookCommand('turn');
+// Refresh exact generated commands, including the previous plain-text output.
+const OWNED_COMMANDS = new Set([...SESSION_COMMANDS, TURN_COMMAND,
+  genesisHookCommand('session')]);
+
+async function renderedSettings(projectRoot) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const location = path.join(root, SETTINGS_PATH);
+  let source = null;
+  let value = {};
+  try {
+    source = await readFile(location, 'utf8');
+    value = JSON.parse(source);
+  } catch (error) {
+    if (!['ENOENT', 'ENOTDIR'].includes(error.code)) {
+      throw new GenesisError('CLAUDE_SETTINGS_INVALID', `${SETTINGS_PATH} is not valid JSON: ${error.message}.`);
+    }
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+      || (value.hooks !== undefined && (!value.hooks || typeof value.hooks !== 'object' || Array.isArray(value.hooks)))) {
+    throw new GenesisError('CLAUDE_SETTINGS_INVALID', `${SETTINGS_PATH} must contain an object with an optional hooks object.`);
+  }
+  value.hooks ||= {};
+  for (const [event, groups] of Object.entries(value.hooks)) {
+    if (!Array.isArray(groups)) {
+      throw new GenesisError('CLAUDE_SETTINGS_INVALID', `${SETTINGS_PATH} hooks.${event} must be an array.`);
+    }
+    value.hooks[event] = groups.flatMap((group) => {
+      if (!Array.isArray(group?.hooks)) return [group];
+      const hooks = group.hooks.filter((hook) => !OWNED_COMMANDS.has(hook?.command));
+      return hooks.length ? [{ ...group, hooks }] : [];
+    });
+  }
+  (value.hooks.SessionStart ||= []).push({
+    matcher: '^(startup|resume|clear|compact)$',
+    hooks: SESSION_COMMANDS.map((command) => ({ type: 'command', command, timeout: 30 })),
+  });
+  (value.hooks.UserPromptSubmit ||= []).push({
+    hooks: [{ type: 'command', command: TURN_COMMAND, timeout: 30 }],
+  });
+  return { root, location, source, rendered: `${JSON.stringify(value, null, 2)}\n` };
+}
+
+// Claude discovers .claude/skills; the canonical files remain in .agents/skills.
+// Only exact generated links are owned here. User-owned Claude skills win.
+export async function claudeSkillLinks(root, write = false) {
+  const [canonical, installed] = await Promise.all(['.agents/skills', '.claude/skills'].map(async (directory) => {
+    try { return await readdir(path.join(root, directory), { withFileTypes: true }); }
+    catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  }));
+  const names = new Set(canonical.filter((entry) => entry.isDirectory()).map(({ name }) => name));
+  const existing = new Map(installed.map((entry) => [entry.name, entry]));
+  const changedFiles = [];
+  const warnings = [];
+  for (const name of new Set([...names, ...existing.keys()])) {
+    const relative = `.claude/skills/${name}`;
+    const location = path.join(root, relative);
+    const target = `../../.agents/skills/${name}`;
+    const entry = existing.get(name);
+    const owned = entry?.isSymbolicLink() && await readlink(location) === target;
+    if (!names.has(name)) {
+      if (owned) {
+        changedFiles.push(relative);
+        if (write) await rm(location);
+      }
+    } else if (!entry) {
+      changedFiles.push(relative);
+      if (write) {
+        await mkdir(path.dirname(location), { recursive: true });
+        await symlink(target, location, 'dir');
+      }
+    } else if (!owned) {
+      warnings.push({ code: 'CLAUDE_SKILL_OVERRIDE', message: `${relative} is user-owned and was preserved; Claude uses it instead of the canonical .agents/skills/${name}.` });
+    }
+  }
+  return { changedFiles, ...(warnings.length ? { warnings } : {}) };
+}
+
+export async function installClaudeHooks({ projectRoot } = {}) {
+  const { root, location, source, rendered } = await renderedSettings(projectRoot);
+  const result = await claudeSkillLinks(root, true);
+  if (source !== rendered) {
+    await writeFileAtomic(location, rendered);
+    result.changedFiles.push(SETTINGS_PATH);
+  }
+  return { status: result.changedFiles.length ? 'updated' : 'unchanged', ...result };
+}
+
+export async function inspectClaudeHooks({ projectRoot } = {}) {
+  const { root, source, rendered } = await renderedSettings(projectRoot);
+  const { changedFiles, warnings } = await claudeSkillLinks(root);
+  return { status: source === null ? 'missing' : source !== rendered || changedFiles.length ? 'outdated' : 'current',
+    ...(warnings ? { warnings } : {}) };
+}

package/src/index/codex-hooks.js

@@ -6,16 +6,12 @@ import { gitContext } from './git.js';
 import { classifyProjectKind } from './project-files.js';
 import { writeFileAtomic } from './utils.js';
 import { inspectProjectFormatAtRoot } from './project-format.js';
+import { genesisHookCommand as hookCommand } from './hook-command.js';
 
 const HOOKS_PATH = '.codex/hooks.json';
 const LEGACY_GENESIS_HOOKS_DESCRIPTION = 'Genesis project hooks.';
 const PROJECT_HOOK_ACTIONS = ['session', 'turn', '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 SESSION_HOOK = {
   event: 'SessionStart',
   group: {
@@ -26,7 +22,7 @@ const SESSION_HOOK = {
       commandWindows: 'genesis hook session',
       timeout: 30,
       statusMessage: 'Loading Genesis guidance',
-      additionalContextLimit: 4000,
+      additionalContextLimit: 0,
     }],
   },
 };
@@ -88,7 +84,7 @@ async function installedHooksSource(location) {
   }
 }
 
-export async function installCodexHooks({ projectRoot } = {}) {
+async function renderedHooks(projectRoot) {
   const root = (await gitContext(projectRoot)).repositoryRoot;
   const location = path.join(root, HOOKS_PATH);
   const { source, value } = await installedHooksSource(location);
@@ -100,6 +96,16 @@ export async function installCodexHooks({ projectRoot } = {}) {
   const turnGroups = value.hooks[TURN_HOOK.event] ||= [];
   turnGroups.push(TURN_HOOK.group);
   const rendered = `${JSON.stringify(value, null, 2)}\n`;
+  return { source, rendered, location };
+}
+
+export async function inspectCodexHooks({ projectRoot } = {}) {
+  const { source, rendered } = await renderedHooks(projectRoot);
+  return { status: source === rendered ? 'current' : source === null ? 'missing' : 'outdated' };
+}
+
+export async function installCodexHooks({ projectRoot } = {}) {
+  const { source, rendered, location } = await renderedHooks(projectRoot);
   if (source === rendered) return { status: 'unchanged', changedFiles: [] };
   await writeFileAtomic(location, rendered);
   return { status: 'updated', changedFiles: [HOOKS_PATH] };

package/src/index/hook-command.js

@@ -0,0 +1,4 @@
+export function genesisHookCommand(action, { claudePart } = {}) {
+  const local = `const {runCli}=await import('genesis-compiler/cli');process.exitCode=await runCli(['hook','${action}'${claudePart ? `,'--claude-part','${claudePart}'` : ''}])`;
+  return `if command -v genesis >/dev/null 2>&1; then genesis hook ${action}${claudePart ? ` --claude-part ${claudePart}` : ''}; else node --input-type=module --eval "${local}"; fi`;
+}

package/src/index/init.js

@@ -4,11 +4,10 @@ import path from 'node:path';
 
 import { syncProjectSkills } from './agent-skills.js';
 import { BLUEPRINT_SKELETON_SOURCE } from './blueprint.js';
-import { installCodexHooks } from './codex-hooks.js';
+import { syncAgentIntegrations } from './agent-integrations.js';
 import { COLLABORATION_SKELETON_SOURCE } from './collaboration.js';
 import { ENGINEERING_SKELETON_SOURCE } from './engineering.js';
 import { gitContext } from './git.js';
-import { installOpenCodePlugin } from './opencode-plugin.js';
 import {
   BLUEPRINT_PATH,
   COLLABORATION_PATH,
@@ -50,17 +49,13 @@ export async function initializeProject({ projectRoot, stackPackages = [] } = {}
   await mkdir(path.join(root, PROGRAM_ROOT), { recursive: true });
   const stack = await readStack(root, { stackPackages });
   const skills = await syncProjectSkills({ projectRoot: root, stack });
-  const [hooks, openCodePlugin] = await Promise.all([
-    installCodexHooks({ projectRoot: root }),
-    installOpenCodePlugin({ projectRoot: root }),
-  ]);
+  const integrations = await syncAgentIntegrations({ projectRoot: root });
   const version = projectFormat.status === 'uninitialized'
     ? await createIfMissing(root, PROJECT_VERSION_PATH, CURRENT_PROJECT_FORMAT_SOURCE)
     : null;
   const changedFiles = [
     ...created,
-    ...hooks.changedFiles,
-    ...openCodePlugin.changedFiles,
+    ...integrations.changedFiles,
     ...skills.changedFiles,
     version,
   ]
@@ -69,12 +64,14 @@ export async function initializeProject({ projectRoot, stackPackages = [] } = {}
   return {
     status: changedFiles.length > 0 ? 'updated' : 'unchanged',
     summary: changedFiles.length > 0
-      ? 'Initialized Genesis, Agent Skills, and project guidance for Codex and OpenCode.'
-      : 'Genesis, its Agent Skills, and project guidance for Codex and OpenCode are already initialized.',
+      ? 'Initialized Genesis, Agent Skills, and project guidance for Codex, Claude Code and OpenCode.'
+      : 'Genesis, its Agent Skills, and project guidance for Codex, Claude Code and OpenCode are already initialized.',
     changedFiles,
     diagnostics: skills.diagnostics,
+    ...(integrations.warnings ? { warnings: integrations.warnings } : {}),
     guidance: [
       'Open Codex and use /hooks to review and trust the project guidance hook.',
+      'Claude Code loads the project guidance hooks from .claude/settings.json.',
       'OpenCode loads the project guidance plugin automatically.',
       'Genesis workflow skills are available in .agents/skills/.',
       'Describe product intent in genesis/blueprint.md.',

package/src/index/project-inspection.js

@@ -23,9 +23,11 @@ export const GENESIS_BOOTSTRAP_PATHS = Object.freeze([
   '.genesis/machine-city.json',
   '.genesis/program-city.json',
   '.codex/hooks.json',
+  '.claude/settings.json',
   '.opencode/plugins/genesis-project-guidance.js',
   '.agents/skills/.genesis-managed.json',
   ...['genesis-project', 'genesis-program', 'genesis-deslop'].flatMap((name) => [
+    `.claude/skills/${name}`,
     `.agents/skills/${name}/SKILL.md`,
     `.agents/skills/${name}/agents/openai.yaml`,
   ]),
@@ -33,10 +35,12 @@ export const GENESIS_BOOTSTRAP_PATHS = Object.freeze([
 const bootstrapPaths = new Set(GENESIS_BOOTSTRAP_PATHS);
 
 export async function inspectProjectContent(projectRoot) {
+  // Exclude dependency paths in Git before collecting and sorting its output.
+  const sourcePaths = ['--', '.', ':(exclude,glob)**/node_modules/**'];
   const [visible, deleted, ignored] = await Promise.all([
-    runGit(projectRoot, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', '.']),
-    runGit(projectRoot, ['ls-files', '-z', '--deleted', '--', '.']),
-    runGit(projectRoot, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', '--', '.']),
+    runGit(projectRoot, ['ls-files', '-z', '--cached', '--others', '--exclude-standard', ...sourcePaths]),
+    runGit(projectRoot, ['ls-files', '-z', '--deleted', ...sourcePaths]),
+    runGit(projectRoot, ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', ...sourcePaths]),
   ]);
   const absent = new Set(deleted.stdout.toString('utf8').split('\0').filter(Boolean));
   const paths = [...new Set([visible, ignored].flatMap(({ stdout }) => stdout.toString('utf8').split('\0').filter(Boolean)))]

package/src/index/session-context.js

@@ -1,5 +1,5 @@
 import { readCollaboration } from './collaboration.js';
-import { inspectProjectSkills } from './agent-skills.js';
+import { inspectProjectSkills, renderAgentSkillCatalog } from './agent-skills.js';
 import { GENESIS_CONTRACTS } from './contracts.js';
 import { readEngineering, readEngineeringBaseline } from './engineering.js';
 import { asDiagnostic, GenesisError } from './errors.js';
@@ -166,6 +166,7 @@ export async function projectSessionContext({
     'COLLABORATION APPROACH',
     '',
     collaboration.guidance,
+    ...(skills.skills?.length ? ['', 'PROJECT AGENT SKILLS', '', renderAgentSkillCatalog(skills.skills)] : []),
     ...(hostContext ? ['', 'HOST CONTEXT', '', hostContext] : []),
   ].join('\n');
   return { ...composedContext(GENESIS_CONTRACTS.sessionContext, output), warnings: skills.diagnostics };

package/src/index.js

@@ -31,6 +31,8 @@ import { projectSessionContext, projectTurnContext } from './index/session-conte
 import { withTrustedGitRepository } from './index/process.js';
 
 export { inspectProject };
+export { inspectClaudeHooks, installClaudeHooks as syncClaudeHooks } from './index/claude-hooks.js';
+export { inspectAgentIntegrations, syncAgentIntegrations } from './index/agent-integrations.js';
 export { listParsers, installParsers, verifyParsers, parserEnvironment } from './index/code-indexers/parsers.js';
 export { listTemplates } from './index/template-catalog.js';
 export { applyTemplate } from './index/template-project.js';