@gotgenes/pi-subagents 1.0.0

package/dist/ui/conversation-viewer.js

@@ -0,0 +1,252 @@
+/**
+ * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ *
+ * Displays a scrollable, live-updating view of an agent's conversation.
+ * Subscribes to session events for real-time streaming updates.
+ */
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { extractText } from "../context.js";
+import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
+import { buildInvocationTags, describeActivity, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.js";
+/** Base lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
+const CHROME_LINES_BASE = 6;
+const MIN_VIEWPORT = 3;
+/** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
+export const VIEWPORT_HEIGHT_PCT = 70;
+export class ConversationViewer {
+    tui;
+    session;
+    record;
+    activity;
+    theme;
+    done;
+    scrollOffset = 0;
+    autoScroll = true;
+    unsubscribe;
+    lastInnerW = 0;
+    closed = false;
+    constructor(tui, session, record, activity, theme, done) {
+        this.tui = tui;
+        this.session = session;
+        this.record = record;
+        this.activity = activity;
+        this.theme = theme;
+        this.done = done;
+        this.unsubscribe = session.subscribe(() => {
+            if (this.closed)
+                return;
+            this.tui.requestRender();
+        });
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+            this.closed = true;
+            this.done(undefined);
+            return;
+        }
+        const totalLines = this.buildContentLines(this.lastInnerW).length;
+        const viewportHeight = this.viewportHeight();
+        const maxScroll = Math.max(0, totalLines - viewportHeight);
+        if (matchesKey(data, "up") || matchesKey(data, "k")) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "down") || matchesKey(data, "j")) {
+            this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "pageUp") || matchesKey(data, "shift+up")) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - viewportHeight);
+            this.autoScroll = false;
+        }
+        else if (matchesKey(data, "pageDown") || matchesKey(data, "shift+down")) {
+            this.scrollOffset = Math.min(maxScroll, this.scrollOffset + viewportHeight);
+            this.autoScroll = this.scrollOffset >= maxScroll;
+        }
+        else if (matchesKey(data, "home")) {
+            this.scrollOffset = 0;
+            this.autoScroll = false;
+        }
+        else if (matchesKey(data, "end")) {
+            this.scrollOffset = maxScroll;
+            this.autoScroll = true;
+        }
+    }
+    render(width) {
+        if (width < 6)
+            return []; // too narrow for any meaningful rendering
+        const th = this.theme;
+        const innerW = width - 4; // border + padding
+        this.lastInnerW = innerW;
+        const lines = [];
+        const pad = (s, len) => {
+            const vis = visibleWidth(s);
+            return s + " ".repeat(Math.max(0, len - vis));
+        };
+        const row = (content) => th.fg("border", "│") + " " + truncateToWidth(pad(content, innerW), innerW) + " " + th.fg("border", "│");
+        const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`);
+        const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`);
+        const hrMid = row(th.fg("dim", "─".repeat(innerW)));
+        // Header
+        lines.push(hrTop);
+        const name = getDisplayName(this.record.type);
+        const modeLabel = getPromptModeLabel(this.record.type);
+        const modeTag = modeLabel ? ` ${th.fg("dim", `(${modeLabel})`)}` : "";
+        const statusIcon = this.record.status === "running"
+            ? th.fg("accent", "●")
+            : this.record.status === "completed"
+                ? th.fg("success", "✓")
+                : this.record.status === "error"
+                    ? th.fg("error", "✗")
+                    : th.fg("dim", "○");
+        const duration = formatDuration(this.record.startedAt, this.record.completedAt);
+        const headerParts = [duration];
+        const toolUses = this.activity?.toolUses ?? this.record.toolUses;
+        if (toolUses > 0)
+            headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
+        const tokens = getLifetimeTotal(this.activity?.lifetimeUsage);
+        if (tokens > 0) {
+            const percent = getSessionContextPercent(this.activity?.session);
+            headerParts.push(formatSessionTokens(tokens, percent, th, this.record.compactionCount));
+        }
+        lines.push(row(`${statusIcon} ${th.bold(name)}${modeTag}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${th.fg("dim", headerParts.join(" · "))}`));
+        const invocationLine = this.invocationLine();
+        if (invocationLine)
+            lines.push(row(invocationLine));
+        lines.push(hrMid);
+        // Content area — rebuild every render (live data, no cache needed)
+        const contentLines = this.buildContentLines(innerW);
+        const viewportHeight = this.viewportHeight();
+        const maxScroll = Math.max(0, contentLines.length - viewportHeight);
+        if (this.autoScroll) {
+            this.scrollOffset = maxScroll;
+        }
+        const visibleStart = Math.min(this.scrollOffset, maxScroll);
+        const visible = contentLines.slice(visibleStart, visibleStart + viewportHeight);
+        for (let i = 0; i < viewportHeight; i++) {
+            lines.push(row(visible[i] ?? ""));
+        }
+        // Footer
+        lines.push(hrMid);
+        const scrollPct = contentLines.length <= viewportHeight
+            ? "100%"
+            : `${Math.round(((visibleStart + viewportHeight) / contentLines.length) * 100)}%`;
+        const footerLeft = th.fg("dim", `${contentLines.length} lines · ${scrollPct}`);
+        const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn or Shift+↑↓ · Esc close");
+        const footerGap = Math.max(1, innerW - visibleWidth(footerLeft) - visibleWidth(footerRight));
+        lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight));
+        lines.push(hrBot);
+        return lines;
+    }
+    invalidate() { }
+    dispose() {
+        this.closed = true;
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = undefined;
+        }
+    }
+    // ---- Private ----
+    viewportHeight() {
+        // Cap mirrors the overlay's maxHeight — otherwise the viewer would render
+        // more lines than the overlay shows and clip the footer.
+        const maxRows = Math.floor((this.tui.terminal.rows * VIEWPORT_HEIGHT_PCT) / 100);
+        return Math.max(MIN_VIEWPORT, maxRows - this.chromeLines());
+    }
+    chromeLines() {
+        return CHROME_LINES_BASE + (this.invocationLine() ? 1 : 0);
+    }
+    invocationLine() {
+        const { modelName, tags } = buildInvocationTags(this.record.invocation);
+        const parts = modelName ? [modelName, ...tags] : tags;
+        if (parts.length === 0)
+            return undefined;
+        return this.theme.fg("dim", `  ↳ ${parts.join(" · ")}`);
+    }
+    buildContentLines(width) {
+        if (width <= 0)
+            return [];
+        const th = this.theme;
+        const messages = this.session.messages;
+        const lines = [];
+        if (messages.length === 0) {
+            lines.push(th.fg("dim", "(waiting for first message...)"));
+            return lines;
+        }
+        let needsSeparator = false;
+        for (const msg of messages) {
+            if (msg.role === "user") {
+                const text = typeof msg.content === "string"
+                    ? msg.content
+                    : extractText(msg.content);
+                if (!text.trim())
+                    continue;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.fg("accent", "[User]"));
+                for (const line of wrapTextWithAnsi(text.trim(), width)) {
+                    lines.push(line);
+                }
+            }
+            else if (msg.role === "assistant") {
+                const textParts = [];
+                const toolCalls = [];
+                for (const c of msg.content) {
+                    if (c.type === "text" && c.text)
+                        textParts.push(c.text);
+                    else if (c.type === "toolCall") {
+                        toolCalls.push(c.name ?? c.toolName ?? "unknown");
+                    }
+                }
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.bold("[Assistant]"));
+                if (textParts.length > 0) {
+                    for (const line of wrapTextWithAnsi(textParts.join("\n").trim(), width)) {
+                        lines.push(line);
+                    }
+                }
+                for (const name of toolCalls) {
+                    lines.push(truncateToWidth(th.fg("muted", `  [Tool: ${name}]`), width));
+                }
+            }
+            else if (msg.role === "toolResult") {
+                const text = extractText(msg.content);
+                const truncated = text.length > 500 ? text.slice(0, 500) + "... (truncated)" : text;
+                if (!truncated.trim())
+                    continue;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(th.fg("dim", "[Result]"));
+                for (const line of wrapTextWithAnsi(truncated.trim(), width)) {
+                    lines.push(th.fg("dim", line));
+                }
+            }
+            else if (msg.role === "bashExecution") {
+                const bash = msg;
+                if (needsSeparator)
+                    lines.push(th.fg("dim", "───"));
+                lines.push(truncateToWidth(th.fg("muted", `  $ ${bash.command}`), width));
+                if (bash.output?.trim()) {
+                    const out = bash.output.length > 500
+                        ? bash.output.slice(0, 500) + "... (truncated)"
+                        : bash.output;
+                    for (const line of wrapTextWithAnsi(out.trim(), width)) {
+                        lines.push(th.fg("dim", line));
+                    }
+                }
+            }
+            else {
+                continue;
+            }
+            needsSeparator = true;
+        }
+        // Streaming indicator for running agents
+        if (this.record.status === "running" && this.activity) {
+            const act = describeActivity(this.activity.activeTools, this.activity.responseText);
+            lines.push("");
+            lines.push(truncateToWidth(th.fg("accent", "▍ ") + th.fg("dim", act), width));
+        }
+        return lines.map(l => truncateToWidth(l, width));
+    }
+}

package/dist/ui/schedule-menu.d.ts

@@ -0,0 +1,16 @@
+/**
+ * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
+ *
+ * Minimal v1 surface: list scheduled jobs, select one to inspect details +
+ * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
+ * is the canonical creation path), no toggle/cleanup (cancel is enough for
+ * "I scheduled something dumb, get rid of it"). Add management surfaces here
+ * if real demand emerges.
+ */
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { SubagentScheduler } from "../schedule.js";
+/**
+ * List scheduled jobs; selecting one opens a cancel-confirm with details.
+ * Returns when the user backs out or after a cancellation.
+ */
+export declare function showSchedulesMenu(ctx: ExtensionCommandContext, scheduler: SubagentScheduler): Promise<void>;

package/dist/ui/schedule-menu.js

@@ -0,0 +1,95 @@
+/**
+ * schedule-menu.ts — `/agents → Scheduled jobs` submenu.
+ *
+ * Minimal v1 surface: list scheduled jobs, select one to inspect details +
+ * confirm cancellation. No create wizard (the `Agent` tool's `schedule` param
+ * is the canonical creation path), no toggle/cleanup (cancel is enough for
+ * "I scheduled something dumb, get rid of it"). Add management surfaces here
+ * if real demand emerges.
+ */
+/** Format an ISO timestamp as relative time ("in 4h", "2d ago", "—"). */
+function relTime(iso, now = Date.now()) {
+    if (!iso)
+        return "—";
+    const t = new Date(iso).getTime();
+    if (Number.isNaN(t))
+        return "—";
+    const diff = t - now;
+    const abs = Math.abs(diff);
+    const future = diff > 0;
+    if (abs < 60_000)
+        return future ? "in <1m" : "<1m ago";
+    const m = Math.round(abs / 60_000);
+    if (m < 60)
+        return future ? `in ${m}m` : `${m}m ago`;
+    const h = Math.round(abs / 3_600_000);
+    if (h < 24)
+        return future ? `in ${h}h` : `${h}h ago`;
+    const d = Math.round(abs / 86_400_000);
+    return future ? `in ${d}d` : `${d}d ago`;
+}
+/** One-line status icon. */
+function statusIcon(j) {
+    if (!j.enabled)
+        return "✗";
+    if (j.lastStatus === "error")
+        return "!";
+    if (j.lastStatus === "running")
+        return "⋯";
+    return "✓";
+}
+/** Compact selectable row — name, schedule, agent type, next/last run, count. */
+function formatJob(j, scheduler) {
+    const next = scheduler.getNextRun(j.id);
+    return [
+        statusIcon(j),
+        j.name.padEnd(18).slice(0, 18),
+        j.schedule.padEnd(14).slice(0, 14),
+        `[${j.subagent_type}]`,
+        `next ${relTime(next)}`,
+        `last ${relTime(j.lastRun)}`,
+        `runs ${j.runCount}`,
+    ].join("  ");
+}
+/** Multi-line details block for the cancel confirm. */
+function formatDetails(j, scheduler) {
+    const next = scheduler.getNextRun(j.id) ?? "—";
+    return [
+        `name:      ${j.name}`,
+        `schedule:  ${j.schedule} (${j.scheduleType})`,
+        `agent:     ${j.subagent_type}`,
+        `prompt:    ${j.prompt.slice(0, 200)}${j.prompt.length > 200 ? "…" : ""}`,
+        `created:   ${j.createdAt}`,
+        `last run:  ${j.lastRun ?? "—"} (${j.lastStatus ?? "—"})`,
+        `next run:  ${next}`,
+        `runs:      ${j.runCount}`,
+    ].join("\n");
+}
+/**
+ * List scheduled jobs; selecting one opens a cancel-confirm with details.
+ * Returns when the user backs out or after a cancellation.
+ */
+export async function showSchedulesMenu(ctx, scheduler) {
+    if (!scheduler.isActive()) {
+        ctx.ui.notify("Scheduler is not active in this session.", "warning");
+        return;
+    }
+    const jobs = scheduler.list();
+    if (jobs.length === 0) {
+        ctx.ui.notify("No scheduled jobs.", "info");
+        return;
+    }
+    const labels = jobs.map(j => formatJob(j, scheduler));
+    const choice = await ctx.ui.select(`Scheduled jobs (${jobs.length}) — select to cancel`, labels);
+    if (!choice)
+        return;
+    const idx = labels.indexOf(choice);
+    if (idx < 0)
+        return;
+    const job = jobs[idx];
+    const ok = await ctx.ui.confirm(`Cancel "${job.name}"?`, formatDetails(job, scheduler));
+    if (!ok)
+        return;
+    scheduler.removeJob(job.id);
+    ctx.ui.notify(`Cancelled "${job.name}".`, "info");
+}

package/dist/usage.d.ts

@@ -0,0 +1,50 @@
+/** usage.ts — Token usage: shapes, accumulator operators, session-stats readers. */
+/**
+ * Lifetime usage components, accumulated via `message_end` events. Survives
+ * compaction (which replaces session.state.messages and would reset any
+ * stats-derived sum). cacheRead is excluded because each turn's cacheRead is
+ * the cumulative cached prefix re-read on that one call — summing across
+ * turns counts the prefix N times. See issue #38.
+ */
+export type LifetimeUsage = {
+    input: number;
+    output: number;
+    cacheWrite: number;
+};
+/** Sum of lifetime usage components, or 0 if undefined. */
+export declare function getLifetimeTotal(u?: LifetimeUsage): number;
+/** Add a usage delta into a target accumulator (mutates target). */
+export declare function addUsage(into: LifetimeUsage, delta: LifetimeUsage): void;
+/** Minimal shape we read from upstream `getSessionStats()`. */
+export type SessionStatsLike = {
+    tokens: {
+        input: number;
+        output: number;
+        cacheWrite: number;
+    };
+    contextUsage?: {
+        percent: number | null;
+    };
+};
+export type SessionLike = {
+    getSessionStats(): SessionStatsLike;
+};
+/**
+ * Session-scoped token count: input + output + cacheWrite as reported by
+ * upstream `getSessionStats().tokens` for the *current* session window.
+ *
+ * RESETS at compaction — upstream replaces `session.state.messages` and the
+ * stats are derived from that array. For a lifetime total that survives
+ * compaction, use `getLifetimeTotal(lifetimeUsage)` instead, which reads
+ * from an independent accumulator fed by `message_end` events.
+ *
+ * Avoids upstream's `tokens.total` field, which sums per-turn `cacheRead`
+ * and so counts the cumulative cached prefix N times across N turns
+ * (issue #38).
+ */
+export declare function getSessionTokens(session: SessionLike | undefined): number;
+/**
+ * Context-window utilization (0–100), or null when unavailable
+ * (no model contextWindow, or post-compaction before the next response).
+ */
+export declare function getSessionContextPercent(session: SessionLike | undefined): number | null;

package/dist/usage.js

@@ -0,0 +1,49 @@
+/** usage.ts — Token usage: shapes, accumulator operators, session-stats readers. */
+/** Sum of lifetime usage components, or 0 if undefined. */
+export function getLifetimeTotal(u) {
+    return u ? u.input + u.output + u.cacheWrite : 0;
+}
+/** Add a usage delta into a target accumulator (mutates target). */
+export function addUsage(into, delta) {
+    into.input += delta.input;
+    into.output += delta.output;
+    into.cacheWrite += delta.cacheWrite;
+}
+/**
+ * Session-scoped token count: input + output + cacheWrite as reported by
+ * upstream `getSessionStats().tokens` for the *current* session window.
+ *
+ * RESETS at compaction — upstream replaces `session.state.messages` and the
+ * stats are derived from that array. For a lifetime total that survives
+ * compaction, use `getLifetimeTotal(lifetimeUsage)` instead, which reads
+ * from an independent accumulator fed by `message_end` events.
+ *
+ * Avoids upstream's `tokens.total` field, which sums per-turn `cacheRead`
+ * and so counts the cumulative cached prefix N times across N turns
+ * (issue #38).
+ */
+export function getSessionTokens(session) {
+    if (!session)
+        return 0;
+    try {
+        const t = session.getSessionStats().tokens;
+        return t.input + t.output + t.cacheWrite;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Context-window utilization (0–100), or null when unavailable
+ * (no model contextWindow, or post-compaction before the next response).
+ */
+export function getSessionContextPercent(session) {
+    if (!session)
+        return null;
+    try {
+        return session.getSessionStats().contextUsage?.percent ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/worktree.d.ts

@@ -0,0 +1,36 @@
+/**
+ * worktree.ts — Git worktree isolation for agents.
+ *
+ * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
+ * On completion, if no changes were made, the worktree is cleaned up.
+ * If changes exist, a branch is created and returned in the result.
+ */
+export interface WorktreeInfo {
+    /** Absolute path to the worktree directory. */
+    path: string;
+    /** Branch name created for this worktree (if changes exist). */
+    branch: string;
+}
+export interface WorktreeCleanupResult {
+    /** Whether changes were found in the worktree. */
+    hasChanges: boolean;
+    /** Branch name if changes were committed. */
+    branch?: string;
+    /** Worktree path if it was kept. */
+    path?: string;
+}
+/**
+ * Create a temporary git worktree for an agent.
+ * Returns the worktree path, or undefined if not in a git repo.
+ */
+export declare function createWorktree(cwd: string, agentId: string): WorktreeInfo | undefined;
+/**
+ * Clean up a worktree after agent completion.
+ * - If no changes: remove worktree entirely.
+ * - If changes exist: create a branch, commit changes, return branch info.
+ */
+export declare function cleanupWorktree(cwd: string, worktree: WorktreeInfo, agentDescription: string): WorktreeCleanupResult;
+/**
+ * Prune any orphaned worktrees (crash recovery).
+ */
+export declare function pruneWorktrees(cwd: string): void;

package/dist/worktree.js

@@ -0,0 +1,139 @@
+/**
+ * worktree.ts — Git worktree isolation for agents.
+ *
+ * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
+ * On completion, if no changes were made, the worktree is cleaned up.
+ * If changes exist, a branch is created and returned in the result.
+ */
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Create a temporary git worktree for an agent.
+ * Returns the worktree path, or undefined if not in a git repo.
+ */
+export function createWorktree(cwd, agentId) {
+    // Verify we're in a git repo with at least one commit (HEAD must exist)
+    try {
+        execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe", timeout: 5000 });
+        execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: "pipe", timeout: 5000 });
+    }
+    catch {
+        return undefined;
+    }
+    const branch = `pi-agent-${agentId}`;
+    const suffix = randomUUID().slice(0, 8);
+    const worktreePath = join(tmpdir(), `pi-agent-${agentId}-${suffix}`);
+    try {
+        // Create detached worktree at HEAD
+        execFileSync("git", ["worktree", "add", "--detach", worktreePath, "HEAD"], {
+            cwd,
+            stdio: "pipe",
+            timeout: 30000,
+        });
+        return { path: worktreePath, branch };
+    }
+    catch {
+        // If worktree creation fails, return undefined (agent runs in normal cwd)
+        return undefined;
+    }
+}
+/**
+ * Clean up a worktree after agent completion.
+ * - If no changes: remove worktree entirely.
+ * - If changes exist: create a branch, commit changes, return branch info.
+ */
+export function cleanupWorktree(cwd, worktree, agentDescription) {
+    if (!existsSync(worktree.path)) {
+        return { hasChanges: false };
+    }
+    try {
+        // Check for uncommitted changes in the worktree
+        const status = execFileSync("git", ["status", "--porcelain"], {
+            cwd: worktree.path,
+            stdio: "pipe",
+            timeout: 10000,
+        }).toString().trim();
+        if (!status) {
+            // No changes — remove worktree
+            removeWorktree(cwd, worktree.path);
+            return { hasChanges: false };
+        }
+        // Changes exist — stage, commit, and create a branch
+        execFileSync("git", ["add", "-A"], { cwd: worktree.path, stdio: "pipe", timeout: 10000 });
+        // Truncate description for commit message (no shell sanitization needed — execFileSync uses argv)
+        const safeDesc = agentDescription.slice(0, 200);
+        const commitMsg = `pi-agent: ${safeDesc}`;
+        execFileSync("git", ["commit", "-m", commitMsg], {
+            cwd: worktree.path,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        // Create a branch pointing to the worktree's HEAD.
+        // If the branch already exists, append a suffix to avoid overwriting previous work.
+        let branchName = worktree.branch;
+        try {
+            execFileSync("git", ["branch", branchName], {
+                cwd: worktree.path,
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        catch {
+            // Branch already exists — use a unique suffix
+            branchName = `${worktree.branch}-${Date.now()}`;
+            execFileSync("git", ["branch", branchName], {
+                cwd: worktree.path,
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        // Update branch name in worktree info for the caller
+        worktree.branch = branchName;
+        // Remove the worktree (branch persists in main repo)
+        removeWorktree(cwd, worktree.path);
+        return {
+            hasChanges: true,
+            branch: worktree.branch,
+            path: worktree.path,
+        };
+    }
+    catch {
+        // Best effort cleanup on error
+        try {
+            removeWorktree(cwd, worktree.path);
+        }
+        catch { /* ignore */ }
+        return { hasChanges: false };
+    }
+}
+/**
+ * Force-remove a worktree.
+ */
+function removeWorktree(cwd, worktreePath) {
+    try {
+        execFileSync("git", ["worktree", "remove", "--force", worktreePath], {
+            cwd,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+    }
+    catch {
+        // If git worktree remove fails, try pruning
+        try {
+            execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Prune any orphaned worktrees (crash recovery).
+ */
+export function pruneWorktrees(cwd) {
+    try {
+        execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+    }
+    catch { /* ignore */ }
+}