feat: refine subagents + add chat.inject

Co-authored-by: Tyler Yust <tyler6204@users.noreply.github.com>

src/agents/clawdbot-tools.subagents.sessions-spawn-announces-back-requester-group-channel.test.ts

@@ -35,17 +35,15 @@ describe("clawdbot-tools: subagents", () => {
     };
   });
 
-  it("sessions_spawn announces back to the requester group channel", async () => {
+  it("sessions_spawn runs cleanup via lifecycle events", async () => {
     resetSubagentRegistryForTests();
     callGatewayMock.mockReset();
     const calls: Array<{ method?: string; params?: unknown }> = [];
     let agentCallCount = 0;
-    let sendParams: { to?: string; channel?: string; message?: string } = {};
     let deletedKey: string | undefined;
     let childRunId: string | undefined;
     let childSessionKey: string | undefined;
     const waitCalls: Array<{ runId?: string; timeoutMs?: number }> = [];
-    const sessionLastAssistantText = new Map<string, string>();
 
     callGatewayMock.mockImplementation(async (opts: unknown) => {
       const request = opts as { method?: string; params?: unknown };
@@ -58,15 +56,12 @@ describe("clawdbot-tools: subagents", () => {
           sessionKey?: string;
           channel?: string;
           timeout?: number;
+          lane?: string;
         };
-        const message = params?.message ?? "";
-        const sessionKey = params?.sessionKey ?? "";
-        if (message === "Sub-agent announce step.") {
-          sessionLastAssistantText.set(sessionKey, "announce now");
-        } else {
+        // Only capture the first agent call (subagent spawn, not main agent trigger)
+        if (params?.lane === "subagent") {
           childRunId = runId;
-          childSessionKey = sessionKey;
-          sessionLastAssistantText.set(sessionKey, "result");
+          childSessionKey = params?.sessionKey ?? "";
           expect(params?.channel).toBe("discord");
           expect(params?.timeout).toBe(1);
         }
@@ -79,26 +74,8 @@ describe("clawdbot-tools: subagents", () => {
       if (request.method === "agent.wait") {
         const params = request.params as { runId?: string; timeoutMs?: number } | undefined;
         waitCalls.push(params ?? {});
-        const status = params?.runId === childRunId ? "timeout" : "ok";
-        return { runId: params?.runId ?? "run-1", status };
-      }
-      if (request.method === "chat.history") {
-        const params = request.params as { sessionKey?: string } | undefined;
-        const text = sessionLastAssistantText.get(params?.sessionKey ?? "") ?? "";
-        return {
-          messages: [{ role: "assistant", content: [{ type: "text", text }] }],
-        };
-      }
-      if (request.method === "send") {
-        const params = request.params as
-          | { to?: string; channel?: string; message?: string }
-          | undefined;
-        sendParams = {
-          to: params?.to,
-          channel: params?.channel,
-          message: params?.message,
-        };
-        return { messageId: "m-announce" };
+        // Return "ok" with timing info for the child run
+        return { runId: params?.runId ?? "run-1", status: "ok", startedAt: 1000, endedAt: 2000 };
       }
       if (request.method === "sessions.delete") {
         const params = request.params as { key?: string } | undefined;
@@ -141,8 +118,12 @@ describe("clawdbot-tools: subagents", () => {
 
     const childWait = waitCalls.find((call) => call.runId === childRunId);
     expect(childWait?.timeoutMs).toBe(1000);
+
+    // Two agent calls: subagent spawn + main agent trigger
     const agentCalls = calls.filter((call) => call.method === "agent");
     expect(agentCalls).toHaveLength(2);
+
+    // First call: subagent spawn
     const first = agentCalls[0]?.params as
       | {
           lane?: string;
@@ -156,17 +137,24 @@ describe("clawdbot-tools: subagents", () => {
     expect(first?.channel).toBe("discord");
     expect(first?.sessionKey?.startsWith("agent:main:subagent:")).toBe(true);
     expect(childSessionKey?.startsWith("agent:main:subagent:")).toBe(true);
-    const second = agentCalls[1]?.params as
-      | { channel?: string; deliver?: boolean; lane?: string }
-      | undefined;
-    expect(second?.lane).toBe("nested");
-    expect(second?.deliver).toBe(false);
-    expect(second?.channel).toBe("webchat");
 
-    expect(sendParams.channel).toBe("discord");
-    expect(sendParams.to).toBe("channel:req");
-    expect(sendParams.message ?? "").toContain("announce now");
-    expect(sendParams.message ?? "").toContain("Stats:");
+    // Second call: main agent trigger with announce message
+    const second = agentCalls[1]?.params as
+      | {
+          sessionKey?: string;
+          message?: string;
+          deliver?: boolean;
+        }
+      | undefined;
+    expect(second?.sessionKey).toBe("discord:group:req");
+    expect(second?.deliver).toBe(true);
+    expect(second?.message).toContain("background task");
+
+    // No direct send to external channel (main agent handles delivery)
+    const sendCalls = calls.filter((c) => c.method === "send");
+    expect(sendCalls.length).toBe(0);
+
+    // Session should be deleted since cleanup=delete
     expect(deletedKey?.startsWith("agent:main:subagent:")).toBe(true);
   });
 });