oh-my-codex 0.18.8 → 0.18.9

package/src/scripts/__tests__/codex-native-hook.test.ts

@@ -1867,6 +1867,51 @@ describe("codex native hook dispatch", () => {
     }
   });
 
+  it("includes repo-local .omx project-memory during SessionStart when OMX_ROOT is boxed", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-boxed-memory-"));
+    const boxedRoot = await mkdtemp(join(tmpdir(), "omx-native-hook-boxed-root-"));
+    const previousOmxRoot = process.env.OMX_ROOT;
+    try {
+      process.env.OMX_ROOT = boxedRoot;
+      await writeJson(join(cwd, ".omx", "project-memory.json"), {
+        techStack: "Repo-local CLI memory",
+        conventions: "SessionStart should load CLI-written project memory",
+        directives: [
+          { directive: "Prefer repo-local .omx project memory over boxed runtime fallback.", priority: "high" },
+        ],
+      });
+      await writeJson(join(boxedRoot, ".omx", "project-memory.json"), {
+        techStack: "Boxed runtime memory should not win",
+        notes: [{ category: "runtime", content: "stale boxed runtime note", timestamp: new Date().toISOString() }],
+      });
+
+      const result = await dispatchCodexNativeHook(
+        {
+          hook_event_name: "SessionStart",
+          cwd,
+          session_id: "sess-boxed-memory-1",
+        },
+        { cwd, sessionOwnerPid: 43210 },
+      );
+
+      const additionalContext = String(
+        (result.outputJson as { hookSpecificOutput?: { additionalContext?: string } })?.hookSpecificOutput?.additionalContext ?? "",
+      );
+      assert.match(additionalContext, /\[Project memory\]/);
+      assert.match(additionalContext, /source: \.omx\/project-memory\.json/);
+      assert.match(additionalContext, /Repo-local CLI memory/);
+      assert.match(additionalContext, /SessionStart should load CLI-written project memory/);
+      assert.match(additionalContext, /Prefer repo-local \.omx project memory over boxed runtime fallback\./);
+      assert.doesNotMatch(additionalContext, /Boxed runtime memory should not win/);
+      assert.doesNotMatch(additionalContext, /stale boxed runtime note/);
+    } finally {
+      if (previousOmxRoot === undefined) delete process.env.OMX_ROOT;
+      else process.env.OMX_ROOT = previousOmxRoot;
+      await rm(cwd, { recursive: true, force: true });
+      await rm(boxedRoot, { recursive: true, force: true });
+    }
+  });
+
   it("prefers repository project-memory.json during SessionStart while preserving legacy wiki guidance", async () => {
     const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-session-root-memory-legacy-wiki-"));
     try {
@@ -13932,6 +13977,136 @@ exit 0
     }
   });
 
