@cmetech/otto 1.0.8 → 1.1.0

package/src/resources/extensions/otto/commands/release-notes/command.ts

@@ -0,0 +1,141 @@
+/**
+ * /release-notes — browse OTTO's "what's new" history.
+ *
+ * Usage:
+ *   /release-notes               → interactive selector across all versions
+ *   /release-notes <version>     → show that version directly (e.g. 1.0.7 or v1.0.7)
+ *   /release-notes latest        → alias for the newest version
+ *   /release-notes list          → non-interactive index (one line per version)
+ *
+ * UX modelled after Claude Code's /release-notes: a top-level list with a
+ * count badge per entry, then full detail on selection. Output is written
+ * to stdout so it lands in the chat transcript.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@otto/pi-coding-agent";
+import {
+	RELEASE_NOTES,
+	countItems,
+	findReleaseByVersion,
+	getLatestRelease,
+	type ReleaseNote,
+} from "./_data.js";
+
+const USAGE = `Usage:
+  /release-notes               Browse all releases interactively
+  /release-notes <version>     Show a specific release (e.g. 1.0.7)
+  /release-notes latest        Show the newest release
+  /release-notes list          Print a one-line index of every release`;
+
+function formatSelectorLabel(release: ReleaseNote): string {
+	const total = countItems(release);
+	const headline = release.headline ? ` — ${release.headline}` : "";
+	const badge = total === 1 ? "1 item" : `${total} items`;
+	return `v${release.version}  (${release.date}, ${badge})${headline}`;
+}
+
+function renderSection(title: string, items: string[] | undefined): string {
+	if (!items || items.length === 0) return "";
+	const bulleted = items.map((line) => `- ${line}`).join("\n");
+	return `\n### ${title}\n${bulleted}\n`;
+}
+
+function renderRelease(release: ReleaseNote): string {
+	const header = `# OTTO v${release.version} — ${release.date}`;
+	const headline = release.headline ? `\n_${release.headline}_\n` : "";
+	const body = [
+		renderSection("Added", release.added),
+		renderSection("Fixed", release.fixed),
+		renderSection("Changed", release.changed),
+		renderSection("Notes", release.notes),
+	].join("");
+	const tail = `\n---\n${RELEASE_NOTES.length} releases tracked. Use \`/release-notes\` to browse, \`/release-notes <version>\` for any other release.`;
+	return `${header}${headline}${body}${tail}\n`;
+}
+
+function renderIndex(): string {
+	const rows = RELEASE_NOTES.map((r) => {
+		const total = countItems(r);
+		const badge = total === 1 ? "1 item" : `${total} items`;
+		const headline = r.headline ? ` — ${r.headline}` : "";
+		return `- v${r.version}  (${r.date}, ${badge})${headline}`;
+	}).join("\n");
+	return `# OTTO release index\n\n${rows}\n\nView any release with \`/release-notes <version>\`.\n`;
+}
+
+function findByVersionToken(token: string): ReleaseNote | undefined {
+	if (token === "latest") return getLatestRelease();
+	return findReleaseByVersion(token);
+}
+
+const CUSTOM_TYPE = "otto-release-notes";
+
+function postToChat(pi: ExtensionAPI, content: string): void {
+	// Routes through the session's custom-message stream so the content lands
+	// inside a chat response card instead of stdout (which the TUI redraws on
+	// top of, producing the interleaved-text bug from the first cut).
+	pi.sendMessage({ customType: CUSTOM_TYPE, content, display: true });
+}
+
+export function registerReleaseNotesCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("release-notes", {
+		description: "Browse OTTO release notes — what's new, fixed, and changed",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const trimmed = args.trim();
+
+			// ── Direct version / latest ──────────────────────────────────
+			if (trimmed && trimmed !== "list") {
+				const match = findByVersionToken(trimmed);
+				if (!match) {
+					postToChat(
+						pi,
+						`**No release found for \`${trimmed}\`**\n\nKnown versions: ${RELEASE_NOTES.map((r) => `v${r.version}`).join(", ")}`,
+					);
+					return;
+				}
+				postToChat(pi, renderRelease(match));
+				return;
+			}
+
+			// ── Index dump ───────────────────────────────────────────────
+			if (trimmed === "list") {
+				postToChat(pi, renderIndex());
+				return;
+			}
+
+			// ── Interactive selector ─────────────────────────────────────
+			if (!ctx.hasUI || typeof ctx.ui?.select !== "function") {
+				// Headless / piped: print to stdout (no TUI to corrupt) so the
+				// content is still recoverable in scripted / mcp / rpc modes.
+				process.stdout.write(renderRelease(getLatestRelease()));
+				process.stdout.write("\n" + renderIndex());
+				return;
+			}
+
+			const options = RELEASE_NOTES.map(formatSelectorLabel);
+			let pick: string | string[] | undefined;
+			try {
+				pick = await ctx.ui.select(
+					`OTTO release notes — ${RELEASE_NOTES.length} versions available`,
+					options,
+				);
+			} catch (err) {
+				postToChat(
+					pi,
+					`**release-notes error:** ${(err as Error).message}\n\n${USAGE}`,
+				);
+				return;
+			}
+
+			if (!pick) return; // user cancelled — nothing to do
+			const picked = Array.isArray(pick) ? pick[0] : pick;
+			const index = options.indexOf(picked);
+			const release = index >= 0 ? RELEASE_NOTES[index] : undefined;
+			if (!release) {
+				postToChat(pi, `**No match for** \`${picked}\``);
+				return;
+			}
+			postToChat(pi, renderRelease(release));
+		},
+	});
+}

package/src/resources/extensions/otto/commands/theme/command.ts

@@ -0,0 +1,89 @@
+/**
+ * /theme — list and switch the active OTTO theme at runtime.
+ *
+ * Usage:
+ *   /theme               → interactive picker over built-ins + ~/.otto/agent/themes/*.json
+ *   /theme <name>        → switch directly (e.g. /theme cool-mint)
+ *   /theme list          → print a one-line list of available themes
+ *
+ * Switch is for the current session. To persist across launches, also set
+ * `"theme": "<name>"` in ~/.otto/agent/settings.json.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@otto/pi-coding-agent";
+import { getAvailableThemesWithPaths, setTheme } from "@otto/pi-coding-agent";
+
+const CUSTOM_TYPE = "otto-theme";
+
+function postToChat(pi: ExtensionAPI, content: string): void {
+	pi.sendMessage({ customType: CUSTOM_TYPE, content, display: true });
+}
+
+function renderList(): string {
+	const themes = getAvailableThemesWithPaths();
+	const lines = themes.map((t) => {
+		const origin = t.path ? ` _(${t.path})_` : " _(built-in)_";
+		return `- \`${t.name}\`${origin}`;
+	});
+	return `**Available themes (${themes.length})**\n\n${lines.join("\n")}\n\nUse \`/theme <name>\` to switch. Persist with \`"theme": "<name>"\` in \`~/.otto/agent/settings.json\`.`;
+}
+
+function applyTheme(pi: ExtensionAPI, name: string): void {
+	const result = setTheme(name);
+	if (result.success) {
+		postToChat(
+			pi,
+			`**Theme switched to \`${name}\`** for this session.\n\nTo persist, set \`"theme": "${name}"\` in \`~/.otto/agent/settings.json\`.`,
+		);
+	} else {
+		const available = getAvailableThemesWithPaths().map((t) => t.name).join(", ");
+		postToChat(
+			pi,
+			`**Theme switch failed:** ${result.error ?? "unknown error"}\n\nAvailable: ${available}`,
+		);
+	}
+}
+
+export function registerThemeCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("theme", {
+		description: "List or switch the active OTTO theme",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const trimmed = args.trim();
+
+			if (trimmed === "list") {
+				postToChat(pi, renderList());
+				return;
+			}
+
+			if (trimmed) {
+				applyTheme(pi, trimmed);
+				return;
+			}
+
+			// Interactive picker
+			if (!ctx.hasUI || typeof ctx.ui?.select !== "function") {
+				postToChat(pi, renderList());
+				return;
+			}
+
+			const themes = getAvailableThemesWithPaths();
+			const options = themes.map((t) => (t.path ? `${t.name}  (custom)` : `${t.name}  (built-in)`));
+			let pick: string | string[] | undefined;
+			try {
+				pick = await ctx.ui.select(`Choose theme — ${themes.length} available`, options);
+			} catch (err) {
+				postToChat(pi, `**theme picker error:** ${(err as Error).message}`);
+				return;
+			}
+			if (!pick) return;
+			const picked = Array.isArray(pick) ? pick[0] : pick;
+			const index = options.indexOf(picked);
+			const chosen = index >= 0 ? themes[index] : undefined;
+			if (!chosen) {
+				postToChat(pi, `**No match for** \`${picked}\``);
+				return;
+			}
+			applyTheme(pi, chosen.name);
+		},
+	});
+}

package/src/resources/extensions/otto/extension-manifest.json

@@ -16,6 +16,6 @@
       "otto__import_flow",
       "otto__smoke_test_flow"
     ],
-    "commands": ["langflow", "build-flow", "prompt-engineer"]
+    "commands": ["langflow", "build-flow", "prompt-engineer", "release-notes"]
   }
 }

package/src/resources/extensions/otto/index.ts

@@ -22,6 +22,8 @@ import { registerOttoTools } from "./tools/_loader.js";
 import { executeLangFlowTool } from "./tools/langflow.js";
 import { registerBuildFlowCommand } from "./commands/build-flow/command.js";
 import { registerPromptEngineerCommand } from "./commands/prompt-engineer/command.js";
+import { registerReleaseNotesCommand } from "./commands/release-notes/command.js";
+import { registerThemeCommand } from "./commands/theme/command.js";
 import { parseLangFlowNaturalLanguage } from "./commands/langflow/natural-language.js";
 
 const _here = dirname(fileURLToPath(import.meta.url));
@@ -186,6 +188,12 @@ export default function Otto(pi: ExtensionAPI): void {
   // ── Register /otto prompt-engineer slash command (Phase 5) ──
   registerPromptEngineerCommand(pi);
 
+  // ── Register /release-notes slash command ──
+  registerReleaseNotesCommand(pi);
+
+  // ── Register /theme slash command ──
+  registerThemeCommand(pi);
+
   // ── Load and register flow-trigger slash commands ──
   // Fire-and-forget. Pi's command registry is dynamic; late registrations work.
   loadFlowTriggers(FLOW_TRIGGERS_DIR)

package/src/resources/extensions/subagent/agents.ts

@@ -3,11 +3,53 @@
  */
 
 import * as fs from "node:fs";
