xtrm-cli 2.1.20 → 2.1.29

package/extensions/beads.ts

@@ -0,0 +1,99 @@
+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"));
+
+	// Get session ID from sessionManager (UUID, consistent with hooks)
+	const getSessionId = (ctx: any): string => {
+		return ctx.sessionManager?.getSessionId?.() ?? process.pid.toString();
+	};
+
+	const getSessionClaim = async (sessionId: string, 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;
+
+		const sessionId = getSessionId(ctx);
+
+		if (EventAdapter.isMutatingFileTool(event)) {
+			const claim = await getSessionClaim(sessionId, 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 (${sessionId}).\n  bd update <id> --claim`,
+                    };
+                }
+            }
+		}
+
+		if (isToolCallEventType("bash", event)) {
+			const command = event.input.command;
+			if (command && /\bgit\s+commit\b/.test(command)) {
+                const claim = await getSessionClaim(sessionId, 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;
+			const sessionId = getSessionId(ctx);
+
+			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 \`${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.29",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "main": "./dist/index.js",
   "type": "module",