@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.5

package/src/cli/plugin-cli.ts

@@ -354,6 +354,7 @@ async function handleInstall(
 		console.error(chalk.dim(`  ${APP_NAME} plugin install name@marketplace`));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install github:user/repo`));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install https://github.com/user/repo#v1.0`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install ./path/to/local/plugin`));
 		process.exit(1);
 	}
 
@@ -382,6 +383,49 @@ async function handleInstall(
 			continue;
 		}
 
+		if (target.type === "local") {
+			// Local paths route to link(): symlink the directory into the plugins
+			// node_modules tree so source edits show up without a reinstall. Matches
+			// `omp plugin link <path>` so users can use either verb interchangeably.
+			if (flags.scope) {
+				console.error(
+					chalk.yellow(
+						`Warning: --scope is only supported for marketplace installs (name@marketplace). Ignoring for ${spec}.`,
+					),
+				);
+			}
+			if (flags.force) {
+				console.error(
+					chalk.yellow(
+						`Warning: --force has no effect for local path installs (link is already idempotent). Ignoring for ${spec}.`,
+					),
+				);
+			}
+			if (flags.dryRun) {
+				if (flags.json) {
+					console.log(JSON.stringify({ dryRun: true, action: "link", path: target.path }, null, 2));
+				} else {
+					console.log(chalk.dim(`[dry-run] Would link ${spec}`));
+				}
+				continue;
+			}
+			try {
+				const result = await manager.link(target.path);
+				if (flags.json) {
+					console.log(JSON.stringify(result, null, 2));
+				} else {
+					console.log(chalk.green(`${theme.status.success} Linked ${result.name} from ${spec}`));
+					if (result.manifest.description) {
+						console.log(chalk.dim(`  ${result.manifest.description}`));
+					}
+				}
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to install ${spec}: ${err}`));
+				process.exit(1);
+			}
+			continue;
+		}
+
 		// --scope only applies to marketplace installs; warn when it would be silently no-op'd for npm.
 		if (flags.scope) {
 			console.error(
@@ -923,6 +967,7 @@ ${chalk.bold("Sources:")}
   github:user/repo[#ref]          GitHub shorthand (also gitlab:, bitbucket:, codeberg:, sourcehut:)
   https://github.com/user/repo    Full git URL (https, ssh, or git protocol)
   name@marketplace                Marketplace plugin (see marketplace command)
+  ./path, ../path, /abs, ~/path   Local plugin directory (symlinked, same as plugin link)
 
 ${chalk.bold("Config Subcommands:")}
   config list <pkg>              List all settings

package/src/cli/web-search-cli.ts

@@ -97,7 +97,6 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	const result = await runSearchQuery(params);
 	const component = renderSearchResult(result, { expanded: cmd.expanded, isPartial: false }, theme, {
 		query: cmd.query,
-		allowLongAnswer: true,
 		maxAnswerLines: cmd.expanded ? undefined : 6,
 	});
 

package/src/config/model-registry.ts

@@ -38,6 +38,45 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 // "socket connection was closed unexpectedly").
 const DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
 
+const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+const OLLAMA_HOST_DEFAULT_PORT = "11434";
+
+function normalizeOllamaHostEnv(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	const candidate = trimmed.includes("://")
+		? trimmed
+		: trimmed.startsWith("//")
+			? `http:${trimmed}`
+			: trimmed.startsWith(":")
+				? `http://127.0.0.1${trimmed}`
+				: `http://${trimmed}`;
+	try {
+		const parsed = new URL(candidate);
+		if (!parsed.hostname || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+			return undefined;
+		}
+		if (!parsed.port && parsed.protocol === "http:") {
+			parsed.port = OLLAMA_HOST_DEFAULT_PORT;
+		}
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return undefined;
+	}
+}
+
+function getImplicitOllamaBaseUrl(): string {
+	const baseUrl = Bun.env.OLLAMA_BASE_URL?.trim();
+	return baseUrl || normalizeOllamaHostEnv(Bun.env.OLLAMA_HOST) || DEFAULT_OLLAMA_BASE_URL;
+}
+
+function getOllamaContextLengthOverride(): number | undefined {
+	const value = Bun.env.OLLAMA_CONTEXT_LENGTH?.trim();
+	if (!value) return undefined;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 // Anthropic-safe variant of the discovery cap. The Anthropic stream converter
 // in `packages/ai/src/providers/anthropic.ts` derives the request limit as
 // `(model.maxTokens / 3) | 0`, so the 32K default would surface as 10,922
@@ -1220,7 +1259,18 @@ export class ModelRegistry {
 			return models;
 		}
 
-		return models.map(model => (model.api === "openai-completions" ? { ...model, api: "openai-responses" } : model));
+		const contextLengthOverride = getOllamaContextLengthOverride();
+		return models.map(model => {
+			const normalized = model.api === "openai-completions" ? { ...model, api: "openai-responses" as const } : model;
+			if (contextLengthOverride === undefined) {
+				return normalized;
+			}
+			return {
+				...normalized,
+				contextWindow: contextLengthOverride,
+				maxTokens: Math.min(contextLengthOverride, DISCOVERY_DEFAULT_MAX_TOKENS),
+			};
+		});
 	}
 
 	#addImplicitDiscoverableProviders(configuredProviders: Set<string>): void {
@@ -1229,7 +1279,7 @@ export class ModelRegistry {
 			this.#discoverableProviders.push({
 				provider: "ollama",
 				api: "openai-responses",
-				baseUrl: Bun.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434",
+				baseUrl: getImplicitOllamaBaseUrl(),
 				discovery: { type: "ollama" },
 				optional: true,
 			});
@@ -1993,12 +2043,12 @@ export class ModelRegistry {
 		}
 	}
 	#normalizeOllamaBaseUrl(baseUrl?: string): string {
-		const raw = baseUrl || "http://127.0.0.1:11434";
+		const raw = baseUrl || DEFAULT_OLLAMA_BASE_URL;
 		try {
 			const parsed = new URL(raw);
 			return `${parsed.protocol}//${parsed.host}`;
 		} catch {
-			return "http://127.0.0.1:11434";
+			return DEFAULT_OLLAMA_BASE_URL;
 		}
 	}
 

