@oh-my-pi/pi-coding-agent 15.5.15 → 15.6.0

package/src/config/model-registry.ts

@@ -42,6 +42,12 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import {
+	getBracketStrippedModelIdCandidates,
+	getLongestModelLikeIdSegment,
+	getModelLikeIdSegments,
+	stripBracketedModelIdAffixes,
+} from "./model-id-affixes";
 import {
 	type ModelOverride,
 	type ModelsConfig,
@@ -650,20 +656,53 @@ function shouldReplaceCustomReference(existing: Model<Api> | undefined, candidat
 	return existing.provider !== "openai" && candidate.provider === "openai";
 }
 
+function normalizeCustomReferenceKey(value: string): string {
+	return value.trim().toLowerCase();
+}
+
 function buildCustomReferenceMap(): Map<string, Model<Api>> {
 	const references = new Map<string, Model<Api>>();
 	for (const provider of getBundledProviders()) {
 		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
 			const candidate = model as Model<Api>;
-			if (shouldReplaceCustomReference(references.get(candidate.id), candidate)) {
-				references.set(candidate.id, candidate);
+			const key = normalizeCustomReferenceKey(candidate.id);
+			if (shouldReplaceCustomReference(references.get(key), candidate)) {
+				references.set(key, candidate);
 			}
 		}
 	}
 	return references;
 }
 
+function buildCustomReferenceSuffixAliasMap(exactReferences: ReadonlyMap<string, Model<Api>>): Map<string, Model<Api>> {
+	const aliases = new Map<string, Model<Api>>();
+	for (const reference of exactReferences.values()) {
+		const slashIndex = reference.id.lastIndexOf("/");
+		if (slashIndex === -1) {
+			continue;
+		}
+		const suffix = reference.id.slice(slashIndex + 1);
+		const alias = getLongestModelLikeIdSegment(suffix);
+		if (!alias) {
+			continue;
+		}
+		if (shouldReplaceCustomReference(aliases.get(alias), reference)) {
+			aliases.set(alias, reference);
+		}
+	}
+	return aliases;
+}
+
 const customReferenceMap = buildCustomReferenceMap();
+const customReferenceSuffixAliasMap = buildCustomReferenceSuffixAliasMap(customReferenceMap);
+
+const CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN =
+	/[-:](?:thinking|customtools|high|low|medium|minimal|xhigh|free|cloud|exacto|nitro|original|optimized|nvfp4|fp8|fp4|bf16|int8|int4|search)$/i;
+
+function stripCustomReferenceTrailingMarker(candidate: string): string | undefined {
+	const match = CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN.exec(candidate);
+	return match ? candidate.slice(0, match.index) : undefined;
+}
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
@@ -673,23 +712,46 @@ function getCustomReferenceCandidateIds(modelId: string): string[] {
 		if (!candidate || candidates.has(candidate)) continue;
 		candidates.add(candidate);
 
+		for (const stripped of getBracketStrippedModelIdCandidates(candidate)) {
+			queue.push(stripped);
+		}
+		for (const segment of getModelLikeIdSegments(candidate)) {
+			queue.push(segment);
+		}
+
 		for (const suffix of [":cloud", "-cloud"] as const) {
 			if (candidate.toLowerCase().endsWith(suffix)) {
 				queue.push(candidate.slice(0, -suffix.length));
 			}
 		}
 
+		const slashIndex = candidate.lastIndexOf("/");
+		if (slashIndex !== -1) {
+			queue.push(candidate.slice(slashIndex + 1));
+		}
+
 		const colonToDash = candidate.replace(/:/g, "-");
 		if (colonToDash !== candidate) {
 			queue.push(colonToDash);
 		}
+
+		const lowercased = candidate.toLowerCase();
+		if (lowercased !== candidate) {
+			queue.push(lowercased);
+		}
+
+		const strippedMarker = stripCustomReferenceTrailingMarker(candidate);
+		if (strippedMarker) {
+			queue.push(strippedMarker);
+		}
 	}
 	return [...candidates];
 }
 
 function resolveCustomModelReference(modelId: string): Model<Api> | undefined {
 	for (const candidate of getCustomReferenceCandidateIds(modelId)) {
-		const reference = customReferenceMap.get(candidate);
+		const key = normalizeCustomReferenceKey(candidate);
+		const reference = customReferenceMap.get(key) ?? customReferenceSuffixAliasMap.get(key);
 		if (reference) return reference;
 	}
 	return undefined;
@@ -1785,7 +1847,7 @@ export class ModelRegistry {
 			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
 		}
 		const payload = (await response.json()) as {
-			data?: Array<{ id?: string; supported_endpoint_types?: string[] }>;
+			data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[] }>;
 		};
 		const items = payload.data ?? [];
 		const discovered: Model<Api>[] = [];
