oh-my-codex 0.18.0 → 0.18.2

package/src/scripts/codex-native-pre-post.ts

@@ -2,7 +2,11 @@ import {
   buildDocumentRefreshAdvisoryOutput,
   evaluateStagedDocumentRefresh,
 } from "../document-refresh/enforcer.js";
-import { isLoreCommitGuardEnabled } from "../config/commit-lore-guard.js";
+import {
+  OMX_LORE_COMMIT_GUARD_ENV,
+  isLoreCommitGuardEnabled,
+  readConfiguredLoreCommitGuardValue,
+} from "../config/commit-lore-guard.js";
 import { resolveCodexExecutionSurface } from "./codex-execution-surface.js";
 
 type CodexHookPayload = Record<string, unknown>;
@@ -747,6 +751,17 @@ function buildEffectiveLoreCommitGuardEnv(parsed: GitCommitCommandParseResult):
   for (const [name, value] of Object.entries(parsed.inlineEnvironment)) {
     if (typeof value === "string") effectiveEnvironment[name] = value;
   }
+
+  if (
+    !parsed.environmentStartsClean
+    && !parsed.unsetEnvironmentNames.includes(OMX_LORE_COMMIT_GUARD_ENV)
+    && typeof effectiveEnvironment[OMX_LORE_COMMIT_GUARD_ENV] !== "string"
+  ) {
+    const configuredValue = readConfiguredLoreCommitGuardValue(effectiveEnvironment);
+    if (typeof configuredValue === "string") {
+      effectiveEnvironment[OMX_LORE_COMMIT_GUARD_ENV] = configuredValue;
+    }
+  }
   return effectiveEnvironment;
 }
 

package/src/scripts/notify-dispatcher.ts

@@ -7,6 +7,9 @@
 
 import { readFile } from "fs/promises";
 import { spawnSync } from "child_process";
