@gotgenes/pi-subagents 1.0.0 → 1.0.2

package/docs/plans/0051-update-adr-0001-hard-fork.md

@@ -0,0 +1,74 @@
+---
+issue: 51
+issue_title: "docs: update ADR 0001 to reflect hard-fork decision"
+---
+
+# Update ADR 0001 to reflect hard-fork decision
+
+## Problem Statement
+
+ADR 0001 (`docs/decisions/0001-deferred-patches.md`) was written when the fork was a thin-patch layer over `tintinweb/pi-subagents`.
+The new architecture document (`docs/architecture/architecture.md`) commits to a hard fork with material scope reduction — scheduling removal, a `SubagentsAPI` boundary, `index.ts` decomposition, and more.
+
+Several claims in ADR 0001 are now outdated:
+
+1. The status is "accepted" but the decision has been superseded by the architecture doc.
+2. The Upstream PRs section states "the fork's divergence reduces to package naming and tooling," which is no longer true.
+3. The Consequences → Operational section implies that merging the upstream PRs eliminates behavioral divergence, which no longer holds.
+
+## Goals
+
+- Add a supersession note to ADR 0001 pointing to `docs/architecture/architecture.md`.
+- Update the "Upstream PRs are open" subsection so the "divergence reduces to…" claim reflects reality.
+- Update the Consequences → Operational section to note intentional divergence per the architecture document.
+- Preserve all existing rationale — no information is removed.
+
+## Non-Goals
+
+- Rewriting the ADR from scratch — the original context is still useful.
+- Updating the architecture document itself.
+- Any code changes.
+
+## Background
+
+ADR 0001 has YAML frontmatter (`status: accepted`, `date: 2026-05-11`) and follows a standard ADR structure: Status, Context, Decision, Consequences.
+
+The architecture document (`docs/architecture/architecture.md`) describes a six-phase plan that materially diverges from upstream: scheduling removal, ad-hoc RPC replacement, group-join and output-file removal, a typed `SubagentsAPI` boundary, and `index.ts` decomposition.
+
+The three upstream PRs (#71, #72, #73) are still open and factually accurate — that section just needs the concluding sentence revised.
+
+## Design Overview
+
+The update touches three areas of the ADR:
+
+1. **Frontmatter + Status section** — change `status: accepted` to `status: superseded` in frontmatter, and update the Status section body to read "Superseded" with a pointer to `docs/architecture/architecture.md`.
+2. **"Upstream PRs are open" subsection** — keep the PR list and factual statements intact; revise the final sentence ("Once these land upstream, the fork's divergence reduces to package naming and tooling.") to note that the fork now diverges intentionally beyond those patches, per the architecture document.
+3. **Consequences → Operational** — add a sentence noting that the fork diverges intentionally beyond patches, and that the architecture document governs the fork's direction going forward. Keep the existing bullet about upstream PRs.
+
+No structural changes (new sections, removed sections, reordered content).
+
+## Module-Level Changes
+
+| File                                      | Change                                                                                                                                                                                    |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `docs/decisions/0001-deferred-patches.md` | Update frontmatter `status` from `accepted` to `superseded`; revise Status section; revise closing sentence in "Upstream PRs are open"; add divergence note to Consequences → Operational |
+
+## Test Impact Analysis
+
+No tests are affected — this is a docs-only change.
+
+## TDD Order
+
+1. Update ADR 0001 with all four edits described above.
+   Commit: `docs: update ADR 0001 to reflect hard-fork decision (#51)`
+
+## Risks and Mitigations
+
+| Risk                                           | Mitigation                                                                                                           |
+| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| Supersession note makes the ADR look stale     | Keep all original rationale intact; the note clarifies evolution, not obsolescence                                   |
+| Wording drift between ADR and architecture doc | Use a direct pointer (`docs/architecture/architecture.md`) rather than paraphrasing the architecture doc's decisions |
+
+## Open Questions
+
+None — the issue's acceptance criteria are unambiguous.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-subagents",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A pi extension that brings Claude Code-style autonomous sub-agents to pi. Friendly fork of @tintinweb/pi-subagents.",
   "author": {
     "name": "Chris Lasher"
@@ -8,11 +8,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gotgenes/pi-subagents.git"
+    "url": "git+https://github.com/gotgenes/pi-packages.git",
+    "directory": "packages/pi-subagents"
   },
-  "homepage": "https://github.com/gotgenes/pi-subagents#readme",
+  "homepage": "https://github.com/gotgenes/pi-packages/tree/main/packages/pi-subagents#readme",
   "bugs": {
-    "url": "https://github.com/gotgenes/pi-subagents/issues"
+    "url": "https://github.com/gotgenes/pi-packages/issues"
   },
   "keywords": [
     "pi-package",
@@ -40,10 +41,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.14",
-    "@types/node": "^25.5.0",
-    "markdownlint-cli2": "^0.22.1",
-    "typescript": "^6.0.0",
-    "vitest": "^4.0.18"
+    "@types/node": "^25.6.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5",
+    "rumdl": "^0.1.93"
   },
   "pi": {
     "extensions": [
@@ -53,16 +54,10 @@
     "image": "https://github.com/gotgenes/pi-subagents/raw/main/media/screenshot.png"
   },
   "scripts": {
-    "build": "tsc",
+    "check": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "lint": "biome check src/ test/",
-    "lint:fix": "biome check --fix src/ test/",
-    "lint:md": "markdownlint-cli2 '*.md' 'docs/**/*.md'",
-    "lint:md:fix": "markdownlint-cli2 --fix '*.md' 'docs/**/*.md'",
-    "lint:all": "pnpm run lint && pnpm run lint:md",
-    "format": "biome format --write src/ test/",
-    "check": "pnpm run build && pnpm run lint:all && pnpm run test"
+    "lint:md": "rumdl check '*.md' 'docs/**/*.md'",
+    "lint": "biome check . && pnpm run lint:md"
   }
 }

package/.markdownlint-cli2.yaml

@@ -1,19 +0,0 @@
-# CHANGELOG.md is machine-generated by release-please. Its double blank lines
-# between sections are intentional; exclude it from linting entirely.
-#
-# README.md is largely the upstream tintinweb/pi-subagents README — we
-# preserve the original copy as-is and add a "Fork notice" block at the top
-# rather than reformatting the entire document.
-ignores:
-  - "CHANGELOG.md"
-  - "README.md"
-
-config:
-  line-length: false
-  no-duplicate-heading:
-    siblings_only: true
-  no-inline-html:
-    allowed_elements:
-      - p
-      - img
-  first-line-heading: false

package/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.0.0"
-}

