@oh-my-pi/pi-coding-agent 15.2.2 → 15.2.4

package/src/prompts/tools/hashline.md

@@ -1,58 +1,36 @@
 Your patch language is a compact, line-anchored edit format.
 
-A patch contains one or more file sections. The first non-blank line of every edit section MUST be `@@ PATH`.
+A patch contains one or more file sections. The first non-blank line of every edit section MUST be `§PATH`.
 Operations reference lines in the file by their line number and hash, called "Anchors", e.g. `5th`, `123ab`.
 You MUST copy them verbatim from the latest output for the file you're editing.
 
 Purely textual format. The tool has NO awareness of language, indentation, brackets, fences, or table widths. You MUST emit valid syntax in replacements/insertions.
 
 <ops>
-@@ PATH          header: subsequent ops apply to PATH
+§PATH           header: subsequent ops apply to PATH
 Each op line is ONE of:
-+ ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows as `{{hsep}}TEXT` lines
-< ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `{{hsep}}TEXT` lines
-- A..B           delete the line range (inclusive).
-= A..B           replace the range with payload `{{hsep}}TEXT` lines, or with one blank line if no payload follows.
+»ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows on subsequent lines
+«ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows on subsequent lines
+≔A..B           replace the inclusive range A..B with payload; delete the range if no payload follows
+≔A              shorthand for ≔A..A
 </ops>
 
-<format-reminder>
-Op lines carry no content — payload goes on the next line.
-
-WRONG: + 5pg| some code
-WRONG: {{hsep}} some code
-RIGHT: + 5pg
-{{hsep}}some code
-
-A single `+`/`<`/`=` op accepts MANY `{{hsep}}` payload lines. To insert N consecutive lines, write ONE op followed by N payload lines — NEVER N ops with one payload each.
-
-WRONG (one op per inserted line, with fabricated anchors):
-  + 5pg
-  {{hsep}}first new line
-  + 6xx    ← FABRICATED
-  {{hsep}}second new line
-
-RIGHT (one op, many payload lines):
-  + 5pg
-  {{hsep}}first new line
-  {{hsep}}second new line
-</format-reminder>
-
 <rules>
-- Every payload line MUST start with `{{hsep}}` immediately followed by payload text. Do NOT add a readability space after `{{hsep}}`.
-- Every character after `{{hsep}}` is file content. If the target line intentionally starts with one space, write exactly one space after `{{hsep}}`; otherwise write none.
 - Payload text is verbatim — NEVER escape unicode.
+- Payload ends at the next `»`, `«`, `≔`, `§`, envelope marker, or EOF.
+- `≔A..B` with no payload deletes the range. To keep a blank line, include one explicit empty payload line.
 - **Payload is only what's NEW relative to your range:**
-  - `=` replaces inside; NEVER include lines outside.
-  - `+`/`<` adds at the anchor; NEVER repeat line A or neighbors.
+  - `≔` replaces inside; NEVER include lines outside.
+  - `»`/`«` adds at the anchor; NEVER repeat line A or neighbors.
   - Payload matching nearby content duplicates — drop it or widen.
 - **Pick a self-contained unit first.** Touching a multiline construct? Widen to the whole thing.
-- Then smallest op: add → `+`/`<`; delete → `-`; `=` ONLY when modifying inside.
+- Then smallest op: add → `»`/`«`; delete/replace → `≔`.
 </rules>
 
 <brace-shapes>
 When braces bound your edit, you SHOULD prefer these shapes:
 - **Whole block**: range spans `{` through matching `}`.
-- **Signature only**: one-line `=` on the opener; body untouched.
+- **Signature only**: one-line `≔` on the opener; body untouched.
 - **Insert inside**: anchor on `{` or last interior line; NEVER repeat the braces.
 - **End on `}`**: only when that `}` is part of the change. Otherwise extend or stop earlier.
 </brace-shapes>
