oh-my-codex 0.20.3 → 0.20.5

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

@@ -1243,9 +1243,21 @@ function commandHasPowerShellQuestionReturnPane(command: string): boolean {
 }
 
 function commandHasQuestionReturnPane(command: string): boolean {
-  if (hasInheritedQuestionReturnPaneBridge()) return true;
   if (commandHasPowerShellQuestionReturnPane(command)) return true;
-  return (tokenizeShellCommand(command) ?? []).some(isQuestionReturnPaneAssignment);
+  const tokens = tokenizeShellCommand(command) ?? [];
+  const localBridgeTokens = tokens.filter((token) => {
+    const equalsIndex = token.indexOf('=');
+    if (equalsIndex <= 0) return false;
+    const name = token.slice(0, equalsIndex);
+    return name === 'OMX_QUESTION_RETURN_PANE' || name === 'OMX_LEADER_PANE_ID';
+  });
+  if (localBridgeTokens.length > 0) {
+    // A command-local bridge assignment overrides the inherited environment for the
+    // invoked process, so its validity — not the inherited pane — governs the decision.
+    return localBridgeTokens.every(isQuestionReturnPaneAssignment);
+  }
+  if (hasInheritedQuestionReturnPaneBridge()) return true;
+  return tokens.some(isQuestionReturnPaneAssignment);
 }
 
 function commandInvokesOmxTeam(command: string): boolean {
@@ -1296,29 +1308,48 @@ function buildNativeOmxTeamPreToolUseEnforcementOutput(
   };
 }
 
