jeopi-cli 16.4.2 → 16.4.3

package/src/tools/eval-render.ts

@@ -414,37 +414,39 @@ function formatStatusEventExpanded(event: EvalStatusEvent, theme: Theme): string
 	return lines;
 }
 
-/** Render status events as tree lines. */
+/**
+ * Render status events as tree lines. Shows a tail window (newest events are
+ * the live edge for `log()` progress loops) behind an "… N earlier" marker,
+ * matching the code/output tail-window convention. Collapsed keeps a small
+ * fixed window; expanded widens to the viewport-sized preview window.
+ */
 function renderStatusEvents(events: EvalStatusEvent[], theme: Theme, expanded: boolean): string[] {
 	if (events.length === 0) return [];
 
-	const maxCollapsed = 3;
-	const maxExpanded = 10;
-	const displayCount = expanded ? Math.min(events.length, maxExpanded) : Math.min(events.length, maxCollapsed);
+	const max = expanded ? Math.max(10, previewWindowRows()) : 3;
+	const hidden = Math.max(0, events.length - max);
+	const visible = hidden > 0 ? events.slice(hidden) : events;
 
 	const lines: string[] = [];
-	for (let i = 0; i < displayCount; i++) {
-		const isLast = i === displayCount - 1 && (expanded || events.length <= maxCollapsed);
+	if (hidden > 0) {
+		lines.push(`${theme.fg("dim", theme.tree.branch)} ${theme.fg("dim", `… ${hidden} earlier`)}`);
+	}
+	for (let i = 0; i < visible.length; i++) {
+		const isLast = i === visible.length - 1;
 		const branch = isLast ? theme.tree.last : theme.tree.branch;
 
 		if (expanded) {
-			const eventLines = formatStatusEventExpanded(events[i], theme);
+			const eventLines = formatStatusEventExpanded(visible[i], theme);
 			lines.push(`${theme.fg("dim", branch)} ${eventLines[0]}`);
 			const continueBranch = isLast ? "   " : `${theme.tree.vertical}  `;
 			for (let j = 1; j < eventLines.length; j++) {
 				lines.push(`${theme.fg("dim", continueBranch)}${eventLines[j]}`);
 			}
 		} else {
-			lines.push(`${theme.fg("dim", branch)} ${formatStatusEvent(events[i], theme)}`);
+			lines.push(`${theme.fg("dim", branch)} ${formatStatusEvent(visible[i], theme)}`);
 		}
 	}
 
-	if (!expanded && events.length > maxCollapsed) {
-		lines.push(`${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", `… ${events.length - maxCollapsed} more`)}`);
-	} else if (expanded && events.length > maxExpanded) {
-		lines.push(`${theme.fg("dim", theme.tree.last)} ${theme.fg("dim", `… ${events.length - maxExpanded} more`)}`);
-	}
-
 	return lines;
 }
 

package/src/tools/glob.ts

@@ -173,6 +173,7 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 					signal,
 					localProtocolOptions: this.session.localProtocolOptions,
 					skills: this.session.skills,
+					pathOnly: true,
 				});
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot find internal URL without a backing file: ${rawPattern}`);
@@ -247,7 +248,7 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 
 			const buildResult = (
 				files: string[],
-				opts?: { notice?: string; forceTruncated?: boolean },
+				opts?: { notice?: string; forceTruncated?: boolean; timedOut?: boolean },
 			): AgentToolResult<GlobToolDetails> => {
 				const notice = opts?.notice;
 				const forceTruncated = opts?.forceTruncated ?? false;
@@ -260,7 +261,10 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 						cwd: this.session.cwd,
 						missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 					};
-					const parts = ["No files found matching pattern"];
+					// A timed-out empty result is an incomplete scan, not a verified
+					// absence — never emit the definitive "No files found" claim next
+					// to a timeout notice (the two statements contradict each other).
+					const parts = opts?.timedOut ? [] : ["No files found matching pattern"];
 					if (notice) parts.push(notice);
 					if (missingPathsNote) parts.push(missingPathsNote);
 					// Zero results is useless regardless of notices: the follow-up
@@ -441,8 +445,15 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 				partial.sort((a, b) => b.m - a.m);
 				const sortedPaths = partial.map(entry => entry.p);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
-				const notice = `glob timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — narrow the pattern instead of retrying blindly`;
-				return buildResult(sortedPaths, { notice, forceTruncated: true });
+				// Walk cost tracks directory-tree size, not pattern specificity: a
+				// mtime-ranked scan cannot early-exit, so a "narrow" pattern over a
+				// huge tree still times out. Say so instead of implying the pattern
+				// was too broad.
+				const notice =
+					sortedPaths.length > 0
+						? `glob timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — results are incomplete, scope to a deeper directory instead of retrying blindly`
+						: `Glob timed out after ${seconds}s before finding any matches — the scan is incomplete, NOT proof of absence. The walk is bounded by directory size, not pattern width; scope the search to a deeper directory (e.g. \`sub/dir/*.ext\` instead of \`*.ext\` at a huge root).`;
+				return buildResult(sortedPaths, { notice, forceTruncated: true, timedOut: true });
 			}
 
 			// Merge per-target results: native glob already ranks each target's own
