xtrm-cli 0.5.0 → 0.5.27

package/test/extensions/beads-parity.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import beadsExtension from "../../../config/pi/extensions/beads/index";
+import { SubprocessRunner } from "../../../config/pi/extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+	isToolCallEventType: (name: string, event: any) => event?.toolName === name,
+	isBashToolResult: (event: any) => event?.toolName === "bash",
+}));
+
+vi.mock("../../../config/pi/extensions/core/lib", async () => {
+	const actual = await vi.importActual<any>("../../../config/pi/extensions/core/lib");
+	return {
+		...actual,
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isBeadsProject: vi.fn(() => true),
+			isMutatingFileTool: vi.fn((event: any) => event?.toolName === "write"),
+			parseBdCounts: vi.fn(() => ({ open: 1, inProgress: 0 })),
+		},
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(() => false),
+	unlinkSync: vi.fn(),
+}));
+
+describe("Pi beads extension parity", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		harness.pi.sendUserMessage = vi.fn();
+	});
+
+	it("stores closed-this-session marker on successful bd close", async () => {
+		const calls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			calls.push(args);
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd close xtrm-777 --reason done" },
+			content: [{ type: "text", text: "closed" }],
+			isError: false,
+		});
+
+		expect(calls.some((a) => a[0] === "kv" && a[1] === "set" && a[2].startsWith("closed-this-session:"))).toBe(true);
+		expect(result?.content?.[1]?.text).toContain("Beads Insight");
+	});
+
+	it("fires memory gate once per closed marker and does not loop", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get" && `${args[2]}`.startsWith("closed-this-session:")) {
+				return { code: 0, stdout: "xtrm-123\n", stderr: "" };
+			}
+			return { code: 1, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		await harness.emit("agent_end", { messages: [] });
+		await harness.emit("agent_end", { messages: [] });
+
+		expect(harness.pi.sendUserMessage).toHaveBeenCalledTimes(1);
+		expect(harness.pi.sendUserMessage).toHaveBeenCalledWith(expect.stringContaining("claim `xtrm-123` was closed this session"));
+	});
+
+	it("consumes .memory-gate-done marker and clears session markers", async () => {
+		(fs.existsSync as any).mockReturnValue(true);
+		const calls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			calls.push(args);
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+		await harness.emit("agent_end", { messages: [] });
+
+		expect(fs.unlinkSync).toHaveBeenCalled();
+		expect(calls.some((a) => a[0] === "kv" && a[1] === "clear" && `${a[2]}`.startsWith("claimed:"))).toBe(true);
+		expect(calls.some((a) => a[0] === "kv" && a[1] === "clear" && `${a[2]}`.startsWith("closed-this-session:"))).toBe(true);
+		expect(harness.pi.sendUserMessage).not.toHaveBeenCalled();
+	});
+});

package/test/extensions/extension-harness.ts

@@ -71,14 +71,14 @@ export class ExtensionHarness {
 
 	async emit(event: string, data: any) {
 		if (this.handlers[event]) {
-            let lastResult: any = undefined;
+			let lastResult: any = undefined;
 			for (const handler of this.handlers[event]) {
-				console.log("EXECUTING HANDLER"); const res = await handler(data, this.ctx); console.log("HANDLER RESULT", res);
+				const res = await handler(data, this.ctx);
 				if (res !== undefined) {
-                    lastResult = res; console.log("EMIT FOUND RESULT", res);
-                }
+					lastResult = res;
+				}
 			}
-            return lastResult;
+			return lastResult;
 		}
 		return undefined;
 	}

