@wingman-ai/gateway 0.2.5 → 0.3.0

package/dist/gateway/server.js

@@ -336,12 +336,29 @@ class GatewayServer {
         const sessionManager = await this.getSessionManager(agentId);
         const existingSession = sessionManager.getSession(sessionKey);
         const session = existingSession || sessionManager.getOrCreateSession(sessionKey, agentId);
+        const requestId = msg.id || `req-${Date.now()}`;
         const workdir = session.metadata?.workdir ?? null;
         const defaultOutputDir = this.resolveDefaultOutputDir(agentId);
         const preview = hasContent ? content.trim() : buildAttachmentPreview(attachments);
         sessionManager.updateSession(session.id, {
+            messageCount: (session.messageCount ?? 0) + 1,
             lastMessagePreview: preview.substring(0, 200)
         });
+        try {
+            sessionManager.persistPendingMessage({
+                sessionId: sessionKey,
+                requestId,
+                message: {
+                    id: `user-${requestId}`,
+                    role: "user",
+                    content,
+                    attachments: attachments.length > 0 ? mapAttachmentsForPendingMessage(attachments) : void 0,
+                    createdAt: Date.now()
+                }
+            });
+        } catch (error) {
+            this.logger.warn("Failed to persist pending user message", error);
+        }
         if (!existingSession) this.internalHooks?.emit({
             type: "session",
             action: "start",
@@ -444,9 +461,15 @@ class GatewayServer {
         this.activeSessionRequests.set(sessionQueueKey, msg.id);
         const outputManager = new OutputManager("interactive");
         let emittedAgentError = false;
+        let streamedCompletionResult;
         const outputHandler = (event)=>{
             const payloadWithSession = this.attachSessionContext(event, sessionKey, agentId);
-            if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "agent-error" === payloadWithSession.type) emittedAgentError = true;
+            const payloadType = payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "string" == typeof payloadWithSession.type ? payloadWithSession.type : "";
+            if ("agent-complete" === payloadType) {
+                if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession)) streamedCompletionResult = payloadWithSession.result;
+                return;
+            }
+            if ("agent-error" === payloadType) emittedAgentError = true;
             const baseMessage = {
                 type: "event:agent",
                 id: msg.id,
@@ -477,17 +500,43 @@ class GatewayServer {
             abortController
         });
         try {
-            await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
+            const invocationResult = await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
                 signal: abortController.signal
             });
-            const updated = sessionManager.getSession(sessionKey);
-            if (updated) sessionManager.updateSession(sessionKey, {
-                messageCount: updated.messageCount + 1
+            if (msg.id) sessionManager.clearPendingMessagesForRequest(sessionKey, msg.id);
+            if (emittedAgentError) return;
+            const invocationCancelled = abortController.signal.aborted || "object" == typeof invocationResult && null !== invocationResult && !Array.isArray(invocationResult) && true === invocationResult.cancelled;
+            if (invocationCancelled) return void this.sendAgentError(ws, msg.id, "Request cancelled", {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
+            const completionResult = void 0 === streamedCompletionResult ? invocationResult : streamedCompletionResult;
+            this.sendAgentComplete(ws, msg.id, completionResult, {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
             });
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
+            const message = error instanceof Error ? error.message : String(error);
+            if (msg.id) try {
+                sessionManager.persistPendingMessage({
+                    sessionId: sessionKey,
+                    requestId: msg.id,
+                    message: {
+                        id: msg.id,
+                        role: "assistant",
+                        content: message,
+                        createdAt: Date.now()
+                    }
+                });
+            } catch (persistError) {
+                this.logger.warn("Failed to persist pending assistant error message", persistError);
+            }
             if (!emittedAgentError) {
-                const message = error instanceof Error ? error.message : String(error);
                 const stack = error instanceof Error ? error.stack : void 0;
                 this.sendAgentError(ws, msg.id, message, {
                     sessionId: sessionKey,
@@ -563,6 +612,12 @@ class GatewayServer {
                 },
                 timestamp: Date.now()
             });
+            this.sendAgentError(ws, requestId, "Request cancelled", {
+                sessionId: queued.sessionKey,
+                agentId: queued.agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
             return;
         }
         this.sendMessage(ws, {
@@ -737,11 +792,25 @@ class GatewayServer {
     }
     sendMessage(ws, message) {
         try {
-            ws.send(JSON.stringify(message));
+            const result = ws.send(JSON.stringify(message));
+            if ("number" == typeof result && result <= 0) return false;
+            return true;
         } catch (error) {
             this.log("error", "Failed to send message", error);
+            return false;
         }
     }
+    sendMessageWithRetry(ws, message, attempt = 0) {
+        if (this.sendMessage(ws, message)) return;
+        if (attempt >= 2) return void this.log("warn", "Dropping websocket message after retry attempts", {
+            type: message.type,
+            id: message.id
+        });
+        const delayMs = 25 * (attempt + 1);
+        setTimeout(()=>{
+            this.sendMessageWithRetry(ws, message, attempt + 1);
+        }, delayMs);
+    }
     sendError(ws, code, message) {
         const errorPayload = {
             code,
@@ -753,6 +822,25 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
+    sendAgentComplete(ws, requestId, result, options) {
+        let payload = {
+            type: "agent-complete",
+            result: result ?? null,
+            timestamp: new Date().toISOString()
+        };
+        if (options?.sessionId && options?.agentId) payload = this.attachSessionContext(payload, options.sessionId, options.agentId);
+        const baseMessage = {
+            type: "event:agent",
+            id: requestId,
+            payload,
+            timestamp: Date.now()
+        };
+        this.sendMessageWithRetry(ws, {
+            ...baseMessage,
+            clientId: ws.data.clientId
+        });
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
+    }
     sendAgentError(ws, requestId, message, options) {
         let payload = {
             type: "agent-error",
@@ -767,11 +855,11 @@ class GatewayServer {
             payload,
             timestamp: Date.now()
         };
-        this.sendMessage(ws, {
+        this.sendMessageWithRetry(ws, {
             ...baseMessage,
             clientId: ws.data.clientId
         });
-        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude);
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
     }
     cancelSocketAgentRequests(ws) {
         for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
@@ -800,12 +888,13 @@ class GatewayServer {
             agentId
         };
     }
-    broadcastSessionEvent(sessionId, message, exclude) {
+    broadcastSessionEvent(sessionId, message, exclude, reliable = false) {
         const subscribers = this.sessionSubscriptions.get(sessionId);
         if (!subscribers || 0 === subscribers.size) return 0;
         let sent = 0;
         for (const ws of subscribers)if (!exclude || ws !== exclude) {
-            this.sendMessage(ws, message);
+            if (reliable) this.sendMessageWithRetry(ws, message);
+            else this.sendMessage(ws, message);
             sent++;
         }
         return sent;
@@ -1379,6 +1468,18 @@ function buildAttachmentPreview(attachments) {
     if (hasAudio) return count > 1 ? "Audio attachments" : "Audio attachment";
     return count > 1 ? "Image attachments" : "Image attachment";
 }
+function mapAttachmentsForPendingMessage(attachments) {
+    return attachments.map((attachment)=>{
+        const kind = isFileAttachment(attachment) ? "file" : isAudioAttachment(attachment) ? "audio" : "image";
+        return {
+            kind,
+            dataUrl: attachment.dataUrl,
+            name: attachment.name,
+            mimeType: attachment.mimeType,
+            size: attachment.size
+        };
+    });
+}
 function isAudioAttachment(attachment) {
     if ("audio" === attachment.kind) return true;
     if (attachment.mimeType?.startsWith("audio/")) return true;

package/dist/tests/agentInvokerSummarization.test.cjs

@@ -348,42 +348,6 @@ const parseConfig = (input)=>{
         })).toBeUndefined();
     });
 });
-(0, external_vitest_namespaceObject.describe)("evaluateStreamingCompletion", ()=>{
-    (0, external_vitest_namespaceObject.it)("blocks with stream_error when no assistant text and stream error exists", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: "provider timeout"
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "blocked",
-            reason: "stream_error",
-            message: "Model call failed: provider timeout"
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("blocks with empty_stream_response when no text or fallback is present", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "blocked",
-            reason: "empty_stream_response",
-            message: "Model completed without a response. Check provider logs for request errors."
-        });
-    });
-    (0, external_vitest_namespaceObject.it)("returns ok when assistant text exists", ()=>{
-        const result = (0, agentInvoker_cjs_namespaceObject.evaluateStreamingCompletion)({
-            sawAssistantText: true,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        (0, external_vitest_namespaceObject.expect)(result).toEqual({
-            status: "ok"
-        });
-    });
-});
 (0, external_vitest_namespaceObject.describe)("LangGraph lifecycle termination", ()=>{
     (0, external_vitest_namespaceObject.it)("tracks root LangGraph run id from parentless on_chain_start", ()=>{
         const rootRunId = (0, agentInvoker_cjs_namespaceObject.trackRootLangGraphRunId)(void 0, {
@@ -441,12 +405,67 @@ const parseConfig = (input)=>{
             run_id: "root-run",
             parent_ids: []
         }, "root-run")).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("treats root LangGraph on_chain_end as terminal even without tracked run id", ()=>{
         (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
             event: "on_chain_end",
             name: "LangGraph",
             run_id: "root-run",
             parent_ids: []
-        }, void 0)).toBe(false);
+        }, void 0)).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("treats root LangGraph on_chain_end as terminal when run id is missing", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.isRootLangGraphTerminalEvent)({
+            event: "on_chain_end",
+            name: "LangGraph",
+            parent_ids: []
+        }, "root-run")).toBe(true);
+    });
+});
+(0, external_vitest_namespaceObject.describe)("emitCompletionAndContinuePostProcessing", ()=>{
+    (0, external_vitest_namespaceObject.it)("emits completion before post-processing resolves", ()=>{
+        const callOrder = [];
+        let resolvePostProcess;
+        const postProcess = ()=>new Promise((resolve)=>{
+                callOrder.push("post-process-start");
+                resolvePostProcess = resolve;
+            });
+        (0, agentInvoker_cjs_namespaceObject.emitCompletionAndContinuePostProcessing)({
+            outputManager: {
+                emitAgentComplete: ()=>{
+                    callOrder.push("emit-complete");
+                }
+            },
+            result: {
+                ok: true
+            },
+            postProcess
+        });
+        (0, external_vitest_namespaceObject.expect)(callOrder).toEqual([
+            "emit-complete",
+            "post-process-start"
+        ]);
+        resolvePostProcess?.();
+    });
+    (0, external_vitest_namespaceObject.it)("logs and swallows post-processing failures", async ()=>{
+        const debug = external_vitest_namespaceObject.vi.fn();
+        (0, agentInvoker_cjs_namespaceObject.emitCompletionAndContinuePostProcessing)({
+            outputManager: {
+                emitAgentComplete: external_vitest_namespaceObject.vi.fn()
+            },
+            result: {
+                ok: true
+            },
+            postProcess: async ()=>{
+                throw new Error("materialization failed");
+            },
+            logger: {
+                debug
+            }
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        (0, external_vitest_namespaceObject.expect)(debug).toHaveBeenCalledWith("Failed post-completion processing for streamed agent response", external_vitest_namespaceObject.expect.any(Error));
     });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/tests/agentInvokerSummarization.test.js

@@ -1,6 +1,6 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { validateConfig } from "../cli/config/schema.js";
-import { chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, evaluateStreamingCompletion, isRootLangGraphTerminalEvent, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, trackRootLangGraphRunId } from "../cli/core/agentInvoker.js";
+import { chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, emitCompletionAndContinuePostProcessing, isRootLangGraphTerminalEvent, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, trackRootLangGraphRunId } from "../cli/core/agentInvoker.js";
 const parseConfig = (input)=>{
     const result = validateConfig(input);
     if (!result.success || !result.data) throw new Error(result.error || "Expected config validation to succeed");
@@ -346,42 +346,6 @@ describe("detectStreamErrorMessage", ()=>{
         })).toBeUndefined();
     });
 });
-describe("evaluateStreamingCompletion", ()=>{
-    it("blocks with stream_error when no assistant text and stream error exists", ()=>{
-        const result = evaluateStreamingCompletion({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: "provider timeout"
-        });
-        expect(result).toEqual({
-            status: "blocked",
-            reason: "stream_error",
-            message: "Model call failed: provider timeout"
-        });
-    });
-    it("blocks with empty_stream_response when no text or fallback is present", ()=>{
-        const result = evaluateStreamingCompletion({
-            sawAssistantText: false,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        expect(result).toEqual({
-            status: "blocked",
-            reason: "empty_stream_response",
-            message: "Model completed without a response. Check provider logs for request errors."
-        });
-    });
-    it("returns ok when assistant text exists", ()=>{
-        const result = evaluateStreamingCompletion({
-            sawAssistantText: true,
-            fallbackText: void 0,
-            streamErrorMessage: void 0
-        });
-        expect(result).toEqual({
-            status: "ok"
-        });
-    });
-});
 describe("LangGraph lifecycle termination", ()=>{
     it("tracks root LangGraph run id from parentless on_chain_start", ()=>{
         const rootRunId = trackRootLangGraphRunId(void 0, {
@@ -439,11 +403,66 @@ describe("LangGraph lifecycle termination", ()=>{
             run_id: "root-run",
             parent_ids: []
         }, "root-run")).toBe(false);
+    });
+    it("treats root LangGraph on_chain_end as terminal even without tracked run id", ()=>{
         expect(isRootLangGraphTerminalEvent({
             event: "on_chain_end",
             name: "LangGraph",
             run_id: "root-run",
             parent_ids: []
-        }, void 0)).toBe(false);
+        }, void 0)).toBe(true);
+    });
+    it("treats root LangGraph on_chain_end as terminal when run id is missing", ()=>{
+        expect(isRootLangGraphTerminalEvent({
+            event: "on_chain_end",
+            name: "LangGraph",
+            parent_ids: []
+        }, "root-run")).toBe(true);
+    });
+});
+describe("emitCompletionAndContinuePostProcessing", ()=>{
+    it("emits completion before post-processing resolves", ()=>{
+        const callOrder = [];
+        let resolvePostProcess;
+        const postProcess = ()=>new Promise((resolve)=>{
+                callOrder.push("post-process-start");
+                resolvePostProcess = resolve;
+            });
+        emitCompletionAndContinuePostProcessing({
+            outputManager: {
+                emitAgentComplete: ()=>{
+                    callOrder.push("emit-complete");
+                }
+            },
+            result: {
+                ok: true
+            },
+            postProcess
+        });
+        expect(callOrder).toEqual([
+            "emit-complete",
+            "post-process-start"
+        ]);
+        resolvePostProcess?.();
+    });
+    it("logs and swallows post-processing failures", async ()=>{
+        const debug = vi.fn();
+        emitCompletionAndContinuePostProcessing({
+            outputManager: {
+                emitAgentComplete: vi.fn()
+            },
+            result: {
+                ok: true
+            },
+            postProcess: async ()=>{
+                throw new Error("materialization failed");
+            },
+            logger: {
+                debug
+            }
+        });
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(debug).toHaveBeenCalledWith("Failed post-completion processing for streamed agent response", expect.any(Error));
     });
 });

package/dist/tests/agentInvokerWorkdir.test.cjs

@@ -21,6 +21,8 @@ var __webpack_require__ = {};
     __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();
 var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_vitest_namespaceObject = require("vitest");
@@ -83,6 +85,21 @@ const agentInvoker_cjs_namespaceObject = require("../cli/core/agentInvoker.cjs")
         (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveExecutionWorkspace)(workspace, absolute)).toBe(external_node_path_default().normalize(absolute));
     });
 });
+(0, external_vitest_namespaceObject.describe)("resolveAgentExecutionWorkspace", ()=>{
+    const workspace = external_node_path_default().resolve("workspace");
+    (0, external_vitest_namespaceObject.it)("prefers explicit workdir over default output dir", ()=>{
+        const workdir = external_node_path_default().resolve("outside", "session-output");
+        const defaultOutputDir = external_node_path_default().resolve("outside", "default-output");
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentExecutionWorkspace)(workspace, workdir, defaultOutputDir)).toBe(external_node_path_default().normalize(workdir));
+    });
+    (0, external_vitest_namespaceObject.it)("uses default output dir when session workdir is unset", ()=>{
+        const defaultOutputDir = external_node_path_default().resolve("outside", "default-output");
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentExecutionWorkspace)(workspace, null, defaultOutputDir)).toBe(external_node_path_default().normalize(defaultOutputDir));
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to workspace when neither workdir nor default output dir exist", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentExecutionWorkspace)(workspace, null, null)).toBe(external_node_path_default().normalize(workspace));
+    });
+});
 (0, external_vitest_namespaceObject.describe)("toWorkspaceAliasVirtualPath", ()=>{
     (0, external_vitest_namespaceObject.it)("builds an alias path for absolute workspaces", ()=>{
         const absolute = external_node_path_default().resolve("outside", "session-output");
@@ -94,6 +111,39 @@ const agentInvoker_cjs_namespaceObject = require("../cli/core/agentInvoker.cjs")
         (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.toWorkspaceAliasVirtualPath)("relative/workspace")).toBeNull();
     });
 });
