@cmetech/otto 1.0.9 → 1.1.1

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-0d13c40fc565ba9c
+48d229fb6702d2a2

package/dist/resources/extensions/otto/commands/release-notes/_data.js

@@ -4,6 +4,33 @@
 // To add or correct release notes, edit CHANGELOG.md and rebuild. Editing this
 // file directly will be clobbered on the next build.
 export const RELEASE_NOTES = [
+    {
+        version: '1.1.1',
+        date: '2026-05-29',
+        headline: 'Windows `otto update` no longer emits EPERM cleanup warnings or leaves orphan `.otto-*` staging dirs.',
+        added: [
+            '`update-status.json` written to `~/.otto/agent/` on every `otto update` — tracks `startedAt`, `completedAt`, `fromVersion`, `toVersion`, and `exitCode`. The next `otto update` prints "Last update: vX.Y.Z → vA.B.C at … (✓ success / ✗ exit N)" before checking the registry, so you can see whether a previous background update finished.',
+        ],
+        fixed: [
+            '`otto update` on Windows would log `EPERM: operation not permitted, unlink` warnings against `duckdb.dll`, `sharp.dll`, and `otto_engine.win32-x64.node` because the running otto.exe still held DLL handles. The install still succeeded but left orphan `.otto-RouGtD54`-style staging directories under `%APPDATA%\\npm\\node_modules\\@cmetech\\`. `otto update` now spawns a detached PowerShell bootstrap in a visible "OTTO Updater" console window that waits for the parent otto.exe to exit (max 30s), runs the install with locks released, sweeps the orphan staging dirs, and writes a completion status to `~/.otto/agent/update-status.json` that the next `otto update` surfaces. macOS / Linux behavior unchanged — POSIX inode semantics handle live-process replacement without the lock issue.',
+        ],
+    },
+    {
+        version: '1.1.0',
+        date: '2026-05-29',
+        headline: 'Harness compatibility (Claude / Codex / Kiro skills + agents), [claude] origin chips, and a `/theme` slash command.',
+        added: [
+            'Harness skill paths (`~/.claude/skills`, `~/.codex/skills`, `~/.kiro/skills`) are now auto-seeded into `settings.skills` on launch — but only if the directory actually exists on disk. Skills loaded from those paths follow pi.dev\'s documented convention. A new `settings.seededSkillPaths` zombie-guard records every path attempted, so removing an entry from `settings.skills` keeps it removed across launches.',
+            'Skill origin is now visible in the slash-command autocomplete. Skills loaded from a known harness folder (`~/.claude/skills`, `~/.codex/skills`, `~/.kiro/skills`) carry `source: "harness:<id>"`. The dropdown shows a colored chip — e.g. `[claude] skill:review-pr  Review a pull request (claude)` — so the origin is glanceable. Implementation: new `HARNESS_SOURCE_PATHS` in `skills.ts`, new optional `tag` field on `AutocompleteItem` + `SelectItem`, new `SelectListTheme.tag` color hook.',
+            'Harness agent discovery. OTTO\'s `subagent` tool now also resolves agent names against `~/.claude/agents/`, `~/.codex/agents/`, `~/.kiro/agents/` (user scope) and the nearest `.claude/agents/`, `.codex/agents/`, `.kiro/agents/` (project scope). A Claude skill that delegates to a companion agent now finds it without manual setup. Collision rule: OTTO\'s own agents win at each scope; project always wins over user.',
+            'Tool-name normalization for harness-imported agents. Capitalized Claude/Codex/Kiro tool names in an agent\'s `tools:` frontmatter are rewritten to OTTO\'s lowercase registry names at load time — `Bash` → `bash`, `Read` → `read`, `AskUserQuestion` → `ask_user_questions`, `Task`/`Agent` → `subagent`, `WebSearch` → `web_search`, `WebFetch` → `fetch_page`, `Skill` → the stub below. Unknown names flow through as lowercase and the runtime allowlist silently drops them, so a single unknown entry no longer blocks the rest of the agent\'s toolset. MCP names (`mcp__server__*`) are preserved verbatim.',
+            'Stub `skill` tool for imported Claude skills that call `Skill(name=...)`. OTTO doesn\'t support model-invoked skill execution; the stub returns a friendly message redirecting the model to either ask the user to run `/skill:<name>` from chat input or to act on the skill content inline.',
+            '`/subagent` listing now renders each row with embedded ANSI styling: white agent name, dim source/model metadata, dim description, and an accent `[claude]/[codex]/[kiro]` chip when the agent was discovered under a harness path. Matches the `/skills` autocomplete chip style. `AgentConfig` gains an optional `harnessSource` field.',
+            'New `/theme` slash command — `/theme` opens an interactive picker over built-in themes (`otto`, `dark`, `light`, `tui-classic`, `vivid`) plus any `*.json` you drop in `~/.otto/agent/themes/`. `/theme <name>` switches directly. `/theme list` prints a non-interactive index. Switch is session-only; set `"theme": "<name>"` in `~/.otto/agent/settings.json` to persist.',
+            'New `docs/HARNESS-COMPAT.md` — user-facing matrix of what\'s automatically translated when importing skills/agents from Claude/Codex/Kiro, what doesn\'t translate, and how to test.',
+            'New `docs/UPSTREAM-SYNC.md` living ledger — fork baseline (gsd-pi @ 1.0.1, import commit `bb6da93`), per-package divergence status, file-level patch log, and the cherry-pick workflow for evaluating future upstream changes. Update this file in the same commit as any new vendored-package edit.',
+        ],
+    },
     {
         version: '1.0.9',
         date: '2026-05-29',

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/index.js

@@ -20,6 +20,7 @@ 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");
@@ -185,6 +186,8 @@ export default function Otto(pi) {
     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

@@ -1,3 +1,19 @@
+/**
+ * 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;

package/dist/seed-defaults.js

@@ -21,7 +21,26 @@
 // settings.seededDefaults. A subsequent `otto remove npm:foo` clears the entry
 // from settings.packages but leaves the seededDefaults marker, so we will NOT
 // re-add it on the next launch.
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * 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 const HARNESS_SKILL_PATHS = [
+    { setting: '~/.claude/skills', resolved: join(homedir(), '.claude', 'skills') },
+    { setting: '~/.codex/skills', resolved: join(homedir(), '.codex', 'skills') },
+    { setting: '~/.kiro/skills', resolved: join(homedir(), '.kiro', 'skills') },
+];
 // Add new personas here. Empty `packages: []` is allowed (the onboarding UI
 // will skip categories with no packages so users aren't shown empty lists).
 export const OTTO_DEFAULT_PACKAGE_CATEGORIES = [
@@ -178,6 +197,12 @@ export async function maybeSeedDefaultPackages(flags, agentDirPath) {
     if (seededChanged) {
         settingsManager.setSeededDefaults(newSeeded);
     }
+    // ── Auto-seed harness skill paths ──────────────────────────────────────────
+    // For each conventional harness skill folder that exists on disk, append the
+    // literal `~/` path to settings.skills. Skipped for paths already present in
+    // settings.skills, and for paths recorded in settings.seededSkillPaths (so a
+    // user who removed an entry is not overridden on subsequent launches).
+    reconcileHarnessSkillPaths(settingsManager);
     // ── Reconcile quietExtensions ──────────────────────────────────────────────
     // Packages can declare a `quietPattern` (e.g. pi-notion). When we seed such a
     // package for the first time, also append its pattern to settings.quietExtensions.
@@ -224,3 +249,46 @@ function collectQuietPatternsForSources(targetSources) {
     }
     return Array.from(patterns);
 }
+/**
+ * Append harness skill paths (~/.claude/skills, ~/.codex/skills, ~/.kiro/skills)
+ * to settings.skills when:
+ *   1. The resolved directory actually exists on disk (no point seeding a
+ *      phantom path for a harness the user doesn't have installed), AND
+ *   2. The path isn't already in settings.skills (idempotent), AND
+ *   3. The path isn't in settings.seededSkillPaths (zombie guard — respect
+ *      a user who removed an entry from settings.skills).
+ *
+ * Records every attempted path in settings.seededSkillPaths regardless of
+ * whether it was added, so the zombie guard converges to the union of
+ * everything we've ever tried.
+ */
+function reconcileHarnessSkillPaths(settingsManager) {
+    const seededBefore = new Set(settingsManager.getSeededSkillPaths());
+    const existing = new Set(settingsManager.getSkillPaths());
+    const newPaths = [...settingsManager.getSkillPaths()];
+    let pathsChanged = false;
+    for (const { setting, resolved } of HARNESS_SKILL_PATHS) {
+        if (!existsSync(resolved))
+            continue;
+        if (seededBefore.has(setting))
+            continue;
+        if (!existing.has(setting)) {
+            newPaths.push(setting);
+            existing.add(setting);
+            pathsChanged = true;
+        }
+    }
+    // seededSkillPaths tracks every path we've attempted in this run, even when
+    // the directory wasn't present — so a user who installs Claude later won't
+    // get the path auto-added (consistent with our other zombie-guard semantics).
+    // If you want the inverse behaviour, remove the entry from seededSkillPaths.
+    const attemptedPaths = HARNESS_SKILL_PATHS
+        .filter(({ resolved }) => existsSync(resolved))
+        .map(({ setting }) => setting);
+    const newSeeded = Array.from(new Set([...seededBefore, ...attemptedPaths]));
+    const seededChanged = newSeeded.length !== seededBefore.size;
+    if (pathsChanged)
+        settingsManager.setSkillPaths(newPaths);
+    if (seededChanged)
+        settingsManager.setSeededSkillPaths(newSeeded);
+}

package/dist/update-cmd.d.ts

@@ -2,5 +2,24 @@ interface RunUpdateOptions {
     agentDir?: string;
     skillsDir?: string;
 }
+/**
+ * Build the PowerShell bootstrap that runs the install in a detached, visible
+ * console window. Exported for tests. The script:
+ *   1. Writes an initial status file at `statusPath`.
+ *   2. Waits up to 30s for the parent otto.exe (parentPid) to exit so its
+ *      DLL handles release.
+ *   3. Runs the install command (`npm install -g …` or `bun add -g …`).
+ *   4. Sweeps any orphan `.otto-*` staging dirs npm left behind.
+ *   5. Updates the status file with completion details.
+ *   6. Prints a clear "Done" message and waits for a keypress.
+ */
+export declare function buildWindowsBootstrapScript(args: {
+    parentPid: number;
+    installCmd: string;
+    statusPath: string;
+    current: string;
+    latest: string;
+    startedAt: string;
+}): string;
 export declare function runUpdate(options?: RunUpdateOptions): Promise<void>;
 export {};