@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/tts/streaming-player.ts

@@ -1,321 +1,120 @@
-/**
- * Gapless streaming audio output for assistant speech.
- *
- * Replaces the spawn-`afplay`-per-sentence approach (a fresh process per chunk
- * meant audible gaps, per-spawn latency, and no way to interrupt a clip mid-play)
- * with a single persistent player process fed raw 32-bit-float mono PCM over
- * stdin. Chunks are queued and drained by one writer so segments play back to
- * back; writes are paced to stay only {@link LEAD_SECONDS} ahead of realtime so
- * ducking and stop take effect promptly instead of after seconds of buffered
- * audio. {@link StreamingAudioPlayer.stop} kills the process for instant silence.
- *
- * Where no streaming backend exists (Windows, or a host without ffmpeg/sox), it
- * degrades to the per-file {@link playAudioFile} path so speech still works —
- * just without gapless playback or mid-clip interruption. A backend that spawns
- * but dies early (e.g. an ffmpeg built without its platform audio device) is
- * detected via its exit and the session downgrades to per-file playback without
- * dropping the chunk being played.
- */
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { $which, logger, Snowflake } from "@oh-my-pi/pi-utils";
-import type { FileSink, Subprocess } from "bun";
-import { getToolPath } from "../utils/tools-manager";
-import { type PlayerCommand, playAudioFile } from "./player";
-import { encodeWav } from "./wav";
+import { AudioPlayback } from "@oh-my-pi/pi-natives";
 
-/** Kokoro emits 24 kHz mono; used when a chunk does not declare a rate. */
+/** Kokoro emits 24 kHz mono PCM when a chunk does not declare a rate. */
 const DEFAULT_SAMPLE_RATE = 24_000;
-/** Cap how far ahead of realtime we buffer into the player so duck/stop are responsive. */
-const LEAD_SECONDS = 0.6;
-/** Output gain applied while ducked (the user is speaking over the assistant). */
+
+/** Output gain applied while the user speaks over assistant audio. */
 export const DUCK_GAIN = 0.25;
 