@@ -568,17 +579,20 @@ export const globToolRenderer = {
 			missingPaths.length > 0 ? uiTheme.fg("warning", `skipped missing: ${missingPaths.join(", ")}`) : undefined;
 
 		if (fileCount === 0) {
+			// `truncated` on an empty result means the scan timed out mid-walk —
+			// render "incomplete", not a definitive "No files found".
+			const emptyLabel = truncated ? "No matches before timeout (scan incomplete)" : "No files found";
 			const header = renderStatusLine(
 				{
 					icon: "warning",
 					title: "Glob",
 					titleColor: "toolTitle",
 					description: formatGlobRenderPaths(args?.paths),
-					meta: ["0 files"],
+					meta: truncated ? ["0 files", uiTheme.fg("warning", "timed out")] : ["0 files"],
 				},
 				uiTheme,
 			);
-			const lines = [header, formatEmptyMessage("No files found", uiTheme)];
+			const lines = [header, formatEmptyMessage(emptyLabel, uiTheme)];
 			if (missingNote) lines.push(missingNote);
 			return new Text(lines.join("\n"), 1, 0);
 		}

package/src/tools/grep.ts

@@ -766,6 +766,7 @@ async function resolveInternalSearchInputs(opts: {
 		localProtocolOptions: opts.localProtocolOptions,
 		skills: opts.skills,
 		skipDirectoryListing: true,
+		pathOnly: true,
 	};
 
 	for (let idx = 0; idx < paths.length; idx++) {

package/src/tools/image-gen.ts

@@ -822,11 +822,10 @@ function buildOpenAIImageHeaders(model: Model, apiKey: string, sessionId: string
 
 	if (model.api === "openai-codex-responses" || model.provider === "openai-codex") {
 		const accountId = getCodexAccountId(apiKey);
-		if (!accountId) {
-			throw new Error("Failed to extract accountId from OpenAI Codex token");
-		}
 		headers.delete("x-api-key");
-		headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
+		if (accountId) {
+			headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
+		}
 		headers.set(OPENAI_HEADERS.BETA, OPENAI_HEADER_VALUES.BETA_RESPONSES);
 		headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
 		headers.set("User-Agent", `pi/${packageJson.version} (${os.platform()} ${os.release()}; ${os.arch()})`);

package/src/tools/irc.ts

@@ -171,7 +171,7 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 			case "send":
 				return this.#executeSend(registry, senderId, params, signal);
 			case "wait":
-				return this.#executeWait(senderId, params, signal);
+				return this.#executeWait(registry, senderId, params, signal);
 			case "inbox":
 				return this.#executeInbox(registry, senderId, params);
 			default:
@@ -367,23 +367,37 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 		}
 	}
 
-	async #executeWait(senderId: string, params: IrcParams, signal?: AbortSignal): Promise<AgentToolResult<IrcDetails>> {
+	async #executeWait(
+		registry: AgentRegistry,
+		senderId: string,
+		params: IrcParams,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<IrcDetails>> {
 		const from = params.from?.trim() || undefined;
 		const timeoutMs = this.#resolveTimeoutMs(params);
-		const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal);
-		if (!waited) {
-			const filterNote = from ? ` from ${from}` : "";
+		try {
+			const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal, {
+				liveness: { registry, senderId },
+			});
+			if (!waited) {
+				const filterNote = from ? ` from ${from}` : "";
+				return {
+					content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
+					details: { op: "wait", from: senderId, waited: null },
+					// A clean wait timeout carries no information once consumed.
+					useless: true,
+				};
+			}
 			return {
-				content: [{ type: "text", text: `No message${filterNote} within ${formatDuration(timeoutMs)}.` }],
-				details: { op: "wait", from: senderId, waited: null },
-				// A clean wait timeout carries no information once consumed.
-				useless: true,
+				content: [{ type: "text", text: formatIncoming(waited) }],
+				details: { op: "wait", from: senderId, waited },
 			};
+		} catch (error) {
+			if (signal?.aborted) {
+				throw error;
+			}
+			return errorResult(error instanceof Error ? error.message : String(error), { op: "wait", from: senderId });
 		}
-		return {
-			content: [{ type: "text", text: formatIncoming(waited) }],
-			details: { op: "wait", from: senderId, waited },
-		};
 	}
 
 	#executeInbox(registry: AgentRegistry, senderId: string, params: IrcParams): AgentToolResult<IrcDetails> {

package/src/tools/read.ts

@@ -1251,13 +1251,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const ignoreResultLimits = options.ignoreResultLimits ?? false;
 		const requestedEnd = limit !== undefined ? Math.min(requestedStart + limit, allLines.length) : allLines.length;
 		// Expand only on sides the user actually constrained: leading context
-		// when offset>1, trailing context when a finite limit was set.
+		// when offset>1, trailing context when a finite limit was set. Raw mode
+		// never expands — without line numbers the padding is indistinguishable
+		// from requested content, so `raw:31-31` must return line 31 and nothing
+		// else (verbatim-extraction contract).
+		const rawDisplay = options.raw === true;
 		const expanded = expandRangeWithContext(
 			requestedStart,
 			requestedEnd,
 			allLines.length,
-			offset !== undefined && offset > 1,
-			limit !== undefined,
+			!rawDisplay && offset !== undefined && offset > 1,
+			!rawDisplay && limit !== undefined,
 		);
 		const startLine = expanded.startLine;
 		const endLineExpanded = expanded.endLine;
@@ -2415,10 +2419,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					}
 
 					// User-requested 0-indexed range start. Lines BEFORE this become
-					// leading context (added below if offset is explicit).
+					// leading context (added below if offset is explicit). Raw mode
+					// never adds context: without line numbers the padding is
+					// indistinguishable from requested content, so `raw:31-31` must
+					// return line 31 and nothing else.
+					const rawSelector = isRawSelector(parsed);
 					const requestedStart = offset ? Math.max(0, offset - 1) : 0;
-					const expandStart = offset !== undefined && offset > 1;
-					const expandEnd = limit !== undefined;
+					const expandStart = !rawSelector && offset !== undefined && offset > 1;
+					const expandEnd = !rawSelector && limit !== undefined;
 					const leadingContext = expandStart ? Math.min(requestedStart, RANGE_LEADING_CONTEXT_LINES) : 0;
 					const trailingContext = expandEnd ? RANGE_TRAILING_CONTEXT_LINES : 0;
 					const startLine = requestedStart - leadingContext;
@@ -2469,7 +2477,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					// verbatim bytes for paste-back-into-tool workflows. Total byte/line
 					// counts in `truncation` keep reflecting the source, not the trimmed
 					// view — column truncation surfaces separately via `.limits()`.
-					const rawSelector = isRawSelector(parsed);
 					const maxColumns = resolveOutputMaxColumns(this.session.settings);
 					// Column truncation is display-only. `collectedLines` MUST stay
 					// byte-for-byte with the on-disk content so the snapshot recorded

package/src/tools/write.ts

@@ -13,6 +13,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
 import { createLspWritethrough, type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "../lsp";
+import { DeferredDiagnostics } from "../lsp/deferred-diagnostics";
 import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import { getLanguageFromPath, highlightCode, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
@@ -317,12 +318,15 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	}
 
 	readonly #writethrough: WritethroughCallback;
+	readonly #deferredDiagnostics: DeferredDiagnostics | undefined;
 
 	constructor(private readonly session: ToolSession) {
 		const enableLsp = session.enableLsp ?? true;
 		const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
 		const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnWrite");
 		const dedup = enableDiagnostics && session.settings.get("lsp.diagnosticsDeduplicate");
+		this.#deferredDiagnostics =
+			enableDiagnostics && session.queueDeferredDiagnostics ? new DeferredDiagnostics(session, dedup) : undefined;
 		this.#writethrough = withPathWriteLock(
 			enableLsp
 				? createLspWritethrough(session.cwd, {
@@ -826,9 +830,13 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 					}
 					return { content: [{ type: "text", text: resultText }], details: {} };
 				}
-				// Schemes without a `write` hook fall through to existing logic
-				// (local:// resolves to a backing file via plan-mode-guard) or are
-				// rejected downstream when no backing file exists.
+				if (scheme !== "local") {
+					throw new ToolError(
+						`${scheme}:// URLs are read-only for write; use the protocol-specific tool for mutations.`,
+					);
+				}
+				// local:// is backed by the session-local artifact sandbox and is
+				// resolved by resolvePlanPath below so write/read share the same root.
 			}
 
 			const conflictUri = parseConflictUri(path);
@@ -927,9 +935,18 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				};
 			}
 
