@oh-my-pi/pi-coding-agent 16.0.7 → 16.0.9

package/src/cli/flag-tables.ts

@@ -270,6 +270,7 @@ export const VALUELESS_FLAGS: ReadonlySet<string> = new Set([
 	"--hide-thinking",
 	"--advisor",
 	"--print",
+	"--print-thoughts",
 	"--no-extensions",
 	"--no-skills",
 	"--no-rules",

package/src/cli/update-cli.ts

@@ -370,13 +370,64 @@ async function unlinkIfExists(filePath: string): Promise<void> {
 	}
 }
 
+/**
+ * Remove a backup binary without letting the removal abort a completed update.
+ *
+ * On Windows the executable that was just moved aside is still mapped as the
+ * running process image, so unlinking it fails with EPERM/EACCES until this
+ * process exits (issue #845). The replacement and verification already
+ * succeeded by the time we get here, so every error is swallowed; the leftover
+ * is reclaimed by {@link sweepStaleBackups} on the next update once it is no
+ * longer in use. Returns whether the file is gone.
+ */
+async function removeBackupBestEffort(filePath: string): Promise<boolean> {
+	try {
+		await fs.promises.unlink(filePath);
+		return true;
+	} catch (err) {
+		return isEnoent(err);
+	}
+}
+
+/**
+ * Best-effort removal of binary-update backups left by earlier runs.
+ *
+ * Each self-update moves the previous executable to `<binary>.<timestamp>.<pid>.bak`
+ * before swapping the new one in. On Windows that backup cannot be deleted
+ * while the updating process is alive, so it is left for a later run to reclaim
+ * once its owning process has exited. Also matches the legacy fixed
+ * `<binary>.bak` name produced before backups were timestamped, so users
+ * upgrading from a buggy release get the orphaned file cleaned up.
+ */
+export async function sweepStaleBackups(targetPath: string): Promise<void> {
+	const dir = path.dirname(targetPath);
+	const base = path.basename(targetPath);
+	let entries: string[];
+	try {
+		entries = await fs.promises.readdir(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.startsWith(`${base}.`) || !entry.endsWith(".bak")) continue;
+		// Legacy "<base>.bak" → empty middle; new "<base>.<timestamp>.<pid>.bak"
+		// → dot-separated numeric run. Anything else is an unrelated *.bak file.
+		const middle = entry.slice(base.length + 1, entry.length - ".bak".length);
+		if (middle.length > 0 && !/^\d+(\.\d+)*$/.test(middle)) continue;
+		await removeBackupBestEffort(path.join(dir, entry));
+	}
+}
+
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */
 export async function replaceBinaryForUpdate(options: BinaryReplacementOptions): Promise<InstalledVersionVerification> {
 	let backupReady = false;
 	try {
-		await unlinkIfExists(options.backupPath);
+		// `backupPath` is unique per attempt (see updateViaBinaryAt), so this rename
+		// never has to overwrite — or unlink — a possibly-locked leftover from an
+		// earlier run. Renaming the running executable itself is permitted on
+		// Windows; only deleting its still-mapped image is not.
 		await fs.promises.rename(options.targetPath, options.backupPath);
 		backupReady = true;
 		await fs.promises.rename(options.tempPath, options.targetPath);
@@ -389,7 +440,10 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 		}
 
 		backupReady = false;
-		await unlinkIfExists(options.backupPath);
+		// Swap done and verified. On Windows the backup is still the running
+		// process image and cannot be unlinked until this process exits, so a
+		// failure here must NOT fail an otherwise-successful update.
+		await removeBackupBestEffort(options.backupPath);
 		return verification;
 	} catch (err) {
 		if (backupReady) {
@@ -517,7 +571,11 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 	const url = `https://github.com/${REPO}/releases/download/${tag}/${binaryName}`;
 
 	const tempPath = `${targetPath}.new`;
-	const backupPath = `${targetPath}.bak`;
+	// Unique per attempt: a stale backup from an earlier update may still be
+	// locked (it is the previous process image on Windows), and a fixed name
+	// would force the move-aside rename to overwrite it. pid + timestamp keeps
+	// two forced updates in the same millisecond from colliding.
+	const backupPath = `${targetPath}.${Date.now()}.${process.pid}.bak`;
 	console.log(chalk.dim(`Downloading ${binaryName}…`));
 
 	const response = await fetch(url, { redirect: "follow" });
@@ -535,6 +593,8 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 		expectedVersion,
 		verifyInstalledVersion,
 	});
+	// Reclaim backups from earlier updates whose owning process has since exited.
+	await sweepStaleBackups(targetPath);
 	printVerifiedVersion(expectedVersion);
 	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
 }

