genesis-compiler 1.2.25 → 1.2.26

package/README.md

@@ -21,7 +21,8 @@ genesis/
 .agents/skills/
   genesis-*          Genesis workflow skills
   <technology>/      authoritative skills installed by selected Stack pieces
-.codex/hooks.json    optional project-local Codex lifecycle integration
+.codex/hooks.json    project-local Codex lifecycle integration
+.opencode/plugins/   project-local OpenCode lifecycle integration
 .genesis/
   machine-city.json  derived detailed source and function map
   program-city.json  derived simple subsystem and operation map
@@ -108,12 +109,13 @@ 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 one project-local Codex guidance hook. The skills are ordinary
+and project-local guidance adapters for Codex 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. After
-that, use Codex normally. No technology is assumed until you explicitly select
-Stack components:
+metadata. Open `/hooks` once in Codex to review and trust the guidance hook;
+OpenCode discovers its local project plugin automatically. Both use the same
+Genesis-owned operating guide for new sessions and after compaction. No
+technology is assumed until you explicitly select Stack components:
 
 ```bash
 genesis stack add --stack-package genesis-stack nodejs
@@ -263,11 +265,12 @@ 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 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.
+The project Codex hook 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
+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

package/docs/prompt-integration.md

@@ -77,10 +77,13 @@ 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 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
+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.
+OpenCode renders once per session, keeps that value active in its stateless
+model requests, and rerenders after its `session.compacted` event. Neither
+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
 intentional Blueprint and affected Program changes aligned.
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "genesis-compiler",
-  "version": "1.2.25",
+  "version": "1.2.26",
   "type": "module",
-  "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with optional Codex hooks.",
+  "description": "An agent-independent prompt, multi-language code-index, cleanup, and verification companion with project agent guidance.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mobily-enterprises/genesis-compiler.git"
@@ -36,6 +36,7 @@
     "prompts/start.txt",
     "prompts/work.txt",
     "plugins/genesis",
+    "plugins/opencode",
     "profiles",
     "skills",
     "src"

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

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

package/plugins/opencode/project-guidance.js

@@ -0,0 +1,57 @@
+// Generated by Genesis. Run `genesis migrate` to refresh this project plugin.
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execute = promisify(execFile);
+
+async function renderProjectContext(projectRoot) {
+  const { stdout } = await execute(
+    "genesis",
+    ["hook", "session", "--project-root", projectRoot],
+    {
+      cwd: projectRoot,
+      maxBuffer: 256 * 1024,
+      timeout: 5_000
+    }
+  );
+  return stdout.trimEnd();
+}
+
+function eventSessionId(event = {}) {
+  return String(
+    event.properties?.sessionID || event.properties?.info?.id || ""
+  ).trim();
+}
+
+export const GenesisProjectGuidance = async ({ directory, worktree } = {}) => {
+  const projectRoot = path.resolve(worktree || directory || process.cwd());
+  const contexts = new Map();
+
+  function contextForSession(sessionId) {
+    let context = contexts.get(sessionId);
+    if (!context) {
+      context = renderProjectContext(projectRoot);
+      contexts.set(sessionId, context);
+      context.catch(() => {
+        if (contexts.get(sessionId) === context) contexts.delete(sessionId);
+      });
+    }
+    return context;
+  }
+
+  return {
+    event: async ({ event } = {}) => {
+      if (!["session.compacted", "session.deleted"].includes(event?.type)) return;
+      const sessionId = eventSessionId(event);
+      if (sessionId) contexts.delete(sessionId);
+    },
+    "experimental.chat.system.transform": async (input = {}, output = {}) => {
+      const sessionId = String(input.sessionID || input.sessionId || "").trim();
+      if (!sessionId) return;
+      const context = await contextForSession(sessionId);
+      const system = Array.isArray(output.system) ? output.system : [];
+      if (!system.includes(context)) output.system = [...system, context];
+    }
+  };
+};

package/src/cli.js

@@ -21,7 +21,6 @@ import {
 } from './index.js';
 import {
   codexAdoptionRecommendation,
-  codexSessionContext,
 } from './index/codex-hooks.js';
 import { engineeringProfile, readEngineeringBaseline } from './index/engineering.js';
 import { asDiagnostic, fail } from './index/errors.js';
@@ -29,6 +28,7 @@ import {
   inspectProjectFormat,
   projectFormatDiagnostic,
 } from './index/project-format.js';
+import { projectSessionContext } from './index/session-context.js';
 
 const USAGE = `Usage:
   genesis init
