@scotthuang/agent-knock-knock 0.3.2 → 0.4.0

package/dist/src/openclaw-plugin.js

@@ -2,7 +2,7 @@ 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 { 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));
@@ -24,58 +24,6 @@ const delegateParameters = {
             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: "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."
-        },
         idleTimeoutMinutes: {
             type: "number",
             description: "Minutes an idle AKK session remains open before lazy cleanup closes it."
@@ -83,6 +31,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."
         }
     }
 };
@@ -201,12 +154,6 @@ const sendParameters = {
             type: "string",
             enum: ["answer", "task", "control", "error"]
         },
-        allProxy: {
-            type: "string"
-        },
-        model: {
-            type: "string"
-        },
         idleTimeoutMinutes: {
             type: "number"
         },
@@ -230,31 +177,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,6 +192,10 @@ const closeParameters = {
         },
         reason: {
             type: "string"
+        },
+        expected_message_id: {
+            type: "string",
+            description: "Required only to clear an orphaned terminal dispatch shown by AKK list. Must exactly match that entry's current message_id."
         }
     }
 };
@@ -289,25 +215,13 @@ const agentTakeoverParameters = {
         },
         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."
+            enum: ["terminal_control"],
+            description: "Attach to the existing Codex process through its shared tmux terminal."
         },
         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."
@@ -320,29 +234,9 @@ const agentTakeoverParameters = {
             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: {
             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."
         }
     }
 };
@@ -364,7 +258,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 {
@@ -414,17 +308,17 @@ const plugin = definePluginEntry({
                 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> to send work through a uniquely matching idle tmux terminal. /akk uses the plugin-configured defaultAgent and falls back to Codex; use /akk claude <task> or /akk codex <task> when the user explicitly requests that 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.",
+            description: "Send an implementation task to a uniquely matching idle Codex or Claude Code tmux terminal. AKK never starts a hidden coding-agent runtime; no match or an ambiguous match fails closed with setup guidance. Omit agent to use the configured default, falling back to Codex.",
             parameters: delegateParameters,
             async execute(_toolCallId, params) {
-                const result = runDelegate(api, params, toolContext);
+                const result = await runDelegate(api, params, toolContext);
                 return {
                     content: [
                         {
@@ -496,7 +390,6 @@ const plugin = definePluginEntry({
             buildArgs: (params, toolContext) => {
                 const config = isRecord(api.pluginConfig) ? api.pluginConfig : {};
                 const openclawSession = stringValue(toolContext?.sessionKey) ??
-                    stringValue(config.openclawSession) ??
                     "agent:main:main";
                 const args = [
                     "send",
@@ -507,9 +400,6 @@ const plugin = definePluginEntry({
                     "--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));
@@ -518,9 +408,6 @@ const plugin = definePluginEntry({
                 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;
             }
         });
@@ -549,7 +436,7 @@ const plugin = definePluginEntry({
         });
         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 : {};
@@ -560,44 +447,35 @@ const plugin = definePluginEntry({
         });
         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, "--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 args = ["close", "--conversation", requiredString(params.conversation_id, "conversation_id")];
                 pushOptional(args, "--reason", stringValue(params.reason));
+                pushOptional(args, "--expected-message-id", stringValue(params.expected_message_id));
                 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.",
+            description: "Build or execute a terminal-control attachment plan for an existing Codex session running inside tmux. The first call is side-effect-free; attach only after the user confirms the exact tmux target.",
             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",
@@ -612,32 +490,18 @@ const plugin = definePluginEntry({
                 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, "--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 +515,16 @@ async function handleAkkCommand(api, ctx) {
             return { text: akkUsageText() };
         }
         if (parsed.action === "delegate") {
-            const result = runDelegate(api, {
+            const result = await runDelegate(api, {
                 agent: parsed.agent,
                 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, {
@@ -684,15 +551,18 @@ async function handleAkkCommand(api, ctx) {
             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 +577,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"}`,
@@ -741,7 +627,6 @@ function formatStatusCommandResult(result) {
 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 +637,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(", ")}`] : []),
@@ -796,6 +679,22 @@ function formatSendCommandResult(result) {
     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 +721,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,7 +752,7 @@ function formatCloseCommandResult(result) {
         `status: ${conversation.status ?? "unknown"}`
     ].join("\n");
 }
-function runDelegate(api, params, toolContext) {
+async function 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();
@@ -848,21 +760,7 @@ function runDelegate(api, params, toolContext) {
     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,
@@ -876,56 +774,72 @@ 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.slice(1), { 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";
     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 +871,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;
@@ -1205,11 +1108,10 @@ 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.",
+        `- \`AKK send ${conversationId}: <message>\` continues in this same shared terminal.`,
+        `- \`AKK status ${conversationId}\` shows this task record.`,
+        `- \`AKK close ${conversationId}\` closes the AKK record without closing tmux.`
     ].join("\n");
 }
 function pushOptional(args, flag, value) {
@@ -1223,18 +1125,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;
 }