@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.3

package/src/session/session-persistence.ts

@@ -141,6 +141,100 @@ function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string
 	return obj;
 }
 
+/**
+ * Read the duplication-relevant fields of an OpenAI Responses reasoning item.
+ * Returns `undefined` for anything that is not a `type: "reasoning"` object, so
+ * non-reasoning payload entries and corrupt signatures are never matched.
+ */
+function readReasoningItem(item: unknown): { encrypted_content?: string; id?: string } | undefined {
+	if (item === null || typeof item !== "object") return undefined;
+	if (!("type" in item) || item.type !== "reasoning") return undefined;
+	const reasoning: { encrypted_content?: string; id?: string } = {};
+	if ("encrypted_content" in item && typeof item.encrypted_content === "string" && item.encrypted_content.length > 0) {
+		reasoning.encrypted_content = item.encrypted_content;
+	}
+	if ("id" in item && typeof item.id === "string" && item.id.length > 0) reasoning.id = item.id;
+	return reasoning;
+}
+
+/**
+ * True when a `thinkingSignature` (a JSON-encoded reasoning item) is already
+ * carried by a reasoning item in the message's provider payload — matched on
+ * `encrypted_content` (the load-bearing blob) when present, else on item `id`.
+ * A signature the payload does not cover is never reported as recoverable, so it
+ * is always kept.
+ */
+function signatureCoveredByPayload(
+	signature: string,
+	encrypted: ReadonlySet<string>,
+	ids: ReadonlySet<string>,
+): boolean {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(signature);
+	} catch {
+		return false;
+	}
+	const reasoning = readReasoningItem(parsed);
+	if (!reasoning) return false;
+	if (reasoning.encrypted_content) return encrypted.has(reasoning.encrypted_content);
+	if (reasoning.id) return ids.has(reasoning.id);
+	return false;
+}
+
+/**
+ * Drop `thinkingSignature` from assistant thinking blocks whose reasoning item is
+ * already carried, verbatim, in the message's OpenAI Responses `providerPayload`.
+ *
+ * Responses/Codex turns mint each reasoning item once and store it twice:
+ * `providerPayload.items` (the authoritative native-history copy that replay and
+ * remote compaction read) and `content[].thinkingSignature`, which is literally
+ * `JSON.stringify(reasoningItem)` — including the large `encrypted_content` blob.
+ * Replay only ever reads the payload; the signature is a no-payload fallback that
+ * same-provider turns never reach and cross-model turns strip as untrustworthy.
+ * Persisting both stores the encrypted reasoning twice for zero token or replay
+ * benefit, so the on-disk copy drops the duplicate signature whenever its
+ * reasoning item is recoverable from the payload. The in-memory entry is left
+ * untouched; only the serialized line is slimmed.
+ */
+function stripReplayedReasoningSignatures(entry: FileEntry): FileEntry {
+	if (entry.type !== "message" || entry.message.role !== "assistant") return entry;
+	const message = entry.message;
+	const payload = message.providerPayload;
+	if (payload?.type !== "openaiResponsesHistory" || !Array.isArray(payload.items)) return entry;
+	const hasSignedThinking = message.content.some(
+		block =>
+			block.type === "thinking" && typeof block.thinkingSignature === "string" && block.thinkingSignature.length > 0,
+	);
+	if (!hasSignedThinking) return entry;
+
+	const encrypted = new Set<string>();
+	const ids = new Set<string>();
+	for (const rawItem of payload.items) {
+		const reasoning = readReasoningItem(rawItem);
+		if (!reasoning) continue;
+		if (reasoning.encrypted_content) encrypted.add(reasoning.encrypted_content);
+		if (reasoning.id) ids.add(reasoning.id);
+	}
+	if (encrypted.size === 0 && ids.size === 0) return entry;
+
+	let changed = false;
+	const content = message.content.map(block => {
+		if (
+			block.type !== "thinking" ||
+			typeof block.thinkingSignature !== "string" ||
+			block.thinkingSignature.length === 0
+		) {
+			return block;
+		}
+		if (!signatureCoveredByPayload(block.thinkingSignature, encrypted, ids)) return block;
+		changed = true;
+		return { ...block, thinkingSignature: undefined };
+	});
+	if (!changed) return entry;
+	return { ...entry, message: { ...message, content } };
+}
+
 export function prepareEntryForPersistence(entry: FileEntry, blobStore: BlobStore): FileEntry {
-	return truncateForPersistence(entry, blobStore) as FileEntry;
+	return truncateForPersistence(stripReplayedReasoningSignatures(entry), blobStore) as FileEntry;
 }