-			const diagnostics = await this.#writethrough(absolutePath, cleanContent, signal, undefined, batchRequest);
+			const diagnostics = await this.#writethrough(
+				absolutePath,
+				cleanContent,
+				signal,
+				undefined,
+				batchRequest,
+				dst => this.#deferredDiagnostics?.begin(dst),
+			);
 			invalidateFsScanAfterWrite(absolutePath);
-			this.session.bumpFileMutationVersion?.(absolutePath);
+			if (!this.#deferredDiagnostics || batchRequest?.flush === false) {
+				this.session.bumpFileMutationVersion?.(absolutePath);
+			}
 			const madeExecutable = await maybeMarkExecutableForShebang(absolutePath, cleanContent);
 
 			const header = maybeWriteSnapshotHeader(this.session, absolutePath, cleanContent);

package/src/tools/yield.ts

@@ -198,6 +198,14 @@ function wrapYieldParameters(dataSchema: Record<string, unknown>): Record<string
  */
 const MAX_SCHEMA_RETRIES = 3;
 
+/**
+ * Max consecutive untyped empty-result submissions before the yield tool fails
+ * the child explicitly. Some weak tool callers can acknowledge the required
+ * wrapper in prose while repeatedly sending `{ result: {} }`; without a hard
+ * stop the parent waits forever.
+ */
+const MAX_EMPTY_RESULT_RETRIES = 3;
+
 export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	readonly name = "yield";
 	readonly approval = "read" as const;
