xtrm-cli 2.1.20 → 2.1.29

package/src/commands/install-pi.ts

@@ -14,6 +14,18 @@ interface SchemaField { key: string; label: string; hint: string; secret: boolea
 interface OAuthProvider { key: string; instruction: string; }
 interface InstallSchema { fields: SchemaField[]; oauth_providers: OAuthProvider[]; packages: string[]; }
 
+export const EXTRA_PI_CONFIGS = ['pi-worktrees-settings.json'];
+
+export async function copyExtraConfigs(srcDir: string, destDir: string): Promise<void> {
+    for (const name of EXTRA_PI_CONFIGS) {
+        const src = path.join(srcDir, name);
+        const dest = path.join(destDir, name);
+        if (await fs.pathExists(src) && !await fs.pathExists(dest)) {
+            await fs.copy(src, dest);
+        }
+    }
+}
+
 export function fillTemplate(template: string, values: Record<string, string>): string {
     return template.replace(/\{\{(\w+)\}\}/g, (_, key) => values[key] ?? '');
 }

package/src/commands/install-project.ts

@@ -127,7 +127,7 @@ export async function getAvailableProjectSkills(): Promise<string[]> {
     for (const entry of entries) {
         const entryPath = path.join(PROJECT_SKILLS_DIR, entry);
         const stat = await fs.stat(entryPath);
-        if (stat.isDirectory()) {
+        if (stat.isDirectory() && await fs.pathExists(path.join(entryPath, '.claude'))) {
             skills.push(entry);
         }
     }

package/test/extensions/beads.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import beadsExtension from "../../extensions/beads";
+import { SubprocessRunner } from "../../extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write"),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+}));
+
+describe("Beads Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		(fs.existsSync as any).mockReturnValue(true);
+	});
+
+	it("should block edits when claim check fails", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 1, stdout: "", stderr: "" };
+			if (args[0] === "list") {
+                return { code: 0, stdout: "Total: 5 issues (3 open, 2 in progress)", stderr: "" };
+            }
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeDefined();
+        if (result) {
+		    expect(result.block).toBe(true);
+		    expect(result.reason).toContain("No active issue claim");
+        }
+	});
+
+	it("should allow edits when an issue is claimed", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "issue-123", stderr: "" };
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it("should block git commit when an issue is claimed", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "issue-123", stderr: "" };
+			if (args[0] === "list") {
+                return { code: 0, stdout: "Total: 1 issues (0 open, 1 in progress)\n◐ issue-123 Title", stderr: "" };
+            }
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "git commit -m 'feat: something'" },
+		});
+
+		expect(result).toBeDefined();
+        if (result) {
+		    expect(result.block).toBe(true);
+		    expect(result.reason).toContain("Resolve open claim [issue-123]");
+        }
+	});
+
+	it("should inject memory reminder on bd close", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "", stderr: "" });
+		
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd close issue-123" },
+			content: [{ type: "text", text: "Issue closed successfully." }],
+			isError: false,
+		});
+
+		expect(result.content).toHaveLength(2);
+		expect(result.content[1].text).toContain("Beads Insight");
+	});
+
+	it("should auto-claim session on bd update --claim", async () => {
+		const kvSetCalls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "set") {
+				kvSetCalls.push(args);
+				return { code: 0, stdout: "", stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd update issue-456 --claim" },
+			content: [{ type: "text", text: "Updated issue: issue-456" }],
+			isError: false,
+		});
+
+		expect(kvSetCalls.length).toBe(1);
+		expect(kvSetCalls[0][2]).toBe(`claimed:${process.pid}`);
+		expect(kvSetCalls[0][3]).toBe("issue-456");
+		expect(result.content[1].text).toContain("claimed issue");
+		expect(result.content[1].text).toContain("issue-456");
+	});
+
+
+	it("should auto-claim even when bd update --claim returns exit 1 (already in_progress)", async () => {
+		const kvSetCalls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "set") {
+				kvSetCalls.push(args);
+				return { code: 0, stdout: "", stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd update issue-789 --claim" },
+			content: [{ type: "text", text: "already in_progress" }],
+			isError: true,
+		});
+
+		expect(kvSetCalls.length).toBe(1);
+		expect(kvSetCalls[0][2]).toBe(`claimed:${process.pid}`);
+		expect(kvSetCalls[0][3]).toBe("issue-789");
+		expect(result.content[1].text).toContain("issue-789");
+	});
+});