package/src/session/session-storage.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { hasFsCode, isEnoent, logger, peekFileEnds, Snowflake, toError } from "@oh-my-pi/pi-utils";
+import { overlayTitleSlotContent, type SessionTitleUpdate, serializeTitleSlot } from "./session-title-slot";
 
 const utf8Decoder = new TextDecoder("utf-8");
 
@@ -31,6 +32,14 @@ export interface SessionStorage {
 	ensureDirSync(dir: string): void;
 	existsSync(path: string): boolean;
 	writeTextSync(path: string, content: string): void;
+	/**
+	 * Update the current session title through the storage backend.
+	 *
+	 * File-like backends rewrite the fixed-width JSONL title slot; indexed
+	 * backends can store the semantic title fields and synthesize the slot when
+	 * reading.
+	 */
+	updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void>;
 	statSync(path: string): SessionStorageStat;
 	listFilesSync(dir: string, pattern: string): string[];
 
@@ -163,6 +172,25 @@ export class FileSessionStorage implements SessionStorage {
 		}
 	}
 
+	async updateSessionTitle(fpath: string, update: SessionTitleUpdate): Promise<void> {
+		const fd = fs.openSync(fpath, "r+");
+		try {
+			const buf = Buffer.from(serializeTitleSlot(update), "utf-8");
+			let offset = 0;
+			while (offset < buf.length) {
+				const written = fs.writeSync(fd, buf, offset, buf.length - offset, offset);
+				if (written === 0) {
+					throw new Error("Short write");
+				}
+				offset += written;
+			}
+		} catch (err) {
+			throw toError(err);
+		} finally {
+			fs.closeSync(fd);
+		}
+	}
+
 	statSync(path: string): SessionStorageStat {
 		const stats = fs.statSync(path);
 		return { size: stats.size, mtimeMs: stats.mtimeMs, mtime: stats.mtime };
@@ -526,6 +554,14 @@ export class MemorySessionStorage implements SessionStorage {
 		this.#files.set(path, createMemoryFileEntry(content, Date.now()));
 	}
 
+	async updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void> {
+		const entry = this.#requireEntry(path);
+		this.#files.set(
+			path,
+			createMemoryFileEntry(overlayTitleSlotContent(materializeMemoryEntry(entry), update), Date.now()),
+		);
+	}
+
 	/**
 	 * Internal O(1) append used by {@link MemorySessionStorageWriter}. Lazily
 	 * creates the entry. External callers should go through `openWriter()`

package/src/session/session-title-slot.ts

@@ -0,0 +1,141 @@
+import {
+	SESSION_TITLE_SLOT_BYTES,
+	SESSION_TITLE_SLOT_ENTRY_TYPE,
+	type SessionTitleSlotEntry,
+	type SessionTitleSource,
+} from "./session-entries";
+
+const utf8Encoder = new TextEncoder();
+
+/** Semantic title update persisted by session storage backends. */
+export interface SessionTitleUpdate {
+	title?: string;
+	source?: SessionTitleSource;
+	updatedAt: string;
+}
+
+function byteLength(value: string): number {
+	return utf8Encoder.encode(value).byteLength;
+}
+
+function titleSlotLine(title: string, source: SessionTitleSource | undefined, updatedAt: string, pad: string): string {
+	const slot: SessionTitleSlotEntry = source
+		? {
+				type: SESSION_TITLE_SLOT_ENTRY_TYPE,
+				v: 1,
+				title,
+				source,
+				updatedAt,
+				pad,
+			}
+		: {
+				type: SESSION_TITLE_SLOT_ENTRY_TYPE,
+				v: 1,
+				title,
+				updatedAt,
+				pad,
+			};
+	return `${JSON.stringify(slot)}\n`;
+}
+
+function truncateTitleForSlot(title: string, source: SessionTitleSource | undefined, updatedAt: string): string {
+	const codePoints = [...title];
+	let low = 0;
+	let high = codePoints.length;
+	let best = "";
+
+	while (low <= high) {
+		const mid = (low + high) >>> 1;
+		const candidate = codePoints.slice(0, mid).join("");
+		if (byteLength(titleSlotLine(candidate, source, updatedAt, "")) <= SESSION_TITLE_SLOT_BYTES) {
+			best = candidate;
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+
+	return best;
+}
+
+function isSessionTitleSource(value: unknown): value is SessionTitleSource {
+	return value === "auto" || value === "user";
+}
+
+function parseTitleSlotObject(value: unknown): SessionTitleSlotEntry | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const record = value as Record<string, unknown>;
+	if (record.type !== SESSION_TITLE_SLOT_ENTRY_TYPE || record.v !== 1) return undefined;
+	if (typeof record.title !== "string" || typeof record.updatedAt !== "string" || typeof record.pad !== "string") {
+		return undefined;
+	}
+	const source = record.source;
+	if (source !== undefined && !isSessionTitleSource(source)) return undefined;
+	const slot: SessionTitleSlotEntry = {
+		type: SESSION_TITLE_SLOT_ENTRY_TYPE,
+		v: 1,
+		title: record.title,
+		updatedAt: record.updatedAt,
+		pad: record.pad,
+	};
+	if (source) slot.source = source;
+	return slot;
+}
+
+/** Parse a physical title slot JSONL line. Returns undefined for legacy headers. */
+export function parseTitleSlotLine(line: string): SessionTitleSlotEntry | undefined {
+	try {
+		return parseTitleSlotObject(JSON.parse(line)) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Parse the fixed-width title slot from a physical session body. */
+export function parseTitleSlotFromContent(content: string): SessionTitleSlotEntry | undefined {
+	const newlineIndex = content.indexOf("\n");
+	if (newlineIndex < 0) return undefined;
+	return parseTitleSlotLine(content.slice(0, newlineIndex));
+}
+
+/** Convert a parsed title slot to the semantic storage update shape. */
+export function titleUpdateFromSlot(slot: SessionTitleSlotEntry | undefined): SessionTitleUpdate | undefined {
+	if (!slot) return undefined;
+	return {
+		title: slot.title,
+		source: slot.source,
+		updatedAt: slot.updatedAt,
+	};
+}
+
+/** Serialize the fixed-width first-line title slot, exactly 256 UTF-8 bytes including newline. */
+export function serializeTitleSlot(options: SessionTitleUpdate): string {
+	const title = truncateTitleForSlot(options.title ?? "", options.source, options.updatedAt);
+	const unpadded = titleSlotLine(title, options.source, options.updatedAt, "");
+	const padBytes = SESSION_TITLE_SLOT_BYTES - byteLength(unpadded);
+	if (padBytes < 0) throw new Error("Session title slot metadata exceeds fixed slot size");
+	const line = titleSlotLine(title, options.source, options.updatedAt, " ".repeat(padBytes));
+	if (byteLength(line) !== SESSION_TITLE_SLOT_BYTES) {
+		throw new Error("Session title slot serialization failed to produce fixed-width output");
+	}
+	return line;
+}
+
+/** Replace the physical fixed-width title slot in a full session body. */
+export function overlayTitleSlotContent(content: string, update: SessionTitleUpdate): string {
+	const slot = Buffer.from(serializeTitleSlot(update), "utf-8");
+	const existing = Buffer.from(content, "utf-8");
+	if (existing.length <= slot.length) return slot.toString("utf-8");
+	return Buffer.concat([slot, existing.subarray(slot.length)]).toString("utf-8");
+}
+
+/** Replace the physical fixed-width title slot in a prefix byte window. */
+export function overlayTitleSlotPrefix(prefix: string, prefixBytes: number, update: SessionTitleUpdate): string {
+	if (prefixBytes <= 0) return "";
+	const slot = Buffer.from(serializeTitleSlot(update), "utf-8");
+	if (prefixBytes <= slot.length) return slot.subarray(0, prefixBytes).toString("utf-8");
+	const existing = Buffer.from(prefix, "utf-8");
+	return Buffer.concat([slot, existing.subarray(slot.length)])
+		.subarray(0, prefixBytes)
+		.toString("utf-8");
+}

package/src/session/sql-session-storage.ts

@@ -3,6 +3,7 @@ import {
 	type SessionStorageBackend,
 	type SessionStorageIndexEntry,
 } from "./indexed-session-storage";
+import type { SessionTitleUpdate } from "./session-title-slot";
 
 /**
  * Supported `bun:sql` adapter dialects. `Bun.SQL` reports this string on
@@ -55,10 +56,14 @@ export interface SqlSessionStorageOptions {
 
 interface DialectQueries {
 	createTable: string;
+	/** Add title metadata columns to existing tables created before title fields existed. */
+	addTitleColumns: readonly string[];
 	/** Insert or replace the full content for `path`. Used for `writeText`/`flags="w"` truncate. */
 	upsertReplace: string;
 	/** Insert if missing; otherwise append the new chunk to existing content. Used for `writeLine`. */
 	upsertAppend: string;
+	/** Update indexed title metadata without rewriting the JSONL body. */
+	updateTitle: string;
 	/** Delete a single row by path. */
 	delete: string;
 	/** Move a row from one path to another (caller deletes any conflicting destination first). */
@@ -75,6 +80,9 @@ interface IndexRow {
 	path: string;
 	byte_len: number | bigint | string;
 	mtime_ms: number | bigint | string;
+	title?: string | null;
+	title_source?: string | null;
+	title_updated_at?: string | null;
 }
 
 interface ContentRow {
@@ -119,17 +127,26 @@ function buildQueries(adapter: SqlSessionStorageAdapter, table: string): Dialect
 				`CREATE TABLE IF NOT EXISTS ${table} (` +
 				`path VARCHAR(512) NOT NULL PRIMARY KEY, ` +
 				`content LONGTEXT NOT NULL, ` +
-				`mtime_ms BIGINT NOT NULL` +
+				`mtime_ms BIGINT NOT NULL, ` +
+				`title TEXT NULL, ` +
+				`title_source VARCHAR(16) NULL, ` +
+				`title_updated_at VARCHAR(64) NULL` +
 				`) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin`,
+			addTitleColumns: [
+				`ALTER TABLE ${table} ADD COLUMN title TEXT NULL`,
+				`ALTER TABLE ${table} ADD COLUMN title_source VARCHAR(16) NULL`,
+				`ALTER TABLE ${table} ADD COLUMN title_updated_at VARCHAR(64) NULL`,
+			],
 			upsertReplace:
-				`INSERT INTO ${table} (path, content, mtime_ms) VALUES (?, ?, ?) ` +
-				`ON DUPLICATE KEY UPDATE content = VALUES(content), mtime_ms = VALUES(mtime_ms)`,
+				`INSERT INTO ${table} (path, content, mtime_ms, title, title_source, title_updated_at) VALUES (?, ?, ?, ?, ?, ?) ` +
+				`ON DUPLICATE KEY UPDATE content = VALUES(content), mtime_ms = VALUES(mtime_ms), title = VALUES(title), title_source = VALUES(title_source), title_updated_at = VALUES(title_updated_at)`,
 			upsertAppend:
 				`INSERT INTO ${table} (path, content, mtime_ms) VALUES (?, ?, ?) ` +
 				`ON DUPLICATE KEY UPDATE content = CONCAT(content, VALUES(content)), mtime_ms = VALUES(mtime_ms)`,
+			updateTitle: `UPDATE ${table} SET title = ?, title_source = ?, title_updated_at = ?, mtime_ms = ? WHERE path = ?`,
 			delete: `DELETE FROM ${table} WHERE path = ?`,
 			rename: `UPDATE ${table} SET path = ?, mtime_ms = ? WHERE path = ?`,
-			loadIndex: `SELECT path, mtime_ms, length(content) AS byte_len FROM ${table}`,
+			loadIndex: `SELECT path, mtime_ms, length(content) AS byte_len, title, title_source, title_updated_at FROM ${table}`,
 			readFull: `SELECT content AS content FROM ${table} WHERE path = ?`,
 			readSlices:
 				`SELECT substring(cast(content AS binary), 1, ?) AS head, ` +
@@ -157,19 +174,28 @@ function buildQueries(adapter: SqlSessionStorageAdapter, table: string): Dialect
 			`CREATE TABLE IF NOT EXISTS ${table} (` +
 			`path TEXT PRIMARY KEY, ` +
 			`content TEXT NOT NULL, ` +
-			`mtime_ms ${mtimeType} NOT NULL` +
+			`mtime_ms ${mtimeType} NOT NULL, ` +
+			`title TEXT, ` +
+			`title_source TEXT, ` +
+			`title_updated_at TEXT` +
 			`)`,
+		addTitleColumns: [
+			`ALTER TABLE ${table} ADD COLUMN title TEXT`,
+			`ALTER TABLE ${table} ADD COLUMN title_source TEXT`,
+			`ALTER TABLE ${table} ADD COLUMN title_updated_at TEXT`,
+		],
 		upsertReplace:
-			`INSERT INTO ${table} (path, content, mtime_ms) ` +
-			`VALUES (${placeholder(1)}, ${placeholder(2)}, ${placeholder(3)}) ` +
-			`ON CONFLICT (path) DO UPDATE SET content = excluded.content, mtime_ms = excluded.mtime_ms`,
+			`INSERT INTO ${table} (path, content, mtime_ms, title, title_source, title_updated_at) ` +
+			`VALUES (${placeholder(1)}, ${placeholder(2)}, ${placeholder(3)}, ${placeholder(4)}, ${placeholder(5)}, ${placeholder(6)}) ` +
+			`ON CONFLICT (path) DO UPDATE SET content = excluded.content, mtime_ms = excluded.mtime_ms, title = excluded.title, title_source = excluded.title_source, title_updated_at = excluded.title_updated_at`,
 		upsertAppend:
 			`INSERT INTO ${table} (path, content, mtime_ms) ` +
 			`VALUES (${placeholder(1)}, ${placeholder(2)}, ${placeholder(3)}) ` +
 			`ON CONFLICT (path) DO UPDATE SET content = ${tableQualifier} || excluded.content, mtime_ms = excluded.mtime_ms`,
+		updateTitle: `UPDATE ${table} SET title = ${placeholder(1)}, title_source = ${placeholder(2)}, title_updated_at = ${placeholder(3)}, mtime_ms = ${placeholder(4)} WHERE path = ${placeholder(5)}`,
 		delete: `DELETE FROM ${table} WHERE path = ${placeholder(1)}`,
 		rename: `UPDATE ${table} SET path = ${placeholder(1)}, mtime_ms = ${placeholder(2)} WHERE path = ${placeholder(3)}`,
-		loadIndex: `SELECT path, mtime_ms, ${byteLengthExpr} AS byte_len FROM ${table}`,
+		loadIndex: `SELECT path, mtime_ms, ${byteLengthExpr} AS byte_len, title, title_source, title_updated_at FROM ${table}`,
 		readFull: `SELECT content AS content FROM ${table} WHERE path = ${placeholder(1)}`,
 		readSlices,
 	};
@@ -180,6 +206,13 @@ function rowNumber(value: number | bigint | string): number {
 	if (typeof value === "bigint") return Number(value);
 	return Number.parseInt(value, 10);
 }
+function rowTitleSource(value: string | null | undefined): SessionTitleUpdate["source"] | undefined {
+	return value === "auto" || value === "user" ? value : undefined;
+}
+function isDuplicateColumnError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	return message.includes("duplicate column") || message.includes("already exists");
+}
 
 function decodeSqlBytes(value: unknown): string {
 	if (value === null || value === undefined) return "";
@@ -260,6 +293,13 @@ class SqlSessionStorageBackend implements SessionStorageBackend {
 	async init(): Promise<void> {
 		if (this.#createTable) {
 			await this.#client.unsafe(this.#q.createTable);
+			for (const query of this.#q.addTitleColumns) {
+				try {
+					await this.#client.unsafe(query);
+				} catch (err) {
+					if (!isDuplicateColumnError(err)) throw err;
+				}
+			}
 		}
 	}
 
@@ -269,6 +309,9 @@ class SqlSessionStorageBackend implements SessionStorageBackend {
 			path: row.path,
 			size: rowNumber(row.byte_len),
 			mtimeMs: rowNumber(row.mtime_ms),
+			title: row.title ?? undefined,
+			titleSource: rowTitleSource(row.title_source),
+			titleUpdatedAt: row.title_updated_at ?? undefined,
 		}));
 	}
 
@@ -289,8 +332,25 @@ class SqlSessionStorageBackend implements SessionStorageBackend {
 		return [decodeSqlBytes(row.head), decodeSqlBytes(row.tail)];
 	}
 
-	async writeFull(path: string, content: string, mtimeMs: number): Promise<void> {
-		await this.#client.unsafe(this.#q.upsertReplace, [path, content, mtimeMs]);
+	async writeFull(path: string, content: string, mtimeMs: number, title?: SessionTitleUpdate): Promise<void> {
+		await this.#client.unsafe(this.#q.upsertReplace, [
+			path,
+			content,
+			mtimeMs,
+			title?.title ?? null,
+			title?.source ?? null,
+			title?.updatedAt ?? null,
+		]);
+	}
+
+	async updateSessionTitle(path: string, title: SessionTitleUpdate, mtimeMs: number): Promise<void> {
+		await this.#client.unsafe(this.#q.updateTitle, [
+			title.title ?? null,
+			title.source ?? null,
+			title.updatedAt,
+			mtimeMs,
+			path,
+		]);
 	}
 
 	async append(path: string, line: string, mtimeMs: number): Promise<void> {

package/src/slash-commands/builtin-registry.ts

@@ -438,16 +438,18 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "advisor",
 		description: "Toggle the advisor (a second model that reviews each turn and injects notes)",
 		acpDescription: "Toggle advisor",
-		acpInputHint: "[on|off|status|dump [raw]]",
+		acpInputHint: "[on|off|status|dump [raw]|configure]",
 		subcommands: [
 			{ name: "on", description: "Enable the advisor" },
 			{ name: "off", description: "Disable the advisor" },
 			{ name: "status", description: "Show advisor status" },
 			{ name: "dump", description: "Copy the advisor's transcript to clipboard", usage: "[raw]" },
+			{ name: "configure", description: "Open the advisor configuration editor (TUI)" },
 		],
 		allowArgs: true,
 		getTuiAutocompleteDescription: runtime => {
 			const stats = runtime.ctx.session.getAdvisorStats();
+			if (stats.active && stats.advisors.length > 1) return `Advisor: on (${stats.advisors.length} advisors)`;
 			if (stats.active && stats.model) return `Advisor: on (${stats.model.provider}/${stats.model.id})`;
 			if (stats.configured) return "Advisor: configured, no model";
 			return "Advisor: off";
@@ -488,7 +490,13 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				await runtime.output(text ?? "Advisor is not active for this session.");
 				return commandConsumed();
 			}
-			return usage("Usage: /advisor [on|off|status|dump [raw]]", runtime);
+			if (verb === "configure") {
+				await runtime.output(
+					"/advisor configure opens an interactive editor and is only available in the interactive TUI.",
+				);
+				return commandConsumed();
+			}
+			return usage("Usage: /advisor [on|off|status|dump [raw]|configure]", runtime);
 		},
 		handleTui: async (command, runtime) => {
 			const { verb, rest } = parseSubcommand(command.args);
@@ -533,7 +541,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				runtime.ctx.editor.setText("");
 				return;
 			}
