@wingman-ai/gateway 0.2.4 → 0.3.0

package/dist/providers/codex.js

@@ -1,9 +1,12 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createLogger } from "../logger.js";
 const CODEX_HOME_ENV = "CODEX_HOME";
 const CODEX_AUTH_FILE = "auth.json";
+const CODEX_REFRESH_TOKEN_URL_OVERRIDE_ENV = "CODEX_REFRESH_TOKEN_URL_OVERRIDE";
+const DEFAULT_CODEX_REFRESH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const TOKEN_REFRESH_BUFFER_MS = 300000;
 const DEFAULT_CODEX_INSTRUCTIONS = "You are Wingman, a coding assistant. Follow the user's request exactly and keep tool usage focused.";
 const logger = createLogger();
 function getCodexAuthPath() {
@@ -13,53 +16,77 @@ function getCodexAuthPath() {
 }
 function resolveCodexAuthFromFile() {
     const authPath = getCodexAuthPath();
-    if (!existsSync(authPath)) return {
+    const root = readCodexAuthRoot(authPath);
+    if (!root) return {
+        authPath
+    };
+    const tokens = root.tokens && "object" == typeof root.tokens ? root.tokens : void 0;
+    const accessToken = firstNonEmptyString([
+        tokens?.access_token,
+        root.access_token
+    ]);
+    const refreshToken = firstNonEmptyString([
+        tokens?.refresh_token,
+        root.refresh_token
+    ]);
+    const idToken = firstNonEmptyString([
+        tokens?.id_token,
+        root.id_token
+    ]);
+    const accountId = firstNonEmptyString([
+        tokens?.account_id,
+        root.account_id,
+        extractAccountIdFromIdToken(idToken)
+    ]);
+    return {
+        accessToken,
+        refreshToken,
+        idToken,
+        accountId,
         authPath
     };
-    try {
-        const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
-        if (!parsed || "object" != typeof parsed) return {
-            authPath
-        };
-        const root = parsed;
-        const tokens = root.tokens && "object" == typeof root.tokens ? root.tokens : void 0;
-        const accessToken = firstNonEmptyString([
-            tokens?.access_token,
-            root.access_token
-        ]);
-        const accountId = firstNonEmptyString([
-            tokens?.account_id,
-            root.account_id
-        ]);
-        return {
-            accessToken,
-            accountId,
-            authPath
-        };
-    } catch  {
-        return {
-            authPath
-        };
-    }
 }
 function createCodexFetch(options = {}) {
     const baseFetch = options.baseFetch || globalThis.fetch.bind(globalThis);
     return async (input, init)=>{
-        const codexAuth = resolveCodexAuthFromFile();
-        const accessToken = codexAuth.accessToken || options.fallbackToken;
-        const accountId = codexAuth.accountId || options.fallbackAccountId;
+        let codexAuth = await maybeRefreshCodexAuth({
+            authState: resolveCodexAuthFromFile(),
+            baseFetch
+        });
+        let accessToken = codexAuth.accessToken || options.fallbackToken;
+        let accountId = codexAuth.accountId || options.fallbackAccountId;
         if (!accessToken) throw new Error("Codex credentials missing. Run `codex login` or set CODEX_ACCESS_TOKEN.");
-        const headers = new Headers(init?.headers || {});
-        headers.delete("authorization");
-        headers.delete("x-api-key");
-        headers.set("Authorization", `Bearer ${accessToken}`);
-        if (accountId) headers.set("ChatGPT-Account-ID", accountId);
         const body = withCodexRequestDefaults(init?.body);
-        const response = await baseFetch(input, {
-            ...init,
-            headers,
+        let response = await dispatchCodexRequest({
+            input,
+            init,
+            baseFetch,
+            accessToken,
+            accountId,
             body
         });
+        if ((401 === response.status || 403 === response.status) && canRetryCodexRequest(body) && codexAuth.refreshToken) {
+            const refreshed = await maybeRefreshCodexAuth({
+                authState: codexAuth,
+                baseFetch,
+                force: true
+            });
+            const refreshedAccessToken = refreshed.accessToken || options.fallbackToken;
+            const refreshedAccountId = refreshed.accountId || options.fallbackAccountId;
+            if (refreshedAccessToken && refreshedAccessToken !== accessToken) {
+                codexAuth = refreshed;
+                accessToken = refreshedAccessToken;
+                accountId = refreshedAccountId;
+                response = await dispatchCodexRequest({
+                    input,
+                    init,
+                    baseFetch,
+                    accessToken,
+                    accountId,
+                    body
+                });
+            }
+        }
         if (!response.ok) {
             let responseBody = "";
             try {
@@ -75,6 +102,172 @@ function createCodexFetch(options = {}) {
         return response;
     };
 }
+async function dispatchCodexRequest(input) {
+    const headers = new Headers(input.init?.headers || {});
+    headers.delete("authorization");
+    headers.delete("x-api-key");
+    headers.set("Authorization", `Bearer ${input.accessToken}`);
+    if (input.accountId) headers.set("ChatGPT-Account-ID", input.accountId);
+    return input.baseFetch(input.input, {
+        ...input.init,
+        headers,
+        body: input.body
+    });
+}
+function canRetryCodexRequest(body) {
+    return null == body || "string" == typeof body || body instanceof URLSearchParams;
+}
+async function maybeRefreshCodexAuth(input) {
+    const { authState, baseFetch, force = false } = input;
+    if (!authState.refreshToken) return authState;
+    const shouldRefresh = force || !authState.accessToken || isTokenExpiredOrExpiring(authState.accessToken);
+    if (!shouldRefresh) return authState;
+    try {
+        const refreshed = await refreshCodexAuthToken(authState, baseFetch);
+        if (refreshed) return refreshed;
+    } catch (error) {
+        logger.warn("Failed to refresh Codex token", {
+            error: error instanceof Error ? error.message : String(error)
+        });
+    }
+    return authState;
+}
+async function refreshCodexAuthToken(authState, baseFetch) {
+    const refreshToken = authState.refreshToken;
+    if (!refreshToken) return;
+    const clientId = extractClientIdForRefresh(authState);
+    const tokenUrl = resolveCodexRefreshTokenUrl();
+    const form = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+    });
+    if (clientId) form.set("client_id", clientId);
+    const response = await baseFetch(tokenUrl, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: form.toString()
+    });
+    if (!response.ok) {
+        const preview = await readResponsePreview(response);
+        logger.warn("Codex token refresh failed", {
+            status: response.status,
+            statusText: response.statusText || null,
+            bodyPreview: preview || null
+        });
+        return;
+    }
+    const payload = await response.json();
+    const accessToken = firstNonEmptyString([
+        payload.access_token
+    ]);
+    if (!accessToken) return void logger.warn("Codex token refresh failed: missing access_token");
+    const idToken = firstNonEmptyString([
+        payload.id_token,
+        authState.idToken
+    ]);
+    const refreshed = {
+        accessToken,
+        refreshToken: firstNonEmptyString([
+            payload.refresh_token,
+            authState.refreshToken
+        ]),
+        idToken,
+        accountId: firstNonEmptyString([
+            extractAccountIdFromIdToken(idToken),
+            authState.accountId
+        ])
+    };
+    persistCodexAuthUpdate(authState.authPath, refreshed);
+    return resolveCodexAuthFromFile();
+}
+async function readResponsePreview(response) {
+    try {
+        const text = await response.text();
+        return text.trim().slice(0, 1200);
+    } catch  {
+        return "";
+    }
+}
+function persistCodexAuthUpdate(authPath, updated) {
+    const root = readCodexAuthRoot(authPath) || {};
+    const existingTokens = root.tokens && "object" == typeof root.tokens && !Array.isArray(root.tokens) ? root.tokens : {};
+    const tokens = {
+        ...existingTokens,
+        access_token: updated.accessToken
+    };
+    if (updated.refreshToken) tokens.refresh_token = updated.refreshToken;
+    if (updated.idToken) tokens.id_token = updated.idToken;
+    if (updated.accountId) tokens.account_id = updated.accountId;
+    root.tokens = tokens;
+    root.last_refresh = new Date().toISOString();
+    writeFileSync(authPath, `${JSON.stringify(root, null, 2)}\n`, "utf-8");
+}
+function readCodexAuthRoot(authPath) {
+    if (!existsSync(authPath)) return;
+    try {
+        const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
+        if (!parsed || "object" != typeof parsed || Array.isArray(parsed)) return;
+        return parsed;
+    } catch  {
+        return;
+    }
+}
+function resolveCodexRefreshTokenUrl() {
+    const override = process.env[CODEX_REFRESH_TOKEN_URL_OVERRIDE_ENV];
+    if (override?.trim()) return override.trim();
+    return DEFAULT_CODEX_REFRESH_TOKEN_URL;
+}
+function extractClientIdForRefresh(authState) {
+    const accessTokenClaims = parseJwtPayload(authState.accessToken);
+    const accessTokenClientId = accessTokenClaims && "string" == typeof accessTokenClaims.client_id ? accessTokenClaims.client_id : void 0;
+    if (accessTokenClientId?.trim()) return accessTokenClientId.trim();
+    const idTokenClaims = parseJwtPayload(authState.idToken);
+    if (!idTokenClaims) return;
+    const aud = idTokenClaims.aud;
+    if ("string" == typeof aud && aud.trim()) return aud.trim();
+    if (Array.isArray(aud)) {
+        for (const value of aud)if ("string" == typeof value && value.trim()) return value.trim();
+    }
+}
+function isTokenExpiredOrExpiring(token) {
+    const expiryMs = extractTokenExpiryMs(token);
+    if (!expiryMs) return false;
+    return expiryMs <= Date.now() + TOKEN_REFRESH_BUFFER_MS;
+}
+function extractTokenExpiryMs(token) {
+    const payload = parseJwtPayload(token);
+    if (!payload || "number" != typeof payload.exp) return;
+    return 1000 * payload.exp;
+}
+function extractAccountIdFromIdToken(idToken) {
+    const payload = parseJwtPayload(idToken);
+    if (!payload) return;
+    const nested = payload["https://api.openai.com/auth"];
+    if (nested && "object" == typeof nested && !Array.isArray(nested)) {
+        const accountId = nested.chatgpt_account_id;
+        if ("string" == typeof accountId && accountId.trim()) return accountId.trim();
+    }
+    const direct = payload.chatgpt_account_id;
+    if ("string" == typeof direct && direct.trim()) return direct.trim();
+}
+function parseJwtPayload(token) {
+    if (!token) return;
+    const parts = token.split(".");
+    if (3 !== parts.length) return;
+    try {
+        const payload = parts[1];
+        const normalized = payload + "=".repeat((4 - payload.length % 4) % 4);
+        const decoded = Buffer.from(normalized, "base64url").toString("utf-8");
+        const parsed = JSON.parse(decoded);
+        if (!parsed || "object" != typeof parsed || Array.isArray(parsed)) return;
+        return parsed;
+    } catch  {
+        return;
+    }
+}
 function withCodexRequestDefaults(body) {
     if ("string" != typeof body || !body.trim()) return body;
     try {

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([]);
+    });
+});