package/test/extensions/quality-gates-parity.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import qualityGatesExtension from "../../../config/pi/extensions/quality-gates/index";
+import { SubprocessRunner } from "../../../config/pi/extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../../config/pi/extensions/core/lib", async () => {
+	const actual = await vi.importActual<any>("../../../config/pi/extensions/core/lib");
+	return {
+		...actual,
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event: any) => event.toolName === "write" || event.toolName === "edit"),
+			extractPathFromToolInput: vi.fn((event: any) => event.input.path),
+		},
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(() => true),
+}));
+
+describe("Pi quality-gates extension parity", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+	});
+
+	it("runs JS gate for .cjs files and reports stdout details", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 0,
+			stdout: "ESLint auto-fixed issues",
+			stderr: "",
+		});
+
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "hooks/sample.cjs" },
+			content: [{ type: "text", text: "ok" }],
+		});
+
+		expect(SubprocessRunner.run).toHaveBeenCalledWith(
+			"node",
+			expect.arrayContaining([expect.stringContaining("quality-check.cjs")]),
+			expect.any(Object),
+		);
+		expect(result?.content?.[1]?.text).toContain("ESLint auto-fixed issues");
+	});
+
+	it("fails tool result when hook exits with status 2", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 2,
+			stdout: "",
+			stderr: "Compilation failed: error TS1234",
+		});
+
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+			content: [{ type: "text", text: "Original content" }],
+		});
+
+		expect(result?.isError).toBe(true);
+		expect(result?.content?.[1]?.text).toContain("Compilation failed");
+		expect(harness.ctx.ui.notify).toHaveBeenCalledWith("Quality Gate failed for main.ts", "error");
+	});
+
+	it("no-ops when hook script is missing", async () => {
+		(fs.existsSync as any).mockReturnValue(false);
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+			content: [{ type: "text", text: "Original content" }],
+		});
+
+		expect(result).toBeUndefined();
+		expect(SubprocessRunner.run).not.toHaveBeenCalled();
+	});
+});

package/test/extensions/session-flow.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import sessionFlowExtension from "../../../config/pi/extensions/session-flow/index";
+import { SubprocessRunner } from "../../../config/pi/extensions/core/lib";
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+	isBashToolResult: (event: any) => event?.toolName === "bash",
+}));
+
+vi.mock("../../../config/pi/extensions/core/lib", async () => {
+	const actual = await vi.importActual<any>("../../../config/pi/extensions/core/lib");
+	return {
+		...actual,
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isBeadsProject: vi.fn(() => true),
+		},
+	};
+});
+
+describe("Pi session-flow extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		harness.pi.sendUserMessage = vi.fn();
+	});
+
+	it("adds claim-sync context on bd update --claim", async () => {
+		sessionFlowExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd update xtrm-123 --claim" },
+			content: [{ type: "text", text: "ok" }],
+		});
+
+		expect(result?.content?.[1]?.text).toContain("claimed xtrm-123");
+	});
+
+	it("does not trigger follow-up turns on agent_end (prevents stop-loop)", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") {
+				return { code: 0, stdout: "xtrm-123\n", stderr: "" };
+			}
+			if (args[0] === "show") {
+				return { code: 0, stdout: JSON.stringify({ id: "xtrm-123", status: "in_progress" }), stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		sessionFlowExtension(harness.pi);
+
+		await harness.emit("agent_end", { messages: [] });
+		await harness.emit("agent_end", { messages: [] });
+
+		expect(harness.pi.sendUserMessage).not.toHaveBeenCalled();
+		expect(harness.ctx.ui.notify).toHaveBeenCalledTimes(1);
+		expect(harness.ctx.ui.notify).toHaveBeenCalledWith(
+			expect.stringContaining("bd close xtrm-123"),
+			"warning",
+		);
+	});
+
+	it("reminds about xt end only once per worktree", async () => {
+		harness.ctx.cwd = "/repo/.xtrm/worktrees/demo";
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") {
+				return { code: 0, stdout: "xtrm-999\n", stderr: "" };
+			}
+			if (args[0] === "show") {
+				return { code: 0, stdout: JSON.stringify({ id: "xtrm-999", status: "closed" }), stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		sessionFlowExtension(harness.pi);
+
+		await harness.emit("agent_end", { messages: [] });
+		await harness.emit("agent_end", { messages: [] });
+
+		expect(harness.ctx.ui.notify).toHaveBeenCalledTimes(1);
+		expect(harness.ctx.ui.notify).toHaveBeenCalledWith(
+			"Run `xt end` to create a PR and clean up this worktree.",
+			"info",
+		);
+	});
+});

package/test/extensions/xtrm-loader.test.ts

@@ -1,12 +1,19 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { ExtensionHarness } from "./extension-harness";
-import xtrmLoaderExtension from "../../extensions/xtrm-loader";
+import xtrmLoaderExtension from "../../../config/pi/extensions/xtrm-loader/index";
 import * as fs from "node:fs";
 