+import { homedir } from "node:os";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@otto/pi-coding-agent";
 
 const PROJECT_AGENT_DIR_CANDIDATES = [".otto/workflow", ".pi"] as const;
 
+/**
+ * Conventional agent folders used by other AI coding harnesses, mirroring the
+ * harness skill-paths support in pi-coding-agent's skills.ts. Each entry maps
+ * a harness id (used as a discriminator in logs and the agent's `source`
+ * label) to its user-scope and project-scope conventional paths.
+ *
+ * When a Claude-style skill delegates to a subagent (`subagent_type: foo` /
+ * `Task` tool call), OTTO's subagent tool resolves `foo` against everything
+ * `discoverAgents` returns. Including these harness paths is what lets a
+ * skill imported from `~/.claude/skills` find its companion agent in
+ * `~/.claude/agents` rather than failing with "unknown agent."
+ *
+ * Caveats — independent of discovery — that may affect runtime success:
+ *   - Claude agents commonly declare `tools: [Bash, Read, ...]` (capitalized).
+ *     OTTO's tool names tend to be lowercase. If an agent's allowlist is
+ *     enforced strictly by the harness it was written for, capitalized
+ *     entries won't match OTTO's tool registry. Agents without a `tools`
+ *     field (no restriction) work without issue.
+ *   - Agent body prompts may reference harness-specific features
+ *     (Claude's `/compact`, MCP server names hardcoded for `claude_desktop`,
+ *     `~/.claude/...` paths). The agent still runs; those references may
+ *     just be ineffective.
+ */
+const HARNESS_AGENT_PATHS: Record<
+	string,
+	{ userDir: string; projectSubdir: string }
+> = {
+	claude: {
+		userDir: path.join(homedir(), ".claude", "agents"),
+		projectSubdir: path.join(".claude", "agents"),
+	},
+	codex: {
+		userDir: path.join(homedir(), ".codex", "agents"),
+		projectSubdir: path.join(".codex", "agents"),
+	},
+	kiro: {
+		userDir: path.join(homedir(), ".kiro", "agents"),
+		projectSubdir: path.join(".kiro", "agents"),
+	},
+};
+
 export type AgentScope = "user" | "project" | "both";
 
 export interface AgentConfig {
@@ -19,6 +61,9 @@ export interface AgentConfig {
 	systemPrompt: string;
 	source: "user" | "project";
 	filePath: string;
+	/** Harness id (e.g. "claude", "codex", "kiro") when discovered under a known
+	 * harness agent folder. Surfaced as a glanceable chip in `/subagent`. */
+	harnessSource?: string;
 }
 
 export interface AgentDiscoveryResult {
@@ -40,27 +85,72 @@ export function parseConflictsWith(value: string | undefined): string[] | undefi
 	return conflicts.length > 0 ? conflicts : undefined;
 }
 
-function parseAgentTools(value: string | string[] | undefined): string[] | undefined {
+/**
+ * Maps capitalized tool names used by other AI coding harnesses (Claude, Codex,
+ * Kiro) to OTTO's lowercase tool-registry names. Applied at agent-load time so
+ * an agent imported from ~/.claude/agents/ with `tools: [Bash, Read]` ends up
+ * with `tools: ["bash", "read"]` and actually has access to those tools.
+ *
+ * Tools without an explicit mapping fall through to .toLowerCase() — that's
+ * enough for any name that's already aligned with OTTO's case-insensitive
+ * convention. Tool names with no OTTO equivalent (TodoWrite, SlashCommand,
+ * NotebookEdit) are kept (lowercased) and silently ignored by the runtime
+ * allowlist check — so they don't block the rest of the agent's toolset.
+ *
+ * MCP tool patterns (mcp__server__name, mcp__server__*) are preserved
+ * verbatim — they're already case-sensitive identifiers, and MCP servers
+ * register their own tools at runtime.
+ */
+const HARNESS_TOOL_NAME_MAP: Record<string, string> = {
+	Bash: "bash",
+	Read: "read",
+	Write: "write",
+	Edit: "edit",
+	Glob: "glob",
+	Grep: "grep",
+	AskUserQuestion: "ask_user_questions",
+	Agent: "subagent",
+	Task: "subagent",
+	WebSearch: "web_search",
+	WebFetch: "fetch_page",
+	Skill: "skill",
+};
+
+function normalizeHarnessToolName(raw: string): string | null {
+	const trimmed = raw.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("mcp__")) return trimmed;
+	if (HARNESS_TOOL_NAME_MAP[trimmed]) return HARNESS_TOOL_NAME_MAP[trimmed];
+	return trimmed.toLowerCase();
+}
+
+export function parseAgentTools(value: string | string[] | undefined): string[] | undefined {
 	if (typeof value === "string") {
 		const tools = value
 			.split(",")
-			.map((tool) => tool.trim())
-			.filter(Boolean);
-		return tools.length > 0 ? tools : undefined;
+			.map((tool) => normalizeHarnessToolName(tool))
+			.filter((tool): tool is string => Boolean(tool));
+		const deduped = Array.from(new Set(tools));
+		return deduped.length > 0 ? deduped : undefined;
 	}
 
 	if (Array.isArray(value)) {
 		const tools = value
 			.flatMap((tool) => typeof tool === "string" ? tool.split(",") : [])
-			.map((tool) => tool.trim())
-			.filter(Boolean);
-		return tools.length > 0 ? tools : undefined;
+			.map((tool) => normalizeHarnessToolName(tool))
+			.filter((tool): tool is string => Boolean(tool));
+		const deduped = Array.from(new Set(tools));
+		return deduped.length > 0 ? deduped : undefined;
 	}
 
 	return undefined;
 }
 
-function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
+function loadAgentsFromDir(
+	dir: string,
+	source: "user" | "project",
+	harnessSource?: string,
+): AgentConfig[] {
 	const agents: AgentConfig[] = [];
 
 	if (!fs.existsSync(dir)) {
@@ -104,6 +194,7 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			systemPrompt: body,
 			source,
 			filePath,
+			harnessSource,
 		});
 	}
 