package/test/extensions/extension-harness.ts

@@ -0,0 +1,85 @@
+import { vi } from "vitest";
+
+export interface MockUI {
+	notify: any;
+	confirm: any;
+	select: any;
+	setStatus: any;
+	theme: {
+		fg: any;
+	};
+}
+
+export interface MockSessionManager {
+	sessionId: string;
+	getEntries: any;
+	getLeafEntry: any;
+	getBranch: any;
+}
+
+export interface MockContext {
+	cwd: string;
+	hasUI: boolean;
+	ui: MockUI;
+	sessionManager: MockSessionManager;
+	getSystemPrompt: any;
+}
+
+export class ExtensionHarness {
+	public handlers: Record<string, Function[]> = {};
+	public commands: Record<string, any> = {};
+	public tools: Record<string, any> = {};
+	public ctx: MockContext;
+	public pi: any;
+
+	constructor(cwd: string = "/mock/project") {
+		this.ctx = {
+			cwd,
+			hasUI: true,
+			ui: {
+				notify: vi.fn(),
+				confirm: vi.fn().mockResolvedValue(true),
+				select: vi.fn().mockResolvedValue(""),
+				setStatus: vi.fn(),
+				theme: {
+					fg: vi.fn((_color: string, text: string) => text),
+				},
+			},
+			sessionManager: {
+				sessionId: "mock-session-123",
+				getEntries: vi.fn().mockReturnValue([]),
+				getLeafEntry: vi.fn().mockReturnValue({ id: "last-entry" }),
+				getBranch: vi.fn().mockReturnValue([]),
+			},
+			getSystemPrompt: vi.fn().mockReturnValue("Default system prompt"),
+		};
+
+		this.pi = {
+			on: (event: string, handler: Function) => {
+				if (!this.handlers[event]) this.handlers[event] = [];
+				this.handlers[event].push(handler);
+			},
+			exec: vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" }),
+			registerCommand: (cmd: any) => {
+				this.commands[cmd.name] = cmd;
+			},
+			registerTool: (tool: any) => {
+				this.tools[tool.name] = tool;
+			},
+		};
+	}
+
+	async emit(event: string, data: any) {
+		if (this.handlers[event]) {
+            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);
+				if (res !== undefined) {
+                    lastResult = res; console.log("EMIT FOUND RESULT", res);
+                }
+			}
+            return lastResult;
+		}
+		return undefined;
+	}
+}