+  it("blocks implementation writes when Autopilot ralplan is visible only in skill-active phase", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-skill-ralplan-pretool-block-"));
+    try {
+      const stateDir = join(cwd, ".omx", "state");
+      const sessionId = "sess-autopilot-skill-ralplan-pretool-block";
+      await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+      await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+      await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+        active: true,
+        skill: "autopilot",
+        phase: "autopilot:ralplan",
+        session_id: sessionId,
+        active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
+      });
+      await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+        active: true,
+        mode: "autopilot",
+        current_phase: "planning",
+        session_id: sessionId,
+        state: {
+          handoff_artifacts: {
+            ralplan_consensus_gate: { required: true, complete: false },
+          },
+        },
+      });
+
+      const result = await dispatchCodexNativeHook(
+        {
+          hook_event_name: "PreToolUse",
+          cwd,
+          session_id: sessionId,
+          thread_id: "thread-autopilot-skill-ralplan-pretool-block",
+          tool_name: "Edit",
+          tool_input: { file_path: "src/runtime.ts" },
+        },
+        { cwd },
+      );
+
+      assert.equal(result.omxEventName, "pre-tool-use");
+      assert.equal(result.outputJson?.decision, "block");
+      assert.match(String(result.outputJson?.reason ?? ""), /Autopilot planning is active .*implementation\/write tools are blocked/i);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("ignores stale Autopilot ralplan skill mirrors after detail state leaves planning", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-stale-ralplan-mirror-"));
+    try {
+      const stateDir = join(cwd, ".omx", "state");
+      const sessionId = "sess-autopilot-stale-ralplan-mirror";
+      await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+      await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+      await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+        active: true,
+        skill: "autopilot",
+        phase: "autopilot:ralplan",
+        session_id: sessionId,
+        active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
+      });
+
+      for (const phase of ["ultragoal", "code-review", "completing", "complete"]) {
+        await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+          active: true,
+          mode: "autopilot",
+          current_phase: phase,
+          session_id: sessionId,
+        });
+
+        const result = await dispatchCodexNativeHook(
+          {
+            hook_event_name: "PreToolUse",
+            cwd,
+            session_id: sessionId,
+            thread_id: "thread-autopilot-stale-ralplan-mirror",
+            tool_name: "Edit",
+            tool_input: { file_path: "src/runtime.ts" },
+          },
+          { cwd },
+        );
+
+        assert.equal(result.omxEventName, "pre-tool-use");
+        assert.equal(result.outputJson, null, `stale skill-active ralplan mirror must not block when Autopilot detail phase is ${phase}`);
+      }
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("allows explicit blank Autopilot detail phase to use a ralplan skill mirror", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-blank-phase-mirror-"));
+    try {
+      const stateDir = join(cwd, ".omx", "state");
+      const sessionId = "sess-autopilot-blank-phase-mirror";
+      await mkdir(join(stateDir, "sessions", sessionId), { recursive: true });
+      await writeJson(join(stateDir, "session.json"), { session_id: sessionId });
+      await writeJson(join(stateDir, "sessions", sessionId, "skill-active-state.json"), {
+        active: true,
+        skill: "autopilot",
+        phase: "autopilot:ralplan",
+        session_id: sessionId,
+        active_skills: [{ skill: "autopilot", phase: "autopilot:ralplan", active: true, session_id: sessionId }],
+      });
+      await writeJson(join(stateDir, "sessions", sessionId, "autopilot-state.json"), {
+        active: true,
+        mode: "autopilot",
+        current_phase: "",
+        session_id: sessionId,
+      });
+
+      const result = await dispatchCodexNativeHook(
+        {
+          hook_event_name: "PreToolUse",
+          cwd,
+          session_id: sessionId,
+          thread_id: "thread-autopilot-blank-phase-mirror",
+          tool_name: "Edit",
+          tool_input: { file_path: "src/runtime.ts" },
+        },
+        { cwd },
+      );
+
+      assert.equal(result.omxEventName, "pre-tool-use");
+      assert.equal(result.outputJson?.decision, "block");
+      assert.match(String(result.outputJson?.reason ?? ""), /Autopilot planning is active .*implementation\/write tools are blocked/i);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
   it("does not block implementation writes from Autopilot ralplan detail state without canonical skill state", async () => {
     const cwd = await mkdtemp(join(tmpdir(), "omx-native-hook-autopilot-ralplan-no-canonical-"));
     try {

package/src/scripts/codex-native-hook.ts

@@ -83,6 +83,7 @@ import {
   onSessionStart as buildWikiSessionStartContext,
 } from "../wiki/lifecycle.js";
 import { readAutoresearchCompletionStatus, readAutoresearchModeStateForActiveDecision } from "../autoresearch/skill-validation.js";
+import { normalizeAutopilotPhase } from "../autopilot/fsm.js";
 import { readRunState } from "../runtime/run-state.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { getRunContinuationSnapshot, shouldContinueRun } from "../runtime/run-loop.js";
@@ -2592,12 +2593,12 @@ function isActiveRalplanPhase(state: Record<string, unknown> | null): boolean {
   return true;
 }
 
-function isActiveAutopilotRalplanPhase(state: Record<string, unknown> | null): boolean {
-  if (!state || state.active !== true) return false;
-  const mode = safeString(state.mode).trim();
-  if (mode && mode !== "autopilot") return false;
-  const phase = safeString(state.current_phase ?? state.currentPhase).trim().toLowerCase();
-  return phase === "ralplan" || phase === "replan" || phase === "autopilot:replan";
+function isAutopilotRalplanLikePhase(phase: string): boolean {
+  return normalizeAutopilotPhase(phase) === "ralplan";
+}
+
+function canAutopilotSkillMirrorSupplyRalplanPhase(phase: string): boolean {
+  return phase === "" || normalizeAutopilotPhase(phase) === "ralplan";
 }
 
 function hasExplicitExecutionHandoffSkill(
@@ -2733,7 +2734,9 @@ async function readActiveRalplanStateForPreToolUse(
   const autopilotState = sessionId
     ? await readStopSessionPinnedState("autopilot-state.json", cwd, sessionId, stateDir)
     : await readJsonIfExists(join(stateDir, "autopilot-state.json"));
-  if (!isActiveAutopilotRalplanPhase(autopilotState) || !autopilotState) return null;
+  if (!autopilotState || autopilotState.active !== true) return null;
+  const autopilotMode = safeString(autopilotState.mode).trim();
+  if (autopilotMode && autopilotMode !== "autopilot") return null;
   if (!modeStateMatchesSkillStopContext(autopilotState, cwd, sessionId)) return null;
   const terminalAutopilotRunState = await readCanonicalTerminalRunStateForStop(cwd, sessionId, "autopilot");
   if (terminalAutopilotRunState) return null;
@@ -2742,6 +2745,15 @@ async function readActiveRalplanStateForPreToolUse(
     entry.skill === "autopilot"
     && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)
   ));
+  if (!hasActiveAutopilotSkill) return null;
+  const autopilotStatePhase = safeString(autopilotState.current_phase ?? autopilotState.currentPhase).trim().toLowerCase();
+  if (!canAutopilotSkillMirrorSupplyRalplanPhase(autopilotStatePhase)) return null;
+  const hasRalplanScopedAutopilotSkill = listActiveSkills(canonicalState).some((entry) => (
+    entry.skill === "autopilot"
+    && isAutopilotRalplanLikePhase(safeString(entry.phase).trim().toLowerCase())
+    && matchesSkillStopContext(entry, canonicalState, sessionId, threadId)
+  ));
+  if (!isAutopilotRalplanLikePhase(autopilotStatePhase) && !hasRalplanScopedAutopilotSkill) return null;
   return hasActiveAutopilotSkill ? autopilotState : null;
 }
 

package/src/scripts/prepare-build.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { existsSync, rmSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const requiredDistFiles = [
+  join(process.cwd(), 'dist', 'cli', 'omx.js'),
+  join(process.cwd(), 'dist', 'scripts', 'postinstall.js'),
+];
+
+if (requiredDistFiles.every((file) => existsSync(file))) {
+  process.exit(0);
+}
+
+const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const tscBin = process.platform === 'win32'
+  ? join(process.cwd(), 'node_modules', '.bin', 'tsc.cmd')
+  : join(process.cwd(), 'node_modules', '.bin', 'tsc');
+const nodeModulesDir = join(process.cwd(), 'node_modules');
+
+function runNpm(args, env = process.env) {
+  return spawnSync(npmBin, args, {
+    cwd: process.cwd(),
+    stdio: process.env.npm_config_json === 'true' ? ['inherit', 'ignore', 'inherit'] : 'inherit',
+    env,
+  });
+}
+
+function exitOnFailure(result, label) {
+  if (result.error) {
+    console.error(`omx prepare: failed to launch ${label}: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.status !== 0) {
+    process.exit(typeof result.status === 'number' ? result.status : 1);
+  }
+}
+
+let shouldCleanupBootstrappedDependencies = false;
+
+if (!existsSync(tscBin)) {
+  const hadNodeModules = existsSync(nodeModulesDir);
+  const installResult = runNpm(
+    [
+      'install',
+      '--global=false',
+      '--location=project',
+      '--include=dev',
+      '--ignore-scripts',
+      '--no-audit',
+      '--no-progress',
+    ],
+    {
+      ...process.env,
+      npm_config_global: 'false',
+      npm_config_location: 'project',
+    },
+  );
+  exitOnFailure(installResult, 'npm dependency bootstrap');
+  shouldCleanupBootstrappedDependencies = !hadNodeModules;
+}
+
+const pathWithLocalBins = [
+  join(process.cwd(), 'node_modules', '.bin'),
+  process.env.PATH ?? '',
+].filter(Boolean).join(delimiter);
+
+const buildResult = spawnSync(npmBin, ['run', 'build'], {
+  cwd: process.cwd(),
+  stdio: process.env.npm_config_json === 'true' ? ['inherit', 'ignore', 'inherit'] : 'inherit',
+  env: { ...process.env, PATH: pathWithLocalBins },
+});
+exitOnFailure(buildResult, 'npm build');
+
+if (shouldCleanupBootstrappedDependencies) {
+  try {
+    rmSync(nodeModulesDir, { recursive: true, force: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[omx:prepare] Warning: could not remove bootstrapped node_modules: ${message}`);
+  }
+}

package/src/scripts/postinstall-bootstrap.js

@@ -1,23 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const distScriptPath = join(__dirname, "..", "..", "dist", "scripts", "postinstall.js");
-
-if (!existsSync(distScriptPath)) {
-  process.exit(0);
-}
-
-const moduleUrl = pathToFileURL(distScriptPath).href;
-try {
-  const postinstallModule = await import(moduleUrl);
-  if (typeof postinstallModule.main === "function") {
-    await postinstallModule.main();
-  }
-} catch (error) {
-  console.warn(
-    `[omx] Postinstall bootstrap skipped after a non-fatal error: ${error instanceof Error ? error.message : String(error)}`,
-  );
-}