@oh-my-pi/pi-coding-agent 17.3.4 → 17.3.7

package/dist/types/session/turn-recovery.d.ts

@@ -129,8 +129,8 @@ export declare class TurnRecovery {
     handleEmptyAssistantStop(message: AssistantMessage): Promise<"continue" | "terminal" | undefined>;
     /** Classifies suspicious terminal stops and schedules bounded recovery. */
     handleUnexpectedAssistantStop(message: AssistantMessage): Promise<boolean>;
-    /** Removes a persisted failed assistant turn after its persistence slot settles. */
-    dropPersistedAssistantTurn(message: AssistantMessage): Promise<void>;
+    /** Removes a persisted failed assistant turn after its persistence slot settles; returns the dropped branch entry id. */
+    dropPersistedAssistantTurn(message: AssistantMessage): Promise<string | undefined>;
     /** Runs recovery compaction and restores the failed turn when no rewrite occurs. */
     runRecoveryCompactionWithRollback(reason: "overflow" | "incomplete", message: AssistantMessage, allowDefer: boolean, options: {
         autoContinue: boolean;
@@ -174,7 +174,7 @@ export declare class TurnRecovery {
      * the Gemini header-runaway interrupt, which must not replay a partial,
      * loop-fueling thinking block.
      */
-    discardAssistantTurn(assistantMessage: AssistantMessage): void;
+    discardAssistantTurn(assistantMessage: AssistantMessage): string | undefined;
     /**
      * Retry an empty, reason-less provider abort: a turn with no content that
      * carries the generic sentinel (bare `abort()`), whether the provider
@@ -198,10 +198,10 @@ export declare class TurnRecovery {
      */
     isRetryableError(message: AssistantMessage): boolean;
     /**
-     * Classify a reasonless abort or stream stall whose emitted tool calls all
-     * have results. The failed assistant/tool-result pair stays in context so
-     * continuation cannot replay completed side effects; synthetic results tell
-     * the next turn that an unexecuted call must be reissued.
+     * Classify a reasonless abort, idle stream stall, or HTTP/2 stream reset whose
+     * emitted tool calls all have results. The failed assistant/tool-result pair
+     * stays in context so continuation cannot replay completed side effects;
+     * synthetic results tell the next turn that an unexecuted call must be reissued.
      */
     classifyResolvedInterruptedToolTurn(message: AssistantMessage): "reasonless-abort" | "stream-stall" | undefined;
     /** Checks whether a provider error represents a classifier refusal. */

package/dist/types/slash-commands/helpers/stats-dashboard.d.ts

@@ -1,6 +1,7 @@
 export declare const DEFAULT_STATS_DASHBOARD_PORT = 3847;
 export interface StatsDashboardArgs {
     port: number;
+    host: string;
 }
 export interface StatsDashboardLaunchResult {
     url: string;

package/dist/types/tools/browser/attach.d.ts

@@ -5,6 +5,22 @@ import type { Browser, Page } from "puppeteer-core";
  * subsequent bind in the launched app, but Chromium's listener will retry.
  */
 export declare function findFreeCdpPort(): Promise<number>;
+/**
+ * Loopback HTTP/1.1 GET that never routes through a proxy, resolving to the
+ * response status code (or null when the endpoint is unreachable, aborted,
+ * malformed, or slow past `timeoutMs`).
+ *
+ * Chrome's DevTools endpoint listens on loopback and speaks plain HTTP/1.1.
+ * Both `fetch` and Bun's `node:http` honor `HTTP_PROXY`/`HTTPS_PROXY` and
+ * forward even `127.0.0.1` requests to the proxy unless `NO_PROXY` covers them,
+ * so a local proxy that 502s internal addresses makes a healthy daemon look
+ * dead and the CDP readiness checks tear it down (issue #8567). Talking to the
+ * socket over raw TCP sidesteps proxy env entirely.
+ */
+export declare function probeCdpStatus(url: string, opts: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<number | null>;
 /** Poll `${cdpUrl}/json/version` until it responds with 200, with abort + timeout support. */
 export declare function waitForCdp(cdpUrl: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 /**

package/dist/types/tools/browser/launch.d.ts

@@ -56,8 +56,8 @@ export interface SharedBrowserLaunchSpec {
  * Resolve the executable and complete argv for a shared Chromium the daemon
  * broker spawns directly (no puppeteer inside the broker). Mirrors
  * `launchHeadlessBrowser` flag assembly — puppeteer's default args minus the
- * stealth-suppressed set — plus `--remote-debugging-port=0` so every client
- * attaches over CDP. Returns null when no Chromium executable resolves;
+ * stealth-suppressed set — suppresses Puppeteer's unowned startup window, and
+ * exposes CDP on an ephemeral port. Returns null when no executable resolves;
  * callers fall back to a process-local launch.
  */
 export declare function resolveSharedBrowserLaunchSpec(opts: {

package/dist/types/tools/browser.d.ts

@@ -76,7 +76,7 @@ export interface BrowserToolDetails {
 /**
  * Browser tool: stateful, multi-tab. Three actions:
  * - `open`  → acquire/create a named tab on a browser kind (headless | spawned | connected) and optionally goto a url.
- * - `close` → release a named tab (or all tabs); dispose browser when refcount hits 0.
+ * - `close` → release a named tab handle (or all handles); attached/relay pages remain open, and spawned pages remain unless killed.
  * - `run`   → execute JS code against an existing tab with `page`/`browser`/`tab` helpers in scope.
  */
 export declare class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolDetails> {

package/dist/types/tools/builtin-names.d.ts

@@ -2,7 +2,7 @@ export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal", "think"];
 export type HiddenToolName = (typeof HIDDEN_TOOL_NAMES)[number];
-/** Return the canonical tool name for current and legacy built-in tool IDs. */
+/** Canonicalize built-in IDs and legacy aliases. Leave plugin names unchanged. */
 export declare function normalizeToolName(name: string): string;
 /** Normalize and deduplicate tool names while preserving first-seen order. */
 export declare function normalizeToolNames(names: Iterable<string>): string[];

package/dist/types/tools/file-write-fallback.d.ts

@@ -0,0 +1,124 @@
+import type { BunFile } from "bun";
+import type { ExtensionContext } from "../extensibility/extensions/types.js";
+/** A denied write, captured for a registered fallback to retry through a privileged channel. */
+export interface FileWriteFallbackRequest {
+    /**
+     * Absolute, symlink-resolved path to write the bytes to.
+     *
+     * This is where the failed in-process write would itself have landed, which is
+     * not necessarily the path the tool was given: `open` follows every component,
+     * so a link anywhere in that path redirects the bytes. Resolving it here is
+     * what lets a handler's allowlist see the real destination instead of a
+     * lexically innocent path, so a handler MUST treat this as authoritative and
+     * MUST NOT re-derive the target from anything else.
+     */
+    dst: string;
+    /**
+     * Session the denied write was issued from, or `undefined` when the mutation
+     * did not happen inside a tool call (an external `applyPatch` caller, a test).
+     *
+     * The registry is process-wide, so a handler can be consulted for a write from
+     * a session other than the one whose extension registered it. Compare this with
+     * `ctx.sessionManager.getSessionId()` to tell the two apart — a handler that
+     * prompts through `ctx.ui` needs to, since that UI belongs to ITS session and
+     * not necessarily to the one being asked about.
+     */
+    sessionId: string | undefined;
+    /** The exact bytes the tool intended to write. */
+    content: string;
+    /**
+     * The error that proves the write hit a permission boundary. Usually the write's
+     * own `EPERM`/`EACCES`/`EROFS`; for a write into a directory the host may not
+     * create, the denial raised by creating that directory, in which case `dst`'s
+     * parent may not exist yet and the handler is responsible for creating it.
+     */
+    cause: unknown;
+}
+/** Extension-authored handler. Return `true` once `content` is durably on disk at `dst`. */
+export type FileWriteFallbackHandler = (req: FileWriteFallbackRequest, ctx: ExtensionContext) => Promise<boolean>;
+/** A handler already bound to its owning extension's live context. */
+type BoundFileWriteFallbackHandler = (req: FileWriteFallbackRequest) => Promise<boolean>;
+/** A denied unlink, captured for a registered fallback to perform through a privileged channel. */
+export interface FileDeleteFallbackRequest {
+    /**
+     * Absolute, symlink-resolved path the unlink was denied for.
+     *
+     * Every component ABOVE the last is resolved, so a handler cannot be walked
+     * outside its allowed roots through a link in the path. The last component is
+     * deliberately NOT resolved, because `unlink` removes a link itself rather
+     * than its target — which is also why this may still name a symlink.
+     */
+    dst: string;
+    /** The `EPERM`/`EACCES`/`EROFS` that proves the unlink hit a permission boundary. */
+    cause: unknown;
+    /**
+     * Whether `dst` was confirmed to be a plain regular file before diverting.
+     *
+     * `false` means the seam could not establish that, either because the target's
+     * own metadata is behind the same boundary that denied the unlink — the common
+     * sandbox case, since `unlink` on a directory also reports `EPERM` on Darwin —
+     * or because `dst` is a symlink.
+     *
+     * A handler MUST remove `dst` with a plain unlink. It MUST NOT remove it
+     * recursively, and MUST NOT resolve the path first: when this is `false` the
+     * target may be a directory, and resolving a symlink would delete whatever it
+     * points at instead of the link.
+     */
+    confirmedFile: boolean;
+    /** See {@link FileWriteFallbackRequest.sessionId}. */
+    sessionId: string | undefined;
+}
+/** Extension-authored handler. Return `true` once `dst` is gone from disk. */
+export type FileDeleteFallbackHandler = (req: FileDeleteFallbackRequest, ctx: ExtensionContext) => Promise<boolean>;
+/** A handler already bound to its owning extension's live context. */
+type BoundFileDeleteFallbackHandler = (req: FileDeleteFallbackRequest) => Promise<boolean>;
+/** True for `EPERM`, `EACCES`, and `EROFS` — the sandbox-boundary write failures this seam exists for. */
+export declare function isPermissionDeniedError(error: unknown): boolean;
+/** Whether any fallback is registered. Lets a caller skip work that only this seam needs. */
+export declare function hasFileWriteFallback(): boolean;
+/**
+ * Append a fallback writer, consulted in registration order when a direct write is
+ * permission-denied. Returns a disposer that removes this exact registration; the
+ * runner calls it on session shutdown so no handler outlives its session.
+ */
+export declare function addFileWriteFallback(handler: BoundFileWriteFallbackHandler): () => void;
+/** Whether any delete fallback is registered. */
+export declare function hasFileDeleteFallback(): boolean;
+/**
+ * Append a fallback deleter, consulted in registration order when a direct unlink is
+ * permission-denied. Deliberately a separate registry from
+ * {@link addFileWriteFallback}: a write handler brokers `content` to `dst`, and
+ * handing it a request with no content would let it "broker" an empty write and
+ * truncate the file it was asked to remove. Opting in is explicit for that reason.
+ */
+export declare function addFileDeleteFallback(handler: BoundFileDeleteFallbackHandler): () => void;
+/**
+ * Name the session whose tool call is about to run, so a denied mutation inside it
+ * can tell a handler where the request came from.
+ *
+ * Entered once per tool call by `ExtensionToolWrapper` (`extensibility/extensions/
+ * wrapper.ts`), which `sdk.ts` puts around the whole tool registry whenever an
+ * `ExtensionRunner` exists — so the component that owns the handlers is the one
+ * naming its own session, and no caller has to thread an `AgentToolContext`
+ * through for attribution to work.
+ *
+ * That covers the deferred LSP write batch too: a batch id belongs to one
+ * assistant turn of one session, and its flush is awaited inside a tool call of
+ * that same session, so a write performed during a later call of the group is
+ * still attributed to the session that issued it.
+ *
+ * Deliberately NOT a general "current session" accessor: nothing else enters this
+ * scope, so outside a tool call it is empty by design — an external `applyPatch`
+ * caller reports `undefined` rather than borrowing someone else's identity.
+ */
+export declare function withFileMutationSession<T>(sessionId: string | undefined, fn: () => T): T;
+/**
+ * Remove a file, consulting registered delete fallbacks when the unlink is denied.
+ *
+ * Unlike the write path there is no masked-`ENOENT` case to see through: nothing is
+ * created on the way, so an `ENOENT` here means the file genuinely is not there and
+ * must propagate — `edit`'s `REM` turns it into a `NotFoundError`.
+ */
+export declare function deleteFileWithFallback(dst: string, file?: BunFile): Promise<void>;
+export declare function writeFileWithFallback(dst: string, content: string, file?: BunFile): Promise<void>;
+export {};

package/dist/types/tools/hub/jobs.d.ts

@@ -36,6 +36,12 @@ export declare function visibleJobs(manager: AsyncJobManager, ids: string[], own
  * that activity instead of implying the system is quiet. Existence is
  * already public via the peer roster, so listing ids here leaks nothing new;
  * job *control* stays owner-scoped.
+ *
+ * Reporting deliberately uses the claimed `status`, not the session-corroborated
+ * `registry.isRunning` used by the wait-sustaining gates: a ref that claims
+ * `running` with no live turn is exactly the stale entry an operator must see
+ * here to cancel it (#8634). Hiding it would match the badge count to nothing
+ * and remove the only discovery path for the id.
  */
 export declare function runningAgentsOutsideJobs(session: ToolSession): AgentActivitySnapshot[];
 interface TrackedJobLike {

package/dist/types/tools/hub/types.d.ts

@@ -55,6 +55,12 @@ export interface AgentActivitySnapshot {
     activity?: string;
     /** Time since the agent was registered. */
     ageMs: number;
+    /**
+     * Whether an attached session corroborates the `running` claim. False marks
+     * a ref that says `running` with no turn in flight — either a spawn still
+     * wiring up or a stale registration that `hub cancel <id>` clears (#8634).
+     */
+    live: boolean;
 }
 /** Result details for messaging and job ops; fields are disjoint per op. */
 export interface CoordinationDetails {

package/dist/types/tools/index.d.ts

@@ -50,6 +50,7 @@ export * from "./debug.js";
 export * from "./essential-tools.js";
 export * from "./eval.js";
 export * from "./eval-backends.js";
+export * from "./file-write-fallback.js";
 export * from "./gh.js";
 export * from "./glob.js";
 export * from "./grep.js";

package/dist/types/tools/path-utils.d.ts

@@ -155,6 +155,29 @@ export declare function resolveToCwd(filePath: string, cwd: string): string;
  * The cwd itself is rejected: a download names a file, never the directory.
  */
 export declare function confineToWorkspace(filePath: string, cwd: string): string | null;
+/**
+ * Resolve the path a syscall on `filePath` would really act on, or `null` when
+ * that cannot be established.
+ *
+ * A lexical path is not a destination. The kernel follows every component above
+ * the last, so `ws/link/file` under a `ws/link -> /elsewhere` link lands outside
+ * `ws` while still looking relative and `..`-free. Handing such a path to a
+ * privileged helper defeats the defence a helper author reaches for first — a
+ * prefix allowlist passes, because the link sits inside the allowed root while
+ * its target does not. Callers that hand a path to something more privileged
+ * than the syscall that just failed resolve it here first.
+ *
+ * Rejecting symlinked components outright is not an option: `/var` and `/tmp`
+ * are links on macOS, so every path under `os.tmpdir()` traverses one. They are
+ * resolved instead, and only a path whose real destination cannot be established
+ * is refused, because "where would this land" then has no answer to hand over.
+ * {@link confineToWorkspace} refuses an unresolvable link for the same reason.
+ *
+ * @param followFinal `true` for a syscall that follows a link at the final
+ *   component (`open`, so every write), `false` for one that acts on the link
+ *   itself (`unlink`) and therefore needs it left alone.
+ */
+export declare function resolveSyscallTarget(filePath: string, followFinal: boolean): Promise<string | null>;
 export declare function formatPathRelativeToCwd(filePath: string, cwd: string, options?: {
     trailingSlash?: boolean;
 }): string;

package/dist/types/vibe/runtime.d.ts

@@ -102,15 +102,15 @@ export declare class VibeSessionRegistry {
     /** Reset the global registry. Test-only. */
     static resetGlobalForTests(): void;
     /**
-     * Insert a bare worker record without the spawn/job machinery. Test-only —
-     * lets {@link aggregateVibeWorkerTokensPerSecond} be exercised against a
-     * fake roster + AgentRegistry session without driving a real turn.
+     * Insert a bare worker record without the spawn machinery. Test-only —
+     * lets focused runtime tests attach an optional synthetic in-flight job.
      */
     registerRecordForTests(record: {
         id: string;
         cli?: VibeCli;
         ownerId: string;
         state?: VibeSessionState;
+        jobId?: string;
     }): void;
     /** Override the teardown grace period for deterministic lifecycle tests. */
     setTeardownGraceForTesting(timeoutMs: number): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.3.4",
+	"version": "17.3.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,18 +48,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.3.4",
-		"@oh-my-pi/omp-stats": "17.3.4",
-		"@oh-my-pi/omptype": "17.3.4",
-		"@oh-my-pi/pi-agent-core": "17.3.4",
-		"@oh-my-pi/pi-ai": "17.3.4",
-		"@oh-my-pi/pi-catalog": "17.3.4",
-		"@oh-my-pi/pi-mnemopi": "17.3.4",
-		"@oh-my-pi/pi-natives": "17.3.4",
-		"@oh-my-pi/pi-tui": "17.3.4",
-		"@oh-my-pi/pi-utils": "17.3.4",
-		"@oh-my-pi/pi-wire": "17.3.4",
-		"@oh-my-pi/snapcompact": "17.3.4",
+		"@oh-my-pi/hashline": "17.3.7",
+		"@oh-my-pi/omp-stats": "17.3.7",
+		"@oh-my-pi/omptype": "17.3.7",
+		"@oh-my-pi/pi-agent-core": "17.3.7",
+		"@oh-my-pi/pi-ai": "17.3.7",
+		"@oh-my-pi/pi-catalog": "17.3.7",
+		"@oh-my-pi/pi-mnemopi": "17.3.7",
+		"@oh-my-pi/pi-natives": "17.3.7",
+		"@oh-my-pi/pi-tui": "17.3.7",
+		"@oh-my-pi/pi-utils": "17.3.7",
+		"@oh-my-pi/pi-wire": "17.3.7",
+		"@oh-my-pi/snapcompact": "17.3.7",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/auto-thinking/classifier.ts

@@ -14,7 +14,7 @@
  * Throws on any failure (no model, no key, unparseable output, abort/timeout);
  * the caller falls back to a concrete level and continues the turn.
  */
-import { type AssistantMessage, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { type AssistantMessage, completeSimple, Effort, type Model, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
 import { prompt } from "@oh-my-pi/pi-utils";
 
@@ -60,14 +60,24 @@ function difficultySystemPromptFor(ceiling: Effort): string {
 
 /** Local classifiers occasionally need more room for chat-template boilerplate. */
 const LOCAL_ANSWER_MAX_TOKENS = 16;
+/** On-device reasoning classifiers need room for the bucket keyword after the `<think>` preamble. */
+const LOCAL_REASONING_MAX_TOKENS = 1024;
 /**
- * Online classifier budget. Sized to survive backends that ignore
- * `disableReasoning` (e.g. Qwen3 via llama.cpp catalogued `reasoning: false`
- * but still emitting thinking): the classifier keyword needs to land after any
- * unavoidable thinking preamble. `maxTokens` is a hard cap — non-thinking
- * completions still return in a handful of tokens (issue #4355).
+ * Online classifier budget. Sized against two independent constraints:
+ *   - Backends that ignore `disableReasoning` still emit a thinking preamble
+ *     (e.g. Qwen3 via llama.cpp catalogued `reasoning: false` but still thinking;
+ *     Anthropic via LiteLLM/Vertex, whose `openai-completions` route downgrades a
+ *     disabled request to the lowest reasoning effort instead of turning thinking
+ *     off). The classifier keyword must have room to land after that preamble
+ *     (issue #4355).
+ *   - Anthropic-dialect proxies reject `max_tokens <= thinking.budget_tokens`. The
+ *     pinned lowest effort maps to at least Anthropic's 1024-token minimum budget,
+ *     so the cap MUST comfortably exceed 1024 or every classifier call 400s with
+ *     `max_tokens must be greater than thinking.budget_tokens` (issue #8610).
+ * `maxTokens` is a hard cap — non-thinking completions still return in a handful
+ * of tokens.
  */
-const REASONING_SAFE_MAX_TOKENS = 1024;
+const ONLINE_REASONING_SAFE_MAX_TOKENS = 4096;
 
 export interface ClassifyDifficultyDeps {
 	settings: Settings;
@@ -113,21 +123,25 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps, ceili
 	}
 	// Resolve metadata after getApiKey so the session-sticky credential is recorded first.
 	const metadata = deps.metadataResolver?.(model.provider);
-	const maxTokens = REASONING_SAFE_MAX_TOKENS;
-
-	const response = await completeSimple(
-		model,
-		{
-			systemPrompt: [difficultySystemPromptFor(ceiling)],
-			messages: [{ role: "user", content: input, timestamp: Date.now() }],
-		},
-		{
-			apiKey: deps.registry.resolver(model, deps.sessionId),
-			maxTokens,
-			disableReasoning: true,
-			metadata,
-			signal: deps.signal,
-		},
+	const maxTokens = ONLINE_REASONING_SAFE_MAX_TOKENS;
+
+	const response = await retryTransientCompletion(
+		() =>
+			completeSimple(
+				model,
+				{
+					systemPrompt: [difficultySystemPromptFor(ceiling)],
+					messages: [{ role: "user", content: input, timestamp: Date.now() }],
+				},
+				{
+					apiKey: deps.registry.resolver(model, deps.sessionId),
+					maxTokens,
+					disableReasoning: true,
+					metadata,
+					signal: deps.signal,
+				},
+			),
+		{ signal: deps.signal },
 	);
 
 	if (response.stopReason === "error") {
@@ -147,7 +161,7 @@ async function classifyLocal(input: string, modelKey: string, deps: ClassifyDiff
 		throw new Error(`auto-thinking: unsupported local classifier model: ${modelKey}`);
 	}
 	const maxTokens = isTinyMemoryReasoningModelKey(modelKey)
-		? Math.max(LOCAL_ANSWER_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+		? Math.max(LOCAL_ANSWER_MAX_TOKENS, LOCAL_REASONING_MAX_TOKENS)
 		: LOCAL_ANSWER_MAX_TOKENS;
 	const builtPrompt = prompt.render(difficultyLocalPrompt, { prompt: input });
 	const text = await tinyModelClient.complete(modelKey, builtPrompt, {

package/src/cli/models-cli.ts

@@ -304,7 +304,7 @@ export async function runModelsListing(options: RunModelsListingOptions): Promis
 		cwd,
 		eventBus,
 		disableExtensionDiscovery ? undefined : disabledExtensionIds,
-		{ ambient: !disableExtensionDiscovery },
+		{ ambient: !disableExtensionDiscovery, includeAmbientHooks: false },
 	);
 	const extensionRunner =
 		extensionsResult.extensions.length > 0

package/src/cli/stats-cli.ts

@@ -5,7 +5,7 @@
  */
 
 import { truncateToWidth } from "@oh-my-pi/pi-tui/utils";
-import { APP_NAME, formatDuration, formatNumber, formatPercent } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, formatPercent } from "@oh-my-pi/pi-utils";
 import chalk from "@oh-my-pi/pi-utils/chalk";
 import { openPath } from "../utils/open";
 
@@ -57,45 +57,11 @@ function shortenSessionFile(p: string): string {
 
 export interface StatsCommandArgs {
 	port: number;
+	host: string;
 	json: boolean;
 	summary: boolean;
 }
 
-// =============================================================================
-// Argument Parser
-// =============================================================================
-
-/**
- * Parse stats subcommand arguments.
- * Returns undefined if not a stats command.
- */
-export function parseStatsArgs(args: string[]): StatsCommandArgs | undefined {
-	if (args.length === 0 || args[0] !== "stats") {
-		return undefined;
-	}
-
-	const result: StatsCommandArgs = {
-		port: 3847,
-		json: false,
-		summary: false,
-	};
-
-	for (let i = 1; i < args.length; i++) {
-		const arg = args[i];
-		if (arg === "--json" || arg === "-j") {
-			result.json = true;
-		} else if (arg === "--summary" || arg === "-s") {
-			result.summary = true;
-		} else if ((arg === "--port" || arg === "-p") && i + 1 < args.length) {
-			result.port = parseInt(args[++i], 10);
-		} else if (arg.startsWith("--port=")) {
-			result.port = parseInt(arg.split("=")[1], 10);
-		}
-	}
-
-	return result;
-}
-
 function formatCost(n: number): string {
 	if (n < 0.01) return `$${n.toFixed(4)}`;
 	if (n < 1) return `$${n.toFixed(3)}`;
@@ -112,9 +78,8 @@ function normalizePremiumRequests(n: number): number {
 
 export async function runStatsCommand(cmd: StatsCommandArgs): Promise<void> {
 	// Lazy import to avoid loading stats module when not needed
-	const { getDashboardStats, syncAllSessions, getTotalMessageCount, startServer, closeDb } = await import(
-		"@oh-my-pi/omp-stats"
-	);
+	const { closeDb, formatStatsDashboardUrl, getDashboardStats, getTotalMessageCount, startServer, syncAllSessions } =
+		await import("@oh-my-pi/omp-stats");
 
 	// Sync session files first
 	const progress = createSyncProgressReporter();
@@ -136,8 +101,8 @@ export async function runStatsCommand(cmd: StatsCommandArgs): Promise<void> {
 	}
 
 	// Start the dashboard server
-	const { hostname, port } = await startServer(cmd.port);
-	const url = `http://${hostname}:${port}`;
+	const { hostname, port } = await startServer(cmd.port, cmd.host);
+	const url = formatStatsDashboardUrl(hostname, port);
 	console.log(chalk.green(`Dashboard available at: ${url}`));
 
 	// Open browser
@@ -197,34 +162,3 @@ async function printStatsSummary(): Promise<void> {
 
 	console.log("");
 }
-
-// =============================================================================
-// Help
-// =============================================================================
-
-export function printStatsHelp(): void {
-	console.log(`${chalk.bold(`${APP_NAME} stats`)} - AI Usage Statistics Dashboard
-
-${chalk.bold("Usage:")}
-  ${APP_NAME} stats [options]
-
-${chalk.bold("Options:")}
-  -p, --port <port>  Port for the dashboard server (default: 3847)
-  -j, --json         Output stats as JSON and exit
-  -s, --summary      Print summary to console and exit
-  -h, --help         Show this help message
-
-${chalk.bold("Examples:")}
-  ${APP_NAME} stats              # Start dashboard server
-  ${APP_NAME} stats --json       # Print stats as JSON
-  ${APP_NAME} stats --summary    # Print summary to console
-  ${APP_NAME} stats --port 8080  # Start on custom port
-
-${chalk.bold("Metrics:")}
-  - Total requests and error rate
-  - Token usage (input, output, cache)
-  - Cost breakdown
-  - Average duration and time to first token (TTFT)
-  - Tokens per second throughput
-`);
-}

package/src/commands/stats.ts

@@ -4,13 +4,15 @@
 
 import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { statsHelp as commandHelp } from "../cli/command-help";
-import { runStatsCommand, type StatsCommandArgs } from "../cli/stats-cli";
-import { initTheme } from "../modes/theme/theme";
+import type { StatsCommandArgs } from "../cli/stats-cli";
+import * as statsCli from "../cli/stats-cli";
+import * as theme from "../modes/theme/theme";
 
 export default class Stats extends Command {
 	static description = commandHelp.description;
 	static flags = {
 		port: Flags.integer({ char: "p", description: "Port for the dashboard server", default: 3847 }),
+		host: Flags.string({ description: "Host to bind", default: "127.0.0.1" }),
 		json: Flags.boolean({ char: "j", description: "Output stats as JSON", default: false }),
 		summary: Flags.boolean({ char: "s", description: "Print summary to console", default: false }),
 	};
@@ -20,11 +22,12 @@ export default class Stats extends Command {
 
 		const cmd: StatsCommandArgs = {
 			port: flags.port,
+			host: flags.host ?? "127.0.0.1",
 			json: flags.json,
 			summary: flags.summary,
 		};
 
-		await initTheme();
-		await runStatsCommand(cmd);
+		await theme.initTheme();
+		await statsCli.runStatsCommand(cmd);
 	}
 }

package/src/commit/analysis/conventional.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
-import { completeSimple } from "@oh-my-pi/pi-ai";
+import { completeSimple, retryTransientCompletion } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
 import analysisSystemPrompt from "../../commit/prompts/analysis-system.md" with { type: "text" };
 import analysisUserPrompt from "../../commit/prompts/analysis-user.md" with { type: "text" };
@@ -50,15 +50,21 @@ export async function generateConventionalAnalysis({
 		diff,
 	});
 
-	const response = await completeSimple(
-		model,
-		{
-			systemPrompt: [prompt.render(analysisSystemPrompt)],
-			messages: [{ role: "user", content: userContent, timestamp: Date.now() }],
-			tools: [ConventionalAnalysisTool],
-		},
-		{ apiKey, maxTokens: 2400, reasoning: toReasoningEffort(thinkingLevel) },
+	const response = await retryTransientCompletion(() =>
+		completeSimple(
+			model,
+			{
+				systemPrompt: [prompt.render(analysisSystemPrompt)],
+				messages: [{ role: "user", content: userContent, timestamp: Date.now() }],
+				tools: [ConventionalAnalysisTool],
+			},
+			{ apiKey, maxTokens: 2400, reasoning: toReasoningEffort(thinkingLevel) },
+		),
 	);
 
+	if (response.stopReason === "error") {
+		throw new Error(response.errorMessage ?? "provider error");
+	}
+
 	return parseConventionalAnalysisResponse(response, ConventionalAnalysisTool);
 }