@wingman-ai/gateway 0.5.4 → 0.6.0

package/dist/agent/tools/browser_session.js

@@ -1,11 +1,43 @@
 import { tool } from "langchain";
 import { object, string } from "zod";
-import { BrowserControlInputSchema, BrowserSessionActionInputSchema } from "./browser_runtime.js";
+import { BrowserControlInputSchema, BrowserSessionActionInputSchema, BrowserSessionVideoRecordingSchema } from "./browser_runtime.js";
 const CloseBrowserSessionInputSchema = object({
     session_id: string().min(1).describe("Existing browser session id to close")
 });
 const BrowserSessionListInputSchema = object({});
-const buildResponse = (payload)=>payload;
+const BrowserSessionStartInputSchema = BrowserControlInputSchema.extend({
+    recordVideo: BrowserSessionVideoRecordingSchema.optional().describe("Enable Playwright video recording for this managed session. Videos are finalized and returned when the session closes.")
+});
+const buildMediaBlocks = (media)=>media.map((entry)=>{
+        if (!entry || "object" != typeof entry) return null;
+        const record = entry;
+        const uri = "string" == typeof record.url && record.url.trim() ? record.url.trim() : "string" == typeof record.uri && record.uri.trim() ? record.uri.trim() : "";
+        if (!uri) return null;
+        return {
+            type: "resource_link",
+            uri,
+            ..."string" == typeof record.mimeType ? {
+                mimeType: record.mimeType
+            } : {},
+            ..."string" == typeof record.name ? {
+                name: record.name
+            } : {}
+        };
+    }).filter(Boolean);
+const buildResponse = (payload)=>{
+    const media = Array.isArray(payload.media) ? payload.media : [];
+    return {
+        ...payload,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(payload, null, 2)
+            },
+            ...buildMediaBlocks(media)
+        ],
+        structuredContent: payload
+    };
+};
 const summarizeResult = (snapshot, summary)=>({
         session_id: snapshot.sessionId,
         status: snapshot.status,
@@ -25,6 +57,8 @@ const summarizeResult = (snapshot, summary)=>({
         fallback_reason: summary?.fallbackReason || null,
         extensions: summary?.extensions || [],
         action_results: summary?.actionResults || [],
+        media: summary?.media || [],
+        video_recording: summary?.videoRecording || null,
         browser: summary?.browser || null,
         transport: summary?.transport || snapshot.transportUsed
     });
@@ -48,8 +82,8 @@ const createBrowserSessionStartTool = (options, dependencies = {})=>tool(async (
         }
     }, {
         name: "browser_session_start",
-        description: 'Start a managed browser session that persists across multiple tool calls. Use this for iterative QA/debugging where the same browser state should survive across turns. Transport can be selected per session with "auto", "playwright", or "relay".',
-        schema: BrowserControlInputSchema
+        description: 'Default browser automation entrypoint. Start a managed browser session for screenshots, extraction, QA, and multi-step automation; you can use it for one-shot tasks or continue the same browser state across multiple tool calls. Use browser_session_action to continue and browser_session_close when finished. Transport can be selected per session with "auto", "playwright", or "relay".',
+        schema: BrowserSessionStartInputSchema
     });
 const createBrowserSessionActionTool = (options)=>tool(async (input)=>{
         try {
@@ -71,19 +105,21 @@ const createBrowserSessionActionTool = (options)=>tool(async (input)=>{
         }
     }, {
         name: "browser_session_action",
-        description: "Run browser actions inside an existing managed browser session. Use the session_id returned by browser_session_start to continue the same tab/profile state across multiple calls.",
+        description: "Continue the default managed browser workflow by running more actions inside an existing browser session. Use the session_id returned by browser_session_start to keep the same tab/profile state across multiple calls.",
         schema: BrowserSessionActionInputSchema
     });
 const createBrowserSessionCloseTool = (options)=>tool(async ({ session_id })=>{
         try {
-            const snapshot = await options.sessionManager.closeSession({
+            const { snapshot, closeSummary } = await options.sessionManager.closeSession({
                 ownerId: options.ownerId,
                 sessionId: session_id
             });
             return buildResponse({
                 ok: true,
                 closed: true,
-                ...summarizeResult(snapshot, null)
+                ...summarizeResult(snapshot, null),
+                media: closeSummary.media,
+                video_recording: closeSummary.videoRecording
             });
         } catch (error) {
             return buildResponse({
@@ -93,7 +129,7 @@ const createBrowserSessionCloseTool = (options)=>tool(async ({ session_id })=>{
         }
     }, {
         name: "browser_session_close",
-        description: "Close a managed browser session and release any temporary browser resources or profile locks owned by that session.",
+        description: "Finish the managed browser workflow by closing a session and releasing any temporary browser resources or profile locks owned by it. Finalized video recordings are returned here.",
         schema: CloseBrowserSessionInputSchema
     });
 const createBrowserSessionListTool = (options)=>tool(async ()=>{
@@ -104,7 +140,7 @@ const createBrowserSessionListTool = (options)=>tool(async ()=>{
         });
     }, {
         name: "browser_session_list",
-        description: "List the managed browser sessions currently owned by this agent run. Use this to recover a session_id before continuing or closing a session.",
+        description: "List the managed browser sessions currently owned by this agent run. Use this to recover a session_id before continuing or closing the default browser workflow.",
         schema: BrowserSessionListInputSchema
     });
 export { createBrowserSessionActionTool, createBrowserSessionCloseTool, createBrowserSessionListTool, createBrowserSessionStartTool };

package/dist/agent/tools/browser_session_manager.cjs

@@ -99,8 +99,11 @@ class BrowserSessionManager {
     async closeSession(input) {
         const record = this.getOwnedRecord(input.ownerId, input.sessionId);
         const snapshot = this.toSnapshot(record);
-        await this.closeAndDelete(record);
-        return snapshot;
+        const closeSummary = await this.closeAndDelete(record);
+        return {
+            snapshot,
+            closeSummary
+        };
     }
     listSessions(ownerId) {
         const normalizedOwnerId = this.normalizeOwnerId(ownerId);
@@ -118,10 +121,17 @@ class BrowserSessionManager {
         await Promise.allSettled(expired.map((record)=>this.closeAndDelete(record)));
     }
     async closeAndDelete(record) {
-        if (record.closing) return;
+        if (record.closing) return {
+            media: [],
+            videoRecording: null
+        };
         record.closing = true;
+        let closeSummary = {
+            media: [],
+            videoRecording: null
+        };
         try {
-            await (0, external_browser_runtime_cjs_namespaceObject.closeBrowserSessionRuntime)(record.runtime, record.dependencies);
+            closeSummary = await (0, external_browser_runtime_cjs_namespaceObject.closeBrowserSessionRuntime)(record.runtime, record.dependencies);
         } finally{
             this.sessions.delete(record.sessionId);
             const ownerSessions = this.ownerIndex.get(record.ownerId);
@@ -130,6 +140,7 @@ class BrowserSessionManager {
                 if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
             }
         }
+        return closeSummary;
     }
     getOwnedRecord(ownerId, sessionId) {
         const normalizedOwnerId = this.normalizeOwnerId(ownerId);

package/dist/agent/tools/browser_session_manager.d.ts

@@ -1,4 +1,4 @@
-import { type BrowserControlDependencies, type BrowserControlInput, type BrowserControlToolOptions, type BrowserExecutionSummary, type BrowserRuntimeTransport, type BrowserTransportPreference } from "./browser_runtime.js";
+import { type BrowserControlDependencies, type BrowserControlInput, type BrowserControlToolOptions, type BrowserExecutionSummary, type BrowserGeneratedMedia, type BrowserVideoRecordingSummary, type BrowserRuntimeTransport, type BrowserTransportPreference } from "./browser_runtime.js";
 export interface BrowserSessionSnapshot {
     sessionId: string;
     ownerId: string;
@@ -52,7 +52,13 @@ export declare class BrowserSessionManager {
         snapshot: BrowserSessionSnapshot;
         summary: BrowserExecutionSummary;
     }>;
-    closeSession(input: CloseBrowserSessionInput): Promise<BrowserSessionSnapshot>;
+    closeSession(input: CloseBrowserSessionInput): Promise<{
+        snapshot: BrowserSessionSnapshot;
+        closeSummary: {
+            media: BrowserGeneratedMedia[];
+            videoRecording: BrowserVideoRecordingSummary | null;
+        };
+    }>;
     listSessions(ownerId: string): BrowserSessionSnapshot[];
     private cleanupExpiredSessions;
     private closeAndDelete;

package/dist/agent/tools/browser_session_manager.js

@@ -70,8 +70,11 @@ class BrowserSessionManager {
     async closeSession(input) {
         const record = this.getOwnedRecord(input.ownerId, input.sessionId);
         const snapshot = this.toSnapshot(record);
-        await this.closeAndDelete(record);
-        return snapshot;
+        const closeSummary = await this.closeAndDelete(record);
+        return {
+            snapshot,
+            closeSummary
+        };
     }
     listSessions(ownerId) {
         const normalizedOwnerId = this.normalizeOwnerId(ownerId);
@@ -89,10 +92,17 @@ class BrowserSessionManager {
         await Promise.allSettled(expired.map((record)=>this.closeAndDelete(record)));
     }
     async closeAndDelete(record) {
-        if (record.closing) return;
+        if (record.closing) return {
+            media: [],
+            videoRecording: null
+        };
         record.closing = true;
+        let closeSummary = {
+            media: [],
+            videoRecording: null
+        };
         try {
-            await closeBrowserSessionRuntime(record.runtime, record.dependencies);
+            closeSummary = await closeBrowserSessionRuntime(record.runtime, record.dependencies);
         } finally{
             this.sessions.delete(record.sessionId);
             const ownerSessions = this.ownerIndex.get(record.ownerId);
@@ -101,6 +111,7 @@ class BrowserSessionManager {
                 if (0 === ownerSessions.size) this.ownerIndex.delete(record.ownerId);
             }
         }
+        return closeSummary;
     }
     getOwnedRecord(ownerId, sessionId) {
         const normalizedOwnerId = this.normalizeOwnerId(ownerId);

package/dist/cli/commands/init.cjs

@@ -44,41 +44,19 @@ const external_node_url_namespaceObject = require("node:url");
 const prompts_namespaceObject = require("@clack/prompts");
 const external_chalk_namespaceObject = require("chalk");
 var external_chalk_default = /*#__PURE__*/ __webpack_require__.n(external_chalk_namespaceObject);
+const external_js_yaml_namespaceObject = require("js-yaml");
 const modelFactory_cjs_namespaceObject = require("../../agent/config/modelFactory.cjs");
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
 const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
 const schema_cjs_namespaceObject = require("../config/schema.cjs");
 const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
-const DEFAULT_AGENT_ID = "wingman";
-const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
-const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.\nUse browser_session_start/browser_session_action/browser_session_close for iterative browser debugging across turns, and browser_control for one-shot browser tasks.";
-const DEFAULT_TOOLS = [
-    "code_search",
-    "git_status",
-    "command_execute",
-    "browser_control",
-    "browser_session_start",
-    "browser_session_action",
-    "browser_session_close",
-    "browser_session_list",
-    "internet_search",
-    "think"
-];
 const DEFAULT_FS_ROOT = ".";
 const DEFAULT_BROWSER_PROFILE_ID = "default";
 const DEFAULT_BROWSER_PROFILES_DIR = ".wingman/browser-profiles";
 const DEFAULT_BROWSER_EXTENSIONS_DIR = ".wingman/browser-extensions";
 const DEFAULT_BUNDLED_EXTENSION_ID = "wingman";
 const DEFAULT_BROWSER_TRANSPORT = "auto";
-const DEFAULT_MODELS = {
-    anthropic: "anthropic:claude-sonnet-4-5",
-    openai: "openai:gpt-4o",
-    codex: "codex:codex-mini-latest",
-    openrouter: "openrouter:openai/gpt-4o",
-    copilot: "copilot:gpt-4o",
-    xai: "xai:grok-beta"
-};
 const DEFAULT_INIT_MODE = "onboard";
 const DEFAULT_ONBOARD_COMPONENTS = [
     "config",
@@ -137,8 +115,20 @@ async function executeInitCommand(args, options = {}) {
         renderInitBanner(outputManager, nonInteractive, mode, components);
         const bundledAgentsPath = resolveBundledAgentsPath();
         const bundledAgents = bundledAgentsPath ? listBundledAgents(bundledAgentsPath) : [];
-        const explicitAgent = Boolean(args.agent?.trim()) || Boolean(args.subcommand) && !isHelpCommand(args.subcommand) && !args.subcommand.startsWith("-");
-        const defaultAgentId = resolveAgentId(args);
+        const requestedAgentId = resolveRequestedAgentId(args);
+        const explicitAgent = Boolean(requestedAgentId);
+        const resolvedAgentId = resolveDefaultAgentId({
+            requestedAgentId,
+            bundledAgents,
+            configPath
+        });
+        if (!resolvedAgentId && (runConfig || runAgents)) throw new Error("No explicit agents are available. Add an agent under .wingman/agents or pass --agent with an existing bundled agent.");
+        const defaultAgentId = resolvedAgentId || "main";
+        if (runConfig || runAgents) assertAgentIsExplicit({
+            agentId: defaultAgentId,
+            bundledAgents,
+            configRoot
+        });
         const agentPlan = runConfig || runAgents ? syncAgentsOnly ? resolveAgentSyncPlan({
             defaultAgentId,
             bundledAgents,
@@ -163,7 +153,6 @@ async function executeInitCommand(args, options = {}) {
         const model = shouldResolveModel ? await resolveModelSelection({
             nonInteractive,
             optionMap,
-            providerName,
             outputManager
         }) : void 0;
         if (runConfig) await runStep(useClack, "Writing workspace config", async ()=>handleConfigSetup({
@@ -182,7 +171,6 @@ async function executeInitCommand(args, options = {}) {
                 agentId: agentPlan.defaultAgentId,
                 model,
                 force,
-                nonInteractive,
                 outputManager,
                 bundledAgentsPath,
                 copyAgents: agentPlan.copyAgents,
@@ -249,10 +237,35 @@ function isHelpCommand(subcommand) {
         "-h"
     ].includes(subcommand);
 }
-function resolveAgentId(args) {
-    if (args.agent?.trim()) return args.agent.trim();
-    if (args.subcommand && !isHelpCommand(args.subcommand) && !args.subcommand.startsWith("-")) return args.subcommand.trim();
-    return DEFAULT_AGENT_ID;
+function resolveRequestedAgentId(args) {
+    if (args.agent?.trim()) return sanitizeAgentId(args.agent.trim());
+    if (args.subcommand && !isHelpCommand(args.subcommand) && !args.subcommand.startsWith("-")) return sanitizeAgentId(args.subcommand.trim());
+}
+function resolveDefaultAgentId(input) {
+    const { requestedAgentId, bundledAgents, configPath } = input;
+    if (requestedAgentId) return requestedAgentId;
+    const existingDefaultAgent = readConfiguredDefaultAgent(configPath);
+    if (existingDefaultAgent) return existingDefaultAgent;
+    const preferredBundledAgent = resolvePreferredBundledAgentId(bundledAgents);
+    if (preferredBundledAgent) return preferredBundledAgent;
+}
+function readConfiguredDefaultAgent(configPath) {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(configPath)) return;
+    try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if ("string" == typeof parsed.defaultAgent && parsed.defaultAgent.trim()) return sanitizeAgentId(parsed.defaultAgent.trim());
+    } catch  {}
+}
+function resolvePreferredBundledAgentId(bundledAgents) {
+    if (bundledAgents.includes("main")) return "main";
+    return bundledAgents[0];
+}
+function assertAgentIsExplicit(input) {
+    const { agentId, bundledAgents, configRoot } = input;
+    if (bundledAgents.includes(agentId)) return;
+    if (findAgentConfigPath(configRoot, agentId)) return;
+    throw new Error(`Agent "${agentId}" is not defined. Choose one of the bundled agents (${bundledAgents.join(", ")}) or create .wingman/agents/${agentId}/agent.md explicitly.`);
 }
 async function resolveAgentPlan(input) {
     const { explicitAgent, defaultAgentId, bundledAgents, nonInteractive, optionMap, outputManager, ensureDefaultAgentInSelection } = input;
@@ -512,7 +525,7 @@ function bootstrapBrowserDefaults(configRoot, config) {
     };
 }
 async function handleAgentSetup(input) {
-    const { configRoot, agentId, model, force, nonInteractive, outputManager, bundledAgentsPath, copyAgents, ensureDefaultAgent = true } = input;
+    const { configRoot, agentId, model, force, outputManager, bundledAgentsPath, copyAgents, ensureDefaultAgent = true } = input;
     const copiedAgents = bundledAgentsPath ? copyBundledAgents({
         bundledAgentsPath,
         configRoot,
@@ -522,17 +535,8 @@ async function handleAgentSetup(input) {
     }) : new Set();
     if (copiedAgents.size > 0) writeLine(outputManager, `Copied ${copiedAgents.size} bundled agent(s) to ${(0, external_node_path_namespaceObject.join)(configRoot, "agents")}`);
     if (!ensureDefaultAgent) return;
-    const expectedAgentDir = (0, external_node_path_namespaceObject.join)(configRoot, "agents", agentId);
-    const expectedAgentPath = (0, external_node_path_namespaceObject.join)(expectedAgentDir, "agent.json");
-    const expectedAgentExists = (0, external_node_fs_namespaceObject.existsSync)(expectedAgentPath);
-    if (!expectedAgentExists) return void await createFallbackAgent({
-        configRoot,
-        agentId,
-        model,
-        force,
-        nonInteractive,
-        outputManager
-    });
+    const expectedAgentPath = findAgentConfigPath(configRoot, agentId);
+    if (!expectedAgentPath) throw new Error(`Agent "${agentId}" was not found after init. Create .wingman/agents/${agentId}/agent.md explicitly or choose a bundled agent.`);
     if (model) applyModelToAgent(expectedAgentPath, model, outputManager);
 }
 function resolveBundledAgentsPath() {
@@ -589,35 +593,34 @@ function copyDirectory(source, target) {
         else (0, external_node_fs_namespaceObject.copyFileSync)(sourcePath, targetPath);
     }
 }
-async function createFallbackAgent(input) {
-    const { configRoot, agentId, model, force, nonInteractive, outputManager } = input;
+function findAgentConfigPath(configRoot, agentId) {
     const agentDir = (0, external_node_path_namespaceObject.join)(configRoot, "agents", agentId);
-    const agentPath = (0, external_node_path_namespaceObject.join)(agentDir, "agent.json");
-    const agentExists = (0, external_node_fs_namespaceObject.existsSync)(agentPath);
-    if (agentExists && !force) {
-        if (nonInteractive) return void writeLine(outputManager, `Agent "${agentId}" already exists. Use --force to overwrite.`);
-        const shouldOverwrite = await promptConfirm(`Agent "${agentId}" exists. Overwrite? (y/N): `, false);
-        if (!shouldOverwrite) return void writeLine(outputManager, `Keeping existing agent "${agentId}".`);
-    }
-    (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
-        recursive: true
-    });
-    const agentConfig = {
-        name: agentId,
-        description: DEFAULT_AGENT_DESCRIPTION,
-        systemPrompt: DEFAULT_AGENT_PROMPT,
-        tools: DEFAULT_TOOLS
-    };
-    if (model) agentConfig.model = model;
-    (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, JSON.stringify(agentConfig, null, 2));
-    writeLine(outputManager, `Created starter agent at ${agentPath}`);
+    const jsonPath = (0, external_node_path_namespaceObject.join)(agentDir, "agent.json");
+    if ((0, external_node_fs_namespaceObject.existsSync)(jsonPath)) return jsonPath;
+    const markdownPath = (0, external_node_path_namespaceObject.join)(agentDir, "agent.md");
+    if ((0, external_node_fs_namespaceObject.existsSync)(markdownPath)) return markdownPath;
+    return null;
 }
 function applyModelToAgent(agentPath, model, outputManager) {
     try {
-        const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        parsed.model = model;
-        (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, JSON.stringify(parsed, null, 2));
+        if (agentPath.endsWith(".json")) {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            parsed.model = model;
+            (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, JSON.stringify(parsed, null, 2));
+        } else if (agentPath.endsWith(".md")) {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8");
+            const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+            const match = raw.match(frontmatterRegex);
+            if (!match) throw new Error("Invalid agent.md format: missing frontmatter");
+            const [, rawFrontmatter, prompt] = match;
+            const metadata = external_js_yaml_namespaceObject.load(rawFrontmatter) || {};
+            metadata.model = model;
+            const serializedFrontmatter = external_js_yaml_namespaceObject.dump(metadata, {
+                lineWidth: 120
+            });
+            (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, `---\n${serializedFrontmatter}---\n\n${prompt?.trim() || ""}\n`);
+        } else throw new Error("Unsupported agent config format");
         writeLine(outputManager, `Updated ${agentPath} with model ${model}`);
     } catch  {
         writeLine(outputManager, `Unable to update model for ${agentPath}. Update manually.`);
@@ -657,7 +660,7 @@ async function resolveProviderSelection(input) {
     return normalized;
 }
 async function resolveModelSelection(input) {
-    const { nonInteractive, optionMap, providerName, outputManager } = input;
+    const { nonInteractive, optionMap, outputManager } = input;
     const explicitModel = getStringOption(optionMap, [
         "model"
     ]);
@@ -665,22 +668,13 @@ async function resolveModelSelection(input) {
         validateModel(explicitModel);
         return explicitModel;
     }
-    const providers = (0, registry_cjs_namespaceObject.listProviderSpecs)("model");
-    const configuredProvider = providers.find((provider)=>"missing" !== (0, credentials_cjs_namespaceObject.resolveProviderToken)(provider.name).source);
-    const suggestedProvider = providerName || configuredProvider?.name;
-    const suggestedModel = suggestedProvider ? DEFAULT_MODELS[suggestedProvider] : void 0;
-    if (nonInteractive) {
-        if (suggestedModel) return suggestedModel;
-        return;
-    }
+    if (nonInteractive) return;
     const inputValue = await (0, prompts_namespaceObject.text)({
         message: "Model string (provider:model)",
-        placeholder: suggestedModel ? void 0 : "anthropic:claude-sonnet-4-5",
-        defaultValue: suggestedModel
+        placeholder: "anthropic:claude-sonnet-4-5"
     });
     if ((0, prompts_namespaceObject.isCancel)(inputValue)) abortSetup();
     const trimmed = String(inputValue ?? "").trim();
-    if (!trimmed && suggestedModel) return suggestedModel;
     if (!trimmed) return void writeLine(outputManager, "Skipping model selection.");
     validateModel(trimmed);
     return trimmed;
@@ -783,29 +777,13 @@ async function promptForDefaultAgent(agents, currentDefault) {
     const defaultValue = choices.includes(currentDefault) ? currentDefault : choices[0];
     const selection = await (0, prompts_namespaceObject.select)({
         message: "Pick a default agent",
-        options: [
-            ...choices.map((agent)=>({
-                    value: agent,
-                    label: agent
-                })),
-            {
-                value: "__custom__",
-                label: "Custom agent name"
-            }
-        ],
+        options: choices.map((agent)=>({
+                value: agent,
+                label: agent
+            })),
         initialValue: defaultValue
     });
     if ((0, prompts_namespaceObject.isCancel)(selection)) abortSetup();
-    if ("__custom__" === selection) {
-        const input = await (0, prompts_namespaceObject.text)({
-            message: "Default agent name",
-            placeholder: defaultValue
-        });
-        if ((0, prompts_namespaceObject.isCancel)(input)) abortSetup();
-        const trimmed = String(input ?? "").trim();
-        if (!trimmed) return defaultValue;
-        return sanitizeAgentId(trimmed);
-    }
     return sanitizeAgentId(String(selection));
 }
 async function promptForAgentSelection(agents, defaultAgent) {
@@ -872,12 +850,12 @@ Usage:
   wingman init <agent-name>
 
 Options:
-  --agent <name>         Agent name (default: wingman)
+  --agent <name>         Bundled or existing explicit agent name
   --mode <name>          Init mode (onboard|sync). Default: onboard
   --only <targets>       Run only selected setup targets (config,agents,provider)
   --agents <list>        Copy only these bundled agents (comma-separated)
   --model <provider:model>
-                         Set model for the starter agent
+                         Set model for the selected explicit agent
   --provider <name>      Provider to configure (anthropic|openai|codex|openrouter|copilot|xai)
   --token <token>        Save provider token (non-interactive)
   --api-key <key>        Alias for --token