@@ -134,22 +225,89 @@ function findNearestProjectAgentsDir(cwd: string): string | null {
 	}
 }
 
+/**
+ * Walk up from cwd looking for harness project agent dirs (e.g. `.claude/agents`).
+ * Returns ALL matching dirs found at the first ancestor that has at least one,
+ * so a project root with both `.claude/agents` and `.codex/agents` surfaces
+ * both. Stops at the first ancestor with any matches to avoid pulling in
+ * stale agents from outer directories.
+ */
+function findNearestHarnessProjectAgentsDirs(cwd: string): string[] {
+	let currentDir = cwd;
+	while (true) {
+		const matches: string[] = [];
+		for (const { projectSubdir } of Object.values(HARNESS_AGENT_PATHS)) {
+			const candidate = path.join(currentDir, projectSubdir);
+			if (isDirectory(candidate)) matches.push(candidate);
+		}
+		if (matches.length > 0) return matches;
+
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) return [];
+		currentDir = parentDir;
+	}
+}
+
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
 	const userDir = path.join(getAgentDir(), "agents");
 	const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+	const harnessProjectAgentsDirs = findNearestHarnessProjectAgentsDirs(cwd);
 
 	const userAgents = scope === "project" ? [] : loadAgentsFromDir(userDir, "user");
 	const projectAgents = scope === "user" || !projectAgentsDir ? [] : loadAgentsFromDir(projectAgentsDir, "project");
 
