xtrm-tools 2.4.1 → 2.4.2

package/config/pi/extensions/plan-mode/utils.ts

@@ -0,0 +1,168 @@
+/**
+ * Pure utility functions for plan mode.
+ * Extracted for testability.
+ */
+
+// Destructive commands blocked in plan mode
+const DESTRUCTIVE_PATTERNS = [
+	/\brm\b/i,
+	/\brmdir\b/i,
+	/\bmv\b/i,
+	/\bcp\b/i,
+	/\bmkdir\b/i,
+	/\btouch\b/i,
+	/\bchmod\b/i,
+	/\bchown\b/i,
+	/\bchgrp\b/i,
+	/\bln\b/i,
+	/\btee\b/i,
+	/\btruncate\b/i,
+	/\bdd\b/i,
+	/\bshred\b/i,
+	/(^|[^<])>(?!>)/,
+	/>>/,
+	/\bnpm\s+(install|uninstall|update|ci|link|publish)/i,
+	/\byarn\s+(add|remove|install|publish)/i,
+	/\bpnpm\s+(add|remove|install|publish)/i,
+	/\bpip\s+(install|uninstall)/i,
+	/\bapt(-get)?\s+(install|remove|purge|update|upgrade)/i,
+	/\bbrew\s+(install|uninstall|upgrade)/i,
+	/\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)/i,
+	/\bsudo\b/i,
+	/\bsu\b/i,
+	/\bkill\b/i,
+	/\bpkill\b/i,
+	/\bkillall\b/i,
+	/\breboot\b/i,
+	/\bshutdown\b/i,
+	/\bsystemctl\s+(start|stop|restart|enable|disable)/i,
+	/\bservice\s+\S+\s+(start|stop|restart)/i,
+	/\b(vim?|nano|emacs|code|subl)\b/i,
+];
+
+// Safe read-only commands allowed in plan mode
+const SAFE_PATTERNS = [
+	/^\s*cat\b/,
+	/^\s*head\b/,
+	/^\s*tail\b/,
+	/^\s*less\b/,
+	/^\s*more\b/,
+	/^\s*grep\b/,
+	/^\s*find\b/,
+	/^\s*ls\b/,
+	/^\s*pwd\b/,
+	/^\s*echo\b/,
+	/^\s*printf\b/,
+	/^\s*wc\b/,
+	/^\s*sort\b/,
+	/^\s*uniq\b/,
+	/^\s*diff\b/,
+	/^\s*file\b/,
+	/^\s*stat\b/,
+	/^\s*du\b/,
+	/^\s*df\b/,
+	/^\s*tree\b/,
+	/^\s*which\b/,
+	/^\s*whereis\b/,
+	/^\s*type\b/,
+	/^\s*env\b/,
+	/^\s*printenv\b/,
+	/^\s*uname\b/,
+	/^\s*whoami\b/,
+	/^\s*id\b/,
+	/^\s*date\b/,
+	/^\s*cal\b/,
+	/^\s*uptime\b/,
+	/^\s*ps\b/,
+	/^\s*top\b/,
+	/^\s*htop\b/,
+	/^\s*free\b/,
+	/^\s*git\s+(status|log|diff|show|branch|remote|config\s+--get)/i,
+	/^\s*git\s+ls-/i,
+	/^\s*npm\s+(list|ls|view|info|search|outdated|audit)/i,
+	/^\s*yarn\s+(list|info|why|audit)/i,
+	/^\s*node\s+--version/i,
+	/^\s*python\s+--version/i,
+	/^\s*curl\s/i,
+	/^\s*wget\s+-O\s*-/i,
+	/^\s*jq\b/,
+	/^\s*sed\s+-n/i,
+	/^\s*awk\b/,
+	/^\s*rg\b/,
+	/^\s*fd\b/,
+	/^\s*bat\b/,
+	/^\s*exa\b/,
+];
+
+export function isSafeCommand(command: string): boolean {
+	const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command));
+	const isSafe = SAFE_PATTERNS.some((p) => p.test(command));
+	return !isDestructive && isSafe;
+}
+
+export interface TodoItem {
+	step: number;
+	text: string;
+	completed: boolean;
+}
+
+export function cleanStepText(text: string): string {
+	let cleaned = text
+		.replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1") // Remove bold/italic
+		.replace(/`([^`]+)`/g, "$1") // Remove code
+		.replace(
+			/^(Use|Run|Execute|Create|Write|Read|Check|Verify|Update|Modify|Add|Remove|Delete|Install)\s+(the\s+)?/i,
+			"",
+		)
+		.replace(/\s+/g, " ")
+		.trim();
+
+	if (cleaned.length > 0) {
+		cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+	}
+	if (cleaned.length > 50) {
+		cleaned = `${cleaned.slice(0, 47)}...`;
+	}
+	return cleaned;
+}
+
+export function extractTodoItems(message: string): TodoItem[] {
+	const items: TodoItem[] = [];
+	const headerMatch = message.match(/\*{0,2}Plan:\*{0,2}\s*\n/i);
+	if (!headerMatch) return items;
+
+	const planSection = message.slice(message.indexOf(headerMatch[0]) + headerMatch[0].length);
+	const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm;
+
+	for (const match of planSection.matchAll(numberedPattern)) {
+		const text = match[2]
+			.trim()
+			.replace(/\*{1,2}$/, "")
+			.trim();
+		if (text.length > 5 && !text.startsWith("`") && !text.startsWith("/") && !text.startsWith("-")) {
+			const cleaned = cleanStepText(text);
+			if (cleaned.length > 3) {
+				items.push({ step: items.length + 1, text: cleaned, completed: false });
+			}
+		}
+	}
+	return items;
+}
+
+export function extractDoneSteps(message: string): number[] {
+	const steps: number[] = [];
+	for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
+		const step = Number(match[1]);
+		if (Number.isFinite(step)) steps.push(step);
+	}
+	return steps;
+}
+
+export function markCompletedSteps(text: string, items: TodoItem[]): number {
+	const doneSteps = extractDoneSteps(text);
+	for (const step of doneSteps) {
+		const item = items.find((t) => t.step === step);
+		if (item) item.completed = true;
+	}
+	return doneSteps.length;
+}

