@scotthuang/agent-knock-knock 0.5.2 → 0.6.1

package/dist/src/cli.js

@@ -11,7 +11,7 @@ import { captureClaudeTranscriptAnchor, defaultClaudeHome, detectClaudeTranscrip
 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, executorDefinitionForKind } from "./executors.js";
+import { EXECUTOR_KINDS, executorDefinitionForKind, isExecutorKind } from "./executors.js";
 import { redactString, writeRuntimeLog } from "./runtime-log.js";
 import { formatTranscript, readNdjsonLog } from "./transcript.js";
 import { appendEvent, defaultStoreDir, ensureDir, listConversations, logPathForStatePath, loadConversationById, loadState, messageEvent, pathsForConversation, pathsForConversationDir, saveState, statePathForConversationId } from "./store.js";
@@ -191,19 +191,17 @@ async function runCommand(commandName, options) {
 function runInstallOpenClaw(options) {
     const root = packageRootDir();
     const skillOnly = options.skillOnly === true;
-    const workspace = options.workspace === undefined
-        ? undefined
-        : canonicalWorkspace(options.workspace);
+    if (options.workspace !== undefined) {
+        throw new Error("--workspace was removed from install-openclaw; AKK now discovers verified tmux panes across workspaces. Configure autoApprove.rules[].workspaces only for trusted automatic approvals.");
+    }
     if (options.defaultAgent !== undefined) {
         throw new Error("--default-agent was removed; AKK now selects the only eligible idle tmux pane");
     }
     if (options.mode !== undefined) {
         throw new Error("--mode was removed; Agent Knock Knock now uses tmux only");
     }
-    if (skillOnly &&
-        (workspace !== undefined ||
-            options.verify === true)) {
-        throw new Error("--skill-only cannot be combined with --workspace, --mode, or --verify");
+    if (skillOnly && options.verify === true) {
+        throw new Error("--skill-only cannot be combined with --verify");
     }
     const needsOpenClaw = !skillOnly || options.noRestart !== true || options.verify === true;
     const openclawBin = needsOpenClaw
@@ -224,12 +222,6 @@ function runInstallOpenClaw(options) {
                 path: "plugins.entries.agent-knock-knock.enabled",
                 value: true
             },
-            ...(workspace === undefined
-                ? []
-                : [{
-                        path: "plugins.entries.agent-knock-knock.config.workspace",
-                        value: workspace
-                    }])
         ];
         runCheckedCommand(openclawBin, ["config", "set", "--batch-json", JSON.stringify(configOperations)], { label: "openclaw config set" });
         steps.push({
@@ -256,8 +248,7 @@ function runInstallOpenClaw(options) {
     const verification = options.verify === true
         ? buildDoctorReport({
             ...options,
-            openclawBin,
-            ...(workspace ? { workspace } : {})
+            openclawBin
         })
         : undefined;
     const ready = verification
@@ -273,7 +264,6 @@ function runInstallOpenClaw(options) {
         pending_restart: pendingRestart,
         mode: skillOnly ? "skill_only" : "full",
         execution_mode: "tmux",
-        workspace: workspace ?? null,
         package_root: root,
         openclaw_bin: openclawBin ?? null,
         steps,
@@ -322,10 +312,10 @@ function assertConfiguredWorkspace(configuredWorkspace, candidateWorkspace, subj
         candidate = canonicalWorkspace(candidateWorkspace);
     }
     catch {
-        throw new Error(`refusing ${subject}; its workspace cannot be verified against configured workspace ${configured}`);
+        throw new Error(`refusing ${subject}; its working directory cannot be verified against expected workspace ${configured}`);
     }
     if (candidate !== configured) {
-        throw new Error(`refusing ${subject}; workspace ${candidate} does not match configured workspace ${configured}`);
+        throw new Error(`refusing ${subject}; workspace ${candidate} does not match expected workspace ${configured}`);
     }
 }
 function installNextActions({ pendingRestart, verification }) {
@@ -397,6 +387,9 @@ function buildDoctorReport(options) {
     if (options.mode !== undefined) {
         throw new Error("--mode was removed; Agent Knock Knock now checks tmux only");
     }
+    if (options.workspace !== undefined) {
+        throw new Error("--workspace was removed from doctor; AKK now discovers verified tmux panes across workspaces");
+    }
     const timeoutMs = options.timeoutMs === undefined
         ? undefined
         : positiveMilliseconds(options.timeoutMs, "--timeout-ms");
@@ -439,7 +432,6 @@ function buildDoctorReport(options) {
     const filesOk = packageFiles.every((check) => check.exists);
     const openclaw = runOpenClawChainDiagnostics({
         openclawBin,
-        ...(options.workspace ? { workspace: String(options.workspace) } : {}),
         ...(timeoutMs === undefined ? {} : { timeoutMs })
     });
     const ok = capabilities.readiness === "ready" &&
@@ -653,8 +645,12 @@ function createTerminalAgentBridge(options, terminalProvider = createTerminalCon
         terminalProvider,
         async verifyIdentity({ agent, pid, terminalControl }) {
             const adapter = registry.require(agent);
+            const expectedWorkspace = options.workspace ?? terminalControl.currentPath;
+            if (!expectedWorkspace) {
+                throw new Error(`refusing terminal access to ${terminalControl.target}; its workspace is unavailable`);
+            }
             const snapshots = await processSource.listProcessSnapshots((candidate) => candidate.pid === pid, {
-                includeCwd: options.workspace !== undefined,
+                includeCwd: true,
                 includeAncestors: true
             });
             const snapshot = snapshots.find((candidate) => candidate.pid === pid);
@@ -668,8 +664,8 @@ function createTerminalAgentBridge(options, terminalProvider = createTerminalCon
             if (!pane || !terminalPaneContainsProcess(snapshot, pane, snapshots)) {
                 throw new Error(`terminal conversation agent ${agent} with pid ${pid} no longer belongs to pane ${terminalControl.target}`);
             }
-            assertConfiguredWorkspace(options.workspace, snapshot.cwd, `terminal access to ${terminalControl.target} by agent process ${pid}`);
-            assertConfiguredWorkspace(options.workspace, pane.currentPath, `terminal access to ${terminalControl.target} by tmux pane`);
+            assertConfiguredWorkspace(expectedWorkspace, snapshot.cwd, `terminal access to ${terminalControl.target} by agent process ${pid}`);
+            assertConfiguredWorkspace(expectedWorkspace, pane.currentPath, `terminal access to ${terminalControl.target} by tmux pane`);
             return {
                 terminalControl: {
                     ...terminalControl,
@@ -883,7 +879,9 @@ function isTerminalControlCapability(value) {
 }
 async function runDelegate(options) {
     const request = required(options.request, "--request is required");
-    const workspace = canonicalWorkspace(options.workspace ?? process.cwd());
+    const workspace = options.workspace === undefined
+        ? undefined
+        : canonicalWorkspace(options.workspace);
     const requestedAgent = options.agent === undefined
         ? undefined
         : resolveExecutor({ kind: options.agent }).kind;
@@ -899,40 +897,54 @@ async function runDelegate(options) {
     if (scan.summary.error) {
         throw new Error(`tmux discovery failed: ${scan.summary.error}`);
     }
-    const sameWorkspace = scan.terminalControlled.filter((candidate) => {
-        try {
-            return canonicalWorkspace(candidate.workspace) === workspace;
-        }
-        catch {
-            return false;
-        }
-    });
-    const eligible = sameWorkspace.filter((candidate) => candidate.activity_state === "idle");
+    const scopedCandidates = workspace === undefined
+        ? scan.terminalControlled
+        : scan.terminalControlled.filter((candidate) => {
+            try {
+                return canonicalWorkspace(candidate.workspace) === workspace;
+            }
+            catch {
+                return false;
+            }
+        });
+    const eligible = scopedCandidates.filter((candidate) => candidate.activity_state === "idle");
     if (eligible.length === 0) {
-        const observed = sameWorkspace.length > 0
-            ? ` Found ${sameWorkspace.length} matching pane(s), but none is idle.`
+        const observed = scopedCandidates.length > 0
+            ? ` Found ${scopedCandidates.length} matching pane(s), but none is idle.`
             : "";
         const requestedExecutor = requestedAgent
             ? executorDefinitionForKind(requestedAgent)
             : undefined;
-        throw new Error(`No idle ${requestedExecutor?.displayName ?? "Codex or Claude Code"} pane is available in ${workspace}.${observed} ` +
-            `Start ${requestedAgent ?? "codex or claude"} inside tmux in that workspace, wait until it is idle, then retry.`);
+        const workspaceDetail = workspace
+            ? ` in ${workspace}`
+            : "";
+        throw new Error(`No idle ${requestedExecutor?.displayName ?? "Codex or Claude Code"} pane is available${workspaceDetail}.${observed} ` +
+            `Start ${requestedAgent ?? "codex or claude"} inside tmux${workspaceDetail}, wait until it is idle, then retry.`);
     }
     if (eligible.length > 1) {
         const candidates = eligible
-            .map((candidate) => `${candidate.short_ref} (${candidate.agent}, ${candidate.terminal_control?.target ?? candidate.id})`)
+            .map((candidate) => {
+            const identity = `${candidate.agent}, ${candidate.terminal_control?.target ?? candidate.id}`;
+            return workspace
+                ? `${candidate.short_ref} (${identity})`
+                : `${candidate.short_ref} (${identity}, ${candidate.workspace ?? "workspace unknown"})`;
+        })
             .join(", ");
         const scope = requestedAgent
             ? executorDefinitionForKind(requestedAgent).displayName
             : "coding-agent";
-        throw new Error(`Multiple idle ${scope} panes match ${workspace}: ${candidates}. ` +
+        const ambiguity = workspace
+            ? `match ${workspace}`
+            : "are available across workspaces";
+        throw new Error(`Multiple idle ${scope} panes ${ambiguity}: ${candidates}. ` +
             "Use /akk codex: <task>, /akk claude: <task>, or /akk @short-ref: <message> to choose one explicitly.");
     }
+    const selectedWorkspace = canonicalWorkspace(eligible[0].workspace);
     await runSend({
         ...options,
         conversation: eligible[0].id,
         message: request,
-        workspace,
+        workspace: selectedWorkspace,
         background: true
     });
 }
@@ -1319,16 +1331,23 @@ async function runList(options) {
     const includeAll = Boolean(options.all);
     const agentFilter = options.agent ? resolveExecutor({ kind: options.agent }).kind : undefined;
     const statusFilter = options.status;
-    const storedConversations = listConversations(storeDir)
+    const allStoredConversations = listConversations(storeDir);
+    const storedConversations = allStoredConversations
+        .filter(isDiscoverableTmuxConversation)
         .filter((conversation) => includeAll || isActiveStatus(conversation.status))
         .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace))
         .filter((conversation) => !agentFilter || executorForConversation(conversation).kind === agentFilter)
         .filter((conversation) => !statusFilter || conversation.status === statusFilter);
     const conversations = storedConversations.map((conversation) => summarizeConversation(conversation));
-    const delegated = storedConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), { terminalBridge: terminalBridgeEnabled(conversation) }));
+    const delegated = storedConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), {
+        terminalBridge: terminalBridgeEnabled(conversation),
+        approvalState: managedListApprovalState(conversation),
+        conversation
+    }));
     const terminalScan = await buildTerminalListGroup({ options, agentFilter, statusFilter });
-    const managedTerminalKeys = new Set(storedConversations
+    const managedTerminalKeys = new Set(allStoredConversations
         .filter((conversation) => isActiveStatus(conversation.status))
+        .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace))
         .map((conversation) => terminalControlSelectorKey(terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
         ? conversation.native_session_takeover
         : undefined)))
@@ -1343,6 +1362,7 @@ async function runList(options) {
     printJson({
         store_dir: storeDir,
         cleanup,
+        action_contracts: listActionContracts(),
         delegated,
         terminal_controlled: terminalControlled,
         terminal_scan: {
@@ -1442,12 +1462,13 @@ async function terminalControlDiagnostics(provider) {
         paneCount: (await provider.listPanes()).length
     };
 }
-function delegatedListEntry(task, { terminalBridge = false } = {}) {
-    return {
+function delegatedListEntry(task, { terminalBridge = false, approvalState, conversation } = {}) {
+    const entry = {
         ...task,
         id: task.conversation_id,
         short_ref: sessionShortRef(task.conversation_id),
         source: "akk_delegate",
+        ...(approvalState ? { approval_state: approvalState } : {}),
         commands: {
             send: canSendDelegated(task.status),
             cancel: isWaitingForAgent(task.status),
@@ -1456,6 +1477,10 @@ function delegatedListEntry(task, { terminalBridge = false } = {}) {
             approve: terminalBridge && isActiveStatus(task.status)
         }
     };
+    return {
+        ...entry,
+        available_actions: availableListActions(entry, { conversation })
+    };
 }
 async function terminalControlledListEntry(session, activeSessions, options, bridge = createTerminalAgentBridge(options)) {
     const terminalControl = session.terminalControl;
@@ -1469,7 +1494,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         terminalTarget: terminalControl.target
     });
     const orphanedDispatch = orphanedTerminalDispatchForRecovery(terminalControl);
-    return {
+    const entry = {
         id: bridge.terminalConversationId(session),
         short_ref: sessionShortRef(bridge.terminalConversationId(session)),
         source: "terminal_control",
@@ -1508,6 +1533,10 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             close: orphanedDispatch !== undefined
         }
     };
+    return {
+        ...entry,
+        available_actions: availableListActions(entry)
+    };
 }
 async function listStateForTerminal(agent, terminalControl, options, bridge = createTerminalAgentBridge(options), runtime) {
     if (options.noApprovalScan) {
@@ -1574,7 +1603,218 @@ function childPidsForRoot(root, processes) {
         .map((process) => process.pid);
 }
 function canSendDelegated(status) {
-    return !["failed", "closed", "cancelled"].includes(status);
+    return !["done", "failed", "closed", "cancelled"].includes(status);
+}
+function managedListApprovalState(conversation) {
+    if (!terminalBridgeEnabled(conversation) ||
+        !["waiting_for_agent", "waiting_for_openclaw"].includes(String(conversation.status))) {
+        return undefined;
+    }
+    const nativeTakeover = isRecord(conversation.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    if (!terminalControlFromTakeover(nativeTakeover) ||
+        !stringValue(nativeTakeover?.terminal_bridge_message_id)) {
+        return undefined;
+    }
+    const approval = isRecord(nativeTakeover?.terminal_bridge_approval)
+        ? nativeTakeover.terminal_bridge_approval
+        : undefined;
+    const approvalState = isRecord(approval?.approval_state)
+        ? approval.approval_state
+        : undefined;
+    const fingerprint = stringValue(approval?.fingerprint);
+    const notifiedAt = stringValue(approval?.notified_at);
+    const notifiedAtMs = validTimestampMs(notifiedAt);
+    if (!approvalState ||
+        !fingerprint ||
+        notifiedAtMs === undefined ||
+        Date.now() - notifiedAtMs > CLAUDE_SCREEN_APPROVAL_TTL_MS) {
+        return undefined;
+    }
+    return {
+        ...approvalState,
+        fingerprint,
+        notified_at: notifiedAt
+    };
+}
+function listActionContracts() {
+    return {
+        version: 1,
+        instructions: [
+            "Use only actions present in delegated[].available_actions or terminal_controlled[].available_actions.",
+            "Start with the action's prefilled arguments, supply every missing_required field, and consult the top-level action's optional fields only when needed.",
+            "Authoritative full IDs are prefilled; short_ref is for display and human input.",
+            "Availability is a snapshot. AKK revalidates process, tmux pane, workspace, activity, approval, and recovery state before side effects."
+        ],
+        actions: {
+            send: {
+                tool: "agent_knock_knock_send",
+                target_argument: "selector",
+                required: ["request"],
+                optional: [
+                    "selector",
+                    "type",
+                    "idleTimeoutMinutes",
+                    "agentTimeoutMinutes",
+                    "agentHardTimeoutMinutes"
+                ],
+                unsupported: ["timeoutSeconds"],
+                ordinary_use: "Add request only. Omit timeout fields unless the user explicitly asks to change monitoring limits."
+            },
+            status: {
+                tool: "agent_knock_knock_status",
+                target_argument: "conversation_id",
+                required: ["conversation_id"],
+                optional: ["idleTimeoutMinutes", "trace"]
+            },
+            approve: {
+                tool: "agent_knock_knock_approve",
+                target_argument: "conversation_id",
+                required: ["conversation_id", "expected_approval_fingerprint"],
+                requires_explicit_user_confirmation: true,
+                requires_fresh_status: true
+            },
+            cancel: {
+                tool: "agent_knock_knock_cancel",
+                target_argument: "conversation_id",
+                required: ["conversation_id"],
+                optional: ["idleTimeoutMinutes"],
+                requires_user_intent: true
+            },
+            renew: {
+                tool: "agent_knock_knock_renew",
+                target_argument: "conversation_id",
+                required: ["conversation_id"],
+                optional: ["minutes"]
+            },
+            retry_callback: {
+                tool: "agent_knock_knock_retry_callback",
+                target_argument: "conversation_id",
+                required: ["conversation_id"]
+            },
+            close: {
+                tool: "agent_knock_knock_close",
+                target_argument: "conversation_id",
+                required: ["conversation_id"],
+                optional: ["reason", "expected_message_id"],
+                requires_explicit_user_confirmation: true
+            }
+        }
+    };
+}
+function availableListActions(entry, { conversation } = {}) {
+    const id = stringValue(entry.id ?? entry.conversation_id);
+    if (!id) {
+        return {};
+    }
+    const commands = isRecord(entry.commands) ? entry.commands : {};
+    const actions = {
+        status: {
+            tool: "agent_knock_knock_status",
+            arguments: { conversation_id: id }
+        }
+    };
+    const terminalControlled = entry.source === "terminal_control";
+    const managed = entry.source === "akk_delegate";
+    const approvalState = isRecord(entry.approval_state)
+        ? entry.approval_state
+        : {};
+    const nativeTakeover = isRecord(conversation?.native_session_takeover)
+        ? conversation.native_session_takeover
+        : undefined;
+    const managedApprovalPending = isRecord(nativeTakeover?.terminal_bridge_approval);
+    const terminalBridgeReady = managed &&
+        terminalBridgeEnabled(conversation) &&
+        terminalControlFromTakeover(nativeTakeover) !== undefined;
+    if (commands.send === true &&
+        ((terminalBridgeReady &&
+            ["waiting_for_openclaw", "idle"].includes(String(entry.status)) &&
+            !managedApprovalPending &&
+            approvalState.blocked !== true) ||
+            (terminalControlled &&
+                entry.activity_state === "idle" &&
+                approvalState.blocked !== true))) {
+        actions.send = {
+            tool: "agent_knock_knock_send",
+            arguments: { selector: id },
+            missing_required: ["request"]
+        };
+    }
+    const approvalFingerprint = stringValue(approvalState.fingerprint);
+    const managedApprovalEligible = terminalBridgeReady &&
+        entry.status === "waiting_for_openclaw" &&
+        (entry.agent !== "claude" ||
+            approvalState.decision_mode === "keys");
+    if (commands.approve === true &&
+        approvalState.approvable === true &&
+        approvalFingerprint &&
+        ((terminalControlled &&
+            entry.agent === "codex") ||
+            managedApprovalEligible)) {
+        actions.approve = {
+            tool: "agent_knock_knock_approve",
+            arguments: { conversation_id: id },
+            missing_required: ["expected_approval_fingerprint"],
+            before_call: {
+                tool: "agent_knock_knock_status",
+                arguments: { conversation_id: id },
+                use: "After explicit user confirmation, copy the latest terminal_status.approval_state.fingerprint into expected_approval_fingerprint."
+            },
+            requires_explicit_user_confirmation: true,
+            requires_fresh_status: true
+        };
+    }
+    const rawCancellable = terminalControlled &&
+        commands.cancel === true &&
+        (entry.activity_state === "working" ||
+            (approvalState.blocked === true &&
+                approvalState.approvable === true));
+    const managedCancellable = terminalBridgeReady &&
+        ["waiting_for_agent", "waiting_for_openclaw"].includes(String(entry.status)) &&
+        !(managedApprovalPending &&
+            approvalState.approvable !== true);
+    if (rawCancellable || managedCancellable) {
+        actions.cancel = {
+            tool: "agent_knock_knock_cancel",
+            arguments: { conversation_id: id },
+            requires_user_intent: true
+        };
+    }
+    if (terminalBridgeReady && entry.status === "stalled") {
+        actions.renew = {
+            tool: "agent_knock_knock_renew",
+            arguments: { conversation_id: id }
+        };
+    }
+    const callbackDelivery = isRecord(conversation?.callback_delivery)
+        ? conversation.callback_delivery
+        : undefined;
+    if (managed &&
+        isRecord(conversation) &&
+        isRetryableCallbackDelivery(conversation, callbackDelivery)) {
+        actions.retry_callback = {
+            tool: "agent_knock_knock_retry_callback",
+            arguments: { conversation_id: id }
+        };
+    }
+    if (commands.close === true) {
+        const orphanedDispatch = isRecord(entry.orphaned_terminal_dispatch)
+            ? entry.orphaned_terminal_dispatch
+            : undefined;
+        const expectedMessageId = stringValue(orphanedDispatch?.message_id);
+        actions.close = {
+            tool: "agent_knock_knock_close",
+            arguments: {
+                conversation_id: id,
+                ...(expectedMessageId
+                    ? { expected_message_id: expectedMessageId }
+                    : {})
+            },
+            requires_explicit_user_confirmation: true
+        };
+    }
+    return actions;
 }
 async function resolveConversationSelectorOption(commandName, options) {
     if (!SESSION_SELECTOR_COMMANDS.has(String(commandName ?? "")) ||
@@ -1605,7 +1845,13 @@ async function sessionSelectorCandidates(commandName, options) {
     const storedConversations = listConversations(storeDir);
     const workspaceConversations = storedConversations
         .filter((conversation) => matchesConfiguredWorkspace(options.workspace, conversation.workspace));
-    const managed = workspaceConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), { terminalBridge: terminalBridgeEnabled(conversation) }));
+    const discoverableWorkspaceConversations = workspaceConversations
+        .filter(isDiscoverableTmuxConversation);
+    const managed = discoverableWorkspaceConversations.map((conversation) => delegatedListEntry(summarizeConversation(conversation), {
+        terminalBridge: terminalBridgeEnabled(conversation),
+        approvalState: managedListApprovalState(conversation),
+        conversation
+    }));
     const managedTerminalKeys = new Set(workspaceConversations
         .filter((conversation) => isActiveStatus(conversation.status))
         .map((conversation) => terminalControlSelectorKey(terminalControlFromTakeover(isRecord(conversation.native_session_takeover)
@@ -7358,6 +7604,34 @@ function summarizeConversation(conversation) {
         event_log_path: conversation.event_log_path
     };
 }
+function isDiscoverableTmuxConversation(conversation) {
+    if (!isRecord(conversation)) {
+        return false;
+    }
+    if (!isRecord(conversation.executor)) {
+        return false;
+    }
+    const kind = stringValue(conversation.executor.kind)?.toLowerCase();
+    return (kind !== undefined &&
+        isExecutorKind(kind) &&
+        conversation.executor.transport === "tmux");
+}
+function persistedExecutorLogFields(conversation) {
+    if (isDiscoverableTmuxConversation(conversation)) {
+        const executor = executorForConversation(conversation);
+        return {
+            agent: executor.kind,
+            executor_session: executor.session
+        };
+    }
+    const rawExecutor = isRecord(conversation?.executor)
+        ? conversation.executor
+        : {};
+    return {
+        agent: stringValue(rawExecutor.kind) ?? "unsupported",
+        executor_session: stringValue(rawExecutor.session)
+    };
+}
 function summarizeEvent(event) {
     return {
         ts: event.ts,
@@ -7974,10 +8248,10 @@ function cleanupIdleConversations(storeDir, options = {}, now = new Date()) {
                 idle_timeout_minutes: timeoutMinutes,
                 terminal_bridge: terminalBridge
             });
+            const executorLogFields = persistedExecutorLogFields(conversation);
             runtimeLog("info", "idle_conversation_closed", {
                 conversation_id: conversation.conversation_id,
-                agent: executorForConversation(conversation).kind,
-                executor_session: executorForConversation(conversation).session,
+                ...executorLogFields,
                 state_path: statePath,
                 event_log_path: logPath,
                 idle_since: conversation.idle_since,
@@ -8464,8 +8738,8 @@ function usage() {
   agent-knock-knock send [--conversation <id|selector>] --message <text> [--type answer|task|control] [--agent-timeout-minutes <minutes>] [--agent-hard-timeout-minutes <minutes>]
   agent-knock-knock approve [--conversation <id|selector>] --expected-approval-fingerprint <fingerprint>
   agent-knock-knock cancel [--conversation <id|selector>]
-  agent-knock-knock install-openclaw [--workspace <path>] [--verify] [--openclaw-bin <path>] [--skill-path <path>] [--skill-only] [--no-restart]
-  agent-knock-knock doctor [--workspace <path>] [--openclaw-bin <path>]
+  agent-knock-knock install-openclaw [--verify] [--openclaw-bin <path>] [--skill-path <path>] [--skill-only] [--no-restart]
+  agent-knock-knock doctor [--openclaw-bin <path>]
   agent-knock-knock callback --state <file> --message-json <json> [--record-only]
   agent-knock-knock transcript --log <file> [--include-raw]
   agent-knock-knock transcript --conversation <dir> [--include-raw]