package/src/config/settings-schema.ts

@@ -635,7 +635,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "appearance",
 			label: "Terminal Hyperlinks",
 			description:
-				"Wrap file paths in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
+				"Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
 		},
 	},
 	// Display rendering
@@ -722,6 +722,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	includeModelInPrompt: {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			label: "Include Model In Prompt",
+			description: "Surface the active model identifier in the system prompt so the agent knows which model it is",
+		},
+	},
+
 	// Sampling
 	temperature: {
 		type: "number",
@@ -2483,13 +2493,13 @@ export const SETTINGS_SCHEMA = {
 	// Tool Discovery
 	"tools.discoveryMode": {
 		type: "enum",
-		values: ["off", "mcp-only", "all"] as const,
-		default: "off",
+		values: ["auto", "off", "mcp-only", "all"] as const,
+		default: "auto",
 		ui: {
 			tab: "tools",
 			label: "Tool Discovery",
 			description:
-				"Hide tools behind a search tool to save tokens. 'mcp-only' hides MCP tools; 'all' hides all non-essential built-ins too.",
+				"Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.",
 		},
 	},
 

package/src/eval/__tests__/agent-bridge.test.ts

@@ -397,6 +397,78 @@ describe("agent() through eval runtimes", () => {
 		expect(maxInFlight).toBeLessThanOrEqual(2);
 	});
 
+	it("interrupting a Python parallel() fan-out settles the kernel cleanly and preserves session state", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-interrupt-");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 6,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-interrupt", settings);
+		mockAgents();
+		// Subagents that ignore the abort for far longer than the kernel's SIGINT
+		// escalation window. Each kernel worker thread blocks in a synchronous
+		// `urllib` bridge call, joined by `parallel()`'s ThreadPoolExecutor exit.
+		// The host must respond the instant the cell aborts so the kernel can
+		// unwind via KeyboardInterrupt instead of being hard-killed (which used to
+		// surface "[kernel] Python kernel shutdown" and lose all session state).
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			await Bun.sleep(9000); // deliberately ignores options.signal
+			return singleResult(options, { output: options.assignment ?? "" });
+		});
+
+		// Seed persistent session state and confirm the kernel is reusable.
+		const seed = await executePython("PREP_MARKER = 4242", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		if (seed.exitCode === undefined && seed.cancelled) {
+			expect(seed.output).toBe("");
+			return; // kernel unavailable in this environment
+		}
+		expect(seed.exitCode).toBe(0);
+
+		const ac = new AbortController();
+		// Abort ~1s in, after the worker threads are blocked in their bridge calls.
+		setTimeout(() => ac.abort(new Error("external interrupt")), 1000);
+
+		const start = Date.now();
+		const result = await executePython(
+			"import json\nprint(json.dumps(parallel([lambda n=n: agent(str(n)) for n in range(12)])))",
+			{
+				cwd: tempDir.path(),
+				sessionId,
+				sessionFile,
+				kernelMode: "session",
+				toolSession: session,
+				idleTimeoutMs: 60_000,
+				signal: ac.signal,
+			},
+		);
+		const elapsed = Date.now() - start;
+
+		// Cancelled, but cleanly: no hard-kill, settled well within the kernel's 5s
+		// SIGINT escalation window rather than ~6s after it.
+		expect(result.cancelled).toBe(true);
+		expect(result.output).not.toContain("Python kernel shutdown");
+		expect(elapsed).toBeLessThan(4000);
+
+		// The persistent kernel survived the interrupt: prior state is intact.
+		const after = await executePython("print(PREP_MARKER)", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		expect(after.exitCode).toBe(0);
+		expect(after.output.trim()).toBe("4242");
+	}, 30_000);
+
 	it("streams enriched agent progress through onStatus before the cell finishes", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-progress-");
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-progress");

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

@@ -30,6 +30,48 @@ interface BridgeServer {
 const registrations = new Map<string, PyToolBridgeEntry>();
 let serverPromise: Promise<BridgeServer> | null = null;
 
+/**
+ * Forward a bridge call to {@link callSessionTool}, but resolve the HTTP request
+ * the instant the cell's signal aborts instead of waiting for the tool/subagent
+ * to fully tear down.
+ *
+ * The kernel invokes this bridge with a *blocking* `urllib` request from a
+ * worker thread (each `agent()` / `tool.*` call). When the cell is interrupted,
+ * `parallel()`'s `ThreadPoolExecutor.__exit__` joins those worker threads
+ * (`shutdown(wait=True)`), so they cannot unwind until their `urllib` call
+ * returns — i.e. until this handler responds. A host-side `agent()` teardown
+ * (aborting nested LLM streams + tools across a wide fan-out) routinely exceeds
+ * the kernel's SIGINT escalation window, so the kernel was hard-killed and its
+ * persistent state lost while the subagents were still winding down. Responding
+ * immediately on abort lets the kernel raise through the blocked call and settle
+ * cleanly (preserving state); the already-signaled call keeps tearing down in
+ * the background, its eventual result/rejection swallowed.
+ */
+async function callSessionToolPromptOnAbort(name: string, args: unknown, entry: PyToolBridgeEntry): Promise<unknown> {
+	const call = callSessionTool(name, args, {
+		session: entry.toolSession,
+		signal: entry.signal,
+		emitStatus: entry.emitStatus,
+	});
+	const signal = entry.signal;
+	if (!signal) return await call;
+	if (signal.aborted) {
+		void call.catch(() => {});
+		throw new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`);
+	}
+	const { promise: aborted, reject } = Promise.withResolvers<never>();
+	const onAbort = () => reject(new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`));
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([call, aborted]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		// `call` may still be settling (subagent teardown after its own abort);
+		// swallow its outcome so an abort-won race can't surface as unhandled.
+		void call.catch(() => {});
+	}
+}
+
 async function startServer(): Promise<BridgeServer> {
 	const token = crypto.randomUUID();
 	const server = Bun.serve({
@@ -66,11 +108,7 @@ async function startServer(): Promise<BridgeServer> {
 			}
 
 			try {
-				const value = await callSessionTool(name, body.args, {
-					session: entry.toolSession,
-					signal: entry.signal,
-					emitStatus: entry.emitStatus,
-				});
+				const value = await callSessionToolPromptOnAbort(name, body.args, entry);
 				return Response.json({ ok: true, value });
 			} catch (err) {
 				return Response.json({

package/src/extensibility/custom-commands/bundled/ci-green/index.ts

@@ -12,6 +12,35 @@ async function getHeadTag(api: CustomCommandAPI): Promise<string | undefined> {
 	}
 }
 
+async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
+	try {
+		return (await git.branch.current(api.cwd)) ?? "HEAD";
+	} catch {
+		return "HEAD";
+	}
+}
+
+async function getPushRemote(api: CustomCommandAPI, branch: string): Promise<string | undefined> {
+	try {
+		return (
+			(await git.config.getBranch(api.cwd, branch, "pushRemote")) ??
+			(await git.config.getBranch(api.cwd, branch, "remote"))
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+async function getHeadTagContext(api: CustomCommandAPI): Promise<{ branch: string; headTag?: string; remote: string }> {
+	const branch = await getCurrentBranch(api);
+	const [headTag, pushRemote] = await Promise.all([getHeadTag(api), getPushRemote(api, branch)]);
+	return {
+		headTag,
+		branch,
+		remote: pushRemote ?? "origin",
+	};
+}
+
 export class GreenCommand implements CustomCommand {
 	name = "green";
 	description = "Generate a prompt to iterate on CI failures until the branch is green";
@@ -19,7 +48,7 @@ export class GreenCommand implements CustomCommand {
 	constructor(private api: CustomCommandAPI) {}
 
 	async execute(_args: string[], _ctx: HookCommandContext): Promise<string> {
-		const headTag = await getHeadTag(this.api);
-		return prompt.render(ciGreenRequestTemplate, { headTag });
+		const { headTag, branch, remote } = await getHeadTagContext(this.api);
+		return prompt.render(ciGreenRequestTemplate, { headTag, branch, remote });
 	}
 }