@@ -61,9 +39,9 @@ When braces bound your edit, you SHOULD prefer these shapes:
 - **NEVER replay past your range.** Stop before B+1; extend B if it must go.
 - **NEVER duplicate chunks inside one payload.** Caught re-emitting? Rewrite.
 - **Anchor only inside the visible region.** B+1 truncated? Re-`read` first.
-- **You SHOULD prefer the narrowest self-contained edit.** Small `+`/`-` beats wide `=`.
+- **You SHOULD prefer the narrowest self-contained edit.** Narrow range beats wide range.
 - **Anchors reference the file as last read.** NEVER shift for prior ops.
-- **One `+`/`<` op per block, NOT per line.** N lines = ONE op, N payloads. Collapse adjacent ops.
+- **One `»`/`«` op per block, NOT per line.** N lines = ONE op, N payloads. Collapse adjacent ops.
 - **NEVER fabricate anchor hashes.** Missing? Re-`read`.
 </common-failures>
 
@@ -79,71 +57,74 @@ When braces bound your edit, you SHOULD prefer these shapes:
 
 <examples>
 # Replace one line (the payload must re-emit the original indentation)
-@@ mod.ts
-= {{hrefr 1}}..{{hrefr 1}}
-{{hsep}}const TITLE = "Mrs";
+§mod.ts
+≔{{hrefr 1}}
+const TITLE = "Mrs";
 
 # Replace a full multiline statement (widen to a self-contained boundary)
-@@ mod.ts
-= {{hrefr 3}}..{{hrefr 6}}
-{{hsep}}	return [
-{{hsep}}		"Mrs",
-{{hsep}}		name?.trim() || "guest",
-{{hsep}}	].join(" ");
+§mod.ts
+≔{{hrefr 3}}..{{hrefr 6}}
+	return [
+		"Mrs",
+		name?.trim() || "guest",
+	].join(" ");
 
 # Insert AFTER/BEFORE a line
-@@ mod.ts
-+ {{hrefr 4}}
-{{hsep}}		"Dr",
-< {{hrefr 5}}
-{{hsep}}		"Dr",
+§mod.ts
+»{{hrefr 4}}
+		"Dr",
+«{{hrefr 5}}
+		"Dr",
 
 # Append to file
-@@ mod.ts
-+ EOF
-{{hsep}}export const done = true;
+§mod.ts
+»EOF
+export const done = true;
 
 # Delete a line
-@@ mod.ts
-- {{hrefr 5}}..{{hrefr 5}}
+§mod.ts
+≔{{hrefr 5}}
+
+# Blank a line (replace with LF: the empty payload is the blank line before `»EOF`)
+§mod.ts
+≔{{hrefr 5}}
 
-# Blank a line (replace with LF)
-@@ mod.ts
-= {{hrefr 5}}..{{hrefr 5}}
+»EOF
+export const done = true;
 </examples>
 
 <anti-pattern>
 # WRONG — replaces 2 lines just to add one.
