xtrm-cli 0.5.0 → 0.5.27

package/src/commands/pi-install.ts

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { findRepoRoot } from '../utils/repo-root.js';
 import { t, sym } from '../utils/theme.js';
+import { syncManagedPiExtensions } from '../utils/pi-extensions.js';
 
 const PI_AGENT_DIR = process.env.PI_AGENT_DIR || path.join(homedir(), '.pi', 'agent');
 
@@ -19,24 +20,6 @@ function isPiInstalled(): boolean {
     return r.status === 0;
 }
 
-/**
- * List extension directories (contain package.json) in a base directory.
- */
-async function listExtensionDirs(baseDir: string): Promise<string[]> {
-    if (!await fs.pathExists(baseDir)) return [];
-    const entries = await fs.readdir(baseDir, { withFileTypes: true });
-    const extDirs: string[] = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const extPath = path.join(baseDir, entry.name);
-        const pkgPath = path.join(extPath, 'package.json');
-        if (await fs.pathExists(pkgPath)) {
-            extDirs.push(extPath);
-        }
-    }
-    return extDirs;
-}
-
 /**
  * Non-interactive Pi install: copies extensions + installs npm packages.
  * Called automatically as part of `xtrm install`.
@@ -65,34 +48,17 @@ export async function runPiInstall(dryRun: boolean = false): Promise<void> {
         console.log(t.success(`  ✓ pi ${v.stdout.trim()} already installed`));
     }
 
-    // Copy extensions
+    // Sync managed extensions (Pi auto-discovers from ~/.pi/agent/extensions)
     const extensionsSrc = path.join(piConfigDir, 'extensions');
     const extensionsDst = path.join(PI_AGENT_DIR, 'extensions');
-    if (await fs.pathExists(extensionsSrc)) {
-        if (!dryRun) {
-            await fs.ensureDir(PI_AGENT_DIR);
-            await fs.copy(extensionsSrc, extensionsDst, { overwrite: true });
-        }
-        console.log(t.success(`  ${sym.ok} extensions synced`));
-
-        // Register each extension with pi install -l
-        const extDirs = await listExtensionDirs(extensionsDst);
-        if (extDirs.length > 0) {
-            console.log(kleur.dim(`  Registering ${extDirs.length} extensions...`));
-            for (const extPath of extDirs) {
-                const extName = path.basename(extPath);
-                if (dryRun) {
-                    console.log(kleur.cyan(`  [DRY RUN] pi install -l ~/.pi/agent/extensions/${extName}`));
-                    continue;
-                }
-                const r = spawnSync('pi', ['install', '-l', extPath], { stdio: 'pipe', encoding: 'utf8' });
-                if (r.status === 0) {
-                    console.log(t.success(`  ${sym.ok} ${extName} registered`));
-                } else {
-                    console.log(kleur.yellow(`  ⚠ ${extName} — registration failed`));
-                }
-            }
-        }
+    const managedPackages = await syncManagedPiExtensions({
+        sourceDir: extensionsSrc,
+        targetDir: extensionsDst,
+        dryRun,
+        log: (message) => console.log(kleur.dim(message)),
+    });
+    if (managedPackages > 0) {
+        console.log(t.success(`  ${sym.ok} extensions synced (${managedPackages} packages)`));
     }
 
     // Install npm packages from schema

package/src/core/context.ts

@@ -3,8 +3,6 @@ import path from 'path';
 import fs from 'fs-extra';
 // @ts-ignore
 import Conf from 'conf';
-// @ts-ignore
-import prompts from 'prompts';
 import kleur from 'kleur';
 import type { SyncMode } from '../types/config.js';
 
@@ -68,73 +66,27 @@ export function resolveTargets(
 
 export async function getContext(options: GetContextOptions = {}): Promise<Context> {
     const { selector, createMissingDirs = true } = options;
-    const choices = [];
     const candidates = getCandidatePaths();
     const directTargets = resolveTargets(selector, candidates);
 
-    if (directTargets) {
-        const activeConfig = getConfig();
-        if (createMissingDirs) {
-            for (const target of directTargets) {
-                await fs.ensureDir(target);
-            }
-        }
-
-        return {
-            targets: directTargets,
-            syncMode: activeConfig.get('syncMode') as SyncMode,
-            config: activeConfig,
-        };
-    }
-
     const activeConfig = getConfig();
 
-    for (const c of candidates) {
-        const exists = await fs.pathExists(c.path);
-        const icon = exists ? kleur.green('●') : kleur.gray('○');
-        const desc = exists ? 'Found' : 'Not found (will create)';
-
-        choices.push({
-            title: `${icon} ${c.label} (${c.path})`,
-            description: desc,
-            value: c.path,
-            selected: exists, // Pre-select existing environments
-        });
-    }
-
-    const response = await prompts({
-        type: 'multiselect',
-        name: 'targets',
-        message: 'Select target environment(s):',
-        choices: choices,
-        hint: '- Space to select. Return to submit',
-        instructions: false,
-    });
-
-    if (response.targets === undefined) {
-        console.log(kleur.gray('\nCancelled.'));
-        process.exit(130);
-    }
-    if (response.targets.length === 0) {
-        console.log(kleur.gray('No targets selected.'));
-        process.exit(0);
-    }
+    // Use explicitly specified targets, or default to all candidates
+    const selectedPaths = directTargets ?? candidates.map(c => c.path);
 
-    // Ensure directories exist for selected targets
     if (createMissingDirs) {
-        for (const target of response.targets) {
+        for (const target of selectedPaths) {
             await fs.ensureDir(target);
         }
     }
 
     return {
-        targets: response.targets,
+        targets: selectedPaths,
         syncMode: activeConfig.get('syncMode') as SyncMode,
         config: activeConfig,
     };
 
 }
-
 export function resetContext(): void {
     getConfig().clear();
     console.log(kleur.yellow('Configuration cleared.'));

package/src/core/diff.ts

@@ -2,7 +2,6 @@ import { join, normalize } from 'path';
 import fs from 'fs-extra';
 import { hashDirectory, getNewestMtime } from '../utils/hash.js';
 import type { ChangeSet } from '../types/config.js';
-import { getAdapter } from '../adapters/registry.js';
 import { detectAdapter } from '../adapters/registry.js';
 
 // Items to ignore from diff scanning (similar to .gitignore)
@@ -18,7 +17,6 @@ export class PruneModeReadError extends Error {
 export async function calculateDiff(repoRoot: string, systemRoot: string, pruneMode: boolean = false): Promise<ChangeSet> {
     const adapter = detectAdapter(systemRoot);
     const isClaude = adapter?.toolName === 'claude-code';
-    const isQwen = adapter?.toolName === 'qwen';
     const normalizedRoot = normalize(systemRoot).replace(/\\/g, '/');
     const isAgentsSkills = normalizedRoot.includes('.agents/skills');
 
@@ -27,8 +25,6 @@ export async function calculateDiff(repoRoot: string, systemRoot: string, pruneM
         hooks: { missing: [], outdated: [], drifted: [], total: 0 },
         config: { missing: [], outdated: [], drifted: [], total: 0 },
         commands: { missing: [], outdated: [], drifted: [], total: 0 },
-        'qwen-commands': { missing: [], outdated: [], drifted: [], total: 0 },
-        'antigravity-workflows': { missing: [], outdated: [], drifted: [], total: 0 },
     };
 
     // Load installed file hashes from manifest for precise drift classification
@@ -61,20 +57,11 @@ export async function calculateDiff(repoRoot: string, systemRoot: string, pruneM
 
     // 1. Folders: Skills & Hooks & Commands
     const folders = ['skills', 'hooks'];
-    if (isQwen) folders.push('qwen-commands');
-    else if (!isClaude) folders.push('commands');
+    if (!isClaude) folders.push('commands');
 
     for (const category of folders) {
-        let repoPath: string;
-        let systemPath: string;
-
-        if (category === 'qwen-commands') {
-            repoPath = join(repoRoot, '.qwen', 'commands');
-            systemPath = join(systemRoot, 'commands');
-        } else {
-            repoPath = join(repoRoot, category);
-            systemPath = join(systemRoot, category);
-        }
+        const repoPath = join(repoRoot, category);
+        const systemPath = join(systemRoot, category);
 
         if (!(await fs.pathExists(repoPath))) continue;
 

package/src/core/preflight.ts

@@ -54,7 +54,6 @@ function getCandidatePaths(): Array<{ label: string; path: string }> {
     const home = os.homedir();
     return [
         { label: '~/.claude (hooks + skills)', path: path.join(home, '.claude') },
-        { label: '.qwen', path: path.join(home, '.qwen') },
         { label: '~/.agents/skills', path: path.join(home, '.agents', 'skills') },
     ];
 }

package/src/index.ts

@@ -16,9 +16,10 @@ import { createStatusCommand } from './commands/status.js';
 import { createResetCommand } from './commands/reset.js';
 import { createHelpCommand } from './commands/help.js';
 import { createCleanCommand } from './commands/clean.js';
-import { createFinishCommand } from './commands/finish.js';
 import { createEndCommand } from './commands/end.js';
 import { createWorktreeCommand } from './commands/worktree.js';
+import { createDocsCommand } from './commands/docs.js';
+import { createDebugCommand } from './commands/debug.js';
 import { printBanner } from './utils/banner.js';
 
 const program = new Command();
@@ -51,9 +52,10 @@ program
 program.addCommand(createStatusCommand());
 program.addCommand(createResetCommand());
 program.addCommand(createCleanCommand());
-program.addCommand(createFinishCommand());
 program.addCommand(createEndCommand());
 program.addCommand(createWorktreeCommand());
+program.addCommand(createDocsCommand());
+program.addCommand(createDebugCommand());
 program.addCommand(createHelpCommand());
 
 // Default action: show help
@@ -76,11 +78,12 @@ process.on('unhandledRejection', (reason) => {
     process.exit(1);
 });
 
-// Show startup banner unless --help or --version flag is present
+// Show banner only for the install command (never for help/version output)
 const isHelpOrVersion = process.argv.some(a => a === '--help' || a === '-h' || a === '--version' || a === '-V');
+const isInstallCommand = (process.argv[2] ?? '') === 'install';
 
 (async () => {
-    if (!isHelpOrVersion) {
+    if (!isHelpOrVersion && isInstallCommand) {
         await printBanner(version);
     }
     program.parseAsync(process.argv);

package/src/types/config.ts

@@ -23,8 +23,6 @@ export const ChangeSetSchema = z.object({
     hooks: ChangeSetCategorySchema,
     config: ChangeSetCategorySchema,
     commands: ChangeSetCategorySchema,
-    'qwen-commands': ChangeSetCategorySchema,
-    'antigravity-workflows': ChangeSetCategorySchema,
 });
 export type ChangeSet = z.infer<typeof ChangeSetSchema>;
 

package/src/utils/config-injector.ts

@@ -32,9 +32,9 @@ export async function injectHookConfig(targetDir: string, repoRoot: string): Pro
                 events: ['userPromptSubmit'],
             },
             {
-                name: 'serena-workflow-reminder',
-                path: path.join(targetDir, 'hooks', 'serena-workflow-reminder.py'),
-                events: ['toolUse'],
+                name: 'using-xtrm-reminder',
+                path: path.join(targetDir, 'hooks', 'using-xtrm-reminder.mjs'),
+                events: ['sessionStart'],
             },
         ];
 

package/src/utils/pi-extensions.ts

@@ -0,0 +1,41 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export interface SyncPiExtensionsOptions {
+    sourceDir: string;
+    targetDir: string;
+    dryRun?: boolean;
+    log?: (message: string) => void;
+}
+
+/**
+ * Sync managed extension packages into ~/.pi/agent/extensions.
+ *
+ * Pi auto-discovers extensions from this directory, so we intentionally do not
+ * run `pi install -l` for these managed packages (prevents double registration).
+ */
+export async function syncManagedPiExtensions({
+    sourceDir,
+    targetDir,
+    dryRun = false,
+    log,
+}: SyncPiExtensionsOptions): Promise<number> {
+    if (!await fs.pathExists(sourceDir)) return 0;
+
+    if (!dryRun) {
+        await fs.ensureDir(path.dirname(targetDir));
+        await fs.copy(sourceDir, targetDir, { overwrite: true });
+    }
+
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+    const managedPackages = entries.filter((entry) => entry.isDirectory()).length;
+
+    if (log) {
+        if (dryRun) {
+            log(`  [DRY RUN] sync extensions ${sourceDir} -> ${targetDir}`);
+        }
+        log(`  Pi will auto-discover ${managedPackages} extension package(s) from ${targetDir}`);
+    }
+
+    return managedPackages;
+}

