oh-my-codex 0.20.2 → 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,15 +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 { resolveManagedPaneFromAnchor, resolveManagedSessionPane } from './notify-hook/managed-tmux.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 {
@@ -40,6 +38,7 @@ 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 { OMX_RALPH_PANE_OWNER_OPTION } from '../state/mode-state-context.js';
 
 function argValue(name: string, fallback = ''): string {
   const idx = process.argv.indexOf(name);
@@ -72,8 +71,12 @@ function normalizeValidTeamName(value: unknown): string {
 }
 
 function parsePositivePid(value: unknown): number | null {
-  const pid = Math.trunc(asNumber(value as string | number | undefined, 0));
-  return pid > 0 ? pid : null;
+  if (typeof value === 'number') return Number.isSafeInteger(value) && value > 0 ? value : null;
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  if (!/^[1-9][0-9]*$/.test(trimmed)) return null;
+  const pid = Number(trimmed);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
 }
 
 function parseIsoMillis(value: string | null | undefined): number | null {
@@ -191,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[];
@@ -340,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: [],
@@ -504,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)
@@ -771,25 +777,64 @@ async function resolveActiveTeamState(): Promise<ActiveTeamResult> {
   };
 }
 
-async function emitRalphContinueSteer(paneId: string, message: string): Promise<void> {
+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();
+  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, sessionId, windowId, paneOwnerId, paneCurrentCommand, paneStartCommand };
+}
+
+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}`;
-  await new Promise<void>((resolve) => {
-    const { result: typed } = spawnPlatformCommandSync('tmux', ['send-keys', '-t', paneId, '-l', markedText], { encoding: 'utf-8' });
-    if (typed.error) throw new Error(typed.error.message);
-    if (typed.status !== 0) throw new Error((typed.stderr || typed.stdout || '').trim() || 'tmux send-keys failed');
-    setTimeout(resolve, 100);
-  });
-  await new Promise<void>((resolve) => {
-    const { result: submitA } = spawnPlatformCommandSync('tmux', ['send-keys', '-t', paneId, 'C-m'], { encoding: 'utf-8' });
-    if (submitA.error) throw new Error(submitA.error.message);
-    if (submitA.status !== 0) throw new Error((submitA.stderr || submitA.stdout || '').trim() || 'tmux send-keys C-m failed');
-    setTimeout(resolve, 100);
-  });
-  const { result: submitB } = spawnPlatformCommandSync('tmux', ['send-keys', '-t', paneId, 'C-m'], { encoding: 'utf-8' });
-  if (submitB.error) throw new Error(submitB.error.message);
-  if (submitB.status !== 0) {
-    throw new Error((submitB.stderr || submitB.stdout || '').trim() || 'tmux send-keys C-m failed');
-  }
+  const sendKeys = (args: string[], failure: string): void => {
+    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 || 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);
+  sendKeys(['send-keys', '-t', binding.paneId, 'C-m'], 'tmux send-keys C-m failed');
+  await sleep(100);
+  sendKeys(['send-keys', '-t', binding.paneId, 'C-m'], 'tmux send-keys C-m failed');
 }
 
 async function readRalphSteerTimestamp(): Promise<string> {
@@ -1074,89 +1119,7 @@ async function writePidFileRecord(): Promise<void> {
   await writeFile(pidFilePath, JSON.stringify(nextRecord, null, 2)).catch(() => {});
 }
 
-async function buildWatcherManagedPayload(): Promise<Record<string, string> | null> {
-  const session = await readSessionState(cwd).catch(() => null);
-  const sessionId = safeString(session?.session_id).trim();
-  if (!sessionId || !session || isSessionStale(session)) return null;
-  return { session_id: sessionId };
-}
-
-async function persistReboundRalphPaneState(
-  statePath: string,
-  state: Record<string, unknown> | null,
-  paneId: string,
-  nowIso: string,
-): Promise<Record<string, unknown>> {
-  const latestState = await readFile(statePath, 'utf-8')
-    .then((content) => JSON.parse(content) as Record<string, unknown>)
-    .catch(() => null);
-  const nextState = {
-    ...((latestState && typeof latestState === 'object') ? latestState : (state || {})),
-    tmux_pane_id: paneId,
-    tmux_pane_set_at: nowIso,
-  };
-  const tmpPath = `${statePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
-  await writeFile(tmpPath, JSON.stringify(nextState, null, 2));
-  try {
-    await rename(tmpPath, statePath);
-  } catch (error) {
-    await unlink(tmpPath).catch(() => {});
-    throw error;
-  }
-  return nextState;
-}
 