+(0, external_vitest_namespaceObject.describe)("resolveAgentMemorySources", ()=>{
+    const tempDirs = [];
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        for (const dir of tempDirs)(0, external_node_fs_namespaceObject.rmSync)(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    (0, external_vitest_namespaceObject.it)("returns /AGENTS.md when present in execution workspace", ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)(external_node_path_default().join((0, external_node_os_namespaceObject.tmpdir)(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_node_path_default().join(workspace, "AGENTS.md"), "# Agent Memory");
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentMemorySources)(workspace)).toEqual([
+            "/AGENTS.md"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("returns no sources when AGENTS.md is absent", ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)(external_node_path_default().join((0, external_node_os_namespaceObject.tmpdir)(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentMemorySources)(workspace)).toEqual([]);
+    });
+    (0, external_vitest_namespaceObject.it)("ignores .deepagents/AGENTS.md when top-level AGENTS.md is missing", ()=>{
+        const workspace = (0, external_node_fs_namespaceObject.mkdtempSync)(external_node_path_default().join((0, external_node_os_namespaceObject.tmpdir)(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        const deepagentsDir = external_node_path_default().join(workspace, ".deepagents");
+        (0, external_node_fs_namespaceObject.mkdirSync)(deepagentsDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_node_path_default().join(deepagentsDir, "AGENTS.md"), "# Nested Memory");
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveAgentMemorySources)(workspace)).toEqual([]);
+    });
+});
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/tests/agentInvokerWorkdir.test.js

@@ -1,6 +1,8 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import node_path from "node:path";
-import { describe, expect, it } from "vitest";
-import { OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, resolveExecutionWorkspace, resolveExternalOutputMount, toWorkspaceAliasVirtualPath } from "../cli/core/agentInvoker.js";
+import { afterEach, describe, expect, it } from "vitest";
+import { OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, resolveAgentExecutionWorkspace, resolveAgentMemorySources, resolveExecutionWorkspace, resolveExternalOutputMount, toWorkspaceAliasVirtualPath } from "../cli/core/agentInvoker.js";
 describe("resolveExternalOutputMount", ()=>{
     const workspace = node_path.resolve("workspace");
     it("mounts external workdir paths", ()=>{
@@ -59,6 +61,21 @@ describe("resolveExecutionWorkspace", ()=>{
         expect(resolveExecutionWorkspace(workspace, absolute)).toBe(node_path.normalize(absolute));
     });
 });
+describe("resolveAgentExecutionWorkspace", ()=>{
+    const workspace = node_path.resolve("workspace");
+    it("prefers explicit workdir over default output dir", ()=>{
+        const workdir = node_path.resolve("outside", "session-output");
+        const defaultOutputDir = node_path.resolve("outside", "default-output");
+        expect(resolveAgentExecutionWorkspace(workspace, workdir, defaultOutputDir)).toBe(node_path.normalize(workdir));
+    });
+    it("uses default output dir when session workdir is unset", ()=>{
+        const defaultOutputDir = node_path.resolve("outside", "default-output");
+        expect(resolveAgentExecutionWorkspace(workspace, null, defaultOutputDir)).toBe(node_path.normalize(defaultOutputDir));
+    });
+    it("falls back to workspace when neither workdir nor default output dir exist", ()=>{
+        expect(resolveAgentExecutionWorkspace(workspace, null, null)).toBe(node_path.normalize(workspace));
+    });
+});
 describe("toWorkspaceAliasVirtualPath", ()=>{
     it("builds an alias path for absolute workspaces", ()=>{
         const absolute = node_path.resolve("outside", "session-output");
@@ -70,3 +87,36 @@ describe("toWorkspaceAliasVirtualPath", ()=>{
         expect(toWorkspaceAliasVirtualPath("relative/workspace")).toBeNull();
     });
 });
+describe("resolveAgentMemorySources", ()=>{
+    const tempDirs = [];
+    afterEach(()=>{
+        for (const dir of tempDirs)rmSync(dir, {
+            recursive: true,
+            force: true
+        });
+        tempDirs.length = 0;
+    });
+    it("returns /AGENTS.md when present in execution workspace", ()=>{
+        const workspace = mkdtempSync(node_path.join(tmpdir(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        writeFileSync(node_path.join(workspace, "AGENTS.md"), "# Agent Memory");
+        expect(resolveAgentMemorySources(workspace)).toEqual([
+            "/AGENTS.md"
+        ]);
+    });
+    it("returns no sources when AGENTS.md is absent", ()=>{
+        const workspace = mkdtempSync(node_path.join(tmpdir(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        expect(resolveAgentMemorySources(workspace)).toEqual([]);
+    });
+    it("ignores .deepagents/AGENTS.md when top-level AGENTS.md is missing", ()=>{
+        const workspace = mkdtempSync(node_path.join(tmpdir(), "wingman-memory-"));
+        tempDirs.push(workspace);
+        const deepagentsDir = node_path.join(workspace, ".deepagents");
+        mkdirSync(deepagentsDir, {
+            recursive: true
+        });
+        writeFileSync(node_path.join(deepagentsDir, "AGENTS.md"), "# Nested Memory");
+        expect(resolveAgentMemorySources(workspace)).toEqual([]);
+    });
+});

package/dist/tests/cli-init.test.cjs

@@ -43,6 +43,7 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingAgentPath)).toBe(true);
         const codingPrompt = (0, external_node_fs_namespaceObject.readFileSync)(codingAgentPath, "utf-8");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("read_todos");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("update_plan");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).not.toContain("subAgents:");
         (0, external_vitest_namespaceObject.expect)(codingPrompt).toContain("Do not delegate coding work to subagents");
@@ -55,6 +56,7 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("promptFile: ./implementor.md");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("`task` tool");
         (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(codingV2Prompt).toContain("read_todos");
         const codingV2ImplementorPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "implementor.md");
         const codingV2PlannerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "planner.md");
         const codingV2ReviewerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "coding-v2", "reviewer.md");
@@ -63,6 +65,40 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2PlannerPath)).toBe(false);
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ReviewerPath)).toBe(false);
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(codingV2ResearcherPath)).toBe(false);
+        const gameDevAgentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "agent.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevAgentPath)).toBe(true);
+        const gameDevPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevAgentPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: game-dev");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("subAgents:");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: art-generation");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./art-generation.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: asset-refinement");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./asset-refinement.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: planning-idea");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./planning-idea.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: ui-specialist");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./ui-specialist.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("write_todos");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("read_todos");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("UV-aware texture planning");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("MeshStandardMaterial");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("uv`/`uv2");
+        const gameDevArtGenerationPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "art-generation.md");
+        const gameDevAssetRefinementPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "asset-refinement.md");
+        const gameDevPlanningIdeaPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "planning-idea.md");
+        const gameDevUiSpecialistPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "ui-specialist.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevArtGenerationPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevAssetRefinementPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevPlanningIdeaPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevUiSpecialistPath)).toBe(true);
+        const gameDevArtGenerationPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevArtGenerationPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("UV set(s) or UDIM tiles");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("texel density targets");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("Texture-to-geometry mapping notes");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("material slot");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("need `uv`, and `aoMap`");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("flipY = false");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtGenerationPrompt).toContain("RepeatWrapping");
     });
     (0, external_vitest_namespaceObject.it)("merges existing config when --merge is set", async ()=>{
         const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");