@cmetech/otto 1.0.8 → 1.1.0

package/packages/pi-coding-agent/src/core/package-manager.ts

@@ -807,12 +807,13 @@ export class DefaultPackageManager implements PackageManager {
 		const parsed = this.parseSource(source);
 		const scope: SourceScope = options?.local ? "project" : "user";
 		await this.withProgress("install", source, `Installing ${source}...`, async () => {
+			// Explicit user-initiated install — stream npm/git progress to the terminal.
 			if (parsed.type === "npm") {
-				await this.installNpm(parsed, scope, false);
+				await this.installNpm(parsed, scope, false, true);
 				return;
 			}
 			if (parsed.type === "git") {
-				await this.installGit(parsed, scope);
+				await this.installGit(parsed, scope, true);
 				return;
 			}
 			if (parsed.type === "local") {
@@ -831,7 +832,7 @@ export class DefaultPackageManager implements PackageManager {
 		const scope: SourceScope = options?.local ? "project" : "user";
 		await this.withProgress("remove", source, `Removing ${source}...`, async () => {
 			if (parsed.type === "npm") {
-				await this.uninstallNpm(parsed, scope);
+				await this.uninstallNpm(parsed, scope, true);
 				return;
 			}
 			if (parsed.type === "git") {
@@ -869,15 +870,16 @@ export class DefaultPackageManager implements PackageManager {
 		const parsed = this.parseSource(source);
 		if (parsed.type === "npm") {
 			if (parsed.pinned) return;
+			// Explicit `pi package update` — stream npm progress to terminal.
 			await this.withProgress("update", source, `Updating ${source}...`, async () => {
-				await this.installNpm(parsed, scope, false);
+				await this.installNpm(parsed, scope, false, true);
 			});
 			return;
 		}
 		if (parsed.type === "git") {
 			if (parsed.pinned) return;
 			await this.withProgress("update", source, `Updating ${source}...`, async () => {
-				await this.updateGit(parsed, scope);
+				await this.updateGit(parsed, scope, true);
 			});
 			return;
 		}
@@ -890,54 +892,75 @@ export class DefaultPackageManager implements PackageManager {
 	): Promise<void> {
 		for (const { pkg, scope } of sources) {
 			const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
-			const filter = typeof pkg === "object" ? pkg : undefined;
-			const parsed = this.parseSource(sourceStr);
-			const metadata: PathMetadata = { source: sourceStr, scope, origin: "package" };
-
-			if (parsed.type === "local") {
-				const baseDir = this.getBaseDirForScope(scope);
-				this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
-				continue;
+			try {
+				await this.resolveOnePackageSource(pkg, scope, accumulator, onMissing);
+			} catch (error) {
+				// One bad source (typo, 404, network glitch, unreachable git host)
+				// must not abort startup or block resolution of the remaining
+				// packages. Warn loudly so the user knows, then continue.
+				const message = error instanceof Error ? error.message : String(error);
+				process.stderr.write(
+					`[pi] Skipping package "${sourceStr}" — ${message}. ` +
+						`Run \`pi remove ${sourceStr}\` if you want to drop it permanently.\n`,
+				);
 			}
+		}
+	}
 
-			const installMissing = async (): Promise<boolean> => {
-				if (isOfflineModeEnabled()) {
-					return false;
-				}
-				if (!onMissing) {
-					await this.installParsedSource(parsed, scope);
-					return true;
-				}
-				const action = await onMissing(sourceStr);
-				if (action === "skip") return false;
-				if (action === "error") throw new Error(`Missing source: ${sourceStr}`);
+	private async resolveOnePackageSource(
+		pkg: PackageSource,
+		scope: SourceScope,
+		accumulator: ResourceAccumulator,
+		onMissing?: (source: string) => Promise<MissingSourceAction>,
+	): Promise<void> {
+		const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
+		const filter = typeof pkg === "object" ? pkg : undefined;
+		const parsed = this.parseSource(sourceStr);
+		const metadata: PathMetadata = { source: sourceStr, scope, origin: "package" };
+
+		if (parsed.type === "local") {
+			const baseDir = this.getBaseDirForScope(scope);
+			this.resolveLocalExtensionSource(parsed, accumulator, filter, metadata, baseDir);
+			return;
+		}
+
+		const installMissing = async (): Promise<boolean> => {
+			if (isOfflineModeEnabled()) {
+				return false;
+			}
+			if (!onMissing) {
 				await this.installParsedSource(parsed, scope);
 				return true;
-			};
+			}
+			const action = await onMissing(sourceStr);
+			if (action === "skip") return false;
+			if (action === "error") throw new Error(`Missing source: ${sourceStr}`);
+			await this.installParsedSource(parsed, scope);
+			return true;
+		};
 
-			if (parsed.type === "npm") {
-				const installedPath = this.getNpmInstallPath(parsed, scope);
-				const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
-				if (needsInstall) {
-					const installed = await installMissing();
-					if (!installed) continue;
-				}
-				metadata.baseDir = installedPath;
-				this.collectPackageResources(installedPath, accumulator, filter, metadata);
-				continue;
+		if (parsed.type === "npm") {
+			const installedPath = this.getNpmInstallPath(parsed, scope);
+			const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+			if (needsInstall) {
+				const installed = await installMissing();
+				if (!installed) return;
 			}
+			metadata.baseDir = installedPath;
+			this.collectPackageResources(installedPath, accumulator, filter, metadata);
+			return;
+		}
 
-			if (parsed.type === "git") {
-				const installedPath = this.getGitInstallPath(parsed, scope);
-				if (!existsSync(installedPath)) {
-					const installed = await installMissing();
-					if (!installed) continue;
-				} else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
-					await this.refreshTemporaryGitSource(parsed, sourceStr);
-				}
-				metadata.baseDir = installedPath;
-				this.collectPackageResources(installedPath, accumulator, filter, metadata);
+		if (parsed.type === "git") {
+			const installedPath = this.getGitInstallPath(parsed, scope);
+			if (!existsSync(installedPath)) {
+				const installed = await installMissing();
+				if (!installed) return;
+			} else if (scope === "temporary" && !parsed.pinned && !isOfflineModeEnabled()) {
+				await this.refreshTemporaryGitSource(parsed, sourceStr);
 			}
+			metadata.baseDir = installedPath;
+			this.collectPackageResources(installedPath, accumulator, filter, metadata);
 		}
 	}
 
@@ -1169,21 +1192,34 @@ export class DefaultPackageManager implements PackageManager {
 		return { name, version };
 	}
 
-	private async installNpm(source: NpmSource, scope: SourceScope, temporary: boolean): Promise<void> {
+	private async installNpm(
+		source: NpmSource,
+		scope: SourceScope,
+		temporary: boolean,
+		interactive: boolean = false,
+	): Promise<void> {
 		const installRoot = this.getNpmInstallRoot(scope, temporary);
 		this.ensureNpmProject(installRoot);
-		await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
+		await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot], { interactive });
 	}
 
-	private async uninstallNpm(source: NpmSource, scope: SourceScope): Promise<void> {
+	private async uninstallNpm(
+		source: NpmSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const installRoot = this.getNpmInstallRoot(scope, false);
 		if (!existsSync(installRoot)) {
 			return;
 		}
-		await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
+		await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot], { interactive });
 	}
 
-	private async installGit(source: GitSource, scope: SourceScope): Promise<void> {
+	private async installGit(
+		source: GitSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const targetDir = this.getGitInstallPath(source, scope);
 		if (existsSync(targetDir)) {
 			return;
@@ -1194,40 +1230,44 @@ export class DefaultPackageManager implements PackageManager {
 		}
 		mkdirSync(dirname(targetDir), { recursive: true });
 
-		await this.runCommand("git", ["clone", source.repo, targetDir]);
+		await this.runCommand("git", ["clone", source.repo, targetDir], { interactive });
 		if (source.ref) {
-			await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir });
+			await this.runCommand("git", ["checkout", source.ref], { cwd: targetDir, interactive });
 		}
 		const packageJsonPath = join(targetDir, "package.json");
 		if (existsSync(packageJsonPath)) {
-			await this.runCommand("npm", ["install"], { cwd: targetDir });
+			await this.runCommand("npm", ["install"], { cwd: targetDir, interactive });
 		}
 	}
 
-	private async updateGit(source: GitSource, scope: SourceScope): Promise<void> {
+	private async updateGit(
+		source: GitSource,
+		scope: SourceScope,
+		interactive: boolean = false,
+	): Promise<void> {
 		const targetDir = this.getGitInstallPath(source, scope);
 		if (!existsSync(targetDir)) {
-			await this.installGit(source, scope);
+			await this.installGit(source, scope, interactive);
 			return;
 		}
 
 		// Fetch latest from remote (handles force-push by getting new history)
-		await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
+		await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir, interactive });
 
 		// Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.
 		try {
-			await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
+			await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir, interactive });
 		} catch {
-			await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir }).catch(() => {});
-			await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir });
+			await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir, interactive }).catch(() => {});
+			await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir, interactive });
 		}
 
 		// Clean untracked files (extensions should be pristine)
