fix(subagents): rebase onto main — keep no-deliverable-payload notice slice

Alfred · Alfred · commit 6476dae70c80 · 2026-07-12T17:48:18.000-04:00
RC1 (wait-timer pending-timeout forwarding) is superseded on main: shared terminal-outcome classifier with fresh-wait isolation. This branch now carries only the delivery-layer slice: - Synthesize a bounded, closed-vocabulary terminal notice for no-deliverable-payload subagent completions (statusLabel is never echoed; reasons are limited to no visible reply / timed out / failed (details withheld) / incomplete). - Reorder the message-tool-only delivery branch so the text-direct fallback runs before the failed-no-output early-out. - Regression tests for the notice vocabulary (incl. sensitive-label cases) plus wait-timer hard/soft coverage locking main's #89367 semantics. Restart-cancelled completions resolve through main's direct terminal path by design and are not re-tested here.
diff --git a/src/agents/subagent-announce-delivery.test.ts b/src/agents/subagent-announce-delivery.test.ts
@@ -1385,7 +1385,7 @@ describe("deliverSubagentAnnouncement completion delivery", () => {
     });
   });
 
-  it("does not directly deliver failed subagent placeholder output", async () => {
+  it("delivers a synthesized terminal notice when a direct-message subagent fails with no output (#89095)", async () => {
     const callGateway = createGatewayMock({
       result: {
         payloads: [],
@@ -1413,12 +1413,239 @@ describe("deliverSubagentAnnouncement completion delivery", () => {
     });
 
     expectRecordFields(result, {
-      delivered: false,
+      delivered: true,
       path: "direct",
-      reason: "visible_reply_missing",
-      error: "completion agent did not produce a visible reply",
     });
-    expect(sendMessage).not.toHaveBeenCalled();
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content: expect.stringMatching(
+          /^Background task finished without producing a visible reply \(status: error, reason: no visible reply\)\.$/,
+        ),
+        idempotencyKey: "announce-dm-fallback-empty:text-direct",
+      }),
+    );
+  });
+
+  it("delivers a synthesized terminal notice for a clean completion with empty payload (#89095)", async () => {
+    // jrex-jooni's 2026-06-22 verified data point: context-overflow-driven
+    // mid-turn compaction reliably produces a cleanly-stopped child (no error,
+    // stopReason=stop) whose wrap-up completion turn emits no visible payload.
+    // Internally this surfaces as a task_completion with status:"ok" and an
+    // empty result. The old fallback only returned ok-with-content, so this
+    // case dropped to visible_reply_missing and the parent yielded via
+    // sessions_yield never woke.
+    const callGateway = createGatewayMock({
+      result: {
+        payloads: [],
+      },
+    });
+    const sendMessage = createSendMessageMock();
+
+    const result = await deliverDiscordDirectMessageCompletion({
+      callGateway,
+      sendMessage,
+      internalEvents: [
+        {
+          type: "task_completion",
+          source: "subagent",
+          childSessionKey: "agent:worker:subagent:child",
+          childSessionId: "child-session-id",
+          announceType: "subagent task",
+          taskLabel: "clean stop empty payload",
+          status: "ok",
+          statusLabel: "completed",
+          result: "",
+          replyInstruction: "Summarize the result.",
+        },
+      ],
+    });
+
+    expectRecordFields(result, {
+      delivered: true,
+      path: "direct",
+    });
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content:
+          "Background task finished without producing a visible reply (status: ok, reason: no visible reply).",
+      }),
+    );
+  });
+
+  it("delivers a synthesized terminal notice for a timeout-killed subagent with no output (#89095)", async () => {
+    // sunnydongbo's verified case: runTimeoutSeconds force-kill of a blocking
+    // child (sleep 600) produced status: "timeout" + result: "(no output)";
+    // wait-timer fix alone is necessary but not sufficient — without the synth
+    // path, delivery still abandons after 3 retries with
+    // "completion agent did not produce a visible reply".
+    const callGateway = createGatewayMock({
+      result: {
+        payloads: [],
+      },
+    });
+    const sendMessage = createSendMessageMock();
+
+    const result = await deliverDiscordDirectMessageCompletion({
+      callGateway,
+      sendMessage,
+      internalEvents: [
+        {
+          type: "task_completion",
+          source: "subagent",
+          childSessionKey: "agent:worker:subagent:child",
+          childSessionId: "child-session-id",
+          announceType: "subagent task",
+          taskLabel: "timeout-killed child",
+          status: "timeout",
+          statusLabel: "timed out",
+          result: "(no output)",
+          replyInstruction: "Summarize the result.",
+        },
+      ],
+    });
+
+    expectRecordFields(result, {
+      delivered: true,
+      path: "direct",
+    });
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content:
+          "Background task finished without producing a visible reply (status: timeout, reason: no visible reply).",
+      }),
+    );
+  });
+
+  it("synthesized terminal notice does not leak raw child output (#89095)", async () => {
+    // Maintainer-stated design constraint: the synth notice must be bounded
+    // and must not echo raw child output. Verify both for an error-status
+    // completion that carries a long, sensitive-looking error string.
+    const callGateway = createGatewayMock({
+      result: {
+        payloads: [],
+      },
+    });
+    const sendMessage = createSendMessageMock();
+
+    const sensitiveStatusLabel =
+      "failed: API key sk-redacted-1234567890abcdef expired; rotate via https://internal/keys/123";
+    const result = await deliverDiscordDirectMessageCompletion({
+      callGateway,
+      sendMessage,
+      internalEvents: [
+        {
+          type: "task_completion",
+          source: "subagent",
+          childSessionKey: "agent:worker:subagent:child",
+          childSessionId: "child-session-id",
+          announceType: "subagent task",
+          taskLabel: "long error completion",
+          status: "error",
+          statusLabel: sensitiveStatusLabel,
+          result: "(no output)",
+          replyInstruction: "Summarize the result.",
+        },
+      ],
+    });
+
+    expectRecordFields(result, {
+      delivered: true,
+      path: "direct",
+    });
+    const deliveredContent = (sendMessage as ReturnType<typeof vi.fn>).mock.calls[0]?.[0]
+      ?.content as string;
+    expect(deliveredContent).toBeTruthy();
+    // Notice is bounded: well under any channel's per-message budget.
+    expect(deliveredContent.length).toBeLessThan(200);
+    // Notice includes the error reason but not the raw secret-bearing fragment.
+    expect(deliveredContent).toContain(
+      "Background task finished without producing a visible reply",
+    );
+    expect(deliveredContent).not.toContain("sk-redacted-1234567890abcdef");
+    expect(deliveredContent).not.toContain("https://internal/keys/123");
+  });
+
+  it("never echoes statusLabel in the synth notice, even for non-empty results (#89095)", async () => {
+    // Review-hardened path: when the completion carries content the first pass
+    // rejects (non-ok status), the synth reason previously fell through to the
+    // raw statusLabel — which is outcome.error-derived and can carry provider
+    // error text, paths, or secrets. The reason must come from the closed
+    // vocabulary only.
+    const callGateway = createGatewayMock({
+      result: {
+        payloads: [],
+      },
+    });
+    const sendMessage = createSendMessageMock();
+
+    const result = await deliverDiscordDirectMessageCompletion({
+      callGateway,
+      sendMessage,
+      internalEvents: [
+        {
+          type: "task_completion",
+          source: "subagent",
+          childSessionKey: "agent:worker:subagent:child",
+          childSessionId: "child-session-id",
+          announceType: "subagent task",
+          taskLabel: "error completion with partial output",
+          status: "error",
+          statusLabel: "failed: ENOENT reading /Users/someone/.ssh/id_rsa during provider call",
+          result: "partial output the child produced before dying",
+          replyInstruction: "Summarize the result.",
+        },
+      ],
+    });
+
+    expectRecordFields(result, {
+      delivered: true,
+      path: "direct",
+    });
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content:
+          "Background task finished without producing a visible reply (status: error, reason: failed (details withheld)).",
+      }),
+    );
+  });
+
+  it("maps a timeout completion with partial output to the closed timed-out reason (#89095)", async () => {
+    const callGateway = createGatewayMock({
+      result: {
+        payloads: [],
+      },
+    });
+    const sendMessage = createSendMessageMock();
+
+    const result = await deliverDiscordDirectMessageCompletion({
+      callGateway,
+      sendMessage,
+      internalEvents: [
+        {
+          type: "task_completion",
+          source: "subagent",
+          childSessionKey: "agent:worker:subagent:child",
+          childSessionId: "child-session-id",
+          announceType: "subagent task",
+          taskLabel: "timeout completion with partial output",
+          status: "timeout",
+          statusLabel: "timed out after runTimeoutSeconds=600 killed pid 12345",
+          result: "partial output before the force-kill",
+          replyInstruction: "Summarize the result.",
+        },
+      ],
+    });
+
+    expectRecordFields(result, {
+      delivered: true,
+      path: "direct",
+    });
+    expect(sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content:
+          "Background task finished without producing a visible reply (status: timeout, reason: timed out).",
+      }),
+    );
   });
 
   it("directly delivers unprefixed direct targets recognized by the channel grammar", async () => {
diff --git a/src/agents/subagent-announce-delivery.ts b/src/agents/subagent-announce-delivery.ts
@@ -1099,6 +1099,36 @@ function resolveTextCompletionDirectFallback(events: readonly AgentInternalEvent
       return result;
     }
   }
+  // Second pass: synthesize a terminal notice when no ok-with-content completion
+  // exists but at least one task_completion is present. Without this, a direct-
+  // channel parent waiting via sessions_yield never sees a terminal message when
+  // the child stops with no deliverable payload — common when context-overflow
+  // compaction trims the wrap-up turn, when the child is force-killed by run
+  // timeout, or any clean stopReason=stop completion that emits no payload.
+  // The notice is built from a closed vocabulary only — event.statusLabel can
+  // carry raw outcome.error text (provider errors, paths), which must never be
+  // echoed to an external channel. See
+  // https://github.com/openclaw/openclaw/issues/89095.
+  for (let index = (events?.length ?? 0) - 1; index >= 0; index -= 1) {
+    const event = events?.[index];
+    if (event?.type !== "task_completion" || event.source !== "subagent") {
+      continue;
+    }
+    const status =
+      event.status === "ok" || event.status === "timeout" || event.status === "error"
+        ? event.status
+        : "unknown";
+    const rawResult = typeof event.result === "string" ? event.result.trim() : "";
+    const reasonHint =
+      rawResult === "(no output)" || rawResult === ""
+        ? "no visible reply"
+        : status === "timeout"
+          ? "timed out"
+          : status === "error"
+            ? "failed (details withheld)"
+            : "incomplete";
+    return `Background task finished without producing a visible reply (status: ${status}, reason: ${reasonHint}).`;
+  }
   return undefined;
 }
 
