oh-my-codex 0.20.3 → 0.21.0

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

@@ -8,6 +8,12 @@ import {
   readConfiguredLoreCommitGuardValue,
 } from "../config/commit-lore-guard.js";
 import { resolveCodexExecutionSurface } from "./codex-execution-surface.js";
+import {
+  buildAdvisoryPreToolUseOutput,
+  buildHudCapabilityWarningMessage,
+  buildQuestionCapabilityWarningMessage,
+  buildTeamCapabilityWarningMessage,
+} from "../hooks/native/capability-warnings.js";
 
 type CodexHookPayload = Record<string, unknown>;
 
@@ -1243,9 +1249,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 {
@@ -1275,12 +1293,8 @@ function buildNativeOmxHudPreToolUseEnforcementOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
   if (!isNativeOutsideTmuxSurface(payload) || !commandInvokesOmxHud(command)) return null;
-
-  return {
-    decision: "block",
-    reason: "omx hud cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
-    systemMessage: "omx hud is blocked from Bash in Codex App/native outside-tmux sessions; use SessionStart/HUD context instead, or launch OMX CLI from an attached tmux shell first for the tmux HUD runtime.",
-  };
+  // #3497: capability warning only — do not lock PreToolUse.
+  return buildAdvisoryPreToolUseOutput(buildHudCapabilityWarningMessage());
 }
 
 function buildNativeOmxTeamPreToolUseEnforcementOutput(
@@ -1288,37 +1302,49 @@ function buildNativeOmxTeamPreToolUseEnforcementOutput(
   payload: CodexHookPayload,
 ): Record<string, unknown> | null {
   if (!isNativeOutsideTmuxSurface(payload) || !commandInvokesOmxTeam(command)) return null;
-
-  return {
-    decision: "block",
-    reason: "omx team cannot be launched directly from Codex App/native outside-tmux Bash sessions.",
-    systemMessage: `omx team is blocked from Bash in Codex App/native outside-tmux sessions; launch OMX CLI from an attached tmux shell first. Original command: ${command}`,
-  };
+  // #3497: team-only features warn cleanly when tmux is absent; never lock.
+  return buildAdvisoryPreToolUseOutput(
+    buildTeamCapabilityWarningMessage(`Original command: ${command}`),
+  );
 }
 
-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)) {
+    // #3497: advisory capability warning, not a hard PreToolUse lock.
     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: buildAdvisoryPreToolUseOutput(buildQuestionCapabilityWarningMessage(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: buildAdvisoryPreToolUseOutput(
+      `Capability warning: omx question Bash invocations should preserve the leader pane return target 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/auto-nudge.ts

@@ -158,6 +158,7 @@ export function normalizeSkillActiveState(raw) {
   const skill = safeString(raw.skill);
   if (!skill) return null;
   return {
+    ...raw,
     version: asNumber(raw.version) ?? 1,
     active: raw.active !== false,
     skill,

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-dispatch.ts

@@ -954,6 +954,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
     expectedHudPaneId: dispatchTarget.expectedHudPaneId,
     prompt: request.trigger_message,
     submitKeyPresses,
+    submitKey: 'Enter',
     typePrompt: shouldTypePrompt,
     queueFirstSubmit: leaderTargeted,
   });
@@ -973,7 +974,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
 
   // Post-injection verification: confirm the trigger text was consumed.
   // Fixes #391: without this, dispatch marks 'notified' even when the worker
-  // pane is sitting on an unsent draft (C-m was not effectively applied).
+  // pane is sitting on an unsent draft (Enter was not effectively applied).
   const verifyNarrowArgv = buildJoinedCapturePaneArgv(resolution.paneTarget, 8);
   const verifyWideArgv = buildJoinedCapturePaneArgv(resolution.paneTarget);
   for (let round = 0; round < INJECT_VERIFY_ROUNDS; round++) {
@@ -990,7 +991,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       // full-scrollback false positives.
       narrowCap = await runProcess('tmux', verifyNarrowArgv, 2000);
     } catch {
-      // Capture failed; fall through to retry C-m.
+      // Capture failed; fall through to retry Enter.
     }
     if (narrowCap) {
       const wideProof = await verifyExplicitPane();
@@ -1000,7 +1001,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) {
-          // Draft is still visible, so C-m has not actually submitted it yet.
+          // Draft is still visible, so Enter has not actually submitted it yet.
           // Do not let transient spinner/active-task text mask an unsent draft.
           const retrySend = await sendPaneInput({
             paneTarget: resolution.paneTarget,
@@ -1010,6 +1011,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
             expectedHudPaneId: dispatchTarget.expectedHudPaneId,
             prompt: request.trigger_message,
             submitKeyPresses,
+            submitKey: 'Enter',
             typePrompt: false,
           });
           if (!retrySend.ok && retrySend.reason === EXACT_PANE_UNAVAILABLE_REASON) {
@@ -1055,10 +1057,10 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
           };
         }
       } catch {
-        // Capture failed; fall through to retry C-m.
+        // Capture failed; fall through to retry Enter.
       }
     }
-    // Draft still visible and no active task — retry C-m
+    // Draft still visible and no active task — retry Enter
     const retrySend = await sendPaneInput({
       paneTarget: resolution.paneTarget,
       exactPaneId,
@@ -1067,6 +1069,7 @@ async function injectDispatchRequest(request, config, cwd, stateDir) {
       expectedHudPaneId: dispatchTarget.expectedHudPaneId,
       prompt: request.trigger_message,
       submitKeyPresses,
+      submitKey: 'Enter',
       typePrompt: false,
       queueFirstSubmit: leaderTargeted,
     });