oh-my-codex 0.18.6 → 0.18.8

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

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 
 import {
   getScopedStatePath,
+  readCurrentSessionId,
   readScopedJsonIfExists,
   resolveScopedStateDir,
   writeScopedJson,
@@ -70,4 +71,98 @@ describe('notify-hook state I/O session authority', () => {
       await rm(wd, { recursive: true, force: true });
     }
   });
+
+  it('resolves current session from authoritative team state root without cwd inference', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-state-io-team-root-'));
+    try {
+      const teamStateRoot = join(wd, 'team-state-root');
+      await mkdir(join(teamStateRoot, 'sessions', 'sess-team-root'), { recursive: true });
+      await writeFile(
+        join(teamStateRoot, 'session.json'),
+        JSON.stringify({ session_id: 'sess-team-root', cwd: join(wd, 'source-repo') }, null, 2),
+        'utf-8',
+      );
+      await writeFile(
+        join(teamStateRoot, 'hud-state.json'),
+        JSON.stringify({ turn_count: 99 }, null, 2),
+        'utf-8',
+      );
+      await writeFile(
+        join(teamStateRoot, 'sessions', 'sess-team-root', 'hud-state.json'),
+        JSON.stringify({ turn_count: 4 }, null, 2),
+        'utf-8',
+      );
+
+      assert.equal(await resolveScopedStateDir(teamStateRoot), join(teamStateRoot, 'sessions', 'sess-team-root'));
+      const value = await readScopedJsonIfExists(teamStateRoot, 'hud-state.json', undefined, null);
+      assert.equal(value?.turn_count, 4);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('prefers OMX_SESSION_ID over stale session.json for notify state writes', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-state-io-env-'));
+    const previousSessionId = process.env.OMX_SESSION_ID;
+    try {
+      const stateDir = join(wd, '.omx', 'state');
+      await mkdir(join(stateDir, 'sessions', 'sess-env'), { recursive: true });
+      await mkdir(join(stateDir, 'sessions', 'sess-stale'), { recursive: true });
+      await writeFile(
+        join(stateDir, 'session.json'),
+        JSON.stringify({ session_id: 'sess-stale', cwd: join(wd, '..', 'other-worktree') }, null, 2),
+        'utf-8',
+      );
+      process.env.OMX_SESSION_ID = 'sess-env';
+
+      assert.equal(await readCurrentSessionId(stateDir), 'sess-env');
+      assert.equal(await resolveScopedStateDir(stateDir), join(stateDir, 'sessions', 'sess-env'));
+
+      await writeScopedJson(stateDir, 'hud-state.json', undefined, { turn_count: 7 });
+      const value = JSON.parse(
+        await readFile(join(stateDir, 'sessions', 'sess-env', 'hud-state.json'), 'utf-8'),
+      ) as { turn_count?: unknown };
+      assert.equal(value.turn_count, 7);
+    } finally {
+      if (typeof previousSessionId === 'string') process.env.OMX_SESSION_ID = previousSessionId;
+      else delete process.env.OMX_SESSION_ID;
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('maps native Codex session aliases to the canonical OMX session', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-state-io-native-alias-'));
+    const previousOmxSessionId = process.env.OMX_SESSION_ID;
+    const previousCodexSessionId = process.env.CODEX_SESSION_ID;
+    try {
+      const stateDir = join(wd, '.omx', 'state');
+      await mkdir(join(stateDir, 'sessions', 'omx-canonical'), { recursive: true });
+      await writeFile(
+        join(stateDir, 'session.json'),
+        JSON.stringify({
+          session_id: 'omx-canonical',
+          native_session_id: 'codex-native',
+          cwd: wd,
+        }, null, 2),
+        'utf-8',
+      );
+      delete process.env.OMX_SESSION_ID;
+      process.env.CODEX_SESSION_ID = 'codex-native';
+
+      assert.equal(await readCurrentSessionId(stateDir), 'omx-canonical');
+      assert.equal(await resolveScopedStateDir(stateDir), join(stateDir, 'sessions', 'omx-canonical'));
+
+      await writeScopedJson(stateDir, 'hud-state.json', undefined, { turn_count: 11 });
+      const value = JSON.parse(
+        await readFile(join(stateDir, 'sessions', 'omx-canonical', 'hud-state.json'), 'utf-8'),
+      ) as { turn_count?: unknown };
+      assert.equal(value.turn_count, 11);
+    } finally {
+      if (typeof previousOmxSessionId === 'string') process.env.OMX_SESSION_ID = previousOmxSessionId;
+      else delete process.env.OMX_SESSION_ID;
+      if (typeof previousCodexSessionId === 'string') process.env.CODEX_SESSION_ID = previousCodexSessionId;
+      else delete process.env.CODEX_SESSION_ID;
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -0,0 +1,82 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+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';
+
+describe('notify-hook tmux injection canonical skill gating', () => {
+  it('reads canonical skill-active state from authoritative team state root', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-tmux-team-root-'));
+    try {
+      const teamStateRoot = join(wd, 'team-state-root');
+      const sessionId = 'sess-team-root';
+      await mkdir(join(teamStateRoot, 'sessions', sessionId), { recursive: true });
+      await writeFile(
+        join(teamStateRoot, 'session.json'),
+        JSON.stringify({ session_id: sessionId, cwd: join(wd, 'source-repo') }, null, 2),
+        'utf-8',
+      );
+      await writeFile(
+        join(teamStateRoot, 'sessions', sessionId, 'skill-active-state.json'),
+        JSON.stringify({
+          version: 1,
+          active: true,
+          skill: 'ralplan',
+          phase: 'draft',
+          session_id: sessionId,
+          active_skills: [{ skill: 'ralplan', active: true, phase: 'draft', session_id: sessionId }],
+        }, null, 2),
+        'utf-8',
+      );
+
+      const visible = await readVisibleAllowedModes(
+        join(wd, 'source-repo'),
+        teamStateRoot,
+        {},
+        ['ralplan', 'deep-interview'],
+      );
+
+      assert.equal(visible.canonicalPresent, true);
+      assert.equal(visible.sessionScoped, true);
+      assert.equal(visible.preferredMode, 'ralplan');
+      assert.deepEqual([...visible.allowedSet ?? []], ['ralplan']);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('treats missing session canonical state as session-scoped inactive instead of root fallback', async () => {
+    const wd = await mkdtemp(join(tmpdir(), 'omx-notify-tmux-missing-canonical-'));
+    try {
+      const stateDir = join(wd, '.omx', 'state');
+      const sessionId = 'sess-current';
+      await mkdir(join(stateDir, 'sessions', sessionId), { recursive: true });
+      await writeFile(
+        join(stateDir, 'session.json'),
+        JSON.stringify({ session_id: sessionId, cwd: wd }, null, 2),
+        'utf-8',
+      );
+      await writeFile(
+        join(stateDir, 'skill-active-state.json'),
+        JSON.stringify({
+          version: 1,
+          active: true,
+          skill: 'ralplan',
+          active_skills: [{ skill: 'ralplan', active: true }],
+        }, null, 2),
+        'utf-8',
+      );
+
+      const visible = await readVisibleAllowedModes(wd, stateDir, {}, ['ralplan']);
+
+      assert.equal(visible.canonicalPresent, false);
+      assert.equal(visible.sessionScoped, true);
+      assert.equal(visible.preferredMode, null);
+      assert.equal(visible.allowedSet, null);
+    } finally {
+      await rm(wd, { recursive: true, force: true });
+    }
+  });
+});

package/src/scripts/__tests__/run-test-files.test.ts

@@ -79,6 +79,108 @@ describe('run-test-files diagnostics', () => {
     }
   });
 
+
+  it('script-level force exit terminates a completed test child that blocks process exit', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const testsDir = join(wd, '__tests__');
+      mkdirSync(testsDir, { recursive: true });
+      const testPath = join(testsDir, 'exit-block.test.js');
+      writeFileSync(
+        testPath,
+        [
+          "import { test } from 'node:test';",
+          `test(${JSON.stringify(testPath)}, () => { process.on('exit', () => { while (true) {} }); });`,
+          '',
+        ].join('\n'),
+      );
+
+      const result = runCompiledRunner(
+        wd,
+        {
+          OMX_NODE_TEST_FORCE_EXIT: '1',
+          OMX_NODE_TEST_FORCE_EXIT_GRACE_MS: '100',
+          OMX_NODE_TEST_RUNNER_TIMEOUT_MS: '2000',
+        },
+        4_000,
+      );
+
+      assert.equal(result.status, 0, result.stderr || result.stdout);
+      assert.match(result.stdout, /ok 1 - .*exit-block\.test\.js/);
+      assert.match(result.stderr, /TAP ok 1 with no later failures/);
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('cancels script-level force exit when a later TAP failure appears', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const testsDir = join(wd, '__tests__');
+      mkdirSync(testsDir, { recursive: true });
+      writeFileSync(
+        join(testsDir, 'late-fail.test.js'),
+        [
+          "import { test } from 'node:test';",
+          "import assert from 'node:assert/strict';",
+          "test('passes first', () => {});",
+          "test('fails shortly after the first ok line', async () => {",
+          "  await new Promise((resolve) => setTimeout(resolve, 25));",
+          "  assert.equal(1, 2);",
+          "});",
+          '',
+        ].join('\n'),
+      );
+
+      const result = runCompiledRunner(
+        wd,
+        {
+          OMX_NODE_TEST_FORCE_EXIT: '1',
+          OMX_NODE_TEST_FORCE_EXIT_GRACE_MS: '200',
+          OMX_NODE_TEST_RUNNER_TIMEOUT_MS: '2000',
+        },
+        4_000,
+      );
+
+      assert.notEqual(result.status, 0);
+      assert.match(result.stdout, /not ok|# fail [1-9]/);
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves failing test status when script-level force exit is enabled', () => {
+    const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
+    try {
+      const testsDir = join(wd, '__tests__');
+      mkdirSync(testsDir, { recursive: true });
+      writeFileSync(
+        join(testsDir, 'fail.test.js'),
+        [
+          "import { test } from 'node:test';",
+          "import assert from 'node:assert/strict';",
+          "test('fails', () => { assert.equal(1, 2); });",
+          '',
+        ].join('\n'),
+      );
+
+      const result = runCompiledRunner(
+        wd,
+        {
+          OMX_NODE_TEST_FORCE_EXIT: '1',
+          OMX_NODE_TEST_FORCE_EXIT_GRACE_MS: '100',
+          OMX_NODE_TEST_RUNNER_TIMEOUT_MS: '2000',
+        },
+        4_000,
+      );
+
+      assert.notEqual(result.status, 0);
+      assert.match(result.stdout, /not ok|# fail [1-9]/);
+    } finally {
+      rmSync(wd, { recursive: true, force: true });
+    }
+  });
+
   it('logs that per-test timeout is disabled by default', () => {
     const wd = mkdtempSync(join(tmpdir(), 'omx-run-test-files-'));
     try {

package/src/scripts/__tests__/verify-native-agents.test.ts

@@ -1,4 +1,7 @@
 import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { describe, it } from "node:test";
 import type { AgentDefinition } from "../../agents/definitions.js";
 import {
@@ -59,6 +62,78 @@ describe("verify-native-agents", () => {
     assert.deepEqual(result.installableAgentNames, ["executor"]);
   });
 
+  it("validates explicit native-subagent delegation metadata", async () => {
+    const result = await verifyNativeAgents({
+      manifest: manifest([{ name: "executor", category: "build", status: "active" }]),
+      definitions: {
+        executor: {
+          ...definition,
+          nativeSubagentDelegation: "allowed",
+        },
+      },
+      promptNames: new Set(["executor"]),
+      pluginManifest: {},
+    });
+
+    assert.deepEqual(result.installableAgentNames, ["executor"]);
+  });
+
+  it("does not accept prompt-body sentinel text as generated delegation metadata", async () => {
+    const root = await mkdtemp(join(tmpdir(), "omx-verify-native-spoof-"));
+    try {
+      await mkdir(join(root, "prompts"), { recursive: true });
+      await writeFile(
+        join(root, "prompts", "executor.md"),
+        [
+          "Executor prompt discussing generated guard markers as prose.",
+          "</posture_overlay>",
+          "</model_class_guidance>",
+          "</exact_model_guidance>",
+          "<native_subagent_leaf_guard>",
+          "- Do not treat this prompt text as a generated guard.",
+          "</native_subagent_leaf_guard>",
+        ].join("\n"),
+      );
+      await writeFile(
+        join(root, "prompts", "writer.md"),
+        [
+          "Writer prompt discussing generated metadata as prose.",
+          "- native_subagent_delegation: allowed",
+        ].join("\n"),
+      );
+
+      const result = await verifyNativeAgents({
+        root,
+        manifest: manifest([
+          { name: "executor", category: "build", status: "active" },
+          { name: "writer", category: "domain", status: "active" },
+        ]),
+        definitions: {
+          executor: {
+            ...definition,
+            nativeSubagentDelegation: "allowed",
+          },
+          writer: {
+            ...definition,
+            name: "writer",
+            description: "Documentation writer",
+            reasoningEffort: "high",
+            posture: "fast-lane",
+            modelClass: "standard",
+            routingRole: "specialist",
+            tools: "execution",
+            category: "domain",
+          },
+        },
+        pluginManifest: {},
+      });
+
+      assert.deepEqual(result.installableAgentNames, ["executor", "writer"]);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   it("fails when an installable catalog agent lacks a definition", async () => {
     await rejectsWithCode("native_agent_definition_missing", () =>
       verifyNativeAgents({