@oh-my-pi/pi-coding-agent 16.0.8 → 16.0.10

package/dist/types/cli/args.d.ts

@@ -42,6 +42,7 @@ export interface Args {
     noExtensions?: boolean;
     pluginDirs?: string[];
     print?: boolean;
+    printThoughts?: boolean;
     export?: string;
     noSkills?: boolean;
     skills?: string[];

package/dist/types/collab/host.d.ts

@@ -16,14 +16,14 @@ export declare class CollabHost {
     #private;
     constructor(ctx: InteractiveModeContext);
     get link(): string;
-    /** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+    /** Browser deep link for the configured collab web UI. */
     get webLink(): string;
     /** Read-only variant of {@link link}: bare room key, no write token. */
     get viewLink(): string;
     /** Read-only variant of {@link webLink}. */
     get webViewLink(): string;
     get participants(): CollabParticipant[];
-    start(relayUrl: string): Promise<void>;
+    start(relayUrl: string, webUrl?: string): Promise<void>;
     /** Broadcast a goodbye, detach all taps, and close the socket. */
     stop(reason: string): Promise<void>;
 }

package/dist/types/collab/protocol.d.ts

@@ -108,12 +108,11 @@ export declare function generateRoomId(): string;
  */
 export declare function formatCollabLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
 /**
- * Render the browser deep link: `http(s)://<relay-host>/#<collab-link>`. The
- * relay serves the web client at `/`, and the whole collab link (including the
- * room key) rides in the fragment, so it never appears in any HTTP request.
- * Terminals auto-link the https form, making it click-to-join.
+ * Render the browser deep link. The browser UI may be hosted separately from
+ * the relay; the fragment always carries the relay-specific collab link, so
+ * room secrets stay out of HTTP path and query bytes.
  */
-export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array): string;
+export declare function formatCollabWebLink(relayUrl: string, roomId: string, key: Uint8Array, writeToken?: Uint8Array, webUrl?: string): string;
 export declare function parseCollabLink(link: string): ParsedCollabLink | {
     error: string;
 };

package/dist/types/commands/launch.d.ts

