@scotthuang/agent-knock-knock 0.2.47 → 0.2.49

package/dist/src/cli.js

@@ -7,29 +7,40 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { createCodexTerminalAgentAdapter, detectCodexDurableCompletion } from "./codex-terminal-agent-adapter.js";
 import { createClaudeTerminalAgentAdapter } from "./claude-terminal-agent-adapter.js";
+import { captureClaudeTranscriptAnchor, defaultClaudeHome, detectClaudeTranscriptCompletion } from "./claude-local-transcript-provider.js";
 import { ClaudeHookStore, ClaudeHookStoreError, defaultClaudeHookStoreDir } from "./claude-hook-store.js";
 import { claudePermissionHookOutput } from "./claude-hook-protocol.js";
-import { defaultClaudeSettingsPath, installClaudeHooks, loadTrustedClaudeTokenjuiceLaunchers } from "./claude-hook-installer.js";
+import { defaultClaudeSettingsPath, loadTrustedClaudeTokenjuiceLaunchers } from "./claude-hook-installer.js";
 import { CodexLocalSessionProvider } from "./codex-local-session-provider.js";
 import { CodexStoreAdapter } from "./codex-store-adapter.js";
 import { applyMessageToConversation, budgetAction, createConversation, createMessage, executorForConversation, extractStructuredMessage, parseMessageJson, resolveExecutor } from "./protocol.js";
 import { EXECUTOR_KINDS, acpxCommandForExecutor, executorDefinitionForKind, modelEnvForExecutor, normalizeModelForExecutor, proxyEnvForExecutor } from "./executors.js";
 import { executorBootstrapPrompt } from "./bootstrap.js";
-import { writeRuntimeLog } from "./runtime-log.js";
+import { redactString, writeRuntimeLog } from "./runtime-log.js";
 import { formatTranscript, readNdjsonLog } from "./transcript.js";
-import { appendEvent, defaultStoreDir, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, statePathForConversationId } from "./store.js";
+import { appendEvent, defaultStoreDir, ensureDir, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, statePathForConversationId } from "./store.js";
 import { planFork, planTakeover } from "./session-takeover-planner.js";
-import { StaticTerminalControlProvider, TmuxTerminalControlProvider } from "./terminal-control-provider.js";
+import { StaticTerminalControlProvider, TmuxTerminalControlProvider, terminalPaneContainsProcess } from "./terminal-control-provider.js";
 import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { createProductionTerminalAgentRegistry } from "./terminal-agent-registry.js";
 import { StaticTerminalProcessSource, SystemTerminalProcessSource } from "./terminal-process-source.js";
 import { TerminalAgentBridge } from "./terminal-agent-bridge.js";
+import { evaluateApprovalPolicy } from "./approval-policy.js";
+import { evaluateDoctorCapabilities } from "./doctor-capabilities.js";
 const DEFAULT_IDLE_TIMEOUT_MINUTES = 10080;
 const DEFAULT_AGENT_TIMEOUT_MINUTES = 60;
 const DEFAULT_AGENT_HARD_TIMEOUT_MINUTES = 720;
 const DEFAULT_MONITOR_POLL_INTERVAL_MS = 5000;
+const CLAUDE_SCREEN_APPROVAL_TTL_MS = 10 * 60 * 1000;
+const CALLBACK_DELIVERY_TIMEOUT_MS = 30_000;
 const CALLBACK_RETRY_DELAYS_MS = [5000, 15000, 60000, 60000];