-		await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
+		await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir, interactive });
 
 		const packageJsonPath = join(targetDir, "package.json");
 		if (existsSync(packageJsonPath)) {
-			await this.runCommand("npm", ["install"], { cwd: targetDir });
+			await this.runCommand("npm", ["install"], { cwd: targetDir, interactive });
 		}
 	}
 
@@ -1819,19 +1859,46 @@ export class DefaultPackageManager implements PackageManager {
 		};
 	}
 
-	private runCommand(command: string, args: string[], options?: { cwd?: string }): Promise<void> {
+	/**
+	 * Run a child process. When `interactive` is true (the explicit user-facing
+	 * install/update path), stdio is inherited so npm/git progress shows in the
+	 * terminal. When false (the default — auto-resolve during launch), stdout
+	 * and stderr are captured. The captured stderr is appended to the failure
+	 * error so callers can surface the underlying cause without polluting the
+	 * TUI during startup.
+	 */
+	private runCommand(
+		command: string,
+		args: string[],
+		options?: { cwd?: string; interactive?: boolean },
+	): Promise<void> {
+		const interactive = options?.interactive === true;
 		return new Promise((resolvePromise, reject) => {
 			const child = spawn(command, args, {
 				cwd: options?.cwd,
-				stdio: "inherit",
+				stdio: interactive ? "inherit" : ["ignore", "pipe", "pipe"],
 				shell: process.platform === "win32",
 			});
+
+			let stderr = "";
+			if (!interactive) {
+				child.stdout?.on("data", () => { /* drop — progress goes through withProgress */ });
+				child.stderr?.on("data", (chunk: Buffer | string) => {
+					stderr += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+					// Cap to avoid unbounded growth on chatty failures.
+					if (stderr.length > 4_000) stderr = stderr.slice(-4_000);
+				});
+			}
+
 			child.on("error", reject);
 			child.on("exit", (code) => {
 				if (code === 0) {
 					resolvePromise();
 				} else {
-					reject(new Error(`${command} ${args.join(" ")} failed with code ${code}`));
+					const detail = !interactive && stderr.trim().length > 0
+						? `: ${stderr.trim().split("\n").slice(-3).join(" ").slice(0, 500)}`
+						: "";
+					reject(new Error(`${command} ${args.join(" ")} failed with code ${code}${detail}`));
 				}
 			});
 		});

package/packages/pi-coding-agent/src/core/resolve-config-value.ts

@@ -24,6 +24,20 @@ export const SAFE_COMMAND_PREFIXES = [
 	"lpass",
 ];
 
+/**
+ * Whether to emit the per-blocked-command stderr warning. Off by default —
+ * extensions (e.g. piolium's anthropic-vertex registration) intentionally
+ * register !sh-style apiKey expressions that will never resolve on most user
+ * machines; the warning is noise. Opt back in by setting OTTO_LOG_BLOCKED_COMMANDS=1
+ * (or any truthy value) when actively debugging credential resolution.
+ */
+function shouldLogBlockedCommands(): boolean {
+	const v = process.env.OTTO_LOG_BLOCKED_COMMANDS;
+	if (!v) return false;
+	const lv = v.toLowerCase();
+	return lv === "1" || lv === "true" || lv === "yes";
+}
+
 /**
  * Active command prefix allowlist. Defaults to SAFE_COMMAND_PREFIXES but can be
  * overridden via setAllowedCommandPrefixes() (called from settings or env var).
@@ -70,13 +84,17 @@ function executeCommand(commandConfig: string): string | undefined {
 	const tokens = command.split(/\s+/).filter(Boolean);
 	const firstToken = tokens[0];
 	if (!activeCommandPrefixes.includes(firstToken)) {
-		process.stderr.write(`[resolve-config-value] Blocked disallowed command: "${firstToken}". Allowed: ${activeCommandPrefixes.join(", ")}\n`);
+		if (shouldLogBlockedCommands()) {
+			process.stderr.write(`[resolve-config-value] Blocked disallowed command: "${firstToken}". Allowed: ${activeCommandPrefixes.join(", ")}\n`);
+		}
 		commandResultCache.set(commandConfig, undefined);
 		return undefined;
 	}
 
 	if (SHELL_OPERATORS.test(command)) {
-		process.stderr.write(`[resolve-config-value] Blocked shell operators in command: "${command}"\n`);
+		if (shouldLogBlockedCommands()) {
+			process.stderr.write(`[resolve-config-value] Blocked shell operators in command: "${command}"\n`);
+		}
 		commandResultCache.set(commandConfig, undefined);
 		return undefined;
 	}

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -220,6 +220,12 @@ export interface Settings {
 	allowedCommandPrefixes?: string[]; // Override built-in SAFE_COMMAND_PREFIXES for !command resolution (global-only — ignored in project settings)
 	fetchAllowedUrls?: string[]; // Hostnames exempted from SSRF blocklist in fetch_page (global-only — ignored in project settings)
 	hooks?: HooksSettings; // Layer 0 shell-command hooks. Project-scoped hooks require explicit trust (.pi/hooks.trusted).
+	seedDefaultsOnLaunch?: boolean; // When true, ship-with-OTTO default packages are added to `packages` on launch
+	seededDefaults?: string[]; // Sources already attempted to seed — prevents re-adding after the user removes one
+	enabledDefaultPackages?: string[]; // Subset of default sources the user opted into during onboarding. undefined = "all" (back-compat)
+	quietExtensions?: string[]; // Substring patterns matched against extension.path — ui.notify calls from matching extensions are silently dropped
+	seededQuietPatterns?: string[]; // Quiet patterns already attempted to seed — zombie-resurrection guard, mirrors seededDefaults
+	seededSkillPaths?: string[]; // Skill paths already attempted to seed (e.g. ~/.claude/skills) — zombie guard for harness skill auto-seeding
 }
 
 /** Settings keys that are only respected from global config — project settings cannot override these. */
@@ -938,6 +944,65 @@ export class SettingsManager {
 		this.setProjectSetting("packages", packages);
 	}
 
+	getSeedDefaultsOnLaunch(): boolean | undefined {
+		return this.settings.seedDefaultsOnLaunch;
+	}
+
+	setSeedDefaultsOnLaunch(enabled: boolean): void {
+		this.setGlobalSetting("seedDefaultsOnLaunch", enabled);
+	}
+
+	getSeededDefaults(): string[] {
+		return [...(this.settings.seededDefaults ?? [])];
+	}
+
+	setSeededDefaults(sources: string[]): void {
+		this.setGlobalSetting("seededDefaults", sources);
+	}
+
+	/**
+	 * Returns undefined when the user has expressed no preference (back-compat:
+	 * the seeder treats this as "install every default"). Returns a (possibly
+	 * empty) array when the user has explicitly chosen a subset.
+	 */
+	getEnabledDefaultPackages(): string[] | undefined {
+		const value = this.settings.enabledDefaultPackages;
+		return value === undefined ? undefined : [...value];
+	}
+
+	setEnabledDefaultPackages(sources: string[]): void {
+		this.setGlobalSetting("enabledDefaultPackages", sources);
+	}
+
+	/**
+	 * Returns substring patterns matched (case-insensitive) against an extension's
+	 * filesystem path. ui.notify calls from matching extensions are silently
+	 * dropped at runtime — useful for muting noisy session_start banners.
+	 */
+	getQuietExtensions(): string[] {
+		return [...(this.settings.quietExtensions ?? [])];
+	}
+
+	setQuietExtensions(patterns: string[]): void {
+		this.setGlobalSetting("quietExtensions", patterns);
+	}
+
+	getSeededQuietPatterns(): string[] {
+		return [...(this.settings.seededQuietPatterns ?? [])];
+	}
+
+	setSeededQuietPatterns(patterns: string[]): void {
+		this.setGlobalSetting("seededQuietPatterns", patterns);
+	}
+
+	getSeededSkillPaths(): string[] {
+		return [...(this.settings.seededSkillPaths ?? [])];
+	}
+
+	setSeededSkillPaths(paths: string[]): void {
+		this.setGlobalSetting("seededSkillPaths", paths);
+	}
+
 	getExtensionPaths(): string[] {
 		return [...(this.settings.extensions ?? [])];
 	}

package/packages/pi-coding-agent/src/core/skills.ts

@@ -25,6 +25,22 @@ export const ECOSYSTEM_PROJECT_SKILLS_DIR = ".agents";
  */
 const LEGACY_SKILLS_DIR = join(homedir(), CONFIG_DIR_NAME, "agent", "skills");
 
+/**
+ * Conventional user-scope skill folders of other AI coding harnesses. Used by
+ * `getSource` to label skills with `harness:<id>` so the TUI can render an
+ * origin tag in the slash-command autocomplete. Adding an entry here makes a
+ * harness's skills self-identify; it does NOT control whether the directory is
+ * scanned (that's still driven by the user's `settings.skills` array — auto-
+ * seeded by `seed-defaults.ts` when the directory exists).
+ *
+ * Fork-specific edit. See docs/UPSTREAM-SYNC.md.
+ */
+export const HARNESS_SOURCE_PATHS: Record<string, string> = {
+	claude: join(homedir(), ".claude", "skills"),
+	codex: join(homedir(), ".codex", "skills"),
+	kiro: join(homedir(), ".kiro", "skills"),
+};
+
 /** Max name length per spec */
 const MAX_NAME_LENGTH = 64;
 
@@ -445,11 +461,17 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
 		return target.startsWith(prefix);
 	};
 
-	const getSource = (resolvedPath: string): "user" | "project" | "path" => {
+	const getSource = (resolvedPath: string): string => {
 		if (!includeDefaults) {
 			if (isUnderPath(resolvedPath, userSkillsDir)) return "user";
 			if (isUnderPath(resolvedPath, projectSkillsDir)) return "project";
 		}
+		// Tag skills that live under a known external-harness folder so the
+		// TUI can render their origin. Checked even when includeDefaults=true
+		// because harness paths are an opt-in third category, not a default.
+		for (const [harnessId, harnessPath] of Object.entries(HARNESS_SOURCE_PATHS)) {
+			if (isUnderPath(resolvedPath, harnessPath)) return `harness:${harnessId}`;
+		}
 		return "path";
 	};
 

package/packages/pi-coding-agent/src/index.ts

@@ -404,14 +404,18 @@ export {
 } from "./modes/interactive/components/index.js";
 // Theme utilities for custom tools and extensions
 export {
+	getAvailableThemes,
+	getAvailableThemesWithPaths,
 	getLanguageFromPath,
 	getMarkdownTheme,
 	getSelectListTheme,
 	getSettingsListTheme,
 	highlightCode,
 	initTheme,
+	setTheme,
 	Theme,
 	type ThemeColor,
+	type ThemeInfo,
 } from "./modes/interactive/theme/theme.js";
 // Clipboard utilities
 export { copyToClipboard } from "./utils/clipboard.js";

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -565,14 +565,25 @@ export class InteractiveMode {
 			getArgumentCompletions: cmd.getArgumentCompletions,
 		}));
 