+vi.mock("node:os", () => ({
+	homedir: () => "/home/test",
+}));
+
 vi.mock("node:fs", () => ({
 	existsSync: vi.fn(),
 	readFileSync: vi.fn(),
 	readdirSync: vi.fn(),
+	promises: {
+		readFile: vi.fn(),
+	},
 }));
 
 describe("XTRM Loader Extension", () => {
@@ -14,40 +21,51 @@ describe("XTRM Loader Extension", () => {
 
 	beforeEach(() => {
 		vi.resetAllMocks();
-		harness = new ExtensionHarness();
+		harness = new ExtensionHarness("/workspace/project");
+		(fs.readdirSync as any).mockReturnValue([]);
 	});
 
-	it("should load project roadmap and rules", async () => {
+	it("injects using-xtrm content into system prompt at before_agent_start", async () => {
 		(fs.existsSync as any).mockImplementation((p: string) => {
-			if (p.endsWith("ROADMAP.md")) return true;
-			if (p.endsWith(".claude/rules")) return true;
+			if (p === "/home/test/.agents/skills/using-xtrm/SKILL.md") return true;
+			if (p.endsWith("ROADMAP.md")) return false;
+			if (p.endsWith(".claude/rules")) return false;
 			if (p.endsWith(".claude/skills")) return false;
 			return false;
 		});
 
 		(fs.readFileSync as any).mockImplementation((p: string) => {
-			if (p.endsWith("ROADMAP.md")) return "My Roadmap Content";
-			if (p.endsWith("rule1.md")) return "Rule 1 Content";
+			if (p === "/home/test/.agents/skills/using-xtrm/SKILL.md") {
+				return "---\nname: using-xtrm\n---\n# Manual\nUse bd prime";
+			}
 			return "";
 		});
 
-		(fs.readdirSync as any).mockImplementation((p: string) => {
-			if (p.endsWith(".claude/rules")) return [{ name: "rule1.md", isFile: () => true, isDirectory: () => false }];
-			return [];
-		});
-
 		xtrmLoaderExtension(harness.pi);
-
-		// Trigger session_start to load data
 		await harness.emit("session_start", {});
+		const result = await harness.emit("before_agent_start", { systemPrompt: "Base prompt" });
+
+		expect(result?.systemPrompt).toContain("XTRM Session Operating Manual");
+		expect(result?.systemPrompt).toContain("Use bd prime");
+		expect(result?.systemPrompt).not.toContain("name: using-xtrm");
+	});
 
-		// Trigger before_agent_start to see injection
-		const result = await harness.emit("before_agent_start", {
-			systemPrompt: "Base prompt"
+	it("falls back to ~/.pi/agent/skills when ~/.agents path is missing", async () => {
+		(fs.existsSync as any).mockImplementation((p: string) => {
+			if (p === "/home/test/.agents/skills/using-xtrm/SKILL.md") return false;
+			if (p === "/home/test/.pi/agent/skills/using-xtrm/SKILL.md") return true;
+			if (p.endsWith("ROADMAP.md")) return false;
+			if (p.endsWith(".claude/rules")) return false;
+			if (p.endsWith(".claude/skills")) return false;
+			return false;
 		});
 
-		expect(result.systemPrompt).toContain("My Roadmap Content");
-		expect(result.systemPrompt).toContain("Rule 1 Content");
-		expect(harness.ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("context and skills indexed"), "info");
+		(fs.readFileSync as any).mockReturnValue("# Manual\nPi fallback path");
+
+		xtrmLoaderExtension(harness.pi);
+		await harness.emit("session_start", {});
+		const result = await harness.emit("before_agent_start", { systemPrompt: "Base" });
+
+		expect(result?.systemPrompt).toContain("Pi fallback path");
 	});
 });

package/test/install-pi.test.ts

@@ -107,12 +107,15 @@ describe('createInstallPiCommand', () => {
         expect(keys).toContain('qwen-cli');
     });
 
-    it('extensions directory contains all expected .ts files', () => {
+    it('extensions directory contains expected extension package directories', () => {
         const fs = require('node:fs');
         const p = require('node:path');
         const extDir = p.resolve(__dirname, '..', '..', 'config', 'pi', 'extensions');
-        const files = ['auto-session-name.ts','auto-update.ts','bg-process.ts','compact-header.ts','custom-footer.ts','git-checkpoint.ts','todo.ts'];
-        for (const f of files) expect(fs.existsSync(p.join(extDir, f))).toBe(true);
+        const packages = ['auto-session-name', 'auto-update', 'compact-header', 'custom-footer', 'git-checkpoint', 'quality-gates', 'beads', 'session-flow', 'service-skills', 'xtrm-loader', 'plan-mode'];
+        for (const pkg of packages) {
+            expect(fs.existsSync(p.join(extDir, pkg, 'index.ts'))).toBe(true);
+            expect(fs.existsSync(p.join(extDir, pkg, 'package.json'))).toBe(true);
+        }
     });
 
     it('custom-provider-qwen-cli extension has index.ts and package.json', () => {
@@ -155,7 +158,7 @@ describe('createInstallPiCommand', () => {
         expect(result['DASHSCOPE_API_KEY']).toBe('sk-from-models-789');
     });
 
-    it('diffPiExtensions reports missing and stale files', async () => {
+    it('diffPiExtensions reports missing and stale extension packages', async () => {
         const { diffPiExtensions } = await import('../src/commands/install-pi.js?t=diff' + Date.now());
         const nodeFs = require('node:fs');
         const nodePath = require('node:path');
@@ -164,17 +167,25 @@ describe('createInstallPiCommand', () => {
         const srcDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-ext-src-'));
         const dstDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-ext-dst-'));
 
-        nodeFs.writeFileSync(nodePath.join(srcDir, 'a.ts'), 'export const a = 1;');
-        nodeFs.writeFileSync(nodePath.join(srcDir, 'b.ts'), 'export const b = 1;');
-        nodeFs.writeFileSync(nodePath.join(dstDir, 'a.ts'), 'export const a = 2;');
+        nodeFs.mkdirSync(nodePath.join(srcDir, 'a'));
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'a', 'package.json'), JSON.stringify({ name: 'a' }));
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'a', 'index.ts'), 'export const a = 1;');
+
+        nodeFs.mkdirSync(nodePath.join(srcDir, 'b'));
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'b', 'package.json'), JSON.stringify({ name: 'b' }));
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'b', 'index.ts'), 'export const b = 1;');
+
+        nodeFs.mkdirSync(nodePath.join(dstDir, 'a'));
+        nodeFs.writeFileSync(nodePath.join(dstDir, 'a', 'package.json'), JSON.stringify({ name: 'a' }));
+        nodeFs.writeFileSync(nodePath.join(dstDir, 'a', 'index.ts'), 'export const a = 2;');
 
         const diff = await diffPiExtensions(srcDir, dstDir);
 
-        expect(diff.missing).toContain('b.ts');
-        expect(diff.stale).toContain('a.ts');
+        expect(diff.missing).toContain('b');
+        expect(diff.stale).toContain('a');
 
-        nodeFs.rmSync(srcDir, { recursive: true });
-        nodeFs.rmSync(dstDir, { recursive: true });
+        nodeFs.rmSync(srcDir, { recursive: true, force: true });
+        nodeFs.rmSync(dstDir, { recursive: true, force: true });
     });
 
     it('createInstallPiCommand supports --check flag', () => {

package/test/pi-extensions.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { syncManagedPiExtensions } from '../src/utils/pi-extensions.js';
+
+describe('syncManagedPiExtensions', () => {
+    it('copies extension packages and reports package count', async () => {
+        const srcRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-ext-src-'));
+        const dstRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-ext-dst-'));
+
+        fs.mkdirSync(path.join(srcRoot, 'plan-mode'));
+        fs.writeFileSync(path.join(srcRoot, 'plan-mode', 'package.json'), '{}');
+        fs.writeFileSync(path.join(srcRoot, 'plan-mode', 'index.ts'), 'export default {};');
+        fs.mkdirSync(path.join(srcRoot, 'beads'));
+        fs.writeFileSync(path.join(srcRoot, 'beads', 'package.json'), '{}');
+
+        const count = await syncManagedPiExtensions({
+            sourceDir: srcRoot,
+            targetDir: dstRoot,
+        });
+
+        expect(count).toBe(2);
+        expect(fs.existsSync(path.join(dstRoot, 'plan-mode', 'index.ts'))).toBe(true);
+
+        fs.rmSync(srcRoot, { recursive: true, force: true });
+        fs.rmSync(dstRoot, { recursive: true, force: true });
+    });
+
+    it('supports dry-run without writing files', async () => {
+        const srcRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-ext-src-'));
+        const dstRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-ext-dst-'));
+        fs.mkdirSync(path.join(srcRoot, 'quality-gates'));
+
+        const logs: string[] = [];
+        const count = await syncManagedPiExtensions({
+            sourceDir: srcRoot,
+            targetDir: dstRoot,
+            dryRun: true,
+            log: (message) => logs.push(message),
+        });
+
+        expect(count).toBe(1);
+        expect(fs.existsSync(path.join(dstRoot, 'quality-gates'))).toBe(false);
+        expect(logs.some((message) => message.includes('[DRY RUN]'))).toBe(true);
+
+        fs.rmSync(srcRoot, { recursive: true, force: true });
+        fs.rmSync(dstRoot, { recursive: true, force: true });
+    });
+});

package/test/session-launcher.test.ts

@@ -82,58 +82,48 @@ describe('session launcher CLI surface (2q8j)', () => {
 
 describe('worktree creation naming convention (2q8j)', () => {
 
-    it('creates worktree with xt/<name> branch when name is provided', () => {
-        const today = new Date();
-        const dateStr = `${today.getFullYear()}${String(today.getMonth() + 1).padStart(2, '0')}${String(today.getDate()).padStart(2, '0')}`;
-        const expectedName = `myproject-xt-claude-${dateStr}`;
-        const expectedPath = path.join(siblingBase, expectedName);
+    it('creates worktree inside repo under .xtrm/worktrees/ with xt/<name> branch', () => {
+        // Worktree lands at <repoDir>/.xtrm/worktrees/myproject-xt-claude-mysession
+        const expectedPath = path.join(repoDir, '.xtrm', 'worktrees', 'myproject-xt-claude-mysession');
 
-        // Pre-clean any stale worktree from previous runs
         if (fs.existsSync(expectedPath)) {
             removeWorktree(expectedPath, repoDir);
         }
 
-        run(['claude', 'mysession'], {
-            cwd: repoDir,
-            env: { PATH: '/usr/bin:/bin' },
-        });
+        run(['claude', 'mysession'], { cwd: repoDir, env: { PATH: '/usr/bin:/bin' } });
 
-        if (fs.existsSync(expectedPath)) {
-            const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd: expectedPath, encoding: 'utf8', stdio: 'pipe',
-            });
-            expect(branchResult.stdout.trim()).toBe('xt/mysession');
+        expect(fs.existsSync(expectedPath)).toBe(true);
 
-            // Verify it's a sibling of repoDir, not nested inside it
-            // Use repoDir + sep to avoid "myproject-xt-..." startsWith "myproject"
-            expect(expectedPath.startsWith(repoDir + path.sep)).toBe(false);
-            expect(path.dirname(expectedPath)).toBe(siblingBase);
+        const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: expectedPath, encoding: 'utf8', stdio: 'pipe',
+        });
+        expect(branchResult.stdout.trim()).toBe('xt/mysession');
 
-            removeWorktree(expectedPath, repoDir);
-        }
+        // Worktree is nested inside repoDir, not a sibling
+        expect(expectedPath.startsWith(repoDir + path.sep)).toBe(true);
+
+        removeWorktree(expectedPath, repoDir);
     });
 
     it('creates worktree with random xt/<slug> branch when no name provided', () => {
-        const today = new Date();
-        const dateStr = `${today.getFullYear()}${String(today.getMonth() + 1).padStart(2, '0')}${String(today.getDate()).padStart(2, '0')}`;
-        const expectedName = `myproject-xt-pi-${dateStr}`;
-        const expectedPath = path.join(siblingBase, expectedName);
+        // Worktree lands at <repoDir>/.xtrm/worktrees/myproject-xt-pi-<slug>
+        const worktreesDir = path.join(repoDir, '.xtrm', 'worktrees');
 
-        if (fs.existsSync(expectedPath)) {
-            removeWorktree(expectedPath, repoDir);
-        }
+        run(['pi'], { cwd: repoDir, env: { PATH: '/usr/bin:/bin' } });
 
-        run(['pi'], {
-            cwd: repoDir,
-            env: { PATH: '/usr/bin:/bin' },
+        // Find the created worktree (slug is random, so glob the dir)
+        const entries = fs.existsSync(worktreesDir)
+            ? fs.readdirSync(worktreesDir).filter(e => e.startsWith('myproject-xt-pi-'))
+            : [];
+
+        expect(entries.length).toBeGreaterThan(0);
+
+        const wtPath = path.join(worktreesDir, entries[0]!);
+        const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: wtPath, encoding: 'utf8', stdio: 'pipe',
         });
+        expect(branchResult.stdout.trim()).toMatch(/^xt\/[a-z0-9]{4}$/);
 
-        if (fs.existsSync(expectedPath)) {
-            const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd: expectedPath, encoding: 'utf8', stdio: 'pipe',
-            });
-            expect(branchResult.stdout.trim()).toMatch(/^xt\/[a-z0-9]{4}$/);
-            removeWorktree(expectedPath, repoDir);
-        }
+        removeWorktree(wtPath, repoDir);
     });
 });