package/src/commands/launch.ts

@@ -136,6 +136,9 @@ export default class Index extends Command {
 		"no-title": Flags.boolean({
 			description: "Disable title auto-generation",
 		}),
+		"print-thoughts": Flags.boolean({
+			description: "Include thinking blocks in print mode text output",
+		}),
 		"max-time": Flags.string({
 			description: "Stop the session after this many seconds",
 		}),

package/src/config/model-discovery.ts

@@ -13,6 +13,7 @@ import {
 	resolveModelReference,
 	stripBracketedModelIdAffixes,
 } from "@oh-my-pi/pi-catalog/identity";
+import { fetchLmStudioNativeModelMetadata } from "@oh-my-pi/pi-catalog/provider-models/openai-compat";
 import type { ModelSpec } from "@oh-my-pi/pi-catalog/types";
 import { isRecord } from "@oh-my-pi/pi-utils";
 import type { ProviderDiscovery } from "./models-config-schema";
@@ -379,18 +380,25 @@ export async function discoverOpenAIModelsList(
 	const baseHeaders: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 	let headers = baseHeaders;
 	const attempt = async (h: Record<string, string>) => {
-		const res = await ctx.fetch(modelsUrl, {
-			headers: h,
-			signal: AbortSignal.timeout(10_000),
-		});
+		const nativeMetadataPromise =
+			providerConfig.discovery.type === "lm-studio"
+				? fetchLmStudioNativeModelMetadata(baseUrl, ctx.fetch, { headers: h })
+				: Promise.resolve(null);
+		const [res, nativeMetadata] = await Promise.all([
+			ctx.fetch(modelsUrl, {
+				headers: h,
+				signal: AbortSignal.timeout(10_000),
+			}),
+			nativeMetadataPromise,
+		]);
 		if (!res.ok) {
 			throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
 		}
 		headers = h;
-		return res;
+		return [res, nativeMetadata] as const;
 	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const response = apiKey
+	const [response, nativeMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
 	const payload = (await response.json()) as {
@@ -401,8 +409,12 @@ export async function discoverOpenAIModelsList(
 	for (const item of models) {
 		const id = item.id;
 		if (!id) continue;
+		const nativeMetadataForModel = nativeMetadata?.get(id);
 		const contextWindow =
-			toPositiveNumberOrUndefined(item.max_model_len) ?? toPositiveNumberOrUndefined(item.context_length) ?? 128000;
+			toPositiveNumberOrUndefined(item.max_model_len) ??
+			toPositiveNumberOrUndefined(item.context_length) ??
+			nativeMetadataForModel?.contextWindow ??
+			128000;
 		discovered.push(
 			buildModel({
 				id,
@@ -411,7 +423,7 @@ export async function discoverOpenAIModelsList(
 				provider: providerConfig.provider,
 				baseUrl,
 				reasoning: false,
-				input: ["text"],
+				input: nativeMetadataForModel?.input ?? ["text"],
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow,
 				maxTokens: Math.min(contextWindow, discoveryDefaultMaxTokens(providerConfig.api)),

package/src/config/models-config-schema.ts

@@ -1,4 +1,11 @@
-import { type } from "arktype";
+import { scope } from "arktype";
+
+// Config schemas validate at most a handful of times per process (on config
+// load), so the eager JIT codegen ArkType runs at definition time is pure
+// startup tax. A local jitless scope skips that codegen and falls back to
+// interpreted traversal — ~65% cheaper to construct, validation correctness
+// unchanged. (No `name`: duplicate module instances would collide.)
+const { type } = scope({}, { jitless: true });
 
 const OpenRouterRoutingSchema = type({
 	"only?": "string[]",

package/src/debug/index.ts

@@ -29,6 +29,7 @@ import { generateHeapSnapshotData, type ProfilerSession, startCpuProfile } from
 import { buildSampleImage, ProtocolProbeComponent } from "./protocol-probe";
 import { RawSseViewerComponent } from "./raw-sse";
 import { resolveRawSseDebugBuffer } from "./raw-sse-buffer";
+import { getRemoteDebugger, type RemoteDebuggerInfo, startRemoteDebuggerServer } from "./remote-debugger";
 import { clearArtifactCache, createDebugLogSource, createReportBundle, getArtifactCacheStats } from "./report-bundle";
 import { collectSystemInfo, formatSystemInfo } from "./system-info";
 import { collectTerminalState, formatTerminalState } from "./terminal-info";
@@ -49,6 +50,11 @@ const DEBUG_MENU_ITEMS: SelectItem[] = [
 		description: "Styling, links, text sizing, graphics, notify",
 	},
 	{ value: "raw-sse", label: "View: raw SSE stream", description: "Show live provider SSE frames" },
+	{
+		value: "remote-debugger",
+		label: "Start: JS remote debugger",
+		description: "Expose JavaScriptCore inspector socket (experimental)",
+	},
 	{
 		value: "transcript",
 		label: "Export: TUI transcript",
@@ -122,6 +128,9 @@ export class DebugSelectorComponent extends Container {
 			case "raw-sse":
 				await this.#handleViewRawSse();
 				break;
+			case "remote-debugger":
+				await this.#handleStartRemoteDebugger();
+				break;
 			case "system":
 				await this.#handleViewSystemInfo();
 				break;
@@ -353,6 +362,41 @@ export class DebugSelectorComponent extends Container {
 		this.ctx.ui.requestRender();
 	}
 
+	async #handleStartRemoteDebugger(): Promise<void> {
+		const existing = getRemoteDebugger();
+		let info: RemoteDebuggerInfo;
+		try {
+			info = existing ?? (await startRemoteDebuggerServer());
+		} catch (err) {
+			this.ctx.showError(`Failed to start remote debugger: ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
+
+		const block = new TranscriptBlock();
+		block.addChild(
+			new Text(
+				theme.fg(
+					"success",
+					`${theme.status.success} JavaScriptCore remote inspector ${existing ? "already running" : "started"}`,
+				),
+				1,
+				0,
+			),
+		);
+		block.addChild(new Text(theme.fg("dim", `Listening on ${info.host}:${info.port}`), 1, 0));
+		block.addChild(
+			new Text(
+				theme.fg(
+					"muted",
+					"Experimental WebKit RemoteInspectorServer socket (Bun marks it untested on macOS). One-way for this process — there is no stop. Attach a compatible WebKit/Safari Web Inspector client.",
+				),
+				1,
+				0,
+			),
+		);
+		this.ctx.present(block);
+	}
+
 	async #handleViewSystemInfo(): Promise<void> {
 		try {
 			const info = await collectSystemInfo();

package/src/debug/remote-debugger.ts

@@ -0,0 +1,151 @@
+/**
+ * Bun JavaScriptCore remote inspector control.
+ *
+ * Wraps `bun:jsc`'s `startRemoteDebugger`, which exposes JavaScriptCore's
+ * built-in WebKit RemoteInspectorServer over a raw socket. The API is one-shot
+ * and rough around the edges (Bun documents it as untested, "may not be
+ * supported yet on macOS"):
+ *   - it returns `void` and has no stop handle, so we track the live endpoint
+ *     at module scope and make starting idempotent;
+ *   - it rejects port `0`, so "let the OS pick" is implemented by reserving a
+ *     free port via `node:net` and handing the concrete number to Bun;
+ *   - on macOS (Bun 1.3.x) it throws a spurious "port already in use" error
+ *     even when the server binds fine, so success is decided by a loopback
+ *     probe rather than by whether the call threw.
+ */
+
+import { startRemoteDebugger } from "bun:jsc";
+import * as net from "node:net";
+
+const DEFAULT_HOST = "127.0.0.1";
+/** How long to keep probing for the inspector socket before giving up. */
+const PROBE_DEADLINE_MS = 1000;
+const PROBE_INTERVAL_MS = 50;
+
+export interface RemoteDebuggerInfo {
+	host: string;
+	port: number;
+}
+
+let active: RemoteDebuggerInfo | null = null;
+/** In-flight start, shared so concurrent callers coalesce onto one launch. */
+let starting: Promise<RemoteDebuggerInfo> | null = null;
+
+/** Underlying starter signature; tests inject a disposable listener in its place. */
+export type RemoteDebuggerStarter = (host: string, port: number) => void;
+
+export interface StartRemoteDebuggerOptions {
+	/** Explicit port; when omitted a free port is reserved automatically. */
+	port?: number;
+	/** Override the JSC starter. Defaults to `bun:jsc`'s `startRemoteDebugger`. */
+	start?: RemoteDebuggerStarter;
+}
+
+/** The live inspector endpoint for this process, or `null` if not started. */
+export function getRemoteDebugger(): RemoteDebuggerInfo | null {
+	return active;
+}
+
+/** Reserve a free TCP port on `host` by binding to `0`, then releasing it. */
+async function reserveFreePort(host: string): Promise<number> {
+	const server = net.createServer();
+	const listening = Promise.withResolvers<number>();
+	server.once("error", listening.reject);
+	server.listen(0, host, () => {
+		const addr = server.address();
+		if (addr && typeof addr === "object") listening.resolve(addr.port);
+		else listening.reject(new Error("Failed to reserve a debugger port"));
+	});
+	try {
+		return await listening.promise;
+	} finally {
+		const closed = Promise.withResolvers<void>();
+		server.close(() => closed.resolve());
+		await closed.promise;
+	}
+}
+
+/** Resolve once `host:port` accepts a TCP connection (within one attempt). */
+function tryConnect(host: string, port: number, timeoutMs: number): Promise<boolean> {
+	const { promise, resolve } = Promise.withResolvers<boolean>();
+	const socket = net.createConnection({ host, port });
+	let settled = false;
+	const finish = (ok: boolean) => {
+		if (settled) return;
+		settled = true;
+		socket.destroy();
+		resolve(ok);
+	};
+	socket.setTimeout(timeoutMs);
+	socket.once("connect", () => finish(true));
+	socket.once("timeout", () => finish(false));
+	socket.once("error", () => finish(false));
+	return promise;
+}
+
+/** Poll the inspector socket until it accepts a connection or the deadline passes. */
+async function waitForListening(host: string, port: number): Promise<boolean> {
+	const deadline = Date.now() + PROBE_DEADLINE_MS;
+	do {
+		if (await tryConnect(host, port, PROBE_INTERVAL_MS)) return true;
+		await Bun.sleep(PROBE_INTERVAL_MS);
+	} while (Date.now() < deadline);
+	return false;
+}
+
+/**
+ * Start the JavaScriptCore remote inspector for this process and return its
+ * endpoint. Idempotent: the underlying API cannot be stopped or rebound, so a
+ * second call returns the existing endpoint instead of starting again. When
+ * `port` is omitted a free port is reserved automatically.
+ *
+ * Throws only when the socket never comes up; Bun's spurious bind error is
+ * swallowed and overridden by the loopback probe.
+ */
+export async function startRemoteDebuggerServer(options: StartRemoteDebuggerOptions = {}): Promise<RemoteDebuggerInfo> {
+	if (active) return active;
+	starting ??= launch(options);
+	try {
+		return await starting;
+	} finally {
+		starting = null;
+	}
+}
+
+async function launch({ port, start = startRemoteDebugger }: StartRemoteDebuggerOptions): Promise<RemoteDebuggerInfo> {
+	const host = DEFAULT_HOST;
+	const chosen = port ?? (await reserveFreePort(host));
+
+	// Something already on this port? Refuse up front: otherwise Bun throws a
+	// real bind error and our success probe would connect to that unrelated
+	// service, marking a bogus endpoint as the debugger.
+	if (await tryConnect(host, chosen, PROBE_INTERVAL_MS)) {
+		throw new Error(`Port ${host}:${chosen} is already in use; cannot start remote debugger there.`);
+	}
+
+	let thrown: unknown;
+	try {
+		start(host, chosen);
+	} catch (err) {
+		// Bun's startRemoteDebugger throws a spurious bind error even on success,
+		// so defer the verdict to the loopback probe below.
+		thrown = err;
+	}
+
+	if (await waitForListening(host, chosen)) {
+		active = { host, port: chosen };
+		return active;
+	}
+
+	throw thrown instanceof Error ? thrown : new Error(`Remote debugger socket never came up on ${host}:${chosen}`);
+}
+
+/**
+ * Test-only: forget the tracked endpoint so a fresh start can be exercised.
+ * Does not (and cannot) stop a real JSC inspector — callers in tests own the
+ * disposable listener they injected.
+ */
+export function __resetRemoteDebuggerForTests(): void {
+	active = null;
+	starting = null;
+}

package/src/debug/report-bundle.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { WorkProfile } from "@oh-my-pi/pi-natives";
 import { APP_NAME, getLogPath, getLogsDir, getReportsDir, isEnoent } from "@oh-my-pi/pi-utils";
+import { writeArchive } from "../utils/zip";
 import type { CpuProfile, HeapSnapshot } from "./profiler";
 import { collectSystemInfo, sanitizeEnv } from "./system-info";
 
@@ -165,7 +166,7 @@ export async function createReportBundle(options: ReportBundleOptions): Promise<
 	}
 
 	// Write archive
-	await Bun.Archive.write(outputPath, data, { compress: "gzip" });
+	await writeArchive(outputPath, "tar.gz", Object.entries(data));
 
 	return { path: outputPath, files };
 }

package/src/goals/runtime.ts

@@ -178,8 +178,8 @@ export class GoalRuntime {
 		}
 	}
 
-	#markActiveAccounting(goal: Goal): void {
-		if (this.#wallClock.activeGoalId !== goal.id) {
+	#markActiveAccounting(goal: Goal, resetWallClock = false): void {
+		if (resetWallClock || this.#wallClock.activeGoalId !== goal.id) {
 			this.#wallClock = { lastAccountedAt: this.#now(), activeGoalId: goal.id };
 		}
 		if (this.#turnSnapshot) {
@@ -195,6 +195,12 @@ export class GoalRuntime {
 		}
 	}
 
+	clearAccounting(): void {
+		this.#turnSnapshot = undefined;
+		this.#clearActiveAccounting();
+		this.#budgetReportedFor = undefined;
+	}
+
 	onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void {
 		this.#turnSnapshot = { turnId, baselineUsage: { ...baselineUsage } };
 		const state = this.#host.getState();
@@ -235,7 +241,7 @@ export class GoalRuntime {
 			return;
 		}
 		await this.#withAccounting(async () => {
-			await this.#flushUsageLocked("suppressed");
+			await this.#flushUsageLocked("suppressed", undefined, options?.reason === "internal");
 			this.#turnSnapshot = undefined;
 			if (options?.reason !== "interrupted") return;
 			const cloned = this.#getStateClone();
@@ -249,9 +255,14 @@ export class GoalRuntime {
 		});
 	}
 
-	async onThreadResumed(): Promise<GoalModeState | undefined> {
+	async onThreadResumed(options?: { preserveActiveGoal?: boolean }): Promise<GoalModeState | undefined> {
 		const state = this.#getStateClone();
 		if (!state) return undefined;
+		if (options?.preserveActiveGoal && state.enabled && state.goal.status === "active") {
+			this.#markActiveAccounting(state.goal, true);
+			await this.#commitState(state, { emit: true });
+			return state;
+		}
 		if (state.goal.status === "active") {
 			state.enabled = false;
 			state.goal.status = "paused";
@@ -301,6 +312,7 @@ export class GoalRuntime {
 	async #flushUsageLocked(
 		steering: GoalBudgetSteering,
 		currentUsage: GoalTokenUsage = this.#host.getCurrentUsage(),
+		persistWallClock = false,
 	): Promise<void> {
 		const state = this.#getStateClone();
 		if (!state?.enabled || !isAccountingStatus(state.goal)) return;
@@ -333,10 +345,10 @@ export class GoalRuntime {
 		if (this.#wallClock.activeGoalId === state.goal.id && wallSeconds > 0) {
 			this.#wallClock.lastAccountedAt += wallSeconds * 1000;
 		}
-
 		// Persisting wall-clock-only accounting on every tool event bloats /goal sessions with full
-		// objective snapshots. Keep the in-memory/UI state fresh, but persist only token/budget changes.
-		const shouldPersistUsage = tokenDelta > 0 || flippedToBudgetLimited;
+		// objective snapshots. Keep normal tool flushes in memory/UI only, but make wall-clock
+		// usage durable before internal session switches because the active runtime is leaving.
+		const shouldPersistUsage = tokenDelta > 0 || flippedToBudgetLimited || (persistWallClock && wallSeconds > 0);
 		await this.#commitState(state, { persist: shouldPersistUsage ? "goal" : undefined });
 
 		if (state.goal.status !== "budget-limited") {