@scotthuang/agent-knock-knock 0.2.42 → 0.2.43

package/dist/src/cli.js

@@ -17,6 +17,7 @@ import { planFork, planTakeover } from "./session-takeover-planner.js";
 import { StaticTerminalControlProvider, TmuxTerminalControlProvider, enrichActiveProcessesWithTerminalControl, terminalRefFromPane } from "./terminal-control-provider.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 DEFAULT_CODEX_ACPX_AGENT_COMMAND = "npx -y @agentclientprotocol/codex-acp@^1.1.0";
 class InlineCodexSessionAdapter {
@@ -105,6 +106,9 @@ async function runCommand(commandName, options) {
     else if (commandName === "cancel") {
         await runCancel(options);
     }
+    else if (commandName === "renew") {
+        await runRenew(options);
+    }
     else if (commandName === "recover") {
         runRecover(options);
     }
@@ -772,13 +776,13 @@ function isCodexWorkingLine(line) {
     if (!trimmed) {
         return false;
     }
-    if (/^•\s+Working\b/u.test(trimmed)) {
+    if (/^•\s+Working\b/u.test(trimmed) && (/\besc to interrupt\b/u.test(trimmed) || trimmed === "• Working")) {
         return true;
     }
-    if (/\besc to interrupt\b/u.test(trimmed) && (/\bWorking\b/u.test(trimmed) || /\b\/stop to close\b/u.test(trimmed))) {
+    if (/^•\s+Waiting for background terminals?\b(?:\s*·|$)/u.test(trimmed)) {
         return true;
     }
-    return /\bbackground terminal running\b/u.test(trimmed);
+    return /^\d+\s+background terminals? running\b/u.test(trimmed) && /\/(?:ps|stop)\b/u.test(trimmed);
 }
 function isCodexIdlePromptLine(line) {
     const trimmed = line.trim();
@@ -1330,7 +1334,7 @@ function startExecutorMonitor({ statePath, logPath, pid, outputPath, agentTimeou
     child.unref();
     return child;
 }
-function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, pollIntervalMs, codexHome }) {
+function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, agentHardTimeoutMinutes, pollIntervalMs, codexHome }) {
     const args = [
         new URL(import.meta.url).pathname,
         "monitor",
@@ -1341,6 +1345,8 @@ function startTerminalBridgeMonitor({ statePath, logPath, agentTimeoutMinutes, p
         logPath,
         "--agent-timeout-minutes",
         String(agentTimeoutMinutes),
+        "--agent-hard-timeout-minutes",
+        String(agentHardTimeoutMinutes),
         "--poll-interval-ms",
         String(pollIntervalMs)
     ];
@@ -1360,10 +1366,18 @@ function startTerminalBridgeMonitorForConversation({ conversation, statePath, lo
     if (!terminalBridgeEnabled(conversation) || !conversation.gateway_method || options.disableTerminalBridgeMonitor === true) {
         return undefined;
     }
+    const nativeTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
     return startTerminalBridgeMonitor({
         statePath,
         logPath,
-        agentTimeoutMinutes: Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES),
+        agentTimeoutMinutes: Number(options.agentTimeoutMinutes ??
+            nativeTakeover?.["terminal_bridge_inactivity_timeout_minutes"] ??
+            DEFAULT_AGENT_TIMEOUT_MINUTES),
+        agentHardTimeoutMinutes: Number(options.agentHardTimeoutMinutes ??
+            nativeTakeover?.["terminal_bridge_hard_timeout_minutes"] ??
+            DEFAULT_AGENT_HARD_TIMEOUT_MINUTES),
         pollIntervalMs: Number(options.monitorPollIntervalMs ?? DEFAULT_MONITOR_POLL_INTERVAL_MS),
         codexHome: options.codexHome
     });
@@ -1374,7 +1388,7 @@ function terminalBridgeEnabled(conversation) {
         : undefined;
     return nativeTakeover?.["terminal_bridge"] === true;
 }
-function withTerminalBridgeState({ conversation, message, startedAt }) {
+function withTerminalBridgeState({ conversation, message, startedAt, agentTimeoutMinutes, agentHardTimeoutMinutes, preSendScreenFingerprint }) {
     const nativeTakeover = isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : {};
@@ -1384,7 +1398,16 @@ function withTerminalBridgeState({ conversation, message, startedAt }) {
             ...nativeTakeover,
             terminal_bridge: true,
             terminal_bridge_started_at: startedAt,
-            terminal_bridge_message_id: message.id
+            terminal_bridge_message_id: message.id,
+            terminal_bridge_request_text: String(message.body ?? ""),
+            terminal_bridge_request_hash: terminalBridgeRequestFingerprint(message.body),
+            terminal_bridge_pre_send_screen_fingerprint: preSendScreenFingerprint,
+            terminal_bridge_monitor_started_at: startedAt,
+            terminal_bridge_last_activity_at: startedAt,
+            terminal_bridge_inactivity_timeout_minutes: agentTimeoutMinutes,
+            terminal_bridge_hard_timeout_minutes: agentHardTimeoutMinutes,
+            terminal_bridge_inactivity_deadline_at: deadlineAt(startedAt, agentTimeoutMinutes),
+            terminal_bridge_hard_deadline_at: deadlineAt(startedAt, agentHardTimeoutMinutes)
         },
         updated_at: startedAt
     };
@@ -2033,6 +2056,9 @@ function recordTerminalBridgeApprovalNotification({ statePath, logPath, terminal
 }
 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) {
@@ -2523,17 +2549,31 @@ async function runApprove(options) {
     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: new Date().toISOString()
+        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)
     };
     delete nextNativeTakeover.terminal_bridge_approval;
     const nextConversation = {
         ...conversation,
         status: terminalBridgeEnabled(conversation) ? "waiting_for_agent" : conversation.status,
         native_session_takeover: nextNativeTakeover,
-        updated_at: new Date().toISOString()
+        updated_at: approvalResolvedAt
     };
     saveState(statePath, nextConversation);
     const bridgeMonitor = startTerminalBridgeMonitorForConversation({
@@ -2550,7 +2590,8 @@ async function runApprove(options) {
             pid: bridgeMonitor.pid ?? null,
             terminal_control: terminalControl,
             reason: "approval_resolved",
-            agent_timeout_minutes: Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES)
+            agent_timeout_minutes: agentTimeoutMinutes,
+            agent_hard_timeout_minutes: agentHardTimeoutMinutes
         });
         runtimeLog("info", "terminal_bridge_monitor_launch", {
             conversation_id: conversation.conversation_id,
@@ -2640,10 +2681,32 @@ async function runTerminalConversationSend({ options, conversationId, messageBod
         })
     });
 }
-async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, needsNativeTakeoverBootstrap }) {
-    const provider = createTerminalControlProvider(options);
+async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, needsNativeTakeoverBootstrap, terminalSendLockHeld = false }) {
     const bridge = terminalBridgeEnabled(conversation);
+    if (bridge && !terminalSendLockHeld) {
+        const releaseTerminalLock = acquireFileLock(terminalBridgeSendLockPath(storeDirFromOptions(options), terminalControl), { timeoutMs: 30000 });
+        try {
+            return await runTerminalControlSend({
+                options,
+                conversation,
+                nextConversation,
+                statePath,
+                logPath,
+                executor,
+                message,
+                terminalControl,
+                needsNativeTakeoverBootstrap,
+                terminalSendLockHeld: true
+            });
+        }
+        finally {
+            releaseTerminalLock();
+        }
+    }
+    const provider = createTerminalControlProvider(options);
     const bridgeStartedAt = new Date().toISOString();
+    const agentTimeoutMinutes = Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES);
+    const agentHardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ?? DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
     const terminalPayload = needsNativeTakeoverBootstrap && !bridge
         ? terminalSubmissionPayload(buildAgentSendPayload({
             conversation,
@@ -2654,12 +2717,32 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             forkTakeover: undefined
         }))
         : terminalSubmissionPayload(String(message.body ?? ""));
+    let preSendScreenFingerprint;
+    if (bridge) {
+        try {
+            const screen = await provider.capture(terminalControl.target, {
+                scrollbackLines: Number(options.scrollbackLines ?? 120),
+                socketPath: terminalControl.socketPath
+            });
+            preSendScreenFingerprint = terminalBridgeScreenFingerprint(screenExcerpt(screen));
+        }
+        catch {
+            // Delivery can still succeed when capture is unavailable; prompt matching remains the fallback boundary.
+        }
+    }
     await provider.sendText(terminalControl.target, terminalPayload, {
         socketPath: terminalControl.socketPath
     });
     await provider.sendKeys(terminalControl.target, ["C-m"], {
         socketPath: terminalControl.socketPath
     });
+    const supersededConversationIds = bridge
+        ? supersedeTerminalBridgeConversations({
+            storeDir: storeDirFromOptions(options),
+            terminalControl,
+            replacementConversationId: conversation.conversation_id
+        })
+        : [];
     appendEvent(logPath, {
         ts: new Date().toISOString(),
         conversation_id: conversation.conversation_id,
@@ -2667,20 +2750,25 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         executor,
         terminal_control: terminalControl,
         message: textSummary(message.body),
-        payload: textSummary(terminalPayload)
+        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)
+        payload: textSummary(terminalPayload),
+        superseded_conversation_ids: supersededConversationIds
     });
     const bridgeConversation = bridge
         ? withTerminalBridgeState({
             conversation: nextConversation,
             message,
-            startedAt: bridgeStartedAt
+            startedAt: bridgeStartedAt,
+            agentTimeoutMinutes,
+            agentHardTimeoutMinutes,
+            preSendScreenFingerprint
         })
         : nextConversation;
     const deliveredConversation = markTakeoverBootstrapped({
@@ -2707,7 +2795,8 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
             event: "terminal_bridge_monitor_launch",
             pid: bridgeMonitor.pid ?? null,
             terminal_control: terminalControl,
-            agent_timeout_minutes: Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES)
+            agent_timeout_minutes: agentTimeoutMinutes,
+            agent_hard_timeout_minutes: agentHardTimeoutMinutes
         });
         runtimeLog("info", "terminal_bridge_monitor_launch", {
             conversation_id: deliveredConversation.conversation_id,
@@ -2844,6 +2933,72 @@ function createManagedTerminalConversationFromRawId({ options, conversationId, m
         message
     };
 }
+function supersedeTerminalBridgeConversations({ storeDir, terminalControl, replacementConversationId }) {
+    const activeStatuses = new Set([
+        "created",
+        "running",
+        "waiting_for_agent",
+        "waiting_for_openclaw",
+        "stalled",
+        "cancelling"
+    ]);
+    const superseded = [];
+    for (const candidate of listConversations(storeDir)) {
+        if (candidate.conversation_id === replacementConversationId || !activeStatuses.has(candidate.status)) {
+            continue;
+        }
+        const candidateTakeover = isRecord(candidate.native_session_takeover)
+            ? candidate.native_session_takeover
+            : undefined;
+        const candidateControl = terminalControlFromTakeover(candidateTakeover);
+        if (candidateTakeover?.["terminal_bridge"] !== true ||
+            candidateControl?.target !== terminalControl.target ||
+            candidateControl?.socketPath !== terminalControl.socketPath) {
+            continue;
+        }
+        const candidateStatePath = stringValue(candidate.state_path);
+        if (!candidateStatePath) {
+            continue;
+        }
+        const releaseLock = acquireFileLock(`${candidateStatePath}.lock`);
+        try {
+            const current = loadState(candidateStatePath);
+            if (!activeStatuses.has(current.status)) {
+                continue;
+            }
+            const currentTakeover = isRecord(current.native_session_takeover)
+                ? current.native_session_takeover
+                : undefined;
+            const currentControl = terminalControlFromTakeover(currentTakeover);
+            if (currentTakeover?.["terminal_bridge"] !== true ||
+                currentControl?.target !== terminalControl.target ||
+                currentControl?.socketPath !== terminalControl.socketPath) {
+                continue;
+            }
+            const now = new Date().toISOString();
+            saveState(candidateStatePath, {
+                ...current,
+                status: "closed",
+                closed_at: now,
+                close_reason: "terminal bridge superseded by a newer task on the same terminal",
+                superseded_by_conversation_id: replacementConversationId,
+                updated_at: now
+            });
+            appendEvent(logPathForStatePath(candidateStatePath), {
+                ts: now,
+                conversation_id: current.conversation_id,
+                event: "terminal_bridge_superseded",
+                terminal_control: terminalControl,
+                replacement_conversation_id: replacementConversationId
+            });
+            superseded.push(current.conversation_id);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    return superseded;
+}
 function runNativeCodexResumeSend({ options, conversation, nextConversation, statePath, logPath, executor, executorEnv, message, payload, nativeTakeover, needsNativeTakeoverBootstrap }) {
     const codexPath = resolveExecutable("codex");
     const nativeSessionId = String(nativeTakeover["native_session_id"]);
@@ -3225,6 +3380,113 @@ function markConversationNeedsRecovery({ conversation, statePath, logPath, execu
         budget: budgetAction(nextConversation)
     };
 }
+async function runRenew(options) {
+    const { conversation, statePath, logPath } = loadConversationFromOptions(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`);
+    }
+    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 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`);
+    }
+    const now = new Date().toISOString();
+    const renewed = {
+        ...conversation,
+        status: "waiting_for_agent",
+        native_session_takeover: {
+            ...nativeTakeover,
+            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: deadlineAt(now, inactivityTimeoutMinutes),
+            terminal_bridge_hard_deadline_at: deadlineAt(startedAt ?? now, hardTimeoutMinutes),
+            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: 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
+        }
+    });
+    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
+        });
+    }
+    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);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`${optionName} must be a positive number`);
+    }
+    return parsed;
+}
 async function runCancel(options) {
     cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
@@ -3694,9 +3956,27 @@ async function runMonitor(options) {
 async function runTerminalBridgeMonitor(options) {
     const statePath = expandHome(required(options.state, "--state is required"));
     const logPath = expandHome(options.log ?? logPathForStatePath(statePath));
-    const timeoutMinutes = Number(options.agentTimeoutMinutes ?? DEFAULT_AGENT_TIMEOUT_MINUTES);
     const pollIntervalMs = Math.max(50, Number(options.pollIntervalMs ?? DEFAULT_MONITOR_POLL_INTERVAL_MS));
     let conversation = loadState(statePath);
+    const initialNativeTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const timeoutMinutes = Number(options.agentTimeoutMinutes ??
+        initialNativeTakeover?.["terminal_bridge_inactivity_timeout_minutes"] ??
+        DEFAULT_AGENT_TIMEOUT_MINUTES);
+    const hardTimeoutMinutes = positiveMinutes(options.agentHardTimeoutMinutes ??
+        initialNativeTakeover?.["terminal_bridge_hard_timeout_minutes"] ??
+        DEFAULT_AGENT_HARD_TIMEOUT_MINUTES, "--agent-hard-timeout-minutes");
+    const monitorStartedAtMs = Date.now();
+    const monitorMessageId = stringValue(initialNativeTakeover?.["terminal_bridge_message_id"]);
+    const taskStartedAtMs = validTimestampMs(initialNativeTakeover?.["terminal_bridge_started_at"]) ?? monitorStartedAtMs;
+    let lastActivityAtMs = validTimestampMs(initialNativeTakeover?.["terminal_bridge_last_activity_at"]) ?? taskStartedAtMs;
+    let lastPersistedActivityAtMs = lastActivityAtMs;
+    const activityPersistIntervalMs = terminalBridgeActivityPersistIntervalMs(timeoutMinutes, pollIntervalMs);
+    const preSendScreenFingerprint = stringValue(initialNativeTakeover?.["terminal_bridge_pre_send_screen_fingerprint"]);
+    let previousScreenFingerprint = preSendScreenFingerprint;
+    let previousRolloutFingerprint;
+    let persistedActivityReason = stringValue(initialNativeTakeover?.["terminal_bridge_last_activity_reason"]);
     const executor = executorForConversation(conversation);
     appendEvent(logPath, {
         ts: new Date().toISOString(),
@@ -3704,13 +3984,23 @@ async function runTerminalBridgeMonitor(options) {
         event: "terminal_bridge_monitor_started",
         executor,
         agent_timeout_minutes: timeoutMinutes,
-        poll_interval_ms: pollIntervalMs
+        agent_hard_timeout_minutes: hardTimeoutMinutes,
+        poll_interval_ms: pollIntervalMs,
+        task_started_at: new Date(taskStartedAtMs).toISOString(),
+        last_activity_at: new Date(lastActivityAtMs).toISOString(),
+        inactivity_deadline_at: timeoutMinutes > 0
+            ? new Date(lastActivityAtMs + timeoutMinutes * 60 * 1000).toISOString()
+            : null,
+        hard_deadline_at: hardTimeoutMinutes > 0
+            ? new Date(taskStartedAtMs + hardTimeoutMinutes * 60 * 1000).toISOString()
+            : null
     });
     runtimeLog("info", "terminal_bridge_monitor_started", {
         conversation_id: conversation.conversation_id,
         agent: executor.kind,
         executor_session: executor.session,
-        agent_timeout_minutes: timeoutMinutes
+        agent_timeout_minutes: timeoutMinutes,
+        agent_hard_timeout_minutes: hardTimeoutMinutes
     });
     let idleCompletionFingerprint;
     while (true) {
@@ -3733,6 +4023,24 @@ async function runTerminalBridgeMonitor(options) {
         const nativeTakeover = isRecord(conversation.native_session_takeover)
             ? conversation.native_session_takeover
             : undefined;
+        const currentMessageId = stringValue(nativeTakeover?.["terminal_bridge_message_id"]);
+        if (monitorMessageId && currentMessageId !== monitorMessageId) {
+            appendEvent(logPath, {
+                ts: new Date().toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "terminal_bridge_monitor_superseded",
+                monitor_message_id: monitorMessageId,
+                current_message_id: currentMessageId
+            });
+            printJson({
+                conversation,
+                monitored: true,
+                terminal_bridge: true,
+                completed: false,
+                reason: "terminal_bridge_task_replaced"
+            });
+            return;
+        }
         const terminalControl = terminalControlFromTakeover(nativeTakeover);
         if (!terminalControl || nativeTakeover?.["terminal_bridge"] !== true) {
             const stalledConversation = markConversationStalled({
@@ -3841,26 +4149,91 @@ async function runTerminalBridgeMonitor(options) {
             });
             return;
         }
+        const screenFingerprint = terminalBridgeScreenFingerprint(terminalStatus?.screen?.excerpt);
+        const screenChanged = previousScreenFingerprint !== undefined &&
+            screenFingerprint !== undefined &&
+            screenFingerprint !== previousScreenFingerprint;
+        const screenChangedSinceSend = preSendScreenFingerprint !== undefined &&
+            screenFingerprint !== undefined &&
+            screenFingerprint !== preSendScreenFingerprint;
+        previousScreenFingerprint = screenFingerprint;
         const contextMatch = await terminalBridgeCodexContext({
             conversation,
             nativeTakeover,
             options
         });
         const startedAt = stringValue(nativeTakeover?.["terminal_bridge_started_at"]);
+        const rolloutCompletion = contextMatch?.context
+            ? latestCompletedRolloutTurn({
+                context: contextMatch.context,
+                conversation,
+                nativeTakeover,
+                startedAt
+            })
+            : undefined;
         const assistantMessage = contextMatch?.context
             ? latestAssistantAfter(contextMatch.context, startedAt)
             : undefined;
+        const rolloutFingerprint = rolloutCompletion || assistantMessage
+            ? terminalBridgeActivityFingerprint(JSON.stringify({
+                text: rolloutCompletion?.text ?? assistantMessage?.text,
+                timestamp: rolloutCompletion?.timestamp ?? assistantMessage?.timestamp,
+                turn_id: rolloutCompletion?.turnId
+            }))
+            : undefined;
+        const rolloutChanged = rolloutFingerprint !== undefined && rolloutFingerprint !== previousRolloutFingerprint;
+        previousRolloutFingerprint = rolloutFingerprint;
+        const activityReasons = [
+            terminalStatus.activity_state === "working" ? terminalStatus.activity_reason : undefined,
+            screenChanged ? "terminal screen changed" : undefined,
+            rolloutChanged ? "Codex rollout assistant output changed" : undefined
+        ].filter((value) => Boolean(value));
+        if (activityReasons.length > 0) {
+            const observedAtMs = Date.now();
+            lastActivityAtMs = observedAtMs;
+            const activityReason = activityReasons.join("; ");
+            if (persistedActivityReason === undefined ||
+                observedAtMs - lastPersistedActivityAtMs >= activityPersistIntervalMs) {
+                conversation = persistTerminalBridgeActivity({
+                    conversation,
+                    statePath,
+                    logPath,
+                    observedAtMs,
+                    reason: activityReason,
+                    activityState: terminalStatus.activity_state,
+                    timeoutMinutes,
+                    hardTimeoutMinutes
+                });
+                lastPersistedActivityAtMs = observedAtMs;
+                persistedActivityReason = activityReason;
+                if (!isWaitingForAgent(conversation.status)) {
+                    continue;
+                }
+            }
+        }
         const terminalIdle = terminalStatus.activity_state === "idle";
-        const screenMessage = !assistantMessage && terminalIdle
-            ? terminalBridgeScreenMessage({ conversation, terminalStatus })
+        const screenMessage = !rolloutCompletion && !assistantMessage && terminalIdle
+            ? terminalBridgeScreenMessage({
+                conversation,
+                nativeTakeover,
+                terminalStatus,
+                screenChangedSinceSend
+            })
             : undefined;
-        const completion = terminalIdle ? assistantMessage ?? screenMessage : undefined;
+        const completion = rolloutCompletion ?? (terminalIdle ? assistantMessage ?? screenMessage : undefined);
+        const completionMatch = rolloutCompletion
+            ? "rollout_task_complete"
+            : assistantMessage
+                ? contextMatch?.match
+                : "terminal_screen";
         const completionFingerprint = completion
             ? createHash("sha256")
                 .update(JSON.stringify({
                 text: completion.text,
                 timestamp: completion.timestamp,
-                match: assistantMessage ? contextMatch?.match : "terminal_screen"
+                match: completionMatch,
+                turn_id: rolloutCompletion?.turnId,
+                message_id: currentMessageId
             }))
                 .digest("hex")
             : undefined;
@@ -3872,9 +4245,11 @@ async function runTerminalBridgeMonitor(options) {
                 conversation_id: conversation.conversation_id,
                 event: "terminal_bridge_completion_detected",
                 terminal_control: terminalControl,
-                match: assistantMessage ? contextMatch?.match : "terminal_screen",
+                match: completionMatch,
                 codex_session: contextMatch?.context.source,
-                assistant_timestamp: completion?.timestamp
+                assistant_timestamp: completion?.timestamp,
+                rollout_turn_id: rolloutCompletion?.turnId,
+                terminal_bridge_message_id: currentMessageId
             });
             const callbackMessage = createMessage({
                 conversation,
@@ -3887,9 +4262,11 @@ async function runTerminalBridgeMonitor(options) {
                     source: "terminal_bridge",
                     terminal_control: terminalControl,
                     codex_session: contextMatch?.context.source,
-                    confidence: assistantMessage ? contextMatch?.confidence : "screen_only",
-                    match: assistantMessage ? contextMatch?.match : "terminal_screen",
-                    assistant_timestamp: completion?.timestamp
+                    confidence: rolloutCompletion || assistantMessage ? contextMatch?.confidence : "screen_only",
+                    match: completionMatch,
+                    assistant_timestamp: completion?.timestamp,
+                    rollout_turn_id: rolloutCompletion?.turnId,
+                    terminal_bridge_message_id: currentMessageId
                 }
             });
             runLockedCallback({
@@ -3907,18 +4284,59 @@ async function runTerminalBridgeMonitor(options) {
             });
             return;
         }
+        // A concrete approval or completion observed on this poll wins over a timeout boundary.
+        const nowMs = Date.now();
+        if (Number.isFinite(hardTimeoutMinutes) &&
+            hardTimeoutMinutes > 0 &&
+            nowMs - taskStartedAtMs >= hardTimeoutMinutes * 60 * 1000) {
+            appendEvent(logPath, {
+                ts: new Date(nowMs).toISOString(),
+                conversation_id: conversation.conversation_id,
+                event: "terminal_bridge_hard_timeout_reached",
+                terminal_control: terminalControl,
+                task_started_at: new Date(taskStartedAtMs).toISOString(),
+                hard_deadline_at: new Date(taskStartedAtMs + hardTimeoutMinutes * 60 * 1000).toISOString(),
+                agent_hard_timeout_minutes: hardTimeoutMinutes,
+                last_activity_at: new Date(lastActivityAtMs).toISOString(),
+                terminal_activity_state: terminalStatus.activity_state
+            });
+            const stalledConversation = markConversationStalled({
+                statePath,
+                logPath,
+                reason: `terminal bridge reached its hard lifetime of ${hardTimeoutMinutes} minutes`,
+                detail: {
+                    terminal_bridge: true,
+                    terminal_control: terminalControl,
+                    task_started_at: new Date(taskStartedAtMs).toISOString(),
+                    last_activity_at: new Date(lastActivityAtMs).toISOString(),
+                    agent_hard_timeout_minutes: hardTimeoutMinutes,
+                    terminal_activity_state: terminalStatus.activity_state
+                }
+            });
+            printJson({
+                conversation: stalledConversation,
+                monitored: true,
+                terminal_bridge: true,
+                stalled: true,
+                hard_timeout: true,
+                reason: stalledConversation?.stalled_reason
+            });
+            return;
+        }
         if (Number.isFinite(timeoutMinutes) && timeoutMinutes > 0) {
-            const updatedAtMs = Date.parse(String(conversation.updated_at ?? conversation.created_at));
-            if (Number.isFinite(updatedAtMs) && Date.now() - updatedAtMs >= timeoutMinutes * 60 * 1000) {
+            if (nowMs - lastActivityAtMs >= timeoutMinutes * 60 * 1000) {
                 const stalledConversation = markConversationStalled({
                     statePath,
                     logPath,
-                    reason: `terminal bridge did not observe completion after ${timeoutMinutes} minutes`,
+                    reason: `terminal bridge observed no activity for ${timeoutMinutes} minutes`,
                     detail: {
                         terminal_bridge: true,
                         terminal_control: terminalControl,
                         match: contextMatch?.match,
-                        terminal_activity_state: terminalStatus.activity_state
+                        terminal_activity_state: terminalStatus.activity_state,
+                        last_activity_at: new Date(lastActivityAtMs).toISOString(),
+                        inactivity_deadline_at: new Date(lastActivityAtMs + timeoutMinutes * 60 * 1000).toISOString(),
+                        agent_timeout_minutes: timeoutMinutes
                     }
                 });
                 printJson({
@@ -3934,6 +4352,108 @@ async function runTerminalBridgeMonitor(options) {
         sleepSync(pollIntervalMs);
     }
 }
+function validTimestampMs(value) {
+    const parsed = Date.parse(String(value ?? ""));
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function deadlineAt(startedAt, timeoutMinutes) {
+    const startedAtMs = validTimestampMs(startedAt);
+    return startedAtMs !== undefined && Number.isFinite(timeoutMinutes) && timeoutMinutes > 0
+        ? new Date(startedAtMs + timeoutMinutes * 60 * 1000).toISOString()
+        : undefined;
+}
+function terminalBridgeActivityFingerprint(value) {
+    const text = stringValue(value);
+    return text ? createHash("sha256").update(text).digest("hex") : undefined;
+}
+function terminalBridgeScreenFingerprint(value) {
+    return typeof value === "string"
+        ? createHash("sha256").update(value).digest("hex")
+        : undefined;
+}
+function terminalBridgeSendLockPath(storeDir, terminalControl) {
+    const terminalKey = createHash("sha256")
+        .update(JSON.stringify({
+        target: terminalControl.target,
+        socket_path: terminalControl.socketPath
+    }))
+        .digest("hex")
+        .slice(0, 20);
+    return path.join(storeDir, `.terminal-bridge-send-${terminalKey}.lock`);
+}
+function terminalBridgeRequestFingerprint(value) {
+    const text = String(value ?? "").replace(/\s+/gu, " ").trim();
+    return text ? createHash("sha256").update(text).digest("hex") : undefined;
+}
+function terminalBridgeActivityPersistIntervalMs(timeoutMinutes, pollIntervalMs) {
+    if (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0) {
+        return 5 * 60 * 1000;
+    }
+    return Math.max(pollIntervalMs, Math.min(timeoutMinutes * 30 * 1000, 5 * 60 * 1000));
+}
+function persistTerminalBridgeActivity({ conversation, statePath, logPath, observedAtMs, reason, activityState, timeoutMinutes, hardTimeoutMinutes }) {
+    const releaseLock = acquireFileLock(`${statePath}.lock`);
+    try {
+        const currentConversation = loadState(statePath);
+        if (!isWaitingForAgent(currentConversation.status)) {
+            return currentConversation;
+        }
+        const expectedNativeTakeover = isRecord(conversation.native_session_takeover)
+            ? conversation.native_session_takeover
+            : {};
+        const nativeTakeover = isRecord(currentConversation.native_session_takeover)
+            ? currentConversation.native_session_takeover
+            : {};
+        if (nativeTakeover["terminal_bridge_message_id"] !==
+            expectedNativeTakeover["terminal_bridge_message_id"]) {
+            return currentConversation;
+        }
+        const previousActivityAtMs = validTimestampMs(nativeTakeover["terminal_bridge_last_activity_at"]);
+        const observedAt = new Date(observedAtMs).toISOString();
+        const inactivityDeadlineAt = Number.isFinite(timeoutMinutes) && timeoutMinutes > 0
+            ? new Date(observedAtMs + timeoutMinutes * 60 * 1000).toISOString()
+            : undefined;
+        const nextConversation = {
+            ...currentConversation,
+            native_session_takeover: {
+                ...nativeTakeover,
+                terminal_bridge_last_activity_at: observedAt,
+                terminal_bridge_last_activity_reason: reason,
+                terminal_bridge_inactivity_deadline_at: inactivityDeadlineAt,
+                terminal_bridge_inactivity_timeout_minutes: timeoutMinutes,
+                terminal_bridge_hard_timeout_minutes: hardTimeoutMinutes
+            },
+            updated_at: observedAt
+        };
+        saveState(statePath, nextConversation);
+        appendEvent(logPath, {
+            ts: observedAt,
+            conversation_id: currentConversation.conversation_id,
+            event: "terminal_bridge_activity_observed",
+            reason,
+            last_activity_at: observedAt,
+            terminal_activity_state: activityState
+        });
+        if (inactivityDeadlineAt) {
+            appendEvent(logPath, {
+                ts: observedAt,
+                conversation_id: currentConversation.conversation_id,
+                event: "terminal_bridge_inactivity_deadline_extended",
+                reason,
+                previous_last_activity_at: previousActivityAtMs === undefined
+                    ? null
+                    : new Date(previousActivityAtMs).toISOString(),
+                last_activity_at: observedAt,
+                inactivity_deadline_at: inactivityDeadlineAt,
+                agent_timeout_minutes: timeoutMinutes
+            });
+        }
+        return nextConversation;
+    }
+    finally {
+        releaseLock();
+    }
+}
 function terminalBridgeApprovalCandidate({ executor, terminalControl, terminalStatus, fingerprint }) {
     const approval = isRecord(terminalStatus?.approval_state) ? terminalStatus.approval_state : {};
     if (approval.approvable !== true) {
@@ -4019,22 +4539,59 @@ function latestAssistantAfter(context, startedAt) {
         return Number.isFinite(messageTime) && messageTime >= Number(threshold);
     });
 }
-function terminalBridgeScreenMessage({ conversation, terminalStatus }) {
+function latestCompletedRolloutTurn({ context, conversation, nativeTakeover, startedAt }) {
+    const threshold = validTimestampMs(startedAt);
+    const expectedRequestHash = stringValue(nativeTakeover?.["terminal_bridge_request_hash"]) ??
+        terminalBridgeRequestFingerprint(nativeTakeover?.["terminal_bridge_request_text"] ?? conversation.user_request);
+    if (threshold === undefined || !expectedRequestHash) {
+        return undefined;
+    }
+    const turn = [...(context.turns ?? [])]
+        .reverse()
+        .find((candidate) => {
+        const userTimestamp = validTimestampMs(candidate.userTimestamp);
+        const completedAt = validTimestampMs(candidate.completedAt);
+        return candidate.userTextHash === expectedRequestHash &&
+            userTimestamp !== undefined &&
+            completedAt !== undefined &&
+            userTimestamp >= threshold &&
+            completedAt >= userTimestamp &&
+            Boolean(candidate.lastAssistantMessage);
+    });
+    if (!turn?.lastAssistantMessage) {
+        return undefined;
+    }
+    return {
+        role: "assistant",
+        text: turn.lastAssistantMessage,
+        timestamp: turn.completedAt,
+        turnId: turn.turnId,
+        userTimestamp: turn.userTimestamp
+    };
+}
+function terminalBridgeScreenMessage({ conversation, nativeTakeover, terminalStatus, screenChangedSinceSend }) {
     const excerpt = stringValue(terminalStatus?.screen?.excerpt);
     if (!excerpt) {
         return undefined;
     }
-    const request = String(conversation.user_request ?? "").trim();
-    const promptIndex = request ? excerpt.lastIndexOf(request) : -1;
-    const afterPrompt = promptIndex >= 0
-        ? excerpt.slice(promptIndex + request.length)
-        : excerpt;
-    const completionBoundary = terminalBridgeCompletionBoundary(afterPrompt);
-    const completionText = completionBoundary === undefined
-        ? afterPrompt
-        : afterPrompt.slice(0, completionBoundary);
+    const request = String(nativeTakeover?.["terminal_bridge_request_text"] ?? conversation.user_request ?? "").trim();
+    const promptEnd = request ? whitespaceInsensitiveMatchEnd(excerpt, request) : undefined;
+    const afterPrompt = promptEnd === undefined ? undefined : excerpt.slice(promptEnd);
+    const completionBoundary = afterPrompt === undefined
+        ? undefined
+        : terminalBridgeCompletionBoundary(afterPrompt);
+    const completionText = afterPrompt === undefined
+        ? screenChangedSinceSend
+            ? terminalBridgeLatestCompletedSegment(excerpt)
+            : undefined
+        : completionBoundary === undefined
+            ? afterPrompt
+            : afterPrompt.slice(0, completionBoundary);
+    if (completionText === undefined) {
+        return undefined;
+    }
     const cleaned = cleanTerminalBridgeScreenText(completionText);
-    const hasCompletionEvidence = completionBoundary !== undefined || /[•└]/u.test(cleaned ?? "");
+    const hasCompletionEvidence = promptEnd === undefined || completionBoundary !== undefined || /[•└]/u.test(cleaned ?? "");
     if (!cleaned || cleaned.length < 40 || !hasCompletionEvidence) {
         return undefined;
     }
@@ -4044,6 +4601,51 @@ function terminalBridgeScreenMessage({ conversation, terminalStatus }) {
         timestamp: undefined
     };
 }
+function whitespaceInsensitiveMatchEnd(text, expected) {
+    const normalizedExpected = expected.replace(/\s/gu, "");
+    if (!normalizedExpected) {
+        return undefined;
+    }
+    let normalizedText = "";
+    const sourceEnds = [];
+    for (let index = 0; index < text.length;) {
+        const codePoint = text.codePointAt(index);
+        if (codePoint === undefined) {
+            break;
+        }
+        const character = String.fromCodePoint(codePoint);
+        if (!/\s/u.test(character)) {
+            normalizedText += character;
+            for (let codeUnit = 0; codeUnit < character.length; codeUnit += 1) {
+                sourceEnds.push(index + character.length);
+            }
+        }
+        index += character.length;
+    }
+    const matchIndex = normalizedText.lastIndexOf(normalizedExpected);
+    if (matchIndex < 0) {
+        return undefined;
+    }
+    return sourceEnds[matchIndex + normalizedExpected.length - 1];
+}
+function terminalBridgeLatestCompletedSegment(text) {
+    const matches = [...text.matchAll(/^[ \t]*[─━-]+\s+Worked for\b.*$/gmu)];
+    const completion = matches.at(-1);
+    if (completion?.index === undefined) {
+        return undefined;
+    }
+    const previousCompletion = matches.at(-2);
+    let start = previousCompletion?.index === undefined
+        ? 0
+        : previousCompletion.index + previousCompletion[0].length;
+    const beforeCompletion = text.slice(0, completion.index);
+    const prompts = [...beforeCompletion.matchAll(/^[ \t]*›(?:\s|$).*$/gmu)];
+    const latestPrompt = prompts.at(-1);
+    if (latestPrompt?.index !== undefined && latestPrompt.index >= start) {
+        start = latestPrompt.index + latestPrompt[0].length;
+    }
+    return text.slice(start, completion.index);
+}
 function terminalBridgeCompletionBoundary(text) {
     const matches = [...text.matchAll(/^[ \t]*[─━-]+\s+Worked for\b.*$/gmu)];
     return matches.at(-1)?.index;
@@ -4417,7 +5019,7 @@ function acquireFileLock(lockPath, { timeoutMs = 5000, retryMs = 50 } = {}) {
                 throw error;
             }
             if (Date.now() - started >= timeoutMs) {
-                throw new Error(`timed out waiting for callback lock: ${lockPath}`);
+                throw new Error(`timed out waiting for file lock: ${lockPath}`);
             }
             sleepSync(retryMs);
         }
@@ -4955,6 +5557,7 @@ function markConversationStalled({ statePath, logPath, reason, detail = {} }) {
         }
         const now = new Date().toISOString();
         const executor = executorForConversation(conversation);
+        const terminalBridge = terminalBridgeEnabled(conversation);
         const shouldNotify = Boolean(conversation.gateway_method && !conversation.stalled_notification_sent_at);
         stalledMessage = shouldNotify
             ? createMessage({
@@ -4968,7 +5571,9 @@ function markConversationStalled({ statePath, logPath, reason, detail = {} }) {
                     "",
                     `Conversation: ${conversation.conversation_id}`,
                     `Session: ${executor.session}`,
-                    "Use `AKK status` for details, `AKK send` to retry/follow up, or `AKK close` to close it."
+                    terminalBridge
+                        ? `Use \`AKK status ${conversation.conversation_id}\` for details, \`AKK renew ${conversation.conversation_id}\` to resume monitoring without sending another task, or \`AKK close ${conversation.conversation_id}\` to close it.`
+                        : "Use `AKK status` for details, `AKK send` to retry/follow up, or `AKK close` to close it."
                 ].join("\n")
             })
             : undefined;
@@ -5686,9 +6291,10 @@ function usage() {
   agent-knock-knock list [--store-dir <dir>] [--agent ${agentList}] [--status <status>] [--all] [--managed-only] [--no-approval-scan] [--terminal-debug]
   agent-knock-knock status --conversation <id> [--store-dir <dir>] [--trace]
   agent-knock-knock describe --conversation <id> [--store-dir <dir>]
-  agent-knock-knock send --conversation <id> --message <text> [--type answer|task|control] [--all-proxy <url>] [--agent-timeout-minutes <minutes>]
+  agent-knock-knock send --conversation <id> --message <text> [--type answer|task|control] [--all-proxy <url>] [--agent-timeout-minutes <minutes>] [--agent-hard-timeout-minutes <minutes>]
   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 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]