-const DEFAULT_CODEX_ACPX_AGENT_COMMAND = "npx -y @agentclientprotocol/codex-acp@^1.1.0";
+const TERMINAL_BRIDGE_MONITOR_LOCK_VERSION = 1;
+const MINIMUM_NODE_VERSION = "22.14.0";
+const PRIVATE_LOCK_FILE_MODE = 0o600;
+const NO_FOLLOW_FLAG = typeof fs.constants.O_NOFOLLOW === "number"
+    ? fs.constants.O_NOFOLLOW
+    : 0;
+const DEFAULT_CODEX_ACPX_AGENT_COMMAND = "npx -y @agentclientprotocol/codex-acp@1.1.7";
 const CONVERSATION_STATUSES = new Set([
     "created",
     "running",
@@ -102,7 +113,13 @@ catch (error) {
     process.exit(1);
 }
 async function runCommand(commandName, options) {
-    if (commandName === "new") {
+    if (commandName === "help" || commandName === "--help" || commandName === "-h") {
+        usage();
+    }
+    else if (commandName === "version" || commandName === "--version" || commandName === "-v") {
+        printVersion();
+    }
+    else if (commandName === "new") {
         runNew(options);
     }
     else if (commandName === "record") {
@@ -135,11 +152,14 @@ async function runCommand(commandName, options) {
     else if (commandName === "renew") {
         await runRenew(options);
     }
+    else if (commandName === "reconcile-monitors") {
+        await runReconcileMonitors(options);
+    }
     else if (commandName === "recover") {
         runRecover(options);
     }
     else if (commandName === "close") {
-        runClose(options);
+        await runClose(options);
     }
     else if (commandName === "transcript") {
         runTranscript(options);
@@ -148,7 +168,7 @@ async function runCommand(commandName, options) {
         runInstallOpenClaw(options);
     }
     else if (commandName === "install-claude-hooks") {
-        runInstallClaudeHooks(options);
+        throw new Error("install-claude-hooks is no longer supported; Claude tmux control now works without modifying Claude Code settings");
     }
     else if (commandName === "claude-hook") {
         await runClaudeHook(options);
@@ -223,34 +243,6 @@ function runInstallOpenClaw(options) {
             : "Agent Knock Knock is installed. Try: AKK list"
     });
 }
-function runInstallClaudeHooks(options) {
-    const configuredExecutable = stringValue(options.executablePath ?? options.binPath);
-    let executablePath;
-    if (configuredExecutable) {
-        executablePath = path.resolve(expandHome(configuredExecutable));
-    }
-    else {
-        try {
-            executablePath = resolveExecutable("agent-knock-knock");
-        }
-        catch {
-            executablePath = path.resolve(process.argv[1]);
-        }
-    }
-    const result = installClaudeHooks({
-        executablePath,
-        settingsPath: expandHome(options.settingsPath ?? options.settings),
-        dryRun: options.dryRun === true
-    });
-    printJson({
-        installed: result.written || !result.changed,
-        ...result,
-        executablePath,
-        next: result.dryRun
-            ? "Run again without --dry-run to install the Claude Code hooks."
-            : "Claude Code hooks are configured. Existing sessions pick them up through settings reload; start a new session if needed."
-    });
-}
 async function runClaudeHook(options) {
     const rawInput = fs.readFileSync(0, "utf8");
     let input;
@@ -329,8 +321,18 @@ function installOpenClawPlugin(openclawBin, root) {
     return { mode: "replaced" };
 }
 function runDoctor(options) {
-    const commands = ["node", "openclaw", "acpx", "codex", "claude", "cursor"];
-    const checks = commands.map((commandName) => executableCheck(commandName));
+    const commands = ["node", "openclaw", "tmux", "acpx", "codex", "claude", "cursor"];
+    const checks = commands.map((commandName) => {
+        const check = executableCheck(commandName);
+        return commandName === "node"
+            ? {
+                ...check,
+                version: process.versions.node,
+                version_supported: versionAtLeast(process.versions.node, MINIMUM_NODE_VERSION),
+                minimum_version: MINIMUM_NODE_VERSION
+            }
+            : check;
+    });
     const root = packageRootDir();
     const packageFiles = [
         "dist/src/cli.js",
@@ -344,24 +346,44 @@ function runDoctor(options) {
             exists: fs.existsSync(filePath)
         };
     });
-    const requiredOk = checks
-        .filter((check) => ["node", "openclaw", "acpx"].includes(check.command))
-        .every((check) => check.available);
-    const agentOk = checks
-        .filter((check) => ["codex", "claude", "cursor"].includes(check.command))
-        .some((check) => check.available);
+    const capabilities = evaluateDoctorCapabilities(checks);
     const filesOk = packageFiles.every((check) => check.exists);
+    const ok = capabilities.coreOk && filesOk && capabilities.transportOk;
     printJson({
-        ok: requiredOk && agentOk && filesOk,
+        ok,
         package_root: root,
         checks,
         package_files: packageFiles,
+        capabilities: {
+            tmux: capabilities.tmux,
+            acp: capabilities.acp
+        },
         notes: [
-            "node, openclaw, and acpx are required.",
-            "At least one local coding agent command should be available: codex, claude, or cursor."
+            `Node.js ${MINIMUM_NODE_VERSION}+ and OpenClaw are required.`,
+            "Choose tmux (recommended), ACPX/ACP, or install both.",
+            "tmux supports Codex and Claude Code; ACPX supports Codex, Claude Code, and Cursor.",
+            "Claude tmux completion is hook-free and fails closed unless the local transcript schema is verified."
         ],
         options
     });
+    if (!ok) {
+        process.exitCode = 1;
+    }
+}
+function versionAtLeast(version, minimum) {
+    const parsed = version.split(".").slice(0, 3).map((part) => Number.parseInt(part, 10));
+    const required = minimum.split(".").slice(0, 3).map((part) => Number.parseInt(part, 10));
+    if (parsed.length !== 3 ||
+        required.length !== 3 ||
+        [...parsed, ...required].some((part) => !Number.isInteger(part) || part < 0)) {
+        return false;
+    }
+    for (let index = 0; index < 3; index += 1) {
+        if (parsed[index] !== required[index]) {
+            return parsed[index] > required[index];
+        }
+    }
+    return true;
 }
 async function runAgent(options) {
     const agentCommand = required(options.agentCommand, "agent subcommand is required: takeover");
@@ -505,6 +527,7 @@ async function runAgentTakeover(options) {
                 options,
                 takeoverMatchKind: "terminal_control",
                 terminalControl: target.terminalControl,
+                terminalAgentPid: target.pid,
                 needsBootstrap: false
             });
             return {
@@ -666,7 +689,11 @@ function selectTerminateTarget({ plan, session, activeSessions, expectedPid, all
 }
 async function listActiveSessionsWithTerminalControl(provider, options, terminalProvider = createTerminalControlProvider(options)) {
     const activeSessions = await provider.listActiveSessions();
-    return createTerminalAgentBridge(options, terminalProvider).attachProcesses(provider.agent, activeSessions);
+    const activePids = new Set(activeSessions.map((session) => session.pid));
+    const processTree = activePids.size > 0
+        ? await createTerminalProcessSource(options).listProcessSnapshots((snapshot) => activePids.has(snapshot.pid), { includeCwd: false, includeAncestors: true })
+        : [];
+    return createTerminalAgentBridge(options, terminalProvider).attachProcesses(provider.agent, activeSessions, { processTree });
 }
 function createTerminalControlProvider(options) {
     if (options.terminalsJson || options.terminalScreensJson || options.processesJson) {
@@ -689,6 +716,11 @@ function createClaudeHookStore(options = {}) {
         rootDir: expandHome(configuredRoot ?? defaultClaudeHookStoreDir())
     });
 }
+function createConfiguredClaudeHookStore(options = {}) {
+    return stringValue(options.claudeHookStoreDir)
+        ? createClaudeHookStore(options)
+        : undefined;
+}
 function loadClaudeAgentRows(options = {}) {
     let value;
     if (options.claudeAgentsJson !== undefined) {
@@ -741,6 +773,9 @@ function loadClaudeAgentRows(options = {}) {
                 ...(stringValue(row.cwd) ? { cwd: stringValue(row.cwd) } : {}),
                 ...(stringValue(row.kind) ? { kind: stringValue(row.kind) } : {}),
                 ...(stringValue(row.sessionId) ? { sessionId: stringValue(row.sessionId) } : {}),
+                ...(Number.isSafeInteger(Number(row.startedAt)) && Number(row.startedAt) > 0
+                    ? { startedAt: Number(row.startedAt) }
+                    : {}),
                 ...(stringValue(row.status) ? { status: stringValue(row.status) } : {})
             }];
     });
@@ -781,6 +816,7 @@ function isClaudeProcessCommand(commandText) {
         /[\\/]\.local[\\/]share[\\/]claude[\\/]versions[\\/][^\\/\s]+$/u.test(executable);
 }
 function createRuntimeTerminalAgentRegistry(options) {
+    const claudeHookStore = createConfiguredClaudeHookStore(options);
     return createProductionTerminalAgentRegistry({
         overrides: [
             createCodexTerminalAgentAdapter({
@@ -820,16 +856,51 @@ function createRuntimeTerminalAgentRegistry(options) {
             }),
             createClaudeTerminalAgentAdapter({
                 agentRows: loadClaudeAgentRows(options),
-                hookStore: createClaudeHookStore(options),
-                trustedTokenjuiceLaunchers: loadTrustedClaudeTokenjuiceLaunchers(expandHome(options.claudeSettingsPath ?? defaultClaudeSettingsPath()))
+                async detectDurableCompletion(request) {
+                    return detectClaudeTranscriptCompletion(request, {
+                        claudeHome: expandHome(options.claudeHome),
+                        agentRows: loadClaudeAgentRows(options)
+                    });
+                },
+                ...(claudeHookStore
+                    ? {
+                        hookStore: claudeHookStore,
+                        trustedTokenjuiceLaunchers: loadTrustedClaudeTokenjuiceLaunchers(expandHome(options.claudeSettingsPath ?? defaultClaudeSettingsPath()))
+                    }
+                    : {})
             })
         ]
     });
 }
-function createTerminalAgentBridge(options, terminalProvider = createTerminalControlProvider(options)) {
+function createTerminalAgentBridge(options, terminalProvider = createTerminalControlProvider(options), registry = createRuntimeTerminalAgentRegistry(options)) {
+    const processSource = createTerminalProcessSource(options);
     return new TerminalAgentBridge({
-        registry: createRuntimeTerminalAgentRegistry(options),
-        terminalProvider
+        registry,
+        terminalProvider,
+        async verifyIdentity({ agent, pid, terminalControl }) {
+            const adapter = registry.require(agent);
+            const snapshots = await processSource.listProcessSnapshots(undefined, { includeCwd: false });
+            const snapshot = snapshots.find((candidate) => candidate.pid === pid);
+            if (!snapshot || !adapter.classifyProcess(snapshot)) {
+                throw new Error(`terminal conversation agent ${agent} with pid ${pid} is no longer active`);
+            }
+            const panes = await terminalProvider.listPanes();
+            const pane = panes.find((candidate) => candidate.kind === terminalControl.kind &&
+                candidate.target === terminalControl.target &&
+                candidate.panePid === terminalControl.panePid);
+            if (!pane || !terminalPaneContainsProcess(snapshot, pane, snapshots)) {
+                throw new Error(`terminal conversation agent ${agent} with pid ${pid} no longer belongs to pane ${terminalControl.target}`);
+            }
+            return {
+                terminalControl: {
+                    ...terminalControl,
+                    socketPath: pane.socketPath,
+                    panePid: pane.panePid,
+                    currentCommand: pane.currentCommand,
+                    currentPath: pane.currentPath
+                }
+            };
+        }
     });
 }
 function planTerminalControlTakeover(session, activeSessions) {
@@ -926,6 +997,115 @@ function terminalRuntimeIdentityForConversation(conversation, terminalControl) {
         terminalTarget: terminalControl.target
     };
 }
+async function migrateLegacyTerminalAgentIdentity({ conversation, statePath, logPath, options }) {
+    const nativeTakeover = isRecord(conversation?.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const terminalControl = terminalControlFromTakeover(nativeTakeover);
+    if (!nativeTakeover || !terminalControl) {
+        return conversation;
+    }
+    const runtime = terminalRuntimeIdentityForConversation(conversation, terminalControl);
+    if (Number.isInteger(runtime.pid) && Number(runtime.pid) > 0) {
+        return conversation;
+    }
+    const executor = executorForConversation(conversation);
+    const nativeSessionId = stringValue(nativeTakeover.native_session_id);
+    if (executor.kind !== "codex" ||
+        !nativeSessionId ||
+        parseTerminalConversationId(nativeSessionId)) {
+        return conversation;
+    }
+    let matchedProcess;
+    try {
+        const registry = createRuntimeTerminalAgentRegistry(options);
+        const adapter = registry.require("codex");
+        const snapshots = await createTerminalProcessSource(options).listProcessSnapshots((snapshot) => adapter.classifyProcess(snapshot) !== undefined, { includeAncestors: true });
+        const panes = await createTerminalControlProvider(options).listPanes();
+        const matchingPanes = panes.filter((pane) => pane.kind === terminalControl.kind &&
+            pane.target === terminalControl.target &&
+            pane.panePid === terminalControl.panePid);
+        if (matchingPanes.length !== 1) {
+            return conversation;
+        }
+        const candidates = snapshots.flatMap((snapshot) => {
+            const classified = adapter.classifyProcess(snapshot);
+            return classified ? [{ ...classified, agent: "codex" }] : [];
+        });
+        const matches = candidates.filter((candidate) => candidate.sessionId === nativeSessionId &&
+            terminalPaneContainsProcess(candidate, matchingPanes[0], snapshots));
+        if (matches.length !== 1) {
+            return conversation;
+        }
+        matchedProcess = matches[0];
+    }
+    catch (error) {
+        runtimeLog("warn", "legacy_terminal_agent_identity_migration_failed", {
+            conversation_id: conversation.conversation_id,
+            terminal_target: terminalControl.target,
+            reason: error instanceof Error ? error.message : String(error)
+        });
+        return conversation;
+    }
+    if (!matchedProcess) {
+        return conversation;
+    }
+    const releaseLock = acquireFileLock(`${statePath}.lock`);
+    let migratedConversation = conversation;
+    let migrated = false;
+    try {
+        const current = loadState(statePath);
+        const currentTakeover = isRecord(current.native_session_takeover)
+            ? current.native_session_takeover
+            : undefined;
+        const currentControl = terminalControlFromTakeover(currentTakeover);
+        if (!currentTakeover || !currentControl) {
+            return current;
+        }
+        const currentRuntime = terminalRuntimeIdentityForConversation(current, currentControl);
+        if (Number.isInteger(currentRuntime.pid) && Number(currentRuntime.pid) > 0) {
+            return current;
+        }
+        if (currentTakeover.native_session_id !== nativeSessionId ||
+            currentControl.target !== terminalControl.target ||
+            currentControl.socketPath !== terminalControl.socketPath ||
+            currentControl.panePid !== terminalControl.panePid) {
+            return current;
+        }
+        const migratedAt = new Date().toISOString();
+        migratedConversation = {
+            ...current,
+            native_session_takeover: {
+                ...currentTakeover,
+                terminal_agent_pid: matchedProcess.pid,
+                terminal_agent_session_id: matchedProcess.sessionId,
+                terminal_agent_identity_migrated_at: migratedAt
+            },
+            updated_at: migratedAt
+        };
+        saveState(statePath, migratedConversation);
+        migrated = true;
+    }
+    finally {
+        releaseLock();
+    }
+    if (migrated) {
+        appendEvent(logPath, {
+            ts: new Date().toISOString(),
+            conversation_id: migratedConversation.conversation_id,
+            event: "terminal_agent_identity_migrated",
+            terminal_target: terminalControl.target,
+            terminal_agent_pid: matchedProcess.pid,
+            native_session_id: nativeSessionId
+        });
+        runtimeLog("info", "terminal_agent_identity_migrated", {
+            conversation_id: migratedConversation.conversation_id,
+            terminal_target: terminalControl.target,
+            terminal_agent_pid: matchedProcess.pid
+        });
+    }
+    return migratedConversation;
+}
 function isTerminalControlCapability(value) {
     return typeof value === "string" && [
         "screen_status",
@@ -1029,7 +1209,7 @@ function createForkConversation({ agent, strategy, session, contextPackage, fork
         next: `Use AKK send ${forkedConversation.conversation_id}: <message> to start the forked ${agent} session with the approved summary.`
     };
 }
-function createNativeSessionConversation({ agent, strategy, session, modelInfo, options, takeoverMatchKind = strategy, terminalControl = undefined, needsBootstrap = true }) {
+function createNativeSessionConversation({ agent, strategy, session, modelInfo, options, takeoverMatchKind = strategy, terminalControl = undefined, terminalAgentPid = undefined, needsBootstrap = true }) {
     const workspace = session.cwd;
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(workspace));
     cleanupIdleConversations(storeDir, options);
@@ -1078,6 +1258,7 @@ function createNativeSessionConversation({ agent, strategy, session, modelInfo,
         native_session_takeover: {
             agent,
             native_session_id: session.id,
+            terminal_agent_pid: terminalAgentPid,
             source_cwd: session.cwd,
             source_title: session.title,
             strategy,
@@ -1325,7 +1506,7 @@ function runDelegate(options) {
             throw new Error(cleanProcessText(ensureSession.stderr || ensureSession.stdout || `acpx ${executor.kind} sessions ensure exited with status ${ensureSession.status}`));
         }
         const outputPath = path.join(newResult.paths.conversationDir, `${executor.kind}-output.log`);
-        const outputFd = fs.openSync(outputPath, "a");
+        const outputFd = openPrivateAppendFile(outputPath);
         const child = spawn(acpxPath, acpxArgs, {
             detached: true,
             stdio: ["ignore", outputFd, outputFd],
@@ -1472,12 +1653,12 @@ function startExecutorMonitor({ statePath, logPath, pid, outputPath, agentTimeou
         detached: true,
         stdio: "ignore",
         cwd: process.cwd(),
-        env: process.env
+        env: environmentWithoutGatewayTokens()
     });
     child.unref();
     return child;
 }
-function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, agentHardTimeoutMinutes, pollIntervalMs, codexHome, claudeHookStoreDir }) {
+function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, agentHardTimeoutMinutes, pollIntervalMs, codexHome, claudeHome, claudeHookStoreDir }) {
     const args = [
         new URL(import.meta.url).pathname,
         "monitor",
@@ -1496,6 +1677,9 @@ function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, a
     if (codexHome) {
         args.push("--codex-home", codexHome);
     }
+    if (claudeHome) {
+        args.push("--claude-home", claudeHome);
+    }
     if (claudeHookStoreDir) {
         args.push("--claude-hook-store-dir", claudeHookStoreDir);
     }
@@ -1503,7 +1687,7 @@ function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, a
         detached: true,
         stdio: "ignore",
         cwd: process.cwd(),
-        env: process.env
+        env: environmentWithoutGatewayTokens()
     });
     child.unref();
     return child;
@@ -1526,6 +1710,7 @@ function startTerminalBridgeMonitorForConversation({ conversation, statePath, lo
             DEFAULT_AGENT_HARD_TIMEOUT_MINUTES),
         pollIntervalMs: Number(options.monitorPollIntervalMs ?? DEFAULT_MONITOR_POLL_INTERVAL_MS),
         codexHome: options.codexHome,
+        claudeHome: options.claudeHome ?? nativeTakeover?.["claude_home"],
         claudeHookStoreDir: options.claudeHookStoreDir ?? nativeTakeover?.["claude_hook_store_dir"]
     });
 }
@@ -1535,7 +1720,7 @@ function terminalBridgeEnabled(conversation) {
         : undefined;
     return nativeTakeover?.["terminal_bridge"] === true;
 }
-function withTerminalBridgeState({ conversation, message, startedAt, agentTimeoutMinutes, agentHardTimeoutMinutes, preSendScreenFingerprint }) {
+function withTerminalBridgeState({ conversation, message, requestText, startedAt, agentTimeoutMinutes, agentHardTimeoutMinutes, preSendScreenFingerprint, claudeTranscriptAnchor, claudeHome }) {
     const nativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : {};
@@ -1546,10 +1731,14 @@ function withTerminalBridgeState({ conversation, message, startedAt, agentTimeou
             terminal_bridge: true,
             terminal_bridge_started_at: startedAt,
             terminal_bridge_message_id: message.id,
-            terminal_bridge_request_text: String(message.body ?? ""),
-            terminal_bridge_request_hash: terminalBridgeRequestFingerprint(message.body),
+            terminal_bridge_request_text: requestText,
+            terminal_bridge_request_hash: terminalBridgeRequestFingerprint(requestText),
             terminal_bridge_pre_send_screen_fingerprint: preSendScreenFingerprint,
+            claude_transcript_anchor: claudeTranscriptAnchor,
+            claude_home: claudeHome,
             terminal_bridge_completion_claim: undefined,
+            terminal_bridge_approval_dispatch: undefined,
+            terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
             terminal_bridge_monitor_started_at: startedAt,
             terminal_bridge_last_activity_at: startedAt,
             terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
@@ -1561,6 +1750,9 @@ function withTerminalBridgeState({ conversation, message, startedAt, agentTimeou
     };
 }
 function activateClaudeHookLease({ options, conversation, message, terminalControl, expiresAt }) {
+    if (!stringValue(options.claudeHookStoreDir)) {
+        return undefined;
+    }
     const runtime = terminalRuntimeIdentityForConversation(conversation, terminalControl);
     const pid = runtime.pid;
     const agentRow = pid === undefined
@@ -1667,7 +1859,9 @@ function renewClaudeHookLease(conversation, expiresAt) {
     const nativeTakeover = isRecord(conversation?.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
-    if (nativeTakeover?.agent !== "claude") {
+    if (nativeTakeover?.agent !== "claude" ||
+        nativeTakeover.claude_hook_mode !== "enabled" ||
+        !stringValue(nativeTakeover.claude_hook_store_dir)) {
         return undefined;
     }
     const conversationId = stringValue(conversation.conversation_id);
@@ -1773,16 +1967,23 @@ function modelForExecutor(executor, options = {}) {
     return normalizeModelForExecutor(executor, modelEnvForExecutor(executor, process.env));
 }
 function environmentForExecutor(executor, options = {}) {
+    const environment = environmentWithoutGatewayTokens();
     const proxy = proxyForExecutor(executor, options);
     if (!proxy) {
-        return process.env;
+        return environment;
     }
     return {
-        ...process.env,
+        ...environment,
         ALL_PROXY: proxy,
         all_proxy: proxy
     };
 }
+function environmentWithoutGatewayTokens() {
+    const environment = { ...process.env };
+    delete environment.AKK_GATEWAY_TOKEN;
+    delete environment.OPENCLAW_GATEWAY_TOKEN;
+    return environment;
+}
 async function runList(options) {
     const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(process.cwd()));
     const cleanup = cleanupIdleConversations(storeDir, options);
@@ -1855,7 +2056,7 @@ async function buildNativeListGroups({ options, agentFilter, statusFilter }) {
         };
     }
     const terminalProvider = createTerminalControlProvider(options);
-    const bridge = new TerminalAgentBridge({ registry, terminalProvider });
+    const bridge = createTerminalAgentBridge(options, terminalProvider, registry);
     const terminalScan = options.terminalDebug ? await terminalControlDiagnostics(terminalProvider) : undefined;
     const terminalControlled = [];
     const native = [];
@@ -1863,7 +2064,7 @@ async function buildNativeListGroups({ options, agentFilter, statusFilter }) {
     const errors = [];
     try {
         const processSource = createTerminalProcessSource(options);
-        const snapshots = await processSource.listProcessSnapshots((snapshot) => adapters.some((adapter) => adapter.capabilities.processDiscovery && adapter.classifyProcess(snapshot) !== undefined));
+        const snapshots = await processSource.listProcessSnapshots((snapshot) => adapters.some((adapter) => adapter.capabilities.processDiscovery && adapter.classifyProcess(snapshot) !== undefined), { includeAncestors: true });
         const activeSessions = await bridge.listProcesses(snapshots, adapters.map((adapter) => adapter.agent));
         activeCount = activeSessions.length;
         const rootSessions = rootActiveProcesses(activeSessions);
@@ -2030,7 +2231,7 @@ function rootActiveProcesses(processes) {
     const seenTerminalTargets = new Set();
     return roots.filter((process) => {
         const terminalTarget = process.terminalControl?.target
-            ? `${process.agent}:${process.terminalControl.target}`
+            ? `${process.agent}:${process.terminalControl.target}:${process.terminalControl.panePid}`
             : undefined;
         if (!terminalTarget) {
             return true;
@@ -2075,6 +2276,7 @@ async function runStatus(options) {
         const terminalStatus = await terminalStatusForControl(terminalConversation.agent, terminalConversation.terminalControl, options, {
             pid: terminalConversation.pid,
             cwd: terminalConversation.terminalControl.currentPath,
+            conversationId: terminalConversation.conversationId,
             terminalTarget: terminalConversation.terminalControl.target
         });
         printJson({
@@ -2091,7 +2293,12 @@ async function runStatus(options) {
         });
         return;
     }
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const conversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
     const events = readExistingEvents(logPath);
     const result = {
         conversation,
@@ -2129,6 +2336,7 @@ async function runDescribe(options) {
         const terminalStatus = await terminalStatusForControl(terminalConversation.agent, terminalConversation.terminalControl, options, {
             pid: terminalConversation.pid,
             cwd: terminalConversation.terminalControl.currentPath,
+            conversationId: terminalConversation.conversationId,
             terminalTarget: terminalConversation.terminalControl.target
         });
         if (terminalConversation.agent !== "codex") {
@@ -2172,7 +2380,12 @@ async function runDescribe(options) {
         }));
         return;
     }
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const conversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
     const events = readExistingEvents(logPath);
     const terminalControl = terminalControlFromTakeover(isRecord(conversation.native_session_takeover) ? conversation.native_session_takeover : undefined);
     const terminalStatus = terminalControl
@@ -2291,21 +2504,49 @@ function terminalBridgeApprovalInstructions({ conversation, terminalControl, ter
         "Do not use raw tmux, shell, or manual key presses for this approval. Do not approve without explicit user confirmation."
     ].filter((line) => line !== undefined).join("\n");
 }
-function recordTerminalBridgeApprovalNotification({ statePath, logPath, terminalControl, terminalStatus, fingerprint }) {
+function recordTerminalBridgeApprovalNotification({ statePath, logPath, terminalControl, terminalStatus, fingerprint, expectedConversation, onRecorded }) {
     const releaseLock = acquireFileLock(`${statePath}.lock`);
     try {
         const conversation = loadState(statePath);
+        const currentNativeTakeover = isRecord(conversation.native_session_takeover)
+            ? conversation.native_session_takeover
+            : undefined;
+        const currentTerminalControl = terminalControlFromTakeover(currentNativeTakeover);
+        if (!isWaitingForAgent(conversation.status) ||
+            conversation.conversation_id !== expectedConversation.conversationId ||
+            conversation.status !== expectedConversation.status ||
+            conversation.updated_at !== expectedConversation.updatedAt ||
+            currentNativeTakeover?.terminal_bridge !== true ||
+            stringValue(currentNativeTakeover.terminal_bridge_message_id) !==
+                expectedConversation.messageId ||
+            !currentTerminalControl ||
+            currentTerminalControl.kind !== terminalControl.kind ||
+            currentTerminalControl.target !== terminalControl.target ||
+            currentTerminalControl.socketPath !== terminalControl.socketPath ||
+            currentTerminalControl.panePid !== terminalControl.panePid) {
+            return {
+                conversation,
+                duplicate: false,
+                stale: true,
+                recorded: undefined
+            };
+        }
         const nativeTakeover = isRecord(conversation.native_session_takeover)
             ? { ...conversation.native_session_takeover }
             : {};
         const previousApproval = isRecord(nativeTakeover.terminal_bridge_approval)
             ? nativeTakeover.terminal_bridge_approval
             : undefined;
-        if (previousApproval?.fingerprint === fingerprint && previousApproval?.notified_at) {
+        const previousNotifiedAt = validTimestampMs(previousApproval?.notified_at);
+        if (previousApproval?.fingerprint === fingerprint &&
+            previousNotifiedAt !== undefined &&
+            Date.now() - previousNotifiedAt <= CLAUDE_SCREEN_APPROVAL_TTL_MS) {
             return {
                 conversation,
                 duplicate: true,
-                previousApproval
+                stale: false,
+                previousApproval,
+                recorded: undefined
             };
         }
         const now = new Date().toISOString();
@@ -2332,54 +2573,34 @@ function recordTerminalBridgeApprovalNotification({ statePath, logPath, terminal
         });
         return {
             conversation: nextConversation,
-            duplicate: false
+            duplicate: false,
+            stale: false,
+            recorded: onRecorded?.(nextConversation)
         };
     }
     finally {
         releaseLock();
     }
 }
-async function runSend(options) {
-    const messageBody = required(options.message ?? options.request, "--message is required");
-    if (options.agentHardTimeoutMinutes !== undefined) {
-        positiveMinutes(options.agentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
-    }
-    cleanupIdleConversations(storeDirFromOptions(options), options);
-    const terminalConversation = await resolveTerminalConversationFromOptions(options);
-    if (terminalConversation) {
-        if (options.background) {
-            const managed = createManagedTerminalConversationFromRawId({
+function prepareManagedSend({ options, statePath, logPath, messageBody, stateLockHeld = false, persist = true, rejectTerminalControl = false }) {
+    if (!stateLockHeld) {
+        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            return prepareManagedSend({
                 options,
-                conversationId: terminalConversation.conversationId,
-                agent: terminalConversation.agent,
-                pid: terminalConversation.pid,
+                statePath,
+                logPath,
                 messageBody,
-                terminalControl: terminalConversation.terminalControl
-            });
-            await runTerminalControlSend({
-                options,
-                conversation: managed.conversation,
-                nextConversation: managed.nextConversation,
-                statePath: managed.statePath,
-                logPath: managed.logPath,
-                executor: managed.executor,
-                message: managed.message,
-                terminalControl: terminalConversation.terminalControl,
-                needsNativeTakeoverBootstrap: true
+                stateLockHeld: true,
+                persist,
+                rejectTerminalControl
             });
-            return;
         }
-        await runTerminalConversationSend({
-            options,
-            conversationId: terminalConversation.conversationId,
-            agent: terminalConversation.agent,
-            pid: terminalConversation.pid,
-            messageBody,
-            terminalControl: terminalConversation.terminalControl
-        });
-        return;
+        finally {
+            releaseLock();
+        }
     }
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const conversation = loadState(statePath);
     if (["done", "failed", "closed", "cancelled"].includes(conversation.status)) {
         throw new Error(`cannot send to ${conversation.conversation_id}; conversation is ${conversation.status}`);
     }
@@ -2390,10 +2611,15 @@ async function runSend(options) {
         throw new Error(`cannot send to ${conversation.conversation_id}; choose a supported model with --model first`);
     }
     const executor = executorForConversation(conversation);
-    const type = options.type ?? (conversation.status === "waiting_for_openclaw" ? "answer" : "task");
+    const type = options.type ??
+        (conversation.status === "waiting_for_openclaw" ? "answer" : "task");
     const nativeTakeoverForSend = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
+    if (rejectTerminalControl &&
+        terminalControlFromTakeover(nativeTakeoverForSend)) {
+        throw new Error("terminal control changed while waiting to send; refresh status and retry");
+    }
     const forkTakeoverForSend = isRecord(conversation.fork_context_takeover)
         ? conversation.fork_context_takeover
         : undefined;
@@ -2416,7 +2642,9 @@ async function runSend(options) {
     const nextConversation = {
         ...applyMessageToConversation(conversation, message),
         executor,
-        claude_session: executor.kind === "claude" ? executor.session : conversation.claude_session,
+        claude_session: executor.kind === "claude"
+            ? executor.session
+            : conversation.claude_session,
         executor_model: options.model ?? conversation.executor_model,
         model_selection: conversation.status === "needs_model_selection"
             ? {
@@ -2426,17 +2654,152 @@ async function runSend(options) {
             }
             : conversation.model_selection
     };
-    saveState(statePath, nextConversation);
-    appendEvent(logPath, messageEvent(message));
-    runtimeLog("info", "message_created", {
-        conversation_id: conversation.conversation_id,
-        agent: executor.kind,
-        executor_session: executor.session,
-        message_type: type,
-        state_path: statePath,
-        event_log_path: logPath,
-        message: textSummary(messageBody)
+    if (persist) {
+        saveState(statePath, nextConversation);
+        appendEvent(logPath, messageEvent(message));
+        runtimeLog("info", "message_created", {
+            conversation_id: conversation.conversation_id,
+            agent: executor.kind,
+            executor_session: executor.session,
+            message_type: type,
+            state_path: statePath,
+            event_log_path: logPath,
+            message: textSummary(messageBody)
+        });
+    }
+    return {
+        conversation,
+        executor,
+        nativeTakeoverForSend,
+        forkTakeoverForSend,
+        needsNativeTakeoverBootstrap,
+        needsForkTakeoverBootstrap,
+        message,
+        nextConversation
+    };
+}
+async function runSend(options) {
+    const messageBody = required(options.message ?? options.request, "--message is required");
+    if (options.agentHardTimeoutMinutes !== undefined) {
+        positiveMinutes(options.agentHardTimeoutMinutes, "--agent-hard-timeout-minutes");
+    }
+    cleanupIdleConversations(storeDirFromOptions(options), options);
+    const terminalConversation = await resolveTerminalConversationFromOptions(options);
+    if (terminalConversation) {
+        if (options.background) {
+            const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalConversation.terminalControl), { timeoutMs: 30000 });
+            let releaseStateLock;
+            try {
+                const managed = createManagedTerminalConversationFromRawId({
+                    options,
+                    conversationId: terminalConversation.conversationId,
+                    agent: terminalConversation.agent,
+                    pid: terminalConversation.pid,
+                    messageBody,
+                    terminalControl: terminalConversation.terminalControl
+                });
+                ensureDir(path.dirname(managed.statePath));
+                releaseStateLock = acquireFileLock(`${managed.statePath}.lock`);
+                await runTerminalControlSend({
+                    options,
+                    conversation: managed.conversation,
+                    nextConversation: managed.nextConversation,
+                    statePath: managed.statePath,
+                    logPath: managed.logPath,
+                    executor: managed.executor,
+                    message: managed.message,
+                    terminalControl: terminalConversation.terminalControl,
+                    needsNativeTakeoverBootstrap: true,
+                    terminalSendLockHeld: true,
+                    terminalStateLockHeld: true,
+                    recordMessageAfterSend: true,
+                    recordRawAttachmentAfterSend: true
+                });
+            }
+            finally {
+                try {
+                    releaseStateLock?.();
+                }
+                finally {
+                    releaseTerminalLock();
+                }
+            }
+            return;
+        }
+        await runTerminalConversationSend({
+            options,
+            conversationId: terminalConversation.conversationId,
+            agent: terminalConversation.agent,
+            pid: terminalConversation.pid,
+            messageBody,
+            terminalControl: terminalConversation.terminalControl
+        });
+        return;
+    }
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const migratedConversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
+    const migratedTakeover = isRecord(migratedConversation.native_session_takeover)
+        ? migratedConversation.native_session_takeover
+        : undefined;
+    const migratedTerminalControl = terminalControlFromTakeover(migratedTakeover);
+    if (migratedTerminalControl) {
+        const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), migratedTerminalControl), { timeoutMs: 30000 });
+        let releaseStateLock;
+        try {
+            releaseStateLock = acquireFileLock(`${statePath}.lock`);
+            const prepared = prepareManagedSend({
+                options,
+                statePath,
+                logPath,
+                messageBody,
+                stateLockHeld: true,
+                persist: false
+            });
+            const currentTerminalControl = terminalControlFromTakeover(prepared.nativeTakeoverForSend);
+            if (!currentTerminalControl ||
+                currentTerminalControl.kind !== migratedTerminalControl.kind ||
+                currentTerminalControl.target !== migratedTerminalControl.target ||
+                currentTerminalControl.socketPath !== migratedTerminalControl.socketPath ||
+                currentTerminalControl.panePid !== migratedTerminalControl.panePid) {
+                throw new Error("terminal control changed while waiting to send; refresh status and retry");
+            }
+            await runTerminalControlSend({
+                options,
+                conversation: prepared.conversation,
+                nextConversation: prepared.nextConversation,
+                statePath,
+                logPath,
+                executor: prepared.executor,
+                message: prepared.message,
+                terminalControl: currentTerminalControl,
+                needsNativeTakeoverBootstrap: prepared.needsNativeTakeoverBootstrap,
+                terminalSendLockHeld: true,
+                terminalStateLockHeld: true,
+                recordMessageAfterSend: true
+            });
+        }
+        finally {
+            try {
+                releaseStateLock?.();
+            }
+            finally {
+                releaseTerminalLock();
+            }
+        }
+        return;
+    }
+    const prepared = prepareManagedSend({
+        options,
+        statePath,
+        logPath,
+        messageBody,
+        rejectTerminalControl: true
     });
+    const { conversation, executor, nativeTakeoverForSend, forkTakeoverForSend, needsNativeTakeoverBootstrap, needsForkTakeoverBootstrap, message, nextConversation } = prepared;
     const executorEnv = environmentForExecutor(executor, {
         allProxy: options.allProxy ?? conversation.executor_all_proxy
     });
@@ -2566,7 +2929,7 @@ async function runSend(options) {
     const acpxArgs = buildAcpxPromptArgs({ executor, payload, model: executorModel });
     if (options.background) {
         const outputPath = path.join(path.dirname(logPath), `${executor.kind}-followup-output.log`);
-        const outputFd = fs.openSync(outputPath, "a");
+        const outputFd = openPrivateAppendFile(outputPath);
         const child = spawn(acpxPath, acpxArgs, {
             detached: true,
             stdio: ["ignore", outputFd, outputFd],
@@ -2743,7 +3106,12 @@ async function runApprove(options) {
         });
         return;
     }
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const conversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
     const nativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
@@ -2751,263 +3119,529 @@ async function runApprove(options) {
     if (!terminalControl) {
         throw new Error(`conversation ${conversation.conversation_id} is not controlled through a terminal`);
     }
+    if (["done", "failed", "closed", "cancelled"].includes(conversation.status)) {
+        throw new Error(`cannot approve ${conversation.conversation_id}; conversation is ${conversation.status}`);
+    }
     const executor = executorForConversation(conversation);
     const monitoredApproval = isRecord(nativeTakeover?.["terminal_bridge_approval"])
         ? nativeTakeover.terminal_bridge_approval
         : undefined;
-    const expectedFingerprint = stringValue(options.expectedApprovalFingerprint) ??
+    const suppliedExpectedFingerprint = stringValue(options.expectedApprovalFingerprint);
+    const expectedFingerprint = suppliedExpectedFingerprint ??
         stringValue(monitoredApproval?.fingerprint);
+    const hooklessClaudeScreenApproval = executor.kind === "claude" &&
+        nativeTakeover?.claude_hook_mode !== "enabled";
+    if (hooklessClaudeScreenApproval) {
+        const monitoredState = isRecord(monitoredApproval?.approval_state)
+            ? monitoredApproval.approval_state
+            : undefined;
+        const pendingDispatch = isRecord(nativeTakeover?.terminal_bridge_approval_dispatch)
+            ? nativeTakeover.terminal_bridge_approval_dispatch
+            : undefined;
+        const notifiedAt = validTimestampMs(monitoredApproval?.notified_at);
+        if (conversation.status !== "waiting_for_openclaw" ||
+            monitoredState?.decision_mode !== "keys" ||
+            !stringValue(monitoredApproval?.fingerprint)) {
+            printJson({
+                conversation,
+                approved: false,
+                blocked: true,
+                reason: "Claude screen approval requires a current managed-turn approval notification",
+                terminal_control: terminalControl
+            });
+            return;
+        }
+        if (notifiedAt === undefined ||
+            Date.now() - notifiedAt > CLAUDE_SCREEN_APPROVAL_TTL_MS) {
+            printJson({
+                conversation,
+                approved: false,
+                blocked: true,
+                reason: "Claude screen approval expired; inspect and resolve the terminal manually",
+                terminal_control: terminalControl
+            });
+            return;
+        }
+        if (!suppliedExpectedFingerprint ||
+            expectedFingerprint !== monitoredApproval?.fingerprint) {
+            printJson({
+                conversation,
+                approved: false,
+                blocked: true,
+                reason: "Claude screen approval requires the latest notified fingerprint",
+                terminal_control: terminalControl
+            });
+            return;
+        }
+        if (pendingDispatch?.state === "reserved" &&
+            pendingDispatch.terminal_bridge_message_id ===
+                nativeTakeover?.terminal_bridge_message_id) {
+            printJson({
+                conversation,
+                approved: false,
+                blocked: true,
+                reason: "a previous Claude approval dispatch has an uncertain outcome; inspect and resolve the terminal manually",
+                terminal_control: terminalControl
+            });
+            return;
+        }
+        if (expectedFingerprint ===
+            stringValue(nativeTakeover?.terminal_bridge_last_approval_fingerprint)) {
+            printJson({
+                conversation,
+                approved: false,
+                blocked: true,
+                reason: "Claude screen approval fingerprint was already consumed",
+                terminal_control: terminalControl
+            });
+            return;
+        }
+    }
     const autoApproved = options.autoApproved === true;
     const policyRuleId = stringValue(options.policyRuleId);
     const policyFingerprint = stringValue(options.policyFingerprint);
-    const approval = await createTerminalAgentBridge(options).approve(executor.kind, terminalControl, {
-        expectedFingerprint,
-        scrollbackLines: Number(options.scrollbackLines ?? 120),
-        runtime: terminalRuntimeIdentityForConversation(conversation, terminalControl),
-        requiredDecisionMode: autoApproved && executor.kind === "claude"
-            ? "structured"
-            : undefined
-    });
-    const actualFingerprint = approval.fingerprint;
-    if (!approval.approved) {
-        if (autoApproved) {
-            appendEvent(logPath, {
-                ts: new Date().toISOString(),
-                conversation_id: conversation.conversation_id,
-                event: "terminal_auto_approval_decision",
-                action: "rejected",
-                reason: approval.reason,
-                terminal_control: terminalControl,
-                expected_fingerprint: expectedFingerprint,
-                actual_fingerprint: actualFingerprint,
-                policy_rule_id: policyRuleId,
-                policy_fingerprint: policyFingerprint
-            });
-        }
-        printJson({
-            conversation,
-            approved: false,
-            blocked: approval.blocked,
-            reason: approval.reason,
-            terminal_control: terminalControl,
-            expected_approval_fingerprint: expectedFingerprint,
-            actual_approval_fingerprint: actualFingerprint,
-            screen_excerpt: approval.screenExcerpt
-        });
-        return;
-    }
-    appendEvent(logPath, {
-        ts: new Date().toISOString(),
-        conversation_id: conversation.conversation_id,
-        event: "terminal_approval_send",
-        terminal_control: terminalControl,
-        key: approval.key,
-        keys: approval.keys,
-        label: approval.label,
-        decision_mode: approval.decisionMode,
-        request_id: approval.requestId,
-        approval_fingerprint: actualFingerprint,
-        auto_approved: autoApproved,
-        policy_rule_id: policyRuleId,
-        policy_fingerprint: policyFingerprint
-    });
-    if (autoApproved) {
-        appendEvent(logPath, {
-            ts: new Date().toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "terminal_auto_approval_decision",
-            action: "approved",
-            terminal_control: terminalControl,
-            approval_fingerprint: actualFingerprint,
-            policy_rule_id: policyRuleId,
-            policy_fingerprint: policyFingerprint
-        });
-    }
-    runtimeLog("info", "terminal_approval_send", {
-        conversation_id: conversation.conversation_id,
-        terminal_target: terminalControl.target,
-        key: approval.key,
-        keys: approval.keys,
-        label: approval.label,
-        decision_mode: approval.decisionMode,
-        request_id: approval.requestId,
-        approval_fingerprint: actualFingerprint,
-        auto_approved: autoApproved,
-        policy_rule_id: policyRuleId,
-        policy_fingerprint: policyFingerprint
-    });
-    const nativeTakeoverForUpdate = isRecord(conversation.native_session_takeover)
-        ? { ...conversation.native_session_takeover }
-        : {};
-    const approvalResolvedAt = new Date().toISOString();
-    const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ??
-        nativeTakeoverForUpdate.terminal_bridge_inactivity_timeout_minutes ??
-        DEFAULT_AGENT_TIMEOUT_MINUTES);
-    const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ??
-        nativeTakeoverForUpdate.terminal_bridge_hard_timeout_minutes ??
-        DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
-    const nextNativeTakeover = {
-        ...nativeTakeoverForUpdate,
-        terminal_bridge_approval: undefined,
-        terminal_bridge_approval_resolved_at: approvalResolvedAt,
-        terminal_bridge_monitor_started_at: approvalResolvedAt,
-        terminal_bridge_last_activity_at: approvalResolvedAt,
-        terminal_bridge_last_activity_reason: "approval resolved",
-        terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
-        terminal_bridge_hard_timeout_minutes: agentHardTimeoutMinutes,
-        terminal_bridge_inactivity_deadline_at: deadlineAt(approvalResolvedAt, agentTimeoutMinutes),
-        terminal_bridge_hard_deadline_at: deadlineAt(stringValue(nativeTakeoverForUpdate.terminal_bridge_started_at) ?? approvalResolvedAt, agentHardTimeoutMinutes)
+    const autoApprovalPolicy = autoApproved
+        ? parseJsonOption(options.autoApprovalPolicyJson, "--auto-approval-policy-json")
+        : undefined;
+    const runtimeIdentity = terminalRuntimeIdentityForConversation(conversation, terminalControl);
+    let executorPolicyDecision;
+    const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+    let terminalLockReleased = false;
+    const releaseApprovalTerminalLock = () => {
+        if (!terminalLockReleased) {
+            terminalLockReleased = true;
+            releaseTerminalLock();
+        }
     };
-    delete nextNativeTakeover.terminal_bridge_approval;
-    let nextConversation = {
-        ...conversation,
-        status: terminalBridgeEnabled(conversation) ? "waiting_for_agent" : conversation.status,
-        native_session_takeover: nextNativeTakeover,
-        updated_at: approvalResolvedAt
+    let releaseStateLock;
+    const releaseApprovalStateLock = () => {
+        if (releaseStateLock) {
+            const release = releaseStateLock;
+            releaseStateLock = undefined;
+            release();
+        }
     };
-    const approvalLeaseDeadlines = [
-        stringValue(nextNativeTakeover.terminal_bridge_inactivity_deadline_at),
-        stringValue(nextNativeTakeover.terminal_bridge_hard_deadline_at)
-    ].filter((value) => Boolean(value));
-    if (approvalLeaseDeadlines.length > 0) {
-        const renewedLease = renewClaudeHookLease(nextConversation, new Date(Math.min(...approvalLeaseDeadlines.map((value) => Date.parse(value)))).toISOString());
-        if (renewedLease) {
-            nextConversation = {
-                ...nextConversation,
-                native_session_takeover: {
-                    ...nextNativeTakeover,
-                    claude_hook_lease_id: renewedLease.id
+    try {
+        let approval;
+        let lockedConversation = conversation;
+        const currentConversation = loadState(statePath);
+        const currentTakeover = isRecord(currentConversation.native_session_takeover)
+            ? currentConversation.native_session_takeover
+            : undefined;
+        const currentControl = terminalControlFromTakeover(currentTakeover);
+        const currentApproval = isRecord(currentTakeover?.terminal_bridge_approval)
+            ? currentTakeover.terminal_bridge_approval
+            : undefined;
+        if (currentConversation.status !== conversation.status ||
+            currentTakeover?.terminal_bridge_message_id !== nativeTakeover?.terminal_bridge_message_id ||
+            currentControl?.target !== terminalControl.target ||
+            currentControl?.socketPath !== terminalControl.socketPath ||
+            (hooklessClaudeScreenApproval &&
+                currentApproval?.fingerprint !== monitoredApproval?.fingerprint)) {
+            throw new Error("approval state changed while waiting for terminal control; refresh status and retry");
+        }
+        lockedConversation = currentConversation;
+        approval = await createTerminalAgentBridge(options).approve(executor.kind, terminalControl, {
+            expectedFingerprint,
+            scrollbackLines: Number(options.scrollbackLines ?? 120),
+            runtime: runtimeIdentity,
+            requiredDecisionMode: autoApproved && executor.kind === "claude"
+                ? "structured"
+                : undefined,
+            authorize: autoApproved
+                ? ({ agent, terminalControl: currentTerminalControl, inspection, fingerprint }) => {
+                    if (!autoApprovalPolicy) {
+                        return {
+                            approved: false,
+                            reason: "automatic approval requires an executor-side policy"
+                        };
+                    }
+                    const candidate = {
+                        agent,
+                        kind: inspection.approval.promptKind ?? "unknown",
+                        decisionMode: inspection.approval.approvable
+                            ? inspection.approval.action.mode ?? "keys"
+                            : undefined,
+                        command: inspection.approval.command,
+                        cwd: inspection.approval.cwd ?? currentTerminalControl.currentPath,
+                        fingerprint: fingerprint ?? "",
+                        terminalTarget: currentTerminalControl.target
+                    };
+                    executorPolicyDecision = evaluateApprovalPolicy({
+                        policy: autoApprovalPolicy,
+                        candidate
+                    });
+                    if (executorPolicyDecision.action !== "approve") {
+                        return {
+                            approved: false,
+                            reason: `executor-side auto-approval policy rejected the current request: ${executorPolicyDecision.reason}`
+                        };
+                    }
+                    if (policyRuleId && executorPolicyDecision.ruleId !== policyRuleId) {
+                        return {
+                            approved: false,
+                            reason: "executor-side auto-approval rule changed before execution"
+                        };
+                    }
+                    if (policyFingerprint &&
+                        executorPolicyDecision.policyFingerprint !== policyFingerprint) {
+                        return {
+                            approved: false,
+                            reason: "executor-side auto-approval policy changed before execution"
+                        };
+                    }
+                    return { approved: true };
                 }
-            };
+                : undefined,
+            beforeKeyDispatch: hooklessClaudeScreenApproval
+                ? ({ fingerprint, terminalControl: dispatchControl, keys }) => {
+                    if (releaseStateLock) {
+                        throw new Error("Claude approval dispatch was already reserved");
+                    }
+                    releaseStateLock = acquireFileLock(`${statePath}.lock`);
+                    const latestConversation = loadState(statePath);
+                    const latestTakeover = isRecord(latestConversation.native_session_takeover)
+                        ? latestConversation.native_session_takeover
+                        : undefined;
+                    const latestControl = terminalControlFromTakeover(latestTakeover);
+                    const latestApproval = isRecord(latestTakeover?.terminal_bridge_approval)
+                        ? latestTakeover.terminal_bridge_approval
+                        : undefined;
+                    const latestNotifiedAt = validTimestampMs(latestApproval?.notified_at);
+                    const latestDispatch = isRecord(latestTakeover?.terminal_bridge_approval_dispatch)
+                        ? latestTakeover.terminal_bridge_approval_dispatch
+                        : undefined;
+                    if (!latestTakeover ||
+                        latestConversation.status !== "waiting_for_openclaw" ||
+                        latestTakeover.terminal_bridge_message_id !==
+                            nativeTakeover?.terminal_bridge_message_id ||
+                        latestApproval?.fingerprint !== fingerprint ||
+                        latestNotifiedAt === undefined ||
+                        Date.now() - latestNotifiedAt > CLAUDE_SCREEN_APPROVAL_TTL_MS ||
+                        expectedFingerprint !== fingerprint ||
+                        latestControl?.target !== dispatchControl.target ||
+                        latestControl?.socketPath !== dispatchControl.socketPath) {
+                        throw new Error("approval state changed before terminal dispatch; refresh status and retry");
+                    }
+                    if (latestDispatch?.state === "reserved" &&
+                        latestDispatch.terminal_bridge_message_id ===
+                            latestTakeover.terminal_bridge_message_id) {
+                        throw new Error("a previous Claude approval dispatch has an uncertain outcome; inspect and resolve the terminal manually");
+                    }
+                    const reservedAt = new Date().toISOString();
+                    const reservedConversation = {
+                        ...latestConversation,
+                        native_session_takeover: {
+                            ...latestTakeover,
+                            terminal_bridge_approval_dispatch: {
+                                state: "reserved",
+                                attempt_id: randomUUID(),
+                                fingerprint,
+                                keys,
+                                terminal_target: dispatchControl.target,
+                                terminal_bridge_message_id: latestTakeover.terminal_bridge_message_id,
+                                reserved_at: reservedAt
+                            }
+                        },
+                        updated_at: reservedAt
+                    };
+                    saveState(statePath, reservedConversation);
+                    lockedConversation = reservedConversation;
+                }
+                : undefined
+        });
+        const actualFingerprint = approval.fingerprint;
+        const effectivePolicyRuleId = executorPolicyDecision?.ruleId ?? policyRuleId;
+        const effectivePolicyFingerprint = executorPolicyDecision?.policyFingerprint ?? policyFingerprint;
+        if (!approval.approved) {
+            releaseApprovalStateLock();
+            releaseApprovalTerminalLock();
+            if (autoApproved) {
+                appendEvent(logPath, {
+                    ts: new Date().toISOString(),
+                    conversation_id: conversation.conversation_id,
+                    event: "terminal_auto_approval_decision",
+                    action: "rejected",
+                    reason: approval.reason,
+                    terminal_control: terminalControl,
+                    expected_fingerprint: expectedFingerprint,
+                    actual_fingerprint: actualFingerprint,
+                    policy_rule_id: effectivePolicyRuleId,
+                    policy_fingerprint: effectivePolicyFingerprint
+                });
+            }
+            printJson({
+                conversation,
+                approved: false,
+                blocked: approval.blocked,
+                reason: approval.reason,
+                terminal_control: terminalControl,
+                expected_approval_fingerprint: expectedFingerprint,
+                actual_approval_fingerprint: actualFingerprint,
+                screen_excerpt: approval.screenExcerpt
+            });
+            return;
         }
-    }
-    saveState(statePath, nextConversation);
-    const bridgeMonitor = startTerminalBridgeMonitorForConversation({
-        conversation: nextConversation,
-        statePath,
-        logPath,
-        options
-    });
-    if (bridgeMonitor) {
         appendEvent(logPath, {
             ts: new Date().toISOString(),
             conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_monitor_launch",
-            pid: bridgeMonitor.pid ?? null,
+            event: "terminal_approval_send",
             terminal_control: terminalControl,
-            reason: "approval_resolved",
-            agent_timeout_minutes: agentTimeoutMinutes,
-            agent_hard_timeout_minutes: agentHardTimeoutMinutes
+            key: approval.key,
+            keys: approval.keys,
+            label: approval.label,
+            decision_mode: approval.decisionMode,
+            request_id: approval.requestId,
+            approval_fingerprint: actualFingerprint,
+            auto_approved: autoApproved,
+            policy_rule_id: effectivePolicyRuleId,
+            policy_fingerprint: effectivePolicyFingerprint
         });
-        runtimeLog("info", "terminal_bridge_monitor_launch", {
+        if (autoApproved) {
+            appendEvent(logPath, {
+                ts: new Date().toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "terminal_auto_approval_decision",
+                action: "approved",
+                terminal_control: terminalControl,
+                approval_fingerprint: actualFingerprint,
+                policy_rule_id: effectivePolicyRuleId,
+                policy_fingerprint: effectivePolicyFingerprint
+            });
+        }
+        runtimeLog("info", "terminal_approval_send", {
             conversation_id: conversation.conversation_id,
-            monitor_pid: bridgeMonitor.pid ?? null,
             terminal_target: terminalControl.target,
-            reason: "approval_resolved"
+            key: approval.key,
+            keys: approval.keys,
+            label: approval.label,
+            decision_mode: approval.decisionMode,
+            request_id: approval.requestId,
+            approval_fingerprint: actualFingerprint,
+            auto_approved: autoApproved,
+            policy_rule_id: effectivePolicyRuleId,
+            policy_fingerprint: effectivePolicyFingerprint
+        });
+        const nativeTakeoverForUpdate = isRecord(lockedConversation.native_session_takeover)
+            ? { ...lockedConversation.native_session_takeover }
+            : {};
+        const approvalResolvedAt = new Date().toISOString();
+        const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ??
+            nativeTakeoverForUpdate.terminal_bridge_inactivity_timeout_minutes ??
+            DEFAULT_AGENT_TIMEOUT_MINUTES);
+        const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ??
+            nativeTakeoverForUpdate.terminal_bridge_hard_timeout_minutes ??
+            DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
+        const nextNativeTakeover = {
+            ...nativeTakeoverForUpdate,
+            terminal_bridge_approval: undefined,
+            terminal_bridge_approval_dispatch: undefined,
+            terminal_bridge_approval_resolved_at: approvalResolvedAt,
+            terminal_bridge_last_approval_fingerprint: actualFingerprint,
+            terminal_bridge_last_approval_at: approvalResolvedAt,
+            terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
+            terminal_bridge_monitor_started_at: approvalResolvedAt,
+            terminal_bridge_last_activity_at: approvalResolvedAt,
+            terminal_bridge_last_activity_reason: "approval resolved",
+            terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
+            terminal_bridge_hard_timeout_minutes: agentHardTimeoutMinutes,
+            terminal_bridge_inactivity_deadline_at: deadlineAt(approvalResolvedAt, agentTimeoutMinutes),
+            terminal_bridge_hard_deadline_at: deadlineAt(stringValue(nativeTakeoverForUpdate.terminal_bridge_started_at) ?? approvalResolvedAt, agentHardTimeoutMinutes)
+        };
+        delete nextNativeTakeover.terminal_bridge_approval;
+        delete nextNativeTakeover.terminal_bridge_approval_dispatch;
+        let nextConversation = {
+            ...lockedConversation,
+            status: terminalBridgeEnabled(lockedConversation)
+                ? "waiting_for_agent"
+                : lockedConversation.status,
+            native_session_takeover: nextNativeTakeover,
+            updated_at: approvalResolvedAt
+        };
+        const approvalLeaseDeadlines = [
+            stringValue(nextNativeTakeover.terminal_bridge_inactivity_deadline_at),
+            stringValue(nextNativeTakeover.terminal_bridge_hard_deadline_at)
+        ].filter((value) => Boolean(value));
+        if (approvalLeaseDeadlines.length > 0) {
+            const renewedLease = renewClaudeHookLease(nextConversation, new Date(Math.min(...approvalLeaseDeadlines.map((value) => Date.parse(value)))).toISOString());
+            if (renewedLease) {
+                nextConversation = {
+                    ...nextConversation,
+                    native_session_takeover: {
+                        ...nextNativeTakeover,
+                        claude_hook_lease_id: renewedLease.id
+                    }
+                };
+            }
+        }
+        saveState(statePath, nextConversation);
+        releaseApprovalStateLock();
+        releaseApprovalTerminalLock();
+        const bridgeMonitor = startTerminalBridgeMonitorForConversation({
+            conversation: nextConversation,
+            statePath,
+            logPath,
+            options
+        });
+        if (bridgeMonitor) {
+            appendEvent(logPath, {
+                ts: new Date().toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "terminal_bridge_monitor_launch",
+                pid: bridgeMonitor.pid ?? null,
+                terminal_control: terminalControl,
+                reason: "approval_resolved",
+                agent_timeout_minutes: agentTimeoutMinutes,
+                agent_hard_timeout_minutes: agentHardTimeoutMinutes
+            });
+            runtimeLog("info", "terminal_bridge_monitor_launch", {
+                conversation_id: conversation.conversation_id,
+                monitor_pid: bridgeMonitor.pid ?? null,
+                terminal_target: terminalControl.target,
+                reason: "approval_resolved"
+            });
+        }
+        printJson({
+            conversation: nextConversation,
+            approved: true,
+            terminal_control: terminalControl,
+            key: approval.key,
+            keys: approval.keys,
+            label: approval.label,
+            decision_mode: approval.decisionMode,
+            request_id: approval.requestId,
+            approval_fingerprint: actualFingerprint,
+            auto_approved: autoApproved,
+            policy_rule_id: effectivePolicyRuleId,
+            monitor_pid: bridgeMonitor?.pid ?? null
         });
     }
-    printJson({
-        conversation: nextConversation,
-        approved: true,
-        terminal_control: terminalControl,
-        key: approval.key,
-        keys: approval.keys,
-        label: approval.label,
-        decision_mode: approval.decisionMode,
-        request_id: approval.requestId,
-        approval_fingerprint: actualFingerprint,
-        auto_approved: autoApproved,
-        policy_rule_id: policyRuleId,
-        monitor_pid: bridgeMonitor?.pid ?? null
-    });
+    finally {
+        try {
+            releaseApprovalStateLock();
+        }
+        finally {
+            releaseApprovalTerminalLock();
+        }
+    }
 }
 async function runTerminalConversationApprove({ options, conversationId, agent, terminalControl, pid }) {
-    const approval = await createTerminalAgentBridge(options).approve(agent, terminalControl, {
-        expectedFingerprint: stringValue(options.expectedApprovalFingerprint),
-        scrollbackLines: Number(options.scrollbackLines ?? 120),
-        runtime: {
-            pid,
-            cwd: terminalControl.currentPath,
-            terminalTarget: terminalControl.target
+    const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+    try {
+        if (agent === "claude") {
+            printJson({
+                conversation_id: conversationId,
+                source: "terminal_control",
+                approved: false,
+                blocked: true,
+                reason: "Claude screen approval requires `send --background` so AKK can bind it to an active managed turn",
+                terminal_control: terminalControl
+            });
+            return;
         }
-    });
-    if (!approval.approved) {
+        const approval = await createTerminalAgentBridge(options).approve(agent, terminalControl, {
+            expectedFingerprint: stringValue(options.expectedApprovalFingerprint),
+            scrollbackLines: Number(options.scrollbackLines ?? 120),
+            runtime: {
+                pid,
+                cwd: terminalControl.currentPath,
+                conversationId,
+                terminalTarget: terminalControl.target
+            }
+        });
+        if (!approval.approved) {
+            printJson({
+                conversation_id: conversationId,
+                source: "terminal_control",
+                approved: false,
+                blocked: approval.blocked,
+                reason: approval.reason,
+                terminal_control: terminalControl,
+                screen_excerpt: approval.screenExcerpt
+            });
+            return;
+        }
+        runtimeLog("info", "terminal_approval_send", {
+            conversation_id: conversationId,
+            agent,
+            terminal_target: terminalControl.target,
+            key: approval.key,
+            keys: approval.keys,
+            label: approval.label,
+            decision_mode: approval.decisionMode,
+            request_id: approval.requestId
+        });
         printJson({
             conversation_id: conversationId,
             source: "terminal_control",
-            approved: false,
-            blocked: approval.blocked,
-            reason: approval.reason,
+            approved: true,
             terminal_control: terminalControl,
-            screen_excerpt: approval.screenExcerpt
+            key: approval.key,
+            keys: approval.keys,
+            label: approval.label,
+            approval_fingerprint: approval.fingerprint,
+            decision_mode: approval.decisionMode,
+            request_id: approval.requestId
         });
-        return;
     }
-    runtimeLog("info", "terminal_approval_send", {
-        conversation_id: conversationId,
-        agent,
-        terminal_target: terminalControl.target,
-        key: approval.key,
-        keys: approval.keys,
-        label: approval.label,
-        decision_mode: approval.decisionMode,
-        request_id: approval.requestId
-    });
-    printJson({
-        conversation_id: conversationId,
-        source: "terminal_control",
-        approved: true,
-        terminal_control: terminalControl,
-        key: approval.key,
-        keys: approval.keys,
-        label: approval.label,
-        approval_fingerprint: approval.fingerprint,
-        decision_mode: approval.decisionMode,
-        request_id: approval.requestId
-    });
+    finally {
+        releaseTerminalLock();
+    }
 }
 async function runTerminalConversationSend({ options, conversationId, agent, pid, messageBody, terminalControl }) {
-    const terminalPayload = terminalSubmissionPayload(String(messageBody));
-    const terminalBridge = createTerminalAgentBridge(options);
-    if (agent === "claude") {
-        const status = await terminalBridge.status(agent, terminalControl, {
-            scrollbackLines: Number(options.scrollbackLines ?? 120),
+    const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+    try {
+        const terminalPayload = terminalSubmissionPayload(String(messageBody));
+        const terminalBridge = createTerminalAgentBridge(options);
+        if (agent === "claude") {
+            const status = await terminalBridge.status(agent, terminalControl, {
+                scrollbackLines: Number(options.scrollbackLines ?? 120),
+                runtime: {
+                    pid,
+                    cwd: terminalControl.currentPath,
+                    terminalTarget: terminalControl.target
+                }
+            });
+            assertSafeClaudeTerminalSend(status);
+        }
+        await terminalBridge.send(agent, terminalControl, terminalPayload, {
             runtime: {
                 pid,
                 cwd: terminalControl.currentPath,
                 terminalTarget: terminalControl.target
             }
         });
-        assertSafeClaudeTerminalSend(status);
-    }
-    await terminalBridge.send(agent, terminalControl, terminalPayload);
-    runtimeLog("info", "terminal_message_send", {
-        conversation_id: conversationId,
-        agent,
-        terminal_target: terminalControl.target,
-        message: textSummary(messageBody)
-    });
-    printJson({
-        conversation_id: conversationId,
-        source: "terminal_control",
-        delivered: true,
-        status: "async_pending",
-        background: true,
-        callback_expected: false,
-        terminal_control: terminalControl,
-        message: {
-            body: messageBody
-        },
-        openclaw_next_action: openClawYieldNextAction({
-            conversationId,
+        runtimeLog("info", "terminal_message_send", {
+            conversation_id: conversationId,
+            agent,
+            terminal_target: terminalControl.target,
+            message: textSummary(messageBody)
+        });
+        printJson({
+            conversation_id: conversationId,
             source: "terminal_control",
-            callbackExpected: false
-        })
-    });
+            delivered: true,
+            status: "async_pending",
+            background: true,
+            callback_expected: false,
+            terminal_control: terminalControl,
+            message: {
+                body: messageBody
+            },
+            openclaw_next_action: openClawYieldNextAction({
+                conversationId,
+                source: "terminal_control",
+                callbackExpected: false
+            })
+        });
+    }
+    finally {
+        releaseTerminalLock();
+    }
 }
-async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, needsNativeTakeoverBootstrap, terminalSendLockHeld = false }) {
+async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, needsNativeTakeoverBootstrap, terminalSendLockHeld = false, terminalStateLockHeld = false, recordMessageAfterSend = false, recordRawAttachmentAfterSend = false }) {
     const bridge = terminalBridgeEnabled(conversation);
-    if (bridge && !terminalSendLockHeld) {
+    if (!terminalSendLockHeld) {
         const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
         try {
             return await runTerminalControlSend({
@@ -3020,13 +3654,52 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
                 message,
                 terminalControl,
                 needsNativeTakeoverBootstrap,
-                terminalSendLockHeld: true
+                terminalSendLockHeld: true,
+                terminalStateLockHeld,
+                recordMessageAfterSend,
+                recordRawAttachmentAfterSend
             });
         }
         finally {
             releaseTerminalLock();
         }
     }
+    if (bridge && !terminalStateLockHeld) {
+        const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        try {
+            const currentConversation = loadState(statePath);
+            const currentTakeover = isRecord(currentConversation.native_session_takeover)
+                ? currentConversation.native_session_takeover
+                : undefined;
+            const currentControl = terminalControlFromTakeover(currentTakeover);
+            if (currentConversation.conversation_id !== nextConversation.conversation_id ||
+                currentConversation.updated_at !== nextConversation.updated_at ||
+                currentConversation.status !== nextConversation.status ||
+                currentConversation.response_rounds_used !== nextConversation.response_rounds_used ||
+                currentControl?.target !== terminalControl.target ||
+                currentControl?.socketPath !== terminalControl.socketPath) {
+                throw new Error("conversation changed while waiting to send to the terminal; refresh status and retry");
+            }
+            return await runTerminalControlSend({
+                options,
+                conversation: currentConversation,
+                nextConversation: currentConversation,
+                statePath,
+                logPath,
+                executor,
+                message,
+                terminalControl,
+                needsNativeTakeoverBootstrap,
+                terminalSendLockHeld: true,
+                terminalStateLockHeld: true,
+                recordMessageAfterSend,
+                recordRawAttachmentAfterSend
+            });
+        }
+        finally {
+            releaseStateLock();
+        }
+    }
     const terminalBridge = createTerminalAgentBridge(options);
     const bridgeStartedAt = new Date().toISOString();
     const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES);
@@ -3046,6 +3719,10 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         messageId: message.id
     };
     let preSendScreenFingerprint;
+    let claudeTranscriptAnchor;
+    const claudeHome = executor.kind === "claude"
+        ? path.resolve(expandHome(options.claudeHome) ?? defaultClaudeHome())
+        : undefined;
     if (bridge) {
         try {
             const status = await terminalBridge.status(executor.kind, terminalControl, {
@@ -3055,7 +3732,21 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             if (executor.kind === "claude") {
                 assertSafeClaudeTerminalSend(status);
             }
-            preSendScreenFingerprint = terminalBridgeScreenFingerprint(status.screen.excerpt);
+            preSendScreenFingerprint = stringValue(status.screen.digest) ??
+                terminalBridgeScreenFingerprint(status.screen.excerpt);
+            if (executor.kind === "claude") {
+                claudeTranscriptAnchor = captureClaudeTranscriptAnchor({
+                    sessionId: preSendRuntime.sessionId,
+                    cwd: preSendRuntime.cwd,
+                    pid: preSendRuntime.pid,
+                    claudeHome,
+                    agentRows: loadClaudeAgentRows(options)
+                });
+                if (!claudeTranscriptAnchor &&
+                    !stringValue(options.claudeHookStoreDir)) {
+                    throw new Error("the hook-free completion monitor could not bind an owner-private Claude transcript boundary");
+                }
+            }
         }
         catch (error) {
             if (executor.kind === "claude") {
@@ -3087,7 +3778,9 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         ? withClaudeHookLeaseState(nextConversation, claudeHookLeaseState)
         : nextConversation;
     try {
-        await terminalBridge.send(executor.kind, terminalControl, terminalPayload);
+        await terminalBridge.send(executor.kind, terminalControl, terminalPayload, {
+            runtime: preSendRuntime
+        });
     }
     catch (error) {
         if (claudeHookLeaseState) {
@@ -3095,39 +3788,17 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         }
         throw error;
     }
-    const supersededConversationIds = bridge
-        ? supersedeTerminalBridgeConversations({
-            storeDir: storeDirFromOptions(options),
-            terminalControl,
-            replacementConversationId: conversation.conversation_id
-        })
-        : [];
-    appendEvent(logPath, {
-        ts: new Date().toISOString(),
-        conversation_id: conversation.conversation_id,
-        event: "terminal_message_send",
-        executor,
-        terminal_control: terminalControl,
-        message: textSummary(message.body),
-        payload: textSummary(terminalPayload),
-        superseded_conversation_ids: supersededConversationIds
-    });
-    runtimeLog("info", "terminal_message_send", {
-        conversation_id: conversation.conversation_id,
-        agent: executor.kind,
-        terminal_target: terminalControl.target,
-        message: textSummary(message.body),
-        payload: textSummary(terminalPayload),
-        superseded_conversation_ids: supersededConversationIds
-    });
     const bridgeConversation = bridge
         ? withTerminalBridgeState({
             conversation: conversationWithHookLease,
             message,
+            requestText: terminalPayload,
             startedAt: bridgeStartedAt,
             agentTimeoutMinutes,
             agentHardTimeoutMinutes,
-            preSendScreenFingerprint
+            preSendScreenFingerprint,
+            claudeTranscriptAnchor,
+            claudeHome
         })
         : nextConversation;
     const deliveredConversation = markTakeoverBootstrapped({
@@ -3136,9 +3807,68 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         logPath,
         executor,
         native: needsNativeTakeoverBootstrap && !bridge,
-        fork: false
+        fork: false,
+        stateLockHeld: terminalStateLockHeld
+    });
+    saveState(statePath, deliveredConversation);
+    const supersededConversationIds = bridge
+        ? supersedeTerminalBridgeConversations({
+            storeDir: storeDirFromOptions(options),
+            terminalControl,
+            replacementConversationId: conversation.conversation_id
+        })
+        : [];
+    if (recordRawAttachmentAfterSend) {
+        const sourceConversationId = stringValue(isRecord(conversation.native_session_takeover)
+            ? conversation.native_session_takeover.native_session_id
+            : undefined);
+        appendEvent(logPath, {
+            ts: new Date().toISOString(),
+            conversation_id: conversation.conversation_id,
+            event: "raw_terminal_session_attached",
+            source_conversation_id: sourceConversationId,
+            agent: executor.kind,
+            terminal_control: terminalControl,
+            executor
+        });
+        runtimeLog("info", "raw_terminal_session_attached", {
+            conversation_id: conversation.conversation_id,
+            source_conversation_id: sourceConversationId,
+            terminal_target: terminalControl.target,
+            state_path: statePath,
+            event_log_path: logPath
+        });
+    }
+    if (recordMessageAfterSend) {
+        appendEvent(logPath, messageEvent(message));
+        runtimeLog("info", "message_created", {
+            conversation_id: conversation.conversation_id,
+            agent: executor.kind,
+            executor_session: executor.session,
+            message_type: message.type,
+            state_path: statePath,
+            event_log_path: logPath,
+            message: textSummary(message.body)
+        });
+    }
+    appendEvent(logPath, {
+        ts: new Date().toISOString(),
+        conversation_id: conversation.conversation_id,
+        event: "terminal_message_send",
+        executor,
+        terminal_control: terminalControl,
+        message: textSummary(message.body),
+        payload: textSummary(terminalPayload),
+        superseded_conversation_ids: supersededConversationIds
+    });
+    runtimeLog("info", "terminal_message_send", {
+        conversation_id: conversation.conversation_id,
+        agent: executor.kind,
+        terminal_target: terminalControl.target,
+        message: textSummary(message.body),
+        payload: textSummary(terminalPayload),
+        superseded_conversation_ids: supersededConversationIds
     });
-    saveState(statePath, deliveredConversation);
     const bridgeMonitor = bridge
         ? startTerminalBridgeMonitorForConversation({
             conversation: deliveredConversation,
@@ -3182,7 +3912,7 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
     });
 }
 function terminalSubmissionPayload(payload) {
-    return payload.replace(/[\r\n]+$/u, "");
+    return payload.trimEnd();
 }
 function createManagedTerminalConversationFromRawId({ options, conversationId, agent, pid, messageBody, terminalControl }) {
     const workspace = terminalControl.currentPath ?? process.cwd();
@@ -3246,23 +3976,6 @@ function createManagedTerminalConversationFromRawId({ options, conversationId, a
             terminal_bridge: true
         }
     }, paths);
-    saveState(paths.statePath, attachedConversation);
-    appendEvent(paths.logPath, {
-        ts: now.toISOString(),
-        conversation_id: attachedConversation.conversation_id,
-        event: "raw_terminal_session_attached",
-        source_conversation_id: conversationId,
-        agent,
-        terminal_control: terminalControl,
-        executor
-    });
-    runtimeLog("info", "raw_terminal_session_attached", {
-        conversation_id: attachedConversation.conversation_id,
-        source_conversation_id: conversationId,
-        terminal_target: terminalControl.target,
-        state_path: paths.statePath,
-        event_log_path: paths.logPath
-    });
     const message = createMessage({
         conversation: attachedConversation,
         from: "openclaw",
@@ -3276,18 +3989,6 @@ function createManagedTerminalConversationFromRawId({ options, conversationId, a
         }
     });
     const nextConversation = applyMessageToConversation(attachedConversation, message);
-    saveState(paths.statePath, nextConversation);
-    appendEvent(paths.logPath, messageEvent(message));
-    runtimeLog("info", "message_created", {
-        conversation_id: nextConversation.conversation_id,
-        source_conversation_id: conversationId,
-        agent: executor.kind,
-        executor_session: executor.session,
-        message_type: message.type,
-        state_path: paths.statePath,
-        event_log_path: paths.logPath,
-        message: textSummary(messageBody)
-    });
     return {
         conversation: attachedConversation,
         nextConversation,
@@ -3391,7 +4092,7 @@ function runNativeCodexResumeSend({ options, conversation, nextConversation, sta
     });
     if (options.background) {
         const outputPath = path.join(path.dirname(logPath), `${executor.kind}-native-resume-output.log`);
-        const outputFd = fs.openSync(outputPath, "a");
+        const outputFd = openPrivateAppendFile(outputPath);
         const child = spawn(codexPath, codexArgs, {
             detached: true,
             stdio: ["ignore", outputFd, outputFd],
@@ -3599,68 +4300,100 @@ function buildAgentSendPayload({ conversation, executor, message, includeNativeT
 function forkTakeoverSummaryText(forkTakeover) {
     return String(isRecord(forkTakeover) ? forkTakeover.summary ?? "" : "").trim();
 }
-function markTakeoverBootstrapped({ conversation, statePath, logPath, executor, native, fork }) {
+function markTakeoverBootstrapped({ conversation, statePath, logPath, executor, native, fork, stateLockHeld = false }) {
     let nextConversation = conversation;
     if (native) {
-        nextConversation = markNativeSessionBootstrapped({ conversation: nextConversation, statePath, logPath, executor });
+        nextConversation = markNativeSessionBootstrapped({
+            conversation: nextConversation,
+            statePath,
+            logPath,
+            executor,
+            stateLockHeld
+        });
     }
     if (fork) {
-        nextConversation = markForkSessionBootstrapped({ conversation: nextConversation, statePath, logPath, executor });
+        nextConversation = markForkSessionBootstrapped({
+            conversation: nextConversation,
+            statePath,
+            logPath,
+            executor,
+            stateLockHeld
+        });
     }
     return nextConversation;
 }
-function markNativeSessionBootstrapped({ conversation, statePath, logPath, executor }) {
-    const nativeTakeover = isRecord(conversation.native_session_takeover)
-        ? conversation.native_session_takeover
-        : {};
+function markNativeSessionBootstrapped({ conversation, statePath, logPath, executor, stateLockHeld = false }) {
     const now = new Date().toISOString();
-    const nextConversation = {
-        ...conversation,
-        native_session_takeover: {
-            ...nativeTakeover,
-            needs_bootstrap: false,
-            bootstrapped_at: now
-        },
-        updated_at: now
-    };
-    saveState(statePath, nextConversation);
+    const releaseLock = stateLockHeld
+        ? undefined
+        : acquireFileLock(`${statePath}.lock`);
+    let nextConversation = conversation;
+    try {
+        const current = stateLockHeld ? conversation : loadState(statePath);
+        const nativeTakeover = isRecord(current.native_session_takeover)
+            ? current.native_session_takeover
+            : {};
+        nextConversation = {
+            ...current,
+            native_session_takeover: {
+                ...nativeTakeover,
+                needs_bootstrap: false,
+                bootstrapped_at: now
+            },
+            updated_at: now
+        };
+        saveState(statePath, nextConversation);
+    }
+    finally {
+        releaseLock?.();
+    }
     appendEvent(logPath, {
         ts: now,
-        conversation_id: conversation.conversation_id,
+        conversation_id: nextConversation.conversation_id,
         event: "native_session_bootstrapped",
         executor
     });
     runtimeLog("info", "native_session_bootstrapped", {
-        conversation_id: conversation.conversation_id,
+        conversation_id: nextConversation.conversation_id,
         agent: executor.kind,
         executor_session: executor.session,
         state_path: statePath
     });
     return nextConversation;
 }
-function markForkSessionBootstrapped({ conversation, statePath, logPath, executor }) {
-    const forkTakeover = isRecord(conversation.fork_context_takeover)
-        ? conversation.fork_context_takeover
-        : {};
+function markForkSessionBootstrapped({ conversation, statePath, logPath, executor, stateLockHeld = false }) {
     const now = new Date().toISOString();
-    const nextConversation = {
-        ...conversation,
-        fork_context_takeover: {
-            ...forkTakeover,
-            needs_bootstrap: false,
-            bootstrapped_at: now
-        },
-        updated_at: now
-    };
-    saveState(statePath, nextConversation);
+    const releaseLock = stateLockHeld
+        ? undefined
+        : acquireFileLock(`${statePath}.lock`);
+    let nextConversation = conversation;
+    try {
+        const current = stateLockHeld ? conversation : loadState(statePath);
+        const forkTakeover = isRecord(current.fork_context_takeover)
+            ? current.fork_context_takeover
+            : {};
+        nextConversation = {
+            ...current,
+            fork_context_takeover: {
+                ...forkTakeover,
+                needs_bootstrap: false,
+                bootstrapped_at: now
+            },
+            updated_at: now
+        };
+        saveState(statePath, nextConversation);
+    }
+    finally {
+        releaseLock?.();
+    }
     appendEvent(logPath, {
         ts: now,
-        conversation_id: conversation.conversation_id,
+        conversation_id: nextConversation.conversation_id,
         event: "fork_session_bootstrapped",
         executor
     });
     runtimeLog("info", "fork_session_bootstrapped", {
-        conversation_id: conversation.conversation_id,
+        conversation_id: nextConversation.conversation_id,
         agent: executor.kind,
         executor_session: executor.session,
         state_path: statePath
@@ -3747,124 +4480,576 @@ function markConversationNeedsRecovery({ conversation, statePath, logPath, execu
     };
 }
 async function runRenew(options) {
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const conversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
     if (conversation.status === "closed") {
         throw new Error(`cannot renew ${conversation.conversation_id}; conversation is closed`);
     }
-    if (conversation.status !== "stalled") {
-        throw new Error(`cannot renew ${conversation.conversation_id}; conversation is ${conversation.status}, not stalled`);
+    if (conversation.status !== "stalled") {
+        throw new Error(`cannot renew ${conversation.conversation_id}; conversation is ${conversation.status}, not stalled`);
+    }
+    const nativeTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const terminalControl = terminalControlFromTakeover(nativeTakeover);
+    if (!terminalControl || nativeTakeover?.["terminal_bridge"] !== true) {
+        throw new Error(`cannot renew ${conversation.conversation_id}; conversation is not a terminal bridge task`);
+    }
+    const panes = await createTerminalControlProvider(options).listPanes();
+    const terminalExists = panes.some((pane) => pane.target === terminalControl.target &&
+        (terminalControl.socketPath === undefined || pane.socketPath === terminalControl.socketPath));
+    if (!terminalExists) {
+        throw new Error(`cannot renew ${conversation.conversation_id}; terminal ${terminalControl.target} is no longer available`);
+    }
+    const expectedMessageId = stringValue(nativeTakeover?.terminal_bridge_message_id);
+    const expectedStartedAt = stringValue(nativeTakeover?.terminal_bridge_started_at);
+    let renewed = conversation;
+    let renewedTerminalControl = terminalControl;
+    let inactivityTimeoutMinutes = 0;
+    let hardTimeoutMinutes = 0;
+    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const current = loadState(statePath);
+        if (current.status !== "stalled") {
+            throw new Error(`cannot renew ${current.conversation_id}; conversation is ${current.status}, not stalled`);
+        }
+        const currentTakeover = isRecord(current.native_session_takeover)
+            ? current.native_session_takeover
+            : undefined;
+        const currentControl = terminalControlFromTakeover(currentTakeover);
+        if (!currentControl || currentTakeover?.terminal_bridge !== true) {
+            throw new Error(`cannot renew ${current.conversation_id}; conversation is not a terminal bridge task`);
+        }
+        if (current.conversation_id !== conversation.conversation_id ||
+            currentControl.target !== terminalControl.target ||
+            currentControl.socketPath !== terminalControl.socketPath ||
+            currentControl.panePid !== terminalControl.panePid ||
+            stringValue(currentTakeover.terminal_bridge_message_id) !== expectedMessageId ||
+            stringValue(currentTakeover.terminal_bridge_started_at) !== expectedStartedAt) {
+            throw new Error("conversation changed while waiting to renew; refresh status and retry");
+        }
+        renewedTerminalControl = currentControl;
+        inactivityTimeoutMinutes = positiveMinutes(options.minutes ??
+            options.agentTimeoutMinutes ??
+            currentTakeover.terminal_bridge_inactivity_timeout_minutes ??
+            DEFAULT_AGENT_TIMEOUT_MINUTES, "--minutes");
+        hardTimeoutMinutes = positiveMinutes(currentTakeover.terminal_bridge_hard_timeout_minutes ??
+            DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
+        const startedAt = stringValue(currentTakeover.terminal_bridge_started_at);
+        const startedAtMs = startedAt ? Date.parse(startedAt) : NaN;
+        if (Number.isFinite(startedAtMs) &&
+            Date.now() - startedAtMs >= hardTimeoutMinutes * 60 * 1000) {
+            throw new Error(`cannot renew ${current.conversation_id}; terminal bridge hard lifetime of ${hardTimeoutMinutes} minutes has elapsed`);
+        }
+        const now = new Date().toISOString();
+        const currentMessageId = stringValue(currentTakeover.terminal_bridge_message_id);
+        const hardDeadline = deadlineAt(startedAt ?? now, hardTimeoutMinutes) ??
+            new Date(Date.now() + hardTimeoutMinutes * 60 * 1000).toISOString();
+        const inactivityDeadline = deadlineAt(now, inactivityTimeoutMinutes) ??
+            new Date(Date.now() + inactivityTimeoutMinutes * 60 * 1000).toISOString();
+        const renewedLease = executorForConversation(current).kind === "claude" && currentMessageId
+            ? activateClaudeHookLease({
+                options,
+                conversation: current,
+                message: { id: currentMessageId },
+                terminalControl: currentControl,
+                expiresAt: new Date(Math.min(Date.parse(hardDeadline), Date.parse(inactivityDeadline))).toISOString()
+            })
+            : undefined;
+        const renewedBase = renewedLease
+            ? withClaudeHookLeaseState(current, renewedLease)
+            : current;
+        const renewedNativeTakeover = isRecord(renewedBase.native_session_takeover)
+            ? renewedBase.native_session_takeover
+            : currentTakeover;
+        renewed = {
+            ...renewedBase,
+            status: "waiting_for_agent",
+            native_session_takeover: {
+                ...renewedNativeTakeover,
+                terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
+                terminal_bridge_monitor_started_at: now,
+                terminal_bridge_last_activity_at: now,
+                terminal_bridge_inactivity_timeout_minutes: inactivityTimeoutMinutes,
+                terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes,
+                terminal_bridge_inactivity_deadline_at: inactivityDeadline,
+                terminal_bridge_hard_deadline_at: hardDeadline,
+                terminal_bridge_renewed_at: now
+            },
+            updated_at: now
+        };
+        Reflect.deleteProperty(renewed, "stalled_at");
+        Reflect.deleteProperty(renewed, "stalled_reason");
+        Reflect.deleteProperty(renewed, "stalled_notification_sent_at");
+        Reflect.deleteProperty(renewed, "stalled_notification_message_id");
+        saveState(statePath, renewed);
+        appendEvent(logPath, {
+            ts: now,
+            conversation_id: current.conversation_id,
+            event: "terminal_bridge_renewed",
+            previous_status: current.status,
+            terminal_control: currentControl,
+            agent_timeout_minutes: inactivityTimeoutMinutes,
+            agent_hard_timeout_minutes: hardTimeoutMinutes,
+            last_activity_at: now
+        });
+        runtimeLog("info", "terminal_bridge_renewed", {
+            conversation_id: current.conversation_id,
+            terminal_target: currentControl.target,
+            agent_timeout_minutes: inactivityTimeoutMinutes,
+            agent_hard_timeout_minutes: hardTimeoutMinutes
+        });
+    }
+    finally {
+        releaseStateLock();
+    }
+    const monitor = startTerminalBridgeMonitorForConversation({
+        conversation: renewed,
+        statePath,
+        logPath,
+        options: {
+            ...options,
+            agentTimeoutMinutes: inactivityTimeoutMinutes,
+            agentHardTimeoutMinutes: hardTimeoutMinutes
+        }
+    });
+    if (monitor) {
+        appendEvent(logPath, {
+            ts: new Date().toISOString(),
+            conversation_id: renewed.conversation_id,
+            event: "terminal_bridge_monitor_launch",
+            pid: monitor.pid ?? null,
+            terminal_control: renewedTerminalControl,
+            reason: "renewal",
+            agent_timeout_minutes: inactivityTimeoutMinutes,
+            agent_hard_timeout_minutes: hardTimeoutMinutes
+        });
+    }
+    printJson({
+        conversation: renewed,
+        renewed: true,
+        terminal_control: renewedTerminalControl,
+        agent_timeout_minutes: inactivityTimeoutMinutes,
+        agent_hard_timeout_minutes: hardTimeoutMinutes,
+        monitor_pid: monitor?.pid ?? null
+    });
+}
+async function runReconcileMonitors(options) {
+    const storeDir = storeDirFromOptions(options);
+    const conversations = listConversations(storeDir);
+    const items = [];
+    let ignored = 0;
+    let launched = 0;
+    let alreadyRunning = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const listedConversation of conversations) {
+        const statePath = expandHome(stringValue(listedConversation.state_path) ??
+            statePathForConversationId(listedConversation.conversation_id, storeDir));
+        const logPath = expandHome(stringValue(listedConversation.event_log_path) ??
+            logPathForStatePath(statePath));
+        try {
+            const callbackRecovery = prepareCallbackDeliveryReconciliation({
+                statePath,
+                logPath,
+                delayMs: options.callbackRetryDelayMs
+            });
+            if (callbackRecovery.handled) {
+                if (callbackRecovery.status === "launched") {
+                    launched += 1;
+                }
+                else if (callbackRecovery.status === "already_running") {
+                    alreadyRunning += 1;
+                }
+                else {
+                    skipped += 1;
+                }
+                items.push({
+                    conversation_id: callbackRecovery.conversationId,
+                    status: callbackRecovery.status,
+                    reason: callbackRecovery.reason,
+                    ...(callbackRecovery.monitorPid === undefined
+                        ? {}
+                        : { monitor_pid: callbackRecovery.monitorPid })
+                });
+                continue;
+            }
+            const listedNativeTakeover = isRecord(listedConversation.native_session_takeover)
+                ? listedConversation.native_session_takeover
+                : undefined;
+            if (listedNativeTakeover?.terminal_bridge !== true) {
+                ignored += 1;
+                continue;
+            }
+            const initialConversation = await migrateLegacyTerminalAgentIdentity({
+                conversation: loadState(statePath),
+                statePath,
+                logPath,
+                options
+            });
+            const initialEligibility = terminalBridgeReconciliationEligibility(initialConversation);
+            if (!initialEligibility.eligible) {
+                skipped += 1;
+                items.push({
+                    conversation_id: initialConversation.conversation_id,
+                    status: "skipped",
+                    reason: initialEligibility.reason
+                });
+                continue;
+            }
+            const activeOwner = activeTerminalBridgeMonitorOwner(statePath, initialEligibility.terminalMessageId);
+            if (activeOwner) {
+                alreadyRunning += 1;
+                items.push({
+                    conversation_id: initialConversation.conversation_id,
+                    status: "already_running",
+                    reason: "monitor_lock_owner_alive",
+                    monitor_owner_pid: activeOwner.ownerPid ?? null
+                });
+                continue;
+            }
+            const monitorLockVersion = Number(initialEligibility.nativeTakeover.terminal_bridge_monitor_lock_version);
+            if (monitorLockVersion !== TERMINAL_BRIDGE_MONITOR_LOCK_VERSION) {
+                if (Number.isFinite(monitorLockVersion)) {
+                    skipped += 1;
+                    items.push({
+                        conversation_id: initialConversation.conversation_id,
+                        status: "skipped",
+                        reason: "monitor_lock_version_unsupported",
+                        monitor_lock_version: monitorLockVersion
+                    });
+                    continue;
+                }
+                const legacyLaunchPid = latestTerminalBridgeMonitorLaunchPid(logPath);
+                if (legacyLaunchPid === undefined) {
+                    skipped += 1;
+                    items.push({
+                        conversation_id: initialConversation.conversation_id,
+                        status: "skipped",
+                        reason: "legacy_monitor_ownership_unknown"
+                    });
+                    continue;
+                }
+                if (isProcessAlive(legacyLaunchPid)) {
+                    alreadyRunning += 1;
+                    items.push({
+                        conversation_id: initialConversation.conversation_id,
+                        status: "already_running",
+                        reason: "legacy_monitor_launch_pid_alive",
+                        monitor_owner_pid: legacyLaunchPid
+                    });
+                    continue;
+                }
+            }
+            const prepared = prepareTerminalBridgeMonitorReconciliation({
+                statePath,
+                expectedMessageId: initialEligibility.terminalMessageId
+            });
+            if (!prepared.prepared) {
+                if (prepared.alreadyRunning) {
+                    alreadyRunning += 1;
+                    items.push({
+                        conversation_id: initialConversation.conversation_id,
+                        status: "already_running",
+                        reason: prepared.reason,
+                        monitor_owner_pid: prepared.ownerPid ?? null
+                    });
+                }
+                else {
+                    skipped += 1;
+                    items.push({
+                        conversation_id: initialConversation.conversation_id,
+                        status: "skipped",
+                        reason: prepared.reason
+                    });
+                }
+                continue;
+            }
+            const monitor = startTerminalBridgeMonitorForConversation({
+                conversation: prepared.conversation,
+                statePath,
+                logPath,
+                options
+            });
+            if (!monitor) {
+                skipped += 1;
+                items.push({
+                    conversation_id: prepared.conversation.conversation_id,
+                    status: "skipped",
+                    reason: "terminal_bridge_monitor_launch_disabled"
+                });
+                continue;
+            }
+            const launchedAt = new Date().toISOString();
+            appendEvent(logPath, {
+                ts: launchedAt,
+                conversation_id: prepared.conversation.conversation_id,
+                event: "terminal_bridge_monitor_launch",
+                pid: monitor.pid ?? null,
+                terminal_control: prepared.terminalControl,
+                reason: "startup_reconciliation",
+                agent_timeout_minutes: prepared.inactivityTimeoutMinutes,
+                agent_hard_timeout_minutes: prepared.hardTimeoutMinutes
+            });
+            runtimeLog("info", "terminal_bridge_monitor_reconciled", {
+                conversation_id: prepared.conversation.conversation_id,
+                monitor_pid: monitor.pid ?? null,
+                terminal_target: prepared.terminalControl.target
+            });
+            launched += 1;
+            items.push({
+                conversation_id: prepared.conversation.conversation_id,
+                status: "launched",
+                reason: "startup_reconciliation",
+                monitor_pid: monitor.pid ?? null
+            });
+        }
+        catch (error) {
+            errors += 1;
+            items.push({
+                conversation_id: listedConversation.conversation_id,
+                status: "error",
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    printJson({
+        reconciled: true,
+        store_dir: storeDir,
+        checked: conversations.length,
+        ignored,
+        launched,
+        already_running: alreadyRunning,
+        skipped,
+        errors,
+        items
+    });
+}
+function prepareCallbackDeliveryReconciliation({ statePath, logPath, delayMs }) {
+    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const conversation = loadState(statePath);
+        const callbackDelivery = isRecord(conversation.callback_delivery)
+            ? conversation.callback_delivery
+            : undefined;
+        if (!["callback_pending", "callback_failed"].includes(conversation.status)) {
+            return {
+                handled: false
+            };
+        }
+        const conversationId = stringValue(conversation.conversation_id) ?? "unknown";
+        const attempts = Number(callbackDelivery?.attempts ?? 0);
+        if (!["pending", "failed"].includes(String(callbackDelivery?.status ?? "")) ||
+            !isRecord(callbackDelivery?.message)) {
+            return {
+                handled: true,
+                conversationId,
+                status: "skipped",
+                reason: "callback_delivery_metadata_missing"
+            };
+        }
+        if (!Number.isSafeInteger(attempts) || attempts < 1 ||
+            attempts > CALLBACK_RETRY_DELAYS_MS.length) {
+            return {
+                handled: true,
+                conversationId,
+                status: "skipped",
+                reason: "callback_delivery_retries_exhausted"
+            };
+        }
+        const configuredDelayMs = Number(delayMs);
+        const retryDelayMs = Number.isFinite(configuredDelayMs) &&
+            configuredDelayMs >= 0
+            ? configuredDelayMs
+            : CALLBACK_RETRY_DELAYS_MS[Math.max(0, attempts - 1)];
+        const retryMonitor = startCallbackRetryMonitor({
+            statePath,
+            delayMs: retryDelayMs
+        });
+        const launchedAt = new Date().toISOString();
+        const nextAttemptAt = new Date(Date.now() + retryDelayMs).toISOString();
+        const nextConversation = {
+            ...conversation,
+            callback_delivery: {
+                ...callbackDelivery,
+                retry_monitor_pid: retryMonitor.pid ?? null,
+                next_attempt_at: nextAttemptAt
+            },
+            updated_at: launchedAt
+        };
+        saveState(statePath, nextConversation);
+        appendEvent(logPath, {
+            ts: launchedAt,
+            conversation_id: conversationId,
+            event: "callback_retry_monitor_launched",
+            message_id: callbackDelivery.message.id,
+            pid: retryMonitor.pid ?? null,
+            next_attempt_at: nextAttemptAt,
+            reason: "startup_reconciliation"
+        });
+        return {
+            handled: true,
+            conversationId,
+            status: "launched",
+            reason: "callback_delivery_reconciliation",
+            monitorPid: retryMonitor.pid
+        };
+    }
+    finally {
+        releaseStateLock();
     }
-    const nativeTakeover = isRecord(conversation.native_session_takeover)
+}
+function terminalBridgeReconciliationEligibility(conversation) {
+    const nativeTakeover = isRecord(conversation?.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
-    const terminalControl = terminalControlFromTakeover(nativeTakeover);
-    if (!terminalControl || nativeTakeover?.["terminal_bridge"] !== true) {
-        throw new Error(`cannot renew ${conversation.conversation_id}; conversation is not a terminal bridge task`);
+    if (nativeTakeover?.terminal_bridge !== true) {
+        return { eligible: false, reason: "not_terminal_bridge" };
     }
-    const panes = await createTerminalControlProvider(options).listPanes();
-    const terminalExists = panes.some((pane) => pane.target === terminalControl.target &&
-        (terminalControl.socketPath === undefined || pane.socketPath === terminalControl.socketPath));
-    if (!terminalExists) {
-        throw new Error(`cannot renew ${conversation.conversation_id}; terminal ${terminalControl.target} is no longer available`);
+    if (!conversation.gateway_method) {
+        return { eligible: false, reason: "gateway_method_missing" };
     }
-    const inactivityTimeoutMinutes = positiveMinutes(options.minutes ??
-        options.agentTimeoutMinutes ??
-        nativeTakeover?.["terminal_bridge_inactivity_timeout_minutes"] ??
-        DEFAULT_AGENT_TIMEOUT_MINUTES, "--minutes");
-    const hardTimeoutMinutes = positiveMinutes(nativeTakeover?.["terminal_bridge_hard_timeout_minutes"] ??
-        DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
-    const startedAt = stringValue(nativeTakeover?.["terminal_bridge_started_at"]);
-    const startedAtMs = startedAt ? Date.parse(startedAt) : NaN;
-    if (Number.isFinite(startedAtMs) && Date.now() - startedAtMs >= hardTimeoutMinutes * 60 * 1000) {
-        throw new Error(`cannot renew ${conversation.conversation_id}; terminal bridge hard lifetime of ${hardTimeoutMinutes} minutes has elapsed`);
+    if (!stringValue(conversation.gateway_session) && !stringValue(conversation.openclaw_session)) {
+        return { eligible: false, reason: "gateway_session_missing" };
     }
-    const now = new Date().toISOString();
-    const currentMessageId = stringValue(nativeTakeover?.terminal_bridge_message_id);
-    const hardDeadline = deadlineAt(startedAt ?? now, hardTimeoutMinutes) ??
-        new Date(Date.now() + hardTimeoutMinutes * 60 * 1000).toISOString();
-    const inactivityDeadline = deadlineAt(now, inactivityTimeoutMinutes) ??
-        new Date(Date.now() + inactivityTimeoutMinutes * 60 * 1000).toISOString();
-    const renewedLease = executorForConversation(conversation).kind === "claude" && currentMessageId
-        ? activateClaudeHookLease({
-            options,
-            conversation,
-            message: { id: currentMessageId },
-            terminalControl,
-            expiresAt: new Date(Math.min(Date.parse(hardDeadline), Date.parse(inactivityDeadline))).toISOString()
-        })
-        : undefined;
-    const renewedBase = renewedLease
-        ? withClaudeHookLeaseState(conversation, renewedLease)
-        : conversation;
-    const renewedNativeTakeover = isRecord(renewedBase.native_session_takeover)
-        ? renewedBase.native_session_takeover
-        : nativeTakeover;
-    const renewed = {
-        ...renewedBase,
-        status: "waiting_for_agent",
-        native_session_takeover: {
-            ...renewedNativeTakeover,
-            terminal_bridge_monitor_started_at: now,
-            terminal_bridge_last_activity_at: now,
-            terminal_bridge_inactivity_timeout_minutes: inactivityTimeoutMinutes,
-            terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes,
-            terminal_bridge_inactivity_deadline_at: inactivityDeadline,
-            terminal_bridge_hard_deadline_at: hardDeadline,
-            terminal_bridge_renewed_at: now
-        },
-        updated_at: now
+    if (!isWaitingForAgent(conversation.status)) {
+        return {
+            eligible: false,
+            reason: `conversation_status_${String(conversation.status ?? "missing")}`
+        };
+    }
+    const terminalMessageId = stringValue(nativeTakeover.terminal_bridge_message_id);
+    const terminalControl = terminalControlFromTakeover(nativeTakeover);
+    if (!terminalMessageId || !terminalControl) {
+        return { eligible: false, reason: "terminal_bridge_identity_missing" };
+    }
+    const runtime = terminalRuntimeIdentityForConversation(conversation, terminalControl);
+    if (!Number.isInteger(runtime.pid) || Number(runtime.pid) <= 0 || !stringValue(runtime.cwd)) {
+        return { eligible: false, reason: "terminal_agent_identity_missing" };
+    }
+    const inactivityTimeoutMinutes = Number(nativeTakeover.terminal_bridge_inactivity_timeout_minutes);
+    const hardTimeoutMinutes = Number(nativeTakeover.terminal_bridge_hard_timeout_minutes);
+    const startedAtMs = validTimestampMs(nativeTakeover.terminal_bridge_started_at);
+    const lastActivityAtMs = validTimestampMs(nativeTakeover.terminal_bridge_last_activity_at);
+    const inactivityDeadlineAtMs = validTimestampMs(nativeTakeover.terminal_bridge_inactivity_deadline_at);
+    const hardDeadlineAtMs = validTimestampMs(nativeTakeover.terminal_bridge_hard_deadline_at);
+    if (!Number.isFinite(inactivityTimeoutMinutes) ||
+        inactivityTimeoutMinutes <= 0 ||
+        !Number.isFinite(hardTimeoutMinutes) ||
+        hardTimeoutMinutes <= 0 ||
+        startedAtMs === undefined ||
+        lastActivityAtMs === undefined ||
+        inactivityDeadlineAtMs === undefined ||
+        hardDeadlineAtMs === undefined) {
+        return { eligible: false, reason: "terminal_bridge_deadline_metadata_missing" };
+    }
+    return {
+        eligible: true,
+        nativeTakeover,
+        terminalMessageId,
+        terminalControl,
+        runtime,
+        inactivityTimeoutMinutes,
+        hardTimeoutMinutes,
+        inactivityDeadlineAtMs,
+        hardDeadlineAtMs
     };
-    Reflect.deleteProperty(renewed, "stalled_at");
-    Reflect.deleteProperty(renewed, "stalled_reason");
-    Reflect.deleteProperty(renewed, "stalled_notification_sent_at");
-    Reflect.deleteProperty(renewed, "stalled_notification_message_id");
-    saveState(statePath, renewed);
-    appendEvent(logPath, {
-        ts: now,
-        conversation_id: conversation.conversation_id,
-        event: "terminal_bridge_renewed",
-        previous_status: conversation.status,
-        terminal_control: terminalControl,
-        agent_timeout_minutes: inactivityTimeoutMinutes,
-        agent_hard_timeout_minutes: hardTimeoutMinutes,
-        last_activity_at: now
-    });
-    runtimeLog("info", "terminal_bridge_renewed", {
-        conversation_id: conversation.conversation_id,
-        terminal_target: terminalControl.target,
-        agent_timeout_minutes: inactivityTimeoutMinutes,
-        agent_hard_timeout_minutes: hardTimeoutMinutes
-    });
-    const monitor = startTerminalBridgeMonitorForConversation({
-        conversation: renewed,
-        statePath,
-        logPath,
-        options: {
-            ...options,
-            agentTimeoutMinutes: inactivityTimeoutMinutes,
-            agentHardTimeoutMinutes: hardTimeoutMinutes
+}
+function latestTerminalBridgeMonitorLaunchPid(logPath) {
+    let events;
+    try {
+        events = readExistingEvents(logPath);
+    }
+    catch {
+        return undefined;
+    }
+    const launch = [...events].reverse().find((event) => event.event === "terminal_bridge_monitor_launch");
+    const pid = Number(launch?.pid);
+    return Number.isSafeInteger(pid) && pid > 1 ? pid : undefined;
+}
+function prepareTerminalBridgeMonitorReconciliation({ statePath, expectedMessageId }) {
+    const releaseStateLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const conversation = loadState(statePath);
+        const eligibility = terminalBridgeReconciliationEligibility(conversation);
+        if (!eligibility.eligible) {
+            return {
+                prepared: false,
+                alreadyRunning: false,
+                reason: eligibility.reason
+            };
         }
-    });
-    if (monitor) {
-        appendEvent(logPath, {
-            ts: new Date().toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "terminal_bridge_monitor_launch",
-            pid: monitor.pid ?? null,
-            terminal_control: terminalControl,
-            reason: "renewal",
-            agent_timeout_minutes: inactivityTimeoutMinutes,
-            agent_hard_timeout_minutes: hardTimeoutMinutes
-        });
+        if (eligibility.terminalMessageId !== expectedMessageId) {
+            return {
+                prepared: false,
+                alreadyRunning: false,
+                reason: "terminal_bridge_task_replaced"
+            };
+        }
+        const activeOwner = activeTerminalBridgeMonitorOwner(statePath, eligibility.terminalMessageId);
+        if (activeOwner) {
+            return {
+                prepared: false,
+                alreadyRunning: true,
+                reason: "monitor_lock_owner_alive",
+                ownerPid: activeOwner.ownerPid
+            };
+        }
+        let renewedLease;
+        const usesClaudeHookLease = executorForConversation(conversation).kind === "claude" &&
+            eligibility.nativeTakeover.claude_hook_mode === "enabled";
+        if (usesClaudeHookLease) {
+            const leaseDeadlineAtMs = Math.min(eligibility.inactivityDeadlineAtMs, eligibility.hardDeadlineAtMs);
+            if (leaseDeadlineAtMs <= Date.now()) {
+                return {
+                    prepared: false,
+                    alreadyRunning: false,
+                    reason: "claude_hook_lease_deadline_elapsed"
+                };
+            }
+            renewedLease = renewClaudeHookLease(conversation, new Date(leaseDeadlineAtMs).toISOString());
+            if (!renewedLease) {
+                return {
+                    prepared: false,
+                    alreadyRunning: false,
+                    reason: "claude_hook_lease_refresh_failed"
+                };
+            }
+        }
+        const nextNativeTakeover = {
+            ...eligibility.nativeTakeover,
+            terminal_bridge_monitor_lock_version: TERMINAL_BRIDGE_MONITOR_LOCK_VERSION,
+            ...(renewedLease ? { claude_hook_lease_id: renewedLease.id } : {})
+        };
+        const needsSave = eligibility.nativeTakeover.terminal_bridge_monitor_lock_version !==
+            TERMINAL_BRIDGE_MONITOR_LOCK_VERSION ||
+            (renewedLease !== undefined &&
+                eligibility.nativeTakeover.claude_hook_lease_id !== renewedLease.id);
+        const preparedConversation = needsSave
+            ? {
+                ...conversation,
+                native_session_takeover: nextNativeTakeover,
+                updated_at: new Date().toISOString()
+            }
+            : conversation;
+        if (needsSave) {
+            saveState(statePath, preparedConversation);
+        }
+        return {
+            prepared: true,
+            conversation: preparedConversation,
+            terminalControl: eligibility.terminalControl,
+            inactivityTimeoutMinutes: eligibility.inactivityTimeoutMinutes,
+            hardTimeoutMinutes: eligibility.hardTimeoutMinutes
+        };
+    }
+    finally {
+        releaseStateLock();
     }
-    printJson({
-        conversation: renewed,
-        renewed: true,
-        terminal_control: terminalControl,
-        agent_timeout_minutes: inactivityTimeoutMinutes,
-        agent_hard_timeout_minutes: hardTimeoutMinutes,
-        monitor_pid: monitor?.pid ?? null
-    });
 }
 function positiveMinutes(value, optionName) {
     const parsed = Number(value);
@@ -3886,7 +5071,12 @@ async function runCancel(options) {
         });
         return;
     }
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const conversation = await migrateLegacyTerminalAgentIdentity({
+        ...loaded,
+        options
+    });
     if (["closed", "cancelled"].includes(conversation.status)) {
         throw new Error(`cannot cancel ${conversation.conversation_id}; conversation is ${conversation.status}`);
     }
@@ -3964,91 +5154,123 @@ async function runCancel(options) {
     });
 }
 async function runTerminalConversationCancel({ options, conversationId, agent, terminalControl, pid }) {
-    const cancellation = await createTerminalAgentBridge(options).cancel(agent, terminalControl, {
-        runtime: {
-            pid,
-            cwd: terminalControl.currentPath,
-            terminalTarget: terminalControl.target
-        },
-        scrollbackLines: Number(options.scrollbackLines ?? 120)
-    });
-    runtimeLog("info", "terminal_cancel_requested", {
-        conversation_id: conversationId,
-        agent,
-        terminal_target: terminalControl.target,
-        key: cancellation.key,
-        keys: cancellation.keys,
-        denied_approval: cancellation.deniedApproval,
-        request_id: cancellation.requestId,
-        cancel_requested: cancellation.cancelRequested,
-        reason: cancellation.reason
-    });
-    printJson({
-        conversation_id: conversationId,
-        source: "terminal_control",
-        cancel_requested: cancellation.cancelRequested,
-        reason: cancellation.reason,
-        terminal_control: terminalControl,
-        key: cancellation.key,
-        keys: cancellation.keys,
-        denied_approval: cancellation.deniedApproval,
-        request_id: cancellation.requestId
-    });
-}
-async function runTerminalControlCancel({ options, conversation, statePath, logPath, agent, terminalControl }) {
-    const cancellation = await createTerminalAgentBridge(options).cancel(agent, terminalControl, {
-        runtime: terminalRuntimeIdentityForConversation(conversation, terminalControl),
-        scrollbackLines: Number(options.scrollbackLines ?? 120)
-    });
-    if (!cancellation.cancelRequested) {
+    const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+    try {
+        const cancellation = await createTerminalAgentBridge(options).cancel(agent, terminalControl, {
+            runtime: {
+                pid,
+                cwd: terminalControl.currentPath,
+                terminalTarget: terminalControl.target
+            },
+            scrollbackLines: Number(options.scrollbackLines ?? 120)
+        });
+        runtimeLog("info", "terminal_cancel_requested", {
+            conversation_id: conversationId,
+            agent,
+            terminal_target: terminalControl.target,
+            key: cancellation.key,
+            keys: cancellation.keys,
+            denied_approval: cancellation.deniedApproval,
+            request_id: cancellation.requestId,
+            cancel_requested: cancellation.cancelRequested,
+            reason: cancellation.reason
+        });
         printJson({
-            conversation,
-            cancel_requested: false,
+            conversation_id: conversationId,
+            source: "terminal_control",
+            cancel_requested: cancellation.cancelRequested,
             reason: cancellation.reason,
             terminal_control: terminalControl,
-            budget: budgetAction(conversation)
+            key: cancellation.key,
+            keys: cancellation.keys,
+            denied_approval: cancellation.deniedApproval,
+            request_id: cancellation.requestId
         });
-        return;
     }
-    const now = new Date().toISOString();
-    appendEvent(logPath, {
-        ts: now,
-        conversation_id: conversation.conversation_id,
-        event: "terminal_cancel_requested",
-        terminal_control: terminalControl,
-        key: cancellation.key,
-        keys: cancellation.keys,
-        denied_approval: cancellation.deniedApproval,
-        request_id: cancellation.requestId
-    });
-    runtimeLog("info", "terminal_cancel_requested", {
-        conversation_id: conversation.conversation_id,
-        agent,
-        terminal_target: terminalControl.target,
-        key: cancellation.key,
-        keys: cancellation.keys,
-        denied_approval: cancellation.deniedApproval,
-        request_id: cancellation.requestId
-    });
-    const nextConversation = {
-        ...conversation,
-        status: "cancelled",
-        cancelled_at: now,
-        terminal_cancel_requested_at: now,
-        updated_at: now
-    };
-    saveState(statePath, nextConversation);
-    releaseClaudeHookLease(nextConversation);
-    printJson({
-        conversation: nextConversation,
-        cancel_requested: true,
-        terminal_control: terminalControl,
-        key: cancellation.key,
-        keys: cancellation.keys,
-        denied_approval: cancellation.deniedApproval,
-        request_id: cancellation.requestId,
-        budget: budgetAction(nextConversation)
-    });
+    finally {
+        releaseTerminalLock();
+    }
+}
+async function runTerminalControlCancel({ options, conversation, statePath, logPath, agent, terminalControl }) {
+    const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+    let releaseStateLock;
+    try {
+        releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        const currentConversation = loadState(statePath);
+        if (["closed", "cancelled"].includes(currentConversation.status)) {
+            throw new Error(`cannot cancel ${currentConversation.conversation_id}; conversation is ${currentConversation.status}`);
+        }
+        const currentTakeover = isRecord(currentConversation.native_session_takeover)
+            ? currentConversation.native_session_takeover
+            : undefined;
+        const currentControl = terminalControlFromTakeover(currentTakeover);
+        if (!currentControl ||
+            currentControl.target !== terminalControl.target ||
+            currentControl.socketPath !== terminalControl.socketPath) {
+            throw new Error("terminal control changed while waiting to cancel; refresh status and retry");
+        }
+        const cancellation = await createTerminalAgentBridge(options).cancel(agent, currentControl, {
+            runtime: terminalRuntimeIdentityForConversation(currentConversation, currentControl),
+            scrollbackLines: Number(options.scrollbackLines ?? 120)
+        });
+        if (!cancellation.cancelRequested) {
+            printJson({
+                conversation: currentConversation,
+                cancel_requested: false,
+                reason: cancellation.reason,
+                terminal_control: currentControl,
+                budget: budgetAction(currentConversation)
+            });
+            return;
+        }
+        const now = new Date().toISOString();
+        appendEvent(logPath, {
+            ts: now,
+            conversation_id: currentConversation.conversation_id,
+            event: "terminal_cancel_requested",
+            terminal_control: currentControl,
+            key: cancellation.key,
+            keys: cancellation.keys,
+            denied_approval: cancellation.deniedApproval,
+            request_id: cancellation.requestId
+        });
+        runtimeLog("info", "terminal_cancel_requested", {
+            conversation_id: currentConversation.conversation_id,
+            agent,
+            terminal_target: currentControl.target,
+            key: cancellation.key,
+            keys: cancellation.keys,
+            denied_approval: cancellation.deniedApproval,
+            request_id: cancellation.requestId
+        });
+        const nextConversation = {
+            ...currentConversation,
+            status: "cancelled",
+            cancelled_at: now,
+            terminal_cancel_requested_at: now,
+            updated_at: now
+        };
+        saveState(statePath, nextConversation);
+        releaseClaudeHookLease(nextConversation);
+        printJson({
+            conversation: nextConversation,
+            cancel_requested: true,
+            terminal_control: currentControl,
+            key: cancellation.key,
+            keys: cancellation.keys,
+            denied_approval: cancellation.deniedApproval,
+            request_id: cancellation.requestId,
+            budget: budgetAction(nextConversation)
+        });
+    }
+    finally {
+        try {
+            releaseStateLock?.();
+        }
+        finally {
+            releaseTerminalLock();
+        }
+    }
 }
 function runRecover(options) {
     runRecoveryDecision({ ...options, mode: "recover" });
@@ -4117,7 +5339,7 @@ function runRecoveryDecision(options) {
     const acpxArgs = buildAcpxPromptArgs({ executor, payload, model: executorModel });
     if (options.background) {
         const outputPath = path.join(path.dirname(logPath), `${executor.kind}-${options.mode}-output.log`);
-        const outputFd = fs.openSync(outputPath, "a");
+        const outputFd = openPrivateAppendFile(outputPath);
         const child = spawn(acpxPath, acpxArgs, {
             detached: true,
             stdio: ["ignore", outputFd, outputFd],
@@ -4217,36 +5439,57 @@ function formatProtocolHistoryForRecovery(events) {
     });
     return lines.length ? lines.join("\n") : "- No prior protocol messages were recorded.";
 }
-function runClose(options) {
-    const { conversation, statePath, logPath } = loadConversationFromOptions(options);
-    const now = new Date().toISOString();
-    const closed = {
-        ...conversation,
-        status: "closed",
-        closed_at: now,
-        close_reason: options.reason ?? "closed by request",
-        updated_at: now
-    };
-    saveState(statePath, closed);
-    releaseClaudeHookLease(closed);
-    appendEvent(logPath, {
-        ts: now,
-        conversation_id: conversation.conversation_id,
-        event: "conversation_closed",
-        status: "closed",
-        reason: closed.close_reason
-    });
-    runtimeLog("info", "conversation_closed", {
-        conversation_id: conversation.conversation_id,
-        status: "closed",
-        reason: closed.close_reason,
-        state_path: statePath,
-        event_log_path: logPath
-    });
-    printJson({
-        conversation: closed,
-        closed: true
-    });
+async function runClose(options) {
+    const loaded = loadConversationFromOptions(options);
+    const { statePath, logPath } = loaded;
+    const nativeTakeover = isRecord(loaded.conversation.native_session_takeover)
+        ? loaded.conversation.native_session_takeover
+        : undefined;
+    const terminalControl = terminalControlFromTakeover(nativeTakeover);
+    const releaseTerminalLock = terminalControl
+        ? acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 })
+        : () => { };
+    let releaseStateLock;
+    try {
+        releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        const conversation = loadState(statePath);
+        const now = new Date().toISOString();
+        const closed = {
+            ...conversation,
+            status: "closed",
+            closed_at: now,
+            close_reason: options.reason ?? "closed by request",
+            updated_at: now
+        };
+        saveState(statePath, closed);
+        releaseClaudeHookLease(closed);
+        appendEvent(logPath, {
+            ts: now,
+            conversation_id: conversation.conversation_id,
+            event: "conversation_closed",
+            status: "closed",
+            reason: closed.close_reason
+        });
+        runtimeLog("info", "conversation_closed", {
+            conversation_id: conversation.conversation_id,
+            status: "closed",
+            reason: closed.close_reason,
+            state_path: statePath,
+            event_log_path: logPath
+        });
+        printJson({
+            conversation: closed,
+            closed: true
+        });
+    }
+    finally {
+        try {
+            releaseStateLock?.();
+        }
+        finally {
+            releaseTerminalLock();
+        }
+    }
 }
 async function runMonitor(options) {
     if (options.callbackRetry) {
@@ -4383,45 +5626,66 @@ async function runMonitor(options) {
         sleepSync(pollIntervalMs);
     }
 }
-function startCallbackRetryMonitor({ statePath }) {
+function startCallbackRetryMonitor({ statePath, delayMs = CALLBACK_RETRY_DELAYS_MS[0] }) {
+    const normalizedDelayMs = Math.max(0, Number.isFinite(Number(delayMs)) ? Number(delayMs) : CALLBACK_RETRY_DELAYS_MS[0]);
     const child = spawn(process.execPath, [
         new URL(import.meta.url).pathname,
         "monitor",
         "--callback-retry",
         "--state",
-        statePath
+        statePath,
+        "--callback-retry-delay-ms",
+        String(normalizedDelayMs)
     ], {
         detached: true,
         stdio: "ignore",
         cwd: process.cwd(),
-        env: process.env
+        env: environmentWithoutGatewayTokens()
     });
     child.unref();
     return child;
 }
 function runCallbackRetryMonitor(options) {
     const statePath = expandHome(required(options.state, "--state is required"));
+    const initialDelayMs = Math.max(0, Number.isFinite(Number(options.callbackRetryDelayMs))
+        ? Number(options.callbackRetryDelayMs)
+        : CALLBACK_RETRY_DELAYS_MS[0]);
+    sleepSync(initialDelayMs);
     while (true) {
         const conversation = loadState(statePath);
         const callbackDelivery = isRecord(conversation.callback_delivery)
             ? conversation.callback_delivery
             : undefined;
         const attempts = Number(callbackDelivery?.attempts ?? 0);
-        if (conversation.status !== "callback_failed" || !isRecord(callbackDelivery?.message)) {
+        if (!["callback_pending", "callback_failed"].includes(conversation.status) ||
+            !["pending", "failed"].includes(String(callbackDelivery?.status ?? "")) ||
+            !isRecord(callbackDelivery?.message)) {
             return;
         }
         if (attempts > CALLBACK_RETRY_DELAYS_MS.length) {
             return;
         }
-        const delayMs = CALLBACK_RETRY_DELAYS_MS[Math.max(0, attempts - 1)];
-        sleepSync(delayMs);
-        const releaseLock = acquireFileLock(`${statePath}.lock`);
+        let releaseLock;
+        try {
+            releaseLock = acquireFileLock(`${statePath}.lock`);
+        }
+        catch (error) {
+            if (isRecord(error) && error.code === "LOCK_TIMEOUT") {
+                sleepSync(1000);
+                continue;
+            }
+            throw error;
+        }
         try {
             const current = loadState(statePath);
             const currentDelivery = isRecord(current.callback_delivery)
                 ? current.callback_delivery
                 : undefined;
-            if (current.status !== "callback_failed" || !isRecord(currentDelivery?.message)) {
+            const currentAttempts = Number(currentDelivery?.attempts ?? 0);
+            if (!["callback_pending", "callback_failed"].includes(current.status) ||
+                !["pending", "failed"].includes(String(currentDelivery?.status ?? "")) ||
+                !isRecord(currentDelivery?.message) ||
+                currentAttempts > CALLBACK_RETRY_DELAYS_MS.length) {
                 return;
             }
             try {
@@ -4447,13 +5711,62 @@ function runCallbackRetryMonitor(options) {
         finally {
             releaseLock();
         }
+        const latest = loadState(statePath);
+        const latestDelivery = isRecord(latest.callback_delivery)
+            ? latest.callback_delivery
+            : undefined;
+        const latestAttempts = Number(latestDelivery?.attempts ?? 0);
+        if (!["callback_pending", "callback_failed"].includes(latest.status) ||
+            !["pending", "failed"].includes(String(latestDelivery?.status ?? "")) ||
+            !isRecord(latestDelivery?.message) ||
+            latestAttempts > CALLBACK_RETRY_DELAYS_MS.length) {
+            return;
+        }
+        const delayMs = CALLBACK_RETRY_DELAYS_MS[Math.max(0, latestAttempts - 1)];
+        sleepSync(delayMs);
     }
 }
 async function runTerminalBridgeMonitor(options) {
+    const statePath = expandHome(required(options.state, "--state is required"));
+    const conversation = loadState(statePath);
+    const nativeTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const terminalMessageId = stringValue(nativeTakeover?.terminal_bridge_message_id) ?? "missing-message-id";
+    const monitorLock = tryAcquireTerminalBridgeMonitorLock(statePath, terminalMessageId);
+    if (!monitorLock.acquired) {
+        runtimeLog("info", "terminal_bridge_monitor_already_running", {
+            conversation_id: conversation.conversation_id,
+            terminal_bridge_message_id: terminalMessageId,
+            monitor_owner_pid: monitorLock.ownerPid
+        });
+        printJson({
+            conversation,
+            monitored: false,
+            terminal_bridge: true,
+            already_running: true,
+            reason: "terminal_bridge_monitor_already_running",
+            monitor_owner_pid: monitorLock.ownerPid ?? null
+        });
+        return;
+    }
+    try {
+        await runTerminalBridgeMonitorWithLock(options);
+    }
+    finally {
+        monitorLock.release();
+    }
+}
+async function runTerminalBridgeMonitorWithLock(options) {
     const statePath = expandHome(required(options.state, "--state is required"));
     const logPath = expandHome(options.log ?? logPathForStatePath(statePath));
     const pollIntervalMs = Math.max(50, Number(options.pollIntervalMs ?? DEFAULT_MONITOR_POLL_INTERVAL_MS));
-    let conversation = loadState(statePath);
+    let conversation = await migrateLegacyTerminalAgentIdentity({
+        conversation: loadState(statePath),
+        statePath,
+        logPath,
+        options
+    });
     const initialNativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined;
@@ -4587,6 +5900,25 @@ async function runTerminalBridgeMonitor(options) {
         });
         const terminalStatus = poll.status;
         const approval = terminalStatus.approval_state;
+        const currentScreenFingerprint = stringValue(terminalStatus?.screen?.digest) ??
+            terminalBridgeScreenFingerprint(terminalStatus?.screen?.excerpt);
+        const currentScreenChangedSinceSend = preSendScreenFingerprint !== undefined &&
+            currentScreenFingerprint !== undefined &&
+            currentScreenFingerprint !== preSendScreenFingerprint;
+        if (executor.kind === "claude" &&
+            isRecord(approval) &&
+            approval.approvable === true &&
+            approval.decision_mode === "keys" &&
+            !currentScreenChangedSinceSend) {
+            previousScreenFingerprint = currentScreenFingerprint;
+            runtimeLog("warn", "claude_screen_approval_not_new", {
+                conversation_id: conversation.conversation_id,
+                terminal_target: terminalControl.target,
+                reason: "permission screen is not proven to have changed since the managed send"
+            });
+            sleepSync(pollIntervalMs);
+            continue;
+        }
         if (isRecord(approval) && approval.blocked === true && approval.approvable !== true) {
             const approvalReason = stringValue(approval.reason) ??
                 "Claude Code permission state cannot be safely resolved through AKK";
@@ -4608,8 +5940,67 @@ async function runTerminalBridgeMonitor(options) {
                 logPath,
                 terminalControl,
                 terminalStatus,
-                fingerprint
+                fingerprint,
+                expectedConversation: {
+                    conversationId: conversation.conversation_id,
+                    status: conversation.status,
+                    updatedAt: conversation.updated_at,
+                    messageId: currentMessageId
+                },
+                onRecorded: (notificationConversation) => {
+                    const callbackMessage = createMessage({
+                        conversation: notificationConversation,
+                        from: executor.actor,
+                        to: "openclaw",
+                        type: "blocked",
+                        requiresResponse: true,
+                        body: [
+                            `${executor.display_name} is waiting at a permission state that AKK cannot safely approve.`,
+                            approvalReason,
+                            "",
+                            `Conversation: ${notificationConversation.conversation_id}`,
+                            `Terminal: ${terminalControl.target}`,
+                            "Review and resolve this dialog in the terminal manually. AKK intentionally sends no key when the request identity cannot be revalidated."
+                        ].join("\n"),
+                        metadata: {
+                            source: "terminal_bridge",
+                            reason: "approval_not_approvable",
+                            terminal_control: terminalControl,
+                            terminal_status: terminalStatus,
+                            approval_fingerprint: fingerprint
+                        }
+                    });
+                    if (notificationConversation.gateway_method) {
+                        runLockedCallback({
+                            ...options,
+                            statePath,
+                            log: logPath,
+                            messageJson: JSON.stringify(callbackMessage),
+                            gatewayMethod: notificationConversation.gateway_method,
+                            gatewaySession: notificationConversation.gateway_session,
+                            openclawSession: notificationConversation.openclaw_session,
+                            openclawBin: notificationConversation.openclaw_bin,
+                            gatewayUrl: stringValue(notificationConversation.gateway_token)
+                                ? notificationConversation.gateway_url
+                                : undefined,
+                            token: stringValue(notificationConversation.gateway_token)
+                        });
+                        return {
+                            callbackMessage,
+                            delivered: true
+                        };
+                    }
+                    return {
+                        callbackMessage,
+                        delivered: false
+                    };
+                }
             });
+            if (notification.stale) {
+                previousScreenFingerprint = currentScreenFingerprint;
+                sleepSync(pollIntervalMs);
+                continue;
+            }
             if (notification.duplicate) {
                 printJson({
                     conversation: notification.conversation,
@@ -4624,43 +6015,7 @@ async function runTerminalBridgeMonitor(options) {
                 });
                 return;
             }
-            const callbackMessage = createMessage({
-                conversation: notification.conversation,
-                from: executor.actor,
-                to: "openclaw",
-                type: "blocked",
-                requiresResponse: true,
-                body: [
-                    `${executor.display_name} is waiting at a permission state that AKK cannot safely approve.`,
-                    approvalReason,
-                    "",
-                    `Conversation: ${notification.conversation.conversation_id}`,
-                    `Terminal: ${terminalControl.target}`,
-                    "Review and resolve this dialog in the terminal manually. AKK intentionally sends no key when the request identity cannot be revalidated."
-                ].join("\n"),
-                metadata: {
-                    source: "terminal_bridge",
-                    reason: "approval_not_approvable",
-                    terminal_control: terminalControl,
-                    terminal_status: terminalStatus,
-                    approval_fingerprint: fingerprint
-                }
-            });
-            if (notification.conversation.gateway_method) {
-                runLockedCallback({
-                    ...options,
-                    statePath,
-                    log: logPath,
-                    messageJson: JSON.stringify(callbackMessage),
-                    gatewayMethod: notification.conversation.gateway_method,
-                    gatewaySession: notification.conversation.gateway_session,
-                    openclawSession: notification.conversation.openclaw_session,
-                    openclawBin: notification.conversation.openclaw_bin,
-                    gatewayUrl: stringValue(notification.conversation.gateway_token)
-                        ? notification.conversation.gateway_url
-                        : undefined,
-                    token: stringValue(notification.conversation.gateway_token)
-                });
+            if (notification.recorded?.delivered) {
                 return;
             }
             printJson({
@@ -4670,7 +6025,7 @@ async function runTerminalBridgeMonitor(options) {
                 awaiting_approval: true,
                 approvable: false,
                 delivered: false,
-                message: callbackMessage,
+                message: notification.recorded?.callbackMessage,
                 reason: "gateway_method_missing",
                 terminal_control: terminalControl,
                 terminal_status: terminalStatus
@@ -4693,8 +6048,74 @@ async function runTerminalBridgeMonitor(options) {
                 logPath,
                 terminalControl,
                 terminalStatus,
-                fingerprint
+                fingerprint,
+                expectedConversation: {
+                    conversationId: conversation.conversation_id,
+                    status: conversation.status,
+                    updatedAt: conversation.updated_at,
+                    messageId: currentMessageId
+                },
+                onRecorded: (notificationConversation) => {
+                    const callbackMessage = createMessage({
+                        conversation: notificationConversation,
+                        from: executor.actor,
+                        to: "openclaw",
+                        type: "question",
+                        requiresResponse: true,
+                        body: terminalBridgeApprovalInstructions({
+                            conversation: notificationConversation,
+                            terminalControl,
+                            terminalStatus
+                        }),
+                        metadata: {
+                            source: "terminal_bridge",
+                            reason: "approval_required",
+                            terminal_control: terminalControl,
+                            terminal_status: terminalStatus,
+                            approval_fingerprint: fingerprint,
+                            approval_candidate: terminalBridgeApprovalCandidate({
+                                executor,
+                                terminalControl,
+                                terminalStatus,
+                                fingerprint
+                            }),
+                            approve_command: `AKK approve ${notificationConversation.conversation_id} --expected-approval-fingerprint ${fingerprint}`,
+                            deny_command: `AKK cancel ${notificationConversation.conversation_id}`,
+                            approve_tool: "agent_knock_knock_approve",
+                            deny_tool: "agent_knock_knock_cancel"
+                        }
+                    });
+                    if (notificationConversation.gateway_method) {
+                        runLockedCallback({
+                            ...options,
+                            statePath,
+                            log: logPath,
+                            messageJson: JSON.stringify(callbackMessage),
+                            gatewayMethod: notificationConversation.gateway_method,
+                            gatewaySession: notificationConversation.gateway_session,
+                            openclawSession: notificationConversation.openclaw_session,
+                            openclawBin: notificationConversation.openclaw_bin,
+                            gatewayUrl: stringValue(notificationConversation.gateway_token)
+                                ? notificationConversation.gateway_url
+                                : undefined,
+                            token: stringValue(notificationConversation.gateway_token)
+                        });
+                        return {
+                            callbackMessage,
+                            delivered: true
+                        };
+                    }
+                    return {
+                        callbackMessage,
+                        delivered: false
+                    };
+                }
             });
+            if (notification.stale) {
+                previousScreenFingerprint = currentScreenFingerprint;
+                sleepSync(pollIntervalMs);
+                continue;
+            }
             if (notification.duplicate) {
                 printJson({
                     conversation: notification.conversation,
@@ -4707,48 +6128,7 @@ async function runTerminalBridgeMonitor(options) {
                 });
                 return;
             }
-            const callbackMessage = createMessage({
-                conversation: notification.conversation,
-                from: executor.actor,
-                to: "openclaw",
-                type: "question",
-                requiresResponse: true,
-                body: terminalBridgeApprovalInstructions({
-                    conversation: notification.conversation,
-                    terminalControl,
-                    terminalStatus
-                }),
-                metadata: {
-                    source: "terminal_bridge",
-                    reason: "approval_required",
-                    terminal_control: terminalControl,
-                    terminal_status: terminalStatus,
-                    approval_fingerprint: fingerprint,
-                    approval_candidate: terminalBridgeApprovalCandidate({
-                        executor,
-                        terminalControl,
-                        terminalStatus,
-                        fingerprint
-                    }),
-                    approve_command: `AKK approve ${notification.conversation.conversation_id} --expected-approval-fingerprint ${fingerprint}`,
-                    deny_command: `AKK cancel ${notification.conversation.conversation_id}`,
-                    approve_tool: "agent_knock_knock_approve",
-                    deny_tool: "agent_knock_knock_cancel"
-                }
-            });
-            if (notification.conversation.gateway_method) {
-                runLockedCallback({
-                    ...options,
-                    statePath,
-                    log: logPath,
-                    messageJson: JSON.stringify(callbackMessage),
-                    gatewayMethod: notification.conversation.gateway_method,
-                    gatewaySession: notification.conversation.gateway_session,
-                    openclawSession: notification.conversation.openclaw_session,
-                    openclawBin: notification.conversation.openclaw_bin,
-                    gatewayUrl: stringValue(notification.conversation.gateway_token) ? notification.conversation.gateway_url : undefined,
-                    token: stringValue(notification.conversation.gateway_token)
-                });
+            if (notification.recorded?.delivered) {
                 return;
             }
             printJson({
@@ -4757,14 +6137,14 @@ async function runTerminalBridgeMonitor(options) {
                 terminal_bridge: true,
                 awaiting_approval: true,
                 delivered: false,
-                message: callbackMessage,
+                message: notification.recorded?.callbackMessage,
                 reason: "gateway_method_missing",
                 terminal_control: terminalControl,
                 terminal_status: terminalStatus
             });
             return;
         }
-        const screenFingerprint = terminalBridgeScreenFingerprint(terminalStatus?.screen?.excerpt);
+        const screenFingerprint = currentScreenFingerprint;
         const screenChanged = previousScreenFingerprint !== undefined &&
             screenFingerprint !== undefined &&
             screenFingerprint !== previousScreenFingerprint;
@@ -5009,7 +6389,48 @@ function terminalBridgeScreenFingerprint(value) {
         ? createHash("sha256").update(value).digest("hex")
         : undefined;
 }
+function terminalBridgeMonitorLockPath(statePath, terminalMessageId) {
+    const messageKey = createHash("sha256")
+        .update(terminalMessageId)
+        .digest("hex")
+        .slice(0, 20);
+    return `${statePath}.terminal-bridge-monitor-${messageKey}.lock`;
+}
+function fileLockOwnerPid(lockPath) {
+    return readFileLockOwner(lockPath).pid;
+}
+function activeTerminalBridgeMonitorOwner(statePath, terminalMessageId) {
+    const lockPath = terminalBridgeMonitorLockPath(statePath, terminalMessageId);
+    if (!fs.existsSync(lockPath) || staleFileLock(lockPath)) {
+        return undefined;
+    }
+    return {
+        lockPath,
+        ownerPid: fileLockOwnerPid(lockPath)
+    };
+}
+function tryAcquireTerminalBridgeMonitorLock(statePath, terminalMessageId) {
+    const lockPath = terminalBridgeMonitorLockPath(statePath, terminalMessageId);
+    try {
+        return {
+            acquired: true,
+            lockPath,
+            release: acquireFileLock(lockPath, { timeoutMs: 0 })
+        };
+    }
+    catch (error) {
+        if (isRecord(error) && error.code === "LOCK_TIMEOUT") {
+            return {
+                acquired: false,
+                lockPath,
+                ownerPid: fileLockOwnerPid(lockPath)
+            };
+        }
+        throw error;
+    }
+}
 function terminalBridgeSendLockPath(storeDir, terminalControl) {
+    ensureDir(storeDir);
     const terminalKey = createHash("sha256")
         .update(JSON.stringify({
         target: terminalControl.target,
@@ -5216,7 +6637,7 @@ function terminalBridgeApprovalCandidate({ executor, terminalControl, terminalSt
         command: stringValue(approval.command),
         tool_name: stringValue(approval.tool_name),
         request_detail: stringValue(approval.request_detail),
-        cwd: terminalControl.currentPath,
+        cwd: stringValue(approval.cwd) ?? terminalControl.currentPath,
         fingerprint,
         terminal_target: terminalControl.target,
         decision_mode: stringValue(approval.decision_mode)
@@ -5318,6 +6739,11 @@ function resolveOptionalExecutable(command) {
 function packageRootDir() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 }
+function printVersion() {
+    const packageJsonPath = path.join(packageRootDir(), "package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    process.stdout.write(`${packageJson.version}\n`);
+}
 function runCheckedCommand(command, args, { label }) {
     const result = spawnSync(command, args, {
         encoding: "utf8",
@@ -5356,18 +6782,18 @@ function buildCallbackCommand({ statePath, gatewayUrl, token, openclawSession, g
         "--state",
         shellQuote(statePath)
     ];
-    if (token) {
-        parts.push("--gateway-url", shellQuote(gatewayUrl), "--token", shellQuote(token), "--openclaw-session", shellQuote(openclawSession));
-    }
-    else if (!gatewayMethod) {
-        parts.push("--record-only");
-    }
     if (gatewayMethod) {
         parts.push("--gateway-method", shellQuote(gatewayMethod), "--gateway-session", shellQuote(gatewaySession ?? openclawSession));
         if (openclawBin) {
             parts.push("--openclaw-bin", shellQuote(openclawBin));
         }
     }
+    else if (token) {
+        parts.push("--gateway-url", shellQuote(gatewayUrl), "--token", shellQuote(token), "--openclaw-session", shellQuote(openclawSession));
+    }
+    else {
+        parts.push("--record-only");
+    }
     parts.push("--message-json", "'<structured-message-json>'");
     return parts.join(" ");
 }
@@ -5490,6 +6916,18 @@ function runLockedCallback(options) {
         CONVERSATION_STATUSES.has(storedFinalStatus)
         ? storedFinalStatus
         : nextConversation.status;
+    const callbackRetryDelayMs = CALLBACK_RETRY_DELAYS_MS[Math.min(CALLBACK_RETRY_DELAYS_MS.length - 1, Math.max(0, deliveryAttempt - 1))];
+    const callbackWatchdog = trackCallbackDelivery &&
+        requiresDelivery &&
+        options.recordOnly !== true &&
+        !retryingPending &&
+        options.disableCallbackRetry !== true &&
+        deliveryAttempt <= CALLBACK_RETRY_DELAYS_MS.length
+        ? startCallbackRetryMonitor({
+            statePath: options.statePath,
+            delayMs: callbackRetryDelayMs
+        })
+        : undefined;
     if (!retryingPending && !recoveringTerminalCompletion) {
         appendEvent(logPath, messageEvent(message));
     }
@@ -5510,7 +6948,13 @@ function runLockedCallback(options) {
                 openclaw_bin: options.openclawBin ?? conversation.openclaw_bin,
                 close_terminal_bridge_on_done: closeTerminalBridgeOnDone,
                 track_delivery: true,
-                final_status: finalStatus
+                final_status: finalStatus,
+                ...(callbackWatchdog
+                    ? {
+                        retry_monitor_pid: callbackWatchdog.pid ?? null,
+                        next_attempt_at: new Date(Date.now() + callbackRetryDelayMs).toISOString()
+                    }
+                    : {})
             },
             updated_at: now
         };
@@ -5524,6 +6968,18 @@ function runLockedCallback(options) {
             message_id: message.id,
             attempt: deliveryAttempt
         });
+        if (callbackWatchdog) {
+            appendEvent(logPath, {
+                ts: new Date().toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "callback_retry_monitor_launched",
+                message_id: message.id,
+                pid: callbackWatchdog.pid ?? null,
+                next_attempt_at: isRecord(nextConversation.callback_delivery)
+                    ? nextConversation.callback_delivery.next_attempt_at
+                    : undefined
+            });
+        }
     }
     saveState(options.statePath, nextConversation);
     runtimeLog("info", "callback_received", {
@@ -5758,8 +7214,8 @@ function recordCallbackProcessDelivery({ logPath, conversation, message, event,
         round: message.round,
         ...detail,
         status: delivery.status,
-        stdout: delivery.stdout,
-        stderr: delivery.stderr
+        stdout: redactString(delivery.stdout),
+        stderr: redactString(delivery.stderr)
     });
     runtimeLog("info", runtimeEvent, {
         conversation_id: conversation.conversation_id,
@@ -5772,26 +7228,37 @@ function recordCallbackProcessDelivery({ logPath, conversation, message, event,
 }
 function acquireFileLock(lockPath, { timeoutMs = 5000, retryMs = 50 } = {}) {
     const started = Date.now();
+    const token = randomUUID();
     while (true) {
+        let fd;
         try {
-            const fd = fs.openSync(lockPath, "wx");
-            fs.writeFileSync(fd, `${process.pid}\n`, "utf8");
+            fd = fs.openSync(lockPath, fs.constants.O_CREAT |
+                fs.constants.O_EXCL |
+                fs.constants.O_WRONLY |
+                NO_FOLLOW_FLAG, PRIVATE_LOCK_FILE_MODE);
+            fs.fchmodSync(fd, PRIVATE_LOCK_FILE_MODE);
+            fs.writeFileSync(fd, `${JSON.stringify({
+                pid: process.pid,
+                token,
+                created_at: new Date().toISOString()
+            })}\n`, "utf8");
             fs.fsyncSync(fd);
             fs.closeSync(fd);
-            return () => {
-                fs.rmSync(lockPath, { force: true });
-            };
+            fd = undefined;
+            return () => releaseFileLock(lockPath, token);
         }
         catch (error) {
-            if (error.code !== "EEXIST") {
+            if (fd !== undefined) {
+                fs.closeSync(fd);
+            }
+            if (!isRecord(error) || error.code !== "EEXIST") {
                 throw error;
             }
-            if (staleFileLock(lockPath)) {
-                fs.rmSync(lockPath, { force: true });
+            if (reclaimStaleFileLock(lockPath)) {
                 continue;
             }
             if (Date.now() - started >= timeoutMs) {
-                throw new Error(`timed out waiting for file lock: ${lockPath}`);
+                throw Object.assign(new Error(`timed out waiting for file lock: ${lockPath}`), { code: "LOCK_TIMEOUT" });
             }
             sleepSync(retryMs);
         }
@@ -5799,12 +7266,14 @@ function acquireFileLock(lockPath, { timeoutMs = 5000, retryMs = 50 } = {}) {
 }
 function staleFileLock(lockPath) {
     try {
-        const stat = fs.statSync(lockPath);
-        const ownerText = fs.readFileSync(lockPath, "utf8").trim();
-        const ownerPid = Number(ownerText);
-        if (Number.isSafeInteger(ownerPid) && ownerPid > 1) {
+        const stat = fs.lstatSync(lockPath);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error(`file lock must be a regular file, not a symlink: ${lockPath}`);
+        }
+        const owner = readFileLockOwner(lockPath);
+        if (owner.pid !== undefined) {
             try {
-                process.kill(ownerPid, 0);
+                process.kill(owner.pid, 0);
                 return false;
             }
             catch (error) {
@@ -5817,6 +7286,91 @@ function staleFileLock(lockPath) {
         return isRecord(error) && error.code === "ENOENT";
     }
 }
+function reclaimStaleFileLock(lockPath) {
+    const reclaimPath = `${lockPath}.reclaim`;
+    let reclaimFd;
+    try {
+        reclaimFd = fs.openSync(reclaimPath, fs.constants.O_CREAT |
+            fs.constants.O_EXCL |
+            fs.constants.O_WRONLY |
+            NO_FOLLOW_FLAG, PRIVATE_LOCK_FILE_MODE);
+        fs.fchmodSync(reclaimFd, PRIVATE_LOCK_FILE_MODE);
+        fs.writeFileSync(reclaimFd, `${process.pid}\n`, "utf8");
+        fs.fsyncSync(reclaimFd);
+    }
+    catch (error) {
+        if (reclaimFd !== undefined) {
+            fs.closeSync(reclaimFd);
+        }
+        if (isRecord(error) && error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+    try {
+        if (!staleFileLock(lockPath)) {
+            return false;
+        }
+        try {
+            fs.unlinkSync(lockPath);
+            return true;
+        }
+        catch (error) {
+            return isRecord(error) && error.code === "ENOENT";
+        }
+    }
+    finally {
+        fs.closeSync(reclaimFd);
+        try {
+            fs.unlinkSync(reclaimPath);
+        }
+        catch (error) {
+            if (!isRecord(error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+}
+function releaseFileLock(lockPath, token) {
+    try {
+        if (readFileLockOwner(lockPath).token !== token) {
+            return;
+        }
+        fs.unlinkSync(lockPath);
+    }
+    catch (error) {
+        if (!isRecord(error) || error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+function readFileLockOwner(lockPath) {
+    try {
+        const text = fs.readFileSync(lockPath, "utf8").trim();
+        try {
+            const owner = JSON.parse(text);
+            if (isRecord(owner)) {
+                const pid = Number(owner.pid);
+                return {
+                    pid: Number.isSafeInteger(pid) && pid > 1 ? pid : undefined,
+                    token: stringValue(owner.token)
+                };
+            }
+        }
+        catch {
+            // Legacy locks contained only the owner PID.
+        }
+        const legacyPid = Number(text);
+        return {
+            pid: Number.isSafeInteger(legacyPid) && legacyPid > 1
+                ? legacyPid
+                : undefined
+        };
+    }
+    catch {
+        return {};
+    }
+}
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -6594,8 +8148,8 @@ function deliverStalledNotification({ statePath, logPath, conversation, message,
         method: conversation.gateway_method,
         message_id: message.id,
         status: delivery.status,
-        stdout: delivery.stdout,
-        stderr: delivery.stderr
+        stdout: redactString(delivery.stdout),
+        stderr: redactString(delivery.stderr)
     });
     runtimeLog("info", `${eventPrefix}_gateway_method_delivery`, {
         conversation_id: conversation.conversation_id,
@@ -6626,8 +8180,8 @@ function deliverStalledNotification({ statePath, logPath, conversation, message,
         event: `${eventPrefix}_chat_send_delivery`,
         message_id: message.id,
         status: chatSendDelivery.status,
-        stdout: chatSendDelivery.stdout,
-        stderr: chatSendDelivery.stderr
+        stdout: redactString(chatSendDelivery.stdout),
+        stderr: redactString(chatSendDelivery.stderr)
     });
     runtimeLog("info", `${eventPrefix}_chat_send_delivery`, {
         conversation_id: conversation.conversation_id,
@@ -6653,54 +8207,84 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
     }
     const conversations = listConversations(storeDir);
     let closed = 0;
-    for (const conversation of conversations) {
-        if (conversation.status !== "idle" || !conversation.idle_since) {
+    for (const listedConversation of conversations) {
+        if (listedConversation.status !== "idle" || !listedConversation.idle_since) {
             continue;
         }
-        const idleSinceMs = Date.parse(conversation.idle_since);
-        if (!Number.isFinite(idleSinceMs)) {
+        const listedIdleSinceMs = Date.parse(listedConversation.idle_since);
+        if (!Number.isFinite(listedIdleSinceMs)) {
             continue;
         }
-        const terminalBridge = terminalBridgeEnabled(conversation) &&
-            isRecord(conversation.native_session_takeover) &&
-            typeof conversation.native_session_takeover.terminal_bridge_message_id === "string";
-        if (!terminalBridge && now.getTime() - idleSinceMs < timeoutMinutes * 60 * 1000) {
+        const listedTerminalBridge = terminalBridgeEnabled(listedConversation) &&
+            isRecord(listedConversation.native_session_takeover) &&
+            typeof listedConversation.native_session_takeover.terminal_bridge_message_id === "string";
+        if (!listedTerminalBridge && now.getTime() - listedIdleSinceMs < timeoutMinutes * 60 * 1000) {
             continue;
         }
-        const statePath = conversation.state_path ?? statePathForConversationId(conversation.conversation_id, storeDir);
-        const logPath = conversation.event_log_path ?? logPathForStatePath(statePath);
-        const closeReason = terminalBridge
-            ? "terminal bridge task completed"
-            : `idle timeout after ${timeoutMinutes} minutes`;
-        const closedConversation = {
-            ...conversation,
-            status: "closed",
-            closed_at: now.toISOString(),
-            close_reason: closeReason,
-            updated_at: now.toISOString()
-        };
-        delete closedConversation.idle_since;
-        saveState(statePath, closedConversation);
-        appendEvent(logPath, {
-            ts: now.toISOString(),
-            conversation_id: conversation.conversation_id,
-            event: "conversation_closed",
-            status: "closed",
-            reason: closedConversation.close_reason,
-            idle_timeout_minutes: timeoutMinutes,
-            terminal_bridge: terminalBridge
-        });
-        runtimeLog("info", "idle_conversation_closed", {
-            conversation_id: conversation.conversation_id,
-            agent: executorForConversation(conversation).kind,
-            executor_session: executorForConversation(conversation).session,
-            state_path: statePath,
-            event_log_path: logPath,
-            idle_since: conversation.idle_since,
-            idle_timeout_minutes: timeoutMinutes,
-            reason: closedConversation.close_reason
-        });
-        closed += 1;
+        const statePath = listedConversation.state_path ??
+            statePathForConversationId(listedConversation.conversation_id, storeDir);
+        let releaseStateLock;
+        try {
+            releaseStateLock = acquireFileLock(`${statePath}.lock`);
+        }
+        catch (error) {
+            if (isRecord(error) && error.code === "LOCK_TIMEOUT") {
+                continue;
+            }
+            throw error;
+        }
+        try {
+            const conversation = loadState(statePath);
+            if (conversation.status !== "idle" || !conversation.idle_since) {
+                continue;
+            }
+            const idleSinceMs = Date.parse(conversation.idle_since);
+            if (!Number.isFinite(idleSinceMs)) {
+                continue;
+            }
+            const terminalBridge = terminalBridgeEnabled(conversation) &&
+                isRecord(conversation.native_session_takeover) &&
+                typeof conversation.native_session_takeover.terminal_bridge_message_id === "string";
+            if (!terminalBridge && now.getTime() - idleSinceMs < timeoutMinutes * 60 * 1000) {
+                continue;
+            }
+            const logPath = conversation.event_log_path ?? logPathForStatePath(statePath);
+            const closeReason = terminalBridge
+                ? "terminal bridge task completed"
+                : `idle timeout after ${timeoutMinutes} minutes`;
+            const closedConversation = {
+                ...conversation,
+                status: "closed",
+                closed_at: now.toISOString(),
+                close_reason: closeReason,
+                updated_at: now.toISOString()
+            };
+            delete closedConversation.idle_since;
+            saveState(statePath, closedConversation);
+            appendEvent(logPath, {
+                ts: now.toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "conversation_closed",
+                status: "closed",
+                reason: closedConversation.close_reason,
+                idle_timeout_minutes: timeoutMinutes,
+                terminal_bridge: terminalBridge
+            });
+            runtimeLog("info", "idle_conversation_closed", {
+                conversation_id: conversation.conversation_id,
+                agent: executorForConversation(conversation).kind,
+                executor_session: executorForConversation(conversation).session,
+                state_path: statePath,
+                event_log_path: logPath,
+                idle_since: conversation.idle_since,
+                idle_timeout_minutes: timeoutMinutes,
+                reason: closedConversation.close_reason
+            });
+            closed += 1;
+        }
+        finally {
+            releaseStateLock();
+        }
     }
     return {
         checked: conversations.length,
@@ -6731,10 +8315,13 @@ function messageFingerprint(message) {
     });
 }
 function deliverToOpenClaw({ gatewayUrl, token, openclawSession, message }) {
-    const agent = `openclaw acp --url ${gatewayUrl} --token ${token} --session ${openclawSession}`;
+    const agent = `openclaw acp --url ${gatewayUrl} --session ${openclawSession}`;
     const result = spawnSync("acpx", ["--agent", agent, JSON.stringify(message)], {
         encoding: "utf8",
-        maxBuffer: 1024 * 1024 * 10
+        maxBuffer: 1024 * 1024 * 10,
+        timeout: CALLBACK_DELIVERY_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+        env: openClawGatewayEnvironment(token)
     });
     if (result.error) {
         return {
@@ -6759,7 +8346,7 @@ function deliverToGatewayMethod({ method, openclawBin, gatewayUrl, token, sessio
             sessionKey,
             statePath,
             logPath,
-            conversation,
+            conversation: redactCliOutput(conversation),
             message
         }),
         "--json"
@@ -6767,12 +8354,12 @@ function deliverToGatewayMethod({ method, openclawBin, gatewayUrl, token, sessio
     if (gatewayUrl) {
         args.push("--url", gatewayUrl);
     }
-    if (token && token !== "<token>") {
-        args.push("--token", token);
-    }
     const result = spawnSync(openclawBin ?? "openclaw", args, {
         encoding: "utf8",
-        maxBuffer: 1024 * 1024 * 10
+        maxBuffer: 1024 * 1024 * 10,
+        timeout: CALLBACK_DELIVERY_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+        env: openClawGatewayEnvironment(token)
     });
     if (result.error) {
         return {
@@ -6799,12 +8386,12 @@ function deliverToSessionSend({ openclawBin, gatewayUrl, token, params }) {
     if (gatewayUrl) {
         args.push("--url", gatewayUrl);
     }
-    if (token && token !== "<token>") {
-        args.push("--token", token);
-    }
     const result = spawnSync(openclawBin ?? "openclaw", args, {
         encoding: "utf8",
-        maxBuffer: 1024 * 1024 * 10
+        maxBuffer: 1024 * 1024 * 10,
+        timeout: CALLBACK_DELIVERY_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+        env: openClawGatewayEnvironment(token)
     });
     if (result.error) {
         return {
@@ -6831,12 +8418,12 @@ function deliverToChatSend({ openclawBin, gatewayUrl, token, params }) {
     if (gatewayUrl) {
         args.push("--url", gatewayUrl);
     }
-    if (token && token !== "<token>") {
-        args.push("--token", token);
-    }
     const result = spawnSync(openclawBin ?? "openclaw", args, {
         encoding: "utf8",
-        maxBuffer: 1024 * 1024 * 10
+        maxBuffer: 1024 * 1024 * 10,
+        timeout: CALLBACK_DELIVERY_TIMEOUT_MS,
+        killSignal: "SIGKILL",
+        env: openClawGatewayEnvironment(token)
     });
     if (result.error) {
         return {
@@ -6851,6 +8438,15 @@ function deliverToChatSend({ openclawBin, gatewayUrl, token, params }) {
         stderr: result.stderr ?? ""
     };
 }
+function openClawGatewayEnvironment(token) {
+    if (!token || token === "<token>") {
+        return process.env;
+    }
+    return {
+        ...process.env,
+        OPENCLAW_GATEWAY_TOKEN: token
+    };
+}
 function captureJson(argv) {
     const result = spawnSync(process.execPath, [new URL(import.meta.url).pathname, ...argv], {
         encoding: "utf8"
@@ -6938,7 +8534,30 @@ function expandHome(filePath) {
     return filePath;
 }
 function printJson(value) {
-    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    process.stdout.write(`${JSON.stringify(redactCliOutput(value), null, 2)}\n`);
+}
+function redactCliOutput(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redactCliOutput(item));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).flatMap(([key, item]) => {
+            if (key === "gateway_token" || key === "gatewayToken") {
+                return [];
+            }
+            if (key === "claude_transcript_anchor" ||
+                key === "claudeTranscriptAnchor" ||
+                key === "claude_home" ||
+                key === "claudeHome") {
+                return [];
+            }
+            if ((key === "callback_command" || key === "callbackCommand") && typeof item === "string") {
+                return [[key, redactString(item)]];
+            }
+            return [[key, redactCliOutput(item)]];
+        }));
+    }
+    return value;
 }
 function cleanProcessText(text) {
     const value = String(text ?? "").trim();
@@ -7004,6 +8623,24 @@ function readOutputTail(outputPath, maxBytes = 65536) {
         return "";
     }
 }
+function openPrivateAppendFile(filePath) {
+    if (fs.existsSync(filePath) && fs.lstatSync(filePath).isSymbolicLink()) {
+        throw new Error(`refusing agent output symlink: ${filePath}`);
+    }
+    const noFollow = typeof fs.constants.O_NOFOLLOW === "number"
+        ? fs.constants.O_NOFOLLOW
+        : 0;
+    const descriptor = fs.openSync(filePath, fs.constants.O_CREAT |
+        fs.constants.O_APPEND |
+        fs.constants.O_WRONLY |
+        noFollow, 0o600);
+    if (!fs.fstatSync(descriptor).isFile()) {
+        fs.closeSync(descriptor);
+        throw new Error(`agent output must be a regular file: ${filePath}`);
+    }
+    fs.fchmodSync(descriptor, 0o600);
+    return descriptor;
+}
 function detectModelSelectionError(text) {
     const cleaned = cleanProcessText(text);
     if (!cleaned) {
@@ -7077,6 +8714,8 @@ function withStoragePaths(conversation, paths) {
 function usage() {
     const agentList = EXECUTOR_KINDS.join("|");
     process.stdout.write(`Usage:
+  agent-knock-knock --help
+  agent-knock-knock --version
   agent-knock-knock new --request <text> [--agent ${agentList}] [--workspace <path>] [--store-dir <dir>]
   agent-knock-knock record --state <file> --message-json <json>
   agent-knock-knock bootstrap-prompt --callback-command <command> [--agent ${agentList}]
@@ -7088,11 +8727,11 @@ function usage() {
   agent-knock-knock approve --conversation <id>
   agent-knock-knock cancel --conversation <id> [--all-proxy <url>]
   agent-knock-knock renew --conversation <id> [--minutes <inactivity-minutes>]
+  agent-knock-knock reconcile-monitors [--store-dir <dir>]
   agent-knock-knock retry-callback --conversation <id> [--store-dir <dir>]
   agent-knock-knock recover --conversation <id> [--session <name>] [--all-proxy <url>]
   agent-knock-knock close --conversation <id> [--reason <text>]
   agent-knock-knock install-openclaw [--openclaw-bin <path>] [--skill-path <path>] [--skill-only] [--no-restart]
-  agent-knock-knock install-claude-hooks [--settings-path <path>] [--executable-path <path>] [--dry-run]
   agent-knock-knock doctor
   agent-knock-knock agent takeover --agent codex --session-id <id> --strategy terminate_then_resume|terminal_control|fork [--create-conversation]
   agent-knock-knock callback --state <file> --message-json <json> [--record-only]