xtrm-cli 2.1.20 → 2.1.28

package/extensions/beads.ts

@@ -0,0 +1,96 @@
+import type { ExtensionAPI, ToolCallEvent, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { SubprocessRunner, EventAdapter, Logger } from "./core/lib";
+
+const logger = new Logger({ namespace: "beads" });
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+	const isBeadsProject = (cwd: string) => fs.existsSync(path.join(cwd, ".beads"));
+
+	// Pin session to PID — stable for the life of the Pi process, consistent across all extension handlers
+	const sessionId = process.pid.toString();
+
+	const getSessionClaim = async (cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
+		if (result.code === 0) return result.stdout.trim();
+		return null;
+	};
+
+	const hasTrackableWork = async (cwd: string): Promise<boolean> => {
+		const result = await SubprocessRunner.run("bd", ["list"], { cwd });
+		if (result.code === 0 && result.stdout.includes("Total:")) {
+			const m = result.stdout.match(/Total:\s*\d+\s+issues?\s*\((\d+)\s+open,\s*(\d+)\s+in progress\)/);
+			if (m) {
+				const open = parseInt(m[1], 10);
+				const inProgress = parseInt(m[2], 10);
+				return (open + inProgress) > 0;
+			}
+		}
+		return false;
+	};
+
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		if (!isBeadsProject(cwd)) return undefined;
+
+		if (EventAdapter.isMutatingFileTool(event)) {
+			const claim = await getSessionClaim(cwd);
+			if (!claim) {
+			    const hasWork = await hasTrackableWork(cwd);
+			    if (hasWork) {
+			        if (ctx.hasUI) {
+				        ctx.ui.notify("Beads: Edit blocked. Claim an issue first.", "warning");
+			        }
+			        return {
+                        block: true,
+                        reason: `No active issue claim for this session (pid:${sessionId}).\n  bd update <id> --claim\n  bd kv set "claimed:${sessionId}" "<id>"`,
+                    };
+                }
+            }
+		}
+
+		if (isToolCallEventType("bash", event)) {
+			const command = event.input.command;
+			if (command && /\bgit\s+commit\b/.test(command)) {
+                const claim = await getSessionClaim(cwd);
+				if (claim) {
+					return {
+                        block: true,
+                        reason: `Resolve open claim [${claim}] before committing.`,
+                    };
+				}
+			}
+		}
+
+		return undefined;
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (isBashToolResult(event)) {
+			const command = event.input.command;
+
+			// Auto-claim on bd update --claim regardless of exit code.
+			// bd returns exit 1 with "already in_progress" when status unchanged — still a valid claim intent.
+			if (command && /\bbd\s+update\b/.test(command) && /--claim\b/.test(command)) {
+				const issueMatch = command.match(/\bbd\s+update\s+(\S+)/);
+				if (issueMatch) {
+					const issueId = issueMatch[1];
+					const cwd = getCwd(ctx);
+					await SubprocessRunner.run("bd", ["kv", "set", `claimed:${sessionId}`, issueId], { cwd });
+					const claimNotice = `\n\n✅ **Beads**: Session \`pid:${sessionId}\` claimed issue \`${issueId}\`. File edits are now unblocked.`;
+					return { content: [...event.content, { type: "text", text: claimNotice }] };
+				}
+			}
+
+			if (command && /\bbd\s+close\b/.test(command) && !event.isError) {
+				const reminder = "\n\n**Beads Insight**: Work completed. Consider if this session produced insights worth persisting via `bd remember`.";
+				const newContent = [...event.content, { type: "text", text: reminder }];
+				return { content: newContent };
+			}
+		}
+		return undefined;
+	});
+}

package/extensions/core/adapter.ts

@@ -0,0 +1,45 @@
+import type { ExtensionAPI, ToolCallEvent } from "@mariozechner/pi-coding-agent";
+
+export class EventAdapter {
+	/**
+	 * Checks if the tool event is a mutating file operation (write, edit, etc).
+	 */
+	static isMutatingFileTool(event: ToolCallEvent<any, any>): boolean {
+		const tools = [
+			"write",
+			"edit",
+			"replace_content",
+			"replace_lines",
+			"delete_lines",
+			"insert_at_line",
+			"create_text_file",
+			"rename_symbol",
+			"replace_symbol_body",
+			"insert_after_symbol",
+			"insert_before_symbol",
+		];
+		return tools.includes(event.toolName);
+	}
+
+	/**
+	 * Extracts the target path from a tool input, resolving against the current working directory.
+	 */
+	static extractPathFromToolInput(event: ToolCallEvent<any, any>, cwd: string): string | null {
+		const input = event.input;
+		if (!input) return null;
+
+		const pathRaw = input.path || input.file || input.filePath;
+		if (typeof pathRaw === "string") {
+			return pathRaw; // Usually Pi passes absolute paths anyway or paths relative to root
+		}
+
+		return null;
+	}
+
+	/**
+	 * Safely formats a block reason string to ensure UI readiness.
+	 */
+	static formatBlockReason(prefix: string, details: string): string {
+		return `${prefix}: ${details}`;
+	}
+}

