oh-my-codex 0.14.4 → 0.15.1

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

@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { execFileSync } from 'node:child_process';
+import { chmod, mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { handleTeamWorkerPostToolUseSuccess, teamWorkerPostToolUseInternals } from '../team-worker-posttooluse.js';
+import { readTeamEvents } from '../../../team/state/events.js';
+
+async function initWorkerFixture(): Promise<{ cwd: string; stateRoot: string; env: NodeJS.ProcessEnv }> {
+  const cwd = await mkdtemp(join(tmpdir(), 'omx-posttooluse-worker-'));
+  execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['config', 'user.name', 'Test User'], { cwd, stdio: 'ignore' });
+  await writeFile(join(cwd, 'README.md'), 'hello\n', 'utf-8');
+  execFileSync('git', ['add', 'README.md'], { cwd, stdio: 'ignore' });
+  execFileSync('git', ['commit', '-m', 'init'], { cwd, stdio: 'ignore' });
+
+  const stateRoot = join(cwd, '.omx', 'state');
+  const workerDir = join(stateRoot, 'team', 'demo-team', 'workers', 'worker-1');
+  await mkdir(workerDir, { recursive: true });
+  await writeFile(join(workerDir, 'identity.json'), JSON.stringify({
+    name: 'worker-1',
+    team_state_root: stateRoot,
+    worktree_path: cwd,
+  }, null, 2), 'utf-8');
+  await writeFile(join(stateRoot, 'team', 'demo-team', 'phase.json'), JSON.stringify({ current_phase: 'team-exec' }, null, 2), 'utf-8');
+  await writeFile(join(stateRoot, 'team', 'demo-team', 'config.json'), JSON.stringify({ leader_cwd: cwd }, null, 2), 'utf-8');
+  return {
+    cwd,
+    stateRoot,
+    env: {
+      ...process.env,
+      OMX_TEAM_WORKER: 'demo-team/worker-1',
+      OMX_TEAM_STATE_ROOT: stateRoot,
+    },
+  };
+}
+
+const successPayload = {
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_response: { exit_code: 0 },
+  tool_use_id: 'tool-1',
+};
+
+describe('handleTeamWorkerPostToolUseSuccess', () => {
+  it('creates a safe worker checkpoint, ledger entries, leader signal, and dedupe marker', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'feature.txt'), 'feature\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    assert.equal(result.handled, true);
+    assert.equal(result.status, 'applied');
+    assert.ok(result.checkpointCommit);
+    assert.deepEqual(result.operationKinds, ['auto_checkpoint', 'worker_clean_rebase', 'leader_integration_attempt']);
+
+    const log = execFileSync('git', ['log', '-1', '--pretty=%s'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    assert.equal(log, 'omx(team): auto-checkpoint worker-1');
+
+    const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
+    assert.equal(events.length, 1);
+    const event = events[0]!;
+    assert.equal(event.type, 'worker_integration_attempt_requested');
+    assert.equal(event.worker, 'worker-1');
+    const metadata = event.metadata as Record<string, unknown>;
+    assert.equal(metadata.operation_kind, 'leader_integration_attempt');
+    assert.equal(metadata.outcome_status, 'applied');
+    assert.equal(metadata.source, 'posttooluse');
+    assert.equal(metadata.dedupe_key, result.dedupeKey);
+    assert.match(String(metadata.leader_head_observed), /^[0-9a-f]{40}$/);
+
+    const dedupe = JSON.parse(await readFile(join(fixture.stateRoot, 'team', 'demo-team', 'workers', 'worker-1', 'posttooluse-dedupe.json'), 'utf-8')) as { keys: string[] };
+    assert.equal(dedupe.keys.includes(result.dedupeKey!), true);
+
+    const ledger = JSON.parse(await readFile(join(fixture.cwd, '.omx', 'reports', 'team-commit-hygiene', 'demo-team.ledger.json'), 'utf-8')) as { entries: Array<{ operation: string; status: string }> };
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'auto_checkpoint' && entry.status === 'applied'), true);
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'worker_clean_rebase' && entry.status === 'noop'), true);
+    assert.equal(ledger.entries.some((entry) => entry.operation === 'leader_integration_attempt' && entry.status === 'applied'), true);
+  });
+
+  it('records noop without creating a checkpoint commit', async () => {
+    const fixture = await initWorkerFixture();
+    const before = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    const after = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    assert.equal(result.status, 'noop');
+    assert.equal(result.checkpointCommit, null);
+    assert.equal(after, before);
+  });
+
+  it('skips protected runtime-only changes', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'AGENTS.md'), 'generated worker instructions\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, 'only_protected_paths_changed');
+    assert.equal(result.checkpointCommit, null);
+  });
+
+  it('does not checkpoint its own runtime report artifacts on a repeated PostToolUse turn', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'feature.txt'), 'feature\n', 'utf-8');
+
+    const first = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const headAfterFirst = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const second = await handleTeamWorkerPostToolUseSuccess({ ...successPayload, tool_use_id: 'tool-2' }, fixture.cwd, fixture.env);
+    const headAfterSecond = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
+
+    assert.equal(first.status, 'applied');
+    assert.equal(second.status, 'noop');
+    assert.equal(headAfterSecond, headAfterFirst);
+    assert.equal(events.length, 1);
+  });
+
+  it('skips checkpointing when the index is already staged and preserves staged changes', async () => {
+    const fixture = await initWorkerFixture();
+    await writeFile(join(fixture.cwd, 'pre-staged.txt'), 'already staged\n', 'utf-8');
+    execFileSync('git', ['add', 'pre-staged.txt'], { cwd: fixture.cwd, stdio: 'ignore' });
+    await writeFile(join(fixture.cwd, 'unstaged.txt'), 'new work\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
+    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, 'index_not_clean');
+    assert.deepEqual(staged, ['pre-staged.txt']);
+    assert.match(status, /\?\? unstaged\.txt/);
+  });
+
+  it('unstages checkpointable paths when checkpoint commit fails after staging', async () => {
+    const fixture = await initWorkerFixture();
+    const hookPath = join(fixture.cwd, '.git', 'hooks', 'prepare-commit-msg');
+    await writeFile(hookPath, '#!/bin/sh\nexit 42\n', 'utf-8');
+    await chmod(hookPath, 0o755);
+    await writeFile(join(fixture.cwd, 'commit-fail.txt'), 'must not remain staged\n', 'utf-8');
+
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
+    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+
+    assert.equal(result.status, 'skipped');
+    assert.match(result.reason ?? '', /^git_commit_failed:/);
+    assert.equal(staged, '');
+    assert.match(status, /\?\? commit-fail\.txt/);
+  });
+
+  it('exports canonical dedupe and protected-path helpers for fallback suppression', () => {
+    const key = teamWorkerPostToolUseInternals.buildDedupeKey({
+      teamName: 'team',
+      workerName: 'worker-1',
+      workerHeadAfter: 'after',
+      operationKind: 'leader_integration_attempt',
+    });
+    assert.equal(key, 'team|worker-1|after|leader_integration_attempt');
+    assert.equal(teamWorkerPostToolUseInternals.isProtectedCheckpointPath('.omx/state/team/x'), true);
+    assert.equal(teamWorkerPostToolUseInternals.isProtectedCheckpointPath('src/index.ts'), false);
+  });
+
+  it('fails closed for missing worker identity without guessed state writes', async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'omx-posttooluse-missing-identity-'));
+    const result = await handleTeamWorkerPostToolUseSuccess(successPayload, cwd, {
+      ...process.env,
+      OMX_TEAM_WORKER: 'demo-team/worker-1',
+      OMX_TEAM_STATE_ROOT: join(cwd, '.omx', 'state'),
+    });
+
+    assert.equal(result.handled, false);
+    assert.equal(result.status, 'skipped');
+    assert.equal(existsSync(join(cwd, '.omx', 'state', 'team')), false);
+  });
+});

