@oh-my-pi/pi-coding-agent 16.1.19 → 16.1.21

package/src/autolearn/controller.ts

@@ -15,9 +15,11 @@ import type { Settings } from "../config/settings";
 import autolearnGuidance from "../prompts/system/autolearn-guidance.md" with { type: "text" };
 import autolearnGuidanceLearn from "../prompts/system/autolearn-guidance-learn.md" with { type: "text" };
 import autolearnNudge from "../prompts/system/autolearn-nudge.md" with { type: "text" };
+import autolearnNudgeAutoContinue from "../prompts/system/autolearn-nudge-autocontinue.md" with { type: "text" };
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 
-const AUTOLEARN_NUDGE = autolearnNudge.trim();
+const AUTOLEARN_NUDGE_PASSIVE = autolearnNudge.trim();
+const AUTOLEARN_NUDGE_AUTOCONTINUE = autolearnNudgeAutoContinue.trim();
 const DEFAULT_MIN_TOOL_CALLS = 5;
 
 /**
@@ -110,7 +112,20 @@ export class AutoLearnController {
 
 		// Auto-run a capture turn only when explicitly enabled; otherwise the
 		// hidden reminder rides the next real turn passively.
+		//
+		// The two paths get DIFFERENT nudge text:
+		// - Auto-continue spawns a synthetic turn with the nudge as its only
+		//   user-role payload, so the prompt must be terminal — it tells the
+		//   agent to capture and STOP, and must not be read as the user's
+		//   reply to any pending question. Without that contract, the agent
+		//   conflates the synthetic prompt with user approval and resumes
+		//   prior work (e.g. commits/pushes an unanswered "want me to push?"
+		//   question — #3504).
+		// - Passive mode appends the nudge to the user's real next message,
+		//   so the agent must answer the user normally and treat the capture
+		//   as additive — not as the whole turn's job.
 		const autoContinue = this.#settings.get("autolearn.autoContinue") === true;
+		const content = autoContinue ? AUTOLEARN_NUDGE_AUTOCONTINUE : AUTOLEARN_NUDGE_PASSIVE;
 		// Arm suppression synchronously: the synthetic capture turn's agent_end
 		// fires inside sendCustomMessage (before it resolves), so the flag must be
 		// set before then. Disarm when no turn actually started — a deferred/queued
@@ -122,7 +137,7 @@ export class AutoLearnController {
 			.sendCustomMessage(
 				{
 					customType: "autolearn-nudge",
-					content: AUTOLEARN_NUDGE,
+					content,
 					display: false,
 					attribution: "user",
 				},

package/src/cli/gallery-cli.ts

@@ -21,13 +21,42 @@ import { captureGalleryScreenshots } from "./gallery-screenshot";
 export const GALLERY_STATES = ["streaming", "progress", "success", "error"] as const;
 export type GalleryState = (typeof GALLERY_STATES)[number];
 
-const STATE_LABELS: Record<GalleryState, string> = {
+/** User-facing labels printed above each rendered lifecycle state. */
+export const GALLERY_STATE_LABELS: Record<GalleryState, string> = {
 	streaming: "streaming args",
 	progress: "in progress",
 	success: "done",
 	error: "failed",
 };
 
