genesis-compiler 1.7.2 → 1.7.4

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,14 +82,42 @@ 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`.
+The OpenCode adapter then skips the turn subprocess, and `genesis hook turn`
+returns empty output without calling the resolver. Session guidance remains
+active. Otherwise, OpenCode caches the latest user message's turn result,
+including an empty result, and clears it on compaction or deletion.
+
+OpenCode hook failures carry `GENESIS_HOOK_FAILURE` followed by JSON containing
+`scope`, `outcome` (`timeout`, `unavailable`, or `failed`), `elapsedMs`,
+`timeoutMs`, `code`, `signal`, and bounded `stderr`. Known secret values from the
+environment are redacted. The adapter's five-second deadline is independent of
+Codex hook settings. A host can render these fields as an actionable failure
+instead of displaying the runtime stack.
+
+The OpenCode session adapter also includes verified native `parentSessionIds`
+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 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
 project from its selected Stack and Git-visible project paths without building
@@ -165,11 +193,20 @@ 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 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.2",
+  "version": "1.7.4",
   "type": "module",
   "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {

package/plugins/opencode/project-guidance.js

@@ -7,21 +7,45 @@ const execute = promisify(execFile);
 
 const HOST_CONTEXT_INPUT_ENV = "GENESIS_HOST_CONTEXT_INPUT";
 
-async function renderContext(projectRoot, sessionId, scope) {
-  const { stdout } = await execute(
-    "genesis",
-    ["hook", scope, "--project-root", projectRoot],
-    {
-      cwd: projectRoot,
-      env: {
-        ...process.env,
-        [HOST_CONTEXT_INPUT_ENV]: JSON.stringify({ sessionId })
-      },
-      maxBuffer: 256 * 1024,
-      timeout: 5_000
+async function renderContext(projectRoot, sessionId, scope, parentSessionIds = []) {
+  if (scope === "turn" && process.env.GENESIS_TURN_CONTEXT_ENABLED === "0") return "";
+  const started = Date.now();
+  const timeoutMs = 5_000;
+  try {
+    const { stdout } = await execute(
+      "genesis",
+      ["hook", scope, "--project-root", projectRoot],
+      {
+        cwd: projectRoot,
+        env: {
+          ...process.env,
+          [HOST_CONTEXT_INPUT_ENV]: JSON.stringify({ sessionId, parentSessionIds })
+        },
+        maxBuffer: 256 * 1024,
+        timeout: timeoutMs
+      }
+    );
+    return stdout.trimEnd();
+  } catch (error) {
+    let stderr = String(error.stderr || "");
+    for (const [name, value] of Object.entries(process.env)) {
+      if (value && /(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|DSN|DATABASE_URL)/iu.test(name)) {
+        stderr = stderr.replaceAll(value, "[redacted]");
+      }
     }
-  );
-  return stdout.trimEnd();
+    const elapsedMs = Date.now() - started;
+    const details = {
+      scope,
+      outcome: error.killed && error.signal === "SIGTERM" && elapsedMs >= timeoutMs ? "timeout" :
+        error.code === "ENOENT" ? "unavailable" : "failed",
+      elapsedMs,
+      timeoutMs,
+      code: error.code ?? null,
+      signal: error.signal || null,
+      stderr: stderr.trim().slice(0, 1_500)
+    };
+    throw new Error(`GENESIS_HOOK_FAILURE ${JSON.stringify(details)}`);
+  }
 }
 
 function eventSessionId(event = {}) {
@@ -30,14 +54,26 @@ function eventSessionId(event = {}) {
   ).trim();
 }
 
-export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
+export const GenesisProjectGuidance = async ({ client, directory, worktree } = {}) => {
   const projectRoot = path.resolve(directory || worktree || process.cwd());
   const contexts = new Map();
+  const turnContexts = new Map();
 
   function contextForSession(sessionId) {
     let context = contexts.get(sessionId);
     if (!context) {
-      context = renderContext(projectRoot, sessionId, "session");
+      context = Promise.resolve().then(async () => {
+        const parents = [];
+        let id = sessionId;
+        while (client && id && parents.length < 32) {
+          const result = await client.session.get({ path: { id } });
+          if (result.error) throw new Error("Genesis could not read the native session ancestry.");
+          id = String(result.data?.parentID || "").trim();
+          if (!id || id === sessionId || parents.includes(id)) break;
+          parents.push(id);
+        }
+        return renderContext(projectRoot, sessionId, "session", parents);
+      });
       contexts.set(sessionId, context);
       context.catch(() => {
         if (contexts.get(sessionId) === context) contexts.delete(sessionId);
@@ -50,7 +86,10 @@ export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
     event: async ({ event } = {}) => {
       if (!["session.compacted", "session.deleted"].includes(event?.type)) return;
       const sessionId = eventSessionId(event);
-      if (sessionId) contexts.delete(sessionId);
+      if (sessionId) {
+        contexts.delete(sessionId);
+        turnContexts.delete(sessionId);
+      }
     },
     "experimental.chat.system.transform": async (input = {}, output = {}) => {
       const sessionId = String(input.sessionID || input.sessionId || "").trim();
@@ -67,7 +106,15 @@ export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
       const sessionId = String(message.info?.sessionID || "").trim();
       const messageId = String(message.info?.id || "").trim();
       if (!sessionId || !messageId || !Array.isArray(message.parts)) return;
-      const context = await renderContext(projectRoot, sessionId, "turn");
+      let current = turnContexts.get(sessionId);
+      if (current?.messageId !== messageId) {
+        current = { messageId, context: renderContext(projectRoot, sessionId, "turn") };
+        turnContexts.set(sessionId, current);
+        current.context.catch(() => {
+          if (turnContexts.get(sessionId) === current) turnContexts.delete(sessionId);
+        });
+      }
+      const context = await current.context;
       if (!context || message.parts.some((part) => part?.synthetic === true && part?.text === context)) {
         return;
       }

package/src/cli.js

@@ -562,6 +562,9 @@ async function execute({ command, operands, options }, { signal } = {}) {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
     }
     const scope = operands[0];
+    if (scope === 'turn' && process.env.GENESIS_TURN_CONTEXT_ENABLED === '0') {
+      return { kind: 'turn', status: 'ready', output: '' };
+    }
     if (scope === 'session' && process.env[SESSION_CONTEXT_INSTALLED_ENV] === '1') {
       return { kind: 'session', status: 'ready', output: '' };
     }

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,101 @@
+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_COMMAND = genesisHookCommand('session');
+const TURN_COMMAND = genesisHookCommand('turn');
+
+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) => ![SESSION_COMMAND, TURN_COMMAND].includes(hook?.command));
+      return hooks.length ? [{ ...group, hooks }] : [];
+    });
+  }
+  (value.hooks.SessionStart ||= []).push({
+    matcher: '^(startup|resume|clear|compact)$',
+    hooks: [{ type: 'command', command: SESSION_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: {
@@ -24,9 +20,9 @@ const SESSION_HOOK = {
       type: 'command',
       command: hookCommand('session'),
       commandWindows: 'genesis hook session',
-      timeout: 5,
+      timeout: 30,
       statusMessage: 'Loading Genesis guidance',
-      additionalContextLimit: 4000,
+      additionalContextLimit: 0,
     }],
   },
 };
@@ -38,7 +34,7 @@ const TURN_HOOK = {
       type: 'command',
       command: hookCommand('turn'),
       commandWindows: 'genesis hook turn',
-      timeout: 5,
+      timeout: 30,
       additionalContextLimit: 512,
     }],
   },
@@ -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) {
+  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`;
+}

