aiden-runtime 4.5.0 → 4.6.1

package/dist/core/v4/ui/theme.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/ui/theme.ts — ONB1 (v4.7 onboarding rework).
+ *
+ * Self-contained theme module for the redesigned first-run experience.
+ * Lives alongside, NOT instead of, the existing skin engine
+ * (cli/v4/skinEngine.ts). The skin engine drives the REPL / boot card
+ * / every post-onboarding surface; this theme drives only the
+ * onboarding screens (slices 1–10 of dispatch ONB1).
+ *
+ * Why a separate module:
+ *   - Onboarding palette is specified to a different muted/text spec
+ *     than the existing skin (e.g. cool-grey #71717A vs warm-tan
+ *     #B8A89A). Swapping the skin would re-paint every chat turn the
+ *     user sees afterwards, surprising the eye on the *second* boot.
+ *   - Onboarding is a single-shot surface — no per-user customisation,
+ *     no YAML loader, no `monochrome`/`light` variants needed beyond
+ *     graceful colour-depth degradation.
+ *
+ * Truecolor → 256 → 16 detection runs once at module load and is
+ * cached. Set `AIDEN_FORCE_COLOR_DEPTH=truecolor|256|16|none` to
+ * override (smoke tests rely on this).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEP_LIGHT = exports.SEP_HEAVY = exports.dim = exports.italic = exports.bold = exports.c = exports.PALETTE = void 0;
+exports.getColorDepth = getColorDepth;
+exports.paint = paint;
+exports.separator = separator;
+exports.termWidth = termWidth;
+/**
+ * The 8-colour onboarding palette. Hex strings are the source of
+ * truth; the emit functions below convert per detected depth.
+ */
+exports.PALETTE = {
+    primary: '#FF6B35', // brand orange — Aiden hero
+    accent: '#FFB088', // light orange — highlights
+    success: '#4ADE80', // green checkmarks
+    warning: '#FBBF24', // amber warnings
+    error: '#EF4444', // red errors
+    text: '#F5F5F5', // bright white — headers/titles
+    muted: '#71717A', // dim grey — secondary text/hints
+    rule: '#27272A', // dark grey — separators
+};
+/** Parse a `#RRGGBB` hex string into [r,g,b]. */
+function hexToRgb(hex) {
+    const m = /^#?([0-9a-fA-F]{6})$/.exec(hex);
+    if (!m)
+        return [255, 255, 255];
+    const n = parseInt(m[1], 16);
+    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
+}
+/**
+ * Map a 24-bit RGB triple to the closest xterm-256 colour index.
+ * Uses the standard 6×6×6 cube + grey-ramp approximation.
+ */
+function rgbTo256(r, g, b) {
+    // Grey-ramp fast path: when r==g==b within 8, prefer the 24-step ramp.
+    if (Math.abs(r - g) < 8 && Math.abs(g - b) < 8) {
+        if (r < 8)
+            return 16;
+        if (r > 248)
+            return 231;
+        return Math.round(((r - 8) / 247) * 24) + 232;
+    }
+    const q = (v) => Math.round(v / 51);
+    return 16 + 36 * q(r) + 6 * q(g) + q(b);
+}
+/**
+ * Map a 24-bit RGB triple to a low-fidelity 16-colour ANSI code
+ * (30–37 / 90–97). Picks the closest of the 16 standard slots.
+ */
+function rgbTo16(r, g, b) {
+    const STD = [
+        [30, 0, 0, 0], [31, 205, 49, 49], [32, 13, 188, 121], [33, 229, 229, 16],
+        [34, 36, 114, 200], [35, 188, 63, 188], [36, 17, 168, 205], [37, 229, 229, 229],
+        [90, 102, 102, 102], [91, 241, 76, 76], [92, 35, 209, 139], [93, 245, 245, 67],
+        [94, 59, 142, 234], [95, 214, 112, 214], [96, 41, 184, 219], [97, 229, 229, 229],
+    ];
+    let best = STD[0];
+    let bestDist = Infinity;
+    for (const cand of STD) {
+        const [, cr, cg, cb] = cand;
+        const d = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
+        if (d < bestDist) {
+            bestDist = d;
+            best = cand;
+        }
+    }
+    return best[0];
+}
+/** Detect the terminal's effective colour depth. Cached at module load. */
+function detectColorDepth() {
+    const forced = process.env.AIDEN_FORCE_COLOR_DEPTH?.toLowerCase();
+    if (forced === 'truecolor' || forced === '256' || forced === '16' || forced === 'none') {
+        return forced;
+    }
+    if (process.env.NO_COLOR && process.env.NO_COLOR !== '')
+        return 'none';
+    if (!process.stdout.isTTY)
+        return 'none';
+    const ct = (process.env.COLORTERM ?? '').toLowerCase();
+    if (ct === 'truecolor' || ct === '24bit')
+        return 'truecolor';
+    const term = (process.env.TERM ?? '').toLowerCase();
+    if (term.includes('256'))
+        return '256';
+    if (term === 'dumb' || term === '')
+        return 'none';
+    return '16';
+}
+const COLOR_DEPTH = detectColorDepth();
+/** Public: report the depth (smoke tests + diagnostics). */
+function getColorDepth() { return COLOR_DEPTH; }
+/** Wrap `text` in the SGR sequence for `kind`, degrading per depth. */
+function paint(text, kind) {
+    if (COLOR_DEPTH === 'none')
+        return text;
+    const [r, g, b] = hexToRgb(exports.PALETTE[kind]);
+    if (COLOR_DEPTH === 'truecolor')
+        return `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+    if (COLOR_DEPTH === '256')
+        return `\x1b[38;5;${rgbTo256(r, g, b)}m${text}\x1b[39m`;
+    return `\x1b[${rgbTo16(r, g, b)}m${text}\x1b[39m`;
+}
+/** Convenience helpers — one per palette key. */
+exports.c = {
+    primary: (s) => paint(s, 'primary'),
+    accent: (s) => paint(s, 'accent'),
+    success: (s) => paint(s, 'success'),
+    warning: (s) => paint(s, 'warning'),
+    error: (s) => paint(s, 'error'),
+    text: (s) => paint(s, 'text'),
+    muted: (s) => paint(s, 'muted'),
+    rule: (s) => paint(s, 'rule'),
+};
+/** SGR helpers for emphasis. Italic gracefully degrades when unsupported. */
+const bold = (s) => (COLOR_DEPTH === 'none' ? s : `\x1b[1m${s}\x1b[22m`);
+exports.bold = bold;
+const italic = (s) => (COLOR_DEPTH === 'none' ? s : `\x1b[3m${s}\x1b[23m`);
+exports.italic = italic;
+const dim = (s) => (COLOR_DEPTH === 'none' ? s : `\x1b[2m${s}\x1b[22m`);
+exports.dim = dim;
+/**
+ * Common ornaments — single source so onboarding screens share rhythm.
+ */
+exports.SEP_HEAVY = '━';
+exports.SEP_LIGHT = '─';
+/** Render a full-width separator in RULE colour, optionally heavy. */
+function separator(width, heavy = true) {
+    const w = Math.max(8, Math.min(width, 100));
+    const ch = heavy ? exports.SEP_HEAVY : exports.SEP_LIGHT;
+    return exports.c.rule(ch.repeat(w));
+}
+/** Effective terminal width clamped to a sane band. */
+function termWidth() {
+    const raw = process.stdout.columns ?? 80;
+    return Math.max(40, Math.min(raw, 100));
+}

package/dist/core/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // AUTO-GENERATED by scripts/inject-version.js — do not edit by hand
-exports.VERSION = '4.5.0';
+exports.VERSION = '4.6.1';

package/dist/moat/plannerGuard.js

@@ -87,10 +87,39 @@ const RULES = [
         toolsets: ['execute'],
     },
     // Process registry
+    //
+    // Note: the bare word "spawn" appears in this rule's keyword list
+    // (legacy — predates v4.6 sub-agents). The dedicated 'subagent'
+    // rule below ALSO matches "spawn" via a tighter delegation
+    // vocabulary, so a message like "spawn a background server" hits
+    // BOTH rules and adds both toolsets — UNION semantics make this
+    // additive, not conflicting.
     {
         keywords: /\b(process|background|long.?running|server|spawn|kill|daemon)\b/i,
         toolsets: ['process'],
     },
+    // v4.6 Phase 1 — sub-agent delegation surface (spawn_sub_agent +
+    // subagent_fanout). Both tools live in toolset `'subagent'`, which
+    // no pre-v4.6 rule mapped to — so PlannerGuard's per-turn narrowing
+    // silently stripped them from the model's catalog whenever any
+    // other rule fired. The model could see them via lookup_tool_schema
+    // but failed to actually invoke them because the provider tool list
+    // (post-narrow) didn't include them — see Dispatch 2H diagnostic.
+    //
+    // Regex notes:
+    //   - `spawn_sub_agent` and `subagent_fanout` literals are listed
+    //     explicitly because `\bspawn\b` does NOT match within
+    //     `spawn_sub_agent` (underscore is a word char in JS regex,
+    //     so there's no word boundary between `n` and `_`). Users who
+    //     name the tool directly hit the literal arm.
+    //   - The free-form vocabulary arm (`spawn`, `delegate`, etc.)
+    //     catches natural-language delegation intent. UNION semantics
+    //     with other rules let "spawn a child to read files" surface
+    //     both 'subagent' AND 'files'.
+    {
+        keywords: /\b(spawn_sub_agent|subagent_fanout|spawn|subagent|sub.?agent|delegate|fanout|fan.?out|child.?agent|parallel|isolated)\b/i,
+        toolsets: ['subagent'],
+    },
     // Media playback control (v4.1.4-media)
     //
     // Without this, intents like "list media sessions" matched the

package/dist/providers/v4/anthropicAdapter.js

@@ -92,14 +92,14 @@ class AnthropicAdapter {
     // ── Public: non-streaming ────────────────────────────────────────────────
     async call(input) {
         const body = this.buildBody(input, /* streaming */ false);
-        const reply = await this.dispatch(body, /* streaming */ false);
+        const reply = await this.dispatch(body, /* streaming */ false, input.signal);
         const json = (await reply.json());
         return decodeResponse(json);
     }
     // ── Public: streaming ────────────────────────────────────────────────────
     async *callStream(input) {
         const body = this.buildBody(input, /* streaming */ true);
-        const reply = await this.dispatch(body, /* streaming */ true);
+        const reply = await this.dispatch(body, /* streaming */ true, input.signal);
         if (!reply.body) {
             // Server promised SSE but gave us nothing — fall through to a synthetic
             // empty done event so the agent loop terminates rather than hangs.
@@ -163,7 +163,7 @@ class AnthropicAdapter {
         // beta flags, or per-deployment routing tags without forking the adapter.
         return { ...headers, ...this.extraHeaders };
     }
-    async dispatch(body, streaming) {
+    async dispatch(body, streaming, externalSignal) {
         // Resolved once per process via the userAgent module's cache, so paying
         // for the version detection here is cheap on every retry/turn.
         const userAgent = await (0, userAgent_1.getClaudeCliUserAgent)();
@@ -174,6 +174,22 @@ class AnthropicAdapter {
         for (let attempt = 0; attempt < totalTries; attempt++) {
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            // v4.6 prep — forward an external AbortSignal into this attempt's
+            // internal controller so a parent agent that aborts mid-flight
+            // cancels the in-flight fetch. External aborts surface as a raw
+            // AbortError (NOT ProviderTimeoutError) so AidenAgent can route
+            // them as `finishReason: 'interrupted'` instead of treating them
+            // as a retryable timeout.
+            let externalAbortHandler = null;
+            if (externalSignal) {
+                if (externalSignal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    externalAbortHandler = () => controller.abort();
+                    externalSignal.addEventListener('abort', externalAbortHandler, { once: true });
+                }
+            }
             let response;
             try {
                 response = await fetch(this.endpoint, {
@@ -185,7 +201,16 @@ class AnthropicAdapter {
             }
             catch (err) {
                 clearTimeout(timer);
+                if (externalAbortHandler && externalSignal) {
+                    externalSignal.removeEventListener('abort', externalAbortHandler);
+                }
                 if (err?.name === 'AbortError') {
+                    // v4.6 prep — external abort takes priority over internal
+                    // timeout. Surface the raw AbortError immediately (no retry)
+                    // so AidenAgent's catch routes it as 'interrupted'.
+                    if (externalSignal?.aborted) {
+                        throw err;
+                    }
                     // Treat timeout as retryable; only surface ProviderTimeoutError if
                     // we've burned the last attempt.
                     lastErr = new errors_1.ProviderTimeoutError(this.providerName, this.timeoutMs);
@@ -200,6 +225,9 @@ class AnthropicAdapter {
                 throw lastErr;
             }
             clearTimeout(timer);
+            if (externalAbortHandler && externalSignal) {
+                externalSignal.removeEventListener('abort', externalAbortHandler);
+            }
             if (response.ok)
                 return response;
             // Phase 25.1.5d diagnostic: gated dump of request + response so we

package/dist/providers/v4/chatCompletionsAdapter.js

@@ -73,7 +73,7 @@ class ChatCompletionsAdapter {
     // ── Non-streaming ────────────────────────────────────────────────────
     async call(input) {
         const body = this.buildBody(input, /* streaming */ false);
-        const reply = await this.dispatch(body, /* streaming */ false);
+        const reply = await this.dispatch(body, /* streaming */ false, input.signal);
         const text = await reply.text();
         let parsed;
         try {
@@ -91,7 +91,7 @@ class ChatCompletionsAdapter {
     // ── Streaming ────────────────────────────────────────────────────────
     async *callStream(input) {
         const body = this.buildBody(input, /* streaming */ true);
-        const reply = await this.dispatch(body, /* streaming */ true);
+        const reply = await this.dispatch(body, /* streaming */ true, input.signal);
         if (!reply.body) {
             yield {
                 type: 'done',
@@ -150,7 +150,7 @@ class ChatCompletionsAdapter {
             headers['Accept'] = 'text/event-stream';
         return { ...headers, ...this.extraHeaders };
     }
-    async dispatch(body, streaming) {
+    async dispatch(body, streaming, externalSignal) {
         const headers = this.buildHeaders(streaming);
         const serialised = JSON.stringify(body);
         const totalTries = this.maxRetries + 1;
@@ -158,6 +158,19 @@ class ChatCompletionsAdapter {
         for (let attempt = 0; attempt < totalTries; attempt++) {
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            // v4.6 prep — forward external abort into the internal controller.
+            // External aborts surface as raw AbortError so AidenAgent routes
+            // them as 'interrupted' rather than retrying as ProviderTimeoutError.
+            let externalAbortHandler = null;
+            if (externalSignal) {
+                if (externalSignal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    externalAbortHandler = () => controller.abort();
+                    externalSignal.addEventListener('abort', externalAbortHandler, { once: true });
+                }
+            }
             let response;
             try {
                 response = await fetch(this.endpoint, {
@@ -169,7 +182,14 @@ class ChatCompletionsAdapter {
             }
             catch (err) {
                 clearTimeout(timer);
+                if (externalAbortHandler && externalSignal) {
+                    externalSignal.removeEventListener('abort', externalAbortHandler);
+                }
                 if (err?.name === 'AbortError') {
+                    // v4.6 prep — external abort takes priority over internal timeout.
+                    if (externalSignal?.aborted) {
+                        throw err;
+                    }
                     lastErr = new errors_1.ProviderTimeoutError(this.providerName, this.timeoutMs);
                 }
                 else {
@@ -182,6 +202,9 @@ class ChatCompletionsAdapter {
                 throw lastErr;
             }
             clearTimeout(timer);
+            if (externalAbortHandler && externalSignal) {
+                externalSignal.removeEventListener('abort', externalAbortHandler);
+            }
             if (response.ok)
                 return response;
             const status = response.status;

package/dist/providers/v4/codexResponsesAdapter.js

@@ -104,7 +104,7 @@ class CodexResponsesAdapter {
     // ── Public: non-streaming entry ─────────────────────────────────────
     async call(input) {
         const body = this.buildBody(input);
-        const reply = await this.dispatch(body);
+        const reply = await this.dispatch(body, input.signal);
         // Codex backend always streams; aggregate the SSE frames into the
         // same shape the JSON path returns. Plain api.openai.com path returns
         // JSON directly.
@@ -175,7 +175,7 @@ class CodexResponsesAdapter {
         }
         return { ...headers, ...this.extraHeaders };
     }
-    async dispatch(body) {
+    async dispatch(body, externalSignal) {
         const headers = this.buildHeaders();
         const serialised = JSON.stringify(body);
         const totalTries = this.maxRetries + 1;
@@ -183,6 +183,19 @@ class CodexResponsesAdapter {
         for (let attempt = 0; attempt < totalTries; attempt++) {
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            // v4.6 prep — forward external abort into the internal controller.
+            // External aborts surface as raw AbortError so AidenAgent routes
+            // them as 'interrupted' rather than retrying as ProviderTimeoutError.
+            let externalAbortHandler = null;
+            if (externalSignal) {
+                if (externalSignal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    externalAbortHandler = () => controller.abort();
+                    externalSignal.addEventListener('abort', externalAbortHandler, { once: true });
+                }
+            }
             let response;
             try {
                 response = await fetch(this.endpoint, {
@@ -194,7 +207,14 @@ class CodexResponsesAdapter {
             }
             catch (err) {
                 clearTimeout(timer);
+                if (externalAbortHandler && externalSignal) {
+                    externalSignal.removeEventListener('abort', externalAbortHandler);
+                }
                 if (err?.name === 'AbortError') {
+                    // v4.6 prep — external abort takes priority over internal timeout.
+                    if (externalSignal?.aborted) {
+                        throw err;
+                    }
                     lastErr = new errors_1.ProviderTimeoutError(this.providerName, this.timeoutMs);
                 }
                 else {
@@ -207,6 +227,9 @@ class CodexResponsesAdapter {
                 throw lastErr;
             }
             clearTimeout(timer);
+            if (externalAbortHandler && externalSignal) {
+                externalSignal.removeEventListener('abort', externalAbortHandler);
+            }
             if (response.ok)
                 return response;
             const status = response.status;

package/dist/providers/v4/ollamaPromptToolsAdapter.js

@@ -63,7 +63,7 @@ class OllamaPromptToolsAdapter {
         let lastError = null;
         for (let attempt = 1; attempt <= totalAttempts; attempt += 1) {
             try {
-                const response = await this.fetchWithTimeout(url, headers, body);
+                const response = await this.fetchWithTimeout(url, headers, body, input.signal);
                 if (response.ok) {
                     const json = (await response.json());
                     return this.parseResponse(json);
@@ -134,6 +134,17 @@ class OllamaPromptToolsAdapter {
         const headers = { 'Content-Type': 'application/json' };
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        // v4.6 prep — forward external abort into the internal controller.
+        let externalAbortHandler = null;
+        if (input.signal) {
+            if (input.signal.aborted) {
+                controller.abort();
+            }
+            else {
+                externalAbortHandler = () => controller.abort();
+                input.signal.addEventListener('abort', externalAbortHandler, { once: true });
+            }
+        }
         let response;
         try {
             response = await fetch(url, {
@@ -145,13 +156,23 @@ class OllamaPromptToolsAdapter {
         }
         catch (err) {
             clearTimeout(timer);
+            if (externalAbortHandler && input.signal) {
+                input.signal.removeEventListener('abort', externalAbortHandler);
+            }
             if (err instanceof Error && err.name === 'AbortError') {
+                // v4.6 prep — external abort takes priority over internal timeout.
+                if (input.signal?.aborted) {
+                    throw err;
+                }
                 throw new errors_1.ProviderTimeoutError(this.providerName, this.timeoutMs);
             }
             throw new errors_1.ProviderError(`Ollama not reachable at ${this.baseUrl}: ${err instanceof Error ? err.message : String(err)}`, this.providerName, undefined, err, true);
         }
         if (!response.ok) {
             clearTimeout(timer);
+            if (externalAbortHandler && input.signal) {
+                input.signal.removeEventListener('abort', externalAbortHandler);
+            }
             const status = response.status;
             const rawText = await this.safeReadText(response);
             // Phase v4.1.1-oauth-fix Phase 5: composeMessage handles body
@@ -160,8 +181,15 @@ class OllamaPromptToolsAdapter {
         }
         if (!response.body) {
             clearTimeout(timer);
+            if (externalAbortHandler && input.signal) {
+                input.signal.removeEventListener('abort', externalAbortHandler);
+            }
             throw new errors_1.ProviderError(`Provider ${this.providerName} returned an empty stream body`, this.providerName);
         }
+        // Response is good; the stream consumer will run for a while. The
+        // controller stays armed (with `externalSignal` still listening) so
+        // that mid-stream aborts cancel reader.read() via fetch's signal.
+        // Listener cleanup happens in the stream-consumer try/finally below.
         const reader = response.body.getReader();
         const decoder = new TextDecoder('utf-8');
         let lineBuffer = '';
@@ -223,10 +251,18 @@ class OllamaPromptToolsAdapter {
         }
         catch (err) {
             clearTimeout(timer);
+            // v4.6 prep — external abort during mid-stream read surfaces as
+            // AbortError; re-throw so AidenAgent routes it as 'interrupted'.
+            if (err instanceof Error && err.name === 'AbortError' && input.signal?.aborted) {
+                throw err;
+            }
             throw new errors_1.ProviderError(`Provider ${this.providerName} stream interrupted: ${err instanceof Error ? err.message : String(err)}`, this.providerName, undefined, err, true);
         }
         finally {
             clearTimeout(timer);
+            if (externalAbortHandler && input.signal) {
+                input.signal.removeEventListener('abort', externalAbortHandler);
+            }
             try {
                 reader.releaseLock();
             }
@@ -422,9 +458,20 @@ class OllamaPromptToolsAdapter {
         const textBefore = firstTagIdx >= 0 ? text.slice(0, firstTagIdx).trim() : text;
         return { textBefore, toolCalls };
     }
-    async fetchWithTimeout(url, headers, body) {
+    async fetchWithTimeout(url, headers, body, externalSignal) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        // v4.6 prep — forward external abort into the internal controller.
+        let externalAbortHandler = null;
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                controller.abort();
+            }
+            else {
+                externalAbortHandler = () => controller.abort();
+                externalSignal.addEventListener('abort', externalAbortHandler, { once: true });
+            }
+        }
         try {
             return await fetch(url, {
                 method: 'POST',
@@ -435,12 +482,20 @@ class OllamaPromptToolsAdapter {
         }
         catch (err) {
             if (err instanceof Error && err.name === 'AbortError') {
+                // v4.6 prep — external abort takes priority over internal timeout.
+                // Surface the raw AbortError so AidenAgent routes it as 'interrupted'.
+                if (externalSignal?.aborted) {
+                    throw err;
+                }
                 throw new errors_1.ProviderTimeoutError(this.providerName, this.timeoutMs);
             }
             throw err;
         }
         finally {
             clearTimeout(timer);
+            if (externalAbortHandler && externalSignal) {
+                externalSignal.removeEventListener('abort', externalAbortHandler);
+            }
         }
     }
     async safeReadText(response) {

package/dist/tools/v4/index.js

@@ -90,6 +90,9 @@ const memoryReplace_1 = require("./memory/memoryReplace");
 const memoryRemove_1 = require("./memory/memoryRemove");
 const sessionSummary_1 = require("./memory/sessionSummary");
 const subagentFanout_1 = require("./subagent/subagentFanout");
+// v4.6 Phase 1 — spawn_sub_agent stub registered alongside the
+// fanout stub so the schema is visible at agent construction.
+const spawnSubAgentTool_1 = require("./subagent/spawnSubAgentTool");
 /**
  * Register every read-only tool into `registry`. The
  * `lookup_tool_schema` tool needs a registry reference, so it's
@@ -152,11 +155,25 @@ function registerReadOnlyTools(registry) {
     // Until then, calling the stub returns a clear "not wired" error
     // rather than crashing.
     register(makeSubagentFanoutStub());
+    // v4.6 Phase 1 — register a stub for spawn_sub_agent. Same
+    // rationale: agent construction at `cli/v4/aidenCLI.ts` snapshots
+    // the tool array, so the schema must be in the registry by then.
+    // The REPL wiring at `buildAgentRuntime` calls
+    // `register(makeSpawnSubAgentTool({...real deps}))` to replace
+    // this stub once `parentAgent`, `runStore`, etc. are available.
+    // The stub carries `contexts: ['repl']` so it's excluded from the
+    // daemon agent's tool catalog via `getSchemas(_, 'daemon')`.
+    register((0, spawnSubAgentTool_1.makeSpawnSubAgentStub)());
 }
 /** Stub used until the runtime wires real provider / adapter / agent
  *  dependencies. Returns the SAME schema as the real tool so MCP and
  *  /tools see a consistent surface. */
 function makeSubagentFanoutStub() {
+    // v4.6 Phase 2R — `runChild` removed from `SubagentFanoutFactoryOptions`.
+    // The stub returns a "no providers configured" error envelope on every
+    // call via `resolveProviders: () => []`. Production wires real
+    // `spawnDeps` post-runtime build (`cli/v4/aidenCLI.ts` for REPL,
+    // `cli/v4/commands/mcp.ts` for MCP serve).
     return (0, subagentFanout_1.makeSubagentFanoutTool)({
         resolveProviders: () => [],
         resolveActiveModel: () => ({ providerId: 'unset', modelId: 'unset' }),
@@ -167,9 +184,6 @@ function makeSubagentFanoutStub() {
                     'Call register(makeSubagentFanoutTool({...})) after buildAgentRuntime.');
             },
         },
-        runChild: async () => {
-            throw new Error('subagent_fanout: tool not wired — runtime did not replace the stub.');
-        },
     });
 }
 /**

package/dist/tools/v4/skills/lookupToolSchema.js

@@ -64,7 +64,12 @@ function makeLookupToolSchema(registry) {
                 category: handler.category,
                 mutates: handler.mutates,
                 toolset: handler.toolset,
-                riskTier: 'safe', // v4.4 Phase 1
+                // v4.6 Phase 1 — read the queried tool's actual risk tier
+                // (was previously hardcoded to 'safe' regardless of the tool,
+                // which mis-reported caution/dangerous tools as safe in the
+                // /tools surface). Falls back to 'safe' for tools that never
+                // annotated their tier — matches the registry-level default.
+                riskTier: handler.riskTier ?? 'safe',
             };
         },
     };