+const GALLERY_STATE_ALIASES: Record<string, GalleryState> = {
+	streaming: "streaming",
+	"streaming args": "streaming",
+	progress: "progress",
+	"in progress": "progress",
+	success: "success",
+	done: "success",
+	error: "error",
+	failed: "error",
+};
+
+/** Accepted `--state` tokens, including legacy lifecycle names and displayed labels. */
+export const GALLERY_STATE_TOKENS = Object.keys(GALLERY_STATE_ALIASES);
+
+/** Normalize user-provided `--state` tokens to the internal gallery lifecycle states. */
+export function parseGalleryStates(states: readonly string[] | undefined): GalleryState[] | undefined {
+	if (!states || states.length === 0) return undefined;
+	const parsed: GalleryState[] = [];
+	for (const raw of states) {
+		const state = GALLERY_STATE_ALIASES[raw.trim().toLowerCase()];
+		if (!state) {
+			throw new Error(`Invalid --state '${raw}'. Valid values: ${GALLERY_STATE_TOKENS.join(", ")}`);
+		}
+		if (!parsed.includes(state)) parsed.push(state);
+	}
+	return parsed;
+}
+
 export interface GalleryCommandArgs {
 	/** Render width in columns (defaults to terminal width, clamped). */
 	width?: number;
@@ -166,7 +195,7 @@ async function renderGallerySections(
 		const heading = fixture.label && fixture.label !== name ? `${name} — ${fixture.label}` : name;
 		const lines: string[] = ["", sectionRule(heading, width)];
 		for (const state of states) {
-			lines.push("", theme.fg("dim", `  · ${STATE_LABELS[state]}`));
+			lines.push("", theme.fg("dim", `  · ${GALLERY_STATE_LABELS[state]}`));
 			try {
 				for (const line of await renderGalleryState(name, fixture, state, width, expanded)) lines.push(line);
 			} catch (err) {

package/src/cli/gallery-fixtures/agentic.ts

@@ -263,6 +263,11 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 				],
 			} satisfies IrcDetails,
 		},
+		errorResult: {
+			isError: true,
+			content: [{ type: "text", text: "IRC inbox failed: message store unavailable." }],
+			details: { op: "inbox" } satisfies IrcDetails,
+		},
 	},
 
 	irc_list: {
@@ -309,6 +314,11 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 				],
 			} satisfies IrcDetails,
 		},
+		errorResult: {
+			isError: true,
+			content: [{ type: "text", text: "IRC list failed: agent hub is unavailable." }],
+			details: { op: "list" } satisfies IrcDetails,
+		},
 	},
 
 	goal: {
@@ -388,19 +398,18 @@ export const agenticFixtures: Record<string, GalleryFixture> = {
 		},
 		errorResult: {
 			isError: true,
-			content: [{ type: "text", text: "Job cancelled by user." }],
+			content: [{ type: "text", text: "1 job failed." }],
 			details: {
 				jobs: [
 					{
 						id: "job_d4",
 						type: "task",
-						status: "cancelled",
+						status: "failed",
 						label: "Refactor the session store to Redis",
 						durationMs: 52_300,
-						errorText: "Aborted: superseded by goal re-scope.",
+						errorText: "Subagent exited 1: Redis connection string is missing.",
 					},
 				],
-				cancelled: [{ id: "job_d4", status: "cancelled" }],
 			},
 		},
 	},

package/src/commands/gallery.ts

@@ -2,7 +2,7 @@
  * Render every built-in tool's renderer across its lifecycle states.
  */
 import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