package/extensions/core/lib.ts

@@ -0,0 +1,3 @@
+export * from "./logger";
+export * from "./runner";
+export * from "./adapter";

package/extensions/core/logger.ts

@@ -0,0 +1,45 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LoggerOptions {
+	namespace: string;
+	level?: LogLevel;
+}
+
+export class Logger {
+	private namespace: string;
+	private level: LogLevel;
+
+	constructor(options: LoggerOptions) {
+		this.namespace = options.namespace;
+		this.level = options.level || "info";
+	}
+
+	private shouldLog(level: LogLevel): boolean {
+		const levels: LogLevel[] = ["debug", "info", "warn", "error"];
+		return levels.indexOf(level) >= levels.indexOf(this.level);
+	}
+
+	debug(message: string, ...args: any[]) {
+		if (this.shouldLog("debug")) {
+			console.debug(`[${this.namespace}] DEBUG: ${message}`, ...args);
+		}
+	}
+
+	info(message: string, ...args: any[]) {
+		if (this.shouldLog("info")) {
+			console.info(`[${this.namespace}] INFO: ${message}`, ...args);
+		}
+	}
+
+	warn(message: string, ...args: any[]) {
+		if (this.shouldLog("warn")) {
+			console.warn(`[${this.namespace}] WARN: ${message}`, ...args);
+		}
+	}
+
+	error(message: string, ...args: any[]) {
+		if (this.shouldLog("error")) {
+			console.error(`[${this.namespace}] ERROR: ${message}`, ...args);
+		}
+	}
+}

package/extensions/core/runner.ts

@@ -0,0 +1,71 @@
+import { execFile, spawnSync } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export interface RunOptions {
+	timeoutMs?: number;
+	cwd?: string;
+	env?: Record<string, string>;
+	input?: string; // Standard input
+}
+
+export interface RunResult {
+	code: number;
+	stdout: string;
+	stderr: string;
+}
+
+export class SubprocessRunner {
+	/**
+	 * Run a command deterministically with a timeout and optional stdin.
+	 */
+	static async run(
+		command: string,
+		args: string[],
+		options: RunOptions = {}
+	): Promise<RunResult> {
+		const timeout = options.timeoutMs ?? 10000;
+		const cwd = options.cwd ?? process.cwd();
+		const env = { ...process.env, ...options.env };
+
+		if (options.input !== undefined) {
+			// Use spawnSync for stdin support if input is provided
+			const result = spawnSync(command, args, {
+				cwd,
+				env,
+				input: options.input,
+				encoding: "utf8",
+				timeout,
+				maxBuffer: 1024 * 1024 * 10,
+			});
+
+			return {
+				code: result.status ?? 1,
+				stdout: (result.stdout ?? "").trim(),
+				stderr: (result.stderr ?? "").trim(),
+			};
+		}
+
+		try {
+			const result = await execFileAsync(command, args, {
+				timeout,
+				cwd,
+				env,
+				maxBuffer: 1024 * 1024 * 10,
+			});
+
+			return {
+				code: 0,
+				stdout: result.stdout.trim(),
+				stderr: result.stderr.trim(),
+			};
+		} catch (error: any) {
+			return {
+				code: error.code ?? 1,
+				stdout: (error.stdout ?? "").trim(),
+				stderr: (error.stderr ?? error.message ?? "").trim(),
+			};
+		}
+	}
+}

package/extensions/main-guard-post-push.ts