@@ -1806,14 +1836,14 @@ async function sendSubagentAnnounceDirectly(params: {
       !hasGatewayAgentMessagingToolDeliveryEvidence(directAnnounceResponse) &&
       !hasIntentionalSilentGatewayAgentPayload(directAnnounceResponse)
     ) {
-      if (hasFailedSubagentNoOutputCompletion(params.internalEvents)) {
-        return {
-          delivered: false,
-          path: "direct",
-          reason: "visible_reply_missing",
-          error: "completion agent did not produce a visible reply",
-        };
-      }
+      // Try the direct text-completion fallback FIRST. The synth notice in
+      // resolveTextCompletionDirectFallback now always returns content when any
+      // task_completion event exists (including failed/timeout/empty payloads),
+      // so a parent yielded via sessions_yield receives a bounded terminal
+      // notice rather than silently retry-abandoning. Without reordering, the
+      // hasFailedSubagentNoOutputCompletion gate below short-circuits to
+      // visible_reply_missing for the exact "(no output)" case the synth path
+      // is meant to cover. See https://github.com/openclaw/openclaw/issues/89095.
       if (subagentDirectMessageCompletionRequiresMessageTool) {
         const textDelivery = await deliverTextCompletionDirect({
           cfg,
@@ -1826,6 +1856,14 @@ async function sendSubagentAnnounceDirectly(params: {
           return textDelivery;
         }
       }
+      if (hasFailedSubagentNoOutputCompletion(params.internalEvents)) {
+        return {
+          delivered: false,
+          path: "direct",
+          reason: "visible_reply_missing",
+          error: "completion agent did not produce a visible reply",
+        };
+      }
       return {
         delivered: false,
         path: "direct",
diff --git a/src/gateway/server-methods/server-methods.test.ts b/src/gateway/server-methods/server-methods.test.ts
