@oh-my-pi/pi-coding-agent 16.1.16 → 16.1.17

package/dist/types/auto-thinking/classifier.d.ts

@@ -25,10 +25,12 @@ export interface ClassifyDifficultyDeps {
     metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
 }
 /**
- * Classify `promptText` and return a concrete effort clamped to `deps.model`.
+ * Classify `promptText` and return a concrete effort clamped to `deps.model`,
+ * or `undefined` when the model has no controllable effort surface (auto has
+ * nothing to pick — the caller leaves the prior reasoning level in place).
  * @throws when the backend cannot produce a usable classification.
  */
-export declare function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort>;
+export declare function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort | undefined>;
 /** Map the online 4-way level keyword to an {@link Effort}; earliest match wins. */
 export declare function parseDifficultyLevel(text: string): Effort | undefined;
 /** Map the local 3-way bucket keyword to an {@link Effort}; earliest match wins. */

package/dist/types/config/model-discovery.d.ts

@@ -38,6 +38,7 @@ export interface DiscoveryContext {
 export declare function discoverModelsByProviderType(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverOllamaModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverLlamaCppModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
+export declare function discoverLlamaCppModelContextWindow(model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">, ctx: DiscoveryContext): Promise<number | undefined>;
 export declare function discoverOpenAIModelsList(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 /**
  * Discover models from an Anthropic+OpenAI-compatible reseller proxy that

package/dist/types/config/model-registry.d.ts

@@ -89,6 +89,10 @@ export declare class ModelRegistry {
     refresh(strategy?: ModelRefreshStrategy): Promise<void>;
     refreshInBackground(strategy?: ModelRefreshStrategy): void;
     refreshProvider(providerId: string, strategy?: ModelRefreshStrategy): Promise<void>;
+    /**
+     * Refresh dynamic metadata that can appear only after a local model loads.
+     */
+    refreshSelectedModelMetadata(model: Model<Api>): Promise<Model<Api>>;
     /**
      * Discover models for providers registered at runtime via `fetchDynamicModels`
      * (extension providers). Merges the discovered catalog into the existing model

package/dist/types/extensibility/plugins/legacy-pi-compat.d.ts

@@ -1,14 +1,22 @@
 import * as path from "node:path";
 /**
  * Compute the bunfs package root from the compiled binary's `import.meta.dir`
- * (or any stand-in supplied by tests). Bun 1.3 reports the bunfs mount root
- * (`/$bunfs/root` or `<drive>:\~BUN\root`) for imported modules as well as the
- * entrypoint, so the normal path is `<root>/packages`.
+ * (or any stand-in supplied by tests). Bun compiled binaries report one of:
  *
- * The suffix branch preserves correctness if a future Bun release switches to
- * module-specific `import.meta.dir` values inside compiled binaries, matching
- * the source layout:
- * `<bunfs>/packages/coding-agent/src/extensibility/plugins`.
+ * - the bunfs mount root itself — `/$bunfs/root` or `<drive>:\~BUN\root` (Bun
+ *   1.2.x and early 1.3.x). Append `packages` for the canonical layout.
+ * - the bunfs mount root followed by the binary's basename — `//root/<bin>`
+ *   on POSIX or `<drive>:\~BUN\root\<bin>.exe` on Windows (observed on Bun
+ *   1.3.14 with the cross-compiled `omp-darwin-arm64` release asset — issue
+ *   #3329). The trailing segment is stripped so the result still lands on
+ *   `<root>/packages`.
+ * - the module's own source directory if a future Bun release switches to
+ *   module-specific `import.meta.dir` values:
+ *   `<bunfs>/packages/coding-agent/src/extensibility/plugins`.
+ * The bunfs-root-with-binary branch slices the original `metaDir`, and
+ * `bunfsPath` uses a matching double-slash-preserving join, so the bunfs-native
+ * prefix is preserved verbatim — `path.posix.join` collapses `//root` to
+ * `/root`, but Bun's bunfs lookup is keyed on the exact `//root` form.
  *
  * Exported for tests; production callers use `BUNFS_PACKAGE_ROOT` below.
  */
@@ -22,6 +30,13 @@ export declare function __computeBunfsPackageRoot(metaDir: string, pathImpl?: ty
  * older cache entry, recreating mixed-runtime plugin loading.
  */
 export declare function __computeBundledSelfPackageRoot(metaDir: string, pathImpl?: typeof path): string;
+/**
+ * Join a computed bunfs package root with descendants without collapsing
+ * Bun's POSIX `//root` mount prefix.
+ *
+ * Exported for tests; production callers use `bunfsPath` below.
+ */
+export declare function __joinBunfsPath(root: string, segments: readonly string[], pathImpl?: typeof path): string;
 /**
  * Drop overrides whose targets are missing on disk so they can fall through to
  * the canonical-resolution path. Exported for the test seam in #2168.

package/dist/types/extensibility/plugins/loader.d.ts

@@ -1,19 +1,26 @@
 import type { InstalledPlugin } from "./types";
+/** Installed plugin plus the root scope that supplied its runtime metadata. */
+export interface ScopedInstalledPlugin extends InstalledPlugin {
+    scope: "user" | "project";
+}
 /**
  * Get list of enabled plugins with their resolved configurations.
  *
- * Respects both global runtime config and project overrides. Iterates the
- * union of `<plugins>/package.json#dependencies` (`bun install`-installed
- * packages) and `<plugins>/omp-plugins.lock.json#plugins` (so locally
- * `plugin link`-symlinked extensions, which never get a dependency entry,
- * are still discovered). The optional `home` parameter pins the plugins
- * root for callers that need to enumerate plugins relative to a non-default
- * home (tests with a tempdir, discovery loaders threaded with
- * `LoadContext.home`).
+ * Enumerates two plugin roots in order: the user root
+ * (`getPluginsDir(home)`) and, when a project anchor (`.omp/` or `.git/`)
+ * exists at or above `cwd`, the project root
+ * (`<projectAnchor>/.omp/plugins`). Each root contributes the union of its
+ * `package.json#dependencies` and `omp-plugins.lock.json#plugins`. Project
+ * entries shadow user entries with the same package name, matching the
+ * shadow semantics of `MarketplaceManager.listInstalledPlugins`.
+ *
+ * The optional `home` parameter pins the user plugins root for callers that
+ * need to enumerate plugins relative to a non-default home (tests with a
+ * tempdir, discovery loaders threaded with `LoadContext.home`).
  */
 export declare function getEnabledPlugins(cwd: string, opts?: {
     home?: string;
-}): Promise<InstalledPlugin[]>;
+}): Promise<ScopedInstalledPlugin[]>;
 /**
  * Declared manifest entries paired with their resolved file path. Returns one
  * record per declared entry — base entries first, then enabled-feature entries

package/dist/types/extensibility/tool-event-input.d.ts

@@ -0,0 +1,2 @@
+/** Adds derived compatibility fields to tool event input without changing tool execution parameters. */
+export declare function normalizeToolEventInput(toolName: string, input: Record<string, unknown>): Record<string, unknown>;

package/dist/types/hindsight/content.d.ts

@@ -64,14 +64,6 @@ export interface RetentionTranscript {
     transcript: string | null;
     messageCount: number;
 }
-/**
- * Format messages into a retention transcript using `[role: ...]` markers.
- *
- * - When `retainFullWindow` is true, all messages are included (used when the
- *   caller pre-sliced the window itself).
- * - Otherwise, only the last user turn (last user message → end) is retained.
- *
- * Messages are tag-stripped before framing to break the recall→retain loop.
- * Returns `{ transcript: null }` when nothing meaningful survives.
- */
 export declare function prepareRetentionTranscript(messages: HindsightMessage[], retainFullWindow?: boolean): RetentionTranscript;
+/** Format only user-authored messages for memory fact/entity extraction. */
+export declare function prepareUserRetentionTranscript(messages: HindsightMessage[]): RetentionTranscript;

package/dist/types/modes/components/chat-transcript-builder.d.ts

@@ -34,6 +34,8 @@ export declare class ChatTranscriptBuilder {
     get isEmpty(): boolean;
     /** Discard all components and rebuild the whole transcript from `entries`. */
     rebuild(entries: SessionMessageEntry[]): void;
+    /** Append newly persisted entries without rebuilding already rendered rows. */
+    append(entries: SessionMessageEntry[]): void;
     /** Toggle tool-output expansion across every expandable component. */
     setExpanded(expanded: boolean): void;
     get expanded(): boolean;

package/dist/types/modes/components/custom-editor.d.ts

@@ -19,6 +19,7 @@ export declare const SPACE_HOLD_MECHANICAL_RUN = 2;
 /** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
  *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
 export declare const SPACE_HOLD_RELEASE_MS = 250;
+export declare function extractBracketedPastePaths(data: string): string[] | undefined;
 export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
 export declare function extractBracketedImagePastePath(data: string): string | undefined;
 /**
@@ -86,6 +87,8 @@ export declare class CustomEditor extends Editor {
     onPasteImage?: () => Promise<boolean>;
     /** Called when a bracketed paste contains one or more image-file paths. */
     onPasteImagePath?: (path: string) => void | Promise<void>;
+    /** Called when a bracketed paste contains one or more non-image file paths. */
+    onPasteFilePath?: (path: string) => void | Promise<void>;
     /** Called when the configured raw text-paste shortcut is pressed. */
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */

package/dist/types/modes/components/status-line/types.d.ts

@@ -90,6 +90,7 @@ export interface SegmentContext {
         } | null;
     };
     usage: {
+        tier?: string;
         fiveHour?: {
             percent: number;
             resetMinutes?: number;

package/dist/types/modes/controllers/command-controller.d.ts

@@ -3,6 +3,7 @@ import { type ProviderDetails, type UsageReport } from "@oh-my-pi/pi-ai";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
 import type { CompactMode } from "../../session/compact-modes";
 import { type ShakeMode } from "../../session/shake-types";
 export declare class CommandController {
@@ -43,3 +44,4 @@ export declare class CommandController {
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number, resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined): string;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -1,6 +1,19 @@
 import { type AutocompleteProvider, type SlashCommand } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../../modes/types";
 import { readImageFromClipboard, readTextFromClipboard } from "../../utils/clipboard";
+/**
+ * Slash commands that may carry secrets in their arguments should never be
+ * persisted to history.
+ *
+ * - /login accepts three callback forms (redirect URL, query string, raw auth
+ *   code) — all can contain OAuth code=/state= params.
+ * - /join <link> carries a 32-byte room key and optional write token.
+ * - /mcp add --token <token> carries a bearer token.
+ *
+ * The command name is extracted the same way as parseSlashCommand() — splitting
+ * on the earliest whitespace or colon — so /login:?code=... is correctly matched.
+ */
+export declare function shouldSkipHistory(slashText: string): boolean;
 export declare class InputController {
     #private;
     private ctx;
@@ -25,6 +38,7 @@ export declare class InputController {
         abort?: boolean;
         currentText?: string;
     }): number;
+    handleFilePathPaste(filePath: string): Promise<void>;
     handleImagePathPaste(path: string): Promise<void>;
     handleImagePaste(): Promise<boolean>;
     handleClipboardTextRawPaste(): Promise<void>;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -5,6 +5,17 @@ export declare class SelectorController {
     #private;
     private ctx;
     constructor(ctx: InteractiveModeContext);
+    /**
+     * Restore keyboard focus to whatever currently owns the editor slot. The
+     * slot can hold the editor itself or a hook selector/input/editor pushed
+     * in by `ExtensionUiController` — e.g. an approval prompt that fired while
+     * a fullscreen overlay was up. `overlayHandle.hide()` restores focus to
+     * the component focused when the overlay opened, which is stale in that
+     * case (the editor was swapped out): keys land on a hidden editor and the
+     * visible prompt receives nothing (issue #3349). Call this after the
+     * overlay hides to re-target focus at the visible slot owner.
+     */
+    focusActiveEditorArea(): void;
     /**
      * Shows a selector component in place of the editor.
      * @param create Factory that receives a `done` callback and returns the component and focus target

package/dist/types/session/agent-session.d.ts

@@ -46,7 +46,7 @@ import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo";
 import type { ClientBridge } from "./client-bridge";
 import { type CustomMessage } from "./messages";
-import type { SessionContext } from "./session-context";
+import type { BuildSessionContextOptions, SessionContext } from "./session-context";
 import type { BranchSummaryEntry, NewSessionOptions } from "./session-entries";
 import type { SessionManager } from "./session-manager";
 import type { ShakeMode, ShakeResult } from "./shake-types";
@@ -590,12 +590,12 @@ export declare class AgentSession {
     }[];
     buildDisplaySessionContext(): SessionContext;
     /**
-     * Full-history transcript for TUI display: every path entry in
-     * chronological order with compactions rendered inline at the point they
-     * fired (instead of replacing prior history). Display-only — NEVER feed
-     * the result to `agent.replaceMessages` or a provider.
+     * Transcript for TUI display. Full history is kept for export/resume-style
+     * callers; live chat can collapse compacted history to keep the hot render
+     * surface bounded. Display-only — NEVER feed the result to
+     * `agent.replaceMessages` or a provider.
      */
-    buildTranscriptSessionContext(): SessionContext;
+    buildTranscriptSessionContext(options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory">): SessionContext;
     /** Convert session messages using the same pre-LLM pipeline as the active session. */
     convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
     /** Apply session-level stream hooks to a direct side request. */

package/dist/types/session/provider-image-budget.d.ts

@@ -0,0 +1,3 @@
+import type { Context, Model } from "@oh-my-pi/pi-ai";
+/** Drops oldest transient image blocks so outgoing vision requests fit the active provider's image cap. */
+export declare function clampProviderContextImages(context: Context, model: Model): Context;

package/dist/types/session/session-context.d.ts

@@ -32,13 +32,14 @@ export declare function getRestorableSessionModels(models: Readonly<Record<strin
 export declare function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEntry | null;
 export interface BuildSessionContextOptions {
     /**
-     * Build the full-history display transcript instead of the LLM context:
-     * every path entry in chronological order, with each compaction emitted
-     * inline as a `compactionSummary` message at the position it fired rather
-     * than replacing the history before it. Display-only — never send the
-     * result to a provider.
+     * Build the display transcript instead of the LLM context. By default this
+     * preserves every path entry with compactions inline; set
+     * `collapseCompactedHistory` for the live TUI surface to render only the
+     * latest compacted tail.
      */
     transcript?: boolean;
+    /** In transcript mode, elide entries replaced by the latest compaction. */
+    collapseCompactedHistory?: boolean;
 }
 /**
  * Build the session context from entries using tree traversal.

package/dist/types/task/parallel.d.ts

@@ -25,6 +25,10 @@ export interface ParallelResult<R> {
 export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ *
+ * `max <= 0` (or any non-finite input) means unbounded — every `acquire()` resolves
+ * immediately — matching `task.maxConcurrency = 0`'s "Unlimited" semantics in the
+ * settings UI ([#3305](https://github.com/can1357/oh-my-pi/issues/3305)).
  */
 export declare class Semaphore {
     #private;

package/dist/types/thinking.d.ts

@@ -77,8 +77,15 @@ export declare function parseCliThinkingLevel(value: string | null | undefined):
  * above Low (falling back to the full supported set only when the model maxes
  * out below Low). Within that pool the request snaps to the highest level not
  * exceeding it, or the pool minimum when the request is below the pool.
+ *
+ * Returns `undefined` for reasoning-capable models without a controllable
+ * effort surface (`thinking.efforts` empty — e.g. devin-agent models, where
+ * Cascade selects effort by routing to sibling model ids). Matches
+ * {@link clampThinkingLevelForModel}: with no effort to pick, `auto` must not
+ * forward a concrete effort that would then trip {@link requireSupportedEffort}
+ * downstream.
  */
-export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort;
+export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort | undefined;
 /**
  * The provisional concrete level shown while `auto` is configured but before a
  * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,

package/dist/types/tiny/title-client.d.ts

@@ -1,4 +1,4 @@
-import { type SpawnedSubprocess, type WorkerHandle } from "../subprocess/worker-client";
+import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
 export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
@@ -44,7 +44,7 @@ export declare function tinyWorkerEnv(): Record<string, string>;
 export declare function createTinyTitleSubprocess(): SpawnedSubprocess<TinyTitleWorkerOutbound>;
 export declare class TinyTitleClient {
     #private;
-    constructor(spawnWorker?: () => WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
+    constructor(spawnWorker?: () => RefCountedWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;

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

@@ -1,6 +1,8 @@
 export declare function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null;
 export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
 export declare function getToolPath(tool: ToolName): string | null;
+/** Download a tool asset without handing the streaming Response to Bun.write. */
+export declare function downloadFile(url: string, dest: string, signal?: AbortSignal): Promise<void>;
 type EnsureToolOptions = {
     signal?: AbortSignal;
     silent?: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.16",
+	"version": "16.1.17",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.16",
-		"@oh-my-pi/omp-stats": "16.1.16",
-		"@oh-my-pi/pi-agent-core": "16.1.16",
-		"@oh-my-pi/pi-ai": "16.1.16",
-		"@oh-my-pi/pi-catalog": "16.1.16",
-		"@oh-my-pi/pi-mnemopi": "16.1.16",
-		"@oh-my-pi/pi-natives": "16.1.16",
-		"@oh-my-pi/pi-tui": "16.1.16",
-		"@oh-my-pi/pi-utils": "16.1.16",
-		"@oh-my-pi/pi-wire": "16.1.16",
-		"@oh-my-pi/snapcompact": "16.1.16",
+		"@oh-my-pi/hashline": "16.1.17",
+		"@oh-my-pi/omp-stats": "16.1.17",
+		"@oh-my-pi/pi-agent-core": "16.1.17",
+		"@oh-my-pi/pi-ai": "16.1.17",
+		"@oh-my-pi/pi-catalog": "16.1.17",
+		"@oh-my-pi/pi-mnemopi": "16.1.17",
+		"@oh-my-pi/pi-natives": "16.1.17",
+		"@oh-my-pi/pi-tui": "16.1.17",
+		"@oh-my-pi/pi-utils": "16.1.17",
+		"@oh-my-pi/pi-wire": "16.1.17",
+		"@oh-my-pi/snapcompact": "16.1.17",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/auto-thinking/classifier.ts

@@ -55,10 +55,15 @@ export interface ClassifyDifficultyDeps {
 }
 
 /**
- * Classify `promptText` and return a concrete effort clamped to `deps.model`.
+ * Classify `promptText` and return a concrete effort clamped to `deps.model`,
+ * or `undefined` when the model has no controllable effort surface (auto has
+ * nothing to pick — the caller leaves the prior reasoning level in place).
  * @throws when the backend cannot produce a usable classification.
  */
-export async function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+export async function classifyDifficulty(
+	promptText: string,
+	deps: ClassifyDifficultyDeps,
+): Promise<Effort | undefined> {
 	const backend = deps.settings.get("providers.autoThinkingModel");
 	const input = prepareClassifierInput(promptText);
 	const effort =

package/src/cli/profile-alias.ts

@@ -198,37 +198,68 @@ export function resolveProfileAliasCommandFromProcess(
 	if (!runtime || !script || !/\.[cm]?[jt]s$/.test(script)) return DEFAULT_ALIAS_COMMAND;
 
 	const scriptPath = path.resolve(cwd, script);
-	const posix = `${quoteForShell(runtime)} ${quoteForShell(scriptPath)}`;
+	// Normalize to forward slashes for POSIX shell fields — bash/zsh/fish
+	// can't resolve backslash-separated paths, even on Windows (Git Bash, WSL).
+	const posixScriptPath = scriptPath.replace(/\\/g, "/");
+	const posixRuntime = runtime.replace(/\\/g, "/");
+	const posix = `${quoteForShell(posixRuntime)} ${quoteForShell(posixScriptPath)}`;
 	return {
-		display: `${runtime} ${scriptPath}`,
+		display: `${posixRuntime} ${posixScriptPath}`,
 		posix,
 		fish: posix,
 		powerShell: `${quoteForPowerShell(runtime)} ${quoteForPowerShell(scriptPath)}`,
 	};
 }
 
+/** Normalize backslashes to forward slashes for POSIX-shell paths.
+ *  path.posix.join only adds / separators — it preserves existing backslashes
+ *  in input segments like homeDir ("C:\Users\me"), producing mixed paths.
+ *  Windows UNC paths (\\server\share) become //server/share — path.posix.join
+ *  would collapse the leading // to /, so we restore it after joining. */
+function toPosix(p: string): string {
+	return p.replace(/\\/g, "/");
+}
+
+/** Like path.posix.join, but preserves leading // (UNC roots) which
+ *  path.posix.join collapses to a single /. */
+function posixJoinUnc(...segments: string[]): string {
+	const joined = path.posix.join(...segments);
+	// path.posix.join normalizes // at the start to /, breaking UNC roots.
+	// Restore it if any input segment started with // (a toPosix'd UNC path).
+	if (segments.some(s => s.startsWith("//") && !s.startsWith("///"))) {
+		return `/${joined}`;
+	}
+	return joined;
+}
+
 function resolveShellConfigPath(
 	shell: ProfileAliasShell,
 	homeDir: string,
 	platform: NodeJS.Platform,
 	env: NodeJS.ProcessEnv,
 ): string {
+	// POSIX shells (bash/zsh/fish) always need forward-slash config paths,
+	// even on Windows. path.posix.join adds / separators but preserves existing
+	// backslashes in input segments, so we normalize each component with toPosix.
+	// PowerShell profiles use the platform-native path.join (backslashes on
+	// Windows, forward slashes elsewhere).
+	const posixHome = toPosix(homeDir);
 	switch (shell) {
 		case "zsh":
-			return path.join(env.ZDOTDIR || homeDir, ".zshrc");
+			return posixJoinUnc(env.ZDOTDIR ? toPosix(env.ZDOTDIR) : posixHome, ".zshrc");
 		case "bash":
-			return platform === "darwin" ? path.join(homeDir, ".bash_profile") : path.join(homeDir, ".bashrc");
+			return platform === "darwin" ? posixJoinUnc(posixHome, ".bash_profile") : posixJoinUnc(posixHome, ".bashrc");
 		case "fish": {
 			// fish sources conf.d from $XDG_CONFIG_HOME/fish (default ~/.config/fish);
 			// a hard-coded ~/.config would be silently ignored when the user relocates
 			// their XDG config root, leaving the alias unsourced after a restart.
-			const configHome = env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
-			return path.join(configHome, "fish", "conf.d", "omp-profiles.fish");
+			const configHome = env.XDG_CONFIG_HOME ? toPosix(env.XDG_CONFIG_HOME) : posixJoinUnc(posixHome, ".config");
+			return posixJoinUnc(configHome, "fish", "conf.d", "omp-profiles.fish");
 		}
 		case "pwsh":
 			return platform === "win32"
 				? path.join(homeDir, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
-				: path.join(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+				: posixJoinUnc(posixHome, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
 		case "powershell":
 			return path.join(homeDir, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
 	}

package/src/cli/usage-cli.ts

@@ -15,7 +15,7 @@ import {
 	type UsageReport,
 	type UsageUnit,
 } from "@oh-my-pi/pi-ai";
-import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, sanitizeText } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { ModelRegistry } from "../config/model-registry";
 import { discoverAuthStorage } from "../sdk";
@@ -450,6 +450,10 @@ export function formatUsageBreakdown(
 		lines.push(
 			`${chalk.bold.cyan(formatProviderName(provider))} ${chalk.dim(`— ${accountCount} ${accountCount === 1 ? "account" : "accounts"}`)}`,
 		);
+		// Provider-wide disclaimers render once per provider, not per limit.
+		const providerNotes = [...new Set(providerReports.flatMap(report => report.notes ?? []))];
+		for (const note of providerNotes)
+			lines.push(`  ${chalk.dim(sanitizeText(note.replace(/[\r\n]+/g, " ").replace(/\t/g, "  ")))}`);
 
 		const labelWidth = providerReports
 			.flatMap(report => report.limits)

package/src/config/model-discovery.ts

@@ -117,6 +117,11 @@ type LlamaCppDiscoveredServerMetadata = {
 	input?: ("text" | "image")[];
 };
 
+type LlamaCppModelListEntry = {
+	id: string;
+	contextWindow?: number;
+};
+
 function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
 		return value;
@@ -162,6 +167,26 @@ function extractLlamaCppContextWindow(payload: Record<string, unknown>): number
 	return toPositiveNumberOrUndefined(payload.n_ctx);
 }
 
+function extractLlamaCppModelContextWindow(item: Record<string, unknown>): number | undefined {
+	const meta = item.meta;
+	if (!isRecord(meta)) {
+		return undefined;
+	}
+	return toPositiveNumberOrUndefined(meta.n_ctx) ?? toPositiveNumberOrUndefined(meta.n_ctx_train);
+}
+
+function parseLlamaCppModelList(payload: unknown): LlamaCppModelListEntry[] {
+	if (!isRecord(payload) || !Array.isArray(payload.data)) {
+		return [];
+	}
+	return payload.data.flatMap(item => {
+		if (!isRecord(item) || typeof item.id !== "string" || !item.id) {
+			return [];
+		}
+		return [{ id: item.id, contextWindow: extractLlamaCppModelContextWindow(item) }];
+	});
+}
+
 function extractLlamaCppInputCapabilities(payload: Record<string, unknown>): ("text" | "image")[] | undefined {
 	const modalities = payload.modalities;
 	if (!isRecord(modalities)) {
@@ -338,12 +363,13 @@ export async function discoverLlamaCppModels(
 	const [response, serverMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as { data?: Array<{ id: string }> };
-	const models = payload.data ?? [];
+	const payload = (await response.json()) as unknown;
+	const models = parseLlamaCppModelList(payload);
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
-		const id = item.id;
+		const { id } = item;
 		if (!id) continue;
+		const contextWindow = item.contextWindow ?? serverMetadata?.contextWindow ?? 128000;
 		discovered.push(
 			buildModel({
 				id,
@@ -355,11 +381,8 @@ export async function discoverLlamaCppModels(
 				input: serverMetadata?.input ?? ["text"],
 				imageInputDecoder: "stb",
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: serverMetadata?.contextWindow ?? 128000,
-				maxTokens: Math.min(
-					serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY,
-					DISCOVERY_DEFAULT_MAX_TOKENS,
-				),
+				contextWindow,
+				maxTokens: Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS),
 				headers,
 				compat: {
 					supportsStore: false,
@@ -372,6 +395,34 @@ export async function discoverLlamaCppModels(
 	return discovered;
 }
 
+export async function discoverLlamaCppModelContextWindow(
+	model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">,
+	ctx: DiscoveryContext,
+): Promise<number | undefined> {
+	const baseUrl = normalizeLlamaCppBaseUrl(model.baseUrl);
+	const modelsUrl = `${baseUrl}/models`;
+	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
+	const attempt = async (headers: Record<string, string>) => {
+		const response = await ctx.fetch(modelsUrl, {
+			headers,
+			signal: AbortSignal.timeout(250),
+		});
+		if (!response.ok) {
+			return undefined;
+		}
+		const entries = parseLlamaCppModelList(await response.json());
+		return entries.find(entry => entry.id === model.id)?.contextWindow;
+	};
+	try {
+		const apiKey = await ctx.getBearerApiKeyResolver(model.provider);
+		return apiKey
+			? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
+			: await attempt(baseHeaders);
+	} catch {
+		return undefined;
+	}
+}
+
 export async function discoverOpenAIModelsList(
 	providerConfig: DiscoveryProviderConfig,
 	ctx: DiscoveryContext,