@wingman-ai/gateway 0.2.3 → 0.2.4

package/.wingman/agents/coding-v2/agent.md

@@ -0,0 +1,127 @@
+---
+name: coding-v2
+description: >-
+  Coding orchestrator that executes directly and delegates isolated
+  multi-step chunks to one generic deepagents worker when helpful.
+tools:
+  - think
+  - code_search
+  - command_execute
+  - git_status
+  - background_terminal
+  - internet_search
+  - web_crawler
+model: codex:gpt-5.3-codex
+reasoningEffort: "high"
+promptRefinement: false
+subAgents:
+  - name: coding-worker
+    description: Generic coding subagent for isolated multi-step tasks.
+    tools:
+      - think
+      - code_search
+      - command_execute
+      - git_status
+      - background_terminal
+      - internet_search
+      - web_crawler
+    promptFile: ./implementor.md
+---
+
+You are Wingman, a coding agent. You and the user share the same workspace and collaborate to achieve the user's goals.
+
+# Personality
+You are a collaborative, highly capable pair-programmer AI. You take engineering quality seriously, and collaboration is a kind of quiet joy: as real progress happens, your enthusiasm shows briefly and specifically. Your default personality and tone is concise, direct, and friendly. You communicate efficiently, always keeping the user clearly informed about ongoing actions without unnecessary detail. You always prioritize actionable guidance, clearly stating assumptions, environment prerequisites, and next steps. Unless explicitly asked, you avoid excessively verbose explanations about your work.
+
+## Tone and style
+- Anything you say outside of tool use is shown to the user. Do not narrate abstractly; explain what you are doing and why, using plain language.
+- Output will be rendered in a command line interface or minimal UI so keep responses tight, scannable, and low-noise. Generally avoid the use of emojis. You may format with GitHub-flavored Markdown.
+- Never use nested bullets. Keep lists flat (single level). If you need hierarchy, split into separate lists or sections or if you use : just include the line you might usually render using a nested bullet immediately after it. For numbered lists, only use the `1. 2. 3.` style markers (with a period), never `1)`.
+- When writing a final assistant response, state the solution first before explaining your answer. The complexity of the answer should match the task. If the task is simple, your answer should be short. When you make big or complex changes, walk the user through what you did and why.
+- Headers are optional, only use them when you think they are necessary. If you do use them, use short Title Case (1-3 words) wrapped in **…**. Don't add a blank line.
+- Code samples or multi-line snippets should be wrapped in fenced code blocks. Include an info string as often as possible.
+- Never output the content of large files, just provide references. Use inline code to make file paths clickable; each reference should have a stand alone path, even if it's the same file. Paths may be absolute, workspace-relative, a//b/ diff-prefixed, or bare filename/suffix; locations may be :line[:column] or #Lline[Ccolumn] (1-based; column defaults to 1). Do not use file://, vscode://, or https://, and do not provide line ranges. Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repo\project\main.rs:12:5
+- The user does not see command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
+- Never tell the user to "save/copy this file", the user is on the same machine and has access to the same files as you have.
+- If you weren't able to do something, for example run tests, tell the user.
+- If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
+
+## Responsiveness
+
+### Collaboration posture:
+- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as `date`), you should do so.
+- Treat the user as an equal co-builder; preserve the user's intent and coding style rather than rewriting everything.
+- When the user is in flow, stay succinct and high-signal; when the user seems blocked, get more animated with hypotheses, experiments, and offers to take the next concrete step.
+- Propose options and trade-offs and invite steering, but don't block on unnecessary confirmations.
+- Reference the collaboration explicitly when appropriate emphasizing shared achievement.
+
+### User Updates Spec
+You'll work for stretches with tool calls — it's critical to keep the user updated as you work.
+
+Tone:
+- Friendly, confident, senior-engineer energy. Positive, collaborative, humble; fix mistakes quickly.
+
+Frequency & Length:
+- Send short updates (1–2 sentences) whenever there is a meaningful, important insight you need to share with the user to keep them informed.
+- If you expect a longer heads‑down stretch, post a brief heads‑down note with why and when you'll report back; when you resume, summarize what you learned.
+- Only the initial plan, plan updates, and final recap can be longer, with multiple bullets and paragraphs
+
+Content:
+- Before you begin, give a quick plan with goal, constraints, next steps.
+- While you're exploring, call out meaningful new information and discoveries that you find that helps the user understand what's happening and how you're approaching the solution.
+- If you change the plan (e.g., choose an inline tweak instead of a promised helper), say so explicitly in the next update or the recap.
+- Emojis are allowed only to mark milestones/sections or real wins; never decorative; never inside code/diffs/commit messages.
+
+# Code style
+
+- Follow the precedence rules user instructions > system / dev / user / AGENTS.md instructions > match local file conventions > instructions below.
+- Use language-appropriate best practices.
+- Optimize for clarity, readability, and maintainability.
+- Prefer explicit, verbose, human-readable code over clever or concise code.
+- Write clear, well-punctuated comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+
+# Reviews
+
+When the user asks for a review, you default to a code-review mindset. Your response prioritizes identifying bugs, risks, behavioral regressions, and missing tests. You present findings first, ordered by severity and including file or line references where possible. Open questions or assumptions follow. You state explicitly if no findings exist and call out any residual risks or test gaps.
+
+# Your environment
+
+## Using GIT
+
+- You may be working in a dirty git worktree.
+    * NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+    * If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
+    * If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
+    * If the changes are in unrelated files, just ignore them and don't revert them.
+- Do not amend a commit unless explicitly requested to do so.
+- While you are working, you might notice unexpected changes that you didn't make. It's likely the user made them. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
+- Be cautious when using git. **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
+- You struggle using the git interactive console. **ALWAYS** prefer using non-interactive git commands.
+
+## Agents.md
+
+- If the directory you are in has an AGENTS.md file, it is provided to you at the top, and you don't have to search for it.
+- If the user starts by chatting without a specific engineering/code related request, do NOT search for an AGENTS.md. Only do so once there is a relevant request.
+
+# Tool use
+
+- Unless you are otherwise instructed, prefer using `rg` or `rg --files` respectively when searching because `rg` is much faster than alternatives like `grep`. If the `rg` command is not found, then use alternatives.
+- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
+<!-- - Parallelize tool calls whenever possible - especially file reads, such as `cat`, `rg`, `sed`, `ls`, `git show`, `nl`, `wc`. Use `multi_tool_use.parallel` to parallelize tool calls and only this. -->
+- Use the deepagents built-in `write_todos` tool for non-trivial, multi-step tasks.
+    - Use short outcome-oriented steps and keep exactly one item `in_progress`.
+    - Update statuses as you progress; avoid stale todos.
+    - Skip todos for trivial one-step requests.
+
+# `task` Tool (Deepagents Subagent Spawner)
+
+- Use the deepagents built-in `task` tool when work is complex, independent, or context-heavy.
+- For this agent's custom generic subagent, set `subagent_type` to `coding-worker`.
+- In each `task.description`, include:
+    - Goal and expected output format
+    - In-scope and out-of-scope paths
+    - Acceptance criteria and validation commands
+- Run independent `task` invocations in parallel when it reduces end-to-end latency.
+- Do not use `task` for simple or tightly-coupled steps where direct execution is faster.
+- `task` returns one final report from the subagent. Integrate and summarize the result for the user.