package/dist/agent-manager.d.ts

@@ -1,108 +0,0 @@
-/**
- * agent-manager.ts — Tracks agents, background execution, resume support.
- *
- * Background agents are subject to a configurable concurrency limit (default: 4).
- * Excess agents are queued and auto-started as running agents complete.
- * Foreground agents bypass the queue (they block the parent anyway).
- */
-import type { Model } from "@earendil-works/pi-ai";
-import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type ToolActivity } from "./agent-runner.js";
-import type { AgentInvocation, AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
-export type OnAgentComplete = (record: AgentRecord) => void;
-export type OnAgentStart = (record: AgentRecord) => void;
-export type OnAgentCompact = (record: AgentRecord, info: CompactionInfo) => void;
-export type CompactionInfo = {
-    reason: "manual" | "threshold" | "overflow";
-    tokensBefore: number;
-};
-interface SpawnOptions {
-    description: string;
-    model?: Model<any>;
-    maxTurns?: number;
-    isolated?: boolean;
-    inheritContext?: boolean;
-    thinkingLevel?: ThinkingLevel;
-    isBackground?: boolean;
-    /**
-     * Skip the maxConcurrent queue check for this spawn — start immediately even
-     * if the configured concurrency limit would otherwise queue it. Used by the
-     * scheduler so a fired job can't be deferred past its trigger window.
-     */
-    bypassQueue?: boolean;
-    /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
-    isolation?: IsolationMode;
-    /** Resolved invocation snapshot captured for UI display. */
-    invocation?: AgentInvocation;
-    /** Parent abort signal — when aborted, the subagent is also stopped. */
-    signal?: AbortSignal;
-    /** Called on tool start/end with activity info (for streaming progress to UI). */
-    onToolActivity?: (activity: ToolActivity) => void;
-    /** Called on streaming text deltas from the assistant response. */
-    onTextDelta?: (delta: string, fullText: string) => void;
-    /** Called when the agent session is created (for accessing session stats). */
-    onSessionCreated?: (session: AgentSession) => void;
-    /** Called at the end of each agentic turn with the cumulative count. */
-    onTurnEnd?: (turnCount: number) => void;
-    /** Called once per assistant message_end with that message's usage delta. */
-    onAssistantUsage?: (usage: {
-        input: number;
-        output: number;
-        cacheWrite: number;
-    }) => void;
-    /** Called when the session successfully compacts. */
-    onCompaction?: (info: CompactionInfo) => void;
-}
-export declare class AgentManager {
-    private agents;
-    private cleanupInterval;
-    private onComplete?;
-    private onStart?;
-    private onCompact?;
-    private maxConcurrent;
-    /** Queue of background agents waiting to start. */
-    private queue;
-    /** Number of currently running background agents. */
-    private runningBackground;
-    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart, onCompact?: OnAgentCompact);
-    /** Update the max concurrent background agents limit. */
-    setMaxConcurrent(n: number): void;
-    getMaxConcurrent(): number;
-    /**
-     * Spawn an agent and return its ID immediately (for background use).
-     * If the concurrency limit is reached, the agent is queued.
-     */
-    spawn(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: SpawnOptions): string;
-    /** Actually start an agent (called immediately or from queue drain). */
-    private startAgent;
-    /** Start queued agents up to the concurrency limit. */
-    private drainQueue;
-    /**
-     * Spawn an agent and wait for completion (foreground use).
-     * Foreground agents bypass the concurrency queue.
-     */
-    spawnAndWait(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: Omit<SpawnOptions, "isBackground">): Promise<AgentRecord>;
-    /**
-     * Resume an existing agent session with a new prompt.
-     */
-    resume(id: string, prompt: string, signal?: AbortSignal): Promise<AgentRecord | undefined>;
-    getRecord(id: string): AgentRecord | undefined;
-    listAgents(): AgentRecord[];
-    abort(id: string): boolean;
-    /** Dispose a record's session and remove it from the map. */
-    private removeRecord;
-    private cleanup;
-    /**
-     * Remove all completed/stopped/errored records immediately.
-     * Called on session start/switch so tasks from a prior session don't persist.
-     */
-    clearCompleted(): void;
-    /** Whether any agents are still running or queued. */
-    hasRunning(): boolean;
-    /** Abort all running and queued agents immediately. */
-    abortAll(): number;
-    /** Wait for all running and queued agents to complete (including queued ones). */
-    waitForAll(): Promise<void>;
-    dispose(): void;
-}
-export {};