package/src/scripts/notify-hook/managed-tmux.ts

@@ -61,6 +61,10 @@ function readNativeSessionId(sessionState: { native_session_id?: unknown; codex_
   return safeString(sessionState.native_session_id || sessionState.codex_session_id || '').trim();
 }
 
+function readAuthoritativeTmuxSessionName(sessionState: { tmux_session_name?: unknown; tmuxSessionName?: unknown }): string {
+  return safeString(sessionState.tmux_session_name || sessionState.tmuxSessionName || '').trim();
+}
+
 function readCurrentTmuxSessionName(): string {
   if (!process.env.TMUX) return '';
   try {
@@ -154,10 +158,12 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
     }
 
     const authoritativeSessionCwd = safeString(sessionState.cwd || cwd).trim() || cwd;
-    const expectedTmuxSessionName = buildExpectedManagedTmuxSessionName(
-      authoritativeSessionCwd,
-      canonicalSessionId || invocationSessionId,
-    );
+    const authoritativeTmuxSessionName = readAuthoritativeTmuxSessionName(sessionState);
+    const expectedTmuxSessionName = authoritativeTmuxSessionName
+      || buildExpectedManagedTmuxSessionName(
+        authoritativeSessionCwd,
+        canonicalSessionId || invocationSessionId,
+      );
     const currentTmuxSessionName = readCurrentTmuxSessionName();
     if (currentTmuxSessionName && currentTmuxSessionName === expectedTmuxSessionName) {
       return {
@@ -171,6 +177,18 @@ export async function resolveManagedSessionContext(cwd: string, payload: any, {
         currentTmuxSessionName,
       };
     }
+    if (authoritativeTmuxSessionName && currentTmuxSessionName) {
+      return {
+        managed: false,
+        reason: 'tmux_session_mismatch',
+        invocationSessionId,
+        canonicalSessionId,
+        nativeSessionId,
+        sessionState,
+        expectedTmuxSessionName,
+        currentTmuxSessionName,
+      };
+    }
 
     if (processHasAncestorPid(sessionState.pid)) {
       return {

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

@@ -6,7 +6,11 @@ import { spawn } from 'child_process';
 
 export function runProcess(command: string, args: string[], timeoutMs = 3000): Promise<{ stdout: string; stderr: string; code: number | null }> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const usingTestTmux = command === 'tmux' && process.env.OMX_TEST_TMUX_BIN;
+    const relaxingTestTmuxTimeout = command === 'tmux' && process.env.OMX_TEST_RELAX_TMUX_TIMEOUT === '1';
+    const executable = usingTestTmux ? process.env.OMX_TEST_TMUX_BIN as string : command;
+    const effectiveTimeoutMs = usingTestTmux || relaxingTestTmuxTimeout ? Math.max(timeoutMs, 10_000) : timeoutMs;
+    const child = spawn(executable, args, { stdio: ['ignore', 'pipe', 'pipe'] });
     let stdout = '';
     let stderr = '';
     let finished = false;
@@ -15,8 +19,8 @@ export function runProcess(command: string, args: string[], timeoutMs = 3000): P
       if (finished) return;
       finished = true;
       child.kill('SIGTERM');
-      reject(new Error(`timeout after ${timeoutMs}ms`));
-    }, timeoutMs);
+      reject(new Error(`timeout after ${effectiveTimeoutMs}ms`));
+    }, effectiveTimeoutMs);
 
     child.stdout.on('data', (chunk: Buffer) => {
       stdout += chunk.toString();

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

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { appendFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
 import { execFileSync } from 'child_process';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'node:url';
@@ -27,7 +27,7 @@ import {
  * owned path.
  * Disable entirely with OMX_RUNTIME_BRIDGE=0.
  */
-function runtimeExec(command, stateDir) {
+function runtimeExec(command, stateDir, team) {
   if (process.env.OMX_RUNTIME_BRIDGE === '0') return;
   try {
     const binaryPath = resolveRuntimeBinaryPath();
@@ -36,11 +36,82 @@ function runtimeExec(command, stateDir) {
       stdio: ['pipe', 'pipe', 'pipe'],
       windowsHide: true,
     });
-  } catch {
+  } catch (error) {
+    recordBridgeFallback({
+      stateDir,
+      team,
+      operation: 'runtimeExec',
+      fallbackTarget: 'js_state_mutation',
+      command: safeString(command?.command).trim() || 'unknown',
+      requestId: safeString(command?.request_id).trim() || undefined,
+      messageId: safeString(command?.message_id).trim() || undefined,
+      reason: bridgeErrorReason(error),
+    });
     // non-fatal: JS path is the fallback
   }
 }
 
+function bridgeErrorReason(error) {
+  const err = error || {};
+  const stderr = safeString(err.stderr).trim();
+  if (stderr) return stderr.slice(0, 500);
+  const message = safeString(err.message).trim();
+  if (message) return message.slice(0, 500);
+  return 'unknown_bridge_error';
+}
+
+function bridgeFallbackLogPath(stateDir) {
+  return join(dirname(stateDir), 'logs', `team-dispatch-${new Date().toISOString().slice(0, 10)}.jsonl`);
+}
+
+function recordBridgeFallback({
+  stateDir,
+  team,
+  operation,
+  fallbackTarget,
+  command,
+  requestId,
+  messageId,
+  reason,
+}) {
+  const event = {
+    timestamp: new Date().toISOString(),
+    type: 'bridge_fallback',
+    source: 'notify-hook.team-dispatch',
+    fallback: true,
+    counter: 'team_dispatch_bridge_fallback_total',
+    bridge_operation: operation,
+    fallback_target: fallbackTarget,
+    team: safeString(team).trim() || null,
+    command: safeString(command).trim() || null,
+    request_id: safeString(requestId).trim() || null,
+    message_id: safeString(messageId).trim() || null,
+    reason: safeString(reason).trim() || 'unknown_bridge_fallback',
+  };
+  try {
+    const logPath = bridgeFallbackLogPath(stateDir);
+    mkdirSync(dirname(logPath), { recursive: true });
+    appendFileSync(logPath, `${JSON.stringify(event)}\n`);
+  } catch {
+    // best effort observability only
+  }
+  try {
+    appendTeamDeliveryLog(join(dirname(stateDir), 'logs'), {
+      event: 'bridge_fallback',
+      ...event,
+    }).catch(() => {});
+  } catch {
+    // best effort observability only
+  }
+  try {
+    process.emitWarning(`[omx] team-dispatch bridge fallback: ${event.bridge_operation} -> ${event.fallback_target}: ${event.reason}`, {
+      code: 'OMX_TEAM_DISPATCH_BRIDGE_FALLBACK',
+    });
+  } catch {
+    // best effort observability only
+  }
+}
+
 function readJson(path, fallback) {
   return readFile(path, 'utf8')
     .then((raw) => JSON.parse(raw))
@@ -50,8 +121,29 @@ function readJson(path, fallback) {
 async function readBridgeDispatchRequests(stateDir, teamName) {
   const candidate = join(stateDir, 'dispatch.json');
   if (!existsSync(candidate)) return null;
-  const parsed = await readJson(candidate, null);
-  if (!parsed || !Array.isArray(parsed.records)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(candidate, 'utf8'));
+  } catch (error) {
+    recordBridgeFallback({
+      stateDir,
+      team: teamName,
+      operation: 'readBridgeDispatchRequests',
+      fallbackTarget: 'legacy_dispatch_requests',
+      reason: `parse_failed:${bridgeErrorReason(error)}`,
+    });
+    return null;
+  }
+  if (!parsed || !Array.isArray(parsed.records)) {
+    recordBridgeFallback({
+      stateDir,
+      team: teamName,
+      operation: 'readBridgeDispatchRequests',
+      fallbackTarget: 'legacy_dispatch_requests',
+      reason: 'invalid_dispatch_compat_schema',
+    });
+    return null;
+  }
   return parsed.records
     .map((record) => {
       if (!record || typeof record !== 'object') return null;
@@ -501,7 +593,7 @@ async function finalizeClaimedDispatchRequest({
         request.status = 'failed';
         request.failed_at = nowIso;
         request.last_reason = 'unconfirmed_after_max_retries';
-        runtimeExec({ command: 'MarkFailed', request_id: request.request_id, reason: 'unconfirmed_after_max_retries' }, stateDir);
+        runtimeExec({ command: 'MarkFailed', request_id: request.request_id, reason: 'unconfirmed_after_max_retries' }, stateDir, teamName);
         summary.processed += 1;
         summary.failed += 1;
         mutated = true;
@@ -538,9 +630,9 @@ async function finalizeClaimedDispatchRequest({
         request.status = 'notified';
         request.notified_at = nowIso;
         request.last_reason = result.reason;
-        runtimeExec({ command: 'MarkNotified', request_id: request.request_id, channel: 'tmux' }, stateDir);
+        runtimeExec({ command: 'MarkNotified', request_id: request.request_id, channel: 'tmux' }, stateDir, teamName);
         if (request.kind === 'mailbox' && request.message_id) {
-          runtimeExec({ command: 'MarkMailboxNotified', message_id: request.message_id }, stateDir);
+          runtimeExec({ command: 'MarkMailboxNotified', message_id: request.message_id }, stateDir, teamName);
           if (usingLegacyRequests) {
             await updateMailboxNotified(stateDir, teamName, request.to_worker, request.message_id).catch(() => {});
           }
@@ -571,7 +663,7 @@ async function finalizeClaimedDispatchRequest({
       request.status = 'failed';
       request.failed_at = nowIso;
       request.last_reason = result.reason;
-      runtimeExec({ command: 'MarkFailed', request_id: request.request_id, reason: result.reason }, stateDir);
+      runtimeExec({ command: 'MarkFailed', request_id: request.request_id, reason: result.reason }, stateDir, teamName);
       summary.processed += 1;
       summary.failed += 1;
       mutated = true;
@@ -752,7 +844,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       const wideCap = await runProcess('tmux', verifyWideArgv, 2000);
       // Worker is actively processing (mirrors sync path tmux-session.ts:1292-1294)
       if (paneHasActiveTask(wideCap.stdout)) {
-        runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir);
+        runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir, request.team_name);
         return {
           ok: true,
           reason: 'tmux_send_keys_confirmed_active_task',
@@ -773,7 +865,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       const triggerInNarrow = capturedPaneContainsTrigger(narrowCap.stdout, request.trigger_message);
       const triggerNearTail = capturedPaneContainsTriggerNearTail(wideCap.stdout, request.trigger_message);
       if (!triggerInNarrow && !triggerNearTail) {
-        runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir);
+        runtimeExec({ command: 'MarkDelivered', request_id: request.request_id }, stateDir, request.team_name);
         return {
           ok: true,
           reason: 'tmux_send_keys_confirmed',

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

@@ -39,7 +39,7 @@ export async function evaluatePaneInjectionReadiness(paneTarget: any, {
   }
   if (skipIfScrolling) {
     try {
-      const modeResult = await runProcess('tmux', buildPaneInModeArgv(target), 1000);
+      const modeResult = await runProcess('tmux', buildPaneInModeArgv(target), 3000);
       if (safeString(modeResult.stdout).trim() === '1') {
         return {
           ok: false,
@@ -67,7 +67,7 @@ export async function evaluatePaneInjectionReadiness(paneTarget: any, {
     readinessEvidence,
   });
   try {
-    const result = await runProcess('tmux', buildPaneCurrentCommandArgv(target), 1000);
+    const result = await runProcess('tmux', buildPaneCurrentCommandArgv(target), 3000);
     paneCurrentCommand = safeString(result.stdout).trim();
     paneRunningShell = requireRunningAgent && isPaneRunningShell(paneCurrentCommand);
   } catch {
@@ -75,7 +75,7 @@ export async function evaluatePaneInjectionReadiness(paneTarget: any, {
   }
 
   try {
-    const capture = await runProcess('tmux', buildCapturePaneArgv(target, captureLines), 1000);
+    const capture = await runProcess('tmux', buildCapturePaneArgv(target, captureLines), 3000);
     const paneCapture = safeString(capture.stdout);
     const hasCaptureEvidence = paneCapture.trim() !== '';
     if (hasCaptureEvidence) {