-@@ mod.ts
-= {{hrefr 1}}..{{hrefr 2}}
-{{hsep}}const TITLE = "Mr";
-{{hsep}}const DEBUG = false;
-{{hsep}}export function greet(name) {
+§mod.ts
+≔{{hrefr 1}}..{{hrefr 2}}
+const TITLE = "Mr";
+const DEBUG = false;
+export function greet(name) {
 # RIGHT — same effect, one-line insert
-@@ mod.ts
-+ {{hrefr 1}}
-{{hsep}}const DEBUG = false;
+§mod.ts
+»{{hrefr 1}}
+const DEBUG = false;
 
 # WRONG — replace from the middle of a larger statement (error-prone)
-@@ mod.ts
-= {{hrefr 4}}..{{hrefr 5}}
-{{hsep}}		"Dr",
-{{hsep}}		name?.trim() || "guest",
+§mod.ts
+≔{{hrefr 4}}..{{hrefr 5}}
+		"Dr",
+		name?.trim() || "guest",
 # RIGHT — widen to the full statement
-@@ mod.ts
-= {{hrefr 3}}..{{hrefr 6}}
-{{hsep}}	return [
-{{hsep}}		"Dr",
-{{hsep}}		name?.trim() || "guest",
-{{hsep}}	].join(" ");
+§mod.ts
+≔{{hrefr 3}}..{{hrefr 6}}
+	return [
+		"Dr",
+		name?.trim() || "guest",
+	].join(" ");
 </anti-pattern>
 
 <critical>
 - Copy anchors verbatim (line number + 2-char hash); NEVER include the `|TEXT` body.
-- Every payload line MUST start with `{{hsep}}`; raw content is invalid.
-- NEVER write unified diff syntax. Header is `@@ PATH`; ops are `<`/`+`/`-`/`=`.
-- `= A..B` deletes the range; payload is what's written. Edge line matches just outside? Widen, or it duplicates.
-- Multiple ops are cheap. SHOULD prefer two narrow ops over one wide `=`.
-  - Before `= A..B`, mentally delete A..B. Splits an unclosed bracket/brace/string from above, or orphans a closer inside? You're bisecting a construct.
+- NEVER write unified diff syntax. Headers are `§PATH`; ops are `»`/`«`/`≔`.
+- `≔A..B` deletes the range when no payload follows. To keep a blank line, include one explicit empty payload line.
+- `≔A..B` with payload writes exactly that payload. Edge line matches just outside? Widen, or it duplicates.
+- Multiple ops are cheap. SHOULD prefer two narrow ops over one wide `≔`.
+  - Before `≔A..B`, mentally delete A..B. Splits an unclosed bracket/brace/string from above, or orphans a closer inside? You're bisecting a construct.
 - NEVER use this tool to reformat code (indentation, whitespace, line wrapping, style). Run the project's formatter instead.
 </critical>

package/src/sdk.ts

@@ -31,7 +31,7 @@ import {
 	Snowflake,
 } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import { AsyncJobManager, isBackgroundJobSupportEnabled } from "./async";
+import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "./async";
 import { createAutoresearchExtension } from "./autoresearch";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability, setActiveRules } from "./capability/rule";
@@ -101,7 +101,7 @@ import {
 import { AgentSession } from "./session/agent-session";
 import { resolveAuthBrokerConfig } from "./session/auth-broker-config";
 import { AuthBrokerClient, AuthStorage, RemoteAuthCredentialStore } from "./session/auth-storage";
-import { convertToLlm } from "./session/messages";
+import { type CustomMessage, convertToLlm } from "./session/messages";
 import { SessionManager } from "./session/session-manager";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
@@ -152,6 +152,83 @@ import { EventBus } from "./utils/event-bus";
 import { buildNamedToolChoice } from "./utils/tool-choice";
 import { buildWorkspaceTree, type WorkspaceTree } from "./workspace-tree";
 
+type AsyncResultEntry = {
+	jobId: string;
+	result: string;
+	job: AsyncJob | undefined;
+	durationMs: number | undefined;
+};
+
+type AsyncResultJobDetails = {
+	jobId: string;
+	type?: "bash" | "task";
+	label?: string;
+	durationMs?: number;
+};
+
+type AsyncResultDetails = {
+	jobs: AsyncResultJobDetails[];
+};
+
+type McpNotificationEntry = {
+	serverName: string;
+	uri: string;
+};
+
+function buildAsyncResultBatchMessage(entries: AsyncResultEntry[]): CustomMessage<AsyncResultDetails> | null {
+	if (entries.length === 0) return null;
+	const jobs = entries.map(entry => ({
+		jobId: entry.jobId,
+		result: entry.result,
+		type: entry.job?.type,
+		label: entry.job?.label,
+		durationMs: entry.durationMs,
+	}));
+	const details: AsyncResultDetails = {
+		jobs: jobs.map(job => ({
+			jobId: job.jobId,
+			type: job.type,
+			label: job.label,
+			durationMs: job.durationMs,
+		})),
+	};
+	return {
+		role: "custom",
+		customType: "async-result",
+		content: prompt.render(asyncResultTemplate, {
+			multiple: jobs.length > 1,
+			jobs,
+		}),
+		display: true,
+		attribution: "agent",
+		details,
+		timestamp: Date.now(),
+	};
+}
+
+function buildMcpNotificationBatchMessage(entries: McpNotificationEntry[]): AgentMessage | null {
+	const resources: McpNotificationEntry[] = [];
+	const seen = new Set<string>();
+	for (const entry of entries) {
+		const key = `${entry.serverName}\0${entry.uri}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		resources.push(entry);
+	}
+	if (resources.length === 0) return null;
+	const lines = [`[MCP notification] ${resources.length} resource(s) updated:`];
+	for (const resource of resources) {
+		lines.push(`- server="${resource.serverName}" uri=${resource.uri}`);
+	}
+	lines.push('Use read(path="mcp://<uri>") to inspect if relevant.');
+	return {
+		role: "user",
+		content: [{ type: "text", text: lines.join("\n") }],
+		attribution: "agent",
+		timestamp: Date.now(),
+	};
+}
+
 // Types
 export interface CreateAgentSessionOptions {
 	/** Working directory for project-local discovery. Default: getProjectDir() */
@@ -1035,23 +1112,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						const formattedResult = await formatAsyncResultForFollowUp(result);
 						if (asyncJobManager!.isDeliverySuppressed(jobId)) return;
 
-						const message = prompt.render(asyncResultTemplate, { jobId, result: formattedResult });
 						const durationMs = job ? Math.max(0, Date.now() - job.startTime) : undefined;
-						await session.sendCustomMessage(
-							{
-								customType: "async-result",
-								content: message,
-								display: true,
-								attribution: "agent",
-								details: {
-									jobId,
-									type: job?.type,
-									label: job?.label,
-									durationMs,
-								},
-							},
-							{ deliverAs: "followUp", triggerTurn: true },
-						);
+						session.yieldQueue.enqueue<AsyncResultEntry>("async-result", {
+							jobId,
+							result: formattedResult,
+							job,
+							durationMs,
+						});
 					},
 				})
 			: undefined;
@@ -1902,6 +1969,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			providerSessionId: options.providerSessionId,
 		});
 		hasSession = true;
+		if (asyncJobManager) {
+			session.yieldQueue.register<AsyncResultEntry>("async-result", {
+				isStale: entry => asyncJobManager.isDeliverySuppressed(entry.jobId),
+				build: buildAsyncResultBatchMessage,
+			});
+		}
+		session.yieldQueue.register<McpNotificationEntry>("mcp-notification", {
+			build: buildMcpNotificationBatchMessage,
+		});
 
 		// Attach the live session to the pre-registered ref so peers can route IRC
 		// messages here. Refresh sessionFile in case it was unavailable at pre-register
@@ -2036,9 +2112,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						notificationDebounceTimers.delete(key);
 						// Re-check: user may have disabled notifications during the debounce window
 						if (!settings.get("mcp.notifications")) return;
-						void session.followUp(
-							`[MCP notification] Server "${serverName}" reports resource \`${uri}\` was updated. Use read(path="mcp://${uri}") to inspect if relevant.`,
-						);
+						session.yieldQueue.enqueue<McpNotificationEntry>("mcp-notification", { serverName, uri });
 					}, debounceMs),
 				);
 			});