package/config/pi/extensions/service-skills.ts

@@ -3,18 +3,56 @@ import { SubprocessRunner } from "./core/lib";
 import * as path from "node:path";
 import * as fs from "node:fs";
 
+const SERVICE_REGISTRY_FILES = [
+	"service-registry.json",
+	path.join(".claude", "skills", "service-registry.json"),
+];
+
+const GLOBAL_SKILL_ROOTS = [
+	path.join(process.env.HOME || "", ".agents", "skills"),
+	path.join(process.env.HOME || "", ".claude", "skills"),
+];
+
 export default function (pi: ExtensionAPI) {
 	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
 
+	const resolveRegistryPath = (cwd: string): string | null => {
+		for (const rel of SERVICE_REGISTRY_FILES) {
+			const candidate = path.join(cwd, rel);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+		return null;
+	};
+
+	const resolveSkillScript = (cwd: string, skillName: string, scriptName: string): string | null => {
+		const localPath = path.join(cwd, ".claude", "skills", skillName, "scripts", scriptName);
+		if (fs.existsSync(localPath)) return localPath;
+
+		for (const root of GLOBAL_SKILL_ROOTS) {
+			if (!root) continue;
+			const candidate = path.join(root, skillName, "scripts", scriptName);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+
+		return null;
+	};
+
 	// 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 registryPath = resolveRegistryPath(cwd);
+		if (!registryPath) return undefined;
+
+		const catalogerPath = resolveSkillScript(cwd, "using-service-skills", "cataloger.py");
+		if (!catalogerPath) return undefined;
 
 		const result = await SubprocessRunner.run("python3", [catalogerPath], {
 			cwd,
-			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd }
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd,
+				SERVICE_REGISTRY_PATH: registryPath,
+			},
 		});
 
 		if (result.code === 0 && result.stdout.trim()) {
@@ -23,7 +61,6 @@ export default function (pi: ExtensionAPI) {
 		return undefined;
 	});
 
-
 	const toClaudeToolName = (toolName: string): string => {
 		if (toolName === "bash") return "Bash";
 		if (toolName === "read_file") return "Read";
@@ -37,8 +74,11 @@ export default function (pi: ExtensionAPI) {
 	// 2. Drift Detection (skill activation is before_agent_start only — not per-tool)
 	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 registryPath = resolveRegistryPath(cwd);
+		if (!registryPath) return undefined;
+
+		const driftDetectorPath = resolveSkillScript(cwd, "updating-service-skills", "drift_detector.py");
+		if (!driftDetectorPath) return undefined;
 
 		const hookInput = JSON.stringify({
 			tool_name: toClaudeToolName(event.toolName),
@@ -49,7 +89,11 @@ export default function (pi: ExtensionAPI) {
 		const result = await SubprocessRunner.run("python3", [driftDetectorPath], {
 			cwd,
 			input: hookInput,
-			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd,
+				SERVICE_REGISTRY_PATH: registryPath,
+			},
 			timeoutMs: 10000,
 		});
 

package/config/pi/extensions/session-flow.ts

@@ -0,0 +1,117 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import fs from "node:fs";
+import path from "node:path";
+import { SubprocessRunner, EventAdapter } from "./core/lib";
+import { readSessionState } from "./core/session-state";
+
+function isClaimCommand(command: string): { isClaim: boolean; issueId: string | null } {
+	if (!/\bbd\s+update\b/.test(command) || !/--claim\b/.test(command)) {
+		return { isClaim: false, issueId: null };
+	}
+	const match = command.match(/\bbd\s+update\s+(\S+)/);
+	return { isClaim: true, issueId: match?.[1] ?? null };
+}
+
+function statePathFrom(startCwd: string): string {
+	let current = path.resolve(startCwd || process.cwd());
+	for (;;) {
+		const candidate = path.join(current, ".xtrm-session-state.json");
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) return path.join(startCwd, ".xtrm-session-state.json");
+		current = parent;
+	}
+}
+
+async function ensureWorktreeSessionState(cwd: string, issueId: string): Promise<{ ok: boolean; message?: string }> {
+	const repoRootResult = await SubprocessRunner.run("git", ["rev-parse", "--show-toplevel"], { cwd });
+	if (repoRootResult.code !== 0 || !repoRootResult.stdout) return { ok: false, message: "not a git repo" };
+	const repoRoot = repoRootResult.stdout.trim();
+
+	const gitDir = await SubprocessRunner.run("git", ["rev-parse", "--git-dir"], { cwd });
+	const commonDir = await SubprocessRunner.run("git", ["rev-parse", "--git-common-dir"], { cwd });
+	if (gitDir.code === 0 && commonDir.code === 0 && gitDir.stdout.trim() !== commonDir.stdout.trim()) {
+		return { ok: false, message: "already in linked worktree" };
+	}
+
+	const overstoryDir = path.join(repoRoot, ".overstory");
+	const worktreesBase = fs.existsSync(overstoryDir)
+		? path.join(overstoryDir, "worktrees")
+		: path.join(repoRoot, ".worktrees");
+	fs.mkdirSync(worktreesBase, { recursive: true });
+
+	const branch = `feature/${issueId}`;
+	const worktreePath = path.join(worktreesBase, issueId);
+	if (!fs.existsSync(worktreePath)) {
+		const branchExists = (await SubprocessRunner.run("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { cwd: repoRoot })).code === 0;
+		const addArgs = branchExists
+			? ["worktree", "add", worktreePath, branch]
+			: ["worktree", "add", worktreePath, "-b", branch];
+		const add = await SubprocessRunner.run("git", addArgs, { cwd: repoRoot, timeoutMs: 20000 });
+		if (add.code !== 0) {
+			return { ok: false, message: add.stderr || add.stdout || "worktree creation failed" };
+		}
+	}
+
+	const statePath = statePathFrom(repoRoot);
+	const payload = {
+		issueId,
+		branch,
+		worktreePath,
+		prNumber: null,
+		prUrl: null,
+		phase: "claimed",
+		conflictFiles: [],
+		startedAt: new Date().toISOString(),
+		lastChecked: new Date().toISOString(),
+	};
+	fs.writeFileSync(statePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+	return { ok: true, message: `Worktree created: ${worktreePath} Branch: ${branch}` };
+}
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!isBashToolResult(event)) return undefined;
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+
+		const command = event.input.command || "";
+		const { isClaim, issueId } = isClaimCommand(command);
+		if (!isClaim || !issueId) return undefined;
+
+		const ensured = await ensureWorktreeSessionState(cwd, issueId);
+		if (ensured.ok) {
+			const text = `\n\n🧭 Session Flow: ${ensured.message}`;
+			return { content: [...event.content, { type: "text", text }] };
+		}
+		return undefined;
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+		const state = readSessionState(cwd);
+		if (!state) return undefined;
+
+		if (state.phase === "waiting-merge" || state.phase === "pending-cleanup") {
+			const pr = state.prNumber != null ? `#${state.prNumber}` : "(pending PR)";
+			const url = state.prUrl ? ` ${state.prUrl}` : "";
+			pi.sendUserMessage(`🚫 PR ${pr}${url} not yet merged. Run: xtrm finish`);
+			return undefined;
+		}
+
+		if (state.phase === "conflicting") {
+			const files = state.conflictFiles?.length ? state.conflictFiles.join(", ") : "unknown files";
+			pi.sendUserMessage(`🚫 Merge conflicts in: ${files}. Resolve, push, then: xtrm finish`);
+			return undefined;
+		}
+
+		if (state.phase === "claimed" || state.phase === "phase1-done") {
+			pi.sendUserMessage(`⚠ Session has an active worktree at ${state.worktreePath}. Consider running: xtrm finish`);
+		}
+		return undefined;
+	});
+}

package/hooks/beads-claim-sync.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 // beads-claim-sync — PostToolUse hook
 // Auto-sets kv claim on bd update --claim; auto-clears on bd close.
+// Also bootstraps worktree-first session state for xtrm finish workflow.
 
 import { spawnSync } from 'node:child_process';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { writeSessionState } from './session-state.mjs';
 
 function readInput() {
   try {
@@ -35,6 +37,112 @@ function commandSucceeded(payload) {
   return true;
 }
 
+function runGit(args, cwd, timeout = 8000) {
+  return spawnSync('git', args, {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    timeout,
+  });
+}
+
+function getRepoRoot(cwd) {
+  const result = runGit(['rev-parse', '--show-toplevel'], cwd);
+  if (result.status !== 0) return null;
+  return result.stdout.trim();
+}
+
+function inLinkedWorktree(cwd) {
+  const gitDir = runGit(['rev-parse', '--git-dir'], cwd);
+  const gitCommonDir = runGit(['rev-parse', '--git-common-dir'], cwd);
+  if (gitDir.status !== 0 || gitCommonDir.status !== 0) return false;
+  return gitDir.stdout.trim() !== gitCommonDir.stdout.trim();
+}
+
+function ensureWorktreeForClaim(cwd, issueId) {
+  const repoRoot = getRepoRoot(cwd);
+  if (!repoRoot) return { created: false, reason: 'not-git' };
+
+  if (inLinkedWorktree(cwd)) {
+    return { created: false, reason: 'already-worktree', repoRoot };
+  }
+
+  const overstoryDir = join(repoRoot, '.overstory');
+  const worktreesBase = existsSync(overstoryDir)
+    ? join(overstoryDir, 'worktrees')
+    : join(repoRoot, '.worktrees');
+
+  mkdirSync(worktreesBase, { recursive: true });
+
+  const branch = `feature/${issueId}`;
+  const worktreePath = join(worktreesBase, issueId);
+
+  if (existsSync(worktreePath)) {
+    // Already created previously — rewrite state file for continuity.
+    try {
+      const stateFile = writeSessionState({
+        issueId,
+        branch,
+        worktreePath,
+        prNumber: null,
+        prUrl: null,
+        phase: 'claimed',
+        conflictFiles: [],
+      }, { cwd: repoRoot });
+      return { created: false, reason: 'exists', repoRoot, branch, worktreePath, stateFile };
+    } catch {
+      return { created: false, reason: 'exists', repoRoot, branch, worktreePath };
+    }
+  }
+
+  const branchExists = runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], repoRoot).status === 0;
+  const addArgs = branchExists
+    ? ['worktree', 'add', worktreePath, branch]
+    : ['worktree', 'add', worktreePath, '-b', branch];
+
+  const addResult = runGit(addArgs, repoRoot, 20000);
+  if (addResult.status !== 0) {
+    return {
+      created: false,
+      reason: 'create-failed',
+      repoRoot,
+      branch,
+      worktreePath,
+      error: (addResult.stderr || addResult.stdout || '').trim(),
+    };
+  }
+
+  try {
+    const stateFile = writeSessionState({
+      issueId,
+      branch,
+      worktreePath,
+      prNumber: null,
+      prUrl: null,
+      phase: 'claimed',
+      conflictFiles: [],
+    }, { cwd: repoRoot });
+
+    return {
+      created: true,
+      reason: 'created',
+      repoRoot,
+      branch,
+      worktreePath,
+      stateFile,
+    };
+  } catch (err) {
+    return {
+      created: true,
+      reason: 'created-state-write-failed',
+      repoRoot,
+      branch,
+      worktreePath,
+      error: String(err?.message || err),
+    };
+  }
+}
+
 function main() {
   const input = readInput();
   if (!input || input.hook_event_name !== 'PostToolUse') process.exit(0);
@@ -68,8 +176,21 @@ function main() {
         process.exit(0);
       }
 
+      const wt = ensureWorktreeForClaim(cwd, issueId);
+      const details = [];
+      if (wt.created) {
+        details.push(`🧭 **Session Flow**: Worktree created: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
+      } else if (wt.reason === 'exists') {
+        details.push(`🧭 **Session Flow**: Worktree already exists: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
+      } else if (wt.reason === 'already-worktree') {
+        details.push('🧭 **Session Flow**: Already in a linked worktree — skipping nested worktree creation.');
+      } else if (wt.reason === 'create-failed') {
+        const err = wt.error ? `\nWarning: ${wt.error}` : '';
+        details.push(`⚠️ **Session Flow**: Worktree creation failed for \`${issueId}\`. Continuing without blocking claim.${err}`);
+      }
+
       process.stdout.write(JSON.stringify({
-        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.`,
+        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.${details.length ? `\n${details.join('\n')}` : ''}`,
       }));
       process.stdout.write('\n');
       process.exit(0);

package/hooks/beads-compact-restore.mjs

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 // Claude Code SessionStart hook — restore in_progress beads issues after context compaction.
 // Reads .beads/.last_active (written by beads-compact-save.mjs), reinstates statuses,
-// deletes the marker, and injects a brief agent context message.
+// restores session state file, deletes the marker, and injects a brief agent context message.
 // Exit 0 in all paths (informational only).
-//
-// Installed by: xtrm install
 
 import { execSync } from 'node:child_process';
 import { readFileSync, existsSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
+import { writeSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -22,13 +21,26 @@ const lastActivePath = path.join(cwd, '.beads', '.last_active');
 
 if (!existsSync(lastActivePath)) process.exit(0);
 
-const ids = readFileSync(lastActivePath, 'utf8').trim().split('\n').filter(Boolean);
+let ids = [];
+let sessionState = null;
+
+try {
+  const raw = readFileSync(lastActivePath, 'utf8').trim();
+  if (raw.startsWith('{')) {
+    const parsed = JSON.parse(raw);
+    ids = Array.isArray(parsed.ids) ? parsed.ids.filter(Boolean) : [];
+    sessionState = parsed.sessionState ?? null;
+  } else {
+    // Backward compatibility: legacy newline format
+    ids = raw.split('\n').filter(Boolean);
+  }
+} catch {
+  // If file is malformed, just delete and continue fail-open.
+}
 
 // Clean up regardless of whether restore succeeds
 unlinkSync(lastActivePath);
 
-if (ids.length === 0) process.exit(0);
-
 let restored = 0;
 for (const id of ids) {
   try {
@@ -44,13 +56,33 @@ for (const id of ids) {
   }
 }
 
-if (restored > 0) {
+let restoredSession = false;
+if (sessionState && typeof sessionState === 'object') {
+  try {
+    writeSessionState(sessionState, { cwd });
+    restoredSession = true;
+  } catch {
+    // fail open
+  }
+}
+
+if (restored > 0 || restoredSession) {
+  const lines = [];
+  if (restored > 0) {
+    lines.push(`Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction.`);
+  }
+
+  if (restoredSession && (sessionState.phase === 'waiting-merge' || sessionState.phase === 'pending-cleanup')) {
+    const pr = sessionState.prNumber != null ? `#${sessionState.prNumber}` : '(pending PR)';
+    const prUrl = sessionState.prUrl ? ` ${sessionState.prUrl}` : '';
+    lines.push(`RESUME: Run xtrm finish — PR ${pr}${prUrl} waiting for merge. Worktree: ${sessionState.worktreePath}`);
+  }
+
   process.stdout.write(
     JSON.stringify({
       hookSpecificOutput: {
         hookEventName: 'SessionStart',
-        additionalSystemPrompt:
-          `Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction. Check \`bd list\` for details.`,
+        additionalSystemPrompt: `${lines.join(' ')} Check \`bd list\` for details.`,
       },
     }) + '\n',
   );

package/hooks/beads-compact-save.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 // Claude Code PreCompact hook — save in_progress beads issues before context is compacted.
-// Writes issue IDs to .beads/.last_active so beads-compact-restore.mjs can reinstate them.
+// Writes a compact bundle to .beads/.last_active for restore hook.
+// Bundle includes issue IDs and xtrm session state when available.
 // Exit 0 in all paths (informational only).
-//
-// Installed by: xtrm install
 
 import { execSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
+import { readSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -40,7 +40,38 @@ for (const line of output.split('\n')) {
   if (match) ids.push(match[1]);
 }
 
-if (ids.length === 0) process.exit(0);
+const sessionState = readSessionState(cwd);
+const bundle = {
+  ids,
+  sessionState: sessionState ? {
+    issueId: sessionState.issueId,
+    branch: sessionState.branch,
+    worktreePath: sessionState.worktreePath,
+    prNumber: sessionState.prNumber,
+    prUrl: sessionState.prUrl,
+    phase: sessionState.phase,
+    conflictFiles: Array.isArray(sessionState.conflictFiles) ? sessionState.conflictFiles : [],
+    startedAt: sessionState.startedAt,
+    lastChecked: sessionState.lastChecked,
+  } : null,
+  savedAt: new Date().toISOString(),
+};
+
+if (bundle.ids.length === 0 && !bundle.sessionState) process.exit(0);
+
+writeFileSync(path.join(beadsDir, '.last_active'), JSON.stringify(bundle, null, 2) + '\n', 'utf8');
+
+if (bundle.sessionState?.phase === 'waiting-merge') {
+  const pr = bundle.sessionState.prNumber != null ? `#${bundle.sessionState.prNumber}` : '(pending PR)';
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreCompact',
+        additionalSystemPrompt:
+          `PENDING: xtrm finish waiting for PR ${pr} to merge. Re-run xtrm finish to resume.`,
+      },
+    }) + '\n',
+  );
+}
 
-writeFileSync(path.join(beadsDir, '.last_active'), ids.join('\n') + '\n', 'utf8');
 process.exit(0);