@linxiraos/pi-utils 1.1.25 → 1.1.27

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [1.1.27] - 2026-10-07
+
+- 版本线推进至 1.1.27；本版无独立用户可见变化。
+
+### Breaking Changes
+
+- Replaced the `cursorPosition` option of `TerminalQueryResponder` with `hostCursorHandshake`, which leaves only the PTY host's own session-start cursor query unanswered instead of every cursor-position query
+
 ## [1.1.25] - 2026-10-03
 
 - 版本线推进至 1.1.25；本版无独立用户可见变化。

package/dist/types/dirs.d.ts

@@ -357,6 +357,12 @@ export declare function getDaemonRuntimeDir(projectDir: string): string;
 export declare function getGlobalDaemonRuntimeRoot(): string;
 /** Get a profile-independent runtime directory for a machine-global daemon service. */
 export declare function getGlobalDaemonRuntimeDir(service: string): string;
+/**
+ * Directory naming session ownership leases (~/.zeta/run/session-owners; XDG
+ * default: $XDG_STATE_HOME/zeta/run/session-owners). Shared across profiles:
+ * every omp process that opens a session must meet the same lease.
+ */
+export declare function getSessionOwnersDir(): string;
 /** Get the provider in-flight root directory (~/.zeta/run/provider-inflight; XDG default: $XDG_STATE_HOME/zeta/run/provider-inflight). */
 export declare function getProviderInFlightRoot(): string;
 /** Get the marketplaces registry path (~/.zeta/marketplaces.json; XDG default: $XDG_DATA_HOME/zeta/marketplaces.json). Adopts a legacy registry on first XDG resolution. */

package/dist/types/math-delimiters.d.ts

@@ -6,6 +6,8 @@
  */
 /** Opening delimiter. Each closer (`$`, `$$`, `\)`, `\]`) is as wide as its opener. */
 export type MathOpener = "$" | "$$" | "\\(" | "\\[";