@@ -217,6 +225,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 	#knownSectionLabels: readonly string[] = [];
 	#isKnownSection?: (label: string) => boolean;
 	#schemaValidationFailures = 0;
+	#emptyResultFailures = 0;
 
 	constructor(session: ToolSession) {
 		let validate: ((value: unknown) => JsonSchemaValidationResult) | undefined;
@@ -322,8 +331,26 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			throw new Error("result cannot contain both data and error");
 		}
 		if (errorMessage === undefined && data === undefined && yieldType === undefined) {
+			this.#emptyResultFailures++;
+			if (this.#emptyResultFailures > MAX_EMPTY_RESULT_RETRIES) {
+				const attemptCount = this.#emptyResultFailures;
+				this.#emptyResultFailures = 0;
+				const error =
+					`yield result stayed empty after ${attemptCount} consecutive attempt(s); aborting child instead of retrying forever. ` +
+					'Submit success as `{ "result": { "data": <your output> } }` or failure as `{ "result": { "error": "message" } }`.';
+				return {
+					content: [{ type: "text", text: `Task aborted: ${error}` }],
+					details: {
+						data: undefined,
+						status: "aborted",
+						error,
+						type: yieldType,
+					},
+				};
+			}
+			const remaining = MAX_EMPTY_RESULT_RETRIES - this.#emptyResultFailures;
 			throw new Error(
-				'result must contain either `data` or `error`. Use `{result: {data: <your output>}}` for success or `{result: {error: "message"}}` for failure.',
+				`result must contain either \`data\` or \`error\`. Use \`{result: {data: <your output>}}\` for success or \`{result: {error: "message"}}\` for failure. Empty untyped result retries remaining before abort: ${remaining}.`,
 			);
 		}
 