+	// Harness agents — user scope: ~/.claude/agents, ~/.codex/agents, ~/.kiro/agents.
+	// Harness agents — project scope: nearest .claude/agents etc. up the cwd tree.
+	// Both go into the same scope buckets as OTTO's own agents; collisions are
+	// resolved by the existing Map-write-wins order below (project wins user).
+	const harnessUserAgents: AgentConfig[] = [];
+	if (scope !== "project") {
+		for (const [harnessId, { userDir: harnessUserDir }] of Object.entries(HARNESS_AGENT_PATHS)) {
+			harnessUserAgents.push(...loadAgentsFromDir(harnessUserDir, "user", harnessId));
+		}
+	}
+	const harnessProjectAgents: AgentConfig[] = [];
+	if (scope !== "user") {
+		// Map each discovered project dir back to its harness id by suffix match
+		// (e.g. ".../.claude/agents" → "claude"). The id surfaces in /subagent as
+		// a glanceable chip.
+		for (const dir of harnessProjectAgentsDirs) {
+			let harnessId: string | undefined;
+			for (const [id, { projectSubdir }] of Object.entries(HARNESS_AGENT_PATHS)) {
+				if (dir.endsWith(projectSubdir)) {
+					harnessId = id;
+					break;
+				}
+			}
+			harnessProjectAgents.push(...loadAgentsFromDir(dir, "project", harnessId));
+		}
+	}
+
 	const agentMap = new Map<string, AgentConfig>();
 