+/** Opener of an own-line display block. */
+export type MathBlockOpener = "$$" | "\\[";
 /** A closed math span found in the source. */
 export interface MathSpan {
     opener: MathOpener;
@@ -65,3 +67,39 @@ export declare function mathSpanInContext(context: {
 }, src: string): MathSpan | undefined;
 /** The own-line display block starting at offset 0, or `undefined`. */
 export declare function mathBlockAt(source: string): MathBlock | undefined;
+/**
+ * {@link mathBlockAt} for many offsets of one `source`. An own-line opener
+ * whose closer line is missing means every later opener of the same kind
+ * misses one too, since its search covers a suffix of that search. The scan
+ * keeps that answer, so asking at every block start takes linear time instead
+ * of a scan to the end of `source` per unclosed opener.
+ */
+export declare class MathBlockScan {
+    #private;
+    constructor(source: string);
+    /** The own-line display block starting at `from`, or `undefined`. */
+    at(from: number): MathBlock | undefined;
+}
+/**
+ * The display opener alone on the line at `from` (up to 3 leading spaces,
+ * trailing spaces or tabs; the source's last line may be unterminated), or
+ * `undefined`.
+ */
+export declare function mathBlockOpenerAt(source: string, from?: number): MathBlockOpener | undefined;
+/**
+ * Whether the own-line display block opened at `from` in `source` is closed,
+ * or could still close once more text is appended: the text from `from`
+ * onward is a streaming prefix whose real closer may not have arrived. A
+ * closer on the unterminated last line has not arrived either, since the next
+ * append may extend it into text (`$$ E = mc^2 $$`). With no opener line at
+ * `from` it returns false before scanning, so a caller can ask at every block
+ * start.
+ */
+export declare function mathBlockMayCloseAt(source: string, from?: number): boolean;
+/**
+ * Offset of the first line of `source`, from the line start `from` on, that
+ * holds the closer of `opener` alone (up to 3 leading spaces, trailing spaces
+ * or tabs), the unterminated last line included, or `undefined`: the first
+ * line at which a block `opener` opened before `from` could close.
+ */
+export declare function mathBlockCloserIndex(source: string, from: number, opener: MathBlockOpener): number | undefined;

package/dist/types/procmgr.d.ts

@@ -36,26 +36,6 @@ export declare function isPosixShell(shell: string): boolean;
  * Resolve a basic shell (bash or sh) as fallback.
  */
 export declare function resolveBasicShell(): string | undefined;
-/**
- * Resolve the external shell to advertise on Windows.
- *
- * A host bash is OPTIONAL: bash tool commands always execute in the embedded
- * brush-core shell. The resolved binary only serves the spawn-a-shell paths
- * (interactive PTY sessions, ACP client terminals, SHELL env), so this
- * prefers a real Git Bash when one exists and otherwise falls back to
- * cmd.exe — it never fails.
- *
- * Search order:
- * 1. Git for Windows install roots (machine + per-user installers)
- * 2. scoop installs — scoop's git manifest sets GIT_INSTALL_ROOT and shims
- *    sh.exe/git.exe but never bash.exe, so PATH lookup alone misses it
- * 3. bash.exe on PATH (Cygwin, MSYS2, ...)
- * 4. sh.exe on PATH (Git for Windows' sh.exe is bash; prefer a sibling
- *    bash.exe when present)
- * 5. cmd.exe from ComSpec
- *
- * Exported for tests; `env` overrides Bun.env-based discovery.
- */
 export declare function resolveWindowsShell(env?: Record<string, string | undefined>): string;
 /**
  * Get shell configuration based on platform.
@@ -70,6 +50,20 @@ export declare function resolveWindowsShell(env?: Record<string, string | undefi
  * `shellPath` mid-process immediately falls back to the platform default.
  */
 export declare function getShellConfig(customShellPath?: string, options?: ShellConfigOptions): ShellConfig;
+/**
+ * Capture the current process environment for child shells and drop both cached
+ * shell configs, so the next {@link getShellConfig} builds the spawn environment
+ * from that capture. Call right after code that changed `process.env` in a way
+ * child shells must see, such as extension session lifecycle handlers exporting
+ * session-scoped variables; later writes reach child shells only at the next call.
+ */
+export declare function refreshShellConfigCache(): void;
+/**
+ * Test-only: forget the capture and both cached shell configs, so the next
+ * {@link getShellConfig} builds from the live environment again. Production code
+ * MUST NOT call this; the capture's lifecycle is owned by {@link refreshShellConfigCache}.
+ */
+export declare function __resetShellConfigCacheForTests(): void;
 /**
  * Check if a process is running.
  */

package/dist/types/vterm/query-responder.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Options for {@link TerminalQueryResponder}.
+ */
+export interface TerminalQueryResponderOptions {
+    /**
+     * The PTY host opens the session with its own cursor-position query
+     * (`CSI 6 n`), which the PTY layer has already answered — ConPTY's
+     * `PSEUDOCONSOLE_INHERIT_CURSOR` handshake. Leave that first cursor query
+     * unanswered: the host consumes exactly one report, so a second one would
+     * reach the program as input it never asked for. Every later cursor query
+     * is answered. Defaults to `false`.
+     */
+    hostCursorHandshake?: boolean;
+}
 /**
  * Answers terminal capability queries emitted by programs on a headless PTY.
  *
@@ -16,6 +30,7 @@
  */
 export declare class TerminalQueryResponder {
     #private;
+    constructor(options?: TerminalQueryResponderOptions);
     /**
      * Feed one raw PTY output chunk. Returns the reply bytes to write back into
      * the PTY, or an empty string when the chunk held no answerable query.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@linxiraos/pi-utils",
-	"version": "1.1.25",
+	"version": "1.1.27",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"utilities",
@@ -54,7 +54,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-natives": "1.1.25"
+		"@linxiraos/pi-natives": "1.1.27"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/dirs.ts

@@ -1159,6 +1159,15 @@ export function getGlobalDaemonRuntimeDir(service: string): string {
 	return path.join(getGlobalDaemonRuntimeRoot(), service);
 }
 
+/**
+ * Directory naming session ownership leases (~/.zeta/run/session-owners; XDG
+ * default: $XDG_STATE_HOME/zeta/run/session-owners). Shared across profiles:
+ * every omp process that opens a session must meet the same lease.
+ */
+export function getSessionOwnersDir(): string {
+	return dirs.baseRootSubdir(path.join("run", "session-owners"), "state");
+}
+
 /** Get the provider in-flight root directory (~/.zeta/run/provider-inflight; XDG default: $XDG_STATE_HOME/zeta/run/provider-inflight). */
 export function getProviderInFlightRoot(): string {
 	return dirs.rootSubdir(path.join("run", "provider-inflight"), "state");

package/src/marked/core.ts

@@ -820,8 +820,10 @@ function isBlockStart(lines: string[], index: number): boolean {
 	return false;
 }
 
+// `[^\n]`, not `.`: `.` stops at U+2028 and U+2029, which end no Markdown line,
+// and the match then skips the text in front of them.
 function lineArray(src: string): string[] {
-	return src.match(/.*(?:\n|$)/g)?.filter((line, index, all) => line !== "" || index < all.length - 1) ?? [];
+	return src.match(/[^\n]*(?:\n|$)/g)?.filter((line, index, all) => line !== "" || index < all.length - 1) ?? [];
 }
 function stripFinalNewline(value: string): string {
 	return value.endsWith("\n") ? value.slice(0, -1) : value;

package/src/math-delimiters.ts

@@ -8,6 +8,9 @@
 /** Opening delimiter. Each closer (`$`, `$$`, `\)`, `\]`) is as wide as its opener. */
 export type MathOpener = "$" | "$$" | "\\(" | "\\[";
 
+/** Opener of an own-line display block. */
+export type MathBlockOpener = "$$" | "\\[";
+
 /** A closed math span found in the source. */
 export interface MathSpan {
 	opener: MathOpener;
@@ -33,8 +36,8 @@ export interface MathBlock {
 // it. The own-line requirement leaves inline `$$…$$` inside prose to the span
 // grammar below. `\r?\n` at each line boundary keeps the grammar CRLF-safe for
 // direct callers; marked-fed renderers already normalize line endings first.
-const MATH_BLOCK_DOLLAR = /^ {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/;
-const MATH_BLOCK_BRACKET = /^ {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/;
+const MATH_BLOCK_DOLLAR = / {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/y;
+const MATH_BLOCK_BRACKET = / {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/y;
 
 /**
  * Leftmost offset at or after `from` where an opener could begin. A scan hint,
@@ -182,9 +185,110 @@ function spanOf(source: string, opener: MathOpener, bodyStart: number, closeAt:
 
 /** The own-line display block starting at offset 0, or `undefined`. */
 export function mathBlockAt(source: string): MathBlock | undefined {
-	const match = MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source);
-	if (!match || match[1].trim() === "") return undefined;
-	return { raw: match[0], body: match[1] };
+	MATH_BLOCK_DOLLAR.lastIndex = 0;
+	MATH_BLOCK_BRACKET.lastIndex = 0;
+	return blockOf(MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source));
+}
+
+/** The block a match of the block grammar describes; a whitespace-only body is no block. */
+function blockOf(match: RegExpExecArray | null): MathBlock | undefined {
+	return match === null || match[1].trim() === "" ? undefined : { raw: match[0], body: match[1] };
+}
+
+// An own-line display opener line (`$$` or `\[` after up to 3 spaces), capturing
+// the opener and the line's end: "" when it is the source's unterminated last line.
+const MATH_BLOCK_OPENER_LINE_RE = / {0,3}(\$\$|\\\[)[ \t]*(\r?\n|$)/y;
+
+/**
+ * {@link mathBlockAt} for many offsets of one `source`. An own-line opener
+ * whose closer line is missing means every later opener of the same kind
+ * misses one too, since its search covers a suffix of that search. The scan
+ * keeps that answer, so asking at every block start takes linear time instead
+ * of a scan to the end of `source` per unclosed opener.
+ */
+export class MathBlockScan {
+	readonly #source: string;
+	// Offset of the first `$$` / `\[` opener line found with no closer line after it.
+	#unclosedDollarFrom = Number.POSITIVE_INFINITY;
+	#unclosedBracketFrom = Number.POSITIVE_INFINITY;
+
+	constructor(source: string) {
+		this.#source = source;
+	}
+
+	/** The own-line display block starting at `from`, or `undefined`. */
+	at(from: number): MathBlock | undefined {
+		MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+		const line = MATH_BLOCK_OPENER_LINE_RE.exec(this.#source);
+		// An unterminated opener line opens no block.
+		if (line === null || line[2] === "") return undefined;
+		const dollar = line[1] === "$$";
+		if (from >= (dollar ? this.#unclosedDollarFrom : this.#unclosedBracketFrom)) return undefined;
+		const grammar = dollar ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+		grammar.lastIndex = from;
+		const match = grammar.exec(this.#source);
+		if (match === null) {
+			if (dollar) this.#unclosedDollarFrom = from;
+			else this.#unclosedBracketFrom = from;
+		}
+		return blockOf(match);
+	}
+}
+
+/**
+ * The display opener alone on the line at `from` (up to 3 leading spaces,
+ * trailing spaces or tabs; the source's last line may be unterminated), or
+ * `undefined`.
+ */
+export function mathBlockOpenerAt(source: string, from = 0): MathBlockOpener | undefined {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	return line === null ? undefined : line[1] === "$$" ? "$$" : "\\[";
+}
+
+/**
+ * Whether the own-line display block opened at `from` in `source` is closed,
+ * or could still close once more text is appended: the text from `from`
+ * onward is a streaming prefix whose real closer may not have arrived. A
+ * closer on the unterminated last line has not arrived either, since the next
+ * append may extend it into text (`$$ E = mc^2 $$`). With no opener line at
+ * `from` it returns false before scanning, so a caller can ask at every block
+ * start.
+ */
+export function mathBlockMayCloseAt(source: string, from = 0): boolean {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	if (line === null) return false;
+	// The opener's own line is still being written.
+	if (line[2] === "") return true;
+	const grammar = line[1] === "$$" ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+	grammar.lastIndex = from;
+	const match = grammar.exec(source);
+	// No closer line yet, or only on the last line, which is still being written.
+	if (match === null || (from + match[0].length === source.length && !match[0].endsWith("\n"))) return true;
+	return blockOf(match) !== undefined;
+}
+
+// A display closer alone on its line, captured; the last line counts unterminated.
+const MATH_BLOCK_CLOSER_LINE_RE = /(?<=^|\n) {0,3}(\$\$|\\\])[ \t]*(?=\r?\n|$)/g;
+
+/**
+ * Offset of the first line of `source`, from the line start `from` on, that
+ * holds the closer of `opener` alone (up to 3 leading spaces, trailing spaces
+ * or tabs), the unterminated last line included, or `undefined`: the first
+ * line at which a block `opener` opened before `from` could close.
+ */
+export function mathBlockCloserIndex(source: string, from: number, opener: MathBlockOpener): number | undefined {
+	const closer = opener === "$$" ? "$$" : "\\]";
+	MATH_BLOCK_CLOSER_LINE_RE.lastIndex = from;
+	for (
+		let line = MATH_BLOCK_CLOSER_LINE_RE.exec(source);
+		line !== null;
+		line = MATH_BLOCK_CLOSER_LINE_RE.exec(source)
+	) {
+		if (line[1] === closer) return line.index;
+	}
+	return undefined;
 }
 
 /**

package/src/procmgr.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Process, ProcessStatus } from "@linxiraos/pi-natives";
 import type { Subprocess } from "bun";
-import { getAgentDir, MAIN_CONFIG_FILENAMES } from "./dirs";
+import { getAgentDir, getProjectDir, MAIN_CONFIG_FILENAMES } from "./dirs";
 import { $env, filterChildShellEnv } from "./env";
 import { isExecutable } from "./executable";
 import { $which } from "./which";
@@ -20,18 +20,31 @@ export interface ShellConfigOptions {
 	/** File path or runtime layer that supplied the active shell setting. */
 	configSource?: string;
 }
-/** Auto-resolved shell (no custom path); stable for the process lifetime. */
+/** Auto-resolved shell (no custom path); kept until {@link refreshShellConfigCache}. */
 let cachedDefaultShellConfig: ShellConfig | null = null;
 /** Config for the most recent custom `shellPath`; never served once the path is cleared. */
 let cachedCustomShellConfig: ShellConfig | null = null;
+/**
+ * The child-shell environment {@link refreshShellConfigCache} last captured. Unset
+ * until the first refresh, so spawn environments are built from the live environment.
+ */
+let capturedChildShellEnv: Record<string, string> | undefined;
+/**
+ * Project whose dotenv values the spawn environment filters out: the one current
+ * when it was first built or captured.
+ * That is normally the launch project, whose dotenv files Bun and omp load into
+ * `process.env`; a later session in another project must not receive them.
+ */
+let spawnEnvProjectDir: string | undefined;
 
 /**
  * Build the spawn environment (cached).
  */
 function buildSpawnEnv(shell: string): Record<string, string> {
 	const noCI = $env.PI_BASH_NO_CI || $env.CLAUDE_BASH_NO_CI;
+	spawnEnvProjectDir ??= getProjectDir();
 	return {
-		...filterChildShellEnv(Bun.env),
+		...(capturedChildShellEnv ?? filterChildShellEnv(Bun.env, spawnEnvProjectDir)),
 		SHELL: shell,
 		GIT_EDITOR: "true",
 		GPG_TTY: "not a tty",
@@ -145,6 +158,17 @@ export function resolveBasicShell(): string | undefined {
  *
  * Exported for tests; `env` overrides Bun.env-based discovery.
  */
+
+/** True for the WSL launcher bash.exe variants, which are not Windows shells. */
+function isWslLauncher(bashPath: string): boolean {
+	const normalized = bashPath.toLowerCase().replaceAll("/", "\\");
+	return (
+		normalized.endsWith("\\system32\\bash.exe") ||
+		normalized.endsWith("\\windowsapps\\bash.exe") ||
+		normalized.endsWith("\\system32\\wsl.exe")
+	);
+}
+
 export function resolveWindowsShell(env: Record<string, string | undefined> = Bun.env): string {
 	const gitRoots = [
 		env.ProgramFiles && path.join(env.ProgramFiles, "Git"),
@@ -160,8 +184,12 @@ export function resolveWindowsShell(env: Record<string, string | undefined> = Bu
 		if (fs.existsSync(candidate)) return candidate;
 	}
 
+	// The WSL launcher (`System32\bash.exe` / `WindowsApps\bash.exe`) is not a
+	// Windows shell: it runs inside Linux without the spawn environment, so
+	// scripted `-c` snapshots break. Skip it and let the sh.exe sibling (Git
+	// Bash) or cmd.exe win instead.
 	const bashOnPath = $which("bash.exe");
-	if (bashOnPath) return bashOnPath;
+	if (bashOnPath && !isWslLauncher(bashOnPath)) return bashOnPath;
 
 	const shOnPath = $which("sh.exe");
 	if (shOnPath) {
@@ -202,6 +230,32 @@ export function getShellConfig(customShellPath?: string, options: ShellConfigOpt
 	return cachedDefaultShellConfig;
 }
 
+/**
+ * Capture the current process environment for child shells and drop both cached
+ * shell configs, so the next {@link getShellConfig} builds the spawn environment
+ * from that capture. Call right after code that changed `process.env` in a way
+ * child shells must see, such as extension session lifecycle handlers exporting
+ * session-scoped variables; later writes reach child shells only at the next call.
+ */
+export function refreshShellConfigCache(): void {
+	spawnEnvProjectDir ??= getProjectDir();
+	capturedChildShellEnv = filterChildShellEnv(Bun.env, spawnEnvProjectDir);
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
+/**
+ * Test-only: forget the capture and both cached shell configs, so the next
+ * {@link getShellConfig} builds from the live environment again. Production code
+ * MUST NOT call this; the capture's lifecycle is owned by {@link refreshShellConfigCache}.
+ */
+export function __resetShellConfigCacheForTests(): void {
+	capturedChildShellEnv = undefined;
+	spawnEnvProjectDir = undefined;
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
 /** Platform shell discovery used when no custom `shellPath` is configured. */
 function resolveDefaultShell(): string {
 	if (process.platform === "win32") {

package/src/sqlite.ts

@@ -1,6 +1,7 @@
 /** Shared SQLite opening, error attribution, and result-code classification for persistent stores. */
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { getDbBusyTimeoutMs } from "./env";
 import { withFileLockSync } from "./file-lock";
 import { isEnoent } from "./fs-error";
@@ -12,6 +13,55 @@ const SQLITE_STORE_SUFFIXES = ["-wal", "-shm", "-journal", ""];
 
 type SqliteFileIdentity = string | null | undefined;
 
+/**
+ * Corrupt handles held open by in-process openers awaiting recovery, keyed by
+ * resolved store path. Windows refuses to unlink a file any handle still holds,
+ * so the opener that quarantines the store closes its peers' dead handles too.
+ */
+const pendingCorruptHandles = new Map<string, Set<Database>>();
+
+function corruptHandleKey(dbPath: string): string {
+	const resolved = path.resolve(dbPath);
+	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function registerCorruptHandle(dbPath: string, db: Database | undefined): void {
+	if (!db) return;
+	const key = corruptHandleKey(dbPath);
+	let handles = pendingCorruptHandles.get(key);
+	if (!handles) {
+		handles = new Set();
+		pendingCorruptHandles.set(key, handles);
+	}
+	handles.add(db);
+}
+
+function unregisterCorruptHandle(dbPath: string, db: Database | undefined): void {
+	if (!db) return;
+	const key = corruptHandleKey(dbPath);
+	const handles = pendingCorruptHandles.get(key);
+	if (!handles) return;
+	handles.delete(db);
+	if (handles.size === 0) pendingCorruptHandles.delete(key);
+}
+
+/** Closes peers' failed handles on the store; each peer still closes (idempotently) and adopts on its own path. */
+function closePeerCorruptHandles(dbPath: string, own: Database | undefined): void {
+	const handles = pendingCorruptHandles.get(corruptHandleKey(dbPath));
+	if (!handles) return;
+	for (const peer of handles) {
+		if (peer === own) continue;
+		try {
+			peer.close();
+		} catch (error) {
+			logger.warn("Failed to close a peer's corrupt SQLite handle before quarantine", {
+				path: dbPath,
+				error: String(error),
+			});
+		}
+	}
+}
+
 class SqliteAttemptFailure extends Error {
 	readonly original: unknown;
 	readonly identity: SqliteFileIdentity;
@@ -99,6 +149,7 @@ async function openWithBusyRetries<T>(
 		} catch (caught) {
 			const error = options.recoverCorruption ? revealHiddenCorruption(db, caught) : caught;
 			if (options.recoverCorruption && isSqliteCorruptionError(error)) {
+				registerCorruptHandle(dbPath, db);
 				throw new SqliteAttemptFailure(error, identity, { db });
 			}
 			closeFailedDatabase(db, error, identity);
@@ -120,6 +171,7 @@ function openOnce<T>(dbPath: string, initialize: (db: Database) => T, options: S
 	} catch (caught) {
 		const error = options.recoverCorruption ? revealHiddenCorruption(db, caught) : caught;
 		if (options.recoverCorruption && isSqliteCorruptionError(error)) {
+			registerCorruptHandle(dbPath, db);
 			throw new SqliteAttemptFailure(error, identity, { db });
 		}
 		closeFailedDatabase(db, error, identity);
@@ -143,6 +195,10 @@ function quarantineCorruptSqliteStore(dbPath: string, db: Database | undefined):
 		}
 	}
 	db?.close();
+	// Only Windows refuses to unlink a file another handle still holds. Elsewhere
+	// each peer must keep its own handle until it closes it after adopting the
+	// replacement; closing it here races the peer's recovery on POSIX.
+	if (process.platform === "win32") closePeerCorruptHandles(dbPath, db);
 
 	const removed: string[] = [];
 	try {
@@ -199,6 +255,7 @@ function recoverCorruptDatabase(dbPath: string, error: unknown, options: SqliteO
 				return quarantineCorruptSqliteStore(dbPath, failure.db);
 			});
 		} finally {
+			unregisterCorruptHandle(dbPath, failure.db);
 			closeFailedDatabase(failure.db, failure.original, failure.identity);
 		}
 	} catch (preservationError) {
@@ -267,7 +324,7 @@ export function openSqliteDatabaseSync<T>(
 /** Adds the failing store's path to an error without losing SQLite result codes or its original stack. */
 export function annotateSqliteError(error: unknown, dbPath: string): Error {
 	const annotated = error instanceof Error ? error : new Error(String(error));
-	annotated.message = `Database ${JSON.stringify(dbPath)}: ${annotated.message}`;
+	annotated.message = `Database "${dbPath}": ${annotated.message}`;
 	return annotated;
 }
 

package/src/temp.ts

@@ -96,6 +96,11 @@ export async function removeWithRetries(target: string): Promise<void> {
 			return;
 		} catch (err) {
 			if (!shouldRetryRemove(err, attempt)) throw err;
+			// bun on Windows finalizes SQLite's db/-wal/-shm file and directory
+			// handles on GC, so a closed database can still block deletion for
+			// seconds. One forced major collection on the first retry releases
+			// them immediately instead of burning the retry window.
+			if (attempt === 0) Bun.gc(true);
 			await Bun.sleep(kRemoveRetryDelayMs);
 		}
 	}
@@ -108,6 +113,7 @@ export function removeSyncWithRetries(target: string): void {
 			return;
 		} catch (err) {
 			if (!shouldRetryRemove(err, attempt)) throw err;
+			if (attempt === 0) Bun.gc(true);
 			sleepSync(kRemoveRetryDelayMs);
 		}
 	}

package/src/vterm/query-responder.ts

@@ -1,3 +1,18 @@
+/**
+ * Options for {@link TerminalQueryResponder}.
+ */
+export interface TerminalQueryResponderOptions {
+	/**
+	 * The PTY host opens the session with its own cursor-position query
+	 * (`CSI 6 n`), which the PTY layer has already answered — ConPTY's
+	 * `PSEUDOCONSOLE_INHERIT_CURSOR` handshake. Leave that first cursor query
+	 * unanswered: the host consumes exactly one report, so a second one would
+	 * reach the program as input it never asked for. Every later cursor query
+	 * is answered. Defaults to `false`.
+	 */
+	hostCursorHandshake?: boolean;
+}
+
 /**
  * Answers terminal capability queries emitted by programs on a headless PTY.
  *
@@ -17,6 +32,12 @@
 export class TerminalQueryResponder {
 	/** Trailing bytes that may be the start of an unfinished query escape. */
 	#residual = "";
+	/** Whether the next cursor query is the host's already-answered session-start handshake. */
+	#hostCursorHandshakePending: boolean;
+
+	constructor(options: TerminalQueryResponderOptions = {}) {
+		this.#hostCursorHandshakePending = options.hostCursorHandshake ?? false;
+	}
 
 	/**
 	 * Feed one raw PTY output chunk. Returns the reply bytes to write back into
@@ -29,7 +50,12 @@ export class TerminalQueryResponder {
 		QUERY.lastIndex = 0;
 		for (let match = QUERY.exec(buffer); match !== null; match = QUERY.exec(buffer)) {
 			lastEnd = match.index + match[0].length;
-			replies += replyFor(match);
+			const reply = replyFor(match);
+			if (reply === CURSOR_POSITION_REPORT && this.#hostCursorHandshakePending) {
+				this.#hostCursorHandshakePending = false;
+				continue;
+			}
+			replies += reply;
 		}
 		// Keep only a short unmatched trailing escape: a query split across
 		// chunks completes on the next feed, while a long tail is ordinary output
@@ -41,6 +67,9 @@ export class TerminalQueryResponder {
 	}
 }
 
+/** Cursor position report for the home position: there is no screen to locate the cursor on. */
+const CURSOR_POSITION_REPORT = "\x1b[1;1R";
+
 /** Longest query escape we answer, bounding the cross-chunk residual. */
 const MAX_PARTIAL_QUERY = 32;
 
@@ -63,7 +92,7 @@ function replyFor(match: RegExpExecArray): string {
 		}
 		if (intermediate !== "") return ""; // private DSR forms (DECXCPR, appearance) stay unanswered
 		const selector = params.split(";", 1)[0];
-		if (selector === "6") return "\x1b[1;1R"; // cursor position: home, there is no screen
+		if (selector === "6") return CURSOR_POSITION_REPORT;
 		if (selector === "5") return "\x1b[0n"; // device status: OK
 		return "";
 	}