@cmetech/otto 1.0.8 → 1.1.0

package/dist/resources/extensions/otto/commands/theme/command.js

@@ -0,0 +1,75 @@
+/**
+ * /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 { getAvailableThemesWithPaths, setTheme } from "@otto/pi-coding-agent";
+const CUSTOM_TYPE = "otto-theme";
+function postToChat(pi, content) {
+    pi.sendMessage({ customType: CUSTOM_TYPE, content, display: true });
+}
+function renderList() {
+    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, name) {
+    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) {
+    pi.registerCommand("theme", {
+        description: "List or switch the active OTTO theme",
+        handler: async (args, ctx) => {
+            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;
+            try {
+                pick = await ctx.ui.select(`Choose theme — ${themes.length} available`, options);
+            }
+            catch (err) {
+                postToChat(pi, `**theme picker error:** ${err.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/dist/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/dist/resources/extensions/otto/index.js

@@ -19,6 +19,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));
 const FLOW_TRIGGERS_DIR = join(_here, "commands", "flow-triggers");
@@ -182,6 +184,10 @@ export default function Otto(pi) {
     registerBuildFlowCommand(pi);
     // ── 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/dist/resources/extensions/subagent/agents.js

@@ -2,33 +2,113 @@
  * Agent discovery and configuration
  */
 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"];
+/**
+ * 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 = {
+    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 function parseConflictsWith(value) {
     if (typeof value !== "string")
         return undefined;
     const conflicts = value.split(",").map((s) => s.trim()).filter(Boolean);
     return conflicts.length > 0 ? conflicts : undefined;
 }
-function parseAgentTools(value) {
+/**
+ * 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 = {
+    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) {
+    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) {
     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) => 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) => Boolean(tool));
+        const deduped = Array.from(new Set(tools));
+        return deduped.length > 0 ? deduped : undefined;
     }
     return undefined;
 }
-function loadAgentsFromDir(dir, source) {
+function loadAgentsFromDir(dir, source, harnessSource) {
     const agents = [];
     if (!fs.existsSync(dir)) {
         return agents;
@@ -68,6 +148,7 @@ function loadAgentsFromDir(dir, source) {
             systemPrompt: body,
             source,
             filePath,
+            harnessSource,
         });
     }
     return agents;
@@ -96,25 +177,96 @@ function findNearestProjectAgentsDir(cwd) {
         currentDir = parentDir;
     }
 }
+/**
+ * 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) {
+    let currentDir = cwd;
+    while (true) {
+        const matches = [];
+        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, scope) {
     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 = [];
+    if (scope !== "project") {
+        for (const [harnessId, { userDir: harnessUserDir }] of Object.entries(HARNESS_AGENT_PATHS)) {
+            harnessUserAgents.push(...loadAgentsFromDir(harnessUserDir, "user", harnessId));
+        }
+    }
+    const harnessProjectAgents = [];
+    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;
+            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();
+    // 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/dist/resources/extensions/subagent/index.js

@@ -17,12 +17,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { StringEnum } from "@otto/pi-ai";
-import { getMarkdownTheme } from "@otto/pi-coding-agent";
+import { 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 { discoverAgents } from "./agents.js";
+import { buildSkillToolStubResponse } from "./skill-tool-stub.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
 import { loadEffectiveGSDPreferences } from "../workflow/preferences.js";
@@ -643,7 +644,13 @@ export default function (pi) {
     pi.on("session_shutdown", async () => {
         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) => {
@@ -652,8 +659,17 @@ export default function (pi) {
                 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");
         },
     });
     pi.registerTool({
@@ -1565,4 +1581,29 @@ export default function (pi) {
             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",
+                        text: buildSkillToolStubResponse({
+                            name: typeof params.name === "string" ? params.name : undefined,
+                        }),
+                    },
+                ],
+                details: {},
+            };
+        },
+    });
 }

package/dist/resources/extensions/subagent/skill-tool-stub.js

@@ -0,0 +1,23 @@
+/**
+ * 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 function buildSkillToolStubResponse(input) {
+    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/dist/seed-defaults.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Conventional skill folders used by other AI coding harnesses. When the
+ * recommended-packages seeding runs and the directory exists on disk, the
+ * path string (with literal `~/` so it stays portable in settings.json) is
+ * appended to `settings.skills` and recorded in `settings.seededSkillPaths`
+ * as a zombie-resurrection guard. Users who remove an entry from
+ * settings.skills will not see it re-added on the next launch.
+ *
+ * Pi.dev's documented convention is for users to add these paths manually to
+ * settings.skills; OTTO seeds them automatically as a quality-of-life default
+ * for users who have these harnesses installed.
+ */
+export declare const HARNESS_SKILL_PATHS: readonly {
+    setting: string;
+    resolved: string;
+}[];
+export interface DefaultPackage {
+    /** Install source as parsed by package-manager (npm:..., git:..., ./...). */
+    source: string;
+    /** Short display name shown in onboarding (without the npm: prefix). */
+    name: string;
+    /** One-line blurb shown as a hint in onboarding's checkbox UI. */
+    description: string;
+    /**
+     * When set, this substring is appended to settings.quietExtensions on first
+     * seed so the package's session_start banner is silenced by default. Tracked
+     * in settings.seededQuietPatterns so a user who removes the pattern from
+     * quietExtensions is not overridden on subsequent launches.
+     *
+     * Use for packages whose maintainers emit unactionable startup chatter
+     * (e.g. pi-notion's `[notion] MCP config found …`).
+     */
+    quietPattern?: string;
+}
+export interface DefaultPackageCategory {
+    /** Stable id stored in settings.json:enabledDefaultCategories (future). */
+    id: string;
+    /** Display label shown in the category multiselect. */
+    label: string;
+    /** One-line description shown as a hint on the category multiselect. */
+    description: string;
+    /** Packages included in this category. May be empty for placeholder personas. */
+    packages: DefaultPackage[];
+}
+export declare const OTTO_DEFAULT_PACKAGE_CATEGORIES: readonly DefaultPackageCategory[];
+/**
+ * Flat, deduplicated list of every default source across all categories. Used
+ * as the back-compat seeding set when no `enabledDefaultPackages` filter is
+ * stored (the flag/env users who never went through the categorical
+ * onboarding). The `Set` dedupes when the same source legitimately appears in
+ * multiple categories (e.g. a productivity tool that's also useful for devs).
+ */
+export declare const OTTO_DEFAULT_PACKAGES: readonly string[];
+/** Categories with at least one package — the only ones worth showing in UI. */
+export declare function getOnboardableCategories(): DefaultPackageCategory[];
+export interface SeedFlags {
+    withDefaults?: boolean;
+    noSeedDefaults?: boolean;
+}
+export declare function shouldSeedDefaults(flags: SeedFlags, settingValue: boolean | undefined, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolves the effective set of sources to seed given the user's enabledDefaultPackages
+ * preference. See the file header for semantics of undefined / [] / [...].
+ */
+export declare function resolveEnabledDefaults(enabled: string[] | undefined, all?: readonly string[]): string[];
+export declare function maybeSeedDefaultPackages(flags: SeedFlags, agentDirPath: string): Promise<void>;