@scotthuang/agent-knock-knock 0.3.2 → 0.5.0

package/dist/src/openclaw-plugin.js

@@ -1,80 +1,27 @@
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { EXECUTOR_KINDS, executorDefinitionForKind, parseLeadingExecutorAlias } from "./executors.js";
-import { AKK_CALLBACK_METHOD, akkUsageText, buildAkkCommandCliArgs, formatAkkListCommandResult, parseAkkCommand, resolvePluginStoreDir, resolveConversationOverrides } from "./openclaw-plugin-helpers.js";
+import { EXECUTOR_KINDS, executorDefinitionForKind } from "./executors.js";
+import { AKK_CALLBACK_METHOD, akkUsageText, buildAkkCommandCliArgs, formatAkkListCommandResult, parseAkkCommand, resolvePluginStoreDir } from "./openclaw-plugin-helpers.js";
 import { attemptAutoApproval } from "./approval-policy.js";
 const CALLBACK_METHOD = AKK_CALLBACK_METHOD;
 const defaultBinPath = fileURLToPath(new URL("./cli.js", import.meta.url));
-const delegateParameters = {
+const sendParameters = {
     type: "object",
     additionalProperties: false,
     required: ["request"],
     properties: {
-        agent: {
+        selector: {
             type: "string",
-            enum: EXECUTOR_KINDS,
-            description: "Coding agent to delegate to. Defaults to plugin config defaultAgent, falling back to codex when unset. Explicit user agent requests override the default."
+            description: "Optional existing tmux target selector from AKK list: codex, claude, only, latest, an @short-ref, or an authoritative full id. Omit it to start a new managed turn through the unique eligible idle pane."
         },
         request: {
             type: "string",
-            description: "Implementation task for the coding agent."
+            description: "New task or follow-up message for the coding agent."
         },
-        workspace: {
-            type: "string",
-            description: "Workspace path for the selected coding agent. Defaults to plugin config or the Gateway process directory."
-        },
-        claudeSession: {
-            type: "string",
-            description: "Claude Code session name."
-        },
-        codexSession: {
-            type: "string",
-            description: "Codex session name."
-        },
-        cursorSession: {
-            type: "string",
-            description: "Cursor session name."
-        },
-        codexAllProxy: {
-            type: "string",
-            description: "ALL_PROXY value used when launching Codex through ACPX."
-        },
-        cursorAllProxy: {
-            type: "string",
-            description: "ALL_PROXY value used when launching Cursor through ACPX."
-        },
-        codexModel: {
-            type: "string",
-            description: "ACPX model id used when launching Codex."
-        },
-        cursorModel: {
-            type: "string",
-            description: "ACPX model id used when launching Cursor."
-        },
-        model: {
-            type: "string",
-            description: "ACPX model id used when launching the selected coding agent."
-        },
-        allProxy: {
-            type: "string",
-            description: "ALL_PROXY value used when launching the selected coding agent through ACPX."
-        },
-        session: {
-            type: "string",
-            description: "Explicit coding agent session name."
-        },
-        openclawSession: {
+        type: {
             type: "string",
-            description: "OpenClaw session label recorded in the protocol state."
-        },
-        softLimit: {
-            type: "number",
-            description: "Soft response-requiring round limit."
-        },
-        hardLimit: {
-            type: "number",
-            description: "Hard response-requiring round limit."
+            enum: ["answer", "task", "control", "error"]
         },
         idleTimeoutMinutes: {
             type: "number",
@@ -83,6 +30,11 @@ const delegateParameters = {
         agentTimeoutMinutes: {
             type: "number",
             description: "Callback timeout in minutes; terminal bridge tasks treat it as an inactivity timeout."
+        },
+        agentHardTimeoutMinutes: {
+            type: "number",
+            exclusiveMinimum: 0,
+            description: "Maximum terminal monitor lifetime in minutes."
         }
     }
 };
@@ -102,7 +54,7 @@ const listParameters = {
         },
         managedOnly: {
             type: "boolean",
-            description: "When true, only list AKK-managed delegated tasks and skip native/terminal active discovery."
+            description: "When true, only list AKK-managed turns and skip live tmux terminal discovery."
         },
         noApprovalScan: {
             type: "boolean",
@@ -162,65 +114,6 @@ const statusParameters = {
         }
     }
 };
-const describeParameters = {
-    type: "object",
-    additionalProperties: false,
-    required: ["conversation_id"],
-    properties: {
-        conversation_id: {
-            type: "string",
-            description: "AKK-managed conversation id, native Codex id, or terminal-controlled id from AKK list. Use this when the user asks what a listed AKK/Codex session is about."
-        },
-        idleTimeoutMinutes: {
-            type: "number"
-        },
-        maxMessages: {
-            type: "number"
-        },
-        maxCommands: {
-            type: "number"
-        },
-        maxTextLength: {
-            type: "number"
-        }
-    }
-};
-const sendParameters = {
-    type: "object",
-    additionalProperties: false,
-    required: ["conversation_id", "message"],
-    properties: {
-        conversation_id: {
-            type: "string",
-            description: "AKK-managed conversation id, or a terminal-controlled id from AKK list such as terminal:v2:tmux:codex:codex-work:0.1:33389. When the user refers to a listed tmux target like my-work:0.1, resolve it to the terminal-controlled id from AKK list before sending."
-        },
-        message: {
-            type: "string"
-        },
-        type: {
-            type: "string",
-            enum: ["answer", "task", "control", "error"]
-        },
-        allProxy: {
-            type: "string"
-        },
-        model: {
-            type: "string"
-        },
-        idleTimeoutMinutes: {
-            type: "number"
-        },
-        agentTimeoutMinutes: {
-            type: "number",
-            description: "Terminal bridge inactivity timeout override in minutes."
-        },
-        agentHardTimeoutMinutes: {
-            type: "number",
-            exclusiveMinimum: 0,
-            description: "Terminal bridge fallback lifetime ceiling override in minutes."
-        }
-    }
-};
 const cancelParameters = {
     type: "object",
     additionalProperties: false,
@@ -230,31 +123,6 @@ const cancelParameters = {
             type: "string",
             description: "AKK-managed conversation id, or a terminal-controlled id from AKK list such as terminal:v2:tmux:codex:codex-work:0.1:33389."
         },
-        allProxy: {
-            type: "string"
-        },
-        idleTimeoutMinutes: {
-            type: "number"
-        }
-    }
-};
-const recoveryParameters = {
-    type: "object",
-    additionalProperties: false,
-    required: ["conversation_id"],
-    properties: {
-        conversation_id: {
-            type: "string"
-        },
-        session: {
-            type: "string"
-        },
-        allProxy: {
-            type: "string"
-        },
-        model: {
-            type: "string"
-        },
         idleTimeoutMinutes: {
             type: "number"
         }
@@ -270,79 +138,10 @@ const closeParameters = {
         },
         reason: {
             type: "string"
-        }
-    }
-};
-const agentTakeoverParameters = {
-    type: "object",
-    additionalProperties: false,
-    required: ["agent", "sessionId", "strategy"],
-    properties: {
-        agent: {
-            type: "string",
-            enum: ["codex"],
-            description: "Local coding agent session provider to plan takeover for. Currently supports Codex."
-        },
-        sessionId: {
-            type: "string",
-            description: "Native Codex session id to inspect or take over."
-        },
-        strategy: {
-            type: "string",
-            enum: ["terminate_then_resume", "fork", "terminal_control"],
-            description: "Takeover strategy. terminate_then_resume returns a confirmation plan to stop the exact active CLI before resume. terminal_control attaches to an existing controllable terminal session after confirmation. fork returns bounded context for OpenClaw summary confirmation."
-        },
-        createConversation: {
-            type: "boolean",
-            description: "When true and the selected strategy is ready, create an AKK-managed conversation bound to the native session so later AKK send/status/close can use it."
-        },
-        confirmTerminate: {
-            type: "boolean",
-            description: "Only for strategy=terminate_then_resume. When true, AKK will terminate the exact expected Codex CLI pid after rechecking that it still matches the requested session, then create the AKK conversation."
-        },
-        expectedPid: {
-            type: "number",
-            description: "Required with confirmTerminate=true. The exact Codex CLI pid from the previous takeover plan that the user confirmed may be terminated."
-        },
-        allowCwdOnly: {
-            type: "boolean",
-            description: "Only for strategy=terminate_then_resume with confirmTerminate=true. Allows terminating the expected pid when Codex does not expose a session id in argv, as long as the pid still runs in the target session cwd. Use only after explaining the higher risk to the user."
-        },
-        confirmTerminal: {
-            type: "boolean",
-            description: "Only for strategy=terminal_control. When true, AKK attaches to the exact terminalTarget after the user confirms that terminal pane."
-        },
-        terminalTarget: {
-            type: "string",
-            description: "Required with confirmTerminal=true. The exact tmux target from the previous terminal_control plan, such as codex-work:0.0."
-        },
-        request: {
-            type: "string",
-            description: "Optional user-visible request label stored on the created AKK conversation."
-        },
-        forkSummary: {
-            type: "string",
-            description: "Required when strategy=fork and createConversation=true. OpenClaw-approved summary of the bounded source context to inject into the new forked AKK session."
-        },
-        openclawSession: {
-            type: "string",
-            description: "OpenClaw session label recorded in the created AKK conversation."
         },
-        codexHome: {
+        expected_message_id: {
             type: "string",
-            description: "Optional Codex home directory. Defaults to ~/.codex."
-        },
-        maxMessages: {
-            type: "number",
-            description: "Maximum rollout messages to include for fork context."
-        },
-        maxCommands: {
-            type: "number",
-            description: "Maximum rollout command records to include for fork context."
-        },
-        maxTextLength: {
-            type: "number",
-            description: "Maximum text length per fork-context message."
+            description: "Required only to clear an orphaned terminal dispatch shown by AKK list. Must exactly match that entry's current message_id."
         }
     }
 };
@@ -364,7 +163,7 @@ const approveParameters = {
 const plugin = definePluginEntry({
     id: "agent-knock-knock",
     name: "Agent Knock Knock",
-    description: "Agent Knock Knock (AKK/akk) delegates OpenClaw coding work to local Codex, Claude, or Cursor agents. Use this for AKK, akk, Agent Knock Knock, Codex delegation, Claude delegation, Cursor delegation, task listing, follow-up messages, status, stalled terminal-monitor renewal, recovery, cancel requests, and close requests. Default delegation target comes from plugin config defaultAgent and falls back to Codex when unset; explicit user agent requests override it.",
+    description: "Agent Knock Knock (AKK/akk) lets OpenClaw operate local Codex and Claude Code through shared tmux terminals, with visible monitoring, approvals, callbacks, cancellation, and seamless human takeover.",
     register(api) {
         api.registerGatewayMethod(CALLBACK_METHOD, async ({ params, respond }) => {
             try {
@@ -387,6 +186,7 @@ const plugin = definePluginEntry({
                     try {
                         const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                         const args = ["reconcile-monitors"];
+                        pushOptional(args, "--workspace", pluginWorkspace(config));
                         pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                         const result = runCli(api, args);
                         api.logger.info?.("agent-knock-knock monitor reconciliation: " +
@@ -407,42 +207,26 @@ const plugin = definePluginEntry({
         }
         api.registerCommand?.({
             name: "akk",
-            description: "Delegate coding work to Agent Knock Knock, list tasks, send follow-ups, cancel running work, and close tasks.",
+            description: "Send coding work through existing Codex or Claude Code tmux terminals, inspect tasks, approve exact prompts, and cancel running work.",
             acceptsArgs: true,
             requireAuth: true,
             nativeProgressMessages: {
                 default: "AKK is handling the request..."
             },
             agentPromptGuidance: [
-                "Use /akk <task> to delegate coding work to Agent Knock Knock. /akk uses the plugin-configured defaultAgent and falls back to Codex when unset; use /akk claude <task>, /akk cursor <task>, or /akk codex <task> when the user explicitly requests that agent."
+                "Use /akk <task> when exactly one eligible idle coding-agent tmux pane should receive new work. Use /akk codex: <task>, /akk claude: <task>, or another selector returned by /akk list to target an existing pane. AKK never starts a coding agent."
             ],
             handler: async (ctx) => handleAkkCommand(api, ctx)
         });
-        api.registerTool((toolContext) => ({
-            label: "AKK Delegate",
-            name: "agent_knock_knock_delegate",
-            description: "Delegate an implementation task to a local coding agent. Use this when the user says AKK, akk, Agent Knock Knock, asks to hand work to Codex, Claude, or Cursor, or asks OpenClaw to start a background coding-agent task. If the user says AKK without an explicit agent, omit the agent parameter so the plugin-configured defaultAgent is used, falling back to Codex when unset. The tool starts the coding agent in the background and returns only protocol metadata, not raw terminal output.",
-            parameters: delegateParameters,
-            async execute(_toolCallId, params) {
-                const result = runDelegate(api, params, toolContext);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(result, null, 2)
-                        }
-                    ],
-                    details: result
-                };
-            }
-        }), { name: "agent_knock_knock_delegate", optional: true });
         registerCliTool(api, {
             name: "agent_knock_knock_list",
-            description: "List Agent Knock Knock work and local active coding-agent sessions. Use this for AKK list, current AKK tasks, native Codex work, terminal-controlled Codex or Claude Code work, or asking which coding-agent sessions are open. The result separates delegated tasks, native processes, and terminal-controlled sessions; terminal entries include approval state when available.",
+            description: "List AKK-managed work and existing Codex or Claude Code tmux terminals. Use this to choose an exact selector before sending, inspecting, approving, or cancelling. AKK reports terminal approval state when available and never starts a coding agent.",
             parameters: listParameters,
             buildArgs: (params) => {
+                const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const args = ["list"];
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(isRecord(api.pluginConfig) ? api.pluginConfig : {}));
+                pushOptional(args, "--workspace", pluginWorkspace(config));
+                pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                 pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(api.pluginConfig?.idleTimeoutMinutes));
                 pushOptional(args, "--agent", stringValue(params.agent));
                 pushOptional(args, "--status", stringValue(params.status));
@@ -461,77 +245,36 @@ const plugin = definePluginEntry({
                 return args;
             }
         });
-        registerCliTool(api, {
+        api.registerTool((_toolContext) => ({
+            label: "AKK Status",
             name: "agent_knock_knock_status",
-            description: "Get detailed status for one Agent Knock Knock coding-agent task or terminal-controlled session. For terminal-controlled ids from AKK list, this is the only read-result/screen-inspection command: AKK captures the terminal pane internally and returns terminal_screen.",
+            description: "Inspect one AKK-managed turn or existing coding-agent tmux terminal. Returns live state, a bounded terminal screen, and available purpose/context with confidence and limitations. AKK never starts a coding agent.",
             parameters: statusParameters,
-            buildArgs: (params) => {
-                const args = ["status", "--conversation", requiredString(params.conversation_id, "conversation_id")];
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(isRecord(api.pluginConfig) ? api.pluginConfig : {}));
-                pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(api.pluginConfig?.idleTimeoutMinutes));
-                if (params.trace === true) {
-                    args.push("--trace");
-                }
-                return args;
-            }
-        });
-        registerCliTool(api, {
-            name: "agent_knock_knock_describe",
-            description: "Describe what a listed Agent Knock Knock or local coding-agent session is about. It summarizes AKK history when available, otherwise uses supported durable agent context or a conservative terminal-screen fallback with confidence and limitations.",
-            parameters: describeParameters,
-            buildArgs: (params) => {
-                const args = ["describe", "--conversation", requiredString(params.conversation_id, "conversation_id")];
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(isRecord(api.pluginConfig) ? api.pluginConfig : {}));
-                pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(api.pluginConfig?.idleTimeoutMinutes));
-                pushOptional(args, "--max-messages", numberString(params.maxMessages));
-                pushOptional(args, "--max-commands", numberString(params.maxCommands));
-                pushOptional(args, "--max-text-length", numberString(params.maxTextLength));
-                return args;
+            async execute(_toolCallId, params) {
+                const result = runCli(api, buildStatusCliArgs(api, isRecord(params) ? params : {}));
+                return toolResult(result);
             }
-        });
-        registerCliTool(api, {
+        }), { name: "agent_knock_knock_status", optional: true });
+        api.registerTool((toolContext) => ({
+            label: "AKK Send",
             name: "agent_knock_knock_send",
-            description: "Send a message, follow-up, or new task to an existing open Agent Knock Knock or terminal-controlled coding-agent session from AKK list, including Codex or Claude Code in tmux. Do not start a new delegate for those requests. This is asynchronous: after acceptance, end the OpenClaw turn and wait for the AKK callback or a later explicit status request.",
+            description: "Send a new task or follow-up through an existing Codex or Claude Code tmux terminal. Omit selector only when AKK should require one unique eligible idle pane; otherwise pass codex, claude, only, latest, an @short-ref from AKK list, or an authoritative full id. AKK never starts a coding agent. This is asynchronous: after acceptance, yield and wait for the callback or a later explicit status request.",
             parameters: sendParameters,
-            buildArgs: (params, toolContext) => {
-                const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
-                const openclawSession = stringValue(toolContext?.sessionKey) ??
-                    stringValue(config.openclawSession) ??
-                    "agent:main:main";
-                const args = [
-                    "send",
-                    "--conversation",
-                    requiredString(params.conversation_id, "conversation_id"),
-                    "--message",
-                    requiredString(params.message, "message"),
-                    "--background"
-                ];
-                pushOptional(args, "--type", stringValue(params.type));
-                const overrides = resolveConversationOverrides(params, config);
-                pushOptional(args, "--all-proxy", overrides.allProxy);
-                pushOptional(args, "--model", overrides.model);
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
-                pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(config.idleTimeoutMinutes));
-                pushOptional(args, "--agent-timeout-minutes", numberString(params.agentTimeoutMinutes) ?? numberString(config.agentTimeoutMinutes));
-                pushOptional(args, "--agent-hard-timeout-minutes", numberString(params.agentHardTimeoutMinutes) ?? numberString(config.agentHardTimeoutMinutes));
-                pushOptional(args, "--openclaw-session", openclawSession);
-                pushOptional(args, "--gateway-method", CALLBACK_METHOD);
-                pushOptional(args, "--gateway-session", openclawSession);
-                pushOptional(args, "--openclaw-bin", stringValue(config.openclawBin));
-                pushOptional(args, "--callback-command", stringValue(config.callbackCommand));
-                pushOptional(args, "--soft-limit", numberString(config.softLimit));
-                pushOptional(args, "--hard-limit", numberString(config.hardLimit));
-                return args;
+            async execute(_toolCallId, params) {
+                const result = await runSendRequest(api, isRecord(params) ? params : {}, toolContext);
+                return toolResult(result);
             }
-        });
+        }), { name: "agent_knock_knock_send", optional: true });
         registerCliTool(api, {
             name: "agent_knock_knock_approve",
             description: "Manually approve the current AKK terminal permission request only after the user reviews and explicitly confirms it. Claude Code uses no Hooks: this manual path accepts only an exact one-time Bash permission screen for the current managed turn, then recaptures its short-lived evidence and process identity before sending Enter. Separately, trusted default-disabled plugin configuration can auto-approve an exact Claude command/workspace match without exposing policy control to the model. Hook-free durable completion is independently verified from the local Claude transcript.",
             parameters: approveParameters,
             buildArgs: (params) => {
+                const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const args = ["approve", "--conversation", requiredString(params.conversation_id, "conversation_id")];
+                pushOptional(args, "--workspace", pluginWorkspace(config));
                 pushOptional(args, "--expected-approval-fingerprint", requiredString(params.expected_approval_fingerprint, "expected_approval_fingerprint"));
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(isRecord(api.pluginConfig) ? api.pluginConfig : {}));
+                pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                 return args;
             }
         });
@@ -543,101 +286,47 @@ const plugin = definePluginEntry({
                 const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const args = ["renew", "--conversation", requiredString(params.conversation_id, "conversation_id")];
                 pushOptional(args, "--minutes", numberString(params.minutes) ?? numberString(config.agentTimeoutMinutes));
+                pushOptional(args, "--workspace", pluginWorkspace(config));
                 pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                 return args;
             }
         });
         registerCliTool(api, {
             name: "agent_knock_knock_retry_callback",
-            description: "Retry a persisted AKK callback that failed before reaching OpenClaw. The original callback message id is reused for idempotent delivery, and the task closes only after delivery succeeds.",
+            description: "Retry a persisted AKK callback that failed before reaching OpenClaw. The original callback message id is reused for idempotent delivery; a completed terminal task remains available for follow-up until idle cleanup.",
             parameters: retryCallbackParameters,
             buildArgs: (params) => {
                 const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const args = ["retry-callback", "--conversation", requiredString(params.conversation_id, "conversation_id")];
+                pushOptional(args, "--workspace", pluginWorkspace(config));
                 pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                 return args;
             }
         });
         registerCliTool(api, {
             name: "agent_knock_knock_cancel",
-            description: "Cancel an existing Agent Knock Knock Codex, Claude, or Cursor task. Delegated sessions use cooperative ACPX cancellation. Terminal-controlled Claude sends Escape to dismiss or interrupt the current screen flow; other adapters use their declared interrupt keys. The underlying tmux pane remains open.",
+            description: "Interrupt an existing Agent Knock Knock Codex or Claude Code tmux task. Claude sends Escape; Codex uses its declared interrupt key. The shared tmux pane remains open for human takeover.",
             parameters: cancelParameters,
             buildArgs: (params) => {
                 const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
-                const overrides = resolveConversationOverrides(params, config);
                 const args = ["cancel", "--conversation", requiredString(params.conversation_id, "conversation_id")];
-                pushOptional(args, "--all-proxy", overrides.allProxy);
+                pushOptional(args, "--workspace", pluginWorkspace(config));
                 pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
                 pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(config.idleTimeoutMinutes));
                 return args;
             }
         });
-        registerCliTool(api, {
-            name: "agent_knock_knock_recover",
-            description: "Recover an Agent Knock Knock task whose coding-agent session is unavailable by starting a new session with AKK's saved protocol history summary plus the pending message. Use only after the user chooses recovery.",
-            parameters: recoveryParameters,
-            buildArgs: (params) => buildRecoveryArgs(api, "recover", params)
-        });
         registerCliTool(api, {
             name: "agent_knock_knock_close",
-            description: "Close an Agent Knock Knock coding-agent task without terminating the underlying ACPX session. Use this for AKK close requests.",
+            description: "Close an AKK-managed task record without terminating the shared tmux pane. For an orphaned terminal dispatch only, the user must explicitly request recovery and provide the exact expected_message_id reported by AKK list.",
             parameters: closeParameters,
             buildArgs: (params) => {
+                const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const args = ["close", "--conversation", requiredString(params.conversation_id, "conversation_id")];
                 pushOptional(args, "--reason", stringValue(params.reason));
-                pushOptional(args, "--store-dir", resolvePluginStoreDir(isRecord(api.pluginConfig) ? api.pluginConfig : {}));
-                return args;
-            }
-        });
-        registerCliTool(api, {
-            name: "agent_knock_knock_agent_takeover",
-            description: "Build or execute a takeover plan for an existing native local coding-agent session. Use this for AKK takeover requests. By default it is side-effect-free and returns the plan; with createConversation=true it can attach a ready native session or create a confirmed forked AKK-managed conversation. For terminate_then_resume, only call with confirmTerminate=true and expectedPid after the user explicitly confirms stopping that exact Codex CLI pid. If Codex does not expose a session id, allowCwdOnly=true is a higher-risk explicit-pid fallback.",
-            parameters: agentTakeoverParameters,
-            buildArgs: (params, toolContext) => {
-                const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
-                const openclawSession = stringValue(toolContext?.sessionKey) ??
-                    stringValue(config.openclawSession) ??
-                    stringValue(params.openclawSession) ??
-                    "agent:main:main";
-                const args = [
-                    "agent",
-                    "takeover",
-                    "--agent",
-                    requiredString(params.agent, "agent"),
-                    "--session-id",
-                    requiredString(params.sessionId, "sessionId"),
-                    "--strategy",
-                    requiredString(params.strategy, "strategy")
-                ];
-                if (params.createConversation === true) {
-                    args.push("--create-conversation");
-                }
-                if (params.confirmTerminate === true) {
-                    args.push("--confirm-terminate");
-                }
-                if (params.allowCwdOnly === true) {
-                    args.push("--allow-cwd-only");
-                }
-                if (params.confirmTerminal === true) {
-                    args.push("--confirm-terminal");
-                }
-                pushOptional(args, "--expected-pid", numberString(params.expectedPid));
-                pushOptional(args, "--terminal-target", stringValue(params.terminalTarget));
-                pushOptional(args, "--request", stringValue(params.request));
-                pushOptional(args, "--fork-summary", stringValue(params.forkSummary));
+                pushOptional(args, "--workspace", pluginWorkspace(config));
+                pushOptional(args, "--expected-message-id", stringValue(params.expected_message_id));
                 pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
-                pushOptional(args, "--openclaw-session", openclawSession);
-                pushOptional(args, "--gateway-method", CALLBACK_METHOD);
-                pushOptional(args, "--gateway-session", openclawSession);
-                pushOptional(args, "--openclaw-bin", stringValue(config.openclawBin));
-                pushOptional(args, "--callback-command", stringValue(config.callbackCommand));
-                pushOptional(args, "--soft-limit", numberString(config.softLimit));
-                pushOptional(args, "--hard-limit", numberString(config.hardLimit));
-                pushOptional(args, "--idle-timeout-minutes", numberString(config.idleTimeoutMinutes));
-                pushOptional(args, "--codex-home", stringValue(params.codexHome) ?? stringValue(api.pluginConfig?.codexHome));
-                pushOptional(args, "--max-messages", numberString(params.maxMessages));
-                pushOptional(args, "--max-commands", numberString(params.maxCommands));
-                pushOptional(args, "--max-text-length", numberString(params.maxTextLength));
                 return args;
             }
         });
@@ -651,13 +340,15 @@ async function handleAkkCommand(api, ctx) {
             return { text: akkUsageText() };
         }
         if (parsed.action === "delegate") {
-            const result = runDelegate(api, {
-                agent: parsed.agent,
+            const result = await runDelegate(api, {
                 request: parsed.request
             }, {
                 sessionKey: ctx.sessionKey
             });
-            return { text: formatDelegateCommandResult(result) };
+            return {
+                text: formatDelegateCommandResult(result),
+                isError: result.status !== "async_pending"
+            };
         }
         const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
         const args = buildAkkCommandCliArgs(parsed, config, {
@@ -681,18 +372,19 @@ async function handleAkkCommand(api, ctx) {
                 return { text: formatAkkListCommandResult(result) };
             case "status":
                 return { text: formatStatusCommandResult(result) };
-            case "describe":
-                return { text: formatDescribeCommandResult(result) };
             case "send":
-                return { text: formatSendCommandResult(result) };
+                return {
+                    text: formatSendCommandResult(result),
+                    isError: ["uncertain", "aborted"].includes(String(result.submission_outcome ?? ""))
+                };
+            case "approve":
+                return { text: formatApproveCommandResult(result) };
             case "renew":
                 return { text: formatRenewCommandResult(result) };
             case "retry-callback":
                 return { text: formatRetryCallbackCommandResult(result) };
             case "cancel":
                 return { text: formatCancelCommandResult(result) };
-            case "recover":
-                return { text: formatRecoveryCommandResult(result) };
             case "close":
                 return { text: formatCloseCommandResult(result) };
         }
@@ -707,6 +399,22 @@ async function handleAkkCommand(api, ctx) {
 }
 function formatDelegateCommandResult(result) {
     const agent = executorDisplayName(result.agent);
+    if (result.status === "submission_uncertain") {
+        return [
+            `AKK could not prove whether ${agent} received the terminal task.`,
+            `conversation: ${result.conversation_id ?? "unknown"}`,
+            `session: ${result.session ?? "unknown"}`,
+            "next: do not retry automatically; inspect AKK status and the named tmux pane."
+        ].join("\n");
+    }
+    if (result.status === "submission_aborted") {
+        return [
+            `AKK stopped before sending the terminal task to ${agent}.`,
+            `conversation: ${result.conversation_id ?? "unknown"}`,
+            `session: ${result.session ?? "unknown"}`,
+            "next: no tmux input was sent, so this request may be retried."
+        ].join("\n");
+    }
     return [
         `AKK delegated the task to ${agent}.`,
         `conversation: ${result.conversation_id ?? "unknown"}`,
@@ -736,12 +444,27 @@ function formatStatusCommandResult(result) {
     if (summary.request) {
         lines.push(`request: ${truncateText(summary.request, 180)}`);
     }
+    if (result.about) {
+        lines.push(`about: ${truncateText(result.about, 500)}`);
+    }
+    if (result.confidence) {
+        lines.push(`confidence: ${result.confidence}`);
+    }
+    const limitations = Array.isArray(result.limitations)
+        ? result.limitations.filter(Boolean)
+        : [];
+    if (limitations.length > 0) {
+        lines.push(`limitations: ${limitations.slice(0, 3).join("; ")}`);
+    }
+    const screen = terminalScreenExcerpt(result);
+    if (screen) {
+        lines.push(`terminal screen:\n${screen}`);
+    }
     return lines.join("\n");
 }
 function formatDoctorCommandResult(result) {
     const capabilities = isRecord(result.capabilities) ? result.capabilities : {};
     const tmux = isRecord(capabilities.tmux) ? capabilities.tmux : {};
-    const acpx = isRecord(capabilities.acpx) ? capabilities.acpx : {};
     const openclaw = isRecord(result.openclaw) ? result.openclaw : {};
     const checks = Array.isArray(openclaw.checks) ? openclaw.checks : [];
     const failures = checks
@@ -752,9 +475,7 @@ function formatDoctorCommandResult(result) {
             : []))].slice(0, 3);
     return [
         `AKK doctor: ${result.ok === true ? "ready" : "needs attention"}`,
-        `mode: ${result.selected_mode ?? "all"}`,
-        `tmux: ${tmux.checked === false ? "not checked" : tmux.status ?? "unknown"}`,
-        `acpx: ${acpx.checked === false ? "not checked" : acpx.status ?? "unknown"}`,
+        `tmux: ${tmux.status ?? "unknown"}`,
         `OpenClaw package: ${openclaw.package_ready === true ? "ready" : "not ready"}`,
         `Gateway: ${openclaw.gateway_ready === true ? "healthy" : "unavailable"}`,
         ...(failures.length > 0 ? [`check: ${failures.join(", ")}`] : []),
@@ -776,26 +497,27 @@ function formatRetryCallbackCommandResult(result) {
         `attempts: ${result.conversation?.callback_delivery?.attempts ?? "unknown"}`
     ].join("\n");
 }
-function formatDescribeCommandResult(result) {
-    const lines = [
-        `AKK description: ${result.conversation_id ?? "unknown"}`,
-        `source: ${result.source ?? "unknown"}`,
-        `confidence: ${result.confidence ?? "unknown"}`
-    ];
-    if (result.about) {
-        lines.push(`about: ${truncateText(result.about, 500)}`);
-    }
-    const limitations = Array.isArray(result.limitations) ? result.limitations.filter(Boolean) : [];
-    if (limitations.length > 0) {
-        lines.push(`limitations: ${limitations.slice(0, 3).join("; ")}`);
-    }
-    return lines.join("\n");
-}
 function formatSendCommandResult(result) {
     const conversation = result.conversation ?? {};
     const conversationId = conversation.conversation_id ?? result.conversation_id ?? "unknown";
     const status = conversation.status ?? result.status ?? "unknown";
     const nextAction = isRecord(result.openclaw_next_action) ? result.openclaw_next_action : undefined;
+    if (result.submission_outcome === "uncertain") {
+        return [
+            "AKK terminal submission outcome is uncertain.",
+            `conversation: ${conversationId}`,
+            `status: ${result.status ?? status}`,
+            "next: do not retry automatically; inspect AKK status and the named tmux pane."
+        ].join("\n");
+    }
+    if (result.submission_outcome === "aborted") {
+        return [
+            "AKK terminal submission was aborted before tmux input.",
+            `conversation: ${conversationId}`,
+            `status: ${result.status ?? status}`,
+            "next: this request was not sent and may be retried."
+        ].join("\n");
+    }
     const lines = [
         "AKK follow-up sent.",
         `conversation: ${conversationId}`,
@@ -822,17 +544,30 @@ function formatCancelCommandResult(result) {
         `status: ${conversation.status ?? (result.cancel_requested === true ? "cancel requested" : "not cancelled")}`
     ].join("\n");
 }
-function formatRecoveryCommandResult(result) {
+function formatApproveCommandResult(result) {
     const conversation = result.conversation ?? {};
     return [
-        "AKK recovery started.",
-        `conversation: ${conversation.conversation_id ?? "unknown"}`,
-        `agent: ${result.executor?.kind ?? conversation.executor?.kind ?? "unknown"}`,
-        `session: ${result.executor?.session ?? conversation.executor?.session ?? "unknown"}`,
-        `status: ${conversation.status ?? "unknown"}`
+        result.approved === true
+            ? "AKK approved the current terminal request."
+            : "AKK did not approve the terminal request.",
+        `conversation: ${conversation.conversation_id ?? result.conversation_id ?? "unknown"}`,
+        `status: ${conversation.status ?? "unknown"}`,
+        ...(result.reason ? [`reason: ${result.reason}`] : [])
     ].join("\n");
 }
 function formatCloseCommandResult(result) {
+    if (result.source === "terminal_control" &&
+        result.terminal_dispatch_resolved === true) {
+        const terminalControl = isRecord(result.terminal_control)
+            ? result.terminal_control
+            : {};
+        return [
+            "AKK cleared the unresolved terminal dispatch fence.",
+            `terminal: ${terminalControl.target ?? "unknown"}`,
+            `previous owner: ${result.owner_conversation_id ?? "unknown"}`,
+            "The coding agent and tmux pane remain open."
+        ].join("\n");
+    }
     const conversation = result.conversation ?? {};
     return [
         "AKK session closed.",
@@ -840,35 +575,88 @@ function formatCloseCommandResult(result) {
         `status: ${conversation.status ?? "unknown"}`
     ].join("\n");
 }
-function runDelegate(api, params, toolContext) {
+function buildStatusCliArgs(api, params) {
+    const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
+    const args = [
+        "status",
+        "--conversation",
+        requiredString(params.conversation_id, "conversation_id")
+    ];
+    pushOptional(args, "--workspace", pluginWorkspace(config));
+    pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
+    pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ??
+        numberString(api.pluginConfig?.idleTimeoutMinutes));
+    if (params.trace === true) {
+        args.push("--trace");
+    }
+    return args;
+}
+function terminalScreenExcerpt(result) {
+    const screen = result.terminal_screen;
+    const text = typeof screen === "string"
+        ? screen
+        : isRecord(screen)
+            ? stringValue(screen.excerpt) ??
+                stringValue(screen.text) ??
+                stringValue(screen.content)
+            : undefined;
+    if (!text) {
+        return undefined;
+    }
+    return text.length <= 1600
+        ? text
+        : `…${text.slice(-1599)}`;
+}
+async function runSendRequest(api, params, toolContext) {
+    const selector = stringValue(params.selector);
+    if (!selector) {
+        return runDelegate(api, params, toolContext);
+    }
     const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
-    const binPath = stringValue(config.binPath) ?? defaultBinPath;
-    const workspace = stringValue(params.workspace) ?? stringValue(config.workspace) ?? process.cwd();
-    const rawRequest = requiredString(params.request, "request");
-    const prefixedRequest = stringValue(params.agent) ? undefined : parseLeadingExecutorAlias(rawRequest);
-    const request = prefixedRequest?.request ?? rawRequest;
-    const agent = executorDefinitionForKind(stringValue(params.agent) ?? prefixedRequest?.kind ?? stringValue(config.defaultAgent) ?? "codex").kind;
-    const executorDefinition = executorDefinitionForKind(agent);
-    const agentSession = stringValue(params.session) ??
-        firstStringForKeys(params, executorDefinition.sessionConfigKeys) ??
-        firstStringForKeys(config, executorDefinition.sessionConfigKeys);
-    const allProxy = stringValue(params.allProxy) ??
-        firstStringForKeys(params, executorDefinition.proxyConfigKeys) ??
-        firstStringForKeys(config, executorDefinition.proxyConfigKeys) ??
-        stringValue(config.allProxy);
-    const model = stringValue(params.model) ??
-        firstStringForKeys(params, executorDefinition.modelConfigKeys) ??
-        firstStringForKeys(config, executorDefinition.modelConfigKeys) ??
-        stringValue(config.model);
     const openclawSession = stringValue(toolContext?.sessionKey) ??
-        stringValue(config.openclawSession) ??
-        stringValue(params.openclawSession) ??
         "agent:main:main";
     const args = [
-        binPath,
+        "send",
+        "--conversation",
+        selector,
+        "--message",
+        requiredString(params.request, "request"),
+        "--background"
+    ];
+    pushOptional(args, "--type", stringValue(params.type));
+    pushOptional(args, "--workspace", pluginWorkspace(config));
+    pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
+    pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ??
+        numberString(config.idleTimeoutMinutes));
+    pushOptional(args, "--agent-timeout-minutes", numberString(params.agentTimeoutMinutes) ??
+        numberString(config.agentTimeoutMinutes));
+    pushOptional(args, "--agent-hard-timeout-minutes", numberString(params.agentHardTimeoutMinutes) ??
+        numberString(config.agentHardTimeoutMinutes));
+    pushOptional(args, "--openclaw-session", openclawSession);
+    pushOptional(args, "--gateway-method", CALLBACK_METHOD);
+    pushOptional(args, "--gateway-session", openclawSession);
+    pushOptional(args, "--openclaw-bin", stringValue(config.openclawBin));
+    return runCli(api, args);
+}
+function toolResult(result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }
+        ],
+        details: result
+    };
+}
+async function runDelegate(api, params, toolContext) {
+    const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
+    const workspace = pluginWorkspace(config);
+    const request = requiredString(params.request, "request");
+    const openclawSession = stringValue(toolContext?.sessionKey) ??
+        "agent:main:main";
+    const args = [
         "delegate",
-        "--agent",
-        agent,
         "--request",
         request,
         "--workspace",
@@ -876,56 +664,74 @@ function runDelegate(api, params, toolContext) {
         "--background"
     ];
     pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
-    pushOptional(args, "--session", agentSession);
-    pushOptional(args, "--all-proxy", allProxy);
-    pushOptional(args, "--model", model);
     pushOptional(args, "--openclaw-session", openclawSession);
     pushOptional(args, "--gateway-method", CALLBACK_METHOD);
     pushOptional(args, "--gateway-session", openclawSession);
     pushOptional(args, "--openclaw-bin", stringValue(config.openclawBin));
-    pushOptional(args, "--callback-command", stringValue(config.callbackCommand));
-    pushOptional(args, "--soft-limit", numberString(params.softLimit) ?? numberString(config.softLimit));
-    pushOptional(args, "--hard-limit", numberString(params.hardLimit) ?? numberString(config.hardLimit));
     pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(config.idleTimeoutMinutes));
     pushOptional(args, "--agent-timeout-minutes", numberString(params.agentTimeoutMinutes) ?? numberString(config.agentTimeoutMinutes));
-    const spawned = spawnSync(process.execPath, args, {
-        encoding: "utf8",
-        maxBuffer: 1024 * 1024 * 10,
-        cwd: workspace
-    });
-    if (spawned.error) {
-        throw new Error(`agent-knock-knock delegate failed to start: ${spawned.error.message}`);
-    }
-    if (spawned.status !== 0) {
-        throw new Error(cleanError(spawned.stderr || spawned.stdout || `agent-knock-knock delegate exited with status ${spawned.status}`));
-    }
-    const parsed = parseJson(spawned.stdout);
-    const conversationId = parsed.conversation?.conversation_id;
-    const statePath = parsed.paths?.statePath;
-    const logPath = parsed.paths?.logPath;
+    pushOptional(args, "--agent-hard-timeout-minutes", numberString(params.agentHardTimeoutMinutes) ?? numberString(config.agentHardTimeoutMinutes));
+    const parsed = await runCliAsync(api, args, { cwd: workspace });
+    const conversationId = parsed.conversation?.conversation_id ??
+        parsed.conversation_id;
+    const statePath = parsed.conversation?.state_path ??
+        parsed.paths?.statePath;
+    const logPath = parsed.conversation?.event_log_path ??
+        parsed.paths?.logPath;
+    const submissionUncertain = parsed.submission_outcome === "uncertain";
+    const submissionAborted = parsed.submission_outcome === "aborted";
+    const agent = stringValue(parsed.conversation?.executor?.kind) ??
+        stringValue(parsed.agent);
     return {
-        status: "async_pending",
-        delegation_status: "delegated",
+        status: submissionUncertain
+            ? "submission_uncertain"
+            : submissionAborted
+                ? "submission_aborted"
+                : "async_pending",
+        delegation_status: submissionUncertain
+            ? "uncertain"
+            : submissionAborted
+                ? "aborted"
+                : "delegated",
         conversation_id: conversationId,
         conversation_status: parsed.conversation?.status,
         state_path: statePath,
         event_log_path: logPath,
         agent,
         executor: parsed.conversation?.executor,
-        session: parsed.conversation?.executor?.session ?? parsed.conversation?.claude_session,
-        claude_session: parsed.conversation?.claude_session,
+        session: parsed.conversation?.executor?.session ??
+            parsed.terminal_control?.target,
         openclaw_session: openclawSession,
         launched: parsed.launched === true,
+        replayed: parsed.replayed === true,
         background: parsed.background === true,
-        pid: parsed.pid ?? null,
+        pid: parsed.pid ?? parsed.terminal_control?.panePid ?? null,
         callback_method: CALLBACK_METHOD,
-        openclaw_next_action: {
-            action: "yield",
-            reason: "The delegated coding agent is running asynchronously. End this OpenClaw turn now and wait for an Agent Knock Knock callback.",
-            do_not: "Do not inspect event logs, process lists, session internals, files, stdout, or stderr while waiting. Follow-up communication must only use structured callbacks from agent-knock-knock.",
-            expected_callback: "The callback will be injected and scheduled into this OpenClaw session by the agent-knock-knock.callback Gateway method."
-        },
-        note: "The coding agent was launched in the background. This is an async delegation; OpenClaw should yield now and wait for the scheduled callback turn."
+        ...(submissionUncertain
+            ? {
+                submission_outcome: "uncertain",
+                do_not_retry: true,
+                reason: parsed.reason,
+                openclaw_next_action: parsed.openclaw_next_action,
+                note: "AKK could not prove whether tmux accepted Enter. Do not retry automatically; inspect the durable AKK conversation and shared terminal."
+            }
+            : submissionAborted
+                ? {
+                    submission_outcome: "aborted",
+                    safe_to_retry: true,
+                    reason: parsed.reason,
+                    openclaw_next_action: parsed.openclaw_next_action,
+                    note: "AKK stopped before sending tmux input. The request was not submitted and may be retried."
+                }
+                : {
+                    openclaw_next_action: {
+                        action: "yield",
+                        reason: "The coding agent is working in the shared tmux terminal. End this OpenClaw turn now and wait for an Agent Knock Knock callback.",
+                        do_not: "Do not poll terminal internals while waiting. Follow-up communication must use Agent Knock Knock tools so the same shared terminal remains authoritative.",
+                        expected_callback: "The callback will be injected and scheduled into this OpenClaw session by the agent-knock-knock.callback Gateway method."
+                    },
+                    note: "The task was sent to the shared tmux terminal. OpenClaw should yield now and wait for the scheduled callback turn."
+                })
     };
 }
 function registerCliTool(api, { name, description, parameters, buildArgs }) {
@@ -957,17 +763,6 @@ function toolLabel(name) {
         .join(" ");
     return `AKK ${action || "Tool"}`;
 }
-function buildRecoveryArgs(api, command, params) {
-    const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
-    const overrides = resolveConversationOverrides(params, config);
-    const args = [command, "--conversation", requiredString(params.conversation_id, "conversation_id"), "--background"];
-    pushOptional(args, "--session", stringValue(params.session));
-    pushOptional(args, "--all-proxy", overrides.allProxy);
-    pushOptional(args, "--model", overrides.model);
-    pushOptional(args, "--store-dir", resolvePluginStoreDir(config));
-    pushOptional(args, "--idle-timeout-minutes", numberString(params.idleTimeoutMinutes) ?? numberString(config.idleTimeoutMinutes));
-    return args;
-}
 function runCli(api, cliArgs, { cwd = process.cwd(), allowNonzeroJson = false } = {}) {
     const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
     const binPath = stringValue(config.binPath) ?? defaultBinPath;
@@ -1142,7 +937,13 @@ function tryAutoApproveCallback({ api, message, conversationId, statePath }) {
         message,
         policy: config.autoApprove,
         statePath,
-        execute: (args) => runCli(api, args)
+        execute: (args) => {
+            return runCli(api, [
+                ...args,
+                "--workspace",
+                pluginWorkspace(config)
+            ]);
+        }
     });
     if (result) {
         api.logger.info?.(`agent-knock-knock approval policy for ${conversationId ?? "unknown"}: ${result.action} (${result.reason})`);
@@ -1205,13 +1006,15 @@ function formatDoneShortcuts(conversationId) {
         "",
         "[AKK convenience commands]",
         "When summarizing this result to the user, include these short next-step commands:",
-        "- `AKK list` lists open AKK sessions.",
-        `- \`AKK send ${conversationId}: <message>\` sends a follow-up to this same AKK session.`,
-        `- \`AKK status ${conversationId}\` shows this session status.`,
-        `- \`AKK cancel ${conversationId}\` requests cancellation of current running work without closing this AKK session.`,
-        `- \`AKK close ${conversationId}\` closes this AKK session.`
+        "- `AKK list` lists live shared terminals and open AKK tasks.",
+        "- Use the matching `@short-ref` from `AKK list`, then `AKK @short-ref: <message>` to continue in the same shared terminal.",
+        `- \`AKK status ${conversationId}\` shows this task record.`,
+        "- AKK never starts or closes the coding agent or tmux pane."
     ].join("\n");
 }
+function pluginWorkspace(config) {
+    return stringValue(config.workspace) ?? process.cwd();
+}
 function pushOptional(args, flag, value) {
     if (value !== undefined && value !== "") {
         args.push(flag, value);
@@ -1223,18 +1026,6 @@ function isRecord(value) {
 function stringValue(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
-function firstStringForKeys(source, keys) {
-    if (!isRecord(source)) {
-        return undefined;
-    }
-    for (const key of keys) {
-        const value = stringValue(source[key]);
-        if (value) {
-            return value;
-        }
-    }
-    return undefined;
-}
 function numberString(value) {
     return typeof value === "number" && Number.isFinite(value) ? String(value) : undefined;
 }
@@ -1256,7 +1047,7 @@ function parseJson(text) {
         return JSON.parse(text);
     }
     catch (error) {
-        throw new Error(`agent-knock-knock delegate returned invalid JSON: ${error.message}`);
+        throw new Error(`agent-knock-knock CLI returned invalid JSON: ${error.message}`);
     }
 }
 function cleanError(text) {