fix(exec): resume agent session after approval completion

Nanako0129 · steipete · commit 63da2c703428 · 2026-04-01T17:56:55.000+09:00
diff --git a/src/agents/bash-tools.exec-approval-followup.test.ts b/src/agents/bash-tools.exec-approval-followup.test.ts
@@ -36,6 +36,13 @@ describe("exec approval followup", () => {
     expect(prompt).not.toContain("already approved has completed");
   });
 
+  it("tells the agent to continue the task before replying when the command succeeds", () => {
+    const prompt = buildExecApprovalFollowupPrompt("Exec finished (gateway id=req-1, code 0)\nok");
+
+    expect(prompt).toContain("continue from this result before replying to the user");
+    expect(prompt).toContain("Continue the task if needed, then reply to the user");
+  });
+
   it("keeps followups internal when no external route is available", async () => {
     await sendExecApprovalFollowup({
       approvalId: "req-1",
@@ -79,7 +86,7 @@ describe("exec approval followup", () => {
       accountId: "default",
       threadId: "789",
     },
-  ])("uses direct external delivery for $channel followups", async (target) => {
+  ])("uses agent continuation for $channel followups when a session exists", async (target) => {
     await sendExecApprovalFollowup({
       approvalId: `req-${target.channel}`,
       sessionKey: target.sessionKey,
@@ -90,17 +97,42 @@ describe("exec approval followup", () => {
       resultText: "slack exec approval smoke",
     });
 
-    expect(sendMessage).toHaveBeenCalledWith(
+    expect(callGatewayTool).toHaveBeenCalledWith(
+      "agent",
+      expect.any(Object),
       expect.objectContaining({
+        sessionKey: target.sessionKey,
+        deliver: true,
+        bestEffortDeliver: true,
         channel: target.channel,
         to: target.to,
         accountId: target.accountId,
         threadId: target.threadId,
-        content: "slack exec approval smoke",
-        mirror: expect.objectContaining({
-          sessionKey: target.sessionKey,
-          idempotencyKey: `exec-approval-followup:req-${target.channel}`,
-        }),
+        idempotencyKey: `exec-approval-followup:req-${target.channel}`,
+      }),
+      { expectFinal: true },
+    );
+    expect(sendMessage).not.toHaveBeenCalled();
+  });
+
+  it("falls back to direct external delivery only when no session exists", async () => {
+    await sendExecApprovalFollowup({
+      approvalId: "req-no-session",
+      turnSourceChannel: "discord",
+      turnSourceTo: "123",
+      turnSourceAccountId: "default",
+      turnSourceThreadId: "456",
+      resultText: "discord exec approval smoke",
+    });
+
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel: "discord",
+        to: "123",
+        accountId: "default",
+        threadId: "456",
+        content: "discord exec approval smoke",
+        idempotencyKey: "exec-approval-followup:req-no-session",
       }),
     );
     expect(callGatewayTool).not.toHaveBeenCalled();
diff --git a/src/agents/bash-tools.exec-approval-followup.ts b/src/agents/bash-tools.exec-approval-followup.ts
@@ -1,6 +1,5 @@
 import { resolveExternalBestEffortDeliveryTarget } from "../infra/outbound/best-effort-delivery.js";
 import { sendMessage } from "../infra/outbound/message.js";
-import { parseAgentSessionKey } from "../routing/session-key.js";
 import { isGatewayMessageChannel, normalizeMessageChannel } from "../utils/message-channel.js";
 import { callGatewayTool } from "./tools/gateway.js";
 
@@ -38,11 +37,13 @@ export function buildExecApprovalFollowupPrompt(resultText: string): string {
   return [
     "An async command the user already approved has completed.",
     "Do not run the command again.",
+    "If the task requires more steps, continue from this result before replying to the user.",
+    "Only ask the user for help if you are actually blocked.",
     "",
     "Exact completion details:",
     trimmed,
     "",
-    "Reply to the user in a helpful way.",
+    "Continue the task if needed, then reply to the user in a helpful way.",
     "If it succeeded, share the relevant output.",
     "If it failed, explain what went wrong.",
   ].join("\n");
@@ -69,59 +70,50 @@ export async function sendExecApprovalFollowup(
       ? normalizedTurnSourceChannel
       : undefined;
 
+  if (sessionKey) {
+    await callGatewayTool(
+      "agent",
+      { timeoutMs: 60_000 },
+      {
+        sessionKey,
+        message: buildExecApprovalFollowupPrompt(resultText),
+        deliver: deliveryTarget.deliver,
+        ...(deliveryTarget.deliver ? { bestEffortDeliver: true as const } : {}),
+        channel: deliveryTarget.deliver ? deliveryTarget.channel : sessionOnlyOriginChannel,
+        to: deliveryTarget.deliver
+          ? deliveryTarget.to
+          : sessionOnlyOriginChannel
+            ? params.turnSourceTo
+            : undefined,
+        accountId: deliveryTarget.deliver
+          ? deliveryTarget.accountId
+          : sessionOnlyOriginChannel
+            ? params.turnSourceAccountId
+            : undefined,
+        threadId: deliveryTarget.deliver
+          ? deliveryTarget.threadId
+          : sessionOnlyOriginChannel
+            ? params.turnSourceThreadId
+            : undefined,
+        idempotencyKey: `exec-approval-followup:${params.approvalId}`,
+      },
+      { expectFinal: true },
+    );
+    return true;
+  }
+
   if (deliveryTarget.deliver) {
-    const requesterAgentId = sessionKey ? parseAgentSessionKey(sessionKey)?.agentId : undefined;
     await sendMessage({
       channel: deliveryTarget.channel,
       to: deliveryTarget.to ?? "",
       accountId: deliveryTarget.accountId,
       threadId: deliveryTarget.threadId,
       content: resultText,
-      agentId: requesterAgentId,
+      agentId: undefined,
       idempotencyKey: `exec-approval-followup:${params.approvalId}`,
-      mirror: sessionKey
-        ? {
-            sessionKey,
-            agentId: requesterAgentId,
-            idempotencyKey: `exec-approval-followup:${params.approvalId}`,
-          }
-        : undefined,
     });
     return true;
   }
 
-  if (!sessionKey) {
-    throw new Error("Session key or deliverable origin route is required");
-  }
-
-  await callGatewayTool(
-    "agent",
-    { timeoutMs: 60_000 },
-    {
-      sessionKey,
-      message: buildExecApprovalFollowupPrompt(resultText),
-      deliver: deliveryTarget.deliver,
-      ...(deliveryTarget.deliver ? { bestEffortDeliver: true as const } : {}),
-      channel: deliveryTarget.deliver ? deliveryTarget.channel : sessionOnlyOriginChannel,
-      to: deliveryTarget.deliver
-        ? deliveryTarget.to
-        : sessionOnlyOriginChannel
-          ? params.turnSourceTo
-          : undefined,
-      accountId: deliveryTarget.deliver
-        ? deliveryTarget.accountId
-        : sessionOnlyOriginChannel
-          ? params.turnSourceAccountId
-          : undefined,
-      threadId: deliveryTarget.deliver
-        ? deliveryTarget.threadId
-        : sessionOnlyOriginChannel
-          ? params.turnSourceThreadId
-          : undefined,
-      idempotencyKey: `exec-approval-followup:${params.approvalId}`,
-    },
-    { expectFinal: true },
-  );
-
-  return true;
+  throw new Error("Session key or deliverable origin route is required");
 }
diff --git a/src/agents/bash-tools.exec.approval-id.test.ts b/src/agents/bash-tools.exec.approval-id.test.ts
@@ -25,17 +25,23 @@ vi.mock("../infra/exec-obfuscation-detect.js", () => ({
   })),
 }));
 
+vi.mock("../infra/outbound/message.js", () => ({
+  sendMessage: vi.fn(async () => ({ ok: true })),
+}));
+
 let callGatewayTool: typeof import("./tools/gateway.js").callGatewayTool;
 let createExecTool: typeof import("./bash-tools.exec.js").createExecTool;
 let detectCommandObfuscation: typeof import("../infra/exec-obfuscation-detect.js").detectCommandObfuscation;
 let getExecApprovalApproverDmNoticeText: typeof import("../infra/exec-approval-reply.js").getExecApprovalApproverDmNoticeText;
+let sendMessage: typeof import("../infra/outbound/message.js").sendMessage;
 
 async function loadExecApprovalModules() {
   vi.resetModules();
   ({ callGatewayTool } = await import("./tools/gateway.js"));
   ({ createExecTool } = await import("./bash-tools.exec.js"));
   ({ detectCommandObfuscation } = await import("../infra/exec-obfuscation-detect.js"));
   ({ getExecApprovalApproverDmNoticeText } = await import("../infra/exec-approval-reply.js"));
+  ({ sendMessage } = await import("../infra/outbound/message.js"));
 }
 
 function buildPreparedSystemRunPayload(rawInvokeParams: unknown) {
@@ -472,6 +478,55 @@ describe("exec approvals", () => {
     );
   });
 
+  it("continues the original agent session after approved gateway exec completes with an external route", async () => {
+    const agentCalls: Array<Record<string, unknown>> = [];
+
+    mockAcceptedApprovalFlow({
+      onAgent: (params) => {
+        agentCalls.push(params);
+      },
+    });
+
+    const tool = createExecTool({
+      host: "gateway",
+      ask: "always",
+      approvalRunningNoticeMs: 0,
+      sessionKey: "agent:main:discord:channel:123",
+      elevated: { enabled: true, allowed: true, defaultLevel: "ask" },
+      messageProvider: "discord",
+      currentChannelId: "123",
+      accountId: "default",
+      currentThreadTs: "456",
+    });
+
+    const result = await tool.execute("call-gw-followup-discord", {
+      command: "echo ok",
+      workdir: process.cwd(),
+      gatewayUrl: undefined,
+      gatewayToken: undefined,
+    });
+
+    expect(result.details.status).toBe("approval-pending");
+    await expect.poll(() => agentCalls.length, { timeout: 3_000, interval: 20 }).toBe(1);
+    expect(agentCalls[0]).toEqual(
+      expect.objectContaining({
+        sessionKey: "agent:main:discord:channel:123",
+        deliver: true,
+        bestEffortDeliver: true,
+        channel: "discord",
+        to: "123",
+        accountId: "default",
+        threadId: "456",
+        idempotencyKey: expect.stringContaining("exec-approval-followup:"),
+      }),
+    );
+    expect(typeof agentCalls[0]?.message).toBe("string");
+    expect(agentCalls[0]?.message).toContain(
+      "If the task requires more steps, continue from this result before replying to the user.",
+    );
+    expect(sendMessage).not.toHaveBeenCalled();
+  });
+
   it("executes approved commands and emits a session-only followup in webchat-only mode", async () => {
     const agentCalls: Array<Record<string, unknown>> = [];
     const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-exec-followup-sidefx-"));