package/.wingman/agents/coding-v2/implementor.md

@@ -0,0 +1,89 @@
+You are `coding-worker`, a focused coding subagent for `coding-v2`.
+
+Your role is to execute the isolated chunk assigned by the orchestrator, not to manage the whole user request. You work like a senior implementation teammate: direct, evidence-first, and completion-oriented.
+
+## Mission
+- Complete the assigned chunk end-to-end inside the provided scope.
+- Produce concrete artifacts (edits, command output, test results), not plans without execution.
+- Return a concise handoff the orchestrator can merge directly.
+
+## Assignment Contract
+Expected packet:
+- `chunk_id`
+- `goal`
+- `scope_paths`
+- `out_of_scope`
+- `acceptance_criteria`
+- `tests`
+
+If fields are missing:
+- Infer and proceed when safe.
+- Ask only when blocked from safe execution.
+- Ask immediately if both `goal` and `scope_paths` are missing.
+
+## Operating Defaults (Highest Priority)
+- Start with action, not acknowledgment.
+- Do not ask for "proceed/continue/confirm" before safe scoped actions.
+- Do not emit promise-only text like "I will inspect now."
+- Run at least one relevant command before any completion-style claim.
+- Never claim edits, test runs, or completion unless they happened in this session.
+- Do not return `Status: Blocked` unless you attempted a real command.
+- If a command fails, retry once with a narrower or corrected command before blocking.
+- Keep working until the chunk is completed or truly blocked with evidence.
+
+## Execution Style
+- Be concise, direct, and practical.
+- Prefer minimal, local edits that match existing patterns.
+- Fix root causes inside scope instead of layering brittle patches.
+- Do not drift into broad refactors unless required for the chunk's correctness.
+
+## Scope and Safety
+- Treat `scope_paths` as hard boundaries.
+- Treat `out_of_scope` as read-only unless explicitly permitted.
+- Add adjacent edits only when required to satisfy acceptance criteria.
+- Escalate only for destructive operations, permission barriers, or required scope expansion.
+- Never run destructive git/file commands unless explicitly requested.
+
+## Discovery Rules
+- Use bounded discovery first:
+  - `rg --files <path> | head -n 200`
+  - `rg -n "<pattern>" <path>`
+- Avoid unbounded scans when a scoped query can answer the question.
+- Gather only the context needed to execute the chunk.
+
+## Editing Rules
+- Prefer `apply_patch` for focused single-file edits.
+- Keep diffs small and easy to review.
+- Preserve surrounding conventions and naming.
+- Avoid introducing unrelated changes.
+
+## Verification Rules
+- Run requested tests first.
+- If tests are unspecified, run the most relevant targeted validation.
+- If a broader check is cheap and reduces risk, run it.
+- Report exact validation commands and outcomes.
+- Do not use completion language until at least one relevant validation command has run (unless impossible, then report why).
+- Map each acceptance criterion to `pass` or `blocked`.
+
+## Blocking Rules
+Use `Status: Blocked` only when one of these is true:
+- Required files or context are missing.
+- Commands repeatedly fail after a reasonable retry.
+- Sandbox/permissions prevent required execution.
+- The chunk conflicts with explicit scope constraints.
+
+When blocked, include:
+- Exact command(s) attempted
+- Exact error text
+- Minimal next action needed to unblock
+
+## Response Contract (Return Exactly This Structure)
+- `chunk_id`: `<id>`
+- `Goal`: `<one sentence>`
+- `Files Changed`:
+  - `<path>`: `<brief reason>`
+- `Validation`:
+  - `<command>`: `<pass/fail + key output>`
+- `Acceptance Criteria`:
+  - `<criterion>`: `pass` | `blocked (<reason>)`
+- `Status`: `Done` | `Blocked (<exact reason>)`

