teapot-coding-agent 0.26.10 → 0.26.12

package/dist/agent/tools.js

@@ -6,6 +6,7 @@ import { spawn } from "node:child_process";
 import { existsSync, promises as fs, readlinkSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { discoverSkills, isValidSkillName, readSkillFile, saveSkill, SKILL_FILE, } from "./skills.js";
+import { isReasoningEffort } from "../model-meta.js";
 const str = (v, fallback = "") => (typeof v === "string" ? v : fallback);
 const num = (v, fallback) => (typeof v === "number" ? v : fallback);
 function clip(s, max) {
@@ -1532,6 +1533,24 @@ export const TOOLS = [
                 task: { type: "string", description: "self-contained instructions for the sub-agent" },
                 context: { type: "string", enum: ["none", "fork"], description: "default none" },
                 name: { type: "string", description: "optional short name fragment for the id" },
+                // #105: reasoning effort for THIS sub-agent, overriding both the
+                // configured subagent default and the parent's inherited value.
+                //
+                // Precedence mirrors OpenAI Codex (codex-rs/core/src/agent/child_config.rs):
+                // spawn argument -> configured default -> parent's effort. Codex
+                // deliberately does NOT inherit by default — its own test sets a parent at
+                // XHigh and asserts a child spawned with Low runs at Low, because
+                // sub-agents are usually narrow and cheap and inheriting a parent's high
+                // effort across many trivial scouts multiplies cost for no gain.
+                //
+                // Naming it here is what stops the silent loss: previously a spawn could
+                // not express an effort at all, so the parent's value simply vanished.
+                reasoning_effort: {
+                    type: "string",
+                    enum: ["minimal", "low", "medium", "high", "xhigh"],
+                    description: "reasoning effort for this sub-agent. Omit to use the configured default, " +
+                        "then the parent's effort. Lower it for cheap, narrow scouts.",
+                },
             },
             required: ["task"],
         },
@@ -1544,10 +1563,20 @@ export const TOOLS = [
                 return { ok: false, result: "task required" };
             const context = args.context === "fork" ? "fork" : "none";
             try {
+                // #105: validate like the per-agent setter does, so a typo cannot reach
+                // the provider as an unrecognised effort value.
+                const effort = str(args.reasoning_effort).trim();
+                if (effort && !isReasoningEffort(effort))
+                    return {
+                        ok: false,
+                        result: `reasoning_effort must be minimal|low|medium|high|xhigh (got "${effort}") — ` +
+                            "omit it to use the configured default, then the parent's effort",
+                    };
                 const r = await sa.spawn({
                     task,
                     context,
                     name: str(args.name).trim() || undefined,
+                    ...(effort ? { reasoning_effort: effort } : {}),
                 });
                 return { ok: true, result: `spawned sub-agent ${r.id} — park with wait_children() until it reports (never bash sleep), steer via message_agent, halt via stop_children` };
             }

package/dist/master.js

@@ -12,7 +12,7 @@ import { spawn } from "node:child_process";
 import { Agent } from "./agent/agent.js";
 import { parseSchedule, matches, nextFireAt } from "./scheduler/cron.js";
 import { bus } from "./bus.js";
-import { fetchModelList, contextLengthFor, isReasoningEffort } from "./model-meta.js";
+import { fetchModelList, contextLengthFor, isReasoningEffort, } from "./model-meta.js";
 /** how deep sub-agent spawning may nest (parent=0, its subs=1, …) */
 const MAX_SPAWN_DEPTH = 3;
 /**
@@ -620,12 +620,34 @@ export class Master {
             forkTip = parent.log.lastEventId(parent.currentBranch);
             forkBranch = parent.currentBranch;
         }
+        // #105: reasoning effort for the child.
+        //
+        // Precedence mirrors OpenAI Codex (codex-rs/core/src/agent/child_config.rs:
+        // `requested.or_else(configured_default).or(parent)`):
+        //
+        //   1. the spawn argument        — explicit, per-call
+        //   2. `defaultSubagentReasoningEffort` from config — a global backstop
+        //   3. the parent's effort       — last resort
+        //
+        // Codex deliberately does NOT inherit by default, and its own test proves the
+        // intent: parent at XHigh, spawn requests Low, and the child runs at Low
+        // (codex-rs/core/tests/suite/subagent_notifications.rs). Sub-agents are
+        // usually narrow and cheap, so inheriting a parent's `high` across twenty
+        // trivial scouts multiplies cost and latency for no gain.
+        //
+        // Before this, `reasoningEffort` was simply omitted here while `provider`,
+        // `model` and `contextWindowTokens` two lines below WERE inherited — so a
+        // parent's effort vanished silently, with no way for a spawn to express one.
+        const childEffort = o.reasoning_effort || this.config.defaultSubagentReasoningEffort || pcfg?.reasoningEffort;
         const child = await this.addAgent({
             id,
             workspace: parent.workspace,
             provider: pcfg?.provider,
             model: pcfg?.model,
             contextWindowTokens: pcfg?.contextWindowTokens,
+            // #105: persisted with the child, like every other inherited field, so a
+            // restart restores the same effort rather than reverting to the default
+            ...(childEffort ? { reasoningEffort: childEffort } : {}),
             parent: parentId,
             ...(persona && SUB_PERSONAS[persona]?.readOnly ? { readOnly: true } : {}),
         }, { persist: true, fresh: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.26.10",
+  "version": "0.26.12",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",