package/src/session/agent-session.ts

@@ -205,6 +205,7 @@ import type {
 } from "./session-manager";
 import { getLatestCompactionEntry } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
+import { YieldQueue } from "./yield-queue";
 
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent =
@@ -735,6 +736,7 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
+	readonly yieldQueue: YieldQueue;
 
 	#powerAssertion: MacOSPowerAssertion | undefined;
 
@@ -1031,6 +1033,24 @@ export class AgentSession {
 				};
 		this.agent.setProviderResponseInterceptor(this.#onResponse);
 		this.agent.setRawSseEventInterceptor(this.#onSseEvent);
+		this.yieldQueue = new YieldQueue({
+			isStreaming: () => this.isStreaming,
+			injectStreaming: message => this.agent.followUp(message),
+			injectIdle: async messages => {
+				const first = messages[0];
+				if (!first) return;
+				await this.agent.prompt(messages.length === 1 ? first : messages);
+			},
+			scheduleIdleFlush: run => {
+				this.#schedulePostPromptTask(
+					async () => {
+						await run();
+					},
+					{ delayMs: 1 },
+				);
+			},
+		});
+		this.agent.setOnBeforeYield(() => this.yieldQueue.flush("streaming"));
 		this.#convertToLlm = config.convertToLlm ?? convertToLlm;
 		this.#rebuildSystemPrompt = config.rebuildSystemPrompt;
 		this.#getMcpServerInstructions = config.getMcpServerInstructions;
@@ -2720,6 +2740,8 @@ export class AgentSession {
 	async dispose(): Promise<void> {
 		this.#isDisposed = true;
 		this.#pendingBackgroundExchanges = [];
+		this.yieldQueue.clear();
+		this.agent.setOnBeforeYield(undefined);
 		this.#evalExecutionDisposing = true;
 		try {
 			if (this.#extensionRunner?.hasHandlers("session_shutdown")) {

package/src/session/yield-queue.ts

@@ -0,0 +1,155 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { logger } from "@oh-my-pi/pi-utils";
+
+export interface YieldDispatcher<P> {
+	/** Drop entries already delivered through another path. Called per-entry at flush time. */
+	isStale?(entry: P): boolean;
+	/** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
+	build(survivors: P[]): AgentMessage | null;
+}
+
+export interface YieldQueueOptions {
+	isStreaming: () => boolean;
+	injectStreaming(msg: AgentMessage): void;
+	injectIdle(messages: AgentMessage[]): Promise<void>;
+	scheduleIdleFlush(run: () => Promise<void>): void;
+}
+
+type YieldFlushMode = "streaming" | "idle";
+
+interface StoredDispatcher {
+	isStale?: (entry: unknown) => boolean;
+	build: (survivors: unknown[]) => AgentMessage | null;
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export class YieldQueue {
+	readonly #options: YieldQueueOptions;
+	readonly #dispatchers = new Map<string, StoredDispatcher>();
+	readonly #entries = new Map<string, unknown[]>();
+	#idleFlushPending = false;
+
+	constructor(options: YieldQueueOptions) {
+		this.#options = options;
+	}
+
+	register<P>(kind: string, dispatcher: YieldDispatcher<P>): () => void {
+		const stored: StoredDispatcher = {
+			...(dispatcher.isStale ? { isStale: entry => dispatcher.isStale?.(entry as P) ?? false } : {}),
+			build: survivors => dispatcher.build(survivors as P[]),
+		};
+		this.#dispatchers.set(kind, stored);
+		return () => {
+			if (this.#dispatchers.get(kind) !== stored) return;
+			this.#dispatchers.delete(kind);
+			this.#entries.delete(kind);
+		};
+	}
+
+	enqueue<P>(kind: string, entry: P): void {
+		if (!this.#dispatchers.has(kind)) {
+			logger.warn("Yield queue entry ignored for unregistered kind", { kind });
+			return;
+		}
+		let entries = this.#entries.get(kind);
+		if (!entries) {
+			entries = [];
+			this.#entries.set(kind, entries);
+		}
+		entries.push(entry);
+		if (!this.#options.isStreaming()) {
+			this.#scheduleIdleFlush();
+		}
+	}
+
+	has(kind?: string): boolean {
+		if (kind !== undefined) return (this.#entries.get(kind)?.length ?? 0) > 0;
+		for (const entries of this.#entries.values()) {
+			if (entries.length > 0) return true;
+		}
+		return false;
+	}
+
+	async flush(mode: YieldFlushMode): Promise<void> {
+		if (mode === "idle") {
+			this.#idleFlushPending = false;
+		}
+		const idleMessages: AgentMessage[] = [];
+		for (const [kind, dispatcher] of this.#dispatchers) {
+			const entries = this.#drain(kind);
+			if (entries.length === 0) continue;
+			const message = this.#build(kind, dispatcher, entries);
+			if (!message) continue;
+			if (mode === "streaming") {
+				try {
+					this.#options.injectStreaming(message);
+				} catch (error) {
+					logger.warn("Yield queue streaming dispatch failed", { kind, error: formatError(error) });
+				}
+			} else {
+				idleMessages.push(message);
+			}
+		}
+		if (mode === "idle" && idleMessages.length > 0) {
+			try {
+				await this.#options.injectIdle(idleMessages);
+			} catch (error) {
+				logger.warn("Yield queue idle dispatch failed", { error: formatError(error) });
+			}
+		}
+	}
+
+	clear(): void {
+		this.#entries.clear();
+		this.#idleFlushPending = false;
+	}
+
+	#scheduleIdleFlush(): void {
+		if (this.#idleFlushPending) return;
+		this.#idleFlushPending = true;
+		try {
+			this.#options.scheduleIdleFlush(async () => {
+				this.#idleFlushPending = false;
+				if (this.#options.isStreaming()) return;
+				await this.flush("idle");
+			});
+		} catch (error) {
+			this.#idleFlushPending = false;
+			logger.warn("Yield queue idle flush scheduling failed", { error: formatError(error) });
+		}
+	}
+
+	#drain(kind: string): unknown[] {
+		const entries = this.#entries.get(kind);
+		if (!entries || entries.length === 0) return [];
+		this.#entries.delete(kind);
+		return entries;
+	}
+
+	#build(kind: string, dispatcher: StoredDispatcher, entries: unknown[]): AgentMessage | null {
+		const survivors: unknown[] = [];
+		for (const entry of entries) {
+			if (dispatcher.isStale) {
+				let stale: boolean;
+				try {
+					stale = dispatcher.isStale(entry);
+				} catch (error) {
+					logger.warn("Yield queue stale check failed", { kind, error: formatError(error) });
+					continue;
+				}
+				if (stale) continue;
+			}
+			survivors.push(entry);
+		}
+		if (survivors.length === 0) return null;
+		try {
+			return dispatcher.build(survivors);
+		} catch (error) {
+			logger.warn("Yield queue build failed", { kind, error: formatError(error) });
+			return null;
+		}
+	}
+}

package/src/slash-commands/helpers/format.ts

@@ -13,7 +13,7 @@ export function formatDuration(ms: number): string {
 	return `${days}d`;
 }
 
-type ProgressBarTheme = Pick<Theme, "bold" | "fg">;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
 
 const unstyledProgressBarTheme: ProgressBarTheme = {
 	fg(_color, text) {
@@ -22,6 +22,9 @@ const unstyledProgressBarTheme: ProgressBarTheme = {
 	bold(text) {
 		return text;
 	},
+	getFgAnsi() {
+		return "";
+	},
 };
 
 function resolveProgressBarTheme(uiTheme: ProgressBarTheme | undefined): ProgressBarTheme {

package/src/task/worktree.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as natives from "@oh-my-pi/pi-natives";
-import { getWorktreeDir, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { getWorktreeDir, hashPath, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import * as git from "../utils/git";
 
 const { IsoBackendKind } = natives;
@@ -26,10 +26,6 @@ export interface WorktreeBaseline {
 	nested: Array<{ relativePath: string; baseline: RepoBaseline }>;
 }
 
-export function getEncodedProjectName(cwd: string): string {
-	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-}
-
 export async function getRepoRoot(cwd: string): Promise<string> {
 	const repoRoot = await git.repo.root(cwd);
 	if (!repoRoot) {
@@ -316,8 +312,7 @@ export async function ensureIsolation(
 	preferred?: IsoBackendKind,
 ): Promise<IsolationHandle> {
 	const repoRoot = await getRepoRoot(baseCwd);
-	const encodedProject = getEncodedProjectName(repoRoot);
-	const baseDir = getWorktreeDir(encodedProject, id);
+	const baseDir = getWorktreeDir(`${id}-${hashPath(repoRoot)}`);
 	const mergedDir = path.join(baseDir, "merged");
 
 	const resolution = natives.isoResolve(preferred ?? null);