@@ -0,0 +1,44 @@
+import type { ExtensionAPI, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, Logger } from "./core/lib";
+
+const logger = new Logger({ namespace: "main-guard-post-push" });
+
+export default function (pi: ExtensionAPI) {
+	const getProtectedBranches = (): string[] => {
+		const env = process.env.MAIN_GUARD_PROTECTED_BRANCHES;
+		if (env) return env.split(",").map(b => b.trim()).filter(Boolean);
+		return ["main", "master"];
+	};
+
+	pi.on("tool_result", async (event, ctx) => {
+		const cwd = ctx.cwd || process.cwd();
+		if (!isBashToolResult(event) || event.isError) return undefined;
+
+		const cmd = event.input.command.trim();
+		if (!/\bgit\s+push\b/.test(cmd)) return undefined;
+
+		// Check if we pushed to a protected branch
+		const protectedBranches = getProtectedBranches();
+		const tokens = cmd.split(/\s+/);
+		const lastToken = tokens[tokens.length - 1];
+		if (protectedBranches.some(b => lastToken === b || lastToken.endsWith(`:${b}`))) {
+			return undefined;
+		}
+
+		// Success! Suggest PR workflow
+		const reminder = "\n\n**Main-Guard**: Push successful. Next steps:\n" +
+			"  1. `gh pr create --fill` (if not already open)\n" +
+			"  2. `gh pr merge --squash` (once approved)\n" +
+			"  3. `git checkout main && git reset --hard origin/main` (sync local)";
+
+		const newContent = [...event.content];
+		newContent.push({ type: "text", text: reminder });
+
+		if (ctx.hasUI) {
+			ctx.ui.notify("Main-Guard: Suggesting PR workflow", "info");
+		}
+
+		return { content: newContent };
+	});
+}

package/extensions/main-guard.ts

@@ -0,0 +1,126 @@
+import type { ExtensionAPI, ToolCallEvent } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter, Logger } from "./core/lib";
+
+const logger = new Logger({ namespace: "main-guard" });
+
+export default function (pi: ExtensionAPI) {
+	const getProtectedBranches = (): string[] => {
+		const env = process.env.MAIN_GUARD_PROTECTED_BRANCHES;
+		if (env) return env.split(",").map(b => b.trim()).filter(Boolean);
+		return ["main", "master"];
+	};
+
+	const getCurrentBranch = async (cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("git", ["branch", "--show-current"], { cwd });
+		if (result.code === 0) return result.stdout;
+		return null;
+	};
+
+	const protectedPaths = [".env", ".git/", "node_modules/"];
+
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = ctx.cwd || process.cwd();
+		
+		// 1. Safety Check: Protected Paths (Global)
+		if (EventAdapter.isMutatingFileTool(event)) {
+			const path = EventAdapter.extractPathFromToolInput(event, cwd);
+			if (path && protectedPaths.some((p) => path.includes(p))) {
+				const reason = `Path "${path}" is protected. Edits to sensitive system files are restricted.`;
+				if (ctx.hasUI) {
+					ctx.ui.notify(`Safety: Blocked edit to protected path`, "error");
+				}
+				return { block: true, reason };
+			}
+		}
+
+		// 2. Safety Check: Dangerous Commands (Global)
+		if (isToolCallEventType("bash", event)) {
+			const cmd = event.input.command.trim();
+			if (cmd.includes("rm -rf") && !cmd.includes("--help")) {
+				if (ctx.hasUI) {
+					const ok = await ctx.ui.confirm("Dangerous Command", `Allow execution of: ${cmd}?`);
+					if (!ok) return { block: true, reason: "Blocked by user confirmation" };
+				} else {
+					return { block: true, reason: "Dangerous command 'rm -rf' blocked in non-interactive mode" };
+				}
+			}
+		}
+
+		// 3. Main-Guard: Branch Protection
+		const protectedBranches = getProtectedBranches();
+		const branch = await getCurrentBranch(cwd);
+
+		if (branch && protectedBranches.includes(branch)) {
+			// A. Mutating File Tools on Main
+			if (EventAdapter.isMutatingFileTool(event)) {
+				const reason = `On protected branch '${branch}'. Checkout a feature branch first: \`git checkout -b feature/<name>\``;
+				if (ctx.hasUI) {
+					ctx.ui.notify(`Main-Guard: Blocked edit on ${branch}`, "error");
+				}
+				return { block: true, reason };
+			}
+
+			// B. Bash Commands on Main
+			if (isToolCallEventType("bash", event)) {
+				const cmd = event.input.command.trim();
+
+				// Emergency override
+				if (process.env.MAIN_GUARD_ALLOW_BASH === "1") return undefined;
+
+				// Enforce squash-only PR merges
+				if (/^gh\s+pr\s+merge\b/.test(cmd)) {
+					if (!/--squash\b/.test(cmd)) {
+						const reason = "Squash only: use `gh pr merge --squash` (or MAIN_GUARD_ALLOW_BASH=1)";
+						return { block: true, reason };
+					}
+					return undefined;
+				}
+
+				// Safe allowlist
+				const SAFE_BASH_PATTERNS = [
+					/^git\s+(status|log|diff|branch|show|describe|fetch|remote|config)\b/,
+					/^git\s+pull\b/,
+					/^git\s+stash\b/,
+					/^git\s+worktree\b/,
+					/^git\s+checkout\s+-b\s+\S+/,
+					/^git\s+switch\s+-c\s+\S+/,
+					...protectedBranches.map(b => new RegExp(`^git\\s+reset\\s+--hard\\s+origin/${b}\\b`)),
+					/^gh\s+/,
+					/^bd\s+/,
+					/^touch\s+\.beads\//,
+				];
+
+				if (SAFE_BASH_PATTERNS.some(p => p.test(cmd))) {
+					return undefined;
+				}
+
+				// Specific blocks
+				if (/\bgit\s+commit\b/.test(cmd)) {
+					return { block: true, reason: `No commits on '${branch}' — use a feature branch.` };
+				}
+
+				if (/\bgit\s+push\b/.test(cmd)) {
+					const tokens = cmd.split(/\s+/);
+					const lastToken = tokens[tokens.length - 1];
+					const explicitProtected = protectedBranches.some(b => lastToken === b || lastToken.endsWith(`:${b}`));
+					const impliedProtected = tokens.length <= 3 && protectedBranches.includes(branch);
+					
+					if (explicitProtected || impliedProtected) {
+						return { block: true, reason: `No direct push to '${branch}' — push a feature branch and open a PR.` };
+					}
+					return undefined;
+				}
+
+				// Default deny
+				const reason = `Bash restricted on '${branch}'. Allowed: git status/log/diff/pull/stash, gh, bd.\n  Exit: git checkout -b feature/<name>`;
+				if (ctx.hasUI) {
+					ctx.ui.notify("Main-Guard: Command blocked", "error");
+				}
+				return { block: true, reason };
+			}
+		}
+
+		return undefined;
+	});
+}