+	// Order: OTTO user → harness user → OTTO project → harness project.
+	// Later writes win on name collision, so OTTO's own agents take precedence
+	// at each scope, and project always overrides user. Same precedence as the
+	// existing logic, just with harness sources slotted in beneath.
 	if (scope === "both") {
 		for (const agent of userAgents) agentMap.set(agent.name, agent);
+		for (const agent of harnessUserAgents) {
+			if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
+		}
 		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+		for (const agent of harnessProjectAgents) {
+			if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
+		}
 	} else if (scope === "user") {
 		for (const agent of userAgents) agentMap.set(agent.name, agent);
+		for (const agent of harnessUserAgents) {
+			if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
+		}
 	} else {
 		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+		for (const agent of harnessProjectAgents) {
+			if (!agentMap.has(agent.name)) agentMap.set(agent.name, agent);
+		}
 	}
 
 	return { agents: Array.from(agentMap.values()), projectAgentsDir };

package/src/resources/extensions/subagent/index.ts

@@ -20,12 +20,13 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@otto/pi-agent-core";
 import type { Message } from "@otto/pi-ai";
 import { StringEnum } from "@otto/pi-ai";
-import { type ExtensionAPI, getMarkdownTheme } from "@otto/pi-coding-agent";
+import { type ExtensionAPI, getMarkdownTheme, getSelectListTheme } from "@otto/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@otto/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { formatTokenCount } from "../shared/mod.js";
 import { getCurrentPhase } from "../shared/phase-state.js";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