@@ -370,6 +397,7 @@ export class YieldTool implements AgentTool<TSchema, YieldDetails> {
 			}
 		}
 
+		this.#emptyResultFailures = 0;
 		const responseText =
 			status === "aborted"
 				? `Task aborted: ${errorMessage}`

package/src/utils/changelog.ts

@@ -7,6 +7,27 @@ export interface ChangelogEntry {
 	content: string;
 }
 
+/** Number of changelog releases shown by automatic and default recent views. */
+export const RECENT_CHANGELOG_ENTRY_LIMIT = 3;
+/** Maximum Markdown source bytes allowed in automatic startup release notes. */
+export const STARTUP_CHANGELOG_MAX_BYTES = 64 * 1024;
+/** Hint appended when automatic startup release notes are truncated. */
+export const STARTUP_CHANGELOG_FULL_HINT = "Use `/changelog full` to view the complete changelog.";
+
+/** Markdown generated from selected changelog entries and whether it hit a size cap. */
+export interface RenderedChangelog {
+	markdown: string;
+	truncated: boolean;
+}
+
+/** Automatic startup changelog decision, including whether the marker should advance. */
+export interface StartupChangelogSelection {
+	markdown: string | undefined;
+	persistCurrentVersion: boolean;
+	truncated: boolean;
+	selectedEntries: number;
+}
+
 /**
  * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
  * headings and collects each block until the next heading or EOF.
@@ -87,19 +108,95 @@ export function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number
 }
 
 /**
- * Get entries newer than lastVersion
+ * Parse an omp changelog marker version into comparable parts.
  */