@@ -362,7 +362,7 @@ async function execute({ command, operands, options }, { signal } = {}) {
     if (operands[0] === 'discover') {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
     }
-    return { kind: 'session', ...await codexSessionContext({ projectRoot }) };
+    return { kind: 'session', ...await projectSessionContext({ projectRoot }) };
   }
   if (command === 'verify') {
     return verify({

package/src/index/codex-hooks.js

@@ -1,12 +1,10 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 
-import { readEngineering, readEngineeringBaseline } from './engineering.js';
 import { GenesisError } from './errors.js';
 import { gitContext } from './git.js';
 import { isProjectContentPath } from './paths.js';
 import { runGit } from './process.js';
-import { readStack } from './stack.js';
 import { normalizeRelative, pathState, writeFileAtomic } from './utils.js';
 
 const HOOKS_PATH = '.codex/hooks.json';
@@ -20,7 +18,7 @@ function hookCommand(action) {
 const SESSION_HOOK = {
   event: 'SessionStart',
   group: {
-    matcher: '^(startup|resume|clear|compact)$',
+    matcher: '^(startup|clear|compact)$',
     hooks: [{
       type: 'command',
       command: hookCommand('session'),
@@ -90,58 +88,6 @@ export async function installCodexHooks({ projectRoot } = {}) {
   return { status: 'updated', changedFiles: [HOOKS_PATH] };
 }
 
-async function optionalStack(projectRoot) {
-  try { return await readStack(projectRoot); } catch { return null; }
-}
-
-async function optionalEngineering(projectRoot) {
-  try {
-    return await readEngineering(projectRoot);
-  } catch {
-    return {
-      guidance: [
-        '## Universal complexity gate',
-        '',
-        await readEngineeringBaseline(),
-        '',
-        '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,
-    };
-  }
-}
-
-export async function codexSessionContext({ projectRoot } = {}) {
-  const root = (await gitContext(projectRoot)).repositoryRoot;
-  const [stack, engineering] = await Promise.all([
-    optionalStack(root),
-    optionalEngineering(root),
-  ]);
-  const selected = stack?.components.map(({ id }) => id) || [];
-  const stackStatus = stack
-    ? (selected.length > 0 ? selected.join(', ') : 'none')
-    : 'unavailable; run the Genesis `check` operation';
-  return {
-    status: 'ready',
-    output: [
-      'This is a Genesis-enriched project.',
-      '- 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.',
-      '- 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',
-      '',
-      engineering.guidance,
-    ].join('\n'),
-  };
-}
-
 function zeroPaths(buffer) {
   return [...new Set(buffer.toString('utf8').split('\0').map(normalizeRelative).filter(Boolean))];
 }

package/src/index/init.js

@@ -6,6 +6,7 @@ import { BLUEPRINT_SKELETON_SOURCE } from './blueprint.js';
 import { installCodexHooks } from './codex-hooks.js';
 import { ENGINEERING_SKELETON_SOURCE } from './engineering.js';
 import { gitContext } from './git.js';
+import { installOpenCodePlugin } from './opencode-plugin.js';
 import {
   BLUEPRINT_PATH,
   ENGINEERING_PATH,
@@ -44,22 +45,32 @@ 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 = await installCodexHooks({ projectRoot: root });
+  const [hooks, openCodePlugin] = await Promise.all([
+    installCodexHooks({ projectRoot: root }),
+    installOpenCodePlugin({ projectRoot: root }),
+  ]);
   const version = projectFormat.status === 'uninitialized'
     ? await createIfMissing(root, PROJECT_VERSION_PATH, CURRENT_PROJECT_FORMAT_SOURCE)
     : null;
-  const changedFiles = [...created, ...hooks.changedFiles, ...skills.changedFiles, version]
+  const changedFiles = [
+    ...created,
+    ...hooks.changedFiles,
+    ...openCodePlugin.changedFiles,
+    ...skills.changedFiles,
+    version,
+  ]
     .filter(Boolean)
     .sort();
   return {
     status: changedFiles.length > 0 ? 'updated' : 'unchanged',
     summary: changedFiles.length > 0
-      ? 'Initialized Genesis, Agent Skills, and the project Codex guidance hook.'
-      : 'Genesis, its Agent Skills, and the project Codex guidance hook are already initialized.',
+      ? '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.',
     changedFiles,
     diagnostics: skills.diagnostics,
     guidance: [
       'Open Codex and use /hooks to review and trust the project guidance hook.',
+      'OpenCode loads the project guidance plugin automatically.',
       '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/opencode-plugin.js

@@ -0,0 +1,28 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { gitContext } from './git.js';
+import { writeFileAtomic } from './utils.js';
+
+const OPENCODE_PLUGIN_PATH = '.opencode/plugins/genesis-project-guidance.js';
+const OPENCODE_PLUGIN_SOURCE = new URL('../../plugins/opencode/project-guidance.js', import.meta.url);
+
+async function existingSource(location) {
+  try {
+    return await readFile(location, 'utf8');
+  } catch (error) {
+    if (['ENOENT', 'ENOTDIR'].includes(error?.code)) return null;
+    throw error;
+  }
+}
+
+export async function installOpenCodePlugin({ projectRoot } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const location = path.join(root, OPENCODE_PLUGIN_PATH);
+  const source = await readFile(OPENCODE_PLUGIN_SOURCE, 'utf8');
+  if (await existingSource(location) === source) {
+    return { status: 'unchanged', changedFiles: [] };
+  }
+  await writeFileAtomic(location, source);
+  return { status: 'updated', changedFiles: [OPENCODE_PLUGIN_PATH] };
+}

package/src/index/session-context.js

@@ -0,0 +1,55 @@
+import { readEngineering, readEngineeringBaseline } from './engineering.js';
+import { gitContext } from './git.js';
+import { readStack } from './stack.js';
+
+async function optionalStack(projectRoot, stackPackages) {
+  try { return await readStack(projectRoot, { stackPackages }); } catch { return null; }
+}
+
+async function optionalEngineering(projectRoot) {
+  try {
+    return await readEngineering(projectRoot);
+  } catch {
+    return {
+      guidance: [
+        '## Universal complexity gate',
+        '',
+        await readEngineeringBaseline(),
+        '',
+        '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,
+    };
+  }
+}
+
+export async function projectSessionContext({ projectRoot, stackPackages = [] } = {}) {
+  const root = (await gitContext(projectRoot)).repositoryRoot;
+  const [stack, engineering] = await Promise.all([
+    optionalStack(root, stackPackages),
+    optionalEngineering(root),
+  ]);
+  const selected = stack?.components.map(({ id }) => id) || [];
+  const stackStatus = stack
+    ? (selected.length > 0 ? selected.join(', ') : 'none')
+    : 'unavailable; run the Genesis `check` operation';
+  return {
+    status: 'ready',
+    output: [
+      'This is a Genesis-enriched project.',
+      '- 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.',
+      '- 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 is loaded for a new session and refreshed after 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',
+      '',
+      engineering.guidance,
+    ].join('\n'),
+  };
+}