@@ -127,6 +127,9 @@ export default class Index extends Command {
         "no-title": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        "print-thoughts": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
         "max-time": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

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

@@ -32,11 +32,17 @@ export interface ScopedModel {
     thinkingLevel?: ThinkingLevel;
     explicitThinkingLevel: boolean;
 }
+interface ThinkingSuffixOptions {
+    allowMaxAlias?: boolean;
+}
+interface ModelStringParseOptions extends ThinkingSuffixOptions {
+    isLiteralModelId?: (provider: string, id: string) => boolean;
+}
 /**
  * Parse a model string in "provider/modelId" format.
  * Returns undefined if the format is invalid.
  */
-export declare function parseModelString(modelStr: string): {
+export declare function parseModelString(modelStr: string, options?: ModelStringParseOptions): {
     provider: string;
     id: string;
     thinkingLevel?: ThinkingLevel;
@@ -115,7 +121,10 @@ export declare function resolveModelRoleValue(roleValue: string | undefined, ava
     matchPreferences?: ModelMatchPreferences;
     modelRegistry?: CanonicalModelRegistry;
 }): ResolvedModelRoleValue;
-export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings): ThinkingLevel | undefined;
+interface ExplicitThinkingSelectorOptions {
+    isLiteralModelId?: (provider: string, id: string) => boolean;
+}
+export declare function extractExplicitThinkingSelector(value: string | undefined, settings?: Settings, options?: ExplicitThinkingSelectorOptions): ThinkingLevel | undefined;
 /**
  * Resolve a model identifier or pattern to a Model instance.
  */

package/dist/types/config/settings-schema.d.ts

@@ -835,7 +835,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly defaultThinkingLevel: {
         readonly type: "enum";
-        readonly values: readonly [...import("@oh-my-pi/pi-catalog").Effort[], "auto"];
+        readonly values: readonly [...import("@oh-my-pi/pi-catalog").Effort[], "auto", "max"];
         readonly default: "high";
         readonly ui: {
             readonly tab: "model";
@@ -1579,6 +1579,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Relay used by /collab (wss://host[:port])";
         };
     };
+    readonly "collab.webUrl": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Web UI URL";
+            readonly description: "Browser UI used by /collab links; empty derives from collab.relayUrl; explicit http:// is localhost-only";
+        };
+    };
     readonly "collab.displayName": {
         readonly type: "string";
         readonly default: "";
@@ -2012,7 +2022,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "pi";
                 readonly label: "Pi";
-                readonly description: "Use the Pi owned dialect.";
+                readonly description: "Use the Pi owned dialect (compact sigil-delimited tool calls).";
             }, {
                 readonly value: "qwen3";
                 readonly label: "Qwen3";

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

@@ -36,6 +36,7 @@ export declare class GoalRuntime {
     #private;
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
+    clearAccounting(): void;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;
@@ -46,7 +47,9 @@ export declare class GoalRuntime {
     onTaskAborted(options?: {
         reason?: "interrupted" | "internal";
     }): Promise<void>;
-    onThreadResumed(): Promise<GoalModeState | undefined>;
+    onThreadResumed(options?: {
+        preserveActiveGoal?: boolean;
+    }): Promise<GoalModeState | undefined>;
     onBudgetMutated(newBudget: number | undefined): Promise<GoalModeState | undefined>;
     flushUsage(steering: GoalBudgetSteering, currentUsage?: GoalTokenUsage): Promise<void>;
     createGoal(input: {

package/dist/types/modes/print-mode.d.ts

@@ -19,6 +19,8 @@ export interface PrintModeOptions {
     initialMessage?: string;
     /** Images to attach to the initial message */
     initialImages?: ImageContent[];
+    /** If true, include thinking blocks in text output */
+    printThoughts?: boolean;
 }
 /**
  * Run in print (single-shot) mode.

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

@@ -237,6 +237,13 @@ export interface AgentSessionConfig {
     advisorReadOnlyTools?: AgentTool[];
     /** Preloaded watchdog prompt content for the advisor. */
     advisorWatchdogPrompt?: string;
+    /**
+     * Disconnect this session's OWNED MCP manager on dispose. Provided only when
+     * the session created the manager (top-level sessions); subagents reuse a
+     * parent's manager via `options.mcpManager` and omit this so a child's
+     * teardown never tears down the shared servers.
+     */
+    disconnectOwnedMcpManager?: () => Promise<void>;
 }
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -552,6 +559,12 @@ export declare class AgentSession {
     get hasPostPromptWork(): boolean;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
+    /** Latest image attachments addressable by tools as `Image #N` or `attachment://N`. */
+    getImageAttachments(): {
+        label: string;
+        uri: string;
+        image: ImageContent;
+    }[];
     buildDisplaySessionContext(): SessionContext;
     /**
      * Full-history transcript for TUI display: every path entry in

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -1,4 +1,4 @@
-import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
+import { type AutocompleteItem } from "@oh-my-pi/pi-tui";
 import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */

package/dist/types/slash-commands/helpers/collab-qrcode.d.ts

@@ -0,0 +1,13 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+/**
+ * One-shot transcript block that prints a collab browser-join URL as a
+ * scannable QR code. The symbol is encoded once at construction (byte mode,
+ * EC level M) and rendered as ANSI half-blocks; on terminals too narrow for
+ * the symbol it degrades to a one-line hint pointing at the printed URL.
+ */
+export declare class CollabQrCodeComponent implements Component {
+    #private;
+    readonly url: string;
+    constructor(url: string);
+    render(width: number): readonly string[];
+}

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

@@ -1,6 +1,6 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { FetchImpl, Model, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { FetchImpl, ImageContent, Model, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager";
 import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -71,6 +71,12 @@ export type ContextFileEntry = {
     content: string;
     depth?: number;
 };
+/** Image attachment handle exposed to tools for user-facing labels such as `Image #1`. */
+export type ImageAttachmentEntry = {
+    label: string;
+    uri: string;
+    image: ImageContent;
+};
 export type { DiscoverableTool, DiscoverableToolSearchIndex, DiscoverableToolSearchResult, DiscoverableToolSource, } from "../tool-discovery/tool-index";
 /**
  * A late LSP diagnostics result that arrived after the edit/write tool already
@@ -309,6 +315,8 @@ export interface ToolSession {
     /** Get the active OpenTelemetry config so subagent dispatch can forward
      *  the parent's tracer/hooks with the subagent's own identity stamped. */
     getTelemetry?: () => AgentTelemetryConfig | undefined;
+    /** Return image attachments visible to tools for resolving labels such as `Image #1`. */
+    getImageAttachments?: () => ImageAttachmentEntry[];
 }
 export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export type BuiltinToolLoadMode = "essential" | "discoverable";

package/dist/types/utils/image-loading.d.ts

@@ -25,6 +25,16 @@ export interface LoadImageInputOptions {
     /** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
     excludeWebP?: boolean;
 }
+/** Options for loading an in-memory chat image attachment as a vision-model input. */
+export interface LoadImageAttachmentInputOptions {
+    image: ImageContent;
+    label: string;
+    uri: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    /** Force non-WebP output (e.g. for Ollama). Leave unset to honor `OMP_NO_WEBP`. */
+    excludeWebP?: boolean;
+}
 export interface LoadedImageInput {
     resolvedPath: string;
     mimeType: string;
@@ -53,3 +63,5 @@ export interface NormalizeModelContextImagesOptions {
  */
 export declare function normalizeModelContextImages(images: ImageContent[] | undefined, options?: NormalizeModelContextImagesOptions): Promise<ImageContent[] | undefined>;
 export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;
+/** Loads a chat attachment image through the same size and encoder policy as file-backed image inputs. */
+export declare function loadImageAttachmentInput(options: LoadImageAttachmentInputOptions): Promise<LoadedImageInput | null>;

package/dist/types/utils/qrcode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Self-contained QR Code generator (byte mode, versions 1-40, EC levels
+ * L/M/Q/H) with a half-block ANSI terminal renderer.
+ *
+ * Pure TypeScript, zero dependencies: the collab `/collab qrcode` command uses
+ * it to print scannable browser-join codes without pulling a runtime QR
+ * package into the bundle. The algorithm follows ISO/IEC 18004; the two
+ * error-correction tables below are direct transcriptions of that spec.
+ */
+export type QrEcLevel = "L" | "M" | "Q" | "H";
+export interface QrEncodeOptions {
+    /** Lowest version to consider (default 1). */
+    minVersion?: number;
+    /** Highest version to consider (default 40). */
+    maxVersion?: number;
+    /** Force a mask 0-7; -1 (default) auto-selects the lowest-penalty mask. */
+    mask?: number;
+}
+/**
+ * A finished QR symbol: a square grid of dark/light modules plus the chosen
+ * version, EC level, and mask. `module(x, y)` is the only access path the
+ * renderers need.
+ */
+export declare class QrCode {
+    #private;
+    readonly version: number;
+    readonly ecLevel: QrEcLevel;
+    readonly size: number;
+    /** Selected mask pattern (0-7). */
+    readonly mask: number;
+    private constructor();
+    module(x: number, y: number): boolean;
+    /** Encode a string in byte mode (UTF-8). Throws if it exceeds version 40. */
+    static encodeText(text: string, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+    /** Encode raw bytes in byte mode. Throws if they exceed version 40 at this EC level. */
+    static encodeBytes(data: Uint8Array, ecLevel?: QrEcLevel, options?: QrEncodeOptions): QrCode;
+}
+export interface QrRenderOptions {
+    /** Quiet-zone width in modules on every side (default 4, per spec). */
+    margin?: number;
+}
+/**
+ * Render a QR symbol as ANSI half-block rows: each text row packs two module
+ * rows via `▀`/`▄`/`█`, drawn black-on-white so a phone camera reads dark
+ * modules as data and the quiet zone as the light margin. The leading margin
+ * makes the symbol scannable regardless of the terminal's own background.
+ */
+export declare function renderQrHalfBlocks(qr: QrCode, options?: QrRenderOptions): string[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.8",
+	"version": "16.0.10",
 	"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.0.8",
-		"@oh-my-pi/omp-stats": "16.0.8",
-		"@oh-my-pi/pi-agent-core": "16.0.8",
-		"@oh-my-pi/pi-ai": "16.0.8",
-		"@oh-my-pi/pi-catalog": "16.0.8",
-		"@oh-my-pi/pi-mnemopi": "16.0.8",
-		"@oh-my-pi/pi-natives": "16.0.8",
-		"@oh-my-pi/pi-tui": "16.0.8",
-		"@oh-my-pi/pi-utils": "16.0.8",
-		"@oh-my-pi/pi-wire": "16.0.8",
-		"@oh-my-pi/snapcompact": "16.0.8",
+		"@oh-my-pi/hashline": "16.0.10",
+		"@oh-my-pi/omp-stats": "16.0.10",
+		"@oh-my-pi/pi-agent-core": "16.0.10",
+		"@oh-my-pi/pi-ai": "16.0.10",
+		"@oh-my-pi/pi-catalog": "16.0.10",
+		"@oh-my-pi/pi-mnemopi": "16.0.10",
+		"@oh-my-pi/pi-natives": "16.0.10",
+		"@oh-my-pi/pi-tui": "16.0.10",
+		"@oh-my-pi/pi-utils": "16.0.10",
+		"@oh-my-pi/pi-wire": "16.0.10",
+		"@oh-my-pi/snapcompact": "16.0.10",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/args.ts

@@ -56,6 +56,7 @@ export interface Args {
 	noExtensions?: boolean;
 	pluginDirs?: string[];
 	print?: boolean;
+	printThoughts?: boolean;
 	export?: string;
 	noSkills?: boolean;
 	skills?: string[];
@@ -200,6 +201,8 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.advisor = true;
 		} else if (arg === "--print" || arg === "-p") {
 			result.print = true;
+		} else if (arg === "--print-thoughts") {
+			result.printThoughts = true;
 		} else if (arg === "--no-extensions") {
 			result.noExtensions = true;
 		} else if (arg === "--no-skills") {
@@ -211,7 +214,13 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 		} else if (arg === "--auto-approve" || arg === "--yolo") {
 			result.autoApprove = true;
 		} else if (arg.startsWith("@")) {
-			result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+			let filePath = arg.slice(1);
+			if (filePath.startsWith('"') && filePath.endsWith('"') && filePath.length > 1) {
+				filePath = filePath.slice(1, -1);
+			} else if (filePath.startsWith("'") && filePath.endsWith("'") && filePath.length > 1) {
+				filePath = filePath.slice(1, -1);
+			}
+			result.fileArgs.push(filePath);
 		} else if (!arg.startsWith("-") || arg === "-") {
 			// Plain positional or lone `-` (stdin marker) — pass through as a
 			// message rather than flagging it.

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/collab/host.ts

@@ -133,7 +133,7 @@ export class CollabHost {
 		return this.#link;
 	}
 
-	/** Browser deep link (`https://<relay>/#<link>`) — the relay serves the web client at `/`. */
+	/** Browser deep link for the configured collab web UI. */
 	get webLink(): string {
 		return this.#webLink;
 	}
@@ -156,15 +156,15 @@ export class CollabHost {
 		return list;
 	}
 
-	async start(relayUrl: string): Promise<void> {
+	async start(relayUrl: string, webUrl = ""): Promise<void> {
 		const rawKey = generateRoomKey();
 		const writeToken = generateWriteToken();
 		const roomId = generateRoomId();
 		this.#writeToken = writeToken;
 		this.#link = formatCollabLink(relayUrl, roomId, rawKey, writeToken);
-		this.#webLink = formatCollabWebLink(relayUrl, roomId, rawKey, writeToken);
+		this.#webLink = formatCollabWebLink(relayUrl, roomId, rawKey, writeToken, webUrl);
 		this.#viewLink = formatCollabLink(relayUrl, roomId, rawKey);
-		this.#webViewLink = formatCollabWebLink(relayUrl, roomId, rawKey);
+		this.#webViewLink = formatCollabWebLink(relayUrl, roomId, rawKey, undefined, webUrl);
 		const parsed = parseCollabLink(this.#link);
 		if ("error" in parsed) throw new Error(parsed.error);
 		const key = await importRoomKey(rawKey);

package/src/collab/protocol.ts

@@ -116,6 +116,10 @@ const BARE_LINK_RE = /^([A-Za-z0-9_-]{10,64})[#.]([A-Za-z0-9_-]+)$/;
 const B64URL_RE = /^[A-Za-z0-9_-]+$/;
 const LOCAL_HOSTNAMES: Record<string, true> = { localhost: true, "127.0.0.1": true, "::1": true, "[::1]": true };
 
+function isLocalHostname(hostname: string): boolean {
+	return LOCAL_HOSTNAMES[hostname] === true;
+}
+
 export function generateRoomId(): string {
 	const bytes = new Uint8Array(ROOM_ID_BYTES);
 	crypto.getRandomValues(bytes);
@@ -143,7 +147,7 @@ function normalizeRelayOrigin(relayUrl: string): { origin: string } | { error: s
 		default:
 			return { error: `Unsupported relay URL scheme: ${url.protocol}` };
 	}
-	if (scheme === "ws:" && !LOCAL_HOSTNAMES[url.hostname]) {
+	if (scheme === "ws:" && !isLocalHostname(url.hostname)) {
 		return { error: "relay link must be wss:// (plain ws:// is only allowed for localhost)" };
 	}
 	const port = url.port ? `:${url.port}` : "";
@@ -178,24 +182,48 @@ export function formatCollabLink(relayUrl: string, roomId: string, key: Uint8Arr
 	return `${compact}/r/${roomId}.${keyText}`;
 }
 
+function normalizeCollabWebBaseUrl(relayUrl: string, webUrl?: string): string {
+	const explicitWebUrl = webUrl?.trim();
+	if (!explicitWebUrl) {
+		const normalized = normalizeRelayOrigin(relayUrl);
+		if ("error" in normalized) throw new Error(normalized.error);
+		return normalized.origin.startsWith("wss://")
+			? `https://${normalized.origin.slice("wss://".length)}`
+			: `http://${normalized.origin.slice("ws://".length)}`;
+	}
+
+	let url: URL;
+	try {
+		url = new URL(explicitWebUrl);
+	} catch {
+		throw new Error("collab.webUrl must start with http:// or https://");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		throw new Error("collab.webUrl must start with http:// or https://");
+	}
+	if (url.protocol === "http:" && !isLocalHostname(url.hostname)) {
+		throw new Error("collab.webUrl must use https:// unless it targets localhost");
+	}
+	if (url.search || url.hash) {
+		throw new Error("collab.webUrl must not include a query string or fragment");
+	}
+	const path = url.pathname.replace(/\/+$/, "");
+	return `${url.origin}${path}`;
+}
+
 /**
- * Render the browser deep link: `http(s)://<relay-host>/#<collab-link>`. The
- * relay serves the web client at `/`, and the whole collab link (including the
- * room key) rides in the fragment, so it never appears in any HTTP request.
- * Terminals auto-link the https form, making it click-to-join.
+ * Render the browser deep link. The browser UI may be hosted separately from
+ * the relay; the fragment always carries the relay-specific collab link, so
+ * room secrets stay out of HTTP path and query bytes.
  */
 export function formatCollabWebLink(
 	relayUrl: string,
 	roomId: string,
 	key: Uint8Array,
 	writeToken?: Uint8Array,
+	webUrl?: string,
 ): string {
-	const normalized = normalizeRelayOrigin(relayUrl);
-	if ("error" in normalized) throw new Error(normalized.error);
-	const httpOrigin = normalized.origin.startsWith("wss://")
-		? `https://${normalized.origin.slice("wss://".length)}`
-		: `http://${normalized.origin.slice("ws://".length)}`;
-	return `${httpOrigin}/#${formatCollabLink(relayUrl, roomId, key, writeToken)}`;
+	return `${normalizeCollabWebBaseUrl(relayUrl, webUrl)}/#${formatCollabLink(relayUrl, roomId, key, writeToken)}`;
 }
 
 export function parseCollabLink(link: string): ParsedCollabLink | { error: string } {
@@ -213,15 +241,20 @@ export function parseCollabLink(link: string): ParsedCollabLink | { error: strin
 	} catch {
 		return { error: `Invalid collab link: ${link}` };
 	}
+	if ((url.protocol === "http:" || url.protocol === "https:") && url.hash) {
+		const inner = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
+		const parsed = parseCollabLink(inner);
+		if (!("error" in parsed)) return parsed;
+	}
 	const normalized = normalizeRelayOrigin(url.origin);
 	if ("error" in normalized) return normalized;
 	const match = ROOM_PATH_RE.exec(url.pathname);
 	if (!match) {
-		// Web deep link: `http(s)://<relay>/#<collab-link>` — the fragment holds
-		// the whole link, so recurse on it. The recursion terminates because
-		// the inner text is a strict suffix of the input.
+		// Non-http(s) deep links may also carry a complete collab link in the
+		// fragment. http(s) links are handled once above so invalid fragments
+		// fall through to direct relay validation instead of double-recursing.
 		const inner = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
-		if (inner) return parseCollabLink(inner);
+		if (inner && url.protocol !== "http:" && url.protocol !== "https:") return parseCollabLink(inner);
 		return { error: "Collab link must contain a /r/<roomId> path" };
 	}
 	const roomId = match[1]!;

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/config-file.ts

@@ -40,7 +40,7 @@ function migrateJsonToYml(jsonPath: string, ymlPath: string) {
 		}
 
 		const content = fs.readFileSync(jsonPath, "utf-8");
-		const parsed = JSON.parse(content);
+		const parsed = JSONC.parse(content);
 		if (!parsed) {
 			logger.warn("migrateJsonToYml: invalid json structure", { path: jsonPath });
 			migratedPaths.add(key);

package/src/config/keybindings.ts

@@ -10,7 +10,7 @@ import {
 	KeybindingsManager as TuiKeybindingsManager,
 } from "@oh-my-pi/pi-tui";
 import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
+import { JSONC, YAML } from "bun";
 
 /**
  * Application-level keybindings (coding agent specific).
@@ -381,7 +381,7 @@ function loadRawConfig(filePath: string): unknown {
 	try {
 		const content = fs.readFileSync(filePath, "utf-8");
 		if (filePath.endsWith(".json")) {
-			return JSON.parse(content);
+			return JSONC.parse(content);
 		}
 		if (filePath.endsWith(".yml") || filePath.endsWith(".yaml")) {
 			return YAML.parse(content);

package/src/config/model-registry.ts

@@ -563,10 +563,16 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 	} as ModelSpec<Api>);
 }
 
-function normalizeSuppressedSelector(selector: string): string {
+function normalizeSuppressedSelector(
+	selector: string,
+	hasLiveModel?: (provider: string, id: string) => boolean,
+): string {
 	const trimmed = selector.trim();
 	if (!trimmed) return trimmed;
-	const parsed = parseModelString(trimmed);
+	const parsed = parseModelString(trimmed, {
+		allowMaxAlias: true,
+		isLiteralModelId: (provider, id) => hasLiveModel?.(provider, id) === true,
+	});
 	if (!parsed) return trimmed;
 	// Retired effort-tier variant ids normalize to their collapsed logical id
 	// so persisted suppressions keyed by raw member ids still bind.
@@ -2155,14 +2161,20 @@ export class ModelRegistry {
 	 * Suppress a specific model selector (e.g., "provider/id") until a specific timestamp.
 	 */
 	suppressSelector(selector: string, untilMs: number): void {
-		this.#suppressedSelectors.set(normalizeSuppressedSelector(selector), untilMs);
+		this.#suppressedSelectors.set(
+			normalizeSuppressedSelector(selector, (provider, id) => this.find(provider, id) !== undefined),
+			untilMs,
+		);
 	}
 
 	/**
 	 * Check if a model selector is currently suppressed due to rate limits.
 	 */
 	isSelectorSuppressed(selector: string): boolean {
-		const normalizedSelector = normalizeSuppressedSelector(selector);
+		const normalizedSelector = normalizeSuppressedSelector(
+			selector,
+			(provider, id) => this.find(provider, id) !== undefined,
+		);
 		const suppressedUntil = this.#suppressedSelectors.get(normalizedSelector);
 		if (!suppressedUntil) return false;
 		if (suppressedUntil <= Date.now()) {