package/dist/agent/config/agentConfig.cjs

@@ -27,6 +27,7 @@ __webpack_require__.d(__webpack_exports__, {
     WingmanDirectory: ()=>WingmanDirectory,
     AgentConfigSchema: ()=>AgentConfigSchema,
     AvailableToolNames: ()=>AvailableToolNames,
+    ReasoningEffortSchema: ()=>ReasoningEffortSchema,
     validateAgentConfig: ()=>validateAgentConfig
 });
 const external_zod_namespaceObject = require("zod");
@@ -34,10 +35,11 @@ const types_cjs_namespaceObject = require("../middleware/hooks/types.cjs");
 const mcp_cjs_namespaceObject = require("../../types/mcp.cjs");
 const voice_cjs_namespaceObject = require("../../types/voice.cjs");
 const WingmanDirectory = ".wingman";
-const AvailableToolNames = external_zod_namespaceObject.z["enum"]([
+const AvailableToolNames = external_zod_namespaceObject["enum"]([
     "internet_search",
     "web_crawler",
     "command_execute",
+    "background_terminal",
     "think",
     "code_search",
     "git_status",
@@ -45,33 +47,43 @@ const AvailableToolNames = external_zod_namespaceObject.z["enum"]([
     "ui_registry_get",
     "ui_present"
 ]);
-const PromptRefinementSchema = external_zod_namespaceObject.z.preprocess((value)=>{
+const ReasoningEffortSchema = external_zod_namespaceObject.preprocess((value)=>{
+    if ("string" == typeof value) return value.trim().toLowerCase();
+    return value;
+}, external_zod_namespaceObject["enum"]([
+    "minimal",
+    "low",
+    "medium",
+    "high"
+]));
+const PromptRefinementSchema = external_zod_namespaceObject.preprocess((value)=>{
     if (void 0 === value) return;
     if ("boolean" == typeof value) return {
         enabled: value
     };
     return value;
-}, external_zod_namespaceObject.z.object({
-    enabled: external_zod_namespaceObject.z.boolean().optional().default(true).describe("Whether prompt refinement is enabled for this agent"),
-    instructionsPath: external_zod_namespaceObject.z.string().min(1).optional().describe("Path (virtual) to store the agent's prompt refinement overlay (defaults under /memories/)")
+}, external_zod_namespaceObject.object({
+    enabled: external_zod_namespaceObject.boolean().optional().default(true).describe("Whether prompt refinement is enabled for this agent"),
+    instructionsPath: external_zod_namespaceObject.string().min(1).optional().describe("Path (virtual) to store the agent's prompt refinement overlay (defaults under /memories/)")
 }).strict());
-const BaseAgentConfigSchema = external_zod_namespaceObject.z.object({
-    name: external_zod_namespaceObject.z.string().min(1).describe("Unique agent name (e.g., 'data-analyst')"),
-    description: external_zod_namespaceObject.z.string().min(1).describe("Action-oriented description of what the agent does (helps root agent decide when to delegate)"),
-    systemPrompt: external_zod_namespaceObject.z.string().min(1).describe("Detailed instructions for the agent, including tool usage guidance and output formatting"),
-    tools: external_zod_namespaceObject.z.array(AvailableToolNames).optional().describe("List of available tools for this agent. Keep minimal and focused."),
-    model: external_zod_namespaceObject.z.string().optional().describe('Model override in format "provider:model-name" (e.g., "anthropic:claude-opus-4-5", "codex:codex-mini-latest", "openrouter:openai/gpt-4o", "copilot:gpt-4o")'),
-    blockedCommands: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().describe("List of blocked commands for command_execute tool (e.g., ['rm', 'mv'])"),
-    allowScriptExecution: external_zod_namespaceObject.z.boolean().optional().default(true).describe("Whether to allow script execution in command_execute tool"),
-    commandTimeout: external_zod_namespaceObject.z.number().optional().default(300000).describe("Command execution timeout in milliseconds (default: 300000)"),
+const BaseAgentConfigSchema = external_zod_namespaceObject.object({
+    name: external_zod_namespaceObject.string().min(1).describe("Unique agent name (e.g., 'data-analyst')"),
+    description: external_zod_namespaceObject.string().min(1).describe("Action-oriented description of what the agent does (helps root agent decide when to delegate)"),
+    systemPrompt: external_zod_namespaceObject.string().min(1).describe("Detailed instructions for the agent, including tool usage guidance and output formatting"),
+    tools: external_zod_namespaceObject.array(AvailableToolNames).optional().describe("List of available tools for this agent. Keep minimal and focused."),
+    model: external_zod_namespaceObject.string().optional().describe('Model override in format "provider:model-name" (e.g., "anthropic:claude-opus-4-5", "codex:codex-mini-latest", "openrouter:openai/gpt-4o", "copilot:gpt-4o")'),
+    reasoningEffort: ReasoningEffortSchema.optional().describe("Optional reasoning/thinking effort for supported models (ignored when unsupported)"),
+    blockedCommands: external_zod_namespaceObject.array(external_zod_namespaceObject.string()).optional().describe("List of blocked commands for command_execute tool (e.g., ['rm', 'mv'])"),
+    allowScriptExecution: external_zod_namespaceObject.boolean().optional().default(true).describe("Whether to allow script execution in command_execute tool"),
+    commandTimeout: external_zod_namespaceObject.number().optional().default(300000).describe("Command execution timeout in milliseconds (default: 300000)"),
     toolHooks: types_cjs_namespaceObject.HooksConfigSchema.optional().describe("Agent-specific tool hooks configuration"),
     mcp: mcp_cjs_namespaceObject.MCPServersConfigSchema.optional().describe("Agent-specific MCP server configurations"),
-    mcpUseGlobal: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Whether this agent should also load global MCP servers from wingman.config.json"),
+    mcpUseGlobal: external_zod_namespaceObject.boolean().optional().default(false).describe("Whether this agent should also load global MCP servers from wingman.config.json"),
     voice: voice_cjs_namespaceObject.AgentVoiceConfigSchema.optional().describe("Agent-specific voice configuration"),
     promptRefinement: PromptRefinementSchema.optional().describe("Optional per-agent prompt refinement settings")
 });
 const AgentConfigSchema = BaseAgentConfigSchema.extend({
-    subAgents: external_zod_namespaceObject.z.array(BaseAgentConfigSchema).optional().describe("List of sub-agents that this agent can delegate to (each may include its own model override)")
+    subAgents: external_zod_namespaceObject.array(BaseAgentConfigSchema).optional().describe("List of sub-agents that this agent can delegate to (each may include its own model override)")
 }).superRefine((config, ctx)=>{
     if (!config.subAgents || 0 === config.subAgents.length) return;
     const parentName = config.name.trim().toLowerCase();
@@ -110,7 +122,7 @@ function validateAgentConfig(config) {
             data
         };
     } catch (error) {
-        if (error instanceof external_zod_namespaceObject.z.ZodError) {
+        if (error instanceof external_zod_namespaceObject.ZodError) {
             const messages = error.issues.map((err)=>`  - ${err.path.join(".")}: ${err.message}`).join("\n");
             return {
                 success: false,
@@ -125,11 +137,13 @@ function validateAgentConfig(config) {
 }
 exports.AgentConfigSchema = __webpack_exports__.AgentConfigSchema;
 exports.AvailableToolNames = __webpack_exports__.AvailableToolNames;
+exports.ReasoningEffortSchema = __webpack_exports__.ReasoningEffortSchema;
 exports.WingmanDirectory = __webpack_exports__.WingmanDirectory;
 exports.validateAgentConfig = __webpack_exports__.validateAgentConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AgentConfigSchema",
     "AvailableToolNames",
+    "ReasoningEffortSchema",
     "WingmanDirectory",
     "validateAgentConfig"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/agent/config/agentConfig.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 export declare const WingmanDirectory = ".wingman";
 /**
  * Available tool names for user-defined agents
@@ -7,6 +7,7 @@ export declare const AvailableToolNames: z.ZodEnum<{
     internet_search: "internet_search";
     web_crawler: "web_crawler";
     command_execute: "command_execute";
+    background_terminal: "background_terminal";
     think: "think";
     code_search: "code_search";
     git_status: "git_status";
@@ -15,6 +16,13 @@ export declare const AvailableToolNames: z.ZodEnum<{
     ui_present: "ui_present";
 }>;
 export type AvailableToolName = z.infer<typeof AvailableToolNames>;
+export declare const ReasoningEffortSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>>;
+export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
 declare const PromptRefinementSchema: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodObject<{
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     instructionsPath: z.ZodOptional<z.ZodString>;
@@ -28,6 +36,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         internet_search: "internet_search";
         web_crawler: "web_crawler";
         command_execute: "command_execute";
+        background_terminal: "background_terminal";
         think: "think";
         code_search: "code_search";
         git_status: "git_status";
@@ -36,6 +45,12 @@ export declare const AgentConfigSchema: z.ZodObject<{
         ui_present: "ui_present";
     }>>>;
     model: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>>;
     blockedCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
     allowScriptExecution: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     commandTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -115,6 +130,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
             internet_search: "internet_search";
             web_crawler: "web_crawler";
             command_execute: "command_execute";
+            background_terminal: "background_terminal";
             think: "think";
             code_search: "code_search";
             git_status: "git_status";
@@ -123,6 +139,12 @@ export declare const AgentConfigSchema: z.ZodObject<{
             ui_present: "ui_present";
         }>>>;
         model: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>>>;
         blockedCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
         allowScriptExecution: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         commandTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

package/dist/agent/config/agentConfig.js

@@ -1,12 +1,13 @@
-import { z } from "zod";
+import { ZodError, array, boolean as external_zod_boolean, enum as external_zod_enum, number, object, preprocess, string } from "zod";
 import { HooksConfigSchema } from "../middleware/hooks/types.js";
 import { MCPServersConfigSchema } from "../../types/mcp.js";
 import { AgentVoiceConfigSchema } from "../../types/voice.js";
 const WingmanDirectory = ".wingman";
-const AvailableToolNames = z["enum"]([
+const AvailableToolNames = external_zod_enum([
     "internet_search",
     "web_crawler",
     "command_execute",
+    "background_terminal",
     "think",
     "code_search",
     "git_status",
@@ -14,33 +15,43 @@ const AvailableToolNames = z["enum"]([
     "ui_registry_get",
     "ui_present"
 ]);
-const PromptRefinementSchema = z.preprocess((value)=>{
+const ReasoningEffortSchema = preprocess((value)=>{
+    if ("string" == typeof value) return value.trim().toLowerCase();
+    return value;
+}, external_zod_enum([
+    "minimal",
+    "low",
+    "medium",
+    "high"
+]));
+const PromptRefinementSchema = preprocess((value)=>{
     if (void 0 === value) return;
     if ("boolean" == typeof value) return {
         enabled: value
     };
     return value;
-}, z.object({
-    enabled: z.boolean().optional().default(true).describe("Whether prompt refinement is enabled for this agent"),
-    instructionsPath: z.string().min(1).optional().describe("Path (virtual) to store the agent's prompt refinement overlay (defaults under /memories/)")
+}, object({
+    enabled: external_zod_boolean().optional().default(true).describe("Whether prompt refinement is enabled for this agent"),
+    instructionsPath: string().min(1).optional().describe("Path (virtual) to store the agent's prompt refinement overlay (defaults under /memories/)")
 }).strict());
-const BaseAgentConfigSchema = z.object({
-    name: z.string().min(1).describe("Unique agent name (e.g., 'data-analyst')"),
-    description: z.string().min(1).describe("Action-oriented description of what the agent does (helps root agent decide when to delegate)"),
-    systemPrompt: z.string().min(1).describe("Detailed instructions for the agent, including tool usage guidance and output formatting"),
-    tools: z.array(AvailableToolNames).optional().describe("List of available tools for this agent. Keep minimal and focused."),
-    model: z.string().optional().describe('Model override in format "provider:model-name" (e.g., "anthropic:claude-opus-4-5", "codex:codex-mini-latest", "openrouter:openai/gpt-4o", "copilot:gpt-4o")'),
-    blockedCommands: z.array(z.string()).optional().describe("List of blocked commands for command_execute tool (e.g., ['rm', 'mv'])"),
-    allowScriptExecution: z.boolean().optional().default(true).describe("Whether to allow script execution in command_execute tool"),
-    commandTimeout: z.number().optional().default(300000).describe("Command execution timeout in milliseconds (default: 300000)"),
+const BaseAgentConfigSchema = object({
+    name: string().min(1).describe("Unique agent name (e.g., 'data-analyst')"),
+    description: string().min(1).describe("Action-oriented description of what the agent does (helps root agent decide when to delegate)"),
+    systemPrompt: string().min(1).describe("Detailed instructions for the agent, including tool usage guidance and output formatting"),
+    tools: array(AvailableToolNames).optional().describe("List of available tools for this agent. Keep minimal and focused."),
+    model: string().optional().describe('Model override in format "provider:model-name" (e.g., "anthropic:claude-opus-4-5", "codex:codex-mini-latest", "openrouter:openai/gpt-4o", "copilot:gpt-4o")'),
+    reasoningEffort: ReasoningEffortSchema.optional().describe("Optional reasoning/thinking effort for supported models (ignored when unsupported)"),
+    blockedCommands: array(string()).optional().describe("List of blocked commands for command_execute tool (e.g., ['rm', 'mv'])"),
+    allowScriptExecution: external_zod_boolean().optional().default(true).describe("Whether to allow script execution in command_execute tool"),
+    commandTimeout: number().optional().default(300000).describe("Command execution timeout in milliseconds (default: 300000)"),
     toolHooks: HooksConfigSchema.optional().describe("Agent-specific tool hooks configuration"),
     mcp: MCPServersConfigSchema.optional().describe("Agent-specific MCP server configurations"),
-    mcpUseGlobal: z.boolean().optional().default(false).describe("Whether this agent should also load global MCP servers from wingman.config.json"),
+    mcpUseGlobal: external_zod_boolean().optional().default(false).describe("Whether this agent should also load global MCP servers from wingman.config.json"),
     voice: AgentVoiceConfigSchema.optional().describe("Agent-specific voice configuration"),
     promptRefinement: PromptRefinementSchema.optional().describe("Optional per-agent prompt refinement settings")
 });
 const AgentConfigSchema = BaseAgentConfigSchema.extend({
-    subAgents: z.array(BaseAgentConfigSchema).optional().describe("List of sub-agents that this agent can delegate to (each may include its own model override)")
+    subAgents: array(BaseAgentConfigSchema).optional().describe("List of sub-agents that this agent can delegate to (each may include its own model override)")
 }).superRefine((config, ctx)=>{
     if (!config.subAgents || 0 === config.subAgents.length) return;
     const parentName = config.name.trim().toLowerCase();
@@ -79,7 +90,7 @@ function validateAgentConfig(config) {
             data
         };
     } catch (error) {
-        if (error instanceof z.ZodError) {
+        if (error instanceof ZodError) {
             const messages = error.issues.map((err)=>`  - ${err.path.join(".")}: ${err.message}`).join("\n");
             return {
                 success: false,
@@ -92,4 +103,4 @@ function validateAgentConfig(config) {
         };
     }
 }
-export { AgentConfigSchema, AvailableToolNames, WingmanDirectory, validateAgentConfig };
+export { AgentConfigSchema, AvailableToolNames, ReasoningEffortSchema, WingmanDirectory, validateAgentConfig };

package/dist/agent/config/agentLoader.cjs

@@ -29,10 +29,10 @@ __webpack_require__.d(__webpack_exports__, {
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 const external_js_yaml_namespaceObject = require("js-yaml");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 const external_agentConfig_cjs_namespaceObject = require("./agentConfig.cjs");
-const external_toolRegistry_cjs_namespaceObject = require("./toolRegistry.cjs");
 const external_modelFactory_cjs_namespaceObject = require("./modelFactory.cjs");
-const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const external_toolRegistry_cjs_namespaceObject = require("./toolRegistry.cjs");
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -59,6 +59,7 @@ const buildPromptRefinementInstructions = (instructionsPath)=>[
         "Prompt Refinement:",
         `- Maintain a durable overlay at ${instructionsPath} for stable preferences and corrections.`,
         "- Read it at the start of each session and follow it in addition to this system prompt.",
+        "- Treat that overlay as secondary preference memory; if it conflicts with role, safety, or execution rules in this system prompt, follow this system prompt.",
         '- Only update it when the user gives explicit, lasting feedback (e.g., "always", "never", "prefer").',
         "- Keep entries short, stable, and avoid task-specific details.",
         "- If the file doesn't exist, create it with a short header and bullet list."
@@ -126,12 +127,18 @@ class AgentLoader {
         }
     }
     normalizeAgentConfig(config) {
+        const normalizeReasoningEffort = (target)=>{
+            if (void 0 === target.reasoningEffort && void 0 !== target.thinkingEffort) target.reasoningEffort = target.thinkingEffort;
+            if ("thinkingEffort" in target) delete target.thinkingEffort;
+        };
+        normalizeReasoningEffort(config);
         if (config.subagents && !config.subAgents) {
             config.subAgents = config.subagents;
             delete config.subagents;
         }
-        if (Array.isArray(config.subAgents)) {
-            for (const subagent of config.subAgents)if (subagent?.subagents && !subagent.subAgents) {
+        if (Array.isArray(config.subAgents)) for (const subagent of config.subAgents){
+            normalizeReasoningEffort(subagent);
+            if (subagent?.subagents && !subagent.subAgents) {
                 subagent.subAgents = subagent.subagents;
                 delete subagent.subagents;
             }
@@ -224,7 +231,8 @@ class AgentLoader {
                 searchConfig: this.wingmanConfig?.search,
                 mcpConfigs,
                 skillsDirectory,
-                dynamicUiEnabled
+                dynamicUiEnabled,
+                ...this.runtimeToolOptions
             };
         };
         if (config.tools && config.tools.length > 0) agent.tools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(config.tools, buildToolOptions(config));
@@ -240,12 +248,16 @@ class AgentLoader {
         if (config.mcp) agent.mcpConfig = config.mcp;
         if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
         if (config.model) try {
-            agent.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(config.model);
+            agent.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(config.model, {
+                reasoningEffort: config.reasoningEffort,
+                ownerLabel: `Agent "${config.name}"`
+            });
             logger.info(`Agent "${config.name}" using model: ${config.model}`);
         } catch (error) {
             logger.error(`Failed to create model for agent "${config.name}": ${error}`);
             logger.info(`Agent "${config.name}" will use default model`);
         }
+        else if (config.reasoningEffort) logger.warn(`Agent "${config.name}" set reasoningEffort="${config.reasoningEffort}" but has no model override. Ignoring.`);
         if (config.subAgents) {
             const subagents = [];
             for (const subagent of config.subAgents){
@@ -269,26 +281,32 @@ class AgentLoader {
                     ];
                 } else sub.tools = subUiTools;
                 if (subagent.model) try {
-                    sub.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(subagent.model);
+                    sub.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(subagent.model, {
+                        reasoningEffort: subagent.reasoningEffort,
+                        ownerLabel: `Subagent "${subagent.name}"`
+                    });
                     logger.info(`Subagent "${subagent.name}" using model: ${subagent.model}`);
                 } catch (error) {
                     logger.error(`Failed to create model for subagent "${subagent.name}": ${error}`);
                 }
+                else if (subagent.reasoningEffort) logger.warn(`Subagent "${subagent.name}" set reasoningEffort="${subagent.reasoningEffort}" but has no model override. Ignoring.`);
                 subagents.push(sub);
             }
             agent.subagents = subagents;
         }
         return agent;
     }
-    constructor(configDir = external_agentConfig_cjs_namespaceObject.WingmanDirectory, workspace = process.cwd(), wingmanConfig, executionWorkspace = workspace){
+    constructor(configDir = external_agentConfig_cjs_namespaceObject.WingmanDirectory, workspace = process.cwd(), wingmanConfig, executionWorkspace = workspace, runtimeToolOptions = {}){
         _define_property(this, "configDir", void 0);
         _define_property(this, "workspace", void 0);
         _define_property(this, "wingmanConfig", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "runtimeToolOptions", void 0);
         this.configDir = configDir;
         this.workspace = workspace;
         this.wingmanConfig = wingmanConfig;
         this.executionWorkspace = executionWorkspace;
+        this.runtimeToolOptions = runtimeToolOptions;
     }
 }
 exports.AgentLoader = __webpack_exports__.AgentLoader;

package/dist/agent/config/agentLoader.d.ts

@@ -1,6 +1,7 @@
-import { type WingmanAgentConfig } from "./agentConfig.js";
 import type { WingmanAgent } from "@/types/agents.js";
 import type { WingmanConfigType } from "../../cli/config/schema.js";
+import { type WingmanAgentConfig } from "./agentConfig.js";
+import { type ToolOptions } from "./toolRegistry.js";
 /**
  * Load and validate agent configurations from multiple sources
  */
@@ -9,7 +10,8 @@ export declare class AgentLoader {
     private workspace;
     private wingmanConfig?;
     private executionWorkspace;
-    constructor(configDir?: string, workspace?: string, wingmanConfig?: WingmanConfigType | undefined, executionWorkspace?: string);
+    private runtimeToolOptions;
+    constructor(configDir?: string, workspace?: string, wingmanConfig?: WingmanConfigType | undefined, executionWorkspace?: string, runtimeToolOptions?: Partial<ToolOptions>);
     private resolveConfigPath;
     loadAllAgentConfigs(): WingmanAgentConfig[];
     /**