@scotthuang/agent-knock-knock 0.2.16 → 0.2.18

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.18 - 2026-06-30
+
+### Fixed
+
+- Classified Codex remote compact stream disconnects as recoverable executor failures instead of leaving AKK tasks stuck as generic `stalled` conversations.
+- Allowed `AKK recover` to replay saved AKK history and the pending OpenClaw message after a recognized monitor-time executor failure.
+
 ## 0.2.13 - 2026-06-25
 
 ### Fixed

package/dist/src/cli.js

@@ -1589,6 +1589,26 @@ async function runSend(options) {
     cleanupIdleConversations(storeDirFromOptions(options), options);
     const terminalConversation = await resolveTerminalConversationFromOptions(options);
     if (terminalConversation) {
+        if (options.background) {
+            const managed = createManagedTerminalConversationFromRawId({
+                options,
+                conversationId: terminalConversation.conversationId,
+                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
+            });
+            return;
+        }
         await runTerminalConversationSend({
             options,
             conversationId: terminalConversation.conversationId,
@@ -2083,7 +2103,17 @@ async function runTerminalConversationSend({ options, conversationId, messageBod
 }
 async function runTerminalControlSend({ options, conversation, nextConversation, statePath, logPath, executor, message, terminalControl, needsNativeTakeoverBootstrap }) {
     const provider = createTerminalControlProvider(options);
-    await provider.sendText(terminalControl.target, String(message.body ?? ""), {
+    const terminalPayload = needsNativeTakeoverBootstrap
+        ? buildAgentSendPayload({
+            conversation,
+            executor,
+            message,
+            includeNativeTakeoverBootstrap: true,
+            includeForkTakeoverBootstrap: false,
+            forkTakeover: undefined
+        })
+        : String(message.body ?? "");
+    await provider.sendText(terminalControl.target, terminalPayload, {
         socketPath: terminalControl.socketPath
     });
     await provider.sendKeys(terminalControl.target, ["Enter"], {
@@ -2095,13 +2125,15 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         event: "terminal_message_send",
         executor,
         terminal_control: terminalControl,
-        message: textSummary(message.body)
+        message: textSummary(message.body),
+        payload: textSummary(terminalPayload)
     });
     runtimeLog("info", "terminal_message_send", {
         conversation_id: conversation.conversation_id,
         agent: executor.kind,
         terminal_target: terminalControl.target,
-        message: textSummary(message.body)
+        message: textSummary(message.body),
+        payload: textSummary(terminalPayload)
     });
     const deliveredConversation = markTakeoverBootstrapped({
         conversation: nextConversation,
@@ -2128,6 +2160,113 @@ async function runTerminalControlSend({ options, conversation, nextConversation,
         })
     });
 }
+function createManagedTerminalConversationFromRawId({ options, conversationId, messageBody, terminalControl }) {
+    const workspace = terminalControl.currentPath ?? process.cwd();
+    const storeDir = expandHome(options.storeDir ?? options.logDir ?? defaultStoreDir(workspace));
+    cleanupIdleConversations(storeDir, options);
+    const executor = resolveExecutor({
+        kind: "codex",
+        session: conversationId
+    });
+    const now = new Date();
+    const conversation = createConversation({
+        userRequest: String(messageBody),
+        workspace,
+        openclawSession: options.openclawSession ?? "agent:main:main",
+        executorKind: executor.kind,
+        executorSession: executor.session,
+        softLimit: Number(options.softLimit ?? 50),
+        hardLimit: Number(options.hardLimit ?? 100),
+        now
+    });
+    const paths = pathsForConversation(conversation.conversation_id, storeDir);
+    const callbackCommand = options.callbackCommand
+        ? expandCallbackCommandTemplate(options.callbackCommand, { statePath: paths.statePath })
+        : buildCallbackCommand({
+            statePath: paths.statePath,
+            gatewayUrl: options.gatewayUrl ?? "ws://127.0.0.1:18789",
+            token: options.token,
+            openclawSession: options.openclawSession ?? "agent:main:main",
+            gatewayMethod: options.gatewayMethod,
+            gatewaySession: options.gatewaySession,
+            openclawBin: options.openclawBin ?? resolveOptionalExecutable("openclaw")
+        });
+    const attachedConversation = withStoragePaths({
+        ...conversation,
+        executor,
+        status: "idle",
+        idle_since: now.toISOString(),
+        updated_at: now.toISOString(),
+        callback_command: callbackCommand,
+        gateway_url: options.gatewayUrl ?? "ws://127.0.0.1:18789",
+        gateway_method: options.gatewayMethod,
+        gateway_session: options.gatewaySession ?? options.openclawSession ?? "agent:main:main",
+        openclaw_bin: options.openclawBin ?? resolveOptionalExecutable("openclaw"),
+        executor_all_proxy: proxyForExecutor(executor, options),
+        executor_model: options.model ?? options.codexModel,
+        native_session_takeover: {
+            agent: "codex",
+            native_session_id: conversationId,
+            source_cwd: workspace,
+            source_title: `Terminal-controlled Codex ${terminalControl.target}`,
+            strategy: "terminal_control",
+            attached_at: now.toISOString(),
+            takeover_match_kind: "raw_terminal_send",
+            terminal_control: terminalControl,
+            needs_bootstrap: 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: "codex",
+        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",
+        to: executor.actor,
+        type: options.type ?? "task",
+        body: String(messageBody),
+        metadata: {
+            executor_kind: executor.kind,
+            executor_session: executor.session,
+            source_conversation_id: conversationId
+        }
+    });
+    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,
+        statePath: paths.statePath,
+        logPath: paths.logPath,
+        executor,
+        message
+    };
+}
 function runNativeCodexResumeSend({ options, conversation, nextConversation, statePath, logPath, executor, executorEnv, message, payload, nativeTakeover, needsNativeTakeoverBootstrap }) {
     const codexPath = resolveExecutable("codex");
     const nativeSessionId = String(nativeTakeover["native_session_id"]);
@@ -2885,7 +3024,8 @@ function runMonitor(options) {
             return;
         }
         if (Number.isFinite(pid) && !isProcessAlive(pid)) {
-            const modelSelection = detectModelSelectionError(readOutputTail(options.outputPath));
+            const outputTail = readOutputTail(options.outputPath);
+            const modelSelection = detectModelSelectionError(outputTail);
             if (modelSelection) {
                 const modelSelectionConversation = markConversationNeedsModelSelection({
                     statePath,
@@ -2906,6 +3046,30 @@ function runMonitor(options) {
                 });
                 return;
             }
+            const transientFailure = detectTransientExecutorFailure(outputTail);
+            if (transientFailure) {
+                const recoveryResult = markMonitorFailureNeedsRecovery({
+                    statePath,
+                    logPath,
+                    reason: transientFailure.message,
+                    detail: {
+                        executor_pid: pid,
+                        output_path: options.outputPath,
+                        transient_failure: transientFailure
+                    },
+                    outputTail
+                });
+                if (recoveryResult) {
+                    printJson({
+                        conversation: recoveryResult.conversation,
+                        monitored: true,
+                        stalled: false,
+                        needs_recovery: true,
+                        reason: transientFailure.message
+                    });
+                    return;
+                }
+            }
             const stalledConversation = markConversationStalled({
                 statePath,
                 logPath,
@@ -3707,6 +3871,110 @@ function markConversationStalled({ statePath, logPath, reason, detail = {} }) {
     }
     return stalledConversation;
 }
+function markMonitorFailureNeedsRecovery({ statePath, logPath, reason, detail = {}, outputTail = "" }) {
+    const releaseLock = acquireFileLock(`${statePath}.lock`);
+    let recoveryResult;
+    let recoveryMessage;
+    try {
+        const conversation = loadState(statePath);
+        if (!isWaitingForAgent(conversation.status)) {
+            runtimeLog("info", "executor_monitor_finished", {
+                conversation_id: conversation.conversation_id,
+                status: conversation.status,
+                reason: "conversation_changed_before_recovery"
+            });
+            return undefined;
+        }
+        const executor = executorForConversation(conversation);
+        const pendingMessage = latestPendingExecutorMessage({
+            events: readExistingEvents(logPath),
+            executor
+        });
+        if (!pendingMessage) {
+            runtimeLog("warn", "monitor_recovery_skipped", {
+                conversation_id: conversation.conversation_id,
+                agent: executor.kind,
+                executor_session: executor.session,
+                reason: "pending_message_missing"
+            });
+            return undefined;
+        }
+        recoveryResult = markConversationNeedsRecovery({
+            conversation,
+            statePath,
+            logPath,
+            executor,
+            message: pendingMessage,
+            failedStage: "executor_monitor",
+            result: {
+                status: 1,
+                stderr: outputTail
+            },
+            reason
+        });
+        const recoveredConversation = recoveryResult.conversation;
+        const shouldNotify = Boolean(recoveredConversation.gateway_method && !recoveredConversation.recovery_notification_sent_at);
+        if (shouldNotify) {
+            recoveryMessage = createMessage({
+                conversation: recoveredConversation,
+                from: executor.actor,
+                to: "openclaw",
+                type: "error",
+                requiresResponse: false,
+                body: [
+                    `AKK marked this ${executor.display_name} task as needing recovery: ${reason}.`,
+                    "",
+                    `Conversation: ${recoveredConversation.conversation_id}`,
+                    `Session: ${executor.session}`,
+                    "Use `AKK recover` to replay saved AKK history in a new session, or `AKK close` to close it."
+                ].join("\n")
+            });
+            const now = new Date().toISOString();
+            recoveryResult.conversation = {
+                ...recoveredConversation,
+                recovery_notification_sent_at: now,
+                recovery_notification_message_id: recoveryMessage.id,
+                updated_at: now
+            };
+            saveState(statePath, recoveryResult.conversation);
+        }
+        appendEvent(logPath, {
+            ts: new Date().toISOString(),
+            conversation_id: conversation.conversation_id,
+            event: "monitor_recovery_classified",
+            status: "needs_recovery",
+            reason,
+            ...detail
+        });
+    }
+    finally {
+        releaseLock();
+    }
+    if (recoveryResult?.conversation && recoveryMessage) {
+        deliverMonitorFailureNotification({
+            statePath,
+            logPath,
+            conversation: recoveryResult.conversation,
+            message: recoveryMessage,
+            eventPrefix: "recovery"
+        });
+    }
+    return recoveryResult;
+}
+function latestPendingExecutorMessage({ events, executor }) {
+    for (const event of [...events].reverse()) {
+        if (event.event !== "message") {
+            continue;
+        }
+        const message = event.message ?? event;
+        if (message?.from === "openclaw" &&
+            message?.to === executor.actor &&
+            message?.requires_response !== false) {
+            return message;
+        }
+    }
+    return undefined;
+}
 function markConversationNeedsModelSelection({ statePath, logPath, reason, detail = {} }) {
     const releaseLock = acquireFileLock(`${statePath}.lock`);
     let modelSelectionConversation;
@@ -3759,7 +4027,10 @@ function markConversationNeedsModelSelection({ statePath, logPath, reason, detai
     }
     return modelSelectionConversation;
 }
-function deliverStalledNotification({ statePath, logPath, conversation, message }) {
+function deliverMonitorFailureNotification({ statePath, logPath, conversation, message, eventPrefix }) {
+    deliverStalledNotification({ statePath, logPath, conversation, message, eventPrefix });
+}
+function deliverStalledNotification({ statePath, logPath, conversation, message, eventPrefix = "stalled" }) {
     if (!conversation.gateway_method) {
         return;
     }
@@ -3779,14 +4050,14 @@ function deliverStalledNotification({ statePath, logPath, conversation, message
     appendEvent(logPath, {
         ts: new Date().toISOString(),
         conversation_id: conversation.conversation_id,
-        event: "stalled_gateway_method_delivery",
+        event: `${eventPrefix}_gateway_method_delivery`,
         method: conversation.gateway_method,
         message_id: message.id,
         status: delivery.status,
         stdout: delivery.stdout,
         stderr: delivery.stderr
     });
-    runtimeLog("info", "stalled_gateway_method_delivery", {
+    runtimeLog("info", `${eventPrefix}_gateway_method_delivery`, {
         conversation_id: conversation.conversation_id,
         method: conversation.gateway_method,
         message_id: message.id,
@@ -3812,13 +4083,13 @@ function deliverStalledNotification({ statePath, logPath, conversation, message
     appendEvent(logPath, {
         ts: new Date().toISOString(),
         conversation_id: conversation.conversation_id,
-        event: "stalled_chat_send_delivery",
+        event: `${eventPrefix}_chat_send_delivery`,
         message_id: message.id,
         status: chatSendDelivery.status,
         stdout: chatSendDelivery.stdout,
         stderr: chatSendDelivery.stderr
     });
-    runtimeLog("info", "stalled_chat_send_delivery", {
+    runtimeLog("info", `${eventPrefix}_chat_send_delivery`, {
         conversation_id: conversation.conversation_id,
         message_id: message.id,
         status: chatSendDelivery.status,
@@ -4143,6 +4414,9 @@ function classifyProcessFailure(result) {
     if (!combined && status === 0) {
         return undefined;
     }
+    if (isRemoteCompactStreamDisconnect(combined)) {
+        return "transient_remote_compact_failure";
+    }
     if (combined.includes("agent needs reconnect") || combined.includes("internal error")) {
         return "agent_reconnect_required";
     }
@@ -4210,6 +4484,25 @@ function detectModelSelectionError(text) {
     }
     return undefined;
 }
+function detectTransientExecutorFailure(text) {
+    const cleaned = cleanProcessText(text);
+    if (!cleaned) {
+        return undefined;
+    }
+    if (isRemoteCompactStreamDisconnect(cleaned.toLowerCase())) {
+        return {
+            kind: "remote_compact_stream_disconnect",
+            message: "Codex remote compact stream disconnected before completion"
+        };
+    }
+    return undefined;
+}
+function isRemoteCompactStreamDisconnect(text) {
+    const value = String(text ?? "").toLowerCase();
+    return (value.includes("error running remote compact task") &&
+        value.includes("stream disconnected") &&
+        value.includes("/codex/responses/compact"));
+}
 function runtimeLog(level, event, fields = {}) {
     try {
         writeRuntimeLog({