package/src/utils/worktree-session.ts

@@ -1,8 +1,8 @@
 import kleur from 'kleur';
 import path from 'node:path';
-import fs from 'fs-extra';
-import { execSync, spawnSync } from 'node:child_process';
-import { findRepoRoot } from './repo-root.js';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 
 export interface WorktreeSessionOptions {
     runtime: 'claude' | 'pi';
@@ -13,78 +13,114 @@ function randomSlug(len: number = 4): string {
     return Math.random().toString(36).slice(2, 2 + len);
 }
 
-function shortDate(): string {
-    const d = new Date();
-    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, '0')}${String(d.getDate()).padStart(2, '0')}`;
+function gitRepoRoot(cwd: string): string | null {
+    const r = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd, stdio: 'pipe', encoding: 'utf8',
+    });
+    return r.status === 0 ? (r.stdout ?? '').trim() : null;
 }
 
 /**
  * Launch a Claude or Pi session in a sandboxed git worktree.
  *
- * Worktree path: sibling to CWD, named <cwd-basename>-xt-<runtime>-<shortdate>
+ * Worktree path: inside repo under .xtrm/worktrees/, named <cwd-basename>-xt-<runtime>-<slug>
  * Branch: xt/<name> if name provided, xt/<4-char-random> otherwise
- * Dolt bootstrap: redirect worktree to main's canonical beads db
+ * Beads: bd worktree create sets up canonical .beads/redirect to share the main db
+ */
+
+/**
+ * Resolve the statusline.mjs path: prefer the plugin cache (stays in sync with
+ * plugin version), fall back to ~/.claude/hooks/statusline.mjs.
  */
+function resolveStatuslineScript(): string | null {
+    const pluginsFile = path.join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    try {
+        const plugins = JSON.parse(readFileSync(pluginsFile, 'utf8'));
+        for (const [key, entries] of Object.entries(plugins?.plugins ?? {}) as [string, any[]][]) {
+            if (!key.startsWith('xtrm-tools@') || !entries?.length) continue;
+            const p = path.join(entries[0].installPath, 'hooks', 'statusline.mjs');
+            if (existsSync(p)) return p;
+        }
+    } catch { /* fall through */ }
+    // Fallback: ~/.claude/hooks/statusline.mjs
+    const fallback = path.join(homedir(), '.claude', 'hooks', 'statusline.mjs');
+    return existsSync(fallback) ? fallback : null;
+}
+
 export async function launchWorktreeSession(opts: WorktreeSessionOptions): Promise<void> {
     const { runtime, name } = opts;
     const cwd = process.cwd();
-    const repoRoot = await findRepoRoot();
-    const cwdBasename = path.basename(cwd);
 
-    // Resolve worktree path (sibling to cwd)
-    const date = shortDate();
-    const worktreeName = `${cwdBasename}-xt-${runtime}-${date}`;
-    const worktreePath = path.join(path.dirname(cwd), worktreeName);
+    // Use git to find the user's actual repo root — not xtrm-tools' package root
+    const repoRoot = gitRepoRoot(cwd);
+    if (!repoRoot) {
+        console.error(kleur.red('\n  ✗ Not inside a git repository\n'));
+        process.exit(1);
+    }
+
+    const cwdBasename = path.basename(repoRoot);
+
+    // Resolve slug — shared by both branch and worktree path so they're linked
+    const slug = name ?? randomSlug(4);
 
-    // Resolve branch name
-    const branchName = `xt/${name ?? randomSlug(4)}`;
+    // Worktree path: inside repo under .xtrm/worktrees/
+    const worktreeName = `${cwdBasename}-xt-${runtime}-${slug}`;
+    const worktreePath = path.join(repoRoot, '.xtrm', 'worktrees', worktreeName);
+
+    // Branch name
+    const branchName = `xt/${slug}`;
 
     console.log(kleur.bold(`\n  Launching ${runtime} session`));
     console.log(kleur.dim(`  worktree: ${worktreePath}`));
     console.log(kleur.dim(`  branch:   ${branchName}\n`));
 
-    // Create worktree (create branch if it doesn't exist)
-    const branchExists = spawnSync('git', ['rev-parse', '--verify', branchName], {
-        cwd: repoRoot, stdio: 'pipe',
-    }).status === 0;
-
-    const worktreeArgs = branchExists
-        ? ['worktree', 'add', worktreePath, branchName]
-        : ['worktree', 'add', '-b', branchName, worktreePath];
-
-    const worktreeResult = spawnSync('git', worktreeArgs, { cwd: repoRoot, stdio: 'inherit' });
-    if (worktreeResult.status !== 0) {
-        console.error(kleur.red(`\n  ✗ Failed to create worktree at ${worktreePath}\n`));
-        process.exit(1);
-    }
+    // Use bd worktree create — sets up git worktree + canonical .beads/redirect in one step.
+    // Falls back to plain git worktree add if bd is unavailable or the project has no .beads/.
+    const bdResult = spawnSync('bd', ['worktree', 'create', worktreePath, '--branch', branchName], {
+        cwd: repoRoot, stdio: 'inherit',
+    });
 
-    // Dolt bootstrap: redirect worktree to main's canonical beads db
-    const mainBeadsDir = path.join(repoRoot, '.beads');
-    const worktreeBeadsDir = path.join(worktreePath, '.beads');
-    const mainPortFile = path.join(mainBeadsDir, 'dolt-server.port');
-
-    if (await fs.pathExists(mainBeadsDir)) {
-        const worktreePortFile = path.join(worktreeBeadsDir, 'dolt-server.port');
-
-        // Stop the auto-spawned isolated dolt server in the worktree
-        spawnSync('bd', ['dolt', 'stop'], { cwd: worktreePath, stdio: 'pipe' });
-
-        // Read main checkout's port and write to worktree
-        if (await fs.pathExists(mainPortFile)) {
-            const mainPort = (await fs.readFile(mainPortFile, 'utf8')).trim();
-            await fs.ensureDir(worktreeBeadsDir);
-            await fs.writeFile(worktreePortFile, mainPort, 'utf8');
-            console.log(kleur.dim(`  beads: redirected to main server (port ${mainPort})`));
-        } else {
-            console.log(kleur.dim('  beads: no port file found in main checkout, skipping redirect'));
+    if (bdResult.error || bdResult.status !== 0) {
+        // Fall back to plain git worktree add (bd not found or no .beads/ in project)
+        if (bdResult.status !== 0 && !bdResult.error) {
+            console.log(kleur.dim('  beads: no database found, creating worktree without redirect'));
+        }
+        const branchExists = spawnSync('git', ['rev-parse', '--verify', branchName], {
+            cwd: repoRoot, stdio: 'pipe',
+        }).status === 0;
+
+        const gitArgs = branchExists
+            ? ['worktree', 'add', worktreePath, branchName]
+            : ['worktree', 'add', '-b', branchName, worktreePath];
+
+        const gitResult = spawnSync('git', gitArgs, { cwd: repoRoot, stdio: 'inherit' });
+        if (gitResult.status !== 0) {
+            console.error(kleur.red(`\n  ✗ Failed to create worktree at ${worktreePath}\n`));
+            process.exit(1);
         }
     }
 
     console.log(kleur.green(`\n  ✓ Worktree ready — launching ${runtime}...\n`));
 
+    // Inject statusLine config for claude worktree sessions
+    if (runtime === 'claude') {
+        const statuslinePath = resolveStatuslineScript();
+        if (statuslinePath) {
+            const claudeDir = path.join(worktreePath, '.claude');
+            const localSettingsPath = path.join(claudeDir, 'settings.local.json');
+            try {
+                mkdirSync(claudeDir, { recursive: true });
+                writeFileSync(localSettingsPath, JSON.stringify({
+                    statusLine: { type: 'command', command: `node ${statuslinePath}`, padding: 1 },
+                }, null, 2));
+            } catch { /* non-fatal — statusline is cosmetic */ }
+        }
+    }
+
     // Launch the runtime in the worktree
     const runtimeCmd = runtime === 'claude' ? 'claude' : 'pi';
-    const launchResult = spawnSync(runtimeCmd, [], {
+    const runtimeArgs = runtime === 'claude' ? ['--dangerously-skip-permissions'] : [];
+    const launchResult = spawnSync(runtimeCmd, runtimeArgs, {
         cwd: worktreePath,
         stdio: 'inherit',
     });

package/test/extensions/beads-claim-lifecycle.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import beadsExtension from "../../../config/pi/extensions/beads/index";
+import { SubprocessRunner } from "../../../config/pi/extensions/core/lib";
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+	isToolCallEventType: (name: string, event: any) => event?.toolName === name,
+	isBashToolResult: (event: any) => event?.toolName === "bash",
+}));
+
+vi.mock("../../../config/pi/extensions/core/lib", async () => {
+	const actual = await vi.importActual<any>("../../../config/pi/extensions/core/lib");
+	return {
+		...actual,
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isBeadsProject: vi.fn(() => true),
+			isMutatingFileTool: vi.fn((event: any) => event?.toolName === "write"),
+			parseBdCounts: vi.fn(() => ({ open: 2, inProgress: 0 })),
+		},
+	};
+});
+
+describe("Pi beads claim lifecycle", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		harness.pi.sendUserMessage = vi.fn();
+	});
+
+	it("clears stale claim and blocks edits until a fresh claim is made", async () => {
+		const calls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			calls.push(args);
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "xtrm-old\n", stderr: "" };
+			if (args[0] === "show") return { code: 0, stdout: JSON.stringify({ id: "xtrm-old", status: "closed" }), stderr: "" };
+			if (args[0] === "list") return { code: 0, stdout: "Total: 2 issues (2 open, 0 in progress)", stderr: "" };
+			if (args[0] === "kv" && args[1] === "clear") return { code: 0, stdout: "", stderr: "" };
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(calls.some((a) => a[0] === "kv" && a[1] === "clear" && `${a[2]}`.startsWith("claimed:"))).toBe(true);
+		expect(result?.block).toBe(true);
+		expect(result?.reason).toContain("No active claim");
+	});
+
+	it("does not block commit when claim is stale/closed", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "xtrm-old\n", stderr: "" };
+			if (args[0] === "show") return { code: 0, stdout: JSON.stringify({ id: "xtrm-old", status: "closed" }), stderr: "" };
+			if (args[0] === "kv" && args[1] === "clear") return { code: 0, stdout: "", stderr: "" };
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "git commit -m 'test'" },
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it("blocks commit when active claimed issue is still in progress", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (_cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "xtrm-live\n", stderr: "" };
+			if (args[0] === "show") return { code: 0, stdout: JSON.stringify({ id: "xtrm-live", status: "in_progress" }), stderr: "" };
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "git commit -m 'test'" },
+		});
+
+		expect(result?.block).toBe(true);
+		expect(result?.reason).toContain("Active claim [xtrm-live]");
+	});
+});