@oh-my-pi/pi-coding-agent 15.10.3 → 15.10.5

package/src/eval/js/shared/helpers.ts

@@ -24,6 +24,12 @@ export interface HelperOptions {
 export interface HelperContext {
 	cwd(): string;
 	env: Map<string, string>;
+	/**
+	 * On-disk roots for internal-URL schemes the helpers accept (e.g.
+	 * `{ local: "/…/artifacts/local" }`). A path like `local://x.md` is rewritten
+	 * to `<root>/x.md` before any filesystem op; unknown schemes are rejected.
+	 */
+	localRoots(): Record<string, string>;
 	emitStatus(event: JsStatusEvent): void;
 }
 
@@ -66,7 +72,7 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 			if (!isWriteData(data)) {
 				throw new ToolError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
 			}
-			const filePath = resolvePath(ctx, rawPath);
+			const filePath = resolveHelperPath(ctx, rawPath, "write");
 			if (typeof data === "string" || data instanceof Blob || data instanceof ArrayBuffer) {
 				await Bun.write(filePath, data);
 			} else {
@@ -76,7 +82,7 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 			return filePath;
 		},
 		append: async (rawPath, content) => {
-			const target = resolvePath(ctx, rawPath);
+			const target = resolveHelperPath(ctx, rawPath, "write");
 			await Bun.write(
 				target,
 				`${await Bun.file(target)
@@ -202,19 +208,60 @@ function getMergedEnv(ctx: HelperContext): Record<string, string> {
 	return merged;
 }
 
+const INTERNAL_URL_RE = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/i;
+
 function resolvePath(ctx: HelperContext, value: string): string {
 	if (path.isAbsolute(value)) return path.normalize(value);
 	return path.resolve(ctx.cwd(), value);
 }
 
+/**
+ * Map a raw helper path to an absolute filesystem path. Plain paths resolve
+ * against the cwd; an internal-URL whose scheme has an injected root (e.g.
+ * `local://`) is rewritten under that root; any other `scheme://` is rejected
+ * so we never silently create a literal `scheme:/` directory.
+ */
+function resolveHelperPath(ctx: HelperContext, rawPath: string, op: "read" | "write"): string {
+	const match = INTERNAL_URL_RE.exec(rawPath);
+	if (!match) return resolvePath(ctx, rawPath);
+	const scheme = match[1].toLowerCase();
+	const root = ctx.localRoots()[scheme];
+	if (!root) {
+		throw new ToolError(`Protocol paths are not supported by ${op}(): ${rawPath}`);
+	}
+	return resolveUnderRoot(scheme, root, match[2], rawPath);
+}
+
+/** Resolve an internal-URL relative path under its root, mirroring the host
+ *  local-protocol handler: decode, reject absolute/traversal, confine to root. */
+function resolveUnderRoot(scheme: string, root: string, rawRelative: string, rawPath: string): string {
+	let relative: string;
+	try {
+		relative = decodeURIComponent(rawRelative.replaceAll("\\", "/"));
+	} catch {
+		throw new ToolError(`Invalid URL encoding in ${scheme}:// path: ${rawPath}`);
+	}
+	const rootPath = path.resolve(root);
+	if (relative === "") return rootPath;
+	if (path.isAbsolute(relative)) {
+		throw new ToolError(`Absolute paths are not allowed in ${scheme}:// URLs: ${rawPath}`);
+	}
+	const normalized = path.normalize(relative);
+	if (normalized.startsWith("..") || normalized.includes("/../") || normalized.includes("/..")) {
+		throw new ToolError(`Path traversal (..) is not allowed in ${scheme}:// URLs: ${rawPath}`);
+	}
+	const resolved = path.resolve(rootPath, normalized);
+	if (resolved !== rootPath && !resolved.startsWith(`${rootPath}${path.sep}`)) {
+		throw new ToolError(`${scheme}:// path escapes its root: ${rawPath}`);
+	}
+	return resolved;
+}
+
 async function resolveRegularFile(
 	ctx: HelperContext,
 	rawPath: string,
 ): Promise<{ filePath: string; file: Bun.BunFile; size: number }> {
-	if (/^[a-z][a-z0-9+.-]*:\/\//i.test(rawPath)) {
-		throw new ToolError(`Protocol paths are not supported by read(): ${rawPath}`);
-	}
-	const filePath = resolvePath(ctx, rawPath);
+	const filePath = resolveHelperPath(ctx, rawPath, "read");
 	const file = Bun.file(filePath);
 	const stat = await file.stat();
 	if (stat.isDirectory()) {

package/src/eval/js/shared/prelude.txt

@@ -57,9 +57,9 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 
 	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 
-	const llm = async (prompt, opts, ...rest) => {
-		const o = optionsArg("llm", opts, rest, "{ model, system, schema }");
-		const res = await globalThis.__omp_call_tool__("__llm__", { prompt, ...o });
+	const completion = async (prompt, opts, ...rest) => {
+		const o = optionsArg("completion", opts, rest, "{ model, system, schema }");
+		const res = await globalThis.__omp_call_tool__("__completion__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
@@ -164,7 +164,7 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.print = consoleBridge.log;
 	globalThis.display = display;
 	globalThis.tool = tool;
-	globalThis.llm = llm;
+	globalThis.completion = completion;
 	globalThis.output = output;
 	globalThis.agent = agent;
 	globalThis.parallel = parallel;

package/src/eval/js/shared/runtime.ts

@@ -42,6 +42,11 @@ export interface RuntimeOptions {
 	 * via `setRunScope()` instead.
 	 */
 	extraGlobals?: Record<string, unknown>;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes (e.g.
+	 * `{ local: "/…/artifacts/local" }`). Stable for the worker's lifetime.
+	 */
+	localRoots?: Record<string, string>;
 }
 
 // Strict base64: characters from the standard alphabet plus optional `=` padding, and a
@@ -126,15 +131,18 @@ export class JsRuntime {
 	#env: Map<string, string>;
 	#als = new AsyncLocalStorage<RunContext>();
 	#moduleLoader: LocalModuleLoader;
+	#localRoots: Record<string, string>;
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
 		this.sessionId = opts.sessionId;
 		this.#env = new Map();
 		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
+		this.#localRoots = opts.localRoots ?? {};
 		this.helpers = createHelpers({
 			cwd: () => this.#activeCwd(),
 			env: this.#env,
+			localRoots: () => this.#localRoots,
 			emitStatus: event => this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event }),
 		});
 		this.#install(opts.extraGlobals);

package/src/eval/js/tool-bridge.ts

@@ -3,8 +3,8 @@ import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
 import { EVAL_AGENT_BRIDGE_NAME, runEvalAgent } from "../agent-bridge";
 import { EVAL_BUDGET_BRIDGE_NAME, type EvalBudgetResult, runEvalBudget } from "../budget-bridge";
+import { EVAL_COMPLETION_BRIDGE_NAME, runEvalCompletion } from "../completion-bridge";
 import { EVAL_CONCURRENCY_BRIDGE_NAME, type EvalConcurrencyResult, runEvalConcurrency } from "../concurrency-bridge";
-import { EVAL_LLM_BRIDGE_NAME, runEvalLlm } from "../llm-bridge";
 import type { JsStatusEvent } from "./shared/types";
 
 export type { JsStatusEvent } from "./shared/types";
@@ -107,8 +107,8 @@ function summarizeToolResult(
 }
 
 export async function callSessionTool(name: string, args: unknown, options: ToolBridgeOptions): Promise<ToolValue> {
-	if (name === EVAL_LLM_BRIDGE_NAME) {
-		return await runEvalLlm(args, options);
+	if (name === EVAL_COMPLETION_BRIDGE_NAME) {
+		return await runEvalCompletion(args, options);
 	}
 	if (name === EVAL_AGENT_BRIDGE_NAME) {
 		return await runEvalAgent(args, options);

package/src/eval/js/worker-core.ts

@@ -71,6 +71,7 @@ export class WorkerCore {
 		this.#runtime = new JsRuntime({
 			initialCwd: snapshot.cwd,
 			sessionId: snapshot.sessionId,
+			localRoots: snapshot.localRoots,
 		});
 		return this.#runtime;
 	}

package/src/eval/js/worker-entry.ts

@@ -18,6 +18,12 @@ const transport: Transport = {
 		} catch {
 			// Already closed.
 		}
+
+		// `parentPort.close()` only disconnects the channel in Bun; it does not
+		// make the Worker emit `close` or reap ref'ed user handles. Exit from
+		// inside the worker after `WorkerCore` has sent the `closed` ack so the
+		// host can observe real worker exit without calling `Worker.terminate()`.
+		setTimeout(() => process.exit(0), 0);
 	},
 };
 

package/src/eval/js/worker-protocol.ts

@@ -5,6 +5,12 @@ export type { JsDisplayOutput } from "./shared/types";
 export interface SessionSnapshot {
 	cwd: string;
 	sessionId: string;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes
+	 * (e.g. `{ local: "/…/artifacts/local" }`). Lets `read`/`write`/`append`
+	 * accept `local://…` paths instead of writing a literal `local:/` directory.
+	 */
+	localRoots?: Record<string, string>;
 }
 
 export interface RunErrorPayload {

package/src/eval/py/executor.ts

@@ -56,6 +56,13 @@ export interface PythonExecutorOptions {
 	/** Artifact path/id for full output storage */
 	artifactPath?: string;
 	artifactId?: string;
+	/**
+	 * On-disk roots the prelude helpers (`read`/`write`/`append`) substitute for
+	 * internal-URL schemes (e.g. `{ local: "/…/artifacts/local" }`). Exported to
+	 * the kernel as `PI_EVAL_LOCAL_ROOTS` (JSON) so `write("local://x")` lands
+	 * where `read local://x` resolves instead of a literal `local:/` directory.
+	 */
+	localRoots?: Record<string, string>;
 	/**
 	 * ToolSession used to resolve host-side `tool.<name>(args)` calls made from
 	 * the Python prelude's bridge proxy. When omitted, the bridge env vars are
@@ -275,6 +282,7 @@ const MANAGED_KERNEL_ENV_KEYS = [
 	"PI_TOOL_BRIDGE_URL",
 	"PI_TOOL_BRIDGE_TOKEN",
 	"PI_TOOL_BRIDGE_SESSION",
+	"PI_EVAL_LOCAL_ROOTS",
 ] as const;
 
 function buildKernelEnvPatch(options: {
@@ -282,13 +290,16 @@ function buildKernelEnvPatch(options: {
 	artifactsDir?: string;
 	bridgeSessionId?: string;
 	bridge?: { url: string; token: string };
+	localRoots?: Record<string, string>;
 }): KernelRuntimeEnv {
+	const localRoots = options.localRoots;
 	return {
 		PI_SESSION_FILE: options.sessionFile ?? null,
 		PI_ARTIFACTS_DIR: options.artifactsDir ?? null,
 		PI_TOOL_BRIDGE_URL: options.bridge?.url ?? null,
 		PI_TOOL_BRIDGE_TOKEN: options.bridge?.token ?? null,
 		PI_TOOL_BRIDGE_SESSION: options.bridge && options.bridgeSessionId ? options.bridgeSessionId : null,
+		PI_EVAL_LOCAL_ROOTS: localRoots && Object.keys(localRoots).length > 0 ? JSON.stringify(localRoots) : null,
 	};
 }
 
@@ -297,6 +308,7 @@ function buildKernelEnv(options: {
 	artifactsDir?: string;
 	bridgeSessionId?: string;
 	bridge?: { url: string; token: string };
+	localRoots?: Record<string, string>;
 }): Record<string, string> | undefined {
 	const patch = buildKernelEnvPatch(options);
 	const env: Record<string, string> = {};

package/src/eval/py/index.ts

@@ -1,5 +1,10 @@
 import type { ToolSession } from "../../tools";
-import type { ExecutorBackend, ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import {
+	type ExecutorBackend,
+	type ExecutorBackendExecOptions,
+	type ExecutorBackendResult,
+	resolveEvalUrlRoots,
+} from "../backend";
 import { executePython, type PythonExecutorOptions } from "./executor";
 import { checkPythonKernelAvailability } from "./kernel";
 
@@ -34,6 +39,7 @@ export default {
 			kernelMode,
 			sessionFile: opts.sessionFile,
 			artifactsDir: opts.session.getArtifactsDir?.() ?? undefined,
+			localRoots: resolveEvalUrlRoots(opts.session),
 			kernelOwnerId: opts.kernelOwnerId,
 			reset: opts.reset,
 			artifactPath: opts.artifactPath,

package/src/eval/py/prelude.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
-    import os, json, math
+    import os, json, math, re
+    from urllib.parse import unquote
 
     # __omp_display is injected by runner.py before the prelude executes; it
     # mirrors IPython's display() semantics with the same MIME bundle output.
@@ -53,9 +54,47 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("env", key=key, value=val, action="get")
         return val
 
+    _OMP_INTERNAL_URL_RE = re.compile(r"^([a-z][a-z0-9+.-]*)://(.*)$", re.IGNORECASE)
+
+    def _resolve_omp_path(path: str | Path) -> Path:
+        """Map a helper path to a real filesystem Path.
+
+        A `scheme://…` whose scheme has an injected on-disk root (e.g.
+        `local://`, via PI_EVAL_LOCAL_ROOTS) is rewritten under that root so it
+        lands where `read local://…` resolves — not a literal `local:/`
+        directory under the cwd (which `Path("local://x")` collapses to). Plain
+        paths pass through unchanged; any other `scheme://` is rejected."""
+        if not isinstance(path, str):
+            return Path(path)
+        match = _OMP_INTERNAL_URL_RE.match(path)
+        if not match:
+            return Path(path)
+        scheme = match.group(1).lower()
+        try:
+            roots = json.loads(os.environ.get("PI_EVAL_LOCAL_ROOTS") or "{}")
+        except (ValueError, TypeError):
+            roots = {}
+        root = roots.get(scheme) if isinstance(roots, dict) else None
+        if not root:
+            raise ValueError(f"Protocol paths are not supported by this helper: {path}")
+        relative = unquote(match.group(2).replace("\\", "/"))
+        # Mirror the host `path.resolve`/`resolveLocalUrlToPath`: normalize and
+        # make absolute WITHOUT realpath'ing symlinks (Path.resolve would turn
+        # /tmp into /private/tmp and diverge from the read-side resolution).
+        root_path = os.path.abspath(root)
+        if relative == "":
+            return Path(root_path)
+        rel_path = Path(relative)
+        if rel_path.is_absolute() or ".." in rel_path.parts:
+            raise ValueError(f"Unsafe {scheme}:// path (absolute or traversal): {path}")
+        resolved = os.path.abspath(os.path.join(root_path, relative))
+        if resolved != root_path and not resolved.startswith(root_path + os.sep):
+            raise ValueError(f"{scheme}:// path escapes its root: {path}")
+        return Path(resolved)
+
     def read(path: str | Path, offset: int = 1, limit: int | None = None) -> str:
         """Read file contents. offset/limit are 1-indexed line numbers."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         data = p.read_text(encoding="utf-8")
         lines = data.splitlines(keepends=True)
         if offset > 1 or limit is not None:
@@ -69,7 +108,7 @@ if "__omp_prelude_loaded__" not in globals():
 
     def write(path: str | Path, content: str) -> Path:
         """Write file contents (create parents)."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         p.parent.mkdir(parents=True, exist_ok=True)
         p.write_text(content, encoding="utf-8")
         _emit_status("write", path=str(p), chars=len(content))
@@ -77,7 +116,7 @@ if "__omp_prelude_loaded__" not in globals():
 
     def append(path: str | Path, content: str) -> Path:
         """Append to file."""
-        p = Path(path)
+        p = _resolve_omp_path(path)
         p.parent.mkdir(parents=True, exist_ok=True)
         with p.open("a", encoding="utf-8") as f:
             f.write(content)
@@ -463,8 +502,8 @@ if "__omp_prelude_loaded__" not in globals():
 
     tool = _ToolProxy()
 
-    def llm(prompt, *, model="default", system=None, schema=None):
-        """Oneshot, stateless LLM call against a model tier.
+    def completion(prompt, *, model="default", system=None, schema=None):
+        """Oneshot, stateless completion against a model tier.
 
         `model` selects a tier: "smol", "default" (the session's active model),
         or "slow". Pass `system` for a system prompt. Pass a JSON-Schema dict
@@ -476,7 +515,7 @@ if "__omp_prelude_loaded__" not in globals():
             args["system"] = system
         if schema is not None:
             args["schema"] = schema
-        res = _bridge_call("__llm__", args)
+        res = _bridge_call("__completion__", args)
         text = res.get("text") if isinstance(res, dict) else res
         return json.loads(text) if schema is not None else text
 

package/src/eval/py/runner.py

@@ -819,6 +819,7 @@ _MANAGED_ENV_KEYS = (
     "PI_TOOL_BRIDGE_URL",
     "PI_TOOL_BRIDGE_TOKEN",
     "PI_TOOL_BRIDGE_SESSION",
+    "PI_EVAL_LOCAL_ROOTS",
 )
 
 

package/src/exa/render.ts

@@ -93,7 +93,7 @@ export function renderExaResult(
 	const cost = response.costDollars?.total;
 	const time = response.searchTime;
 
-	const icon = formatStatusIcon(resultCount > 0 ? "success" : "warning", uiTheme);
+	const icon = resultCount > 0 ? uiTheme.styledSymbol("tool.exa", "accent") : formatStatusIcon("warning", uiTheme);
 
 	const metaParts = [formatCount("result", resultCount)];
 	if (cost !== undefined) metaParts.push(`cost:$${cost.toFixed(4)}`);

package/src/export/ttsr.ts

@@ -5,6 +5,8 @@
  * the agent's output. When a match occurs, the stream is aborted, the rule is
  * injected as a system reminder, and the request is retried.
  */
+import * as path from "node:path";
+import { AstMatchStrictness, astMatch } from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
 import type { TtsrSettings } from "../config/settings";
@@ -38,6 +40,8 @@ interface TtsrScope {
 interface TtsrEntry {
 	rule: Rule;
 	conditions: RegExp[];
+	/** ast-grep pattern strings; matched only against edit/write tool snapshots. */
+	astConditions: string[];
 	scope: TtsrScope;
 	globalPathGlobs?: Bun.Glob[];
 }
@@ -70,6 +74,8 @@ export class TtsrManager {
 	readonly #rules = new Map<string, TtsrEntry>();
 	readonly #injectionRecords = new Map<string, InjectionRecord>();
 	readonly #buffers = new Map<string, string>();
+	/** Last snapshot evaluated for AST conditions, keyed by stream key, to dedupe matcher runs. */
+	readonly #lastAstSnapshots = new Map<string, string>();
 	#messageCount = 0;
 
 	constructor(settings?: TtsrSettings) {
@@ -302,7 +308,8 @@ export class TtsrManager {
 		}
 
 		const conditions = this.#compileConditions(rule);
-		if (conditions.length === 0) {
+		const astConditions = (rule.astCondition ?? []).map(pattern => pattern.trim()).filter(p => p.length > 0);
+		if (conditions.length === 0 && astConditions.length === 0) {
 			return false;
 		}
 
@@ -318,6 +325,7 @@ export class TtsrManager {
 		this.#rules.set(rule.name, {
 			rule,
 			conditions,
+			astConditions,
 			scope,
 			globalPathGlobs,
 		});
@@ -325,6 +333,7 @@ export class TtsrManager {
 		logger.debug("TTSR rule registered", {
 			ruleName: rule.name,
 			conditions: rule.condition,
+			astConditions: rule.astCondition,
 			scope: rule.scope,
 			globs: rule.globs,
 		});
@@ -359,6 +368,112 @@ export class TtsrManager {
 		return this.#matchBuffer(snapshot, context);
 	}
 
+	/** Derive an ast-grep language alias from candidate paths (bare extension, e.g. "ts"), if any. */
+	#deriveLang(filePaths: string[] | undefined): string | undefined {
+		for (const filePath of filePaths ?? []) {
+			const ext = path.extname(this.#normalizePath(filePath));
+			if (ext.length > 1) {
+				return ext.slice(1).toLowerCase();
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * Evaluate ast-grep `astCondition` rules against a reconstructed tool snapshot.
+	 *
+	 * Only edit/write tool streams reach here (AST conditions need a language, which
+	 * we infer from the file extension on the tool's path argument). The snapshot is
+	 * matched in memory by the native engine (`astMatch`), so this is async and
+	 * intentionally throttled: identical consecutive snapshots (the common case when
+	 * only non-source arguments change between deltas) are skipped.
+	 */
+	async checkAstSnapshot(snapshot: string, context: TtsrMatchContext): Promise<Rule[]> {
+		if (!this.#settings.enabled || context.source !== "tool") {
+			return [];
+		}
+
+		const lang = this.#deriveLang(context.filePaths);
+		if (!lang) {
+			return [];
+		}
+
+		const candidates: TtsrEntry[] = [];
+		for (const [name, entry] of this.#rules) {
+			if (entry.astConditions.length === 0) {
+				continue;
+			}
+			if (
+				!this.#canTrigger(name) ||
+				!this.#matchesScope(entry, context) ||
+				!this.#matchesGlobalPaths(entry, context)
+			) {
+				continue;
+			}
+			candidates.push(entry);
+		}
+		if (candidates.length === 0) {
+			return [];
+		}
+
+		// Throttle: skip re-running the matcher when the source content is unchanged.
+		const bufferKey = this.#bufferKey(context);
+		if (this.#lastAstSnapshots.get(bufferKey) === snapshot) {
+			return [];
+		}
+		this.#lastAstSnapshots.set(bufferKey, snapshot);
+
+		const matches: Rule[] = [];
+		for (const entry of candidates) {
+			if (await this.#astConditionsMatch(entry.astConditions, snapshot, lang)) {
+				matches.push(entry.rule);
+				logger.debug("TTSR ast condition matched", {
+					ruleName: entry.rule.name,
+					astConditions: entry.rule.astCondition,
+					toolName: context.toolName,
+					filePaths: context.filePaths,
+				});
+			}
+		}
+		return matches;
+	}
+
+	async #astConditionsMatch(patterns: string[], source: string, lang: string): Promise<boolean> {
+		try {
+			const result = await astMatch({
+				patterns,
+				source,
+				lang,
+				strictness: AstMatchStrictness.Smart,
+				limit: 1,
+			});
+			if (result.parseErrors && result.parseErrors.length > 0) {
+				logger.debug("TTSR ast match reported parse errors", { parseErrors: result.parseErrors });
+			}
+			return result.totalMatches > 0;
+		} catch (error) {
+			logger.warn("TTSR ast match failed, treating as no match", {
+				patterns,
+				lang,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return false;
+		}
+	}
+
+	/** True when any registered rule carries ast-grep conditions. */
+	hasAstRules(): boolean {
+		if (!this.#settings.enabled) {
+			return false;
+		}
+		for (const entry of this.#rules.values()) {
+			if (entry.astConditions.length > 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	#matchBuffer(buffer: string, context: TtsrMatchContext): Rule[] {
 		if (!this.#settings.enabled) {
 			return [];
@@ -435,6 +550,7 @@ export class TtsrManager {
 	/** Reset stream buffers (called on new turn). */
 	resetBuffer(): void {
 		this.#buffers.clear();
+		this.#lastAstSnapshots.clear();
 	}
 
 	/** Check if any TTSR rules are registered. */
@@ -445,6 +561,11 @@ export class TtsrManager {
 		return this.#rules.size > 0;
 	}
 
+	/** All rules currently registered for TTSR monitoring, in registration order. */
+	getRules(): Rule[] {
+		return Array.from(this.#rules.values(), entry => entry.rule);
+	}
+
 	/** Increment message counter (call after each turn). */
 	incrementMessageCount(): void {
 		this.#messageCount++;

package/src/extensibility/extensions/types.ts

@@ -28,7 +28,7 @@ import type {
 	TextContent,
 	TSchema,
 } from "@oh-my-pi/pi-ai";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
@@ -1134,6 +1134,13 @@ export interface ProviderConfig {
 		/** Optional model rewrite hook for credential-aware routing (e.g., enterprise URLs). */
 		modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
 	};
+	/**
+	 * Async factory that fetches the live model list from the provider endpoint.
+	 * Runs through the same SQLite model-cache as built-in providers (keyed by
+	 * provider name, default 24 h TTL). Receives the resolved API key (undefined
+	 * when unauthenticated). Mutually exclusive with `models`.
+	 */
+	fetchDynamicModels?: (apiKey: string | undefined) => Promise<readonly ProviderModelConfig[]>;
 }
 
 /** Configuration for a model within a provider. */

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -8,7 +8,7 @@
  * entrypoint. Legacy extensions still author parameter schemas as
  * `Type.Object({ ... })`, so this file is served by `legacy-pi-compat.ts` in
  * place of the real pi-ai entrypoint whenever a legacy extension imports the
- * bare package root. Subpath imports (`@oh-my-pi/pi-ai/utils/oauth`, etc.)
+ * bare package root. Subpath imports (`@oh-my-pi/pi-ai/oauth`, etc.)
  * continue to resolve directly against the bundled pi-ai package.
  *
  * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that

package/src/extensibility/plugins/doctor.ts

@@ -48,7 +48,7 @@ export function formatDoctorResults(checks: DoctorCheck[]): string {
 	for (const check of checks) {
 		const icon =
 			check.status === "ok"
-				? theme.status.success
+				? theme.status.enabled
 				: check.status === "warning"
 					? theme.status.warning
 					: theme.status.error;

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

@@ -33,10 +33,11 @@ const PI_PACKAGE_ALTERNATION = PI_PACKAGE_NAMES.join("|");
 // bundled copy. Add new entries as `pkg/from -> pkg/to` whenever a plugin
 // surfaces another upstream-only subpath that breaks resolution.
 const PI_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
-	// `@mariozechner/pi-ai/oauth` re-exported `./utils/oauth/index.js`.
-	// Our pi-ai keeps the implementation under `utils/oauth` but never added a
-	// root-level re-export, so map the upstream subpath onto it directly.
-	["pi-ai/oauth", "pi-ai/utils/oauth"],
+	// (currently empty) Upstream `@mariozechner/pi-ai/oauth` re-exported
+	// `./utils/oauth/index.js`. Our pi-ai now exposes the same surface at the
+	// real `@oh-my-pi/pi-ai/oauth` export, so the legacy subpath canonicalizes
+	// straight to it with no rewrite. Add `from -> to` entries here whenever a
+	// future upstream-only subpath surfaces that breaks resolution.
 ]);
 
 const LEGACY_PI_SPECIFIER_FILTER = new RegExp(`^@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/.*)?$`);
@@ -119,7 +120,7 @@ const TYPEBOX_SHIM_PATH = BUNFS_PACKAGE_ROOT
 // longer satisfies those imports. The override below redirects only the bare
 // pi-ai package root onto a sibling shim that re-exports the canonical surface
 // plus the borrowed `Type` runtime from the Zod-backed TypeBox shim. Subpath
-// imports such as `@oh-my-pi/pi-ai/utils/oauth` continue to resolve directly
+// imports such as `@oh-my-pi/pi-ai/oauth` continue to resolve directly
 // against the bundled pi-ai package.
 const LEGACY_PI_AI_SHIM_PATH = BUNFS_PACKAGE_ROOT
 	? bunfsPath("coding-agent", "src", "extensibility", "legacy-pi-ai-shim.js")

package/src/goals/tools/goal-tool.ts

@@ -209,7 +209,7 @@ export const goalToolRenderer = {
 
 		const header = renderStatusLine(
 			{
-				icon: "success",
+				iconOverride: uiTheme.styledSymbol("tool.goal", "accent"),
 				title: "Goal",
 				description,
 				badge: { label: goal.status, color: goalBadgeColor(goal.status) },