@cmetech/otto 1.0.9 → 1.1.1

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"]);
+	});
+});

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

@@ -0,0 +1,23 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildSkillToolStubResponse } from "../skill-tool-stub.js";
+
+describe("skill tool stub", () => {
+	it("returns a clear message when called with a skill name", () => {
+		const response = buildSkillToolStubResponse({ name: "review-pr" });
+		assert.match(response, /\/skill:review-pr/);
+		assert.match(response, /chat input/i);
+		assert.match(response, /not support/i);
+	});
+
+	it("handles missing name gracefully", () => {
+		const response = buildSkillToolStubResponse({});
+		assert.match(response, /skill/i);
+		assert.match(response, /chat input/i);
+	});
+
+	it("handles a path-like skill name (gsd-*) the same way", () => {
+		const response = buildSkillToolStubResponse({ name: "gsd-code-review" });
+		assert.match(response, /\/skill:gsd-code-review/);
+	});
+});