@@ -1800,23 +1862,35 @@ export class ModelRegistry {
 					: providerConfig.api;
 			if (!api) continue;
 			const isAnthropic = api === "anthropic-messages";
+			const reference = resolveCustomModelReference(id);
+			const discoveryName = typeof item.name === "string" ? item.name.trim() : "";
+			const displayName =
+				reference?.name ??
+				(discoveryName && discoveryName !== id ? discoveryName : undefined) ??
+				stripBracketedModelIdAffixes(id) ??
+				id;
 			discovered.push(
 				enrichModelThinking({
 					id,
-					name: id,
+					name: displayName,
 					api,
 					provider: providerConfig.provider,
 					baseUrl,
-					reasoning: false,
-					input: ["text"],
+					reasoning: reference?.reasoning ?? false,
+					thinking: reference?.thinking,
+					input: reference?.input ?? ["text"],
+					// Proxy pricing is provider-specific and usually does not match
+					// upstream bundled catalogs, so keep costs local-unknown even when
+					// we successfully recover the upstream model identity.
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
+					contextWindow: reference?.contextWindow ?? 128000,
+					maxTokens: reference?.maxTokens ?? 8192,
 					headers,
 					// OpenAI-compat fields are no-ops on anthropic models; the
 					// Anthropic SDK ignores them. Provider-level disableStrictTools
 					// flows in via #applyProviderCompat for the third-party-Anthropic
-					// path.
+					// path. Cross-wire bundled compat is intentionally not copied:
+					// request-shaping fields are provider-wire specific.
 					compat: isAnthropic
 						? undefined
 						: {

package/src/config/settings-schema.ts

@@ -1,6 +1,14 @@
 import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking";
+import {
+	ONLINE_MEMORY_MODEL_KEY,
+	ONLINE_TINY_TITLE_MODEL_KEY,
+	TINY_MEMORY_MODEL_OPTIONS,
+	TINY_MEMORY_MODEL_VALUES,
+	TINY_TITLE_MODEL_OPTIONS,
+	TINY_TITLE_MODEL_VALUES,
+} from "../tiny/models";
 import { EDIT_MODES } from "../utils/edit-mode";
 
 /** Unified settings schema - single source of truth for all settings.
@@ -1292,23 +1300,192 @@ export const SETTINGS_SCHEMA = {
 	"memories.summaryInjectionTokenLimit": { type: "number", default: 5000 },
 
 	// Memory backend selector — picks between local memories pipeline,
-	// Hindsight remote memory, or off. Legacy `memories.enabled` keeps gating
-	// the local backend; see config/settings.ts migration for details.
+	// Mnemosyne local SQLite, Hindsight remote memory, or off. Legacy
+	// `memories.enabled` keeps gating the local backend; see config/settings.ts
+	// migration for details.
 	"memory.backend": {
 		type: "enum",
-		values: ["off", "local", "hindsight"] as const,
+		values: ["off", "local", "hindsight", "mnemosyne"] as const,
 		default: "off",
 		ui: {
 			tab: "memory",
 			label: "Memory Backend",
-			description: "Off, local memory pipeline, or Hindsight remote memory",
+			description: "Off, local summary pipeline, Mnemosyne SQLite, or Hindsight remote memory",
 			options: [
 				{ value: "off", label: "Off", description: "No memory subsystem runs" },
 				{ value: "local", label: "Local", description: "Local rollout summarisation pipeline (memory_summary.md)" },
 				{ value: "hindsight", label: "Hindsight", description: "Vectorize Hindsight remote memory service" },
+				{
+					value: "mnemosyne",
+					label: "Mnemosyne",
+					description: "Local SQLite recall/retain backend with optional embeddings",
+				},
+			],
+		},
+	},
+
+	// Mnemosyne local SQLite memory backend.
+	"mnemosyne.dbPath": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne DB Path",
+			description: "Optional SQLite DB path. Defaults to the agent memories directory.",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.bank": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Bank",
+			description: "Optional shared bank base name. Per-project modes derive project-local banks from it.",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.scoping": {
+		type: "enum",
+		values: ["global", "per-project", "per-project-tagged"] as const,
+		default: "per-project",
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Scoping",
+			description:
+				"global = one shared bank; per-project = isolated bank per cwd; per-project-tagged = project-local writes plus global recall visibility",
+			options: [
+				{
+					value: "global",
+					label: "Global",
+					description: "One shared Mnemosyne bank for every project",
+				},
+				{
+					value: "per-project",
+					label: "Per project",
+					description: "Project-local Mnemosyne bank per cwd basename",
+				},
+				{
+					value: "per-project-tagged",
+					label: "Per project (tagged)",
+					description: "Write to a project-local bank but merge project + shared recall results",
+				},
+			],
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.autoRecall": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Auto Recall",
+			description: "Recall local memories into the first turn of each session",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.autoRetain": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Auto Retain",
+			description: "Retain completed conversation turns into local Mnemosyne memory",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.noEmbeddings": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Disable Embeddings",
+			description: "Force deterministic FTS-only recall instead of vector embeddings",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingModel": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding Model",
+			description: "Optional embedding model override passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingApiUrl": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding API URL",
+			description: "Optional OpenAI-compatible embedding endpoint passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingApiKey": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding API Key",
+			description: "Optional embedding API key passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmMode": {
+		type: "enum",
+		values: ["none", "smol", "remote"] as const,
+		default: "smol",
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Mode",
+			description: "Use no LLM, the configured smol model, or a remote OpenAI-compatible endpoint",
+			condition: "mnemosyneActive",
+			options: [
+				{ value: "none", label: "None", description: "Disable Mnemosyne LLM-backed extraction" },
+				{ value: "smol", label: "Smol", description: "Use the configured pi-ai smol model" },
+				{ value: "remote", label: "Remote", description: "Use the Mnemosyne remote LLM settings below" },
 			],
 		},
 	},
+	"mnemosyne.llmBaseUrl": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Base URL",
+			description: "Optional OpenAI-compatible LLM endpoint for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmApiKey": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM API Key",
+			description: "Optional LLM API key for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmModel": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Model",
+			description: "Optional LLM model name for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.retainEveryNTurns": { type: "number", default: 4 },
+	"mnemosyne.recallLimit": { type: "number", default: 8 },
+	"mnemosyne.recallContextTurns": { type: "number", default: 3 },
+	"mnemosyne.recallMaxQueryChars": { type: "number", default: 4000 },
+	"mnemosyne.injectionTokenLimit": { type: "number", default: 5000 },
+	"mnemosyne.debug": { type: "boolean", default: false },
 
 	// Hindsight (https://hindsight.vectorize.io)
 	"hindsight.apiUrl": {
@@ -2727,6 +2904,30 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"providers.tinyModel": {
+		type: "enum",
+		values: TINY_TITLE_MODEL_VALUES,
+		default: ONLINE_TINY_TITLE_MODEL_KEY,
+		ui: {
+			tab: "providers",
+			label: "Tiny Model",
+			description: "Session-title model: online pi/smol by default, or a local on-device model",
+			options: TINY_TITLE_MODEL_OPTIONS,
+		},
+	},
+	"providers.memoryModel": {
+		type: "enum",
+		values: TINY_MEMORY_MODEL_VALUES,
+		default: ONLINE_MEMORY_MODEL_KEY,
+		ui: {
+			tab: "memory",
+			label: "Memory Model",
+			description:
+				"Mnemosyne LLM for fact extraction + consolidation: online (smol/remote) by default, or a local on-device model",
+			condition: "mnemosyneActive",
+			options: TINY_MEMORY_MODEL_OPTIONS,
+		},
+	},
 
 	"providers.kimiApiFormat": {
 		type: "enum",

package/src/edit/hashline/diff.ts

@@ -11,6 +11,7 @@
  */
 import {
 	Patch as HashlinePatch,
+	missingSnapshotTagMessage,
 	normalizeToLF,
 	type Patch,
 	type PatchSection,
@@ -40,10 +41,6 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
-function hasAnchorScoped(section: PatchSection): boolean {
-	return section.hasAnchorScopedEdit;
-}
-
 function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
 	return snapshot.text === currentText;
 }
@@ -54,9 +51,10 @@ function validateSectionHash(
 	snapshots: SnapshotStore,
 ): string | null {
 	if (section.fileHash === undefined) {
-		return hasAnchorScoped(section)
-			? `Missing hashline snapshot tag for anchored edit to ${section.path}; use \`¶${section.path}#tag\` from your latest read.`
-			: null;
+		// The snapshot tag is mandatory on every section — head/tail inserts
+		// included — to keep this preview path in lockstep with the apply path
+		// (`Patcher.prepare`), which rejects tagless sections unconditionally.
+		return missingSnapshotTagMessage(section.path);
 	}
 	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
 	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;

package/src/eval/__tests__/shared-executors.test.ts

@@ -492,6 +492,42 @@ display({"label": "A"})`,
 		expect(reloaded.output.trim()).toBe("2");
 	});
 
+	it("loads TypeScript type-only imports in cells and local modules", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-js-type-imports-");
+		const sessionFile = path.join(tempDir.path(), "session.jsonl");
+		const sessionId = `js-type-imports:${crypto.randomUUID()}`;
+		const session = createToolSession(tempDir.path(), sessionFile);
+		const typesPath = path.join(tempDir.path(), "types.ts");
+		const valuesPath = path.join(tempDir.path(), "values.ts");
+		const entryPath = path.join(tempDir.path(), "entry.ts");
+		const typesSpec = JSON.stringify(typesPath);
+		const entrySpec = JSON.stringify(entryPath);
+		await Bun.write(typesPath, "export interface TypeOnly { value: number }\n");
+		await Bun.write(valuesPath, "export interface InlineOnly { value: number }\nexport const imported = 41;\n");
+		await Bun.write(
+			entryPath,
+			[
+				'import type { TypeOnly } from "./types.ts";',
+				'import { type InlineOnly, imported } from "./values.ts";',
+				"export const typeOnly = 1;",
+				"export const inlineType = imported;",
+				"",
+			].join("\n"),
+		);
+
+		const result = await executeJs(
+			`import type { TypeOnly } from ${typesSpec};\nconst mod = await import(${entrySpec});\nreturn mod.typeOnly + mod.inlineType;`,
+			{
+				sessionId,
+				session,
+				sessionFile,
+			},
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output.trim()).toBe("42");
+	});
+
 	it("refreshes the Python tool proxy when bridge env appears after kernel warm-up", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-py-tool-proxy-");
 		const sessionFile = path.join(tempDir.path(), "session.jsonl");

package/src/eval/js/shared/local-module-loader.ts

@@ -88,7 +88,10 @@ export class LocalModuleLoader {
 
 	async #buildLocalModule(modulePath: string): Promise<LocalModuleEntry> {
 		const rawSource = fs.readFileSync(modulePath, "utf8");
-		const stripped = stripTypeScriptSyntax(rawSource);
+		const stripped = stripTypeScriptSyntax(rawSource, {
+			force: isTypeScriptModulePath(modulePath),
+			loader: stripLoaderForPath(modulePath),
+		});
 		const moduleDir = path.dirname(modulePath);
 		const localDeps = new Set<string>();
 		for (const specifier of collectModuleSourceSpecifiers(stripped)) {
@@ -251,6 +254,15 @@ function isLocalPathSpecifier(source: string): boolean {
 	);
 }
 
+function isTypeScriptModulePath(modulePath: string): boolean {
+	const ext = path.extname(modulePath);
+	return ext === ".ts" || ext === ".tsx" || ext === ".mts";
+}
+
+function stripLoaderForPath(modulePath: string): "ts" | "tsx" {
+	return path.extname(modulePath) === ".tsx" ? "tsx" : "ts";
+}
+
 function isManagedLocalModulePath(target: string): boolean {
 	return (
 		path.isAbsolute(target) &&

package/src/eval/js/shared/rewrite-imports.ts

@@ -75,6 +75,7 @@ function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgr
 			allowSuperOutsideMethod: true,
 			allowUndeclaredExports: true,
 			errorRecovery: true,
+			plugins: ["typescript"],
 		}) as unknown as { program: { body: ReadonlyArray<BabelProgramNode> } };
 	} catch {
 		return null;
@@ -178,8 +179,7 @@ export function rewriteImports(code: string): string {
 		if (node.type !== "CallExpression") return;
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callee = call.callee;
-		if (!callee || callee.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number")
-			return;
+		if (callee?.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number") return;
 		edits.push({ start: callee.start, end: callee.end, text: "__omp_import__" });
 	});
 
@@ -252,12 +252,7 @@ export function rewriteDynamicImports(code: string, callee = "__omp_import__"):
 		if (node.type !== "CallExpression") return;
 		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
 		const callCallee = call.callee;
-		if (
-			!callCallee ||
-			callCallee.type !== "Import" ||
-			typeof callCallee.start !== "number" ||
-			typeof callCallee.end !== "number"
-		) {
+		if (callCallee?.type !== "Import" || typeof callCallee.start !== "number" || typeof callCallee.end !== "number") {
 			return;
 		}
 		edits.push({ start: callCallee.start, end: callCallee.end, text: callee });
@@ -453,38 +448,48 @@ function requiresAsyncWrapper(code: string): boolean {
 }
 
 /**
- * Strip TypeScript syntax (type annotations, `interface`, `as`, `satisfies`, generics in
- * call expressions, etc.) before the import/lexical rewriters parse the code. We use Bun's
- * native transpiler in `ts` loader mode — fast, no JSX transforms, preserves `import`/
- * `export` declarations so the downstream Babel rewrites keep working.
+ * Strip TypeScript syntax (type annotations, type-only imports/exports, `interface`, `as`,
+ * `satisfies`, generics in call expressions, etc.) before the import/lexical rewriters parse
+ * the code. Bun's native transpiler preserves `import`/`export` declarations, so downstream
+ * Babel rewrites still control module resolution.
  *
- * Skipped when the code parses as plain JavaScript already (Babel can accept it), so the
- * common case avoids an extra transpile pass. We detect "looks like TS" with a cheap regex
- * before invoking the transpiler.
+ * Eval cells use a cheap "looks like TS" heuristic to avoid transpiling ordinary JS. Known
+ * TypeScript modules pass `force` because a file can contain TS-only module syntax such as
+ * `import type` without any value-level type annotations.
  */
-function stripTypeScript(code: string): string {
-	if (!LOOKS_LIKE_TS.test(code)) return code;
+type TypeScriptStripLoader = "ts" | "tsx";
+
+const TS_TRANSPILER = new Bun.Transpiler({ loader: "ts" });
+const TSX_TRANSPILER = new Bun.Transpiler({ loader: "tsx" });
+
+function stripTypeScript(code: string, options: { force?: boolean; loader?: TypeScriptStripLoader } = {}): string {
+	if (!options.force && !LOOKS_LIKE_TS.test(code)) return code;
 	try {
-		return new Bun.Transpiler({ loader: "ts" }).transformSync(code);
+		const transpiler = options.loader === "tsx" ? TSX_TRANSPILER : TS_TRANSPILER;
+		return transpiler.transformSync(code);
 	} catch {
 		// Transpiler failed (e.g. unrecoverable syntax). Hand the original source back so the
 		// downstream rewriter / VM surfaces the real error to the user.
 		return code;
 	}
 }
-export function stripTypeScriptSyntax(code: string): string {
-	return stripTypeScript(code);
+export function stripTypeScriptSyntax(
+	code: string,
+	options: { force?: boolean; loader?: TypeScriptStripLoader } = {},
+): string {
+	return stripTypeScript(code, options);
 }
 
-// Heuristic: any of the obvious TS-only tokens. Plain JS using `as` only inside strings
-// won't match because we require a leading word boundary plus a colon/keyword neighbor.
+// Heuristic: obvious TS-only tokens, including type-only module syntax. Plain JS using `as`
+// only inside strings won't match because we require a leading word boundary plus a
+// colon/keyword neighbor.
 const LOOKS_LIKE_TS =
-	/(?:\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
+	/(?:\bimport\s+type\b|\bexport\s+type\b|\b(?:import|export)\s*\{[^}\n]*\btype\s+\w|\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
 
 export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
-	const stripped = stripTypeScript(code);
-	const finalExpression = returnFinalExpression(stripped);
-	const importsRewritten = rewriteImports(finalExpression.source);
+	const finalExpression = returnFinalExpression(code);
+	const stripped = stripTypeScript(finalExpression.source);
+	const importsRewritten = rewriteImports(stripped);
 	const needsAsyncWrapper = requiresAsyncWrapper(importsRewritten);
 	const rewritten = {
 		source: demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),

package/src/internal-urls/agent-protocol.ts

@@ -16,7 +16,7 @@ import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { applyQuery, pathToQuery } from "./json-query";
 import { artifactsDirsFromRegistry } from "./registry-helpers";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 /**
  * Handler for agent:// URLs.
@@ -126,4 +126,21 @@ export class AgentProtocolHandler implements ProtocolHandler {
 			notes,
 		};
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		const ids = new Set<string>();
+		for (const dir of artifactsDirsFromRegistry()) {
+			let files: string[];
+			try {
+				files = await fs.readdir(dir);
+			} catch (err) {
+				if (isEnoent(err)) continue;
+				throw err;
+			}
+			for (const f of files) {
+				if (f.endsWith(".md")) ids.add(f.slice(0, -3));
+			}
+		}
+		return [...ids].sort().map(value => ({ value }));
+	}
 }

package/src/internal-urls/artifact-protocol.ts

@@ -13,7 +13,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { artifactsDirsFromRegistry } from "./registry-helpers";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
 
 export class ArtifactProtocolHandler implements ProtocolHandler {
 	readonly scheme = "artifact";
@@ -77,4 +77,22 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 			sourcePath: foundPath,
 		};
 	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		const ids = new Set<string>();
+		for (const dir of artifactsDirsFromRegistry()) {
+			let files: string[];
+			try {
+				files = await fs.readdir(dir);
+			} catch (err) {
+				if (isEnoent(err)) continue;
+				throw err;
+			}
+			for (const f of files) {
+				const m = f.match(/^(\d+)\./);
+				if (m) ids.add(m[1]!);
+			}
+		}
+		return [...ids].sort((a, b) => Number(a) - Number(b)).map(value => ({ value }));
+	}
 }