package/dist/agent-manager.js

@@ -1,390 +0,0 @@
-/**
- * agent-manager.ts — Tracks agents, background execution, resume support.
- *
- * Background agents are subject to a configurable concurrency limit (default: 4).
- * Excess agents are queued and auto-started as running agents complete.
- * Foreground agents bypass the queue (they block the parent anyway).
- */
-import { randomUUID } from "node:crypto";
-import { resumeAgent, runAgent } from "./agent-runner.js";
-import { addUsage } from "./usage.js";
-import { cleanupWorktree, createWorktree, pruneWorktrees, } from "./worktree.js";
-/** Default max concurrent background agents. */
-const DEFAULT_MAX_CONCURRENT = 4;
-export class AgentManager {
-    agents = new Map();
-    cleanupInterval;
-    onComplete;
-    onStart;
-    onCompact;
-    maxConcurrent;
-    /** Queue of background agents waiting to start. */
-    queue = [];
-    /** Number of currently running background agents. */
-    runningBackground = 0;
-    constructor(onComplete, maxConcurrent = DEFAULT_MAX_CONCURRENT, onStart, onCompact) {
-        this.onComplete = onComplete;
-        this.onStart = onStart;
-        this.onCompact = onCompact;
-        this.maxConcurrent = maxConcurrent;
-        // Cleanup completed agents after 10 minutes (but keep sessions for resume)
-        this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
-        this.cleanupInterval.unref();
-    }
-    /** Update the max concurrent background agents limit. */
-    setMaxConcurrent(n) {
-        this.maxConcurrent = Math.max(1, n);
-        // Start queued agents if the new limit allows
-        this.drainQueue();
-    }
-    getMaxConcurrent() {
-        return this.maxConcurrent;
-    }
-    /**
-     * Spawn an agent and return its ID immediately (for background use).
-     * If the concurrency limit is reached, the agent is queued.
-     */
-    spawn(pi, ctx, type, prompt, options) {
-        const id = randomUUID().slice(0, 17);
-        const abortController = new AbortController();
-        const record = {
-            id,
-            type,
-            description: options.description,
-            status: options.isBackground ? "queued" : "running",
-            toolUses: 0,
-            startedAt: Date.now(),
-            abortController,
-            lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-            compactionCount: 0,
-            invocation: options.invocation,
-        };
-        this.agents.set(id, record);
-        const args = { pi, ctx, type, prompt, options };
-        if (options.isBackground && !options.bypassQueue && this.runningBackground >= this.maxConcurrent) {
-            // Queue it — will be started when a running agent completes
-            this.queue.push({ id, args });
-            return id;
-        }
-        // startAgent can throw (e.g. strict worktree-isolation failure) — clean
-        // up the record so callers don't see an orphan in `listAgents()`.
-        try {
-            this.startAgent(id, record, args);
-        }
-        catch (err) {
-            this.agents.delete(id);
-            throw err;
-        }
-        return id;
-    }
-    /** Actually start an agent (called immediately or from queue drain). */
-    startAgent(id, record, { pi, ctx, type, prompt, options }) {
-        // Worktree isolation: try to create a temporary git worktree. Strict —
-        // fail loud if not possible (no silent fallback to main tree). Done
-        // BEFORE state mutation so a throw doesn't leave the record half-running.
-        let worktreeCwd;
-        if (options.isolation === "worktree") {
-            const wt = createWorktree(ctx.cwd, id);
-            if (!wt) {
-                throw new Error('Cannot run with isolation: "worktree" — not a git repo, no commits yet, or `git worktree add` failed. ' +
-                    'Initialize git and commit at least once, or omit `isolation`.');
-            }
-            record.worktree = wt;
-            worktreeCwd = wt.path;
-        }
-        record.status = "running";
-        record.startedAt = Date.now();
-        if (options.isBackground)
-            this.runningBackground++;
-        this.onStart?.(record);
-        // Wire parent abort signal to stop the subagent when the parent is interrupted
-        let detachParentSignal;
-        if (options.signal) {
-            const onParentAbort = () => this.abort(id);
-            options.signal.addEventListener("abort", onParentAbort, { once: true });
-            detachParentSignal = () => options.signal.removeEventListener("abort", onParentAbort);
-        }
-        const detach = () => { detachParentSignal?.(); detachParentSignal = undefined; };
-        const promise = runAgent(ctx, type, prompt, {
-            pi,
-            model: options.model,
-            maxTurns: options.maxTurns,
-            isolated: options.isolated,
-            inheritContext: options.inheritContext,
-            thinkingLevel: options.thinkingLevel,
-            cwd: worktreeCwd,
-            signal: record.abortController.signal,
-            onToolActivity: (activity) => {
-                if (activity.type === "end")
-                    record.toolUses++;
-                options.onToolActivity?.(activity);
-            },
-            onTurnEnd: options.onTurnEnd,
-            onTextDelta: options.onTextDelta,
-            onAssistantUsage: (usage) => {
-                addUsage(record.lifetimeUsage, usage);
-                options.onAssistantUsage?.(usage);
-            },
-            onCompaction: (info) => {
-                record.compactionCount++;
-                this.onCompact?.(record, info);
-                options.onCompaction?.(info);
-            },
-            onSessionCreated: (session) => {
-                record.session = session;
-                // Flush any steers that arrived before the session was ready
-                if (record.pendingSteers?.length) {
-                    for (const msg of record.pendingSteers) {
-                        session.steer(msg).catch(() => { });
-                    }
-                    record.pendingSteers = undefined;
-                }
-                options.onSessionCreated?.(session);
-            },
-        })
-            .then(({ responseText, session, aborted, steered }) => {
-            // Don't overwrite status if externally stopped via abort()
-            if (record.status !== "stopped") {
-                record.status = aborted ? "aborted" : steered ? "steered" : "completed";
-            }
-            record.result = responseText;
-            record.session = session;
-            record.completedAt ??= Date.now();
-            detach();
-            // Final flush of streaming output file
-            if (record.outputCleanup) {
-                try {
-                    record.outputCleanup();
-                }
-                catch { /* ignore */ }
-                record.outputCleanup = undefined;
-            }
-            // Clean up worktree if used
-            if (record.worktree) {
-                const wtResult = cleanupWorktree(ctx.cwd, record.worktree, options.description);
-                record.worktreeResult = wtResult;
-                if (wtResult.hasChanges && wtResult.branch) {
-                    record.result = (record.result ?? "") +
-                        `\n\n---\nChanges saved to branch \`${wtResult.branch}\`. Merge with: \`git merge ${wtResult.branch}\``;
-                }
-            }
-            if (options.isBackground) {
-                this.runningBackground--;
-                try {
-                    this.onComplete?.(record);
-                }
-                catch { /* ignore completion side-effect errors */ }
-                this.drainQueue();
-            }
-            return responseText;
-        })
-            .catch((err) => {
-            // Don't overwrite status if externally stopped via abort()
-            if (record.status !== "stopped") {
-                record.status = "error";
-            }
-            record.error = err instanceof Error ? err.message : String(err);
-            record.completedAt ??= Date.now();
-            detach();
-            // Final flush of streaming output file on error
-            if (record.outputCleanup) {
-                try {
-                    record.outputCleanup();
-                }
-                catch { /* ignore */ }
-                record.outputCleanup = undefined;
-            }
-            // Best-effort worktree cleanup on error
-            if (record.worktree) {
-                try {
-                    const wtResult = cleanupWorktree(ctx.cwd, record.worktree, options.description);
-                    record.worktreeResult = wtResult;
-                }
-                catch { /* ignore cleanup errors */ }
-            }
-            if (options.isBackground) {
-                this.runningBackground--;
-                this.onComplete?.(record);
-                this.drainQueue();
-            }
-            return "";
-        });
-        record.promise = promise;
-    }
-    /** Start queued agents up to the concurrency limit. */
-    drainQueue() {
-        while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
-            const next = this.queue.shift();
-            const record = this.agents.get(next.id);
-            if (!record || record.status !== "queued")
-                continue;
-            try {
-                this.startAgent(next.id, record, next.args);
-            }
-            catch (err) {
-                // Late failure (e.g. strict worktree-isolation) — surface on the record
-                // so the user/agent can see it via /agents, then keep draining.
-                record.status = "error";
-                record.error = err instanceof Error ? err.message : String(err);
-                record.completedAt = Date.now();
-                this.onComplete?.(record);
-            }
-        }
-    }
-    /**
-     * Spawn an agent and wait for completion (foreground use).
-     * Foreground agents bypass the concurrency queue.
-     */
-    async spawnAndWait(pi, ctx, type, prompt, options) {
-        const id = this.spawn(pi, ctx, type, prompt, { ...options, isBackground: false });
-        const record = this.agents.get(id);
-        await record.promise;
-        return record;
-    }
-    /**
-     * Resume an existing agent session with a new prompt.
-     */
-    async resume(id, prompt, signal) {
-        const record = this.agents.get(id);
-        if (!record?.session)
-            return undefined;
-        record.status = "running";
-        record.startedAt = Date.now();
-        record.completedAt = undefined;
-        record.result = undefined;
-        record.error = undefined;
-        try {
-            const responseText = await resumeAgent(record.session, prompt, {
-                onToolActivity: (activity) => {
-                    if (activity.type === "end")
-                        record.toolUses++;
-                },
-                onAssistantUsage: (usage) => {
-                    addUsage(record.lifetimeUsage, usage);
-                },
-                onCompaction: (info) => {
-                    record.compactionCount++;
-                    this.onCompact?.(record, info);
-                },
-                signal,
-            });
-            record.status = "completed";
-            record.result = responseText;
-            record.completedAt = Date.now();
-        }
-        catch (err) {
-            record.status = "error";
-            record.error = err instanceof Error ? err.message : String(err);
-            record.completedAt = Date.now();
-        }
-        return record;
-    }
-    getRecord(id) {
-        return this.agents.get(id);
-    }
-    listAgents() {
-        return [...this.agents.values()].sort((a, b) => b.startedAt - a.startedAt);
-    }
-    abort(id) {
-        const record = this.agents.get(id);
-        if (!record)
-            return false;
-        // Remove from queue if queued
-        if (record.status === "queued") {
-            this.queue = this.queue.filter(q => q.id !== id);
-            record.status = "stopped";
-            record.completedAt = Date.now();
-            return true;
-        }
-        if (record.status !== "running")
-            return false;
-        record.abortController?.abort();
-        record.status = "stopped";
-        record.completedAt = Date.now();
-        return true;
-    }
-    /** Dispose a record's session and remove it from the map. */
-    removeRecord(id, record) {
-        record.session?.dispose?.();
-        record.session = undefined;
-        this.agents.delete(id);
-    }
-    cleanup() {
-        const cutoff = Date.now() - 10 * 60_000;
-        for (const [id, record] of this.agents) {
-            if (record.status === "running" || record.status === "queued")
-                continue;
-            if ((record.completedAt ?? 0) >= cutoff)
-                continue;
-            this.removeRecord(id, record);
-        }
-    }
-    /**
-     * Remove all completed/stopped/errored records immediately.
-     * Called on session start/switch so tasks from a prior session don't persist.
-     */
-    clearCompleted() {
-        for (const [id, record] of this.agents) {
-            if (record.status === "running" || record.status === "queued")
-                continue;
-            this.removeRecord(id, record);
-        }
-    }
-    /** Whether any agents are still running or queued. */
-    hasRunning() {
-        return [...this.agents.values()].some(r => r.status === "running" || r.status === "queued");
-    }
-    /** Abort all running and queued agents immediately. */
-    abortAll() {
-        let count = 0;
-        // Clear queued agents first
-        for (const queued of this.queue) {
-            const record = this.agents.get(queued.id);
-            if (record) {
-                record.status = "stopped";
-                record.completedAt = Date.now();
-                count++;
-            }
-        }
-        this.queue = [];
-        // Abort running agents
-        for (const record of this.agents.values()) {
-            if (record.status === "running") {
-                record.abortController?.abort();
-                record.status = "stopped";
-                record.completedAt = Date.now();
-                count++;
-            }
-        }
-        return count;
-    }
-    /** Wait for all running and queued agents to complete (including queued ones). */
-    async waitForAll() {
-        // Loop because drainQueue respects the concurrency limit — as running
-        // agents finish they start queued ones, which need awaiting too.
-        while (true) {
-            this.drainQueue();
-            const pending = [...this.agents.values()]
-                .filter(r => r.status === "running" || r.status === "queued")
-                .map(r => r.promise)
-                .filter(Boolean);
-            if (pending.length === 0)
-                break;
-            await Promise.allSettled(pending);
-        }
-    }
-    dispose() {
-        clearInterval(this.cleanupInterval);
-        // Clear queue
-        this.queue = [];
-        for (const record of this.agents.values()) {
-            record.session?.dispose();
-        }
-        this.agents.clear();
-        // Prune any orphaned git worktrees (crash recovery)
-        try {
-            pruneWorktrees(process.cwd());
-        }
-        catch { /* ignore */ }
-    }
-}