-/** Injection seam for {@link streamingPlayerCommandsFor} — defaults to real PATH/tools lookups. */
-export interface StreamingPlayerLookup {
-	which?: (bin: string) => string | null;
-	ffmpeg?: () => string | null;
+function errorFrom(cause: unknown): Error {
+	return cause instanceof Error ? cause : new Error(String(cause));
 }
 
 /**
- * Ordered candidate commands for a persistent raw-PCM player on `platform`: each
- * reads 32-bit-float little-endian mono PCM at `sampleRate` from stdin (`pipe:0`)
- * and plays it to the default output device. An empty list means no streaming
- * backend is available and the caller should fall back to per-file playback.
- *
- * - darwin: `ffmpeg` (AudioToolbox output device) → sox's `play` (coreaudio).
- * - linux/other POSIX: `ffmpeg` (`-f pulse` then `-f alsa`) → `paplay`/`aplay`
- *   raw fallbacks.
- * - win32: none (PowerShell `SoundPlayer` is file-only).
- */
-export function streamingPlayerCommandsFor(
-	platform: NodeJS.Platform,
-	sampleRate: number,
-	lookup: StreamingPlayerLookup = {},
-): PlayerCommand[] {
-	const which = lookup.which ?? $which;
-	const ffmpeg = lookup.ffmpeg ?? ((): string | null => getToolPath("ffmpeg"));
-	const rate = String(sampleRate > 0 ? sampleRate : DEFAULT_SAMPLE_RATE);
-	const input = ["-loglevel", "error", "-nostdin", "-f", "f32le", "-ar", rate, "-ac", "1", "-i", "pipe:0"];
-
-	if (platform === "darwin") {
-		const commands: PlayerCommand[] = [];
-		const ffmpegBin = ffmpeg();
-		if (ffmpegBin) commands.push({ cmd: ffmpegBin, args: [...input, "-f", "audiotoolbox", "default"] });
-		const play = which("play");
-		if (play) {
-			commands.push({
-				cmd: play,
-				args: ["-q", "-t", "raw", "-e", "floating-point", "-b", "32", "-r", rate, "-c", "1", "-"],
-			});
-		}
-		return commands;
-	}
-	if (platform === "win32") {
-		return [];
-	}
-
-	const commands: PlayerCommand[] = [];
-	const ffmpegBin = ffmpeg();
-	if (ffmpegBin) {
-		commands.push({ cmd: ffmpegBin, args: [...input, "-f", "pulse", "default"] });
-		commands.push({ cmd: ffmpegBin, args: [...input, "-f", "alsa", "default"] });
-	}
-	const paplay = which("paplay");
-	if (paplay) commands.push({ cmd: paplay, args: ["--raw", `--rate=${rate}`, "--format=float32le", "--channels=1"] });
-	const aplay = which("aplay");
-	if (aplay) commands.push({ cmd: aplay, args: ["-q", "-f", "FLOAT_LE", "-r", rate, "-c", "1", "-"] });
-	return commands;
-}
-
-/**
- * Single-session gapless player. Lifecycle: {@link start} once, {@link write}
- * chunks in order, then {@link end} to drain or {@link stop} to abort. Not
- * reusable after stop/end — create a new instance per utterance.
+ * One native gapless playback session. Call {@link start}, enqueue mono `f32`
+ * chunks with {@link write}, then {@link end} to drain or {@link stop} to abort.
  */
 export class StreamingAudioPlayer {
-	#queue: Float32Array[] = [];
+	#native: AudioPlayback | null = null;
 	#sampleRate = DEFAULT_SAMPLE_RATE;
 	#gain = 1;
-	#mode: "stream" | "file" = "file";
-	#proc: Subprocess<"pipe", "ignore", "ignore"> | null = null;
-	#sink: FileSink | null = null;
-	/** Streaming backends not yet tried; consumed head-first by {@link #spawnStream}. */
-	#candidates: PlayerCommand[] | null = null;
-	#writtenSec = 0;
-	#startedAt = 0;
-	#started = false;
+	#error: Error | null = null;
+	#ending: Promise<void> | null = null;
 	#inputClosed = false;
 	#stopped = false;
-	#abortController = new AbortController();
-	#wake: (() => void) | null = null;
-	#drain: Promise<void> = Promise.resolve();
+	#failNative(native: AudioPlayback, cause: unknown): void {
+		this.#error = errorFrom(cause);
+		if (this.#native === native) this.#native = null;
+		try {
+			native.stop();
+		} catch {
+			// Preserve the original playback failure.
+		}
+	}
 
-	/** Pick a backend and begin draining. Idempotent; the first call's rate wins. */
-	start(sampleRate: number): void {
-		if (this.#started || this.#stopped) return;
-		this.#started = true;
+	/** Opens the default speaker at the stream's logical sample rate. */
+	start(sampleRate = DEFAULT_SAMPLE_RATE): void {
+		if (this.#native || this.#error || this.#inputClosed || this.#stopped) return;
 		this.#sampleRate = sampleRate > 0 ? sampleRate : DEFAULT_SAMPLE_RATE;
-		this.#mode = this.#spawnStream() ? "stream" : "file";
-		this.#startedAt = performance.now();
-		this.#drain = this.#drainLoop();
+		let native: AudioPlayback | undefined;
+		try {
+			native = new AudioPlayback(this.#sampleRate);
+			native.setGain(this.#gain);
+			this.#native = native;
+		} catch (cause) {
+			if (native) this.#failNative(native, cause);
+			else this.#error = errorFrom(cause);
+		}
 	}
 
-	/** Queue a mono float32 PCM chunk for playback in arrival order. */
+	/** Queues one mono `f32` PCM chunk without copying it in TypeScript. */
 	write(pcm: Float32Array): void {
-		if (this.#stopped) return;
-		this.#queue.push(pcm);
-		this.#signal();
-	}
-
-	/** Scale subsequent output (1 = normal, <1 = ducked). Applies within {@link LEAD_SECONDS}. */
-	setGain(gain: number): void {
-		this.#gain = gain < 0 ? 0 : gain;
-	}
-
-	/** Close the input; resolves once all queued audio has finished playing. */
-	async end(): Promise<void> {
-		this.#inputClosed = true;
-		this.#signal();
-		await this.#drain;
-	}
-
-	/** Stop immediately: kill the player, drop everything still queued. */
-	stop(): void {
-		if (this.#stopped) return;
-		this.#stopped = true;
-		this.#queue.length = 0;
-		this.#abortController.abort();
-		this.#signal();
+		if (this.#inputClosed || this.#stopped || pcm.length === 0) return;
+		if (!this.#native && !this.#error) this.start(this.#sampleRate);
+		const native = this.#native;
+		if (!native) return;
 		try {
-			// end() flushes asynchronously; the SIGKILL below races it, so a broken
-			// pipe here is expected — swallow the rejection (it otherwise surfaces
-			// as an unhandled EPIPE right as speech ends).
-			void Promise.resolve(this.#sink?.end()).catch(() => {});
-		} catch {}
-		try {
-			this.#proc?.kill("SIGKILL");
-		} catch {}
-	}
-
-	/**
-	 * Spawn the next untried streaming backend; false once the list is
-	 * exhausted. A backend that spawns but dies early (e.g. an ffmpeg built
-	 * without this platform's audio output device) would otherwise swallow PCM
-	 * into a dead pipe, so its exit advances to the next candidate — or to
-	 * per-file playback — and #writeStream's failure path replays the
-	 * in-flight chunk.
-	 */
-	#spawnStream(): boolean {
-		this.#candidates ??= streamingPlayerCommandsFor(process.platform, this.#sampleRate);
-		for (let command = this.#candidates.shift(); command; command = this.#candidates.shift()) {
-			const { cmd, args } = command;
-			try {
-				const proc = Bun.spawn([cmd, ...args], {
-					stdin: "pipe",
-					stdout: "ignore",
-					stderr: "ignore",
-				});
-				this.#proc = proc;
-				this.#sink = proc.stdin;
-				void proc.exited.then(code => {
-					if (this.#proc !== proc || this.#stopped || this.#inputClosed) return;
-					logger.debug("tts: streaming backend exited early; trying next backend", { cmd, code });
-					this.#proc = null;
-					this.#sink = null;
-					this.#mode = this.#spawnStream() ? "stream" : "file";
-				});
-				return true;
-			} catch (error) {
-				logger.debug("tts: streaming player spawn failed", {
-					cmd,
-					error: error instanceof Error ? error.message : String(error),
-				});
-			}
+			native.write(pcm);
+		} catch (cause) {
+			this.#failNative(native, cause);
 		}
-		return false;
 	}
 
-	#signal(): void {
-		const wake = this.#wake;
-		this.#wake = null;
-		wake?.();
-	}
-
-	async #drainLoop(): Promise<void> {
+	/** Applies gain at render time, including to samples already queued natively. */
+	setGain(gain: number): void {
+		if (!Number.isFinite(gain) || gain < 0) throw new RangeError("Audio gain must be a finite non-negative number");
+		this.#gain = gain;
+		const native = this.#native;
+		if (!native) return;
 		try {
-			while (!this.#stopped) {
-				const chunk = this.#queue.shift();
-				if (!chunk) {
-					if (this.#inputClosed) break;
-					await this.#waitForWork();
-					continue;
-				}
-				if (this.#mode === "stream") {
-					// Pace writes so the player buffers ~LEAD_SECONDS, no more, keeping
-					// ducking and stop responsive instead of locked behind buffered audio.
-					const ahead = this.#writtenSec - (performance.now() - this.#startedAt) / 1000;
-					if (ahead > LEAD_SECONDS) {
-						await Bun.sleep((ahead - LEAD_SECONDS) * 1000);
-						if (this.#stopped) return;
-					}
-					if (await this.#writeStream(chunk)) {
-						this.#writtenSec += chunk.length / this.#sampleRate;
-						continue;
-					}
-					// Backend died mid-write: move to the next streaming candidate
-					// (or the file path) and replay this exact chunk so nothing is
-					// dropped.
-					this.#mode = this.#spawnStream() ? "stream" : "file";
-					if (this.#mode === "stream" && (await this.#writeStream(chunk))) {
-						this.#writtenSec += chunk.length / this.#sampleRate;
-					} else {
-						this.#mode = "file";
-						await this.#playFile(chunk);
-					}
-				} else {
-					await this.#playFile(chunk);
-				}
-			}
-			if (!this.#stopped && this.#mode === "stream") {
-				try {
-					await this.#sink?.end();
-				} catch {}
-				if (this.#proc) {
-					try {
-						await this.#proc.exited;
-					} catch {}
-				}
-			}
-		} catch (error) {
-			logger.debug("tts: streaming player drain failed", {
-				error: error instanceof Error ? error.message : String(error),
-			});
+			native.setGain(gain);
+		} catch (cause) {
+			this.#failNative(native, cause);
 		}
 	}
 
-	/** Block until a chunk is queued, the input closes, or stop is called. */
-	#waitForWork(): Promise<void> {
-		const { promise, resolve } = Promise.withResolvers<void>();
-		this.#wake = resolve;
-		// Re-check after arming to close the gap between the empty shift and here.
-		if (this.#queue.length > 0 || this.#inputClosed || this.#stopped) {
-			this.#wake = null;
-			resolve();
+	/** Closes input and resolves after every queued sample reaches the speaker. */
+	end(): Promise<void> {
+		if (this.#ending) return this.#ending;
+		if (this.#stopped) return Promise.resolve();
+		this.#inputClosed = true;
+		if (this.#error) {
+			this.#stopped = true;
+			return Promise.reject(this.#error);
 		}
-		return promise;
-	}
-
-	/**
-	 * Write one chunk into the backend's stdin and await the flush — a broken
-	 * pipe rejects here (not as an unhandled rejection later), so the caller
-	 * can replay the exact chunk on the next backend.
-	 */
-	async #writeStream(pcm: Float32Array): Promise<boolean> {
-		const sink = this.#sink;
-		if (!sink) return false;
-		try {
-			sink.write(this.#bytes(pcm));
-			await sink.flush();
-			return true;
-		} catch (error) {
-			logger.debug("tts: streaming write failed", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-			return false;
+		const native = this.#native;
+		if (!native) {
+			this.#stopped = true;
+			return Promise.resolve();
 		}
+		this.#ending = native
+			.end()
+			.catch(cause => {
+				throw errorFrom(cause);
+			})
+			.finally(() => {
+				if (this.#native === native) this.#native = null;
+				this.#stopped = true;
+			});
+		return this.#ending;
 	}
 
-	async #playFile(pcm: Float32Array): Promise<void> {
-		const wavPath = path.join(os.tmpdir(), `omp-speech-${Snowflake.next()}.wav`);
+	/** Stops immediately and discards queued audio. Safe to call repeatedly. */
+	stop(): void {
+		this.#inputClosed = true;
+		this.#stopped = true;
+		const native = this.#native;
+		this.#native = null;
+		if (!native) return;
 		try {
-			await fs.writeFile(wavPath, encodeWav(this.#scaled(pcm), this.#sampleRate));
-			if (!this.#stopped) await playAudioFile(wavPath, { signal: this.#abortController.signal });
-		} catch (error) {
-			logger.debug("tts: file playback failed", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-		} finally {
-			await fs.unlink(wavPath).catch(() => {});
+			native.stop();
+		} catch {
+			// Best-effort abort during session teardown.
 		}
 	}
-
-	/** Raw f32le bytes for the stream sink, applying gain only when ducked (avoids a copy at unity). */
-	#bytes(pcm: Float32Array): Uint8Array {
-		if (this.#gain === 1) return new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength);
-		return new Uint8Array(this.#scaled(pcm).buffer);
-	}
-
-	#scaled(pcm: Float32Array): Float32Array {
-		if (this.#gain === 1) return pcm;
-		const out = new Float32Array(pcm.length);
-		for (let i = 0; i < pcm.length; i++) out[i] = (pcm[i] ?? 0) * this.#gain;
-		return out;
-	}
 }
 
-/** Factory the vocalizer calls; a function so tests can stub it without spawning a player. */
+/** Creates the single-use player used by the speech vocalizer. */
 export function createStreamingPlayer(): StreamingAudioPlayer {
 	return new StreamingAudioPlayer();
 }

package/src/tts/vocalizer.ts

@@ -100,6 +100,8 @@ export class Vocalizer {
 	#chain: Promise<void> = Promise.resolve();
 	/** Whether the user is currently speaking; new sessions open ducked. */
 	#ducked = false;
+	/** Active scopes that suppress local TTS while another speech surface owns audio. */
+	#suspensions = 0;
 	/** Available rewrite slots; blocks queue when exhausted. */
 	#rewriteSlots = MAX_REWRITES_IN_FLIGHT;
 	#slotWaiters: Array<() => void> = [];
@@ -114,6 +116,21 @@ export class Vocalizer {
 		this.#enhancer = enhancer;
 	}
 
+	/**
+	 * Suppress new vocalization until the returned idempotent release function runs.
+	 * Existing synthesis and playback stop immediately; nested scopes release independently.
+	 */
+	suspend(): () => void {
+		this.#suspensions += 1;
+		this.clear();
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.#suspensions = Math.max(0, this.#suspensions - 1);
+		};
+	}
+
 	/**
 	 * Stream a delta of assistant text into the pipeline. No-op when
 	 * vocalization is disabled. The synthesis session (worker, player) is only
@@ -123,7 +140,7 @@ export class Vocalizer {
 	 * pipeline (enhanced vs mechanical) is latched per utterance.
 	 */
 	pushDelta(text: string): void {
-		if (!settings.get("speech.enabled")) return;
+		if (this.#suspensions > 0 || !settings.get("speech.enabled")) return;
 		if (!text) return;
 		if (this.#enhanced || (!this.#speakable && this.#enhancer && settings.get("speech.enhanced"))) {
 			this.#pushEnhanced(text);

package/src/utils/clipboard.ts

@@ -1,6 +1,7 @@
 import type { ClipboardImage } from "@oh-my-pi/pi-natives";
 import * as native from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
+import MAC_FILE_URL_SCRIPT from "./mac-file-urls.applescript" with { type: "text" };
 
 /**
  * Run a subprocess and capture its stdout without blocking the event loop.
@@ -52,36 +53,6 @@ function isWsl(): boolean {
 	return process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
 }
 
-// AppleScript that returns the POSIX paths of every file URL currently on the
-// macOS pasteboard, one path per line. `pbpaste(1)` only surfaces plain text,
-// EPS, or RTF, so a Finder `Cmd+C` (which puts only a `public.file-url`
-// representation on the pasteboard) makes `pbpaste` empty. AppleScript's
-// `«class furl»` coercion reaches the file-URL representation directly and
-// works for both single-file and multi-file selections. The `try` blocks
-// suppress the `-1700` "can't make … into type" error AppleScript raises when
-// the clipboard holds no file URLs, so the script's exit status only reflects
-// `osascript` itself.
-const MAC_FILE_URL_SCRIPT = [
-	"on run",
-	'\tset output to ""',
-	"\ttry",
-	"\t\tset theClip to the clipboard as «class furl»",
-	"\t\tif class of theClip is list then",
-	"\t\t\trepeat with anItem in theClip",
-	"\t\t\t\ttry",
-	"\t\t\t\t\tset output to output & POSIX path of anItem & linefeed",
-	"\t\t\t\tend try",
-	"\t\t\tend repeat",
-	"\t\telse",
-	"\t\t\ttry",
-	"\t\t\t\tset output to POSIX path of theClip & linefeed",
-	"\t\t\tend try",
-	"\t\tend if",
-	"\tend try",
-	"\treturn output",
-	"end run",
-].join("\n");
-
 /**
  * Read file paths from the macOS pasteboard's `public.file-url` representation.
  *

package/src/utils/jj.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs/promises";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { $which } from "@oh-my-pi/pi-utils";
 import { LRUCache } from "lru-cache/raw";
@@ -63,6 +63,8 @@ export class JjCommandError extends Error {
 // ════════════════════════════════════════════════════════════════════════════
 // Internal: Core execution
 // ════════════════════════════════════════════════════════════════════════════
+const WORKING_COPY_LABEL_REVSET = "@ | heads(::@ & bookmarks())";
+const WORKING_COPY_LABEL_TEMPLATE = 'change_id.shortest(8) ++ "|" ++ local_bookmarks ++ "\\n"';
 
 function ensureAvailable(): void {
 	if (!$which("jj")) {
@@ -121,6 +123,19 @@ async function runText(cwd: string, args: readonly string[], options: CommandOpt
 	return (await runChecked(cwd, args, options)).stdout;
 }
 
+async function runOptionalText(
+	cwd: string,
+	args: readonly string[],
+	options: CommandOptions = {},
+): Promise<string | null> {
+	try {
+		const result = await jj(cwd, args, options);
+		return result.exitCode === 0 ? result.stdout : null;
+	} catch {
+		return null;
+	}
+}
+
 function splitLines(text: string): string[] {
 	return text
 		.split("\n")
@@ -135,6 +150,30 @@ function buildDiffArgs(options: DiffOptions): string[] {
 	return args;
 }
 
+function parseWorkingCopyLabel(raw: string): string | null {
+	let changeId: string | null = null;
+	for (const line of raw.split("\n")) {
+		const sep = line.indexOf("|");
+		const change = (sep === -1 ? line : line.slice(0, sep)).trim();
+		const bookmarks = sep === -1 ? "" : line.slice(sep + 1).trim();
+		if (changeId === null && change) changeId = change;
+		if (bookmarks) return bookmarks.replace(/\s+/g, " ");
+	}
+	return changeId;
+}
+
+function parseStatusSummary(raw: string): git.GitStatusSummary {
+	let unstaged = 0;
+	let untracked = 0;
+	for (const line of raw.split("\n")) {
+		const type = line.trim()[0];
+		if (!type) continue;
+		if (type === "A") untracked++;
+		else unstaged++;
+	}
+	return { staged: 0, unstaged, untracked };
+}
+
 // ════════════════════════════════════════════════════════════════════════════
 // Internal: Repository resolution
 // ════════════════════════════════════════════════════════════════════════════
@@ -153,7 +192,16 @@ async function hasJjWorkspaceMetadata(dir: string): Promise<boolean> {
 	// of the default workspace. Either form is a real workspace, so match on
 	// `.jj/repo` presence rather than the inner `store/` directory.
 	try {
-		await fs.stat(path.join(dir, ".jj", "repo"));
+		await fs.promises.stat(path.join(dir, ".jj", "repo"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function hasJjWorkspaceMetadataSync(dir: string): boolean {
+	try {
+		fs.statSync(path.join(dir, ".jj", "repo"));
 		return true;
 	} catch {
 		return false;
@@ -180,6 +228,21 @@ async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
 	return undefined;
 }
 
+function findWorkspaceRootSync(cwd: string): string | undefined {
+	const key = path.resolve(cwd);
+	if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)?.root;
+
+	for (let dir: string | undefined = key; dir; dir = parentOf(dir)) {
+		if (hasJjWorkspaceMetadataSync(dir)) {
+			workspaceRootCache.set(key, { root: dir });
+			return dir;
+		}
+	}
+
+	workspaceRootCache.set(key, {});
+	return undefined;
+}
+
 /**
  * Resolve the `.jj/repo` directory backing a workspace root, following the file
  * indirection used by non-default workspaces. `jj workspace add` writes a FILE at
@@ -190,8 +253,8 @@ async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
 async function resolveRepoDir(root: string): Promise<string> {
 	const jjDir = path.join(root, ".jj");
 	const repoPath = path.join(jjDir, "repo");
-	if ((await fs.stat(repoPath)).isFile()) {
-		const target = (await fs.readFile(repoPath, "utf8")).trim();
+	if ((await fs.promises.stat(repoPath)).isFile()) {
+		const target = (await fs.promises.readFile(repoPath, "utf8")).trim();
 		return path.resolve(jjDir, target);
 	}
 	return repoPath;
@@ -221,6 +284,56 @@ export const diff = Object.assign(
 	},
 );
 
+// ════════════════════════════════════════════════════════════════════════════
+// API: working copy
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Jujutsu working-copy metadata used by status displays. */
+export const workingCopy = {
+	/**
+	 * Label `@` with its nearest bookmark, falling back to its short change ID.
+	 * Returns `null` when `jj` is unavailable or the query fails.
+	 */
+	async label(cwd: string, signal?: AbortSignal): Promise<string | null> {
+		const raw = await runOptionalText(
+			cwd,
+			[
+				"log",
+				"--no-graph",
+				"--ignore-working-copy",
+				"-r",
+				WORKING_COPY_LABEL_REVSET,
+				"-T",
+				WORKING_COPY_LABEL_TEMPLATE,
+			],
+			{ signal },
+		);
+		return raw === null ? null : parseWorkingCopyLabel(raw);
+	},
+
+	/** Parse working-copy label query output. */
+	parseLabel: parseWorkingCopyLabel,
+};
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: status
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Jujutsu working-copy status derived from the changes in `@`. */
+export const status = {
+	/**
+	 * Count changes in `@` relative to its parent using the Git status shape.
+	 * Jujutsu has no index, so `staged` is always zero.
+	 */
+	async summary(cwd: string, signal?: AbortSignal): Promise<git.GitStatusSummary | null> {
+		const raw = await runOptionalText(cwd, ["diff", "-r", "@", "--summary", "--ignore-working-copy"], { signal });
+		return raw === null ? null : parseStatusSummary(raw);
+	},
+
+	/** Parse `jj diff --summary` output into status counts. */
+	parse: parseStatusSummary,
+};
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: repo
 // ════════════════════════════════════════════════════════════════════════════
@@ -231,6 +344,14 @@ export const repo = {
 		workspaceRootCache.clear();
 	},
 
+	/**
+	 * Resolve the current workspace root synchronously from on-disk metadata.
+	 * Intended for render paths that cannot await filesystem I/O.
+	 */
+	rootSync(cwd: string): string | null {
+		return findWorkspaceRootSync(cwd) ?? null;
+	},
+
 	/** Resolve the current Jujutsu workspace root, or `null` when `cwd` is not in a JJ repository. */
 	async root(cwd: string): Promise<string | null> {
 		return (await findWorkspaceRoot(cwd)) ?? null;