-async function resolveRalphContinuePaneTarget(
-  activeRalph: ActiveModeResult,
-  nowIso: string,
-): Promise<{ paneId: string; state: Record<string, unknown> | null; reboundFrom: string }> {
-  const currentState = activeRalph.state && typeof activeRalph.state === 'object'
-    ? activeRalph.state as Record<string, unknown>
-    : null;
-  const anchorPaneId = safeString(currentState?.tmux_pane_id).trim();
-  if (!anchorPaneId) {
-    return {
-      paneId: '',
-      state: currentState,
-      reboundFrom: '',
-    };
-  }
-
-  const managedPayload = await buildWatcherManagedPayload();
-  if (!managedPayload) {
-    return {
-      paneId: anchorPaneId,
-      state: currentState,
-      reboundFrom: '',
-    };
-  }
-
-  let resolvedPaneId = await resolveManagedPaneFromAnchor(anchorPaneId, cwd, managedPayload, { allowTeamWorker: false });
-  if (!resolvedPaneId) {
-    resolvedPaneId = await resolveManagedSessionPane(cwd, managedPayload);
-  }
-  if (!resolvedPaneId) {
-    return {
-      paneId: '',
-      state: currentState,
-      reboundFrom: '',
-    };
-  }
-  if (resolvedPaneId === anchorPaneId) {
-    return {
-      paneId: resolvedPaneId,
-      state: currentState,
-      reboundFrom: '',
-    };
-  }
-
-  const updatedState = await persistReboundRalphPaneState(activeRalph.path, currentState, resolvedPaneId, nowIso);
-  return {
-    paneId: resolvedPaneId,
-    state: updatedState,
-    reboundFrom: anchorPaneId,
-  };
-}
 
 async function runRalphContinueSteerTick(): Promise<void> {
   const now = Date.now();
@@ -1173,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,
@@ -1217,24 +1181,16 @@ async function runRalphContinueSteerTick(): Promise<void> {
       return { sent: false, skipped: true };
     }
 
-    const resolvedPane = await resolveRalphContinuePaneTarget(activeRalph, nowIso);
-    activeRalph.state = resolvedPane.state;
-    const paneId = resolvedPane.paneId;
-    if (!paneId) {
-      lastRalphContinueSteer.last_reason = 'pane_missing';
+    const binding = parseRalphContinuePaneBinding(activeRalph.state);
+    if (!binding) {
+      lastRalphContinueSteer.last_reason = 'pane_binding_missing';
       lastRalphContinueSteer.pane_id = '';
       return { sent: false, skipped: true };
     }
-
-    const paneGuard = await checkPaneReadyForTeamSendKeys(paneId);
-    lastRalphContinueSteer.pane_id = paneId;
-    lastRalphContinueSteer.pane_current_command = paneGuard.paneCurrentCommand || '';
-    if (!paneGuard.ok) {
-      lastRalphContinueSteer.last_reason = paneGuard.reason || 'pane_guard_blocked';
-      return { sent: false, skipped: true };
-    }
-
-    await emitRalphContinueSteer(paneId, RALPH_CONTINUE_TEXT);
+    lastRalphContinueSteer.pane_id = binding.paneId;
+    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;
     lastRalphContinueSteer.shared_last_sent_at = nowIso;
@@ -1243,8 +1199,7 @@ async function runRalphContinueSteerTick(): Promise<void> {
     await eventLog({
       type: 'ralph_continue_steer',
       reason: 'sent',
-      pane_id: paneId,
-      rebound_from: resolvedPane.reboundFrom || null,
+      pane_id: binding.paneId,
       state_path: activeRalph.path,
       current_phase: safeString(activeRalph.state?.current_phase) || null,
       cadence_ms: RALPH_CONTINUE_CADENCE_MS,
@@ -1887,6 +1842,20 @@ async function runLeaderNudgeTick(): Promise<boolean> {
     return false;
   }
 
+  const activeTeam = await resolveActiveTeamState();
+  if (!activeTeam.active) {
+    leaderNudgeRuns += 1;
+    lastLeaderNudge = {
+      enabled: true,
+      leader_only: true,
+      stale_threshold_ms: staleThresholdMs,
+      precomputed_leader_stale: false,
+      last_tick_at: startedIso,
+      last_error: `inactive_team:${activeTeam.reason}`,
+    };
+    return false;
+  }
+
   try {
     const preComputedLeaderStale = await isLeaderStale(stateDir, staleThresholdMs, Date.now());
     await maybeNudgeTeamLeader({