package/extensions/quality-gates.ts

@@ -0,0 +1,67 @@
+import type { ExtensionAPI, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter, Logger } from "./core/lib";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const logger = new Logger({ namespace: "quality-gates" });
+
+export default function (pi: ExtensionAPI) {
+	pi.on("tool_result", async (event, ctx) => {
+		if (!EventAdapter.isMutatingFileTool(event)) return undefined;
+
+		const cwd = ctx.cwd || process.cwd();
+		const filePath = EventAdapter.extractPathFromToolInput(event, cwd);
+		if (!filePath) return undefined;
+
+		const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+		const ext = path.extname(fullPath);
+
+		let scriptPath: string | null = null;
+		let runner: string = "node";
+
+		if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.cjs");
+			runner = "node";
+		} else if (ext === ".py") {
+			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.py");
+			runner = "python3";
+		}
+
+		if (!scriptPath || !fs.existsSync(scriptPath)) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: event.toolName,
+			tool_input: event.input,
+			cwd: cwd,
+		});
+
+		const result = await SubprocessRunner.run(runner, [scriptPath], {
+			cwd,
+			input: hookInput,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			timeoutMs: 30000,
+		});
+
+		if (result.code === 0) {
+			if (result.stderr && result.stderr.trim()) {
+				const newContent = [...event.content];
+				newContent.push({ type: "text", text: `\n\n**Quality Gate**: ${result.stderr.trim()}` });
+				return { content: newContent };
+			}
+			return undefined;
+		}
+
+		if (result.code === 2) {
+			const newContent = [...event.content];
+			newContent.push({ type: "text", text: `\n\n**Quality Gate FAILED**:\n${result.stderr || result.stdout || "Unknown error"}` });
+			
+			if (ctx.hasUI) {
+				ctx.ui.notify(`Quality Gate failed for ${path.basename(fullPath)}`, "error");
+			}
+
+			return { isError: true, content: newContent };
+		}
+
+		return undefined;
+	});
+}

package/extensions/service-skills.ts