+import { closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { tmpdir } from "os";
 
 interface NotifyDispatcherMetadata {
 	managedBy?: string;
@@ -16,6 +19,195 @@ interface NotifyDispatcherMetadata {
 	dispatcherNotify?: string[];
 }
 
+const DISPATCH_LOCK_STALE_MS = 45_000;
+// Codex Desktop can replay a backlog of turn-ended callbacks well after the UI
+// window has gone away. Keep the default same-turn coalescing window longer
+// than a heavily loaded notification hook invocation so sequential queued
+// callbacks from one thread do not slip through merely because the first
+// dispatch was slow. Payloads with different thread/session identity retain
+// independent notification cadence.
+const DEFAULT_TURN_DISPATCH_MIN_INTERVAL_MS = 10_000;
+const DEFAULT_STALE_EVENT_AGE_MS = 5 * 60_000;
+
+interface DispatchGuard {
+	ok: boolean;
+	release?: () => void;
+}
+
+interface DispatchGuardState {
+	lastDispatchAt?: unknown;
+	lastDispatchByIdentity?: Record<string, unknown>;
+}
+
+function parseNonNegativeEnvMs(name: string, fallback: number): number {
+	const raw = process.env[name];
+	if (typeof raw !== "string" || raw.trim() === "") return fallback;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function parsePayloadObject(payloadArg: string): Record<string, unknown> | null {
+	try {
+		const parsed = JSON.parse(payloadArg) as unknown;
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: null;
+	} catch {
+		return null;
+	}
+}
+
+function isTurnEndedPayload(payload: Record<string, unknown> | null): boolean {
+	if (!payload) return false;
+	const type = String(payload.type ?? payload.event ?? payload.hook_event_name ?? "")
+		.trim()
+		.toLowerCase();
+	return type === ""
+		|| type === "agent-turn-complete"
+		|| type === "turn-complete"
+		|| type === "turn-ended";
+}
+
+function readPayloadTimestampMs(payload: Record<string, unknown>): number | null {
+	for (const key of ["timestamp", "created_at", "createdAt", "event_time", "eventTime", "time"]) {
+		const value = payload[key];
+		if (typeof value === "number" && Number.isFinite(value)) {
+			return value > 1_000_000_000_000 ? value : value * 1000;
+		}
+		if (typeof value === "string" && value.trim()) {
+			const parsed = Date.parse(value);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+	}
+	return null;
+}
+
+function readPayloadIdentity(payload: Record<string, unknown> | null): string {
+	if (!payload) return "global";
+	for (const key of [
+		"thread_id",
+		"threadId",
+		"conversation_id",
+		"conversationId",
+		"session_id",
+		"sessionId",
+	]) {
+		const value = payload[key];
+		if (typeof value === "string" && value.trim()) {
+			return `${key}:${value.trim()}`;
+		}
+	}
+	return "global";
+}
+
+function dispatchGuardDir(metadataPath: string): string {
+	if (metadataPath) return dirname(metadataPath);
+	return join(tmpdir(), "oh-my-codex-notify-dispatch");
+}
+
+function writeDispatchGuardState(
+	statePath: string,
+	state: DispatchGuardState,
+	identity: string,
+	minIntervalMs: number,
+	staleEventAgeMs: number,
+): void {
+	const previousByIdentity = state.lastDispatchByIdentity && typeof state.lastDispatchByIdentity === "object"
+		? state.lastDispatchByIdentity
+		: {};
+	const retainedByIdentity: Record<string, number> = {};
+	const now = Date.now();
+	const retentionMs = Math.max(minIntervalMs, staleEventAgeMs, DEFAULT_TURN_DISPATCH_MIN_INTERVAL_MS);
+	for (const [key, value] of Object.entries(previousByIdentity)) {
+		if (typeof value === "number" && now - value <= retentionMs) {
+			retainedByIdentity[key] = value;
+		}
+	}
+	retainedByIdentity[identity] = now;
+	writeFileSync(statePath, JSON.stringify({
+		lastDispatchAt: identity === "global" ? now : (typeof state.lastDispatchAt === "number" ? state.lastDispatchAt : undefined),
+		lastDispatchByIdentity: retainedByIdentity,
+		pid: process.pid,
+	}));
+}
+
+function acquireTurnDispatchGuard(metadataPath: string, payloadArg: string): DispatchGuard {
+	const payload = parsePayloadObject(payloadArg);
+	if (!isTurnEndedPayload(payload)) return { ok: true };
+
+	const now = Date.now();
+	const staleEventAgeMs = parseNonNegativeEnvMs("OMX_NOTIFY_DISPATCH_STALE_EVENT_AGE_MS", DEFAULT_STALE_EVENT_AGE_MS);
+	const eventTimestampMs = payload ? readPayloadTimestampMs(payload) : null;
+	if (eventTimestampMs !== null && staleEventAgeMs > 0 && now - eventTimestampMs > staleEventAgeMs) {
+		return { ok: false };
+	}
+
+	const dir = dispatchGuardDir(metadataPath);
+	mkdirSync(dir, { recursive: true });
+	const lockPath = join(dir, "notify-dispatch.lock");
+	const statePath = join(dir, "notify-dispatch.guard.json");
+	try {
+		const lockStat = statSync(lockPath);
+		if (now - lockStat.mtimeMs > DISPATCH_LOCK_STALE_MS) unlinkSync(lockPath);
+	} catch {
+		// Missing or unreadable lock: try to acquire below.
+	}
+
+	let fd: number;
+	try {
+		fd = openSync(lockPath, "wx");
+		writeFileSync(fd, String(process.pid));
+		closeSync(fd);
+	} catch {
+		return { ok: false };
+	}
+
+	const release = () => {
+		try {
+			unlinkSync(lockPath);
+		} catch {
+			// Best effort.
+		}
+	};
+
+	try {
+		const minIntervalMs = parseNonNegativeEnvMs("OMX_NOTIFY_DISPATCH_MIN_INTERVAL_MS", DEFAULT_TURN_DISPATCH_MIN_INTERVAL_MS);
+		const identity = readPayloadIdentity(payload);
+		let state: DispatchGuardState = {};
+		try {
+			state = JSON.parse(readFileSync(statePath, "utf-8")) as typeof state;
+		} catch {
+			// No prior guard state.
+		}
+		if (minIntervalMs > 0) {
+			const byIdentity = state.lastDispatchByIdentity && typeof state.lastDispatchByIdentity === "object"
+				? state.lastDispatchByIdentity
+				: {};
+			const identityLastDispatchAt = typeof byIdentity[identity] === "number" ? byIdentity[identity] : 0;
+			const legacyLastDispatchAt = identity === "global" && typeof state.lastDispatchAt === "number" ? state.lastDispatchAt : 0;
+			const lastDispatchAt = Math.max(identityLastDispatchAt, legacyLastDispatchAt);
+			if (lastDispatchAt > 0 && now - lastDispatchAt < minIntervalMs) {
+				release();
+				return { ok: false };
+			}
+		}
+		return {
+			ok: true,
+			release: () => {
+				try {
+					writeDispatchGuardState(statePath, state, identity, minIntervalMs, staleEventAgeMs);
+				} catch {
+					// Guard state is best effort; the lock still prevents concurrent duplicate dispatch.
+				}
+				release();
+			},
+		};
+	} catch {
+		release();
+		return { ok: false };
+	}
+}
+
 function parseArgs(): { metadataPath: string; payloadArg: string } {
 	let metadataPath = "";
 	const args = process.argv.slice(2);
@@ -200,11 +392,17 @@ function runNotify(
 async function main(): Promise<void> {
 	const { metadataPath, payloadArg } = parseArgs();
 	if (!payloadArg || payloadArg.startsWith("-")) return;
-	const metadata = await readMetadata(metadataPath);
-	if (!isManagedPreviousNotify(metadata?.previousNotify, metadata)) {
-		runNotify(metadata?.previousNotify, payloadArg);
+	const guard = acquireTurnDispatchGuard(metadataPath, payloadArg);
+	if (!guard.ok) return;
+	try {
+		const metadata = await readMetadata(metadataPath);
+		if (!isManagedPreviousNotify(metadata?.previousNotify, metadata)) {
+			runNotify(metadata?.previousNotify, payloadArg);
+		}
+		runNotify(metadata?.omxNotify, payloadArg);
+	} finally {
+		guard.release?.();
 	}
-	runNotify(metadata?.omxNotify, payloadArg);
 }
 
 main().catch(() => {});

package/src/scripts/notify-hook/process-runner.ts

@@ -17,35 +17,59 @@ export function runProcess(command: string, args: string[], timeoutMs = 3000): P
     let stdout = '';
     let stderr = '';
     let finished = false;
+    let sigkillTimer: ReturnType<typeof setTimeout> | undefined;
 
-    const timer = setTimeout(() => {
-      if (finished) return;
-      finished = true;
-      child.kill('SIGTERM');
-      reject(new Error(`timeout after ${effectiveTimeoutMs}ms`));
-    }, effectiveTimeoutMs);
+    const cleanup = (clearPendingSigkill = true) => {
+      clearTimeout(timer);
+      if (clearPendingSigkill && sigkillTimer) {
+        clearTimeout(sigkillTimer);
+        sigkillTimer = undefined;
+      }
+      child.stdout.off('data', onStdout);
+      child.stderr.off('data', onStderr);
+      child.off('error', onError);
+      child.off('close', onClose);
+    };
 
-    child.stdout.on('data', (chunk: Buffer) => {
+    const onStdout = (chunk: Buffer) => {
       stdout += chunk.toString();
-    });
-    child.stderr.on('data', (chunk: Buffer) => {
+    };
+    const onStderr = (chunk: Buffer) => {
       stderr += chunk.toString();
-    });
-    child.on('error', (err: Error) => {
+    };
+    const onError = (err: Error) => {
       if (finished) return;
       finished = true;
-      clearTimeout(timer);
+      cleanup();
       reject(err);
-    });
-    child.on('close', (code: number | null) => {
+    };
+    const onClose = (code: number | null) => {
       if (finished) return;
       finished = true;
-      clearTimeout(timer);
+      cleanup();
       if (code === 0) {
         resolve({ stdout, stderr, code });
       } else {
         reject(new Error(stderr.trim() || `${command} exited ${code}`));
       }
-    });
+    };
+
+    const timer = setTimeout(() => {
+      if (finished) return;
+      finished = true;
+      child.kill('SIGTERM');
+      sigkillTimer = setTimeout(() => {
+        sigkillTimer = undefined;
+        child.kill('SIGKILL');
+      }, 250);
+      sigkillTimer.unref?.();
+      cleanup(false);
+      reject(new Error(`timeout after ${effectiveTimeoutMs}ms`));
+    }, effectiveTimeoutMs);
+
+    child.stdout.on('data', onStdout);
+    child.stderr.on('data', onStderr);
+    child.on('error', onError);
+    child.on('close', onClose);
   });
 }

package/src/scripts/notify-hook/team-dispatch.ts

@@ -822,6 +822,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
     prompt: request.trigger_message,
     submitKeyPresses,
     typePrompt: shouldTypePrompt,
+    queueFirstSubmit: leaderTargeted,
   });
   if (!sendResult.ok) {
     return {
@@ -876,11 +877,13 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
           tmux_injection_attempted: true,
         };
       }
-      // Do not declare success while a *worker* pane is still bootstrapping / not
-      // input-ready. Otherwise a pre-ready send can be marked "confirmed" and later
-      // appear as a stuck unsent draft once the UI finishes loading.
-      // Keep leader-fixed behavior unchanged to avoid regressing leader notification flow.
-      if (request.to_worker !== 'leader-fixed' && !paneLooksReady(wideCap.stdout)) {
+      // Do not declare success while a pane is not input-ready. Otherwise a
+      // pre-ready send can be marked "confirmed" and later appear as a stuck
+      // unsent draft once the UI finishes loading. This includes leader-fixed:
+      // its Codex UI can show "tab to queue message" while busy, and marking
+      // delivered before queue/consumption confirmation loses the orchestration
+      // nudge until a human presses Tab manually.
+      if (!paneLooksReady(wideCap.stdout)) {
         continue;
       }
       if (!triggerInNarrow && !triggerNearTail) {
@@ -904,6 +907,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       prompt: request.trigger_message,
       submitKeyPresses,
       typePrompt: false,
+      queueFirstSubmit: leaderTargeted,
     }).catch(() => {});
   }
 

package/src/scripts/notify-hook/team-tmux-guard.ts

@@ -134,6 +134,7 @@ export async function sendPaneInput({
   submitKeyPresses = 2,
   submitDelayMs = 0,
   typePrompt = true,
+  queueFirstSubmit = false,
 }: any): Promise<any> {
   const target = safeString(paneTarget).trim();
   if (!target) {
@@ -163,6 +164,12 @@ export async function sendPaneInput({
     if (typePrompt) {
       await runProcess('tmux', argv.typeArgv, 3000);
     }
+    if (queueFirstSubmit && argv.submitArgv.length > 0) {
+      await runProcess('tmux', ['send-keys', '-t', target, 'Tab'], 3000);
+      if (submitDelayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, submitDelayMs));
+      }
+    }
     for (const submit of argv.submitArgv) {
       if (submitDelayMs > 0) {
         await new Promise((resolve) => setTimeout(resolve, submitDelayMs));

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

@@ -5,6 +5,14 @@ import { join, resolve } from 'node:path';
 const DEFAULT_TEST_TIMEOUT_MS = 0;
 const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
 const DEFAULT_CI_TEST_CONCURRENCY = 1;
+const RUNTIME_STATE_ENV_KEYS = [
+  'OMX_ROOT',
+  'OMX_STATE_ROOT',
+  'OMX_TEAM_STATE_ROOT',
+  'OMX_SESSION_ID',
+  'CODEX_SESSION_ID',
+  'SESSION_ID',
+] as const;
 
 function parseBooleanEnv(value: string | undefined): boolean {
   if (!value) return false;
@@ -91,6 +99,11 @@ console.error(
 const childEnv = { ...process.env };
 delete childEnv.NODE_TEST_CONTEXT;
 childEnv.OMX_TEST_RELAX_TMUX_TIMEOUT = '1';
+if (!parseBooleanEnv(process.env.OMX_NODE_TEST_PRESERVE_RUNTIME_ENV)) {
+  for (const key of RUNTIME_STATE_ENV_KEYS) {
+    delete childEnv[key];
+  }
+}
 
 const result = spawnSync(process.execPath, testArgs, {
   stdio: 'inherit',

package/src/scripts/smoke-packed-install.ts

@@ -1,5 +1,6 @@
 import {
   mkdtempSync,
+  realpathSync,
   rmSync,
 } from 'node:fs';
 import { mkdirSync } from 'node:fs';
@@ -24,6 +25,16 @@ export const PACKED_INSTALL_SMOKE_CORE_COMMANDS = [
   ['sparkshell', '--help'],
 ] as const;
 
+export const PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS = [
+  'SessionStart',
+  'PreToolUse',
+  'PostToolUse',
+  'UserPromptSubmit',
+  'PreCompact',
+  'PostCompact',
+  'Stop',
+] as const;
+
 function usage(): string {
   return [
     'Usage: node scripts/smoke-packed-install.mjs',
@@ -112,6 +123,99 @@ function npmBinName(name: string): string {
   return process.platform === 'win32' ? `${name}.cmd` : name;
 }
 
+function resolveGlobalNodeModules(prefixDir: string): string {
+  const result = run('npm', ['root', '-g', '--prefix', prefixDir], { cwd: prefixDir });
+  const root = String(result.stdout || '').trim();
+  if (!root) throw new Error('npm root -g did not return a node_modules directory');
+  return root;
+}
+
+export function validateHookStdout(eventName: string, stdout: string): void {
+  const trimmed = stdout.trim();
+  if (!trimmed) return;
+  try {
+    JSON.parse(trimmed);
+  } catch (error) {
+    throw new Error(
+      `native hook ${eventName} emitted invalid JSON stdout: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export function buildNativeHookSmokePayload(
+  eventName: typeof PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS[number],
+  smokeCwd: string,
+): Record<string, unknown> {
+  const base = {
+    hook_event_name: eventName,
+    session_id: `packed-install-smoke-${eventName}`,
+    cwd: smokeCwd,
+  };
+  switch (eventName) {
+    case 'SessionStart':
+      return {
+        ...base,
+        transcript_path: join(smokeCwd, 'nonexistent-transcript.jsonl'),
+      };
+    case 'PreToolUse':
+      return {
+        ...base,
+        tool_name: 'Bash',
+        tool_use_id: 'packed-install-smoke-tool',
+        tool_input: { command: 'echo packed install smoke' },
+      };
+    case 'PostToolUse':
+      return {
+        ...base,
+        tool_name: 'Bash',
+        tool_use_id: 'packed-install-smoke-tool',
+        tool_input: { command: 'echo packed install smoke' },
+        tool_response: {
+          exit_code: 0,
+          stdout: 'packed install smoke\n',
+          stderr: '',
+        },
+      };
+    case 'UserPromptSubmit':
+      return {
+        ...base,
+        transcript_path: join(smokeCwd, 'nonexistent-transcript.jsonl'),
+        prompt: 'packed install native hook smoke test',
+      };
+    case 'PreCompact':
+    case 'PostCompact':
+    case 'Stop':
+      return base;
+  }
+}
+
+function smokeInstalledNativeHookDist(prefixDir: string): void {
+  const globalNodeModules = resolveGlobalNodeModules(prefixDir);
+  const packageRoot = join(globalNodeModules, 'oh-my-codex');
+  const hookScript = join(packageRoot, 'dist', 'scripts', 'codex-native-hook.js');
+  const smokeCwd = mkdtempSync(join(tmpdir(), 'omx-packed-hook-smoke-'));
+  try {
+    for (const eventName of PACKED_INSTALL_NATIVE_HOOK_SMOKE_EVENTS) {
+      const payload = buildNativeHookSmokePayload(eventName, smokeCwd);
+      const result = run(process.execPath, [realpathSync(hookScript)], {
+        cwd: smokeCwd,
+        env: {
+          ...process.env,
+          OMX_NATIVE_HOOK_DOCTOR_SMOKE: '1',
+          OMX_ROOT: join(smokeCwd, '.omx-packed-hook-root'),
+          OMX_SESSION_ID: `packed-install-smoke-${eventName}`,
+          OMX_SOURCE_CWD: smokeCwd,
+          OMX_STARTUP_CWD: smokeCwd,
+        },
+        input: JSON.stringify(payload),
+      });
+      validateHookStdout(eventName, result.stdout as string);
+    }
+  } finally {
+    rmSync(smokeCwd, { recursive: true, force: true });
+  }
+}
+
 export function parseNpmPackJsonOutput(stdout: string): Array<{ filename: string }> {
   const start = stdout.lastIndexOf('\n[');
   const jsonText = (start >= 0 ? stdout.slice(start + 1) : stdout).trim();
@@ -147,6 +251,7 @@ async function main(): Promise<void> {
     for (const argv of PACKED_INSTALL_SMOKE_CORE_COMMANDS) {
       run(omxPath, argv, { cwd: repoRoot });
     }
+    smokeInstalledNativeHookDist(prefixDir);
 
     console.log('packed install smoke: PASS');
   } finally {

package/src/scripts/sync-plugin-mirror.ts

@@ -55,7 +55,6 @@ const PLUGIN_NAME = "oh-my-codex";
 const SETUP_OWNED_PLUGIN_MANIFEST_FIELDS = [
 	"agents",
 	"prompts",
-	"hooks",
 ] as const;
 
 async function readJsonFile<T>(path: string): Promise<T> {
@@ -199,13 +198,14 @@ async function assertPluginManifestPolicy(
 	const pkg = await readJsonFile<PackageJson>(join(root, "package.json"));
 	const expectedFields: Pick<
 		PluginManifest,
-		"name" | "version" | "skills" | "mcpServers" | "apps"
+		"name" | "version" | "skills" | "mcpServers" | "apps" | "hooks"
 	> = {
 		name: PLUGIN_NAME,
 		version: pkg.version,
 		skills: "./skills/",
 		mcpServers: "./.mcp.json",
 		apps: "./.app.json",
+		hooks: "./hooks/hooks.json",
 	};
 
 	for (const [field, expectedValue] of Object.entries(expectedFields)) {
@@ -229,7 +229,7 @@ async function assertPluginManifestPolicy(
 					"plugin_bundle_metadata_out_of_sync",
 					"kind=plugin-manifest",
 					`field=${field}`,
-					"message=setup-owned agents/prompts/hooks must not be plugin-scoped",
+					"message=setup-owned agents/prompts must not be plugin-scoped",
 				].join("\n"),
 			);
 		}

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

@@ -199,11 +199,11 @@ export async function verifyNativeAgents(
       ? await readPluginManifest(root)
       : options.pluginManifest;
   if (pluginManifest) {
-    for (const field of ["agents", "prompts", "hooks"]) {
+    for (const field of ["agents", "prompts"]) {
       if (pluginManifest[field] !== undefined) {
         throw errorBlock("native_agent_plugin_boundary_violation", {
           field,
-          message: "native agents/prompts/hooks are setup-owned, not plugin-scoped",
+          message: "native agents/prompts are setup-owned, not plugin-scoped",
         });
       }
     }

package/templates/catalog-manifest.json

@@ -108,6 +108,13 @@
       "core": false,
       "internalRequired": false
     },
+    {
+      "name": "prometheus-strict",
+      "category": "planning",
+      "status": "active",
+      "core": false,
+      "internalRequired": false
+    },
     {
       "name": "best-practice-research",
       "category": "planning",
@@ -499,6 +506,21 @@
       "status": "merged",
       "canonical": "analyst"
     },
+    {
+      "name": "prometheus-strict-metis",
+      "category": "coordination",
+      "status": "active"
+    },
+    {
+      "name": "prometheus-strict-momus",
+      "category": "coordination",
+      "status": "active"
+    },
+    {
+      "name": "prometheus-strict-oracle",
+      "category": "coordination",
+      "status": "active"
+    },
     {
       "name": "critic",
       "category": "coordination",