package/src/index/host-context-resolver.js

@@ -8,7 +8,7 @@ export const HOST_CONTEXT_INPUT_ENV = 'GENESIS_HOST_CONTEXT_INPUT';
 export const SESSION_CONTEXT_INSTALLED_ENV = 'GENESIS_SESSION_CONTEXT_INSTALLED';
 
 const RESOLVER_OUTPUT_MAX_BYTES = 64 * 1024;
-const RESOLVER_TIMEOUT_MS = 5_000;
+const RESOLVER_TIMEOUT_MS = 30_000;
 
 function resolverError(message) {
   return new GenesisError('HOST_CONTEXT_RESOLVER_FAILED', message);

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/opencode-plugin.js

@@ -26,3 +26,10 @@ export async function installOpenCodePlugin({ projectRoot } = {}) {
   await writeFileAtomic(location, source);
   return { status: 'updated', changedFiles: [OPENCODE_PLUGIN_PATH] };
 }
+
+export async function inspectOpenCodePlugin({ projectRoot } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const current = await existingSource(path.join(root, OPENCODE_PLUGIN_PATH));
+  const source = await readFile(OPENCODE_PLUGIN_SOURCE, 'utf8');
+  return { status: current === source ? 'current' : current === null ? 'missing' : 'outdated' };
+}

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';
@@ -226,3 +228,4 @@ export async function syncSkills(options) {
 }
 
 export { inspectSubsystems } from './index/subsystems.js';
+export { inspectOpenCodePlugin, installOpenCodePlugin as syncOpenCodePlugin } from './index/opencode-plugin.js';