-		// Build skill commands from session.skills (if enabled)
+		// Build skill commands from session.skills (if enabled).
+		// When a skill's source starts with "harness:" (set by skills.ts:getSource
+		// for skills loaded from ~/.claude/skills, ~/.codex/skills, ~/.kiro/skills
+		// and similar), surface the origin in the autocomplete dropdown — as a
+		// suffix on the description AND as a `tag` for the colored chip
+		// rendered by SelectList (see pi-tui/src/components/select-list.ts).
 		this.skillCommands.clear();
 		const skillCommandList: SlashCommand[] = [];
 		if (this.settingsManager.getEnableSkillCommands()) {
 			for (const skill of this.session.resourceLoader.getSkills().skills) {
 				const commandName = `skill:${skill.name}`;
 				this.skillCommands.set(commandName, skill.filePath);
-				skillCommandList.push({ name: commandName, description: skill.description });
+				const harnessId = skill.source.startsWith("harness:")
+					? skill.source.slice("harness:".length)
+					: undefined;
+				const description = harnessId
+					? `${skill.description} (${harnessId})`
+					: skill.description;
+				skillCommandList.push({ name: commandName, description, tag: harnessId });
 			}
 		}
 

package/packages/pi-coding-agent/src/modes/interactive/theme/theme.ts

@@ -1106,6 +1106,10 @@ export function getSelectListTheme(): SelectListTheme {
 		description: (text: string) => theme.fg("muted", text),
 		scrollInfo: (text: string) => theme.fg("muted", text),
 		noMatch: (text: string) => theme.fg("muted", text),
+		// Origin chip color (e.g. "[claude] " before a skill name). Uses the
+		// accent palette so the chip is glanceable but doesn't compete with
+		// selectedText (the chip is rendered uncolored when its row is selected).
+		tag: (text: string) => theme.fg("accent", text),
 	};
 }