@@ -0,0 +1,88 @@
+import type { ExtensionAPI, ToolCallEvent, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, Logger } from "./core/lib";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const logger = new Logger({ namespace: "service-skills" });
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+
+	// 1. Catalog Injection
+	pi.on("before_agent_start", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const catalogerPath = path.join(cwd, ".claude", "skills", "using-service-skills", "scripts", "cataloger.py");
+		if (!fs.existsSync(catalogerPath)) return undefined;
+
+		const result = await SubprocessRunner.run("python3", [catalogerPath], {
+			cwd,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd }
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			return { systemPrompt: event.systemPrompt + "\n\n" + result.stdout.trim() };
+		}
+		return undefined;
+	});
+
+	// 2. Territory Activation
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const activatorPath = path.join(cwd, ".claude", "skills", "using-service-skills", "scripts", "skill_activator.py");
+		if (!fs.existsSync(activatorPath)) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: event.toolName === "bash" ? "Bash" : event.toolName,
+			tool_input: event.input,
+			cwd: cwd
+		});
+
+		const result = await SubprocessRunner.run("python3", [activatorPath], {
+			cwd,
+			input: hookInput,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			timeoutMs: 5000
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			try {
+				const parsed = JSON.parse(result.stdout.trim());
+				const context = parsed.hookSpecificOutput?.additionalContext;
+				if (context && ctx.hasUI) {
+					ctx.ui.notify(context, "info");
+				}
+			} catch (e) {
+				logger.error("Failed to parse skill_activator output", e);
+			}
+		}
+		return undefined;
+	});
+
+	// 3. Drift Detection
+	pi.on("tool_result", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const driftDetectorPath = path.join(cwd, ".claude", "skills", "updating-service-skills", "scripts", "drift_detector.py");
+		if (!fs.existsSync(driftDetectorPath)) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: event.toolName === "bash" ? "Bash" : event.toolName,
+			tool_input: event.input,
+			cwd: cwd
+		});
+
+		const result = await SubprocessRunner.run("python3", [driftDetectorPath], {
+			cwd,
+			input: hookInput,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			timeoutMs: 10000
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			const newContent = [...event.content];
+			newContent.push({ type: "text", text: "\n\n" + result.stdout.trim() });
+			return { content: newContent };
+		}
+		return undefined;
+	});
+}

package/extensions/xtrm-loader.ts

@@ -0,0 +1,89 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./core/lib";
+
+const logger = new Logger({ namespace: "xtrm-loader" });
+
+/**
+ * Recursively find markdown files in a directory.
+ */
+function findMarkdownFiles(dir: string, basePath: string = ""): string[] {
+	const results: string[] = [];
+	if (!fs.existsSync(dir)) return results;
+
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			results.push(...findMarkdownFiles(path.join(dir, entry.name), relativePath));
+		} else if (entry.isFile() && entry.name.endsWith(".md")) {
+			results.push(relativePath);
+		}
+	}
+	return results;
+}
+
+export default function (pi: ExtensionAPI) {
+	let projectContext: string = "";
+
+	pi.on("session_start", async (_event, ctx) => {
+		const cwd = ctx.cwd;
+		const contextParts: string[] = [];
+
+		// 1. Architecture & Roadmap
+		const roadmapPaths = [
+			path.join(cwd, "architecture", "project_roadmap.md"),
+			path.join(cwd, "ROADMAP.md"),
+			path.join(cwd, "architecture", "index.md")
+		];
+
+		for (const p of roadmapPaths) {
+			if (fs.existsSync(p)) {
+				const content = fs.readFileSync(p, "utf8");
+				contextParts.push(`## Project Roadmap & Architecture (${path.relative(cwd, p)})\n\n${content}`);
+				break; // Only load the first one found
+			}
+		}
+
+		// 2. Project Rules (.claude/rules)
+		const rulesDir = path.join(cwd, ".claude", "rules");
+		if (fs.existsSync(rulesDir)) {
+			const ruleFiles = findMarkdownFiles(rulesDir);
+			if (ruleFiles.length > 0) {
+				const rulesContent = ruleFiles.map(f => {
+					const content = fs.readFileSync(path.join(rulesDir, f), "utf8");
+					return `### Rule: ${f}\n${content}`;
+				}).join("\n\n");
+				contextParts.push(`## Project Rules\n\n${rulesContent}`);
+			}
+		}
+
+		// 3. Project Skills (.claude/skills)
+		const skillsDir = path.join(cwd, ".claude", "skills");
+		if (fs.existsSync(skillsDir)) {
+			const skillFiles = findMarkdownFiles(skillsDir);
+			if (skillFiles.length > 0) {
+				const skillsContent = skillFiles.map(f => {
+					// We only want to list the paths/names so the agent knows what it can read
+					return `- ${f} (Path: .claude/skills/${f})`;
+				}).join("\n");
+				contextParts.push(`## Available Project Skills\n\nExisting service skills and workflows found in .claude/skills/:\n\n${skillsContent}\n\nUse the read tool to load any of these skills if relevant to the current task.`);
+			}
+		}
+
+		projectContext = contextParts.join("\n\n---\n\n");
+		
+		if (projectContext && ctx.hasUI) {
+			ctx.ui.notify("XTRM-Loader: Project context and skills indexed", "info");
+		}
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		if (!projectContext) return undefined;
+
+		return {
+			systemPrompt: event.systemPrompt + "\n\n# Project Intelligence Context\n\n" + projectContext
+		};
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xtrm-cli",
-  "version": "2.1.20",
+  "version": "2.1.28",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "main": "./dist/index.js",
   "type": "module",

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");
+	});
+});