oh-my-codex 0.15.2 → 0.16.0

package/src/scripts/notify-hook/team-worker-posttooluse.ts

@@ -400,7 +400,7 @@ export async function handleTeamWorkerPostToolUseSuccess(
     if (readToolName(payload) !== 'Bash') return { handled: false, status: 'skipped', reason: 'not_bash', operationKinds: [] };
     if (readExitCode(payload) !== 0) return { handled: false, status: 'skipped', reason: 'nonzero_exit', operationKinds: [] };
 
-    const parsedWorker = parseTeamWorkerEnv(env.OMX_TEAM_WORKER);
+    const parsedWorker = parseTeamWorkerEnv(env.OMX_TEAM_INTERNAL_WORKER ?? env.OMX_TEAM_WORKER);
     if (!parsedWorker) return { handled: false, status: 'skipped', reason: 'missing_worker_env', operationKinds: [] };
 
     const resolvedStateRoot = await resolveWorkerTeamStateRoot(cwd, parsedWorker, env);

package/src/scripts/notify-hook/team-worker-stop.ts

@@ -0,0 +1,246 @@
+// @ts-nocheck
+/**
+ * Native worker Stop leader nudge.
+ *
+ * This path is intentionally tied to a resolved, allowed native Stop event.
+ * It must not depend on idle/heartbeat freshness or inferred progress stalls.
+ */
+
+import { appendFile, mkdir, rename, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { DEFAULT_MARKER } from '../tmux-hook-engine.js';
+import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
+import { safeString, asNumber } from './utils.js';
+import { readJsonIfExists } from './state-io.js';
+import { logTmuxHookEvent } from './log.js';
+import { evaluatePaneInjectionReadiness, sendPaneInput } from './team-tmux-guard.js';
+import { resolvePaneTarget } from './tmux-injection.js';
+import { readTeamWorkersForIdleCheck } from './team-worker.js';
+
+const STOP_NUDGE_COOLDOWN_MS = 30_000;
+const SOURCE_TYPE = 'worker_stop';
+const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
+const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
+
+function resolveWorkerStopCooldownMs() {
+  const raw = safeString(process.env.OMX_TEAM_WORKER_STOP_COOLDOWN_MS || '');
+  const parsed = asNumber(raw);
+  if (parsed !== null && parsed >= 5_000 && parsed <= 10 * 60_000) return parsed;
+  return STOP_NUDGE_COOLDOWN_MS;
+}
+
+async function resolveCanonicalLeaderPaneId(leaderPaneId) {
+  const normalizedLeaderPaneId = safeString(leaderPaneId).trim();
+  if (!normalizedLeaderPaneId) return '';
+  try {
+    const resolved = await resolvePaneTarget({ type: 'pane', value: normalizedLeaderPaneId }, '', '', '', {});
+    const paneTarget = safeString(resolved?.paneTarget).trim();
+    if (paneTarget) return paneTarget;
+  } catch {
+    // Fall back to the recorded pane id; readiness guard remains authoritative.
+  }
+  return normalizedLeaderPaneId;
+}
+
+async function appendWorkerStopEvent(stateDir, teamName, event) {
+  const eventsDir = join(stateDir, 'team', teamName, 'events');
+  const eventsPath = join(eventsDir, 'events.ndjson');
+  await mkdir(eventsDir, { recursive: true }).catch(() => {});
+  await appendFile(eventsPath, JSON.stringify(event) + '\n').catch(() => {});
+}
+
+async function writeStopNudgeState(statePath, state) {
+  await mkdir(dirname(statePath), { recursive: true }).catch(() => {});
+  const tmpPath = `${statePath}.tmp.${process.pid}`;
+  await writeFile(tmpPath, JSON.stringify(state, null, 2));
+  await rename(tmpPath, statePath);
+}
+
+async function recordDeferred({
+  stateDir,
+  logsDir,
+  teamName,
+  workerName,
+  statePath,
+  nextState,
+  reason,
+  tmuxSession,
+  leaderPaneId,
+  paneCurrentCommand = '',
+}) {
+  const nowIso = nextState.last_notified_at;
+  await writeStopNudgeState(statePath, {
+    ...nextState,
+    delivery: 'deferred',
+    reason,
+    pane_current_command: paneCurrentCommand || null,
+  }).catch(() => {});
+  await appendWorkerStopEvent(stateDir, teamName, {
+    event_id: `worker-stop-deferred-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+    team: teamName,
+    type: 'worker_stop_leader_nudge',
+    worker: workerName,
+    to_worker: 'leader-fixed',
+    delivery: 'deferred',
+    reason,
+    created_at: nowIso,
+    source_type: SOURCE_TYPE,
+  });
+  await logTmuxHookEvent(logsDir, {
+    timestamp: nowIso,
+    type: 'leader_notification_deferred',
+    team: teamName,
+    worker: workerName,
+    to_worker: 'leader-fixed',
+    reason,
+    leader_pane_id: leaderPaneId || null,
+    tmux_session: tmuxSession || null,
+    tmux_injection_attempted: false,
+    pane_current_command: paneCurrentCommand || null,
+    source_type: SOURCE_TYPE,
+  }).catch(() => {});
+  await appendTeamDeliveryLog(logsDir, {
+    event: 'nudge_triggered',
+    source: SOURCE_TYPE,
+    team: teamName,
+    from_worker: workerName,
+    to_worker: 'leader-fixed',
+    transport: 'none',
+    result: 'deferred',
+    reason,
+  }).catch(() => {});
+}
+
+export async function maybeNudgeLeaderForAllowedWorkerStop({
+  stateDir,
+  logsDir,
+  workerContext,
+}) {
+  const { teamName, workerName } = workerContext || {};
+  if (!teamName || !workerName || !stateDir) return { ok: false, result: 'unresolved' };
+
+  const workerDir = join(stateDir, 'team', teamName, 'workers', workerName);
+  const statePath = join(workerDir, 'worker-stop-nudge.json');
+  const nowMs = Date.now();
+  const nowIso = new Date(nowMs).toISOString();
+  const existing = (await readJsonIfExists(statePath, null)) || {};
+  const lastNotifiedMs = asNumber(existing.last_notified_at_ms) ?? 0;
+  const cooldownMs = resolveWorkerStopCooldownMs();
+  if ((nowMs - lastNotifiedMs) < cooldownMs) {
+    return { ok: true, result: 'suppressed_cooldown' };
+  }
+
+  const teamInfo = await readTeamWorkersForIdleCheck(stateDir, teamName);
+  if (!teamInfo) return { ok: false, result: 'unresolved' };
+  const { tmuxSession, leaderPaneId } = teamInfo;
+  const tmuxTarget = await resolveCanonicalLeaderPaneId(leaderPaneId);
+  const nextState = {
+    last_notified_at_ms: nowMs,
+    last_notified_at: nowIso,
+    team: teamName,
+    worker: workerName,
+    source_type: SOURCE_TYPE,
+  };
+
+  if (!tmuxTarget) {
+    await recordDeferred({
+      stateDir,
+      logsDir,
+      teamName,
+      workerName,
+      statePath,
+      nextState,
+      reason: LEADER_PANE_MISSING_NO_INJECTION_REASON,
+      tmuxSession,
+      leaderPaneId,
+    });
+    return { ok: true, result: 'deferred' };
+  }
+
+  const paneGuard = await evaluatePaneInjectionReadiness(tmuxTarget, {
+    skipIfScrolling: true,
+    requireRunningAgent: true,
+    requireReady: false,
+    requireIdle: false,
+  });
+  if (!paneGuard.ok) {
+    await recordDeferred({
+      stateDir,
+      logsDir,
+      teamName,
+      workerName,
+      statePath,
+      nextState,
+      reason: paneGuard.reason === 'pane_running_shell' ? LEADER_PANE_SHELL_NO_INJECTION_REASON : paneGuard.reason,
+      tmuxSession,
+      leaderPaneId,
+      paneCurrentCommand: paneGuard.paneCurrentCommand,
+    });
+    return { ok: true, result: 'deferred' };
+  }
+
+  const prompt =
+    `[OMX] ${workerName} native Stop allowed. `
+    + `Run \`omx team status ${teamName}\`, read worker messages/results, then assign next task, reconcile completion, or shut down. `
+    + DEFAULT_MARKER;
+
+  try {
+    const sendResult = await sendPaneInput({
+      paneTarget: tmuxTarget,
+      prompt,
+      submitKeyPresses: 2,
+      submitDelayMs: 100,
+    });
+    if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+
+    await writeStopNudgeState(statePath, {
+      ...nextState,
+      delivery: 'sent',
+      leader_pane_id: leaderPaneId || null,
+      tmux_target: tmuxTarget,
+    });
+    await appendWorkerStopEvent(stateDir, teamName, {
+      event_id: `worker-stop-nudge-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+      team: teamName,
+      type: 'worker_stop_leader_nudge',
+      worker: workerName,
+      to_worker: 'leader-fixed',
+      delivery: 'sent',
+      created_at: nowIso,
+      source_type: SOURCE_TYPE,
+    });
+    await logTmuxHookEvent(logsDir, {
+      timestamp: nowIso,
+      type: 'worker_stop_leader_nudge',
+      team: teamName,
+      worker: workerName,
+      to_worker: 'leader-fixed',
+      tmux_target: tmuxTarget,
+      source_type: SOURCE_TYPE,
+    }).catch(() => {});
+    await appendTeamDeliveryLog(logsDir, {
+      event: 'nudge_triggered',
+      source: SOURCE_TYPE,
+      team: teamName,
+      from_worker: workerName,
+      to_worker: 'leader-fixed',
+      transport: 'send-keys',
+      result: 'sent',
+      reason: 'worker_stop_allowed',
+    }).catch(() => {});
+    return { ok: true, result: 'sent' };
+  } catch (err) {
+    await recordDeferred({
+      stateDir,
+      logsDir,
+      teamName,
+      workerName,
+      statePath,
+      nextState,
+      reason: err instanceof Error ? err.message : safeString(err),
+      tmuxSession,
+      leaderPaneId,
+    });
+    return { ok: true, result: 'deferred' };
+  }
+}

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

@@ -199,26 +199,35 @@ export async function readWorkerStatusState(stateDir, teamName, workerName) {
 }
 
 export async function readTeamWorkersForIdleCheck(stateDir, teamName) {
-  // Try manifest.v2.json first (preferred), then config.json
+  // Try manifest.v2.json first (preferred), then config.json. Some older or
+  // synthetic team states have a partial manifest plus the usable worker pane
+  // metadata in config.json, so fall through when a candidate is incomplete.
   const manifestPath = join(stateDir, 'team', teamName, 'manifest.v2.json');
   const configPath = join(stateDir, 'team', teamName, 'config.json');
-  const srcPath = existsSync(manifestPath) ? manifestPath : existsSync(configPath) ? configPath : null;
-  if (!srcPath) return null;
+  const candidatePaths = [manifestPath, configPath].filter((path) => existsSync(path));
+  let fallback = null;
 
-  try {
-    const raw = await readFile(srcPath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object') return null;
-    const workers = parsed.workers;
-    if (!Array.isArray(workers) || workers.length === 0) return null;
-    const tmuxSession = safeString(parsed.tmux_session || '').trim();
-    const leaderPaneId = safeString(parsed.leader_pane_id || '').trim();
-    return { workers, tmuxSession, leaderPaneId };
-  } catch {
-    return null;
+  for (const srcPath of candidatePaths) {
+    try {
+      const raw = await readFile(srcPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== 'object') continue;
+      const workers = parsed.workers;
+      if (!Array.isArray(workers) || workers.length === 0) continue;
+      const tmuxSession = safeString(parsed.tmux_session || '').trim();
+      const leaderPaneId = safeString(parsed.leader_pane_id || '').trim();
+      const result = { workers, tmuxSession, leaderPaneId };
+      if (leaderPaneId) return result;
+      if (!fallback) fallback = result;
+    } catch {
+      // Try the next state source.
+    }
   }
+
+  return fallback;
 }
 
+
 async function readTeamTaskCounts(stateDir, teamName) {
   const tasksDir = join(stateDir, 'team', teamName, 'tasks');
   const taskCounts = { pending: 0, blocked: 0, in_progress: 0, completed: 0, failed: 0 };

package/src/scripts/notify-hook.ts

@@ -179,7 +179,7 @@ async function main() {
   const isTurnComplete = isTurnCompletePayload(payload);
 
   // Team worker detection via environment variable
-  const teamWorkerEnv = process.env.OMX_TEAM_WORKER; // e.g., "fix-ts/worker-1"
+  const teamWorkerEnv = process.env.OMX_TEAM_INTERNAL_WORKER || process.env.OMX_TEAM_WORKER; // e.g., "fix-ts/worker-1"
   const parsedTeamWorker = parseTeamWorkerEnv(teamWorkerEnv);
   const isTeamWorker = !!parsedTeamWorker;
 

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

@@ -4,6 +4,7 @@ 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;
 
 function collectTests(path: string, out: string[]): void {
   let stats;
@@ -32,6 +33,17 @@ function parseTimeoutMs(value: string | undefined, defaultTimeoutMs: number): nu
   return Math.floor(parsed);
 }
 
+function parseTestConcurrency(env: NodeJS.ProcessEnv): number | undefined {
+  const rawValue = env.OMX_NODE_TEST_CONCURRENCY;
+  if (rawValue) {
+    const parsed = Number(rawValue);
+    if (Number.isFinite(parsed) && parsed >= 1) return Math.floor(parsed);
+    return undefined;
+  }
+
+  return env.CI === 'true' || env.GITHUB_ACTIONS === 'true' ? DEFAULT_CI_TEST_CONCURRENCY : undefined;
+}
+
 const roots = process.argv.slice(2);
 const targets = roots.length > 0 ? roots : ['dist'];
 const files: string[] = [];
@@ -48,16 +60,22 @@ if (files.length === 0) {
 
 const testTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_TIMEOUT_MS, DEFAULT_TEST_TIMEOUT_MS);
 const runnerTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_RUNNER_TIMEOUT_MS, DEFAULT_RUNNER_TIMEOUT_MS);
+const testConcurrency = parseTestConcurrency(process.env);
 const testArgs = ['--test'];
 if (testTimeoutMs > 0) {
   testArgs.push(`--test-timeout=${testTimeoutMs}`);
 }
+if (testConcurrency) {
+  testArgs.push(`--test-concurrency=${testConcurrency}`);
+}
 testArgs.push(...files);
 
 console.error(
   `[run-test-files] running ${files.length} test file(s) from ${targets.join(', ')}${
     testTimeoutMs > 0 ? ` with per-test timeout ${testTimeoutMs}ms` : ' with per-test timeout disabled'
-  }${runnerTimeoutMs > 0 ? ` and runner timeout ${runnerTimeoutMs}ms` : ' and runner timeout disabled'}`,
+  }${testConcurrency ? `, test concurrency ${testConcurrency}` : ', default test concurrency'}${
+    runnerTimeoutMs > 0 ? `, and runner timeout ${runnerTimeoutMs}ms` : ', and runner timeout disabled'
+  }`,
 );
 
 const childEnv = { ...process.env };
@@ -82,6 +100,7 @@ console.error(
   `[run-test-files] node --test did not exit normally${result.signal ? ` (signal: ${result.signal})` : ''}. `
     + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
     + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
+    + `Test concurrency: ${testConcurrency ?? 'default'}. `
     + `Runner timeout: ${runnerTimeoutMs > 0 ? `${runnerTimeoutMs}ms` : 'disabled'}.`,
 );
 process.exit(1);

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 import {
 	getSetupInstallableSkillNames,
 	isCatalogInstallableStatus,
@@ -144,14 +145,14 @@ async function assertRootSkillCatalogConsistency(
 		.filter((skillName) => {
 			if (expectedSkillNames.has(skillName)) return false;
 			const status = manifestByName.get(skillName)?.status;
-			return status !== "alias" && status !== "merged";
+			return status !== "alias" && status !== "merged" && status !== "deprecated";
 		})
 		.sort();
 	if (nonInstallableRootSkillDirs.length > 0) {
 		throw new Error(
 			[
 				"canonical_skill_catalog_out_of_sync",
-				"message=root skill directories excluded from plugin must be alias or merged catalog entries",
+				"message=root skill directories excluded from plugin must be alias, merged, or deprecated catalog entries",
 				`skills=${JSON.stringify(nonInstallableRootSkillDirs)}`,
 			].join("\n"),
 		);
@@ -345,7 +346,15 @@ function parseArgs(argv: string[]): SyncPluginMirrorOptions {
 	};
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+export function isDirectCliInvocation(
+	importMetaUrl: string,
+	argvPath: string | undefined,
+): boolean {
+	if (!argvPath) return false;
+	return fileURLToPath(importMetaUrl) === resolve(argvPath);
+}
+
+if (isDirectCliInvocation(import.meta.url, process.argv[1])) {
 	syncPluginMirror(parseArgs(process.argv.slice(2)))
 		.then((result) => {
 			const action = result.checked ? "verified" : "synced";

package/templates/catalog-manifest.json

@@ -33,8 +33,7 @@
     {
       "name": "ecomode",
       "category": "execution",
-      "status": "merged",
-      "canonical": "ultrawork",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -52,6 +51,20 @@
       "core": false,
       "internalRequired": false
     },
+    {
+      "name": "autoresearch-goal",
+      "category": "execution",
+      "status": "active",
+      "core": false,
+      "internalRequired": false
+    },
+    {
+      "name": "performance-goal",
+      "category": "execution",
+      "status": "active",
+      "core": false,
+      "internalRequired": false
+    },
     {
       "name": "pipeline",
       "category": "execution",
@@ -59,11 +72,17 @@
       "core": false,
       "internalRequired": false
     },
+    {
+      "name": "ultragoal",
+      "category": "execution",
+      "status": "active",
+      "core": true,
+      "internalRequired": false
+    },
     {
       "name": "swarm",
       "category": "execution",
-      "status": "alias",
-      "canonical": "team",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -99,24 +118,21 @@
     {
       "name": "deepsearch",
       "category": "shortcut",
-      "status": "alias",
-      "canonical": "explore",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "tdd",
       "category": "shortcut",
-      "status": "alias",
-      "canonical": "test-engineer",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "build-fix",
       "category": "shortcut",
-      "status": "alias",
-      "canonical": "build-fixer",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -138,24 +154,21 @@
     {
       "name": "security-review",
       "category": "shortcut",
-      "status": "active",
-      "canonical": "security-reviewer",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "visual-verdict",
       "category": "shortcut",
-      "status": "active",
-      "canonical": "vision",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "web-clone",
       "category": "shortcut",
-      "status": "merged",
-      "canonical": "visual-ralph",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -186,22 +199,28 @@
     {
       "name": "review",
       "category": "shortcut",
-      "status": "alias",
-      "canonical": "plan --review",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
-      "name": "ask-claude",
+      "name": "ask",
       "category": "shortcut",
       "status": "active",
       "core": false,
       "internalRequired": false
     },
+    {
+      "name": "ask-claude",
+      "category": "shortcut",
+      "status": "deprecated",
+      "core": false,
+      "internalRequired": false
+    },
     {
       "name": "ask-gemini",
       "category": "shortcut",
-      "status": "active",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -222,21 +241,21 @@
     {
       "name": "help",
       "category": "utility",
-      "status": "active",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "note",
       "category": "utility",
-      "status": "active",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
     {
       "name": "trace",
       "category": "utility",
-      "status": "active",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -303,8 +322,7 @@
     {
       "name": "ralph-init",
       "category": "utility",
-      "status": "merged",
-      "canonical": "plan",
+      "status": "deprecated",
       "core": false,
       "internalRequired": false
     },
@@ -378,7 +396,7 @@
     {
       "name": "security-reviewer",
       "category": "review",
-      "status": "active"
+      "status": "deprecated"
     },
     {
       "name": "performance-reviewer",
@@ -410,7 +428,7 @@
     {
       "name": "build-fixer",
       "category": "domain",
-      "status": "active"
+      "status": "deprecated"
     },
     {
       "name": "designer",

package/plugins/oh-my-codex/skills/ask-claude/SKILL.md

@@ -1,61 +0,0 @@
----
-name: ask-claude
-description: Ask Claude via local CLI and capture a reusable artifact
----
-
-# Ask Claude (Local CLI)
-
-Use the locally installed Claude CLI as a direct external advisor for focused questions, reviews, or second opinions.
-
-## Usage
-
-```bash
-/ask-claude <question or task>
-```
-
-## Routing
-
-### Preferred: Local CLI execution
-Run Claude through the canonical OMX CLI command path (no MCP routing):
-
-```bash
-omx ask claude "{{ARGUMENTS}}"
-```
-
-Exact non-interactive Claude CLI command from `claude --help`:
-
-```bash
-claude -p "{{ARGUMENTS}}"
-# equivalent: claude --print "{{ARGUMENTS}}"
-```
-
-If needed, adapt to the user's installed Claude CLI variant while keeping local execution as the default path.
-
-Legacy compatibility entrypoints (`./scripts/ask-claude.sh`, `npm run ask:claude -- ...`) are transitional wrappers.
-
-### Missing binary behavior
-If `claude` is not found, do **not** switch to MCP.
-Instead:
-1. Explain that local Claude CLI is required for this skill.
-2. Ask the user to install/configure Claude CLI.
-3. Provide a quick verification command:
-
-```bash
-claude --version
-```
-
-## Artifact requirement
-After local execution, save a markdown artifact to:
-
-```text
-.omx/artifacts/claude-<slug>-<timestamp>.md
-```
-
-Minimum artifact sections:
-1. Original user task
-2. Final prompt sent to Claude CLI
-3. Claude output (raw)
-4. Concise summary
-5. Action items / next steps
-
-Task: {{ARGUMENTS}}