-function buildOmxQuestionPreToolUseEnforcementOutput(
+export type OmxQuestionPreToolUseClassification =
+  | { kind: "not-question" }
+  | { kind: "allowed" }
+  | { kind: "denied"; output: Record<string, unknown> };
+
+export function classifyOmxQuestionPreToolUse(
   command: string,
   payload: CodexHookPayload,
-): Record<string, unknown> | null {
-  if (!commandInvokesOmxQuestion(command)) return null;
+): OmxQuestionPreToolUseClassification {
+  if (!commandInvokesOmxQuestion(command)) return { kind: "not-question" };
 
   if (isNativeOutsideTmuxSurface(payload)) {
     return {
-      decision: "block",
-      reason: "omx question cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
-      systemMessage: `omx question is blocked from Codex App/native outside-tmux Bash because no attached tmux pane is available. Use the native structured question tool when available, or ask exactly one concise plain-text question. Original command: ${command}`,
+      kind: "denied",
+      output: {
+        decision: "block",
+        reason: "omx question cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
+        systemMessage: `omx question is blocked from Codex App/native outside-tmux Bash because no attached tmux pane is available. Use the native structured question tool when available, or ask exactly one concise plain-text question. Original command: ${command}`,
+      },
     };
   }
 
-  if (commandHasQuestionReturnPane(command)) return null;
+  if (commandHasQuestionReturnPane(command)) return { kind: "allowed" };
 
   return {
-    decision: "block",
-    reason: "omx question Bash invocations must preserve the leader pane return target.",
-    systemMessage: `omx question is blocked from Bash until the command preserves the leader pane with \`OMX_QUESTION_RETURN_PANE=$TMUX_PANE\` or an explicit \`%pane\` value. Original command: ${command}`,
+    kind: "denied",
+    output: {
+      decision: "block",
+      reason: "omx question Bash invocations must preserve the leader pane return target.",
+      systemMessage: `omx question is blocked from Bash until the command preserves the leader pane with \`OMX_QUESTION_RETURN_PANE=$TMUX_PANE\` or an explicit \`%pane\` value. Original command: ${command}`,
+    },
   };
 }
 
+function buildOmxQuestionPreToolUseEnforcementOutput(
+  command: string,
+  payload: CodexHookPayload,
+): Record<string, unknown> | null {
+  const classification = classifyOmxQuestionPreToolUse(command, payload);
+  return classification.kind === "denied" ? classification.output : null;
+}
+
 export function buildNativePreToolUseOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {

package/src/scripts/generate-native-release-manifest.ts

@@ -1,16 +1,22 @@
 #!/usr/bin/env node
-import { readFileSync, writeFileSync, statSync, readdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { inspectNativeArchive, selectNativeArchiveBinary } from '../native-assets/archive.js';
+import {
+  nativeTargetMapping,
+  validateNativeReleaseManifest,
+  type NativeReleaseAssetPolicyInput,
+} from '../native-assets/policy.js';
 
-function usage(): void {
+function usage(): never {
   console.error('Usage: node scripts/generate-native-release-manifest.mjs --plan <path> --artifacts-dir <dir> --out <path> --release-base-url <url> [--require-products a,b]');
   process.exit(1);
 }
 
 function arg(name: string): string | undefined {
   const index = process.argv.indexOf(name);
-  if (index === -1) return undefined;
-  return process.argv[index + 1];
+  return index === -1 ? undefined : process.argv[index + 1];
 }
 
 function walk(dir: string): string[] {
@@ -18,42 +24,31 @@ function walk(dir: string): string[] {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) files.push(...walk(full));
-    else files.push(full);
+    else if (entry.isFile()) files.push(full);
   }
   return files;
 }
 
-function parseChecksum(raw: string): string {
-  return String(raw).trim().split(/\s+/)[0];
+function sha256(path: string): string {
+  return createHash('sha256').update(readFileSync(path)).digest('hex');
 }
 
-interface TripleMapping {
-  platform: string;
-  arch: string;
-  libc?: string;
+function checksum(raw: string, artifact: string): string {
+  const value = raw.trim().split(/\s+/)[0] || '';
+  if (!/^[a-f0-9]{64}$/i.test(value)) throw new Error(`invalid SHA-256 sidecar for ${artifact}`);
+  return value.toLowerCase();
 }
 
-function mapTriple(triple: string): TripleMapping | undefined {
-  switch (triple) {
-    case 'x86_64-unknown-linux-gnu': return { platform: 'linux', arch: 'x64', libc: 'glibc' };
-    case 'aarch64-unknown-linux-gnu': return { platform: 'linux', arch: 'arm64', libc: 'glibc' };
-    case 'x86_64-unknown-linux-musl': return { platform: 'linux', arch: 'x64', libc: 'musl' };
-    case 'aarch64-unknown-linux-musl': return { platform: 'linux', arch: 'arm64', libc: 'musl' };
-    case 'x86_64-apple-darwin': return { platform: 'darwin', arch: 'x64' };
-    case 'aarch64-apple-darwin': return { platform: 'darwin', arch: 'arm64' };
-    case 'x86_64-pc-windows-msvc': return { platform: 'win32', arch: 'x64' };
-    case 'aarch64-pc-windows-msvc': return { platform: 'win32', arch: 'arm64' };
-    default: return undefined;
+function basenameIndex(files: string[]): Map<string, string> {
+  const result = new Map<string, string>();
+  for (const file of files) {
+    const name = file.split(/[\\/]/).at(-1)!;
+    if (result.has(name)) throw new Error(`duplicate artifact basename: ${name}`);
+    result.set(name, file);
   }
+  return result;
 }
 
-const planPath = arg('--plan');
-const artifactsDir = arg('--artifacts-dir');
-const outPath = arg('--out');
-const releaseBaseUrl = arg('--release-base-url');
-const requireProducts = (arg('--require-products') || '').split(',').map((value) => value.trim()).filter(Boolean);
-if (!planPath || !artifactsDir || !outPath || !releaseBaseUrl) usage();
-
 interface PlanArtifact {
   kind: string;
   name: string;
@@ -73,75 +68,84 @@ interface Plan {
   announcement_tag: string;
 }
 
-interface ManifestAsset {
-  product: string;
-  version: string;
-  platform: string;
-  arch: string;
-  target: string;
-  libc?: string;
-  archive: string;
-  binary: string;
-  binary_path: string;
-  sha256: string;
-  size: number;
-  download_url: string;
-}
+const planPath = arg('--plan');
+const artifactsDir = arg('--artifacts-dir');
+const outPath = arg('--out');
+const releaseBaseUrl = arg('--release-base-url');
+const requestedProducts = (arg('--require-products') || '').split(',').map((value) => value.trim()).filter(Boolean);
+// A product preflight denotes a full cargo-dist release. omx-runtime is released with
+// that bundle but is intentionally not a runtime-hydratable product.
+const requireProducts = requestedProducts.length === 0
+  ? []
+  : [...new Set([...requestedProducts, 'omx-runtime'])];
+if (!planPath || !artifactsDir || !outPath || !releaseBaseUrl) usage();
 
-const plan = JSON.parse(readFileSync(resolve(planPath!), 'utf-8')) as Plan;
-const files = walk(resolve(artifactsDir!));
-const byName = new Map(files.map((file) => [file.split('/').pop()!, file]));
-const assets: ManifestAsset[] = [];
+const plan = JSON.parse(readFileSync(resolve(planPath), 'utf-8')) as Plan;
+if (!/^v[^\s/]+$/.test(plan.announcement_tag)) throw new Error('announcement tag must be a v-prefixed release version');
+const version = plan.announcement_tag.slice(1);
+if (!Array.isArray(plan.releases) || plan.releases.length === 0 || plan.releases.some((release) => release.app_version !== version)) {
+  throw new Error(`release versions must exactly match announcement tag ${plan.announcement_tag}`);
+}
 
+const byName = basenameIndex(walk(resolve(artifactsDir)));
+const assets: NativeReleaseAssetPolicyInput[] = [];
 for (const artifact of Object.values(plan.artifacts)) {
   if (artifact.kind !== 'executable-zip') continue;
-  const triple = artifact.target_triples?.[0];
-  const mapped = triple ? mapTriple(triple) : undefined;
-  if (!mapped) continue;
-  const executable = (artifact.assets || []).find((asset) => asset.kind === 'executable');
-  if (!executable) continue;
+  if (!Array.isArray(artifact.target_triples) || artifact.target_triples.length !== 1) {
+    throw new Error(`expected exactly one target triple for ${artifact.name}`);
+  }
+  const target = artifact.target_triples[0]!;
+  const mapping = nativeTargetMapping(target);
+  if (!mapping) throw new Error(`unsupported native target ${target}`);
+  if (!/\.(?:tar\.xz|tar\.gz|zip)$/i.test(artifact.name)) throw new Error(`unsupported native archive format: ${artifact.name}`);
+  const executable = artifact.assets?.filter((asset) => asset.kind === 'executable') ?? [];
+  if (executable.length !== 1) throw new Error(`expected exactly one executable for ${artifact.name}`);
+  const binary = executable[0]!;
   const archivePath = byName.get(artifact.name);
   const checksumPath = byName.get(artifact.checksum);
-  if (!archivePath || !checksumPath) {
-    throw new Error(`missing artifact files for ${artifact.name}`);
-  }
-
-  const release = plan.releases.find((item) => item.app_name === executable.name || item.app_name === executable.id?.split('-exe-')[0]);
-  const version = release?.app_version || plan.announcement_tag.replace(/^v/, '');
+  if (!archivePath || !checksumPath) throw new Error(`missing artifact files for ${artifact.name}`);
+  if (statSync(archivePath).size <= 0 || statSync(checksumPath).size <= 0) throw new Error(`empty artifact file for ${artifact.name}`);
+  const expectedSha256 = checksum(readFileSync(checksumPath, 'utf-8'), artifact.name);
+  if (sha256(archivePath) !== expectedSha256) throw new Error(`checksum mismatch for ${artifact.name}`);
+  const archiveEntries = await inspectNativeArchive(archivePath);
+  selectNativeArchiveBinary(archiveEntries, binary.path);
+  const release = plan.releases.find((item) => item.app_name === binary.name || item.app_name === binary.id?.split('-exe-')[0]);
+  if (!release || release.app_version !== version) throw new Error(`missing coherent release metadata for ${artifact.name}`);
   assets.push({
-    product: executable.name,
+    product: release.app_name,
     version,
-    platform: mapped.platform,
-    arch: mapped.arch,
-    target: triple!,
-    ...(mapped.libc ? { libc: mapped.libc } : {}),
+    platform: mapping.platform,
+    arch: mapping.arch,
+    target,
+    ...(mapping.libc ? { libc: mapping.libc } : {}),
     archive: artifact.name,
-    binary: executable.name,
-    binary_path: executable.path,
-    sha256: parseChecksum(readFileSync(checksumPath, 'utf-8')),
+    binary: release.app_name,
+    binary_path: binary.path,
+    sha256: expectedSha256,
     size: statSync(archivePath).size,
-    download_url: `${releaseBaseUrl!.replace(/\/$/, '')}/${artifact.name}`,
+    download_url: `${releaseBaseUrl.replace(/\/$/, '')}/${artifact.name}`,
   });
 }
 
 const manifest = {
   manifest_version: 1,
-  version: plan.announcement_tag.replace(/^v/, ''),
+  version,
   tag: plan.announcement_tag,
   generated_at: new Date().toISOString(),
   assets: assets.sort((a, b) => {
-    const keyCompare = `${a.product}-${a.platform}-${a.arch}`.localeCompare(`${b.product}-${b.platform}-${b.arch}`);
-    if (keyCompare !== 0) return keyCompare;
-    const libcOrder: Record<string, number> = { musl: 0, glibc: 1 };
-    const libcCompare = (libcOrder[a.libc ?? ''] ?? 2) - (libcOrder[b.libc ?? ''] ?? 2);
-    if (libcCompare !== 0) return libcCompare;
-    return a.archive.localeCompare(b.archive);
+    const libcRank = (asset: NativeReleaseAssetPolicyInput): number => asset.libc === 'musl' ? 0 : asset.libc === 'glibc' ? 1 : 2;
+    return a.product.localeCompare(b.product)
+      || a.platform.localeCompare(b.platform)
+      || a.arch.localeCompare(b.arch)
+      || libcRank(a) - libcRank(b)
+      || a.archive.localeCompare(b.archive);
   }),
 };
+if (manifest.assets.length === 0) throw new Error('release manifest must declare at least one native archive');
+validateNativeReleaseManifest(manifest);
+if (manifest.tag !== `v${manifest.version}`) throw new Error('manifest tag/version mismatch');
 for (const product of requireProducts) {
-  if (!manifest.assets.some((asset) => asset.product === product)) {
-    throw new Error(`missing required product in release manifest: ${product}`);
-  }
+  if (!manifest.assets.some((asset) => asset.product === product)) throw new Error(`missing required product in release manifest: ${product}`);
 }
-writeFileSync(resolve(outPath!), `${JSON.stringify(manifest, null, 2)}\n`);
-console.log(resolve(outPath!));
+writeFileSync(resolve(outPath), `${JSON.stringify(manifest, null, 2)}\n`);
+console.log(resolve(outPath));

package/src/scripts/notify-fallback-watcher.ts

@@ -19,14 +19,13 @@ import {
 import {
   readScopedJsonIfExists,
 } from './notify-hook/state-io.js';
-import { checkPaneReadyForTeamSendKeys } from './notify-hook/team-tmux-guard.js';
 import {
   checkWorkerPanesAlive,
   isLeaderStale,
   maybeNudgeTeamLeader,
   resolveLeaderStalenessThresholdMs,
 } from './notify-hook/team-leader-nudge.js';
-import { DEFAULT_MARKER } from './tmux-hook-engine.js';
+import { DEFAULT_MARKER, isPaneRunningShell } from './tmux-hook-engine.js';
 import { isTerminalPhase } from './notify-hook/utils.js';
 import { isSessionStale, isSessionStateAuthoritativeForCwd, readSessionState } from '../hooks/session.js';
 import {
@@ -39,7 +38,6 @@ import { validateSessionId } from '../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../team/contracts.js';
 import { shouldContinueRun } from '../runtime/run-loop.js';
 import { deliverNotifyFallback, compactNotifyFallbackDeliveries, NOTIFY_FALLBACK_LEASE_MS } from './notify-fallback-delivery.js';
-import { readExactPaneProofSync } from '../team/exact-pane.js';
 import { OMX_RALPH_PANE_OWNER_OPTION } from '../state/mode-state-context.js';
 
 function argValue(name: string, fallback = ''): string {
@@ -196,6 +194,7 @@ interface RalphContinueSteerState {
   state_path: string;
   pane_id: string;
   pane_current_command: string;
+  pane_start_command: string;
   current_phase: string;
   subagent_session_id: string;
   active_subagent_thread_ids: string[];
@@ -345,6 +344,7 @@ let lastRalphContinueSteer: RalphContinueSteerState = {
   state_path: '',
   pane_id: '',
   pane_current_command: '',
+  pane_start_command: '',
   current_phase: '',
   subagent_session_id: '',
   active_subagent_thread_ids: [],
@@ -509,6 +509,7 @@ function normalizeRalphContinueSteerState(raw: Record<string, unknown> | null |
     state_path: safeString(raw.state_path),
     pane_id: safeString(raw.pane_id),
     pane_current_command: safeString(raw.pane_current_command),
+    pane_start_command: safeString(raw.pane_start_command),
     current_phase: safeString(raw.current_phase),
     subagent_session_id: safeString(raw.subagent_session_id),
     active_subagent_thread_ids: Array.isArray(raw.active_subagent_thread_ids)
@@ -780,45 +781,54 @@ interface RalphContinuePaneBinding {
   paneId: string;
   panePid: number;
   sessionName: string;
+  sessionId: string;
+  windowId: string;
   paneOwnerId: string;
+  paneCurrentCommand: string;
+  paneStartCommand: string;
+}
+
+function isSafeRalphAuthorityValue(value: string): boolean {
+  return /^[A-Za-z0-9_./:+@%=-]+(?: [A-Za-z0-9_./:+@%=-]+)*$/.test(value);
 }
 
 function parseRalphContinuePaneBinding(state: Record<string, unknown> | null): RalphContinuePaneBinding | null {
   const paneId = safeString(state?.tmux_pane_id).trim();
   const panePid = parsePositivePid(state?.tmux_pane_pid);
   const sessionName = safeString(state?.tmux_session_name).trim();
+  const sessionId = safeString(state?.tmux_session_id).trim();
+  const windowId = safeString(state?.tmux_window_id).trim();
   const paneOwnerId = safeString(state?.tmux_pane_owner_id).trim();
-  if (!/^%[0-9]+$/.test(paneId) || panePid === null || !sessionName || !paneOwnerId) return null;
+  const paneCurrentCommand = safeString(state?.tmux_pane_current_command).trim();
+  const paneStartCommand = safeString(state?.tmux_pane_start_command).trim();
+  if (!/^%[0-9]+$/.test(paneId) || panePid === null || !sessionName || !/^\$[0-9]+$/.test(sessionId)
+    || !/^@[0-9]+$/.test(windowId) || !paneOwnerId) return null;
+  if (!isSafeRalphAuthorityValue(sessionName) || !isSafeRalphAuthorityValue(paneOwnerId)
+    || !isSafeRalphAuthorityValue(paneCurrentCommand) || !isSafeRalphAuthorityValue(paneStartCommand)
+    || isPaneRunningShell(paneCurrentCommand)) return null;
   if (paneOwnerId.startsWith('team:')) return null;
-  return { paneId, panePid, sessionName, paneOwnerId };
+  return { paneId, panePid, sessionName, sessionId, windowId, paneOwnerId, paneCurrentCommand, paneStartCommand };
 }
 
-function requireFrozenRalphPaneBinding(binding: RalphContinuePaneBinding): void {
-  const initialProof = readExactPaneProofSync(binding.paneId);
-  if (initialProof.status !== 'live' || initialProof.pid !== binding.panePid) {
-    throw new Error(`persisted Ralph pane identity unavailable: ${binding.paneId}`);
-  }
-  const session = spawnPlatformCommandSync('tmux', ['display-message', '-p', '-t', binding.paneId, '#S'], { encoding: 'utf-8' }).result;
-  if (session.error || session.status !== 0 || safeString(session.stdout).trim() !== binding.sessionName) {
-    throw new Error(`persisted Ralph pane session changed: ${binding.paneId}`);
-  }
-  const owner = spawnPlatformCommandSync('tmux', ['show-option', '-qv', '-p', '-t', binding.paneId, OMX_RALPH_PANE_OWNER_OPTION], { encoding: 'utf-8' }).result;
-  if (owner.error || owner.status !== 0 || safeString(owner.stdout).trim() !== binding.paneOwnerId) {
-    throw new Error(`persisted Ralph pane owner changed: ${binding.paneId}`);
-  }
-  const finalProof = readExactPaneProofSync(binding.paneId);
-  if (finalProof.status !== 'live' || finalProof.pid !== binding.panePid) {
-    throw new Error(`persisted Ralph pane identity changed: ${binding.paneId}`);
-  }
+function ralphInputAuthorityCondition(binding: RalphContinuePaneBinding): string {
+  return `#{&&:#{==:#{pane_id},${binding.paneId}},#{&&:#{==:#{pane_dead},0},#{&&:#{==:#{pane_pid},${binding.panePid}},#{&&:#{==:#{session_name},${binding.sessionName}},#{&&:#{==:#{session_id},${binding.sessionId}},#{&&:#{==:#{window_id},${binding.windowId}},#{&&:#{==:#{${OMX_RALPH_PANE_OWNER_OPTION}},${binding.paneOwnerId}},#{&&:#{==:#{pane_current_command},${binding.paneCurrentCommand}},#{==:#{pane_start_command},${binding.paneStartCommand}}}}}}}}}`;
 }
 
 async function emitRalphContinueSteer(binding: RalphContinuePaneBinding, message: string): Promise<void> {
   const markedText = `${message} ${DEFAULT_MARKER}`;
   const sendKeys = (args: string[], failure: string): void => {
-    requireFrozenRalphPaneBinding(binding);
-    const { result } = spawnPlatformCommandSync('tmux', args, { encoding: 'utf-8' });
+    const receipt = `__omx_ralph_input_${Math.random().toString(36).slice(2)}__`;
+    const success = `${args.map((arg) => `'${arg.replace(/'/g, "'\\\"'\\\"'")}'`).join(' ')} \\; display-message -p ${receipt}`;
+    const denied = 'display-message -p __omx_ralph_input_denied__';
+    const { result } = spawnPlatformCommandSync(
+      'tmux',
+      ['if-shell', '-F', '-t', binding.paneId, ralphInputAuthorityCondition(binding), success, denied],
+      { encoding: 'utf-8' },
+    );
     if (result.error) throw new Error(result.error.message);
-    if (result.status !== 0) throw new Error((result.stderr || result.stdout || '').trim() || failure);
+    if (result.status !== 0 || safeString(result.stdout).trim() !== receipt) {
+      throw new Error((result.stderr || result.stdout || '').trim() || failure);
+    }
   };
   sendKeys(['send-keys', '-t', binding.paneId, '-l', markedText], 'tmux send-keys failed');
   await sleep(100);
@@ -1126,6 +1136,7 @@ async function runRalphContinueSteerTick(): Promise<void> {
     state_path: activeRalph.path,
     pane_id: activePaneId,
     pane_current_command: '',
+    pane_start_command: '',
     subagent_session_id: safeString(activeRalph.state?.owner_codex_session_id).trim(),
     active_subagent_thread_ids: [],
     shared_timestamp_path: ralphSteerTimestampPath,
@@ -1177,19 +1188,8 @@ async function runRalphContinueSteerTick(): Promise<void> {
       return { sent: false, skipped: true };
     }
     lastRalphContinueSteer.pane_id = binding.paneId;
-    try {
-      requireFrozenRalphPaneBinding(binding);
-    } catch (error) {
-      lastRalphContinueSteer.last_reason = 'pane_binding_changed';
-      lastRalphContinueSteer.last_error = error instanceof Error ? error.message : safeString(error);
-      return { sent: false, skipped: true };
-    }
-    const paneGuard = await checkPaneReadyForTeamSendKeys(binding.paneId, binding.paneId);
-    lastRalphContinueSteer.pane_current_command = paneGuard.paneCurrentCommand || '';
-    if (!paneGuard.ok) {
-      lastRalphContinueSteer.last_reason = paneGuard.reason || 'pane_guard_blocked';
-      return { sent: false, skipped: true };
-    }
+    lastRalphContinueSteer.pane_current_command = binding.paneCurrentCommand;
+    lastRalphContinueSteer.pane_start_command = binding.paneStartCommand;
     await emitRalphContinueSteer(binding, RALPH_CONTINUE_TEXT);
     await writeRalphSteerTimestamp(nowIso);
     lastRalphContinueSteer.last_sent_at = nowIso;

package/src/scripts/notify-hook/state-io.ts

@@ -6,6 +6,7 @@ import { mkdir, readFile, readdir, stat, writeFile } from 'fs/promises';
 import { dirname, join } from 'path';
 import { validateSessionId } from '../../mcp/state-paths.js';
 import { asNumber, safeString } from './utils.js';
+import { SKILL_ACTIVE_STATE_FILE, writeSkillActiveStateCopiesForStateDir } from '../../state/skill-active.js';
 
 
 export { readdir };
@@ -223,6 +224,16 @@ export async function writeScopedJson(
   explicitSessionId: string | undefined,
   value: unknown,
 ): Promise<void> {
+  if (fileName === SKILL_ACTIVE_STATE_FILE) {
+    await writeSkillActiveStateCopiesForStateDir(
+      baseStateDir,
+      value as Record<string, unknown>,
+      explicitSessionId,
+      undefined,
+      { sessionOnlyWhenRootMissing: Boolean(explicitSessionId) },
+    );
+    return;
+  }
   const targetPath = await getScopedStatePath(baseStateDir, fileName, explicitSessionId);
   await mkdir(dirname(targetPath), { recursive: true });
   await writeFile(targetPath, JSON.stringify(value, null, 2));

package/src/scripts/notify-hook/team-leader-nudge.ts

@@ -24,6 +24,7 @@ import { readLatestTeamProgressEvidenceMs } from '../../team/progress-evidence.j
 import { validateSessionId } from '../../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../../team/contracts.js';
 import { isDeepInterviewStateActive } from './auto-nudge.js';
+import { registerTeamNotice, releaseTeamNoticeWake } from '../../team/notice-ledger.js';
 const LEADER_PANE_MISSING_NO_INJECTION_REASON = 'leader_pane_missing_no_injection';
 const LEADER_PANE_SHELL_NO_INJECTION_REASON = 'leader_pane_shell_no_injection';
 const TEAM_SHUTDOWN_NO_INJECTION_REASON = 'team_state_gone_or_shutdown';
@@ -1043,8 +1044,16 @@ export async function maybeNudgeTeamLeader({
       await recordShutdownSuppression(orchestrationIntent);
       continue;
     }
-    const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
-    const markedText = `${capped} ${DEFAULT_MARKER}`;
+    const noticeClass = nudgeReason === 'all_workers_idle'
+      || nudgeReason === 'done_waiting_on_leader'
+      || nudgeReason === 'stuck_waiting_on_leader'
+      ? 'all_idle'
+      : nudgeReason.includes('stale')
+        ? 'leader_stale'
+        : 'mailbox';
+    const noticeGeneration = noticeClass === 'mailbox' && newestId
+      ? newestId
+      : `${nudgeReason}:${progressSnapshot.signature}:${prevIdleAtIso || prevAtIso || 'initial'}`;
 
     if (!tmuxTarget) {
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
@@ -1148,7 +1157,7 @@ export async function maybeNudgeTeamLeader({
       continue;
     }
 
-    if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, capped)) {
+    if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, text)) {
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
         await recordShutdownSuppression(orchestrationIntent);
         continue;
@@ -1194,11 +1203,26 @@ export async function maybeNudgeTeamLeader({
       await recordShutdownSuppression(orchestrationIntent);
       continue;
     }
-
+    let queuedNoticeRegistration = null;
     try {
       const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
       let deliveryMode = 'sent';
+      let markedText = `${text.length > 180 ? `${text.slice(0, 177)}...` : text} ${DEFAULT_MARKER}`;
       if (leaderHasActiveTask) {
+        const noticeRegistration = await registerTeamNotice({
+          stateRoot: stateDir,
+          targetId: tmuxPaneOwnerId,
+          teamName,
+          noticeClass,
+          generation: noticeGeneration,
+          source: { kind: 'leader_nudge', detail: nudgeReason },
+        }).catch(() => null);
+        if (!noticeRegistration?.queued || !noticeRegistration.prompt) {
+          await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true });
+          continue;
+        }
+        markedText = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+        queuedNoticeRegistration = noticeRegistration;
         const sendResult = await sendPaneInput({
           paneTarget: tmuxTarget,
           prompt: markedText,
@@ -1214,6 +1238,7 @@ export async function maybeNudgeTeamLeader({
           throw new Error(sendResult.error || sendResult.reason);
         }
         deliveryMode = 'queued';
+        queuedNoticeRegistration = null;
       } else {
         const sendResult = await sendPaneInput({
           paneTarget: tmuxTarget,
@@ -1266,6 +1291,9 @@ export async function maybeNudgeTeamLeader({
         orchestration_intent: orchestrationIntent,
       }).catch(() => {});
     } catch (err) {
+      if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+        await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+      }
       if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
         await recordShutdownSuppression(orchestrationIntent);
         continue;

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

@@ -16,6 +16,7 @@ import { readJsonIfExists } from './state-io.js';
 import { logTmuxHookEvent } from './log.js';
 import { evaluatePaneInjectionReadiness, normalizeExactPaneId, sendPaneInput } from './team-tmux-guard.js';
 import { readTeamWorkersForIdleCheck } from './team-worker.js';
+import { registerTeamNotice, releaseTeamNoticeWake } from '../../team/notice-ledger.js';
 
 const STOP_NUDGE_COOLDOWN_MS = 30_000;
 const SOURCE_TYPE = 'worker_stop';
@@ -249,6 +250,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
   let tmuxSession = '';
   let leaderPaneId = '';
   let recordedShutdownSuppression = false;
+  let queuedNoticeRegistration = null;
   const recordShutdownSuppressionOnce = async () => {
     if (recordedShutdownSuppression) return;
     recordedShutdownSuppression = true;
@@ -356,10 +358,23 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };
   }
 
-  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;
+  const leaderBusy = paneHasActiveTask(paneGuard.paneCapture);
+  let 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}`;
+  if (leaderBusy) {
+    const noticeRegistration = await registerTeamNotice({
+      stateRoot: stateDir,
+      targetId: leaderPaneOwnerId,
+      teamName,
+      noticeClass: 'worker_stop',
+      generation: `${nowIso}:${workerName}`,
+      source: { kind: SOURCE_TYPE, detail: workerName },
+    }).catch(() => null);
+    if (!noticeRegistration?.queued || !noticeRegistration.prompt) {
+      return { ok: true, result: 'coalesced' };
+    }
+    prompt = `${noticeRegistration.prompt} ${DEFAULT_MARKER}`;
+    queuedNoticeRegistration = noticeRegistration;
+  }
 
     const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
     const sendResult = await sendPaneInput({
@@ -373,6 +388,7 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
       expectedHudPaneId: teamInfo.hudPaneId,
     });
     if (!sendResult.ok) throw new Error(sendResult.error || sendResult.reason || 'send_failed');
+    queuedNoticeRegistration = null;
     const deliveryMode = leaderHasActiveTask ? 'steered' : 'sent';
 
     const deliveryState = {
@@ -418,6 +434,9 @@ export async function maybeNudgeLeaderForAllowedWorkerStop({
     }).catch(() => {});
     return { ok: true, result: deliveryMode };
   } catch (err) {
+    if (queuedNoticeRegistration?.targetKey && queuedNoticeRegistration?.wakeId) {
+      await releaseTeamNoticeWake(stateDir, queuedNoticeRegistration.targetKey, queuedNoticeRegistration.wakeId).catch(() => {});
+    }
     if (!(await teamStateAllowsWorkerStopNudge(stateDir, teamName))) {
       await recordShutdownSuppressionOnce();
       return { ok: true, result: TEAM_SHUTDOWN_NO_INJECTION_REASON };