genesis-compiler 1.7.1 → 1.7.3

package/docs/prompt-integration.md

@@ -90,6 +90,32 @@ 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
 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 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.
+
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-compiler",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "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/profiles/engineering/baseline.md

@@ -6,3 +6,4 @@
 - If good software requires material complexity beyond these rules, stop before writing it. Explain the requirement, why the direct design is insufficient, and the smallest added complexity proposed, then ask the user to approve or clarify the tradeoff.
 - During implementation, run the relevant checks and batch related cases when they share setup. Follow the project's verification policy for broad or final checks; do not repeat them merely because an item finishes or a session resumes. Preserve required coverage and isolation.
 - Keep complete test output in local artifacts and preserve exit status. Read concise counts, timings and actionable failure excerpts first, expanding evidence only when needed. Do not load full passing reports or repeatedly poll unchanged logs into agent context. Retain startup and cleanup failures; retry only after a change or new evidence justifies it.
+- For browser verification, batch related actions and return only the relevant values or page region. Capture screenshots at meaningful visual checkpoints or failures, not after every action. Preserve required viewport, identity and security coverage; prefer existing automated cases for repeated checks.

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/codex-hooks.js

@@ -24,7 +24,7 @@ const SESSION_HOOK = {
       type: 'command',
       command: hookCommand('session'),
       commandWindows: 'genesis hook session',
-      timeout: 5,
+      timeout: 30,
       statusMessage: 'Loading Genesis guidance',
       additionalContextLimit: 4000,
     }],
@@ -38,7 +38,7 @@ const TURN_HOOK = {
       type: 'command',
       command: hookCommand('turn'),
       commandWindows: 'genesis hook turn',
-      timeout: 5,
+      timeout: 30,
       additionalContextLimit: 512,
     }],
   },

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

@@ -226,3 +226,4 @@ export async function syncSkills(options) {
 }
 
 export { inspectSubsystems } from './index/subsystems.js';
+export { inspectOpenCodePlugin, installOpenCodePlugin as syncOpenCodePlugin } from './index/opencode-plugin.js';