+import { buildSkillToolStubResponse } from "./skill-tool-stub.js";
 import {
 	type IsolationEnvironment,
 	type IsolationMode,
@@ -798,7 +799,13 @@ export default function (pi: ExtensionAPI) {
 		await stopLiveSubagents();
 	});
 
-	// /subagent command - list available agents
+	// /subagent command - list available agents.
+	// Renders each row with embedded ANSI styling so the message bypasses the
+	// notify renderer's "dim everything" fallback (see hasAnsiStyling check in
+	// pi-coding-agent's renderExtensionNotifyInChat). Agent name renders in the
+	// terminal's default foreground (white-ish), source/model in the muted
+	// description tint, and the harness origin — when detected — as an accent
+	// chip matching the /skills autocomplete style.
 	pi.registerCommand("subagent", {
 		description: "List available subagents",
 		handler: async (_args, ctx) => {
@@ -807,10 +814,17 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.notify("No agents found. Add .md files to ~/.otto/agent/agents/ or .otto/workflow/agents/", "warning");
 				return;
 			}
-			const lines = discovery.agents.map(
-				(a) => `  ${a.name} [${a.source}]${a.model ? ` (${a.model})` : ""}: ${a.description}`,
-			);
-			ctx.ui.notify(`Available agents (${discovery.agents.length}):\n${lines.join("\n")}`, "info");
+			const slt = getSelectListTheme();
+			const tag = slt.tag ?? slt.selectedText;
+			const dim = slt.description;
+			const lines = discovery.agents.map((a) => {
+				const chip = a.harnessSource ? `${tag(`[${a.harnessSource}]`)} ` : "";
+				const meta = dim(`[${a.source}]${a.model ? ` (${a.model})` : ""}`);
+				const desc = dim(`: ${a.description}`);
+				return `  ${chip}${a.name} ${meta}${desc}`;
+			});
+			const header = dim(`Available agents (${discovery.agents.length}):`);
+			ctx.ui.notify(`${header}\n${lines.join("\n")}`, "info");
 		},
 	});
 
@@ -1935,4 +1949,30 @@ export default function (pi: ExtensionAPI) {
 			return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
 		},
 	});
+
+	pi.registerTool({
+		name: "skill",
+		label: "Skill (stub)",
+		description: [
+			"Stub for the Claude-style `Skill` tool used by some imported skills.",
+			"OTTO does not support invoking skills as a tool — users invoke skills via /skill:<name> from the chat input.",
+			"Returns a clear message redirecting the model to use the skill content inline.",
+		].join(" "),
+		parameters: Type.Object({
+			name: Type.Optional(Type.String({ description: "Name of the skill the model wanted to invoke." })),
+		}),
+		async execute(_toolCallId, params) {
+			return {
+				content: [
+					{
+						type: "text" as const,
+						text: buildSkillToolStubResponse({
+							name: typeof params.name === "string" ? params.name : undefined,
+						}),
+					},
+				],
+				details: {},
+			};
+		},
+	});
 }