-export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[] {
-	// Parse lastVersion
-	const parts = lastVersion.split(".").map(Number);
-	const last: ChangelogEntry = {
-		major: parts[0] || 0,
-		minor: parts[1] || 0,
-		patch: parts[2] || 0,
+export function parseChangelogVersion(version: string | undefined): ChangelogEntry | undefined {
+	const match = version?.match(/^(\d+)\.(\d+)\.(\d+)$/);
+	if (!match) {
+		return undefined;
+	}
+
+	return {
+		major: Number.parseInt(match[1], 10),
+		minor: Number.parseInt(match[2], 10),
+		patch: Number.parseInt(match[3], 10),
 		content: "",
 	};
+}
+
+/**
+ * Get entries newer than lastVersion.
+ */
+export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[] {
+	const parsedLastVersion = parseChangelogVersion(lastVersion);
+	if (!parsedLastVersion) {
+		return [];
+	}
+
+	return entries.filter(entry => compareVersions(entry, parsedLastVersion) > 0);
+}
 
-	return entries.filter(entry => compareVersions(entry, last) > 0);
+/**
+ * Render changelog entries oldest-first by default and optionally cap the Markdown source size.
+ */
+export function renderChangelogEntries(
+	entries: ChangelogEntry[],
+	options: { maxBytes?: number; truncationHint?: string; oldestFirst?: boolean } = {},
+): RenderedChangelog {
+	const orderedEntries = options.oldestFirst === false ? entries : [...entries].reverse();
+	const markdown = orderedEntries.map(entry => entry.content).join("\n\n");
+	if (options.maxBytes === undefined || Buffer.byteLength(markdown) <= options.maxBytes) {
+		return { markdown, truncated: false };
+	}
+
+	const suffix = `\n\n…\n\n${options.truncationHint ?? STARTUP_CHANGELOG_FULL_HINT}`;
+	let low = 0;
+	let high = markdown.length;
+	while (low < high) {
+		const middle = Math.floor((low + high + 1) / 2);
+		if (Buffer.byteLength(markdown.slice(0, middle) + suffix) <= options.maxBytes) {
+			low = middle;
+		} else {
+			high = middle - 1;
+		}
+	}
+
+	return { markdown: markdown.slice(0, low) + suffix, truncated: true };
+}
+
+/**
+ * Select bounded release notes for interactive startup.
+ */
+export function selectStartupChangelog(
+	entries: ChangelogEntry[],
+	lastVersion: string | undefined,
+	currentVersion: string,
+): StartupChangelogSelection {
+	const parsedLastVersion = parseChangelogVersion(lastVersion);
+	if (!parsedLastVersion) {
+		return { markdown: undefined, persistCurrentVersion: true, truncated: false, selectedEntries: 0 };
+	}
+	const markerVersion = lastVersion ?? "";
+	if (markerVersion === currentVersion) {
+		return { markdown: undefined, persistCurrentVersion: false, truncated: false, selectedEntries: 0 };
+	}
+
+	const newEntries = getNewEntries(entries, markerVersion).slice(0, RECENT_CHANGELOG_ENTRY_LIMIT);
+	if (newEntries.length === 0) {
+		return { markdown: undefined, persistCurrentVersion: false, truncated: false, selectedEntries: 0 };
+	}
+
+	const rendered = renderChangelogEntries(newEntries, {
+		maxBytes: STARTUP_CHANGELOG_MAX_BYTES,
+		truncationHint: STARTUP_CHANGELOG_FULL_HINT,
+		oldestFirst: false,
+	});
+	return {
+		markdown: rendered.markdown,
+		persistCurrentVersion: true,
+		truncated: rendered.truncated,
+		selectedEntries: newEntries.length,
+	};
 }
 
 // Re-export getChangelogPath from paths.ts for convenience

package/src/utils/git.ts

@@ -197,7 +197,6 @@ const GIT_NON_INTERACTIVE_ENV = {
 	GIT_ASKPASS: "true",
 	GIT_EDITOR: "true",
 	GIT_TERMINAL_PROMPT: "0",
-	GPG_TTY: "not a tty",
 	SSH_ASKPASS: "/usr/bin/false",
 } satisfies Record<string, string>;
 const GH_NON_INTERACTIVE_ENV = {

package/src/utils/title-generator.ts

@@ -4,6 +4,7 @@
 import * as path from "node:path";
 
 import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "jeopi-ai";
+import { StreamMarkupHealing } from "jeopi-ai/utils/stream-markup-healing";
 import { isTerminalHeadless, logger, prompt } from "jeopi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 
@@ -45,7 +46,12 @@ const setTitleTool: Tool = {
 };
 
 /** Matches the title a tool-choice-less model wraps in `<title>...</title>`. */
-const TITLE_MARKER_RE = /<title>([\s\S]*?)<\/title>/i;
+const TITLE_MARKER_GLOBAL_RE = /<title>([\s\S]*?)<\/title>/gi;
+const TITLE_VISIBILITY_SENTINEL = "\uE000jeopi-title-visible\uE000";
+const THINKING_TAG_ENVELOPE_RE = /<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>/gi;
+const THINKING_FENCE_ENVELOPE_RE = /```(?:thinking|reasoning)\b[\s\S]*?```/gi;
+const LEADING_THINKING_TAG_RE = /^\s*<(think|thinking|reasoning)>\s*[\s\S]*?<\/\1>\s*/i;
+const LEADING_THINKING_FENCE_RE = /^\s*```(?:thinking|reasoning)\b[\s\S]*?```\s*/i;
 
 /**
  * Whether the model honors a forced `tool_choice` so the `set_title` tool can be
@@ -289,12 +295,67 @@ function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): stri
 		}
 	}
 	// Tool-choice-less models are asked to wrap the title in <title>...</title>,
-	// but stay lenient: prefer the marker when the model closed it, otherwise
-	// accept a plain sentence after stripping any stray/unclosed tag fragment
-	// (e.g. output truncated before the closing tag).
-	const marker = TITLE_MARKER_RE.exec(textTitle);
-	if (marker) return marker[1].trim();
-	return textTitle.replace(/<\/?title>/gi, "").trim();
+	// but stay lenient: prefer the first closed title marker in visible text,
+	// then fall back to a plain sentence after stripping only known leading
+	// leaked thinking envelopes plus any stray/unclosed title tag fragment.
+	const markedTitle = extractVisibleMarkedTitle(textTitle);
+	if (markedTitle !== undefined) return markedTitle;
+	return stripLeadingLeakedThinkingMarkup(textTitle)
+		.replace(/<\/?title>/gi, "")
+		.trim();
+}
+
+function extractVisibleMarkedTitle(text: string): string | undefined {
+	TITLE_MARKER_GLOBAL_RE.lastIndex = 0;
+	let marker: RegExpExecArray | null = TITLE_MARKER_GLOBAL_RE.exec(text);
+	while (marker !== null) {
+		const title = marker[1];
+		if (title !== undefined && isVisibleTitleMarker(text, marker.index)) return title.trim();
+		marker = TITLE_MARKER_GLOBAL_RE.exec(text);
+	}
+	return undefined;
+}
+
+function isVisibleTitleMarker(text: string, markerIndex: number): boolean {
+	if (isInsideKnownThinkingEnvelope(text, markerIndex)) return false;
+	return stripLeakedThinkingMarkup(`${text.slice(0, markerIndex)}${TITLE_VISIBILITY_SENTINEL}`).endsWith(
+		TITLE_VISIBILITY_SENTINEL,
+	);
+}
+
+function isInsideKnownThinkingEnvelope(text: string, index: number): boolean {
+	return (
+		isInsideEnvelopeMatchedBy(THINKING_TAG_ENVELOPE_RE, text, index) ||
+		isInsideEnvelopeMatchedBy(THINKING_FENCE_ENVELOPE_RE, text, index)
+	);
+}
+
+function isInsideEnvelopeMatchedBy(pattern: RegExp, text: string, index: number): boolean {
+	pattern.lastIndex = 0;
+	let marker = pattern.exec(text);
+	while (marker !== null) {
+		const start = marker.index;
+		const end = start + marker[0].length;
+		if (index > start && index < end) return true;
+		if (start > index) return false;
+		marker = pattern.exec(text);
+	}
+	return false;
+}
+
+function stripLeadingLeakedThinkingMarkup(text: string): string {
+	let current = text;
+	while (true) {
+		const withoutTag = current.replace(LEADING_THINKING_TAG_RE, "");
+		const withoutFence = withoutTag.replace(LEADING_THINKING_FENCE_RE, "");
+		if (withoutFence === current) return current;
+		current = withoutFence;
+	}
+}
+
+function stripLeakedThinkingMarkup(text: string): string {
+	const healer = new StreamMarkupHealing({ pattern: "thinking" });
+	return healer.feed(text) + healer.flushPending();
 }
 
 /**

package/src/web/search/index.ts

@@ -224,12 +224,20 @@ export async function runSearchQuery(
 	params: SearchQueryParams,
 	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal } = {},
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
-	const authStorage = options.authStorage ?? (await discoverAuthStorage());
-	return executeSearch("cli-web-search", params, {
-		authStorage,
-		sessionId: options.sessionId,
-		signal: options.signal,
-	});
+	const createdAuthStorage = options.authStorage ? undefined : await discoverAuthStorage();
+	const authStorage = options.authStorage ?? createdAuthStorage;
+	if (!authStorage) {
+		throw new Error("Failed to initialize authentication storage");
+	}
+	try {
+		return await executeSearch("cli-web-search", params, {
+			authStorage,
+			sessionId: options.sessionId,
+			signal: options.signal,
+		});
+	} finally {
+		createdAuthStorage?.close();
+	}
 }
 
 /**