oh-my-codex 0.18.13 → 0.18.15

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

@@ -3,7 +3,7 @@
  * Team leader nudge: remind the leader to check teammate/mailbox state.
  */
 
-import { readFile, writeFile, mkdir, appendFile, readdir } from 'fs/promises';
+import { readFile, writeFile, mkdir, appendFile, readdir, rename, unlink } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { readUsableSessionState } from '../../hooks/session.js';
@@ -21,13 +21,13 @@ import {
 import { DEFAULT_MARKER, paneHasActiveTask } from '../tmux-hook-engine.js';
 import { isLeaderRuntimeStale } from '../../team/leader-activity.js';
 import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
-import { writeTeamLeaderAttention } from '../../team/state.js';
 import { readLatestTeamProgressEvidenceMs } from '../../team/progress-evidence.js';
 import { validateSessionId } from '../../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../../team/contracts.js';
 import { isDeepInterviewStateActive } from './auto-nudge.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';
 const LEADER_PANE_SAME_CLASSIFIED_STATE_SUPPRESSED_REASON = 'pane_already_shows_same_classified_state';
 const LEADER_NOTIFICATION_DEFERRED_TYPE = 'leader_notification_deferred';
 const ACK_WITHOUT_START_EVIDENCE_REASON = 'ack_without_start_evidence';
@@ -37,6 +37,109 @@ const ACK_LIKE_PATTERNS = [
   /^(?:on it|will do|i(?:'|')ll do it|working on it)[.!]*$/i,
 ];
 
+let atomicJsonWriteCounter = 0;
+
+// Synchronous test-only callbacks let regression tests emulate filesystem races
+// without shipping env-gated destructive fault injection in the notify hook.
+const leaderNudgeTestHooks = {
+  beforeLeaderAttentionRename: null,
+  afterLeaderAttentionRename: null,
+  beforeGlobalNudgeStateRename: null,
+  afterGlobalNudgeStateRename: null,
+};
+
+export function setLeaderNudgeTestHooksForTests(hooks = {}) {
+  leaderNudgeTestHooks.beforeLeaderAttentionRename = typeof hooks.beforeLeaderAttentionRename === 'function'
+    ? hooks.beforeLeaderAttentionRename
+    : null;
+  leaderNudgeTestHooks.afterLeaderAttentionRename = typeof hooks.afterLeaderAttentionRename === 'function'
+    ? hooks.afterLeaderAttentionRename
+    : null;
+  leaderNudgeTestHooks.beforeGlobalNudgeStateRename = typeof hooks.beforeGlobalNudgeStateRename === 'function'
+    ? hooks.beforeGlobalNudgeStateRename
+    : null;
+  leaderNudgeTestHooks.afterGlobalNudgeStateRename = typeof hooks.afterGlobalNudgeStateRename === 'function'
+    ? hooks.afterGlobalNudgeStateRename
+    : null;
+}
+
+async function atomicWriteJsonNoParentCreate(path, value, { beforeRename = null, afterRename = null } = {}) {
+  const tempPath = `${path}.${process.pid}.${Date.now()}.${++atomicJsonWriteCounter}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(value, null, 2));
+    if (beforeRename) await beforeRename(tempPath);
+    await rename(tempPath, path);
+    if (afterRename) await afterRename(path);
+  } catch (error) {
+    await unlink(tempPath).catch(() => {});
+    throw error;
+  }
+}
+
+function cloneLeaderNudgeState(state) {
+  return {
+    ...(state && typeof state === 'object' ? state : {}),
+    last_nudged_by_team: { ...(state?.last_nudged_by_team || {}) },
+    last_idle_nudged_by_team: { ...(state?.last_idle_nudged_by_team || {}) },
+    progress_by_team: { ...(state?.progress_by_team || {}) },
+  };
+}
+
+function removeTeamFromLeaderNudgeState(state, teamName) {
+  if (state?.progress_by_team && typeof state.progress_by_team === 'object') {
+    delete state.progress_by_team[teamName];
+  }
+  if (state?.last_nudged_by_team && typeof state.last_nudged_by_team === 'object') {
+    delete state.last_nudged_by_team[teamName];
+  }
+  if (state?.last_idle_nudged_by_team && typeof state.last_idle_nudged_by_team === 'object') {
+    delete state.last_idle_nudged_by_team[teamName];
+  }
+}
+
+async function teamStateAllowsLeaderNudge(stateDir, teamName) {
+  const teamDir = join(stateDir, 'team', teamName);
+  if (!existsSync(teamDir)) return false;
+  if (existsSync(join(teamDir, 'shutdown.json'))) return false;
+
+  const phase = await readJsonIfExists(join(teamDir, 'phase.json'), null);
+  const currentPhase = safeString(phase?.current_phase || phase?.phase || '').trim();
+  if (currentPhase && isTerminalPhase(currentPhase)) return false;
+
+  return true;
+}
+
+async function recordSuppressedLeaderNudge({
+  logsDir,
+  source,
+  teamName,
+  reason,
+  orchestrationIntent = null,
+}) {
+  const nowIso = new Date().toISOString();
+  await logTmuxHookEvent(logsDir, {
+    timestamp: nowIso,
+    type: 'team_leader_nudge_suppressed',
+    team: teamName,
+    worker: 'leader-fixed',
+    to_worker: 'leader-fixed',
+    reason,
+    orchestration_intent: orchestrationIntent,
+    tmux_injection_attempted: false,
+    source_type: 'leader_nudge',
+  }).catch(() => {});
+  await appendTeamDeliveryLog(logsDir, {
+    event: 'nudge_triggered',
+    source,
+    team: teamName,
+    to_worker: 'leader-fixed',
+    transport: 'none',
+    result: 'suppressed',
+    reason,
+    orchestration_intent: orchestrationIntent,
+  }).catch(() => {});
+}
+
 function normalizeValidSessionId(value) {
   const trimmed = safeString(value).trim();
   if (!trimmed) return '';
@@ -613,6 +716,15 @@ export async function maybeNudgeTeamLeader({
   const leaderStale = typeof preComputedLeaderStale === 'boolean' ? preComputedLeaderStale : false;
 
   for (const teamName of candidateTeamNames) {
+    if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+      await recordSuppressedLeaderNudge({
+        logsDir,
+        source,
+        teamName,
+        reason: TEAM_SHUTDOWN_NO_INJECTION_REASON,
+      });
+      continue;
+    }
     let tmuxSession = '';
     let leaderPaneId = '';
     let ownerSessionId = '';
@@ -773,60 +885,167 @@ export async function maybeNudgeTeamLeader({
     }
 
     const unreadLeaderMessageCount = messages.filter((message) => !safeString(message?.delivered_at).trim()).length;
-    nudgeState.progress_by_team[teamName] = {
-      signature: progressSnapshot.signature,
-      last_progress_at: effectiveProgressAtIso,
-      observed_at: nowIso,
-      missing_signal_workers: progressSnapshot.missingSignalWorkers,
-      work_remaining: progressSnapshot.workRemaining,
-      leader_action_state: leaderActionState,
-      leader_attention_pending: !!nudgeReason,
-      leader_attention_reason: nudgeReason || null,
-      leader_stale: leaderStale,
-      all_workers_idle: allWorkersIdle,
-      pending_task_count:
-        (progressSnapshot.taskCounts.pending || 0)
-        + (progressSnapshot.taskCounts.blocked || 0)
-        + (progressSnapshot.taskCounts.in_progress || 0),
-      unread_leader_message_count: unreadLeaderMessageCount,
-      stalled_for_ms: null,
-      source: source === 'notify_fallback_watcher' ? 'notify_hook' : source,
+    const recordShutdownSuppression = async (orchestrationIntent = null) => {
+      await recordSuppressedLeaderNudge({
+        logsDir,
+        source,
+        teamName,
+        reason: TEAM_SHUTDOWN_NO_INJECTION_REASON,
+        orchestrationIntent,
+      });
+    };
+    const cleanupTeamPersistence = async () => {
+      await unlink(join(stateDir, 'team', teamName, 'leader-attention.json')).catch(() => {});
+      const latestState = await readJsonIfExists(nudgeStatePath, nudgeState);
+      const cleanedState = cloneLeaderNudgeState(latestState);
+      removeTeamFromLeaderNudgeState(cleanedState, teamName);
+      nudgeState = cleanedState;
+      await atomicWriteJsonNoParentCreate(nudgeStatePath, cleanedState).catch(() => {});
     };
-    await writeTeamLeaderAttention(teamName, {
-      team_name: teamName,
-      updated_at: nowIso,
-      source: 'notify_hook',
-      leader_decision_state: leaderActionState,
-      leader_attention_pending: !!nudgeReason,
-      leader_attention_reason: nudgeReason || null,
-      attention_reasons: nudgeReason ? [nudgeReason] : [],
-      leader_stale: leaderStale,
-      leader_session_active: true,
-      leader_session_id: currentSessionId || ownerSessionId || null,
-      leader_session_stopped_at: null,
-      unread_leader_message_count: unreadLeaderMessageCount,
-      work_remaining: progressSnapshot.workRemaining,
-      stalled_for_ms: null,
-    }, cwd).catch(() => {});
-
-    if (!nudgeReason) continue;
-    const orchestrationIntent = resolveLeaderNudgeIntent({ nudgeReason, leaderActionState });
-    const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
-    const markedText = `${capped} ${DEFAULT_MARKER}`;
 
-    if (!tmuxTarget) {
-      nudgeState.last_nudged_by_team[teamName] = {
-        at: nowIso,
-        last_message_id: newestId || prevMsgId || '',
-        reason: nudgeReason,
-        orchestration_intent: orchestrationIntent,
+    const persistLeaderNudgeBookkeeping = async ({ orchestrationIntent = null, recordLastNudged = false } = {}) => {
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression(orchestrationIntent);
+        return false;
+      }
+
+      const leaderAttention = {
+        team_name: teamName,
+        updated_at: nowIso,
+        source: 'notify_hook',
+        leader_decision_state: leaderActionState,
+        leader_attention_pending: !!nudgeReason,
+        leader_attention_reason: nudgeReason || null,
+        attention_reasons: nudgeReason ? [nudgeReason] : [],
+        leader_stale: leaderStale,
+        leader_session_active: true,
+        leader_session_id: currentSessionId || ownerSessionId || null,
+        leader_session_stopped_at: null,
+        unread_leader_message_count: unreadLeaderMessageCount,
+        work_remaining: progressSnapshot.workRemaining,
+        stalled_for_ms: null,
+      };
+
+      const leaderAttentionPath = join(stateDir, 'team', teamName, 'leader-attention.json');
+      try {
+        await atomicWriteJsonNoParentCreate(leaderAttentionPath, leaderAttention, {
+          beforeRename: async (tempPath) => {
+            if (leaderNudgeTestHooks.beforeLeaderAttentionRename) {
+              await leaderNudgeTestHooks.beforeLeaderAttentionRename({ stateDir, teamName, tempPath });
+            }
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+              throw new Error('team_state_gone_or_shutdown_before_leader_attention_rename');
+            }
+          },
+          afterRename: async () => {
+            if (leaderNudgeTestHooks.afterLeaderAttentionRename) {
+              await leaderNudgeTestHooks.afterLeaderAttentionRename({ stateDir, teamName, path: leaderAttentionPath });
+            }
+          },
+        });
+      } catch {
+        await unlink(leaderAttentionPath).catch(() => {});
+        await recordShutdownSuppression(orchestrationIntent);
+        return false;
+      }
+
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await cleanupTeamPersistence();
+        await recordShutdownSuppression(orchestrationIntent);
+        return false;
+      }
+
+      const nextNudgeState = cloneLeaderNudgeState(nudgeState);
+      nextNudgeState.progress_by_team[teamName] = {
+        signature: progressSnapshot.signature,
+        last_progress_at: effectiveProgressAtIso,
+        observed_at: nowIso,
+        missing_signal_workers: progressSnapshot.missingSignalWorkers,
+        work_remaining: progressSnapshot.workRemaining,
+        leader_action_state: leaderActionState,
+        leader_attention_pending: !!nudgeReason,
+        leader_attention_reason: nudgeReason || null,
+        leader_stale: leaderStale,
+        all_workers_idle: allWorkersIdle,
+        pending_task_count:
+          (progressSnapshot.taskCounts.pending || 0)
+          + (progressSnapshot.taskCounts.blocked || 0)
+          + (progressSnapshot.taskCounts.in_progress || 0),
+        unread_leader_message_count: unreadLeaderMessageCount,
+        stalled_for_ms: null,
+        source: source === 'notify_fallback_watcher' ? 'notify_hook' : source,
       };
-      if (shouldSendAllIdleNudge) {
-        nudgeState.last_idle_nudged_by_team[teamName] = {
+      if (recordLastNudged) {
+        nextNudgeState.last_nudged_by_team[teamName] = {
           at: nowIso,
-          worker_count: workerNames.length,
+          last_message_id: newestId || prevMsgId || '',
+          reason: nudgeReason,
           orchestration_intent: orchestrationIntent,
         };
+        if (shouldSendAllIdleNudge) {
+          nextNudgeState.last_idle_nudged_by_team[teamName] = {
+            at: nowIso,
+            worker_count: workerNames.length,
+            orchestration_intent: orchestrationIntent,
+          };
+        }
+      }
+
+      try {
+        await atomicWriteJsonNoParentCreate(nudgeStatePath, nextNudgeState, {
+          beforeRename: async (tempPath) => {
+            if (leaderNudgeTestHooks.beforeGlobalNudgeStateRename) {
+              await leaderNudgeTestHooks.beforeGlobalNudgeStateRename({ stateDir, teamName, tempPath });
+            }
+            if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+              throw new Error('team_state_gone_or_shutdown_before_nudge_state_rename');
+            }
+          },
+          afterRename: async () => {
+            if (leaderNudgeTestHooks.afterGlobalNudgeStateRename) {
+              await leaderNudgeTestHooks.afterGlobalNudgeStateRename({ stateDir, teamName, path: nudgeStatePath });
+            }
+          },
+        });
+      } catch {
+        await cleanupTeamPersistence();
+        await recordShutdownSuppression(orchestrationIntent);
+        return false;
+      }
+
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await cleanupTeamPersistence();
+        await recordShutdownSuppression(orchestrationIntent);
+        return false;
+      }
+
+      nudgeState = nextNudgeState;
+      return true;
+    };
+
+    if (!nudgeReason) {
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression();
+        continue;
+      }
+      await persistLeaderNudgeBookkeeping();
+      continue;
+    }
+    const orchestrationIntent = resolveLeaderNudgeIntent({ nudgeReason, leaderActionState });
+    if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+      await recordShutdownSuppression(orchestrationIntent);
+      continue;
+    }
+    const capped = text.length > 180 ? `${text.slice(0, 177)}...` : text;
+    const markedText = `${capped} ${DEFAULT_MARKER}`;
+
+    if (!tmuxTarget) {
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression(orchestrationIntent);
+        continue;
+      }
+      if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+        continue;
       }
       await emitLeaderNudgeDeferredEvent(cwd, teamName, LEADER_PANE_MISSING_NO_INJECTION_REASON, orchestrationIntent, nowIso, {
         tmuxSession,
@@ -873,18 +1092,12 @@ export async function maybeNudgeTeamLeader({
       const deferredReason = paneGuard.reason === 'pane_running_shell'
         ? LEADER_PANE_SHELL_NO_INJECTION_REASON
         : paneGuard.reason;
-      nudgeState.last_nudged_by_team[teamName] = {
-        at: nowIso,
-        last_message_id: newestId || prevMsgId || '',
-        reason: nudgeReason,
-        orchestration_intent: orchestrationIntent,
-      };
-      if (shouldSendAllIdleNudge) {
-        nudgeState.last_idle_nudged_by_team[teamName] = {
-          at: nowIso,
-          worker_count: workerNames.length,
-          orchestration_intent: orchestrationIntent,
-        };
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression(orchestrationIntent);
+        continue;
+      }
+      if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+        continue;
       }
       await emitLeaderNudgeDeferredEvent(cwd, teamName, deferredReason, orchestrationIntent, nowIso, {
         tmuxSession,
@@ -925,20 +1138,13 @@ export async function maybeNudgeTeamLeader({
     }
 
     if (paneAlreadyShowsVisibleLeaderState(paneGuard.paneCapture, capped)) {
-      nudgeState.last_nudged_by_team[teamName] = {
-        at: nowIso,
-        last_message_id: newestId || prevMsgId || '',
-        reason: nudgeReason,
-        orchestration_intent: orchestrationIntent,
-      };
-      if (shouldSendAllIdleNudge) {
-        nudgeState.last_idle_nudged_by_team[teamName] = {
-          at: nowIso,
-          worker_count: workerNames.length,
-          orchestration_intent: orchestrationIntent,
-        };
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression(orchestrationIntent);
+        continue;
+      }
+      if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+        continue;
       }
-
       await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
 
       try {
@@ -973,6 +1179,11 @@ export async function maybeNudgeTeamLeader({
       continue;
     }
 
+    if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+      await recordShutdownSuppression(orchestrationIntent);
+      continue;
+    }
+
     try {
       const leaderHasActiveTask = paneHasActiveTask(paneGuard.paneCapture);
       let deliveryMode = 'sent';
@@ -996,22 +1207,16 @@ export async function maybeNudgeTeamLeader({
           throw new Error(sendResult.error || sendResult.reason);
         }
       }
-      nudgeState.last_nudged_by_team[teamName] = {
-        at: nowIso,
-        last_message_id: newestId || prevMsgId || '',
-        reason: nudgeReason,
-        orchestration_intent: orchestrationIntent,
-      };
-      if (shouldSendAllIdleNudge) {
-        nudgeState.last_idle_nudged_by_team[teamName] = {
-          at: nowIso,
-          worker_count: workerNames.length,
-          orchestration_intent: orchestrationIntent,
-        };
+      if (await teamStateAllowsLeaderNudge(stateDir, teamName)) {
+        if (!(await persistLeaderNudgeBookkeeping({ orchestrationIntent, recordLastNudged: true }))) {
+          continue;
+        }
+        await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
+      } else {
+        await recordShutdownSuppression(orchestrationIntent);
+        continue;
       }
 
-      await emitTeamNudgeEvent(cwd, teamName, nudgeReason, orchestrationIntent, nowIso);
-
       try {
         await logTmuxHookEvent(logsDir, {
           timestamp: nowIso,
@@ -1039,6 +1244,10 @@ export async function maybeNudgeTeamLeader({
         orchestration_intent: orchestrationIntent,
       }).catch(() => {});
     } catch (err) {
+      if (!(await teamStateAllowsLeaderNudge(stateDir, teamName))) {
+        await recordShutdownSuppression(orchestrationIntent);
+        continue;
+      }
       try {
         await logTmuxHookEvent(logsDir, {
           timestamp: nowIso,
@@ -1063,6 +1272,4 @@ export async function maybeNudgeTeamLeader({
       }).catch(() => {});
     }
   }
-
-  await writeFile(nudgeStatePath, JSON.stringify(nudgeState, null, 2)).catch(() => {});
 }

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

@@ -11,6 +11,28 @@ import {
 } from '../tmux-hook-engine.js';
 
 export const PANE_READINESS_UNVERIFIED_REASON = 'pane_readiness_unverified';
+let nextTmuxBufferId = 0;
+
+function buildSafePasteArgv(target: string, prompt: string): {
+  bufferName: string;
+  setBufferArgv: string[];
+  showBufferArgv: string[];
+  clearComposerArgv: string[];
+  pasteBufferArgv: string[];
+  deleteBufferArgv: string[];
+} {
+  nextTmuxBufferId += 1;
+  const bufferName = `omx-pane-input-${process.pid}-${Date.now()}-${nextTmuxBufferId}`;
+  return {
+    bufferName,
+    setBufferArgv: ['set-buffer', '-b', bufferName, '--', prompt],
+    showBufferArgv: ['show-buffer', '-b', bufferName],
+    clearComposerArgv: ['send-keys', '-t', target, 'C-u'],
+    pasteBufferArgv: ['paste-buffer', '-t', target, '-b', bufferName, '-p', '-d'],
+    deleteBufferArgv: ['delete-buffer', '-b', bufferName],
+  };
+}
+
 
 export function mapPaneInjectionReadinessReason(reason: any): any {
   return reason === 'pane_running_shell' ? 'agent_not_running' : reason;
@@ -145,24 +167,82 @@ export async function sendPaneInput({
     ? Math.max(0, Math.floor(submitKeyPresses))
     : 2;
   const literalPrompt = safeString(prompt);
-  const argv = normalizedSubmitKeyPresses === 0
-    ? {
-      typeArgv: ['send-keys', '-t', target, '-l', literalPrompt],
-      submitArgv: [] as string[][],
-    }
+  const submitArgv = normalizedSubmitKeyPresses === 0
+    ? [] as string[][]
     : buildSendKeysArgv({
       paneTarget: target,
       prompt: literalPrompt,
       dryRun: false,
       submitKeyPresses: normalizedSubmitKeyPresses,
-    });
-  if (!argv) {
+    })?.submitArgv;
+  if (!submitArgv) {
     return { ok: false, sent: false, reason: 'send_failed', paneTarget: target };
   }
+  const pasteArgv = buildSafePasteArgv(target, literalPrompt);
+  const argv = {
+    typeArgv: pasteArgv.pasteBufferArgv,
+    submitArgv,
+    bufferName: pasteArgv.bufferName,
+    setBufferArgv: pasteArgv.setBufferArgv,
+    showBufferArgv: pasteArgv.showBufferArgv,
+    clearComposerArgv: pasteArgv.clearComposerArgv,
+    pasteBufferArgv: pasteArgv.pasteBufferArgv,
+    deleteBufferArgv: pasteArgv.deleteBufferArgv,
+  };
 
+  let bufferSet = false;
   try {
     if (typePrompt) {
-      await runProcess('tmux', argv.typeArgv, 3000);
+      try {
+        await runProcess('tmux', pasteArgv.setBufferArgv, 3000);
+        bufferSet = true;
+      } catch (error) {
+        return {
+          ok: false,
+          sent: false,
+          reason: 'buffer_set_failed',
+          paneTarget: target,
+          argv,
+          error: error instanceof Error ? error.message : safeString(error),
+        };
+      }
+      let verifiedBuffer;
+      try {
+        verifiedBuffer = await runProcess('tmux', pasteArgv.showBufferArgv, 3000);
+      } catch (error) {
+        return {
+          ok: false,
+          sent: false,
+          reason: 'buffer_show_failed',
+          paneTarget: target,
+          argv,
+          error: error instanceof Error ? error.message : safeString(error),
+        };
+      }
+      if (verifiedBuffer.stdout !== literalPrompt) {
+        return {
+          ok: false,
+          sent: false,
+          reason: 'buffer_verify_failed',
+          paneTarget: target,
+          argv,
+          expectedBytes: literalPrompt.length,
+          actualBytes: verifiedBuffer.stdout.length,
+        };
+      }
+      try {
+        await runProcess('tmux', pasteArgv.clearComposerArgv, 3000);
+        await runProcess('tmux', pasteArgv.pasteBufferArgv, 3000);
+      } catch (error) {
+        return {
+          ok: false,
+          sent: false,
+          reason: 'buffer_paste_failed',
+          paneTarget: target,
+          argv,
+          error: error instanceof Error ? error.message : safeString(error),
+        };
+      }
     }
     if (queueFirstSubmit && argv.submitArgv.length > 0) {
       await runProcess('tmux', ['send-keys', '-t', target, 'Tab'], 3000);
@@ -186,6 +266,10 @@ export async function sendPaneInput({
       argv,
       error: error instanceof Error ? error.message : safeString(error),
     };
+  } finally {
+    if (bufferSet) {
+      await runProcess('tmux', pasteArgv.deleteBufferArgv, 3000).catch(() => {});
+    }
   }
 }
 

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

@@ -71,7 +71,7 @@ async function finalizeResolvedPane(paneId: string, reason: string, expectedCwd:
 
 async function resolveCanonicalPaneFromPaneTarget(paneTarget: any, expectedCwd: any): Promise<any> {
   const paneResult = await runProcess('tmux', ['display-message', '-p', '-t', paneTarget, '#{pane_id}']);
-  const paneId = safeString(paneResult.stdout).trim();
+  const paneId = safeString(paneResult.stdout).trim() || (safeString(paneTarget).trim().match(/^%\d+$/) ? safeString(paneTarget).trim() : '');
   if (!paneId) return { paneTarget: null, reason: 'target_not_found' };
 
   let startCommand = '';