@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/gateway/sms/policyStore.js

@@ -0,0 +1,161 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const MAX_TARGET_LENGTH = 256;
+const MINUTE_LIMIT = 1439;
+function isAlertMode(value) {
+    return "off" === value || "important-only" === value || "all" === value;
+}
+function normalizeQuietHours(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    const candidate = value;
+    const startMinute = "number" == typeof candidate.startMinute ? candidate.startMinute : NaN;
+    const endMinute = "number" == typeof candidate.endMinute ? candidate.endMinute : NaN;
+    if (!Number.isInteger(startMinute) || startMinute < 0 || startMinute > MINUTE_LIMIT || !Number.isInteger(endMinute) || endMinute < 0 || endMinute > MINUTE_LIMIT) return null;
+    return {
+        enabled: false !== candidate.enabled,
+        startMinute,
+        endMinute,
+        timezone: "string" == typeof candidate.timezone && candidate.timezone.trim() ? candidate.timezone.trim() : void 0
+    };
+}
+function normalizeTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.length > MAX_TARGET_LENGTH) return null;
+    return trimmed;
+}
+function normalizeSmsPolicyTarget(raw) {
+    return normalizeTarget(raw);
+}
+function createDefaultPolicy(target, nowMs) {
+    return {
+        target,
+        paused: false,
+        pausedUntil: null,
+        stopEnabled: false,
+        alertMode: "important-only",
+        quietHours: null,
+        createdAt: nowMs,
+        updatedAt: nowMs
+    };
+}
+function parsePolicyRecord(entry) {
+    if (!entry || "object" != typeof entry || Array.isArray(entry)) return null;
+    const typed = entry;
+    const target = "string" == typeof typed.target ? normalizeTarget(typed.target) : null;
+    if (!target) return null;
+    const createdAt = "number" == typeof typed.createdAt && Number.isFinite(typed.createdAt) ? typed.createdAt : Date.now();
+    const updatedAt = "number" == typeof typed.updatedAt && Number.isFinite(typed.updatedAt) ? typed.updatedAt : createdAt;
+    const paused = true === typed.paused;
+    const pausedUntil = "number" == typeof typed.pausedUntil && Number.isFinite(typed.pausedUntil) ? Math.trunc(typed.pausedUntil) : null;
+    return {
+        target,
+        paused,
+        pausedUntil: paused ? pausedUntil : null,
+        stopEnabled: true === typed.stopEnabled,
+        alertMode: isAlertMode(typed.alertMode) ? typed.alertMode : "important-only",
+        quietHours: normalizeQuietHours(typed.quietHours),
+        createdAt,
+        updatedAt
+    };
+}
+function resolveExpiredPause(record, nowMs) {
+    if (!record.paused || null === record.pausedUntil || record.pausedUntil > nowMs) return record;
+    return {
+        ...record,
+        paused: false,
+        pausedUntil: null,
+        updatedAt: nowMs
+    };
+}
+const createSmsPolicyStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        return join(configDir, "sms-policies.json");
+    };
+    const readRecords = ()=>{
+        const path = resolvePath();
+        if (!existsSync(path)) return [];
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) return [];
+            const records = [];
+            for (const entry of parsed){
+                const record = parsePolicyRecord(entry);
+                if (record) records.push(record);
+            }
+            return records;
+        } catch  {
+            return [];
+        }
+    };
+    const writeRecords = (records)=>{
+        const path = resolvePath();
+        writeFileSync(path, JSON.stringify(records, null, 2));
+    };
+    const replaceRecord = (records, nextRecord)=>{
+        const index = records.findIndex((record)=>record.target === nextRecord.target);
+        if (index >= 0) records[index] = nextRecord;
+        else records.unshift(nextRecord);
+        return records;
+    };
+    const resolveRecord = (target, nowMs = Date.now())=>{
+        const normalizedTarget = normalizeTarget(target);
+        if (!normalizedTarget) return createDefaultPolicy("unknown", nowMs);
+        const records = readRecords();
+        const existing = records.find((record)=>record.target === normalizedTarget);
+        if (!existing) return createDefaultPolicy(normalizedTarget, nowMs);
+        const resolved = resolveExpiredPause(existing, nowMs);
+        if (resolved !== existing) writeRecords(replaceRecord(records, resolved));
+        return resolved;
+    };
+    return {
+        load: ()=>readRecords(),
+        save: (records)=>writeRecords(records),
+        list: ()=>readRecords(),
+        get: (target)=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) return null;
+            return readRecords().find((record)=>record.target === normalizedTarget) || null;
+        },
+        resolve: (target, nowMs = Date.now())=>resolveRecord(target, nowMs),
+        upsert: (target, patch, nowMs = Date.now())=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) throw new Error("Invalid SMS policy target");
+            const records = readRecords();
+            const existing = records.find((record)=>record.target === normalizedTarget);
+            const base = existing || createDefaultPolicy(normalizedTarget, nowMs);
+            const next = {
+                ...base,
+                updatedAt: nowMs
+            };
+            if ("boolean" == typeof patch.paused) next.paused = patch.paused;
+            if (Object.hasOwn(patch, "pausedUntil")) {
+                const value = patch.pausedUntil;
+                if ("number" == typeof value && Number.isFinite(value)) next.pausedUntil = Math.trunc(value);
+                else next.pausedUntil = null;
+            }
+            if ("boolean" == typeof patch.stopEnabled) next.stopEnabled = patch.stopEnabled;
+            if (isAlertMode(patch.alertMode)) next.alertMode = patch.alertMode;
+            if (Object.hasOwn(patch, "quietHours")) next.quietHours = patch.quietHours ? normalizeQuietHours(patch.quietHours) : null;
+            if (!next.paused) next.pausedUntil = null;
+            const resolved = resolveExpiredPause(next, nowMs);
+            writeRecords(replaceRecord(records, resolved));
+            return resolved;
+        },
+        reset: (target)=>{
+            const normalizedTarget = normalizeTarget(target);
+            if (!normalizedTarget) return;
+            const records = readRecords();
+            const filtered = records.filter((record)=>record.target !== normalizedTarget);
+            if (filtered.length === records.length) return;
+            writeRecords(filtered);
+        },
+        isPaused: (target, nowMs = Date.now())=>resolveRecord(target, nowMs).paused,
+        isStopped: (target, nowMs = Date.now())=>resolveRecord(target, nowMs).stopEnabled
+    };
+};
+export { createSmsPolicyStore, normalizeSmsPolicyTarget };