-import { GALLERY_STATES, type GalleryState, runGalleryCommand } from "../cli/gallery-cli";
+import { GALLERY_STATE_TOKENS, type GalleryState, parseGalleryStates, runGalleryCommand } from "../cli/gallery-cli";
 
 export default class Gallery extends Command {
 	static description = "Preview tool renderers across streaming, in-progress, success, and failure states";
@@ -12,7 +12,7 @@ export default class Gallery extends Command {
 		state: Flags.string({
 			char: "s",
 			description: "Render only the given lifecycle state(s)",
-			options: [...GALLERY_STATES],
+			options: GALLERY_STATE_TOKENS,
 			multiple: true,
 		}),
 		width: Flags.integer({ char: "w", description: "Render width in columns" }),
@@ -37,9 +37,17 @@ export default class Gallery extends Command {
 
 	async run(): Promise<void> {
 		const { flags } = await this.parse(Gallery);
+		let states: GalleryState[] | undefined;
+		try {
+			states = parseGalleryStates(flags.state);
+		} catch (err) {
+			process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+			process.exitCode = 1;
+			return;
+		}
 		await runGalleryCommand({
 			tool: flags.tool,
-			states: flags.state as GalleryState[] | undefined,
+			states,
 			width: flags.width,
 			expanded: flags.expanded,
 			plain: flags.plain,

package/src/config/service-tier.ts

@@ -0,0 +1,87 @@
+import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import type { SubmenuOption } from "./settings-schema";
+
+/**
+ * Service-tier setting values shared by every "Service Tier" setting. `"none"`
+ * is the omit-the-parameter sentinel; the remaining values mirror
+ * {@link ServiceTier}.
+ */
+export const SERVICE_TIER_SETTING_VALUES = [
+	"none",
+	"auto",
+	"default",
+	"flex",
+	"scale",
+	"priority",
+	"openai-only",
+	"claude-only",
+] as const;
+
+export type ServiceTierSettingValue = (typeof SERVICE_TIER_SETTING_VALUES)[number];
+
+/** Variant value set for scoped service-tier settings (subagent/advisor) that can defer to the main agent. */
+export const SERVICE_TIER_INHERIT_SETTING_VALUES = ["inherit", ...SERVICE_TIER_SETTING_VALUES] as const;
+
+export type ServiceTierInheritSettingValue = (typeof SERVICE_TIER_INHERIT_SETTING_VALUES)[number];
+
+/** Submenu descriptions shared by the base `serviceTier` setting. */
+export const SERVICE_TIER_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierSettingValue>> = [
+	{ value: "none", label: "None", description: "Omit service_tier parameter" },
+	{ value: "auto", label: "Auto", description: "Use provider default tier selection (OpenAI)" },
+	{ value: "default", label: "Default", description: "Standard priority processing (OpenAI)" },
+	{ value: "flex", label: "Flex", description: "Flexible capacity tier when available (OpenAI)" },
+	{ value: "scale", label: "Scale", description: "Scale Tier credits when available (OpenAI)" },
+	{
+		value: "priority",
+		label: "Priority",
+		description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)",
+	},
+	{
+		value: "openai-only",
+		label: "Priority (OpenAI only)",
+		description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
+	},
+	{
+		value: "claude-only",
+		label: "Priority (Claude only)",
+		description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)",
+	},
+];
+
+/** Submenu descriptions for inherit-capable service-tier settings. */
+export const SERVICE_TIER_INHERIT_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierInheritSettingValue>> = [
+	{ value: "inherit", label: "Inherit", description: "Use the main agent's Service Tier" },
+	...SERVICE_TIER_OPTIONS,
+];
+
+/**
+ * Resolve a service-tier setting value to the wire {@link ServiceTier} (or
+ * `undefined` to omit). `"inherit"` defers to `inherited`; `"none"` omits.
+ */
+export function resolveServiceTierSetting(value: string, inherited: ServiceTier | undefined): ServiceTier | undefined {
+	if (value === "inherit") return inherited;
+	if (value === "none" || value === "") return undefined;
+	return value as ServiceTier;
+}
+
+/**
+ * Resolve the `serviceTier` *setting value* to stamp onto a subagent's settings
+ * snapshot.
+ *
+ * - A concrete `subagentSetting` (`"none"` or a tier) wins outright.
+ * - `"inherit"` defers to the parent's live effective tier when the caller has a
+ *   live session (`inherited` passed as `ServiceTier | null`, where `null` means
+ *   the parent explicitly has no tier — e.g. `/fast off`). When no live session
+ *   is available (`inherited === undefined`, e.g. cold subagent revive) it falls
+ *   back to the parent's configured `serviceTier` setting so behavior matches a
+ *   plain settings snapshot.
+ */
+export function resolveSubagentServiceTier(
+	subagentSetting: string,
+	configuredTier: ServiceTierSettingValue,
+	inherited: ServiceTier | null | undefined,
+): ServiceTierSettingValue {
+	if (subagentSetting !== "inherit") return subagentSetting as ServiceTierSettingValue;
+	if (inherited === undefined) return configuredTier;
+	return inherited ?? "none";
+}

package/src/config/settings-schema.ts

@@ -35,6 +35,12 @@ import {
 } from "../tts/models";
 import { EDIT_MODES } from "../utils/edit-mode";
 import { SEARCH_PROVIDER_OPTIONS, SEARCH_PROVIDER_PREFERENCES, type SearchProviderId } from "../web/search/types";
+import {
+	SERVICE_TIER_INHERIT_OPTIONS,
+	SERVICE_TIER_INHERIT_SETTING_VALUES,
+	SERVICE_TIER_OPTIONS,
+	SERVICE_TIER_SETTING_VALUES,
+} from "./service-tier";
 
 /** Unified settings schema - single source of truth for all settings.
  *
@@ -1122,7 +1128,7 @@ export const SETTINGS_SCHEMA = {
 
 	serviceTier: {
 		type: "enum",
-		values: ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"] as const,
+		values: SERVICE_TIER_SETTING_VALUES,
 		default: "none",
 		ui: {
 			tab: "model",
@@ -1130,28 +1136,36 @@ export const SETTINGS_SCHEMA = {
 			label: "Service Tier",
 			description:
 				'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.',
-			options: [
-				{ value: "none", label: "None", description: "Omit service_tier parameter" },
-				{ value: "auto", label: "Auto", description: "Use provider default tier selection (OpenAI)" },
-				{ value: "default", label: "Default", description: "Standard priority processing (OpenAI)" },
-				{ value: "flex", label: "Flex", description: "Flexible capacity tier when available (OpenAI)" },
-				{ value: "scale", label: "Scale", description: "Scale Tier credits when available (OpenAI)" },
-				{
-					value: "priority",
-					label: "Priority",
-					description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)",
-				},
-				{
-					value: "openai-only",
-					label: "Priority (OpenAI only)",
-					description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere",
-				},
-				{
-					value: "claude-only",
-					label: "Priority (Claude only)",
-					description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)",
-				},
-			],
+			options: SERVICE_TIER_OPTIONS,
+		},
+	},
+
+	serviceTierSubagent: {
+		type: "enum",
+		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
+		default: "inherit",
+		ui: {
+			tab: "model",
+			group: "Sampling",
+			label: "Service Tier - Subagent",
+			description:
+				"Service Tier for spawned task/eval subagents. Inherit = match the main agent's live tier (tracks /fast); pick a value to scope subagents independently.",
+			options: SERVICE_TIER_INHERIT_OPTIONS,
+		},
+	},
+
+	serviceTierAdvisor: {
+		type: "enum",
+		values: SERVICE_TIER_INHERIT_SETTING_VALUES,
+		default: "none",
+		ui: {
+			tab: "model",
+			group: "Sampling",
+			label: "Service Tier - Advisor",
+			description:
+				"Service Tier for the advisor model. None = standard processing; Inherit = match the main agent's live tier; pick a value (e.g. Priority) to run the advisor on a faster serving path.",
+			options: SERVICE_TIER_INHERIT_OPTIONS,
+			condition: "advisorEnabled",
 		},
 	},
 
@@ -4041,6 +4055,17 @@ export const SETTINGS_SCHEMA = {
 	},
 
 	// Provider selection
+	"providers.ollama-cloud.maxConcurrency": {
+		type: "number",
+		default: 3,
+		ui: {
+			tab: "providers",
+			group: "Services",
+			label: "Ollama Cloud Max Concurrency",
+			description:
+				"Maximum concurrent Ollama Cloud subagent runs per process; 0 disables the provider-specific limit",
+		},
+	},
 	"providers.webSearch": {
 		type: "enum",
 		values: SEARCH_PROVIDER_PREFERENCES,

package/src/eval/agent-bridge.ts

@@ -397,6 +397,8 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
 		parentTelemetry: options.session.getTelemetry?.(),
 		parentAgentId: options.session.getAgentId?.() ?? MAIN_AGENT_ID,
+		// Live source of truth for `serviceTierSubagent: inherit` (null = explicit none).
+		parentServiceTier: options.session.getServiceTier ? (options.session.getServiceTier() ?? null) : undefined,
 		// Deliberately omit parentEvalSessionId: the parent's Python kernel is
 		// blocked on this bridge call, so sharing the eval session would deadlock
 		// (subagent queues behind the parent's in-flight execution, parent waits

package/src/extensibility/plugins/legacy-pi-bundled-keys.ts

@@ -360,6 +360,7 @@ export const BUNDLED_PI_REGISTRY_KEYS: ReadonlySet<string> = new Set([
 	"@oh-my-pi/pi-coding-agent/config/models-config",
 	"@oh-my-pi/pi-coding-agent/config/prompt-templates",
 	"@oh-my-pi/pi-coding-agent/config/resolve-config-value",
+	"@oh-my-pi/pi-coding-agent/config/service-tier",
 	"@oh-my-pi/pi-coding-agent/config/settings-schema",
 	"@oh-my-pi/pi-coding-agent/config/settings",
 	"@oh-my-pi/pi-coding-agent/dap/client",
@@ -483,7 +484,6 @@ export const BUNDLED_PI_REGISTRY_KEYS: ReadonlySet<string> = new Set([
 	"@oh-my-pi/pi-coding-agent/eval/js/executor",
 	"@oh-my-pi/pi-coding-agent/eval/js/tool-bridge",
 	"@oh-my-pi/pi-coding-agent/eval/js/worker-core",
-	"@oh-my-pi/pi-coding-agent/eval/js/worker-entry",
 	"@oh-my-pi/pi-coding-agent/eval/js/worker-protocol",
 	"@oh-my-pi/pi-coding-agent/eval/py/display",
 	"@oh-my-pi/pi-coding-agent/eval/py/executor",

package/src/extensibility/plugins/legacy-pi-bundled-registry.ts

@@ -328,6 +328,7 @@ import * as bundledPiCodingAgentConfigModelsConfig from "@oh-my-pi/pi-coding-age
 import * as bundledPiCodingAgentConfigModelsConfigSchema from "@oh-my-pi/pi-coding-agent/config/models-config-schema";
 import * as bundledPiCodingAgentConfigPromptTemplates from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
 import * as bundledPiCodingAgentConfigResolveConfigValue from "@oh-my-pi/pi-coding-agent/config/resolve-config-value";
+import * as bundledPiCodingAgentConfigServiceTier from "@oh-my-pi/pi-coding-agent/config/service-tier";
 import * as bundledPiCodingAgentConfigSettings from "@oh-my-pi/pi-coding-agent/config/settings";
 import * as bundledPiCodingAgentConfigSettingsSchema from "@oh-my-pi/pi-coding-agent/config/settings-schema";
 import * as bundledPiCodingAgentDap from "@oh-my-pi/pi-coding-agent/dap";
@@ -385,7 +386,6 @@ import * as bundledPiCodingAgentEvalJsContextManager from "@oh-my-pi/pi-coding-a
 import * as bundledPiCodingAgentEvalJsExecutor from "@oh-my-pi/pi-coding-agent/eval/js/executor";
 import * as bundledPiCodingAgentEvalJsToolBridge from "@oh-my-pi/pi-coding-agent/eval/js/tool-bridge";
 import * as bundledPiCodingAgentEvalJsWorkerCore from "@oh-my-pi/pi-coding-agent/eval/js/worker-core";
-import * as bundledPiCodingAgentEvalJsWorkerEntry from "@oh-my-pi/pi-coding-agent/eval/js/worker-entry";
 import * as bundledPiCodingAgentEvalJsWorkerProtocol from "@oh-my-pi/pi-coding-agent/eval/js/worker-protocol";
 import * as bundledPiCodingAgentEvalPyDisplay from "@oh-my-pi/pi-coding-agent/eval/py/display";
 import * as bundledPiCodingAgentEvalPyExecutor from "@oh-my-pi/pi-coding-agent/eval/py/executor";
@@ -1802,6 +1802,9 @@ export const BUNDLED_PI_REGISTRY: Readonly<Record<string, Readonly<Record<string
 		bundledPiCodingAgentConfigPromptTemplates as unknown as Readonly<Record<string, unknown>>,
 	"@oh-my-pi/pi-coding-agent/config/resolve-config-value":
 		bundledPiCodingAgentConfigResolveConfigValue as unknown as Readonly<Record<string, unknown>>,
+	"@oh-my-pi/pi-coding-agent/config/service-tier": bundledPiCodingAgentConfigServiceTier as unknown as Readonly<
+		Record<string, unknown>
+	>,
 	"@oh-my-pi/pi-coding-agent/config/settings-schema": bundledPiCodingAgentConfigSettingsSchema as unknown as Readonly<
 		Record<string, unknown>
 	>,
@@ -2100,9 +2103,6 @@ export const BUNDLED_PI_REGISTRY: Readonly<Record<string, Readonly<Record<string
 	"@oh-my-pi/pi-coding-agent/eval/js/worker-core": bundledPiCodingAgentEvalJsWorkerCore as unknown as Readonly<
 		Record<string, unknown>
 	>,
-	"@oh-my-pi/pi-coding-agent/eval/js/worker-entry": bundledPiCodingAgentEvalJsWorkerEntry as unknown as Readonly<
-		Record<string, unknown>
-	>,
 	"@oh-my-pi/pi-coding-agent/eval/js/worker-protocol": bundledPiCodingAgentEvalJsWorkerProtocol as unknown as Readonly<
 		Record<string, unknown>
 	>,

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { isBuiltin } from "node:module";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary } from "@oh-my-pi/pi-utils";
@@ -456,10 +457,11 @@ const TYPEBOX_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s+|import\s*\(\s*)["'
 
 /**
  * Rewrite the extension-owned specifiers OMP must host-resolve — legacy
- * `@(scope)/pi-*`, bare TypeBox packages, and package `imports` aliases like
- * `#src/*` — to absolute `file://` URLs. Every other specifier (relative
- * siblings and third-party dependencies) is left untouched so Bun resolves it
- * natively from the extension's real on-disk location.
+ * `@(scope)/pi-*`, bare TypeBox packages, package `imports` aliases like
+ * `#src/*`, and extension-local bare dependencies — to absolute `file://` URLs
+ * or compiled-mode virtual specifiers. Relative siblings and built-in modules
+ * are left untouched so Bun resolves them from the extension's real on-disk
+ * location.
  */
 async function rewriteLegacyExtensionSource(source: string, importerPath: string): Promise<string> {
 	const withPi = rewriteLegacyPiImports(source);
@@ -474,7 +476,12 @@ async function rewriteLegacyExtensionSource(source: string, importerPath: string
 					`${prefix}${toImportSpecifier(TYPEBOX_SHIM_PATH)}${suffix}`,
 			)
 		: withPi;
-	return rewriteExtensionPackageImports(withTypeBox, importerPath);
+	return rewriteExtensionBareImports(await rewriteExtensionPackageImports(withTypeBox, importerPath), importerPath);
+}
+
+/** Test seam for compiled-binary legacy extension source rewriting. */
+export async function __rewriteLegacyExtensionSourceForTests(source: string, importerPath: string): Promise<string> {
+	return rewriteLegacyExtensionSource(source, importerPath);
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -688,6 +695,187 @@ async function rewriteExtensionPackageImports(source: string, importerPath: stri
 	return `${rewritten}${source.slice(lastIndex)}`;
 }
 
+const BARE_EXTENSION_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s+|import\s*\(\s*)["'])([^"'()\s]+)(["'])/g;
+
+function isBareExtensionDependencySpecifier(specifier: string): boolean {
+	if (
+		specifier.startsWith(".") ||
+		specifier.startsWith("/") ||
+		specifier.startsWith("#") ||
+		specifier.startsWith("node:") ||
+		specifier.startsWith("bun:") ||
+		/^[a-z][a-z0-9+.-]*:/i.test(specifier)
+	) {
+		return false;
+	}
+	const packageName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+	return Boolean(packageName && !isBuiltin(packageName));
+}
+
+interface BarePackageSpecifier {
+	readonly name: string;
+	readonly subpath: string | null;
+}
+
+function splitBarePackageSpecifier(specifier: string): BarePackageSpecifier | null {
+	const parts = specifier.split("/");
+	if (specifier.startsWith("@")) {
+		const [scope, name, ...rest] = parts;
+		if (!scope || !name) return null;
+		return { name: `${scope}/${name}`, subpath: rest.length > 0 ? rest.join("/") : null };
+	}
+	const [name, ...rest] = parts;
+	if (!name) return null;
+	return { name, subpath: rest.length > 0 ? rest.join("/") : null };
+}
+
+async function findNodePackageRoot(packageName: string, importerPath: string): Promise<string | null> {
+	let dir = path.dirname(importerPath);
+	while (true) {
+		const candidate = path.join(dir, "node_modules", packageName);
+		if (await pathExists(path.join(candidate, "package.json"))) {
+			return candidate;
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) {
+			return null;
+		}
+		dir = parent;
+	}
+}
+
+async function readPackageManifest(packageRoot: string): Promise<Record<string, unknown> | null> {
+	try {
+		const manifest = await Bun.file(path.join(packageRoot, "package.json")).json();
+		return isRecord(manifest) ? manifest : null;
+	} catch {
+		return null;
+	}
+}
+
+async function resolvePackageExportTarget(
+	packageRoot: string,
+	target: string,
+	wildcard: string | null,
+): Promise<string | null> {
+	if (!target.startsWith("./")) {
+		return null;
+	}
+	const substituted = wildcard === null ? target : target.replaceAll("*", wildcard);
+	return resolveSourceModuleFile(path.resolve(packageRoot, substituted));
+}
+
+async function resolveNodePackageExport(
+	packageRoot: string,
+	subpath: string | null,
+	manifest: Record<string, unknown>,
+): Promise<string | null> {
+	const exportsField = manifest.exports;
+	const rootTarget = subpath === null ? selectPackageImportTarget(exportsField) : null;
+	if (rootTarget !== null && rootTarget !== PACKAGE_IMPORT_EXCLUDED) {
+		return resolvePackageExportTarget(packageRoot, rootTarget, null);
+	}
+	if (!isRecord(exportsField)) {
+		return null;
+	}
+
+	const exactKey = subpath === null ? "." : `./${subpath}`;
+	const exactTarget = selectPackageImportTarget(exportsField[exactKey]);
+	if (exactTarget !== null && exactTarget !== PACKAGE_IMPORT_EXCLUDED) {
+		return resolvePackageExportTarget(packageRoot, exactTarget, null);
+	}
+
+	for (const [key, entry] of Object.entries(exportsField)) {
+		const starIndex = key.indexOf("*");
+		if (starIndex === -1 || subpath === null) continue;
+		const prefix = key.slice(2, starIndex);
+		const suffix = key.slice(starIndex + 1);
+		if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) {
+			continue;
+		}
+		const target = selectPackageImportTarget(entry);
+		if (target === null || target === PACKAGE_IMPORT_EXCLUDED) {
+			continue;
+		}
+		return resolvePackageExportTarget(
+			packageRoot,
+			target,
+			subpath.slice(prefix.length, subpath.length - suffix.length),
+		);
+	}
+	return null;
+}
+
+async function resolveNodePackageFallback(
+	packageRoot: string,
+	subpath: string | null,
+	manifest: Record<string, unknown>,
+): Promise<string | null> {
+	if (subpath !== null) {
+		return resolveSourceModuleFile(path.join(packageRoot, subpath));
+	}
+	for (const field of ["module", "main"]) {
+		const target = manifest[field];
+		if (typeof target === "string") {
+			const resolved = await resolveSourceModuleFile(path.resolve(packageRoot, target));
+			if (resolved) return resolved;
+		}
+	}
+	return resolveSourceModuleFile(path.join(packageRoot, "index"));
+}
+
+async function resolveNodePackageDependency(specifier: string, importerPath: string): Promise<string | null> {
+	const parsed = splitBarePackageSpecifier(specifier);
+	if (!parsed) return null;
+	const packageRoot = await findNodePackageRoot(parsed.name, importerPath);
+	if (!packageRoot) return null;
+	const manifest = await readPackageManifest(packageRoot);
+	if (!manifest) return null;
+	return (
+		(await resolveNodePackageExport(packageRoot, parsed.subpath, manifest)) ??
+		(await resolveNodePackageFallback(packageRoot, parsed.subpath, manifest))
+	);
+}
+
+async function resolveExtensionBareDependency(specifier: string, importerPath: string): Promise<string | null> {
+	if (!isBareExtensionDependencySpecifier(specifier)) {
+		return null;
+	}
+	try {
+		const resolved = Bun.resolveSync(specifier, path.dirname(importerPath));
+		if (resolved && resolved !== specifier && !resolved.startsWith("node:") && !resolved.startsWith("bun:")) {
+			return resolved;
+		}
+	} catch {
+		// Compiled binaries do not reliably resolve runtime extension node_modules.
+	}
+	return resolveNodePackageDependency(specifier, importerPath);
+}
+
+async function rewriteExtensionBareImports(source: string, importerPath: string): Promise<string> {
+	let rewritten = "";
+	let lastIndex = 0;
+	for (const match of source.matchAll(BARE_EXTENSION_IMPORT_SPECIFIER_REGEX)) {
+		const matchIndex = match.index;
+		if (matchIndex === undefined) continue;
+
+		const [fullMatch, prefix, specifier, suffix] = match;
+		if (!prefix || !specifier || !suffix) continue;
+
+		const resolved = await resolveExtensionBareDependency(specifier, importerPath);
+		if (!resolved) continue;
+
+		rewritten += source.slice(lastIndex, matchIndex);
+		rewritten += `${prefix}${toImportSpecifier(resolved)}${suffix}`;
+		lastIndex = matchIndex + fullMatch.length;
+	}
+
+	if (lastIndex === 0) {
+		return source;
+	}
+	return `${rewritten}${source.slice(lastIndex)}`;
+}
+
 function escapeRegExp(value: string): string {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/src/main.ts

@@ -140,6 +140,7 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"advisor.subagents",
 	"advisor.syncBacklog",
 	"advisor.immuneTurns",
+	"serviceTierAdvisor",
 ];
 
 const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [