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

package/src/tools/write.ts

@@ -49,7 +49,14 @@ import {
 } from "./conflict-detect";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
-import { formatPathRelativeToCwd, isInternalUrlPath, pathTargetsSsh, peelWriteUrlSelector } from "./path-utils";
+import {
+	formatPathRelativeToCwd,
+	isInternalUrlPath,
+	pathTargetsSsh,
+	peelWriteUrlSelector,
+	probeLiteralPathExists,
+	splitPathAndSel,
+} from "./path-utils";
 import { enforcePlanModeWrite, resolvePlanPath, unwrapHashlineHeaderPath } from "./plan-mode-guard";
 import {
 	cachedRenderedString,
@@ -116,6 +123,43 @@ function assertWriteTargetAddressable(target: string, router: InternalUrlRouter)
 	);
 }
 
+/**
+ * Fail closed when a local write target looks like a mis-dispatched read.
+ *
+ * A read-only step that selects `write` instead of `read` passes the full read
+ * expression (`src/foo.tsx:1-260:raw`) as the target. Because a literal colon
+ * filename is legal on POSIX (issue #4618), that request otherwise resolves to
+ * filesystem creation and reports success, leaving a stray zero-byte file the
+ * model cannot recover from — the local analogue of the `xd://` near-miss guard
+ * ({@link assertWriteTargetAddressable}, issue #6123).
+ *
+ * Fires only on the high-confidence combination the report identifies: the tail
+ * parses as a read-tool selector, the literal target is missing, and no content
+ * was supplied. Non-empty content is the escape hatch — it is never blocked, so
+ * a deliberate write to a selector-shaped filename still succeeds. An existing
+ * literal path or an ambiguous stat (`"unknown"`: EACCES, transient I/O) also
+ * passes through so a real file is never shadowed by the guard.
+ */
+function readSelectorForEmptyWrite(target: string, content: string): string | undefined {
+	if (content.length > 0) return undefined;
+	return splitPathAndSel(target).sel;
+}
+
+function throwReadSelectorMisfire(target: string, sel: string): never {
+	throw new ToolError(
+		`write target '${target}' ends with a read-tool selector ':${sel}' and no such file exists — refusing to create a literal file by that name. ` +
+			`If you meant to read it, use read({ path: "${target}" }). ` +
+			`If you truly intend to create this file, pass its contents in \`content\` (a non-empty write is never blocked).`,
+	);
+}
+
+async function assertNotReadSelectorMisfire(target: string, content: string, cwd: string): Promise<void> {
+	const sel = readSelectorForEmptyWrite(target, content);
+	if (sel === undefined) return;
+	if ((await probeLiteralPathExists(target, cwd)) !== "missing") return;
+	throwReadSelectorMisfire(target, sel);
+}
+
 const BULK_DIRECTIVE_RE = /^#?(\d+)\s*[:=]\s*(@ours|@theirs|@base|@both)$/;
 /**
  * The head of a per-id directive line — `<id>:` / `<id>=` (optionally `#`-prefixed),
@@ -576,6 +620,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				throw new ToolError(error instanceof Error ? error.message : String(error));
 			}
 		}
+		const writeTarget = `${resolvedArchivePath.archivePath}:${resolvedArchivePath.archiveSubPath}`;
+		const sel = readSelectorForEmptyWrite(writeTarget, content);
+		if (sel !== undefined && !entries.has(resolvedArchivePath.archiveSubPath)) {
+			throwReadSelectorMisfire(writeTarget, sel);
+		}
 		entries.set(resolvedArchivePath.archiveSubPath, content);
 
 		try {
@@ -1159,6 +1208,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				return sqliteResult;
 			}
 
+			await assertNotReadSelectorMisfire(path, cleanContent, this.session.cwd);
 			enforcePlanModeWrite(this.session, path, { op: "create" });
 			const absolutePath = resolvePlanPath(this.session, path);
 			const batchRequest = getLspBatchRequest(context?.toolCall);

package/src/tools/xdev.ts

@@ -60,6 +60,9 @@ export const XDEV_KEEP_TOP_LEVEL: Record<string, true> = {
  */
 export const XDEV_TRANSPORT_TOOLS: Record<string, true> = { read: true, write: true };
 
+/** Controls which mounted-device docs are inlined into the system prompt. */
+export type XdevDocsMode = "inline" | "builtins" | "catalog";
+
 /**
  * Whether an enabled tool is presented under `xd://` (rather than top-level)
  * while the `xd://` transport is active. Discoverable tools mount unless they
@@ -170,6 +173,28 @@ function toolSummary(inst: Tool): string {
 	return firstLine?.trim() ?? inst.label ?? inst.name;
 }
 
+function promptCatalogSummary(inst: Tool, maxLength?: number): string {
+	const summary =
+		toolSummary(inst)
+			.split("\n")
+			.find(line => line.trim().length > 0)
+			?.trim() ?? inst.name;
+	if (maxLength === undefined || summary.length <= maxLength) return summary;
+	return `${summary.slice(0, maxLength).trimEnd()}…`;
+}
+
+/** Compile the `tools.xdevInlineDevices` allowlist once per render, dropping
+ *  non-string entries so malformed user config cannot break prompt builds. */
+function compileInlineGlobs(patterns: readonly string[]): Bun.Glob[] {
+	if (!Array.isArray(patterns)) return [];
+	const globs: Bun.Glob[] = [];
+	for (const pattern of patterns) {
+		if (typeof pattern !== "string" || pattern.length === 0) continue;
+		globs.push(new Bun.Glob(pattern));
+	}
+	return globs;
+}
+
 /** Decode the (possibly partially streamed) inner args JSON string into display args. */
 function decodeInnerArgs(raw: unknown): Record<string, unknown> {
 	if (typeof raw !== "string" || raw.length === 0) return {};
@@ -230,7 +255,13 @@ export class XdevRegistry {
 
 	/** `{name, summary}` pairs for prompt templates and /tools display. */
 	entries(): Array<{ name: string; summary: string }> {
-		return this.list().map(tool => ({ name: tool.name, summary: toolSummary(tool) }));
+		return this.list().map(tool => ({
+			name: tool.name,
+			summary: promptCatalogSummary(
+				tool,
+				this.#dynamic.has(tool.name) ? XdevRegistry.EXTERNAL_DESCRIPTION_CAP : undefined,
+			),
+		}));
 	}
 
 	/** `read xd://` listing with one device per line. */
@@ -273,11 +304,16 @@ export class XdevRegistry {
 	 * Dynamic mounts embed at most {@link EXTERNAL_DESCRIPTION_CAP} description
 	 * chars (schema always intact); `read xd://<tool>` returns the full text.
 	 */
-	docsAll(): string {
+	docsAll(mode: XdevDocsMode = "inline", inlinePatterns: readonly string[] = []): string {
 		const sections: string[] = [];
 		const overflow: Tool[] = [];
+		const inlineGlobs = compileInlineGlobs(inlinePatterns);
 		let used = 0;
 		for (const tool of this.list()) {
+			if (!this.#shouldInline(tool, mode, inlineGlobs)) {
+				overflow.push(tool);
+				continue;
+			}
 			const descriptionCap = this.#dynamic.has(tool.name) ? XdevRegistry.EXTERNAL_DESCRIPTION_CAP : undefined;
 			const docs = renderDocs(tool, "##", descriptionCap);
 			if (docs.length > XdevRegistry.DOCS_PER_DEVICE_CAP || used + docs.length > XdevRegistry.DOCS_TOTAL_BUDGET) {
@@ -291,7 +327,10 @@ export class XdevRegistry {
 			sections.push(
 				[
 					"## Additional devices (docs on demand)",
-					...overflow.map(tool => `- ${XD_URL_PREFIX}${tool.name} — ${toolSummary(tool)}`),
+					...overflow.map(tool => {
+						const maxLength = this.#dynamic.has(tool.name) ? XdevRegistry.EXTERNAL_DESCRIPTION_CAP : undefined;
+						return `- ${XD_URL_PREFIX}${tool.name} — ${promptCatalogSummary(tool, maxLength)}`;
+					}),
 					"",
 					`Read ${XD_URL_PREFIX}<tool> for full docs + JSON schema before first use.`,
 				].join("\n"),
@@ -300,6 +339,31 @@ export class XdevRegistry {
 		return sections.join("\n\n");
 	}
 
+	/** Docs for selected mounted devices under the configured prompt-doc policy. */
+	docsFor(names: Iterable<string>, mode: XdevDocsMode, inlinePatterns: readonly string[] = []): string {
+		const sections: string[] = [];
+		const inlineGlobs = compileInlineGlobs(inlinePatterns);
+		let used = 0;
+		for (const name of names) {
+			const tool = this.get(name);
+			if (!tool || !this.#shouldInline(tool, mode, inlineGlobs)) continue;
+			const descriptionCap = this.#dynamic.has(tool.name) ? XdevRegistry.EXTERNAL_DESCRIPTION_CAP : undefined;
+			const docs = renderDocs(tool, "##", descriptionCap);
+			if (docs.length > XdevRegistry.DOCS_PER_DEVICE_CAP || used + docs.length > XdevRegistry.DOCS_TOTAL_BUDGET)
+				continue;
+			used += docs.length;
+			sections.push(docs);
+		}
+		return sections.join("\n\n");
+	}
+
+	#shouldInline(tool: Tool, mode: XdevDocsMode, inlineGlobs: readonly Bun.Glob[]): boolean {
+		return (
+			mode !== "catalog" &&
+			(mode === "inline" || this.#builtins.has(tool.name) || inlineGlobs.some(glob => glob.match(tool.name)))
+		);
+	}
+
 	#resolve(name: string): Tool {
 		const inst = this.get(name);
 		if (!inst) {

package/src/tts/streaming-player.ts

@@ -31,6 +31,15 @@ const DEFAULT_SAMPLE_RATE = 24_000;
 const LEAD_SECONDS = 0.6;
 /** Output gain applied while ducked (the user is speaking over the assistant). */
 export const DUCK_GAIN = 0.25;
+/**
+ * Cap on streamed PCM retained for the nonzero-exit replay. Past this the
+ * buffer is dropped: the failure being recovered is a short clip that fits the
+ * OS pipe buffer before a broken backend dies, while a backend that consumed
+ * minutes of realtime-paced audio was playing it — replaying a whole long
+ * utterance would duplicate audio, and unbounded retention (~5.8 MB/min at
+ * 24 kHz mono f32) would defeat streaming for long input.
+ */
+const REPLAY_RETENTION_SECONDS = 60;
 
 /** Injection seam for {@link streamingPlayerCommandsFor} — defaults to real PATH/tools lookups. */
 export interface StreamingPlayerLookup {
@@ -89,6 +98,20 @@ export function streamingPlayerCommandsFor(
 	return commands;
 }
 
+/**
+ * Test seams for {@link StreamingAudioPlayer}: override backend discovery and
+ * the per-file fallback so playback logic can be exercised without a real audio
+ * device. Both default to the platform lookup and {@link playAudioFile}.
+ */
+export interface StreamingPlayerOptions {
+	/** Ordered backend commands for a sample rate; defaults to {@link streamingPlayerCommandsFor}. */
+	commandsFor?: (sampleRate: number) => PlayerCommand[];
+	/** Per-file fallback playback; defaults to {@link playAudioFile}. */
+	playAudio?: (wavPath: string, signal: AbortSignal) => Promise<void>;
+	/** Max seconds of streamed PCM retained for the nonzero-exit replay; defaults to {@link REPLAY_RETENTION_SECONDS}. */
+	replayRetentionSeconds?: number;
+}
+
 /**
  * Single-session gapless player. Lifecycle: {@link start} once, {@link write}
  * chunks in order, then {@link end} to drain or {@link stop} to abort. Not
@@ -111,6 +134,18 @@ export class StreamingAudioPlayer {
 	#abortController = new AbortController();
 	#wake: (() => void) | null = null;
 	#drain: Promise<void> = Promise.resolve();
+	readonly #commandsFor: (sampleRate: number) => PlayerCommand[];
+	readonly #playAudio: (wavPath: string, signal: AbortSignal) => Promise<void>;
+	readonly #replayRetentionSec: number;
+	/** Streamed PCM retained for this utterance so a failed backend can be replayed via file playback. */
+	#played: Float32Array[] = [];
+	#playedSec = 0;
+
+	constructor(options: StreamingPlayerOptions = {}) {
+		this.#commandsFor = options.commandsFor ?? (rate => streamingPlayerCommandsFor(process.platform, rate));
+		this.#playAudio = options.playAudio ?? ((wavPath, signal) => playAudioFile(wavPath, { signal }));
+		this.#replayRetentionSec = options.replayRetentionSeconds ?? REPLAY_RETENTION_SECONDS;
+	}
 
 	/** Pick a backend and begin draining. Idempotent; the first call's rate wins. */
 	start(sampleRate: number): void {
@@ -146,6 +181,7 @@ export class StreamingAudioPlayer {
 		if (this.#stopped) return;
 		this.#stopped = true;
 		this.#queue.length = 0;
+		this.#played.length = 0;
 		this.#abortController.abort();
 		this.#signal();
 		try {
@@ -168,7 +204,7 @@ export class StreamingAudioPlayer {
 	 * in-flight chunk.
 	 */
 	#spawnStream(): boolean {
-		this.#candidates ??= streamingPlayerCommandsFor(process.platform, this.#sampleRate);
+		this.#candidates ??= this.#commandsFor(this.#sampleRate);
 		for (let command = this.#candidates.shift(); command; command = this.#candidates.shift()) {
 			const { cmd, args } = command;
 			try {
@@ -213,6 +249,12 @@ export class StreamingAudioPlayer {
 					continue;
 				}
 				if (this.#mode === "stream") {
+					if (this.#playedSec <= this.#replayRetentionSec) {
+						this.#played.push(chunk);
+						this.#playedSec += chunk.length / this.#sampleRate;
+						// Over the cap: drop retention for the rest of the utterance.
+						if (this.#playedSec > this.#replayRetentionSec) this.#played.length = 0;
+					}
 					// 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;
@@ -242,11 +284,27 @@ export class StreamingAudioPlayer {
 				try {
 					await this.#sink?.end();
 				} catch {}
-				if (this.#proc) {
+				const proc = this.#proc;
+				let exitCode: number | null = null;
+				if (proc) {
 					try {
-						await this.#proc.exited;
+						exitCode = await proc.exited;
 					} catch {}
 				}
+				// A streaming backend that exits nonzero never opened its audio
+				// device (e.g. the bundled ffmpeg built without pulse/alsa output).
+				// For a short single-segment clip the pipe write succeeds before
+				// that death and #inputClosed is already set, so neither the
+				// broken-pipe replay nor the early-exit handler advances backends.
+				// Replay the buffered utterance through per-file playback so it
+				// still reaches the speakers.
+				if (!this.#stopped && proc && exitCode !== 0) {
+					this.#mode = "file";
+					for (const chunk of this.#played) {
+						if (this.#stopped) break;
+						await this.#playFile(chunk);
+					}
+				}
 			}
 		} catch (error) {
 			logger.debug("tts: streaming player drain failed", {
@@ -291,7 +349,7 @@ export class StreamingAudioPlayer {
 		const wavPath = path.join(os.tmpdir(), `omp-speech-${Snowflake.next()}.wav`);
 		try {
 			await fs.writeFile(wavPath, encodeWav(this.#scaled(pcm), this.#sampleRate));
-			if (!this.#stopped) await playAudioFile(wavPath, { signal: this.#abortController.signal });
+			if (!this.#stopped) await this.#playAudio(wavPath, this.#abortController.signal);
 		} catch (error) {
 			logger.debug("tts: file playback failed", {
 				error: error instanceof Error ? error.message : String(error),

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/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;

package/src/utils/lang-from-path.ts

@@ -102,6 +102,9 @@ const EXTENSION_LANG: Record<string, readonly [string, string]> = {
 	md: ["markdown", "markdown"],
 	markdown: ["markdown", "markdown"],
 	mdx: ["markdown", "markdown"],
+	mdc: ["markdown", "markdown"],
+	mkd: ["markdown", "markdown"],
+	mdown: ["markdown", "markdown"],
 	rst: ["restructuredtext", "restructuredtext"],
 	adoc: ["asciidoc", "asciidoc"],
 	tex: ["latex", "latex"],
@@ -217,6 +220,10 @@ export function getLanguageFromPath(filePath: string): string | undefined {
 	return undefined;
 }
 
+export function isMarkdownPath(filePath: string): boolean {
+	return getLanguageFromPath(filePath) === "markdown";
+}
+
 /**
  * LSP language identifier; falls back to `plaintext`.
  */