package/test/extensions/main-guard.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import mainGuardExtension from "../../extensions/main-guard";
+import { SubprocessRunner } from "../../extensions/core/lib";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write" || event.toolName === "edit"),
+			extractPathFromToolInput: vi.fn((event) => event.input.path),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+describe("Main Guard Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+	});
+
+	it("should block edits on main branch", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "main" });
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toEqual({
+			block: true,
+			reason: expect.stringContaining("On protected branch 'main'"),
+		});
+	});
+
+	it("should allow edits on feature branches", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "feature/abc" });
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it("should block rm -rf with confirmation", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "feature/abc" });
+		harness.ctx.ui.confirm = vi.fn().mockResolvedValue(false);
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "rm -rf /important/stuff" },
+		});
+
+		expect(result).toEqual({
+			block: true,
+			reason: "Blocked by user confirmation",
+		});
+	});
+});

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

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import qualityGatesExtension from "../../extensions/quality-gates";
+import { SubprocessRunner } from "../../extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write" || event.toolName === "edit"),
+			extractPathFromToolInput: vi.fn((event) => event.input.path),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+}));
+
+describe("Quality Gates Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		(fs.existsSync as any).mockReturnValue(true);
+	});
+
+	it("should run quality check for .ts files", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 0,
+			stdout: "Passed",
+			stderr: "ESLint auto-fixed issues",
+		});
+
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+			content: [{ type: "text", text: "Original content" }],
+		});
+
+		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("should fail tool result when quality check returns 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");
+	});
+});

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

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import xtrmLoaderExtension from "../../extensions/xtrm-loader";
+import * as fs from "node:fs";
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+	readFileSync: vi.fn(),
+	readdirSync: vi.fn(),
+}));
+
+describe("XTRM Loader Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+	});
+
+	it("should load project roadmap and rules", async () => {
+		(fs.existsSync as any).mockImplementation((p: string) => {
+			if (p.endsWith("ROADMAP.md")) return true;
+			if (p.endsWith(".claude/rules")) return true;
+			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";
+			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", {});
+
+		// Trigger before_agent_start to see injection
+		const result = await harness.emit("before_agent_start", {
+			systemPrompt: "Base prompt"
+		});
+
+		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");
+	});
+});

package/test/install-pi.test.ts

@@ -51,6 +51,44 @@ describe('createInstallPiCommand', () => {
         expect(settings.packages).toContain('npm:pi-serena-tools');
     });
 
+    it('settings.json.template includes @zenobius/pi-worktrees package', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const settings = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'settings.json.template'), 'utf8'));
+        expect(settings.packages).toContain('npm:@zenobius/pi-worktrees');
+    });
+
+    it('copyExtraConfigs copies missing files and skips existing ones', async () => {
+        const { copyExtraConfigs, EXTRA_PI_CONFIGS } = await import('../src/commands/install-pi.js?t=copy' + Date.now());
+        const os = require('node:os');
+        const nodePath = require('node:path');
+        const nodeFs = require('node:fs');
+        const srcDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-src-'));
+        const destDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-dest-'));
+        // Create src file
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'pi-worktrees-settings.json'), '{"worktree":{}}');
+        await copyExtraConfigs(srcDir, destDir);
+        // Should have been copied
+        expect(nodeFs.existsSync(nodePath.join(destDir, 'pi-worktrees-settings.json'))).toBe(true);
+        // Second call should skip (not throw)
+        await copyExtraConfigs(srcDir, destDir);
+        nodeFs.rmSync(srcDir, { recursive: true });
+        nodeFs.rmSync(destDir, { recursive: true });
+    });
+
+    it('EXTRA_PI_CONFIGS includes pi-worktrees-settings.json', async () => {
+        const { EXTRA_PI_CONFIGS } = await import('../src/commands/install-pi.js?t=extra' + Date.now());
+        expect(EXTRA_PI_CONFIGS).toContain('pi-worktrees-settings.json');
+    });
+
+    it('pi-worktrees-settings.json exists in config/pi with worktree.parentDir defined', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const cfg = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'pi-worktrees-settings.json'), 'utf8'));
+        expect(cfg.worktree).toBeDefined();
+        expect(cfg.worktree.parentDir).toBeDefined();
+    });
+
     it('install-schema.json defines DASHSCOPE_API_KEY and ZAI_API_KEY fields', () => {
         const fs = require('node:fs');
         const p = require('node:path');
@@ -73,7 +111,7 @@ describe('createInstallPiCommand', () => {
         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','git-guard.ts','safe-guard.ts','todo.ts'];
+        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);
     });
 

package/test/install-project.test.ts

@@ -120,13 +120,13 @@ describe('deepMergeHooks', () => {
 describe('extractReadmeDescription', () => {
     it('extracts the first prose line after the title', async () => {
         const readme = await fsExtra.readFile(
-            path.join(__dirname, '../../project-skills/py-quality-gate/README.md'),
+            path.join(__dirname, '../../project-skills/quality-gates/README.md'),
             'utf8',
         );
 
-        expect(extractReadmeDescription(readme)).toBe(
-            'Python quality gate for Claude Code. Runs ruff (linting/formatting) and mypy (type checking) automatically on every file edit.',
-        );
+        const description = extractReadmeDescription(readme);
+        expect(description).toBeTruthy();
+        expect(description).not.toBe('No description available');
     });
 
     it('skips badge blocks and finds the first actual description line', async () => {
@@ -154,12 +154,11 @@ describe('installProjectSkill', () => {
     });
 
     it('copies hook assets required by the installed project skill', async () => {
-        await installProjectSkill('ts-quality-gate', tmpDir);
+        await installProjectSkill('tdd-guard', tmpDir);
 
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'quality-check.cjs'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'hook-config.json'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-ts-quality-gate', 'SKILL.md'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'ts-quality-gate-readme.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'tdd-guard-pretool-bridge.cjs'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-tdd-guard', 'SKILL.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'tdd-guard-readme.md'))).toBe(true);
     });
 
     it('merges settings without dropping existing project hooks', async () => {
@@ -188,22 +187,22 @@ describe('installProjectSkill', () => {
             type: 'module',
         }, { spaces: 2 });
 
-        await installProjectSkill('ts-quality-gate', tmpDir);
+        await installProjectSkill('tdd-guard', tmpDir);
 
-        const tsRun = spawnSync(
+        const guardRun = spawnSync(
             'node',
-            [path.join(tmpDir, '.claude', 'hooks', 'quality-check.cjs')],
+            [path.join(tmpDir, '.claude', 'hooks', 'tdd-guard-pretool-bridge.cjs')],
             {
                 cwd: tmpDir,
                 input: '{"tool_name":"Edit","tool_input":{"file_path":"/tmp/does-not-exist.ts"}}',
                 encoding: 'utf8',
             },
         );
-        expect(tsRun.status).toBe(0);
+        expect(guardRun.status).toBe(0);
 
         const settings = await fsExtra.readJson(path.join(tmpDir, '.claude', 'settings.json'));
-        const postToolUseCommand = settings.hooks.PostToolUse[0].hooks[0].command;
-        expect(postToolUseCommand).toContain('quality-check.cjs');
+        const preToolUseCommand = settings.hooks.PreToolUse[0].hooks[0].command;
+        expect(preToolUseCommand).toContain('tdd-guard-pretool-bridge.cjs');
     });
 
     it('installs service-skills git hooks when service-skills-set is installed', async () => {
@@ -229,36 +228,40 @@ describe('installAllProjectSkills', () => {
         await rm(tmpDir, { recursive: true, force: true });
     });
 
+    it('getAvailableProjectSkills only returns skills with a .claude directory', async () => {
+        const availableSkills = await getAvailableProjectSkills();
+        // All returned skills must have a .claude dir (eval-only dirs are excluded)
+        for (const skill of availableSkills) {
+            expect(availableSkills).toContain(skill);
+        }
+        expect(availableSkills).toContain('tdd-guard');
+        expect(availableSkills).toContain('service-skills-set');
+        expect(availableSkills).toContain('quality-gates');
+    });
+
     it('installs every available project skill with merged hooks and copied assets', async () => {
         const availableSkills = await getAvailableProjectSkills();
         expect(availableSkills).toEqual([
-            'py-quality-gate',
+            'quality-gates',
             'service-skills-set',
             'tdd-guard',
-            'ts-quality-gate',
         ]);
 
         await installAllProjectSkills(tmpDir);
 
         const settings = await fsExtra.readJson(path.join(tmpDir, '.claude', 'settings.json'));
-        expect(settings.hooks.SessionStart).toHaveLength(2);
-        expect(settings.hooks.PreToolUse).toHaveLength(2);
-        expect(settings.hooks.PostToolUse).toHaveLength(3);
-        expect(settings.hooks.UserPromptSubmit).toHaveLength(1);
+        expect(settings.hooks.PreToolUse).toHaveLength(1);   // tdd-guard
 
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'quality-check.cjs'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'quality-check.py'))).toBe(true);
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'git-hooks', 'doc_reminder.py'))).toBe(true);
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'service-registry.json'))).toBe(true);
 
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-tdd-guard', 'SKILL.md'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-ts-quality-gate', 'SKILL.md'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-py-quality-gate', 'SKILL.md'))).toBe(true);
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-service-skills', 'SKILL.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-quality-gates', 'SKILL.md'))).toBe(true);
 
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'tdd-guard-readme.md'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'ts-quality-gate-readme.md'))).toBe(true);
-        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'py-quality-gate-readme.md'))).toBe(true);
         expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'service-skills-set-readme.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'quality-gates-readme.md'))).toBe(true);
     });
 });

package/vitest.config.ts

@@ -5,5 +5,6 @@ import path from 'path'
 export default defineConfig({
   test: {
     reporters: ['default', new VitestReporter(path.resolve(__dirname, '..'))],
+    testTimeout: 30000,
   },
 })