package/dist/providers/registry.cjs

@@ -87,6 +87,7 @@ const PROVIDERS = {
         envVars: [
             "XAI_API_KEY"
         ],
+        baseURL: "https://api.x.ai/v1",
         category: "model"
     },
     lmstudio: {

package/dist/providers/registry.js

@@ -57,6 +57,7 @@ const PROVIDERS = {
         envVars: [
             "XAI_API_KEY"
         ],
+        baseURL: "https://api.x.ai/v1",
         category: "model"
     },
     lmstudio: {

package/dist/tests/cli-config-warnings.test.cjs

@@ -42,6 +42,47 @@ const warnings_cjs_namespaceObject = require("../cli/config/warnings.cjs");
         (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedChannels"))).toBe(true);
         (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedGuilds"))).toBe(true);
     });
+    (0, external_vitest_namespaceObject.it)("returns warnings for common Teams config issues", ()=>{
+        const base = (0, schema_cjs_namespaceObject.validateConfig)({}).data;
+        const config = (0, schema_cjs_namespaceObject.validateConfig)({
+            ...base,
+            gateway: {
+                ...base.gateway,
+                adapters: {
+                    ...base.gateway.adapters,
+                    teams: {
+                        enabled: true,
+                        appId: "",
+                        appPassword: " ",
+                        appType: "MultiTenant",
+                        endpointPath: " ",
+                        mentionOnly: true,
+                        allowBots: false,
+                        allowedTeamIds: [
+                            " "
+                        ],
+                        allowedChannelIds: [
+                            "",
+                            " 19:abc "
+                        ],
+                        channelSessions: {
+                            " 19:channel ": " session-plain "
+                        },
+                        sessionCommand: " ",
+                        responseChunkSize: 3500
+                    }
+                }
+            }
+        }).data;
+        const warnings = (0, warnings_cjs_namespaceObject.collectConfigWarnings)(config).map((warning)=>warning.message);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("appId/appPassword"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("sessionCommand"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("endpointPath"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("channelSessions"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("agent prefix"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedChannelIds"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(warnings.some((msg)=>msg.includes("allowedTeamIds"))).toBe(true);
+    });
     (0, external_vitest_namespaceObject.it)("returns no warnings when Discord adapter is disabled", ()=>{
         const base = (0, schema_cjs_namespaceObject.validateConfig)({}).data;
         (0, external_vitest_namespaceObject.expect)((0, warnings_cjs_namespaceObject.collectConfigWarnings)(base)).toEqual([]);

package/dist/tests/cli-config-warnings.test.js

@@ -40,6 +40,47 @@ describe("Config warnings", ()=>{
         expect(warnings.some((msg)=>msg.includes("allowedChannels"))).toBe(true);
         expect(warnings.some((msg)=>msg.includes("allowedGuilds"))).toBe(true);
     });
+    it("returns warnings for common Teams config issues", ()=>{
+        const base = validateConfig({}).data;
+        const config = validateConfig({
+            ...base,
+            gateway: {
+                ...base.gateway,
+                adapters: {
+                    ...base.gateway.adapters,
+                    teams: {
+                        enabled: true,
+                        appId: "",
+                        appPassword: " ",
+                        appType: "MultiTenant",
+                        endpointPath: " ",
+                        mentionOnly: true,
+                        allowBots: false,
+                        allowedTeamIds: [
+                            " "
+                        ],
+                        allowedChannelIds: [
+                            "",
+                            " 19:abc "
+                        ],
+                        channelSessions: {
+                            " 19:channel ": " session-plain "
+                        },
+                        sessionCommand: " ",
+                        responseChunkSize: 3500
+                    }
+                }
+            }
+        }).data;
+        const warnings = collectConfigWarnings(config).map((warning)=>warning.message);
+        expect(warnings.some((msg)=>msg.includes("appId/appPassword"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("sessionCommand"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("endpointPath"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("channelSessions"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("agent prefix"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("allowedChannelIds"))).toBe(true);
+        expect(warnings.some((msg)=>msg.includes("allowedTeamIds"))).toBe(true);
+    });
     it("returns no warnings when Discord adapter is disabled", ()=>{
         const base = validateConfig({}).data;
         expect(collectConfigWarnings(base)).toEqual([]);

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

@@ -77,35 +77,41 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         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("name: art-director");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./art-director.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: scene-engineer");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./scene-engineer.md");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("name: game-designer");
+        (0, external_vitest_namespaceObject.expect)(gameDevPrompt).toContain("promptFile: ./game-designer.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("Delegation routing");
         (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.expect)(gameDevPrompt).toContain("three-mesh-bvh");
+        const gameDevArtDirectorPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "art-director.md");
+        const gameDevSceneEngineerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "scene-engineer.md");
+        const gameDevDesignerPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "game-dev", "game-designer.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevArtDirectorPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevSceneEngineerPath)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(gameDevDesignerPath)).toBe(true);
+        const gameDevArtDirectorPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevArtDirectorPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtDirectorPrompt).toContain("You are `art-director`");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtDirectorPrompt).toContain("Texture-to-geometry mapping: mesh, material slot, UV set");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtDirectorPrompt).toContain("flipY = false");
+        (0, external_vitest_namespaceObject.expect)(gameDevArtDirectorPrompt).toContain("RepeatWrapping");
+        const gameDevSceneEngineerPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevSceneEngineerPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevSceneEngineerPrompt).toContain("You are `scene-engineer`");
+        (0, external_vitest_namespaceObject.expect)(gameDevSceneEngineerPrompt).toContain("Rapier is the default physics engine");
+        (0, external_vitest_namespaceObject.expect)(gameDevSceneEngineerPrompt).toContain("Prefer `postprocessing` over Three.js built-in `EffectComposer`");
+        const gameDevDesignerPrompt = (0, external_node_fs_namespaceObject.readFileSync)(gameDevDesignerPath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(gameDevDesignerPrompt).toContain("You are `game-designer`");
+        (0, external_vitest_namespaceObject.expect)(gameDevDesignerPrompt).toContain("Always present 2-3 mechanic variants with tradeoffs");
+        (0, external_vitest_namespaceObject.expect)(gameDevDesignerPrompt).toContain("UI Conventions");
+        const mainAgentTemplatePath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "main", "agent.md");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mainAgentTemplatePath)).toBe(true);
+        const mainAgentTemplatePrompt = (0, external_node_fs_namespaceObject.readFileSync)(mainAgentTemplatePath, "utf-8");
+        (0, external_vitest_namespaceObject.expect)(mainAgentTemplatePrompt).toContain("name: main");
+        (0, external_vitest_namespaceObject.expect)(mainAgentTemplatePrompt).toContain("Primary Wingman agent");
     });
     (0, external_vitest_namespaceObject.it)("merges existing config when --merge is set", async ()=>{
         const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");

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

@@ -75,35 +75,41 @@ describe("CLI init", ()=>{
         const gameDevPrompt = readFileSync(gameDevAgentPath, "utf-8");
         expect(gameDevPrompt).toContain("name: game-dev");
         expect(gameDevPrompt).toContain("subAgents:");
-        expect(gameDevPrompt).toContain("name: art-generation");
-        expect(gameDevPrompt).toContain("promptFile: ./art-generation.md");
-        expect(gameDevPrompt).toContain("name: asset-refinement");
-        expect(gameDevPrompt).toContain("promptFile: ./asset-refinement.md");
-        expect(gameDevPrompt).toContain("name: planning-idea");
-        expect(gameDevPrompt).toContain("promptFile: ./planning-idea.md");
-        expect(gameDevPrompt).toContain("name: ui-specialist");
-        expect(gameDevPrompt).toContain("promptFile: ./ui-specialist.md");
+        expect(gameDevPrompt).toContain("name: art-director");
+        expect(gameDevPrompt).toContain("promptFile: ./art-director.md");
+        expect(gameDevPrompt).toContain("name: scene-engineer");
+        expect(gameDevPrompt).toContain("promptFile: ./scene-engineer.md");
+        expect(gameDevPrompt).toContain("name: game-designer");
+        expect(gameDevPrompt).toContain("promptFile: ./game-designer.md");
         expect(gameDevPrompt).toContain("write_todos");
         expect(gameDevPrompt).toContain("read_todos");
-        expect(gameDevPrompt).toContain("UV-aware texture planning");
+        expect(gameDevPrompt).toContain("Delegation routing");
         expect(gameDevPrompt).toContain("MeshStandardMaterial");
-        expect(gameDevPrompt).toContain("uv`/`uv2");
-        const gameDevArtGenerationPath = join(workspace, ".wingman", "agents", "game-dev", "art-generation.md");
-        const gameDevAssetRefinementPath = join(workspace, ".wingman", "agents", "game-dev", "asset-refinement.md");
-        const gameDevPlanningIdeaPath = join(workspace, ".wingman", "agents", "game-dev", "planning-idea.md");
-        const gameDevUiSpecialistPath = join(workspace, ".wingman", "agents", "game-dev", "ui-specialist.md");
-        expect(existsSync(gameDevArtGenerationPath)).toBe(true);
-        expect(existsSync(gameDevAssetRefinementPath)).toBe(true);
-        expect(existsSync(gameDevPlanningIdeaPath)).toBe(true);
-        expect(existsSync(gameDevUiSpecialistPath)).toBe(true);
-        const gameDevArtGenerationPrompt = readFileSync(gameDevArtGenerationPath, "utf-8");
-        expect(gameDevArtGenerationPrompt).toContain("UV set(s) or UDIM tiles");
-        expect(gameDevArtGenerationPrompt).toContain("texel density targets");
-        expect(gameDevArtGenerationPrompt).toContain("Texture-to-geometry mapping notes");
-        expect(gameDevArtGenerationPrompt).toContain("material slot");
-        expect(gameDevArtGenerationPrompt).toContain("need `uv`, and `aoMap`");
-        expect(gameDevArtGenerationPrompt).toContain("flipY = false");
-        expect(gameDevArtGenerationPrompt).toContain("RepeatWrapping");
+        expect(gameDevPrompt).toContain("three-mesh-bvh");
+        const gameDevArtDirectorPath = join(workspace, ".wingman", "agents", "game-dev", "art-director.md");
+        const gameDevSceneEngineerPath = join(workspace, ".wingman", "agents", "game-dev", "scene-engineer.md");
+        const gameDevDesignerPath = join(workspace, ".wingman", "agents", "game-dev", "game-designer.md");
+        expect(existsSync(gameDevArtDirectorPath)).toBe(true);
+        expect(existsSync(gameDevSceneEngineerPath)).toBe(true);
+        expect(existsSync(gameDevDesignerPath)).toBe(true);
+        const gameDevArtDirectorPrompt = readFileSync(gameDevArtDirectorPath, "utf-8");
+        expect(gameDevArtDirectorPrompt).toContain("You are `art-director`");
+        expect(gameDevArtDirectorPrompt).toContain("Texture-to-geometry mapping: mesh, material slot, UV set");
+        expect(gameDevArtDirectorPrompt).toContain("flipY = false");
+        expect(gameDevArtDirectorPrompt).toContain("RepeatWrapping");
+        const gameDevSceneEngineerPrompt = readFileSync(gameDevSceneEngineerPath, "utf-8");
+        expect(gameDevSceneEngineerPrompt).toContain("You are `scene-engineer`");
+        expect(gameDevSceneEngineerPrompt).toContain("Rapier is the default physics engine");
+        expect(gameDevSceneEngineerPrompt).toContain("Prefer `postprocessing` over Three.js built-in `EffectComposer`");
+        const gameDevDesignerPrompt = readFileSync(gameDevDesignerPath, "utf-8");
+        expect(gameDevDesignerPrompt).toContain("You are `game-designer`");
+        expect(gameDevDesignerPrompt).toContain("Always present 2-3 mechanic variants with tradeoffs");
+        expect(gameDevDesignerPrompt).toContain("UI Conventions");
+        const mainAgentTemplatePath = join(workspace, ".wingman", "agents", "main", "agent.md");
+        expect(existsSync(mainAgentTemplatePath)).toBe(true);
+        const mainAgentTemplatePrompt = readFileSync(mainAgentTemplatePath, "utf-8");
+        expect(mainAgentTemplatePrompt).toContain("name: main");
+        expect(mainAgentTemplatePrompt).toContain("Primary Wingman agent");
     });
     it("merges existing config when --merge is set", async ()=>{
         const configDir = join(workspace, ".wingman");

package/dist/tests/gateway-http-security.test.cjs

@@ -93,6 +93,27 @@ function createTestSocket(initialData) {
         (0, external_vitest_namespaceObject.expect)(allowed.status).toBe(204);
         (0, external_vitest_namespaceObject.expect)(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:5173");
     });
+    (0, external_vitest_namespaceObject.it)("allows tauri loopback origin preflight for desktop clients", async ()=>{
+        const server = createGateway({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "token",
+                token: "test-token"
+            },
+            requireAuth: true
+        });
+        const internals = getGatewayInternals(server);
+        const allowed = await internals.handleUiRequest(new Request("http://127.0.0.1:18789/api/providers", {
+            method: "OPTIONS",
+            headers: {
+                Origin: "tauri://localhost",
+                "Access-Control-Request-Method": "GET"
+            }
+        }));
+        (0, external_vitest_namespaceObject.expect)(allowed.status).toBe(204);
+        (0, external_vitest_namespaceObject.expect)(allowed.headers.get("access-control-allow-origin")).toBe("tauri://localhost");
+    });
     (0, external_vitest_namespaceObject.it)("does not trust tailscale identity headers on non-loopback hosts", ()=>{
         const server = createGateway({
             host: "0.0.0.0",

package/dist/tests/gateway-http-security.test.js

@@ -91,6 +91,27 @@ describe("gateway HTTP security", ()=>{
         expect(allowed.status).toBe(204);
         expect(allowed.headers.get("access-control-allow-origin")).toBe("http://localhost:5173");
     });
+    it("allows tauri loopback origin preflight for desktop clients", async ()=>{
+        const server = createGateway({
+            host: "127.0.0.1",
+            port: 18789,
+            auth: {
+                mode: "token",
+                token: "test-token"
+            },
+            requireAuth: true
+        });
+        const internals = getGatewayInternals(server);
+        const allowed = await internals.handleUiRequest(new Request("http://127.0.0.1:18789/api/providers", {
+            method: "OPTIONS",
+            headers: {
+                Origin: "tauri://localhost",
+                "Access-Control-Request-Method": "GET"
+            }
+        }));
+        expect(allowed.status).toBe(204);
+        expect(allowed.headers.get("access-control-allow-origin")).toBe("tauri://localhost");
+    });
     it("does not trust tailscale identity headers on non-loopback hosts", ()=>{
         const server = createGateway({
             host: "0.0.0.0",

package/dist/tests/gateway-origin-policy.test.cjs

@@ -20,6 +20,17 @@ const server_cjs_namespaceObject = require("../gateway/server.cjs");
         });
         (0, external_vitest_namespaceObject.expect)(allowed).toBe(true);
     });
+    (0, external_vitest_namespaceObject.it)("allows tauri loopback origins for desktop clients", ()=>{
+        const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
+            origin: "tauri://localhost",
+            requestUrl: "http://127.0.0.1:18789/api/sessions",
+            gatewayHost: "127.0.0.1",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        (0, external_vitest_namespaceObject.expect)(allowed).toBe(true);
+    });
     (0, external_vitest_namespaceObject.it)("rejects unrelated internet origins", ()=>{
         const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
             origin: "https://evil.example",
@@ -53,6 +64,17 @@ const server_cjs_namespaceObject = require("../gateway/server.cjs");
         });
         (0, external_vitest_namespaceObject.expect)(allowed).toBe(false);
     });
+    (0, external_vitest_namespaceObject.it)("rejects tauri origins for non-loopback gateways", ()=>{
+        const allowed = (0, server_cjs_namespaceObject.isGatewayOriginAllowed)({
+            origin: "tauri://localhost",
+            requestUrl: "http://192.168.1.50:18789/api/sessions",
+            gatewayHost: "0.0.0.0",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        (0, external_vitest_namespaceObject.expect)(allowed).toBe(false);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/gateway-origin-policy.test.js

@@ -18,6 +18,17 @@ describe("gateway origin policy", ()=>{
         });
         expect(allowed).toBe(true);
     });
+    it("allows tauri loopback origins for desktop clients", ()=>{
+        const allowed = isGatewayOriginAllowed({
+            origin: "tauri://localhost",
+            requestUrl: "http://127.0.0.1:18789/api/sessions",
+            gatewayHost: "127.0.0.1",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        expect(allowed).toBe(true);
+    });
     it("rejects unrelated internet origins", ()=>{
         const allowed = isGatewayOriginAllowed({
             origin: "https://evil.example",
@@ -51,4 +62,15 @@ describe("gateway origin policy", ()=>{
         });
         expect(allowed).toBe(false);
     });
+    it("rejects tauri origins for non-loopback gateways", ()=>{
+        const allowed = isGatewayOriginAllowed({
+            origin: "tauri://localhost",
+            requestUrl: "http://192.168.1.50:18789/api/sessions",
+            gatewayHost: "0.0.0.0",
+            gatewayPort: 18789,
+            controlUiEnabled: true,
+            controlUiPort: 18790
+        });
+        expect(allowed).toBe(false);
+    });
 });

package/dist/tests/gateway.test.cjs

@@ -22,6 +22,40 @@ external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
             async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
                 if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
+                if ("stream-model-failure-no-error" === content) {
+                    this.outputManager?.emitAgentStream?.({
+                        event: "on_chain_end",
+                        run_id: "model-failure-run-1",
+                        name: "ChannelWrite<branch:to:todoListMiddleware.after_model>",
+                        data: {
+                            output: [
+                                {
+                                    lg_name: "Command",
+                                    update: {
+                                        messages: [
+                                            {
+                                                type: "constructor",
+                                                id: [
+                                                    "langchain_core",
+                                                    "messages",
+                                                    "AIMessage"
+                                                ],
+                                                kwargs: {
+                                                    id: "model-failure-msg-1",
+                                                    content: "Model call failed after 3 attempts with Error: xAI image generation failed: Prompt len is larger than the maximum allowed length which is 8000"
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ],
+                            input: {}
+                        }
+                    });
+                    return {
+                        streaming: true
+                    };
+                }
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -412,6 +446,29 @@ describeIfBun("Gateway", ()=>{
         });
         requester.close();
     });
+    (0, external_vitest_namespaceObject.it)("does not auto-convert streamed model failure text into agent-error", async ()=>{
+        const requester = await connectClient("session-streamed-failure-requester");
+        const requestId = "req-streamed-failure-no-error";
+        const sessionId = "session-streamed-failure-no-error";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "stream-model-failure-no-error"
+            },
+            timestamp: Date.now()
+        }));
+        const streamMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-stream" && msg.payload?.chunk?.event === "on_chain_end", 10000);
+        (0, external_vitest_namespaceObject.expect)(JSON.stringify(streamMsg.payload?.chunk?.data || {})).toContain("Model call failed after 3 attempts");
+        const completeMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-complete", 10000);
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(completeMsg.payload?.agentId).toBe("main");
+        const terminalErrorEvents = await collectMessages(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error", 400);
+        (0, external_vitest_namespaceObject.expect)(terminalErrorEvents).toHaveLength(0);
+        requester.close();
+    });
     (0, external_vitest_namespaceObject.it)("should emit a single agent-complete terminal event per request", async ()=>{
         const requester = await connectClient("session-single-complete-requester");
         const requestId = "req-single-complete";