package/src/resources/extensions/subagent/skill-tool-stub.ts

@@ -0,0 +1,28 @@
+/**
+ * Stub for the `skill` tool that Claude-style skills sometimes invoke
+ * (`Skill(name="foo")` in the skill body) to chain into another skill.
+ *
+ * OTTO does not support model-invoked skill execution — skills are user-
+ * initiated via `/skill:<name>` from the chat input. Rather than have those
+ * tool calls fail with "no such tool," we register a stub that returns a
+ * clear, actionable message. The model sees the response and can either
+ * fall back to acting on the skill content itself or surface the message
+ * to the user.
+ *
+ * Registered in src/resources/extensions/subagent/index.ts.
+ */
+
+export interface SkillToolStubInput {
+	name?: string;
+}
+
+export function buildSkillToolStubResponse(input: SkillToolStubInput): string {
+	const skillRef = typeof input.name === "string" && input.name.trim().length > 0
+		? `/skill:${input.name.trim()}`
+		: "the desired /skill:<name>";
+	return [
+		"OTTO does not support invoking skills as a tool from inside an agent turn.",
+		`To use this skill, ask the user to run \`${skillRef}\` from the chat input — that's how OTTO surfaces skills.`,
+		"If you have access to the skill's body (it was loaded as a system prompt), follow its instructions inline instead.",
+	].join("\n\n");
+}

package/src/resources/extensions/subagent/tests/parse-agent-tools.test.ts

@@ -0,0 +1,52 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseAgentTools } from "../agents.js";
+
+describe("parseAgentTools", () => {
+	it("lowercases standard Claude tool names", () => {
+		const result = parseAgentTools("Bash, Read, Write, Edit, Glob, Grep");
+		assert.deepEqual(result, ["bash", "read", "write", "edit", "glob", "grep"]);
+	});
+
+	it("maps Claude-specific tool names to OTTO equivalents (with dedup)", () => {
+		const result = parseAgentTools("AskUserQuestion, Agent, Task, WebSearch, WebFetch, Skill");
+		assert.deepEqual(result, [
+			"ask_user_questions",
+			"subagent",
+			"web_search",
+			"fetch_page",
+			"skill",
+		]);
+	});
+
+	it("keeps unknown tools as lowercase (runtime silently drops them)", () => {
+		const result = parseAgentTools("Bash, TodoWrite, SlashCommand, NotebookEdit");
+		assert.deepEqual(result, ["bash", "todowrite", "slashcommand", "notebookedit"]);
+	});
+
+	it("preserves MCP tool names verbatim (already lowercase, server-scoped)", () => {
+		const result = parseAgentTools("Bash, mcp__context7__*, mcp__exa__*");
+		assert.deepEqual(result, ["bash", "mcp__context7__*", "mcp__exa__*"]);
+	});
+
+	it("accepts an array as well as a comma-string", () => {
+		const result = parseAgentTools(["Bash", "Read", "Glob"]);
+		assert.deepEqual(result, ["bash", "read", "glob"]);
+	});
+
+	it("returns undefined for empty input", () => {
+		assert.equal(parseAgentTools(undefined), undefined);
+		assert.equal(parseAgentTools(""), undefined);
+		assert.equal(parseAgentTools([]), undefined);
+	});
+
+	it("trims whitespace and filters blank entries", () => {
+		const result = parseAgentTools("  Bash , , Read  ,  ");
+		assert.deepEqual(result, ["bash", "read"]);
+	});
+
+	it("dedupes after normalization (Task and Agent both map to subagent)", () => {
+		const result = parseAgentTools("Task, Agent, subagent");
+		assert.deepEqual(result, ["subagent"]);
+	});
+});