-			runtime.ctx.showStatus("Usage: /advisor [on|off|status|dump [raw]]");
+			if (verb === "configure") {
+				runtime.ctx.showAdvisorConfigure();
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /advisor [on|off|status|dump [raw]|configure]");
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/ssh/__tests__/connection-manager-args.test.ts

@@ -2,7 +2,18 @@ import { describe, expect, it } from "bun:test";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getRemoteHostDir } from "@oh-my-pi/pi-utils";
-import { buildRemoteCommand, getHostInfo, type SSHConnectionTarget, type SSHHostShell } from "../connection-manager";
+import {
+	buildRemoteCommand,
+	extractProbePayload,
+	findProbeMarker,
+	getHostInfo,
+	HOST_PROBE_MARKER,
+	osFromUname,
+	parseHostInfo,
+	type SSHConnectionTarget,
+	type SSHHostShell,
+	TRANSFER_PROBE_MARKER,
+} from "../connection-manager";
 import { buildSshTarget, sanitizeHostName } from "../utils";
 
 const TARGET: SSHConnectionTarget = { name: "h", host: "h" };
@@ -67,3 +78,114 @@ describe("ssh host shell classification", () => {
 		}
 	});
 });
+
+describe("extractProbePayload (host probe framing)", () => {
+	it("returns the text after the first marker line, ignoring login banners", async () => {
+		// Real-world failure shape: noisy dotfiles print a banner before the
+		// echo we asked for, so the legacy first-line parser would have read
+		// `Last login: ...` and classified the host as unknown (#3719).
+		const stdout = [
+			"Last login: Wed Mar 19 09:14:22 2025 from 10.0.0.1",
+			"Welcome to fancybox 1.0",
+			`${HOST_PROBE_MARKER}linux-gnu|/bin/bash|5.2.21`,
+		].join("\n");
+		expect(extractProbePayload(stdout, "")).toBe("linux-gnu|/bin/bash|5.2.21");
+	});
+
+	it("falls back to stderr when the payload only shows up there", async () => {
+		// Some shells redirect every echo to stderr after a dotfile error; the
+		// parser needs to recover the marker line from either stream.
+		const stderr = `noise\n${HOST_PROBE_MARKER}darwin|/bin/zsh|\n`;
+		expect(extractProbePayload("", stderr)).toBe("darwin|/bin/zsh|");
+	});
+
+	it("returns null when no marker line is present", async () => {
+		expect(extractProbePayload("just login banner\n", "and stderr noise\n")).toBeNull();
+	});
+});
+
+describe("findProbeMarker (transfer-shell probe recovery)", () => {
+	it("returns the tail after the marker when it appears in stdout", () => {
+		// Happy path: `sh -lc 'printf "PI_TRANSFER_OK|"; uname -s'` lands in
+		// stdout. The tail is the uname output the caller uses to refine OS.
+		const stdout = `${TRANSFER_PROBE_MARKER}Linux\n`;
+		expect(findProbeMarker(stdout, "", TRANSFER_PROBE_MARKER)).toBe("Linux\n");
+	});
+
+	it("falls back to stderr when a broken dotfile swaps fd 1/2", () => {
+		// Some remotes have dotfiles that redirect every shell write to stderr.
+		// The transfer probe must still recognize the marker so ssh:// doesn't
+		// refuse a POSIX-capable host (#3722 review).
+		const stderr = `dotfile noise\n${TRANSFER_PROBE_MARKER}Darwin\n`;
+		expect(findProbeMarker("", stderr, TRANSFER_PROBE_MARKER)).toBe("Darwin\n");
+	});
+
+	it("prefers stdout over stderr when the marker is in both", () => {
+		// Order matters: stdout is the canonical path, stderr is the rescue.
+		// A reordering bug would silently use stale stderr fragments first.
+		const stdout = `${TRANSFER_PROBE_MARKER}Linux`;
+		const stderr = `${TRANSFER_PROBE_MARKER}stale`;
+		expect(findProbeMarker(stdout, stderr, TRANSFER_PROBE_MARKER)).toBe("Linux");
+	});
+
+	it("returns null when the marker is in neither stream", () => {
+		expect(findProbeMarker("noise", "more noise", TRANSFER_PROBE_MARKER)).toBeNull();
+	});
+});
+
+describe("osFromUname (transfer-shell probe OS recovery)", () => {
+	it("classifies common POSIX uname payloads", () => {
+		// The markerless host-info fallback uses the transfer-shell probe's
+		// uname output to avoid returning a durable `os: "unknown"` when csh/tcsh
+		// killed the first marker probe before it could echo anything (#3722 review).
+		expect(osFromUname("Linux")).toBe("linux");
+		expect(osFromUname("GNU/Linux")).toBe("linux");
+		expect(osFromUname("Darwin")).toBe("macos");
+	});
+
+	it("classifies Windows compat unames as windows so ssh:// still refuses them", () => {
+		expect(osFromUname("MINGW64_NT-10.0")).toBe("windows");
+		expect(osFromUname("MSYS_NT-10.0")).toBe("windows");
+		expect(osFromUname("CYGWIN_NT-10.0")).toBe("windows");
+	});
+
+	it("returns undefined when uname is not recognized", () => {
+		expect(osFromUname("")).toBeUndefined();
+		expect(osFromUname("SunOS")).toBeUndefined();
+	});
+});
+
+describe("parseHostInfo transferShell handling", () => {
+	it("round-trips a verified transferShell value", () => {
+		// Cache writers persist `transferShell` so callers don't re-probe
+		// every session; parseHostInfo must thread it back through (#3719).
+		const parsed = parseHostInfo({
+			version: 4,
+			os: "linux",
+			shell: "unknown",
+			transferShell: "bash",
+			compatEnabled: false,
+		});
+		expect(parsed?.transferShell).toBe("bash");
+	});
+
+	it("drops a transferShell value outside the sh/bash/zsh allowlist", () => {
+		// Anything we couldn't have probed (fish, csh, garbage) must not slip
+		// into the cache and bypass the ssh:// transfer guard.
+		const parsed = parseHostInfo({
+			version: 4,
+			os: "linux",
+			shell: "sh",
+			transferShell: "fish",
+			compatEnabled: false,
+		});
+		expect(parsed?.transferShell).toBeUndefined();
+	});
+
+	it("returns transferShell undefined when the field is missing", () => {
+		// A pre-v4 cache file lacks transferShell entirely; the parsed value
+		// must be undefined so shouldRefreshHostInfo treats it as stale.
+		const parsed = parseHostInfo({ version: 3, os: "linux", shell: "sh", compatEnabled: false });
+		expect(parsed?.transferShell).toBeUndefined();
+	});
+});