oh-my-codex 0.20.2 → 0.20.5

package/src/scripts/__tests__/issue-3369-autopilot-ralplan-state-machine.test.ts

@@ -0,0 +1,211 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { dispatchCodexNativeHook } from "../codex-native-hook.js";
+import { executeStateOperation } from "../../state/operations.js";
+
+const omxBin = fileURLToPath(new URL("../../cli/omx.js", import.meta.url));
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(value, null, 2));
+}
+
+function runOmx(cwd: string, env: NodeJS.ProcessEnv, ...args: string[]) {
+  return spawnSync(process.execPath, [omxBin, ...args], {
+    cwd,
+    encoding: "utf-8",
+    env: { ...process.env, ...env },
+  });
+}
+
+async function withEnv<T>(values: Record<string, string | undefined>, run: () => Promise<T>): Promise<T> {
+  const before = new Map(Object.keys(values).map((name) => [name, process.env[name]]));
+  try {
+    for (const [name, value] of Object.entries(values)) {
+      if (value === undefined) delete process.env[name];
+      else process.env[name] = value;
+    }
+    return await run();
+  } finally {
+    for (const [name, value] of before) {
+      if (value === undefined) delete process.env[name];
+      else process.env[name] = value;
+    }
+  }
+}
+
+describe("issue #3369 Autopilot Ralplan state-machine self-lock", () => {
+  it("cancels identity-stripped Autopilot Ralplan state without executing Bash", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-3369-ralplan-cancel-"));
+    const sessionId = "sess-3369-ralplan-cancel";
+    const threadId = "thread-3369-ralplan-cancel";
+    const stateDir = join(cwd, ".omx", "state");
+    const sessionDir = join(stateDir, "sessions", sessionId);
+    try {
+      await writeJson(join(stateDir, "session.json"), {
+        session_id: sessionId,
+        cwd,
+        leader_thread_id: threadId,
+      });
+      await writeJson(join(stateDir, "subagent-tracking.json"), {
+        schemaVersion: 1,
+        sessions: {
+          [sessionId]: {
+            session_id: sessionId,
+            leader_thread_id: threadId,
+            threads: { [threadId]: { thread_id: threadId, kind: "leader" } },
+          },
+        },
+      });
+      await writeJson(join(sessionDir, "autopilot-state.json"), {
+        active: true,
+        current_phase: "ralplan",
+        run_outcome: "continue",
+      });
+      await writeJson(join(sessionDir, "skill-active-state.json"), {
+        version: 1,
+        active: true,
+        skill: "autopilot",
+        phase: "ralplan",
+        source: "state-operations",
+        session_id: sessionId,
+        active_skills: [{
+          skill: "autopilot",
+          phase: "ralplan",
+          active: true,
+          session_id: sessionId,
+        }],
+      });
+
+      const result = await dispatchCodexNativeHook({
+        hook_event_name: "PreToolUse",
+        cwd,
+        session_id: sessionId,
+        thread_id: threadId,
+        agent_id: threadId,
+        tool_name: "Bash",
+        tool_input: { command: "omx cancel" },
+      }, { cwd });
+
+      assert.equal(result.outputJson?.decision, "block");
+      assert.match(JSON.stringify(result.outputJson), /cancelled_exact_session/);
+      assert.equal(JSON.parse(await readFile(join(sessionDir, "autopilot-state.json"), "utf8")).active, false);
+      assert.equal(JSON.parse(await readFile(join(sessionDir, "skill-active-state.json"), "utf8")).active, false);
+
+      const stop1 = await dispatchCodexNativeHook({
+        hook_event_name: "Stop",
+        cwd,
+        session_id: sessionId,
+        thread_id: threadId,
+      }, { cwd });
+      const stop2 = await dispatchCodexNativeHook({
+        hook_event_name: "Stop",
+        cwd,
+        session_id: sessionId,
+        thread_id: threadId,
+      }, { cwd });
+      assert.equal(stop1.outputJson, null);
+      assert.equal(stop2.outputJson, null);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("treats blank optional skill owners as absent for exact-session cancel", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-3369-blank-owner-"));
+    const sessionId = "sess-3369-blank-owner";
+    const nativeSessionId = "native-3369-blank-owner";
+    const stateDir = join(cwd, ".omx", "state");
+    const sessionDir = join(stateDir, "sessions", sessionId);
+    try {
+      await writeJson(join(stateDir, "session.json"), {
+        session_id: sessionId,
+        native_session_id: nativeSessionId,
+        cwd,
+        platform: process.platform,
+        state_root: stateDir,
+      });
+      await mkdir(join(stateDir, "sessions", nativeSessionId), { recursive: true });
+      await writeJson(join(stateDir, "sessions", nativeSessionId, "session-owner.json"), {
+        session_id: nativeSessionId,
+        native_session_id: nativeSessionId,
+        cwd,
+        platform: process.platform,
+      });
+      await writeJson(join(sessionDir, "autopilot-state.json"), {
+        active: true,
+        mode: "autopilot",
+        current_phase: "ralplan",
+        session_id: sessionId,
+      });
+      await writeJson(join(sessionDir, "skill-active-state.json"), {
+        active: true,
+        skill: "autopilot",
+        phase: "ralplan",
+        session_id: sessionId,
+        owner_codex_session_id: "",
+        active_skills: [{
+          skill: "autopilot",
+          phase: "ralplan",
+          active: true,
+          session_id: sessionId,
+          owner_codex_session_id: "",
+        }],
+      });
+
+      const result = runOmx(cwd, { OMX_ROOT: cwd, OMX_SESSION_ID: sessionId }, "cancel");
+      assert.equal(result.status, 0, result.stderr || result.stdout);
+      assert.match(result.stdout, /Cancelled: autopilot/);
+      assert.equal(JSON.parse(await readFile(join(sessionDir, "autopilot-state.json"), "utf8")).active, false);
+      assert.equal(JSON.parse(await readFile(join(sessionDir, "skill-active-state.json"), "utf8")).active, false);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("blocks fresh Autopilot admission before creating state files", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "omx-3369-fresh-admission-"));
+    try {
+      await withEnv({ OMX_ROOT: cwd, OMX_SESSION_ID: undefined }, async () => {
+        const sessionDir = join(cwd, ".omx", "state", "sessions", "sess-3369-fresh");
+        await writeJson(join(sessionDir, "ralplan-state.json"), {
+          active: true,
+          current_phase: "planning",
+          run_outcome: "continue",
+        });
+        await writeJson(join(sessionDir, "skill-active-state.json"), {
+          version: 1,
+          active: true,
+          skill: "ralplan",
+          phase: "planning",
+          source: "test-fixture",
+          session_id: "sess-3369-fresh",
+          active_skills: [{
+            skill: "ralplan",
+            phase: "planning",
+            active: true,
+            session_id: "sess-3369-fresh",
+          }],
+        });
+
+        const response = await executeStateOperation("state_write", {
+          workingDirectory: cwd,
+          mode: "autopilot",
+          active: true,
+          current_phase: "deep-interview",
+          session_id: "sess-3369-fresh",
+        });
+        assert.equal(response.isError, true);
+        assert.match(String((response.payload as { error?: string }).error || ""), /documented_host_consensus_receipt_unavailable/);
+        await assert.rejects(readFile(join(sessionDir, "autopilot-state.json")));
+      });
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+});

package/src/scripts/__tests__/notify-state-io.test.ts

@@ -15,6 +15,7 @@ import {
   resolveScopedStateDir,
   writeScopedJson,
 } from '../notify-hook/state-io.js';
+import { SkillActiveStateWriteError } from '../../state/skill-active.js';
 
 describe('notify-hook state I/O session authority', () => {
   it('uses an explicit session id before the current session pointer', async () => {
@@ -238,4 +239,32 @@ describe('notify-hook state I/O session authority', () => {
       await rm(wd, { recursive: true, force: true });
     }
   });
+  it('fails explicit skill-active writes closed on malformed root without session divergence', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-state-io-malformed-root-'));
+    try {
+      const stateDir = join(wd, '.omx', 'state');
+      const sessionId = 'sess-explicit-malformed-root';
+      const sessionPath = join(stateDir, 'sessions', sessionId, 'skill-active-state.json');
+      const rootBytes = '{"active":true,\n';
+      const sessionBytes = '{"active":true,"skill":"old"}\n';
+      await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+      await writeFile(join(stateDir, 'skill-active-state.json'), rootBytes, 'utf8');
+      await writeFile(sessionPath, sessionBytes, 'utf8');
+
+      await assert.rejects(
+        () => writeScopedJson(stateDir, 'skill-active-state.json', sessionId, {
+          active: true,
+          skill: 'new',
+          phase: 'executing',
+          session_id: sessionId,
+          active_skills: [{ skill: 'new', phase: 'executing', active: true, session_id: sessionId }],
+        }),
+        (error) => error instanceof SkillActiveStateWriteError && error.code === 'malformed-root',
+      );
+      assert.equal(await readFile(join(stateDir, 'skill-active-state.json'), 'utf8'), rootBytes);
+      assert.equal(await readFile(sessionPath, 'utf8'), sessionBytes);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
 });

package/src/scripts/__tests__/notify-tmux-injection.test.ts

@@ -4,7 +4,7 @@ import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { readVisibleAllowedModes } from '../notify-hook/tmux-injection.js';
+import { isNotifyModeStateFilename, readVisibleAllowedModes } from '../notify-hook/tmux-injection.js';
 
 describe('notify-hook tmux injection canonical skill gating', () => {
   it('reads canonical skill-active state from authoritative team state root', async () => {
@@ -79,4 +79,29 @@ describe('notify-hook tmux injection canonical skill gating', () => {
       await rm(wd, { recursive: true, force: true });
     }
   });
+
+  it('ignores derived run-state.json when scanning active mode states', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-tmux-derived-run-state-'));
+    try {
+      const stateDir = join(wd, '.omx', 'state');
+      const sessionId = 'sess-derived-run-state';
+      await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+      await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd }, null, 2));
+      await writeFile(join(stateDir, 'sessions', sessionId, 'run-state.json'), JSON.stringify({ active: true, mode: 'run' }, null, 2));
+      await writeFile(join(stateDir, 'sessions', sessionId, 'ralph-state.json'), JSON.stringify({ active: true, mode: 'ralph' }, null, 2));
+
+      const visible = await readVisibleAllowedModes(wd, stateDir, {}, ['ralph', 'run']);
+
+      assert.equal(visible.preferredMode, null);
+      assert.equal(visible.canonicalPresent, false);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('filters only derived run-state while retaining genuine state filenames', () => {
+    assert.equal(isNotifyModeStateFilename('run-state.json'), false);
+    assert.equal(isNotifyModeStateFilename('ralph-state.json'), true);
+    assert.equal(isNotifyModeStateFilename('tmux-hook-state.json'), false);
+  });
 });

package/src/scripts/__tests__/postinstall.test.ts

@@ -24,7 +24,7 @@ describe("isGlobalInstallLifecycle", () => {
 });
 
 describe("runPostinstall", () => {
-  it("records the installed version and prints an explicit opt-in setup hint for bumped global installs", async () => {
+  it("clears stale Bun provenance for a global replacement while printing an explicit opt-in setup hint", async () => {
     const root = await mkdtemp(join(tmpdir(), "omx-postinstall-"));
     const stampPath = join(root, ".codex", ".omx", "install-state.json");
     const logs: string[] = [];
@@ -37,6 +37,7 @@ describe("runPostinstall", () => {
         readStamp: async () => ({
           installed_version: "0.14.0",
           setup_completed_version: "0.14.0",
+          package_manager: "bun",
           updated_at: "2026-04-20T00:00:00.000Z",
         }),
         writeStamp: async (stamp) => writeUserInstallStamp(stamp, stampPath),
@@ -48,9 +49,11 @@ describe("runPostinstall", () => {
       const stamp = JSON.parse(await readFile(stampPath, "utf-8")) as {
         installed_version: string;
         setup_completed_version: string;
+        package_manager?: string;
       };
       assert.equal(stamp.installed_version, "0.14.1");
       assert.equal(stamp.setup_completed_version, "0.14.0");
+      assert.equal(stamp.package_manager, undefined);
     } finally {
       await rm(root, { recursive: true, force: true });
     }
@@ -88,6 +91,25 @@ describe("runPostinstall", () => {
     }
   });
 
+  it("does not infer Bun provenance from a Bun user agent", async () => {
+    let writtenStamp: { package_manager?: "npm" | "bun" } | undefined;
+
+    const result = await runPostinstall({
+      env: {
+        npm_config_global: "true",
+        npm_config_user_agent: "bun/1.2.0 npm/? node/v22.0.0 linux x64",
+      },
+      getCurrentVersion: async () => "0.14.1",
+      readStamp: async () => null,
+      writeStamp: async (stamp) => {
+        writtenStamp = stamp;
+      },
+    });
+
+    assert.equal(result.status, "hinted");
+    assert.equal(writtenStamp?.package_manager, undefined);
+  });
+
   it("skips local installs", async () => {
     const result = await runPostinstall({
       env: { npm_config_global: "false" },

package/src/scripts/__tests__/reasoning-artifact-contract.test.ts

@@ -0,0 +1,129 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parse as parseToml } from '@iarna/toml';
+import { test } from 'node:test';
+import {
+  assertInstalledReasoningDeclarationContract,
+  assertInstalledRootReasoningHelp,
+  assertInstalledRootReasoningRejection,
+  assertInstalledTeamSkillContract,
+} from '../smoke-packed-install.js';
+
+const root = process.cwd();
+const dist = join(root, 'dist');
+
+function read(relativePath: string): string {
+  return readFileSync(join(root, relativePath), 'utf-8');
+}
+
+test('compiled reasoning artifacts preserve exact surface-specific max contracts', async () => {
+  const requiredArtifacts = [
+    'dist/config/models.js',
+    'dist/config/models.d.ts',
+    'dist/agents/definitions.js',
+    'dist/agents/definitions.d.ts',
+    'dist/agents/native-config.js',
+    'dist/agents/native-config.d.ts',
+    'dist/team/model-contract.js',
+    'dist/team/model-contract.d.ts',
+    'dist/cli/index.js',
+    'dist/cli/index.d.ts',
+    'dist/cli/omx.js',
+    'dist/cli/omx.d.ts',
+  ];
+  for (const relativePath of requiredArtifacts) {
+    assert.equal(existsSync(join(root, relativePath)), true, `missing compiled artifact: ${relativePath}`);
+  }
+
+  const modelsDeclaration = read('dist/config/models.d.ts');
+  const definitionsDeclaration = read('dist/agents/definitions.d.ts');
+  const nativeDeclaration = read('dist/agents/native-config.d.ts');
+  const teamDeclaration = read('dist/team/model-contract.d.ts');
+  assertInstalledReasoningDeclarationContract({
+    models: modelsDeclaration,
+    definitions: definitionsDeclaration,
+    nativeConfig: nativeDeclaration,
+    team: teamDeclaration,
+  });
+
+  const models = await import(pathToFileURL(join(dist, 'config/models.js')).href);
+  assert.deepEqual(models.CANONICAL_REASONING_EFFORTS, ['low', 'medium', 'high', 'xhigh']);
+  assert.deepEqual(models.AMBIGUOUS_UNSUPPORTED_REASONING_EFFORTS, ['max', 'ultra']);
+  assert.deepEqual(models.PER_AGENT_REASONING_EFFORTS, ['low', 'medium', 'high', 'xhigh', 'max']);
+  assert.deepEqual(models.ROOT_REASONING_EFFORTS, ['low', 'medium', 'high', 'xhigh']);
+  assert.deepEqual(models.ROOT_UNSUPPORTED_REASONING_EFFORTS, ['max', 'ultra']);
+  assert.equal(models.isAmbiguousUnsupportedReasoningEffort('MAX'), true);
+  assert.equal(models.isUnsupportedRootReasoningEffort('MAX'), true);
+  assert.equal(models.isUnsupportedRootReasoningEffort('ultra'), true);
+  assert.equal(models.isUnsupportedRootReasoningEffort('xhigh'), false);
+  assert.equal(models.normalizeUnsupportedRootReasoningEffort(' MAX '), 'max');
+  assert.equal(models.normalizeUnsupportedRootReasoningEffort('Ultra'), 'ultra');
+  assert.equal(models.normalizeUnsupportedRootReasoningEffort('xhigh'), undefined);
+
+  const nativeConfig = await import(pathToFileURL(join(dist, 'agents/native-config.js')).href);
+  const definitions = await import(pathToFileURL(join(dist, 'agents/definitions.js')).href);
+  const codexHome = mkdtempSync(join(tmpdir(), 'omx-artifact-max-native-'));
+  try {
+    writeFileSync(join(codexHome, '.omx-config.json'), JSON.stringify({
+      agentReasoning: { architect: ' MAX ', critic: 'ultra' },
+    }));
+    const maxToml = nativeConfig.generateAgentToml(
+      definitions.AGENT_DEFINITIONS.architect,
+      'compiled native max contract',
+      { codexHomeOverride: codexHome },
+    );
+    assert.match(maxToml, /model_reasoning_effort = "max"/);
+    assert.doesNotMatch(maxToml, /model_reasoning_effort = "xhigh"/);
+    assert.equal((parseToml(maxToml) as { model_reasoning_effort?: unknown }).model_reasoning_effort, 'max');
+
+    const fallbackToml = nativeConfig.generateAgentToml(
+      definitions.AGENT_DEFINITIONS.critic,
+      'compiled native ultra fallback contract',
+      { codexHomeOverride: codexHome },
+    );
+    assert.match(fallbackToml, /model_reasoning_effort = "high"/);
+    assert.doesNotMatch(fallbackToml, /model_reasoning_effort = "ultra"/);
+  } finally {
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+
+  const team = await import(pathToFileURL(join(dist, 'team/model-contract.js')).href);
+  const maxArgs = team.resolveTeamWorkerLaunchArgs({ preferredReasoning: 'max' });
+  assert.deepEqual(maxArgs, ['-c', 'model_reasoning_effort="max"']);
+  assert.equal(maxArgs.includes('model_reasoning_effort="xhigh"'), false);
+  const opaqueUltra = team.resolveTeamWorkerLaunchDiagnostics({
+    existingRaw: '-c model_reasoning_effort="ultra"',
+    preferredReasoning: 'max',
+  });
+  assert.equal(opaqueUltra.reasoningSource, 'explicit');
+  assert.equal(opaqueUltra.actualReasoning, undefined);
+
+  const canonicalSkill = readFileSync(join(root, 'skills/team/SKILL.md'));
+  const pluginSkill = readFileSync(join(root, 'plugins/oh-my-codex/skills/team/SKILL.md'));
+  assertInstalledTeamSkillContract(canonicalSkill, pluginSkill);
+});
+
+test('compiled root reasoning keeps four-value help and rejects max/ultra without mutation', () => {
+  const omxPath = join(dist, 'cli/omx.js');
+  const codexHome = mkdtempSync(join(tmpdir(), 'omx-artifact-root-reasoning-'));
+  try {
+    const env = { ...process.env, CODEX_HOME: codexHome };
+    const configPath = join(codexHome, 'config.toml');
+    const help = spawnSync(process.execPath, [omxPath, 'reasoning'], { encoding: 'utf-8', env });
+    assert.equal(help.status, 0, help.stderr);
+    assertInstalledRootReasoningHelp(help.stdout);
+    const max = spawnSync(process.execPath, [omxPath, 'reasoning', 'max'], { encoding: 'utf-8', env });
+    assertInstalledRootReasoningRejection('max', max, undefined, existsSync(configPath) ? readFileSync(configPath, 'utf-8') : undefined);
+
+    const originalConfig = 'model = "preserve-root-config"\n';
+    writeFileSync(configPath, originalConfig);
+    const ultra = spawnSync(process.execPath, [omxPath, 'reasoning', 'ultra'], { encoding: 'utf-8', env });
+    assertInstalledRootReasoningRejection('ultra', ultra, originalConfig, readFileSync(configPath, 'utf-8'));
+  } finally {
+    rmSync(codexHome, { recursive: true, force: true });
+  }
+});