@gethmy/agent 1.7.0 → 1.7.2

package/dist/types.js

@@ -1,79 +0,0 @@
-export const DEFAULT_AGENT_CONFIG = {
-    poolSize: 3,
-    maxTimeout: 1_800_000, // 30 minutes
-    pickupColumns: ["To Do"],
-    priorityLabels: { urgent: 100, critical: 90, bug: 50 },
-    columnBoost: true,
-    completion: {
-        createPR: false,
-        moveToColumn: "Review",
-        postSummary: true,
-    },
-    claude: {
-        model: "opus",
-        reviewModel: "sonnet",
-        maxTurns: 200,
-        additionalArgs: [],
-    },
-    worktree: {
-        basePath: ".harmony-worktrees",
-        baseBranch: "main",
-        failedBranchPrefix: "agent-attempts/",
-        approvedBranchPrefix: "agent/",
-        failedAttemptRetentionDays: 7,
-    },
-    verification: {
-        enabled: true,
-        build: true,
-        lint: true,
-        autoFix: true,
-        maxFixAttempts: 1,
-        deepReview: false,
-        devServerBasePort: 4200,
-        timeout: 120_000,
-        failColumn: "To Do",
-    },
-    review: {
-        enabled: true,
-        poolSize: 2,
-        pickupColumns: ["Review"],
-        moveToColumn: "Done",
-        failColumn: "To Do",
-        devServerPort: 4300,
-        maxTimeout: 600_000,
-        postFindings: true,
-        maxReviewCycles: 3,
-        createPR: true,
-        approvedLabel: "Ready to Merge",
-        approvedLabelColor: "#22c55e",
-        mergeMonitor: true,
-        mergedLabel: "Merged",
-        mergedLabelColor: "#6366f1",
-    },
-    budget: {
-        maxAttemptsPerCard: 3,
-        maxCentsPerCard: 500, // $5.00
-        dailyBudgetCents: 5000, // $50.00
-        dlqLabel: "dlq",
-        dlqLabelColor: "#dc2626",
-    },
-    http: {
-        enabled: true,
-        port: 47821,
-        bindAddr: "127.0.0.1",
-    },
-    timing: {
-        heartbeatMs: 30_000,
-        staleHeartbeatMs: 120_000,
-        reconcileIntervalMs: 60_000,
-        worktreeGcIntervalMs: 5 * 60_000,
-    },
-};
-// ============ LABELS ============
-export const NEED_REVIEW_LABEL = "Need Review";
-export const NEED_REVIEW_LABEL_COLOR = "#f59e0b";
-// ============ AGENT IDENTITY ============
-export const AGENT_NAME = "Harmony Agent";
-export function agentIdentifier(workerId) {
-    return `harmony-daemon-${workerId}`;
-}

package/dist/verification.d.ts

@@ -1,39 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { AgentConfig } from "./types.js";
-export interface VerificationResult {
-    passed: boolean;
-    buildErrors: string[];
-    lintWarnings: string[];
-    reviewFindings: string[];
-}
-export declare function runVerification(worktreePath: string, config: AgentConfig, workerId: number): Promise<VerificationResult>;
-export declare function runBuild(worktreePath: string, timeout: number): string[];
-export declare function runLint(worktreePath: string, timeout: number): string[];
-export declare function runDeepReview(worktreePath: string, config: AgentConfig, workerId: number): Promise<string[]>;
-export declare function attemptAutoFix(worktreePath: string, config: AgentConfig, errors: string[]): void;
-export interface RecoveryInfo {
-    /** Remote ref where the failed attempt was pushed. */
-    branchName: string;
-    /** Public URL of the branch (GitHub/GitLab/Bitbucket tree view), if known. */
-    branchUrl: string | null;
-}
-export declare function reportFindings(client: HarmonyApiClient, cardId: string, result: VerificationResult, recovery?: RecoveryInfo | null): Promise<void>;
-export declare class DevServerReadinessError extends Error {
-    constructor(message: string);
-}
-/**
- * Wait for a dev server to signal readiness on stdout/stderr.
- *
- * Rejects (does NOT resolve) on timeout or process error — callers that
- * need the server to be live for correctness (e.g. the review worker)
- * must not proceed without a confirmed signal. If the server dies before
- * becoming ready, we reject with the exit details.
- */
-export declare function waitForDevServer(proc: ChildProcess, timeout: number): Promise<void>;
-/**
- * Verify the dev server actually responds to HTTP GET before treating
- * it as ready. Listening alone isn't enough — a framework can bind but
- * still crash on the first request.
- */
-export declare function probeDevServer(port: number, timeoutMs?: number): Promise<void>;

package/dist/verification.js

@@ -1,317 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-import { log } from "./log.js";
-import { spawnRunArgs } from "./pm.js";
-const TAG = "verification";
-// ============ PUBLIC API ============
-export async function runVerification(worktreePath, config, workerId) {
-    const result = {
-        passed: true,
-        buildErrors: [],
-        lintWarnings: [],
-        reviewFindings: [],
-    };
-    if (config.verification.build) {
-        log.info(TAG, `[worker:${workerId}] Running build...`);
-        result.buildErrors = runBuild(worktreePath, config.verification.timeout);
-        if (result.buildErrors.length > 0) {
-            log.warn(TAG, `[worker:${workerId}] Build failed with ${result.buildErrors.length} error(s)`);
-            result.passed = false;
-        }
-        else {
-            log.info(TAG, `[worker:${workerId}] Build passed`);
-        }
-    }
-    if (config.verification.lint) {
-        log.info(TAG, `[worker:${workerId}] Running lint...`);
-        result.lintWarnings = runLint(worktreePath, config.verification.timeout);
-        if (result.lintWarnings.length > 0) {
-            log.warn(TAG, `[worker:${workerId}] Lint found ${result.lintWarnings.length} issue(s)`);
-            // Lint warnings alone don't block — only build errors block
-        }
-        else {
-            log.info(TAG, `[worker:${workerId}] Lint passed`);
-        }
-    }
-    if (config.verification.deepReview) {
-        log.info(TAG, `[worker:${workerId}] Running deep review...`);
-        result.reviewFindings = await runDeepReview(worktreePath, config, workerId);
-        if (result.reviewFindings.length > 0) {
-            log.warn(TAG, `[worker:${workerId}] Deep review found ${result.reviewFindings.length} finding(s)`);
-        }
-        else {
-            log.info(TAG, `[worker:${workerId}] Deep review passed`);
-        }
-    }
-    return result;
-}
-export function runBuild(worktreePath, timeout) {
-    try {
-        const [cmd, args] = spawnRunArgs("build");
-        execFileSync(cmd, args, {
-            cwd: worktreePath,
-            timeout,
-            stdio: "pipe",
-        });
-        return [];
-    }
-    catch (err) {
-        return parseErrorOutput(err);
-    }
-}
-export function runLint(worktreePath, timeout) {
-    try {
-        const [cmd, args] = spawnRunArgs("lint");
-        execFileSync(cmd, args, {
-            cwd: worktreePath,
-            timeout,
-            stdio: "pipe",
-        });
-        return [];
-    }
-    catch (err) {
-        return parseErrorOutput(err);
-    }
-}
-export async function runDeepReview(worktreePath, config, workerId) {
-    const port = config.verification.devServerBasePort + workerId;
-    let devServer = null;
-    try {
-        // Start dev server in background
-        const [cmd, args] = spawnRunArgs("dev", "--port", String(port));
-        devServer = spawn(cmd, args, {
-            cwd: worktreePath,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        // Wait for dev server to be ready, then confirm it answers HTTP.
-        try {
-            await waitForDevServer(devServer, 30_000);
-            await probeDevServer(port);
-        }
-        catch (err) {
-            log.error(TAG, `Dev server did not become ready: ${err instanceof Error ? err.message : err}`);
-            return [];
-        }
-        // Get diff for review context
-        let diff = "";
-        try {
-            diff = execFileSync("git", ["diff", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8", timeout: 30_000 });
-        }
-        catch {
-            diff = "(unable to retrieve diff)";
-        }
-        // Spawn Claude for review
-        const reviewPrompt = [
-            "You are reviewing code changes for quality and correctness.",
-            `A dev server is running at http://localhost:${port}.`,
-            "Review the following diff and report any issues found.",
-            "Output ONLY a numbered list of findings, one per line.",
-            "If no issues, output: No issues found.",
-            "",
-            "```diff",
-            diff.slice(0, 50_000),
-            "```",
-        ].join("\n");
-        const output = execFileSync("claude", ["--print", "--model", "sonnet", "--max-turns", "10", "--", reviewPrompt], {
-            cwd: worktreePath,
-            encoding: "utf-8",
-            timeout: config.verification.timeout,
-            stdio: "pipe",
-        });
-        return parseReviewFindings(output);
-    }
-    catch (err) {
-        log.error(TAG, `Deep review failed: ${err instanceof Error ? err.message : err}`);
-        return [];
-    }
-    finally {
-        if (devServer && !devServer.killed) {
-            devServer.kill("SIGTERM");
-        }
-    }
-}
-export function attemptAutoFix(worktreePath, config, errors) {
-    const errorSummary = errors.slice(0, 20).join("\n");
-    const fixPrompt = [
-        "The following build/lint errors were found after implementing a feature.",
-        "Fix the source files to resolve these errors.",
-        "Do NOT commit build artifacts or modify files in dist/.",
-        "Fix source files only.",
-        "",
-        "Errors:",
-        "```",
-        errorSummary,
-        "```",
-    ].join("\n");
-    const args = [
-        "--print",
-        "--model",
-        config.claude.model,
-        "--max-turns",
-        "50",
-        "--allowedTools",
-        "Bash,Read,Write,Edit,Glob,Grep",
-        "--",
-        fixPrompt,
-    ];
-    log.info(TAG, "Spawning Claude for auto-fix...");
-    execFileSync("claude", args, {
-        cwd: worktreePath,
-        timeout: config.verification.timeout,
-        stdio: "pipe",
-    });
-}
-export async function reportFindings(client, cardId, result, recovery) {
-    const items = [];
-    if (recovery) {
-        const cmd = `git fetch && git checkout ${recovery.branchName}`;
-        const url = recovery.branchUrl ? ` (${recovery.branchUrl})` : "";
-        items.push(`Recovery: \`${cmd}\`${url}`);
-    }
-    for (const err of result.buildErrors) {
-        items.push(`Build: ${err}`);
-    }
-    for (const err of result.lintWarnings) {
-        items.push(`Lint: ${err}`);
-    }
-    for (const finding of result.reviewFindings) {
-        items.push(`Review: ${finding}`);
-    }
-    const maxSubtasks = 10;
-    const overflow = items.length - maxSubtasks;
-    const toCreate = items.slice(0, maxSubtasks);
-    await Promise.all(toCreate.map(async (item) => {
-        const title = item.length > 120 ? `${item.slice(0, 117)}...` : item;
-        try {
-            await client.createSubtask(cardId, title);
-        }
-        catch (err) {
-            log.error(TAG, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
-        }
-    }));
-    if (overflow > 0) {
-        try {
-            await client.createSubtask(cardId, `...and ${overflow} more issues`);
-        }
-        catch {
-            // best-effort
-        }
-    }
-    log.info(TAG, `Reported ${Math.min(items.length, maxSubtasks)} finding(s) as subtasks on card ${cardId}`);
-}
-// ============ HELPERS ============
-function parseErrorOutput(err) {
-    const stderr = err?.stderr?.toString() ?? "";
-    const stdout = err?.stdout?.toString() ?? "";
-    const combined = `${stderr}\n${stdout}`;
-    const lines = combined
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0 &&
-        (l.includes("error") ||
-            l.includes("Error") ||
-            l.includes("✖") ||
-            l.includes("×")))
-        .map((l) => (l.length > 200 ? `${l.slice(0, 197)}...` : l));
-    // If we couldn't parse specific error lines, return the whole output truncated
-    if (lines.length === 0 && combined.trim().length > 0) {
-        return [combined.trim().slice(0, 200)];
-    }
-    return lines;
-}
-function parseReviewFindings(output) {
-    if (output.toLowerCase().includes("no issues found")) {
-        return [];
-    }
-    return output
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => /^\d+[.)]/.test(l))
-        .map((l) => l.replace(/^\d+[.)]\s*/, ""))
-        .filter((l) => l.length > 0);
-}
-export class DevServerReadinessError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "DevServerReadinessError";
-    }
-}
-/**
- * Wait for a dev server to signal readiness on stdout/stderr.
- *
- * Rejects (does NOT resolve) on timeout or process error — callers that
- * need the server to be live for correctness (e.g. the review worker)
- * must not proceed without a confirmed signal. If the server dies before
- * becoming ready, we reject with the exit details.
- */
-export function waitForDevServer(proc, timeout) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => {
-            proc.stdout?.off("data", onData);
-            proc.stderr?.off("data", onData);
-            proc.off("error", onError);
-            proc.off("exit", onExit);
-            clearTimeout(timer);
-        };
-        const settleResolve = () => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve();
-        };
-        const settleReject = (err) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(err);
-        };
-        const timer = setTimeout(() => {
-            settleReject(new DevServerReadinessError(`dev server did not signal readiness within ${timeout}ms`));
-        }, timeout);
-        const onData = (data) => {
-            const text = data.toString();
-            if (text.includes("ready") ||
-                text.includes("localhost") ||
-                text.includes("Local:")) {
-                settleResolve();
-            }
-        };
-        const onError = (err) => {
-            settleReject(err);
-        };
-        const onExit = (code, signal) => {
-            settleReject(new DevServerReadinessError(`dev server exited before becoming ready (code=${code ?? "?"}, signal=${signal ?? "?"})`));
-        };
-        proc.stdout?.on("data", onData);
-        proc.stderr?.on("data", onData);
-        proc.on("error", onError);
-        proc.on("exit", onExit);
-    });
-}
-/**
- * Verify the dev server actually responds to HTTP GET before treating
- * it as ready. Listening alone isn't enough — a framework can bind but
- * still crash on the first request.
- */
-export async function probeDevServer(port, timeoutMs = 5000) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const res = await fetch(`http://localhost:${port}/`, {
-            signal: controller.signal,
-        });
-        if (!res.ok && res.status >= 500) {
-            throw new DevServerReadinessError(`dev server returned ${res.status} on probe`);
-        }
-    }
-    catch (err) {
-        if (err instanceof DevServerReadinessError)
-            throw err;
-        throw new DevServerReadinessError(`dev server probe failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}

package/dist/watcher.d.ts

@@ -1,53 +0,0 @@
-import type { RealtimeCredentials } from "./types.js";
-export interface CardBroadcastEvent {
-    event: "card_update" | "card_created";
-    payload: Record<string, unknown>;
-}
-export interface AgentCommandEvent {
-    cardId: string;
-    command: "pause" | "resume" | "stop";
-}
-export type CardBroadcastHandler = (event: CardBroadcastEvent) => void;
-export type AgentCommandHandler = (event: AgentCommandEvent) => void;
-export interface PresenceIdentity {
-    userId: string;
-    userEmail: string;
-    agentIdentifier: string;
-    agentName: string;
-}
-/**
- * Subscribes to Supabase broadcast events on the board channel.
- * The harmony-api broadcasts card_update and card_created events
- * after every mutation — this works with the anon key (no RLS needed).
- */
-export declare class Watcher {
-    private credentials;
-    private projectId;
-    private identity;
-    private onCardBroadcast;
-    private onAgentCommand?;
-    private channel;
-    private presenceChannel;
-    private supabase;
-    private daemonId;
-    private connected;
-    private presenceTracked;
-    private suppressStartupLogs;
-    private readyResolve;
-    private readyPromise;
-    get isConnected(): boolean;
-    /** Resolves once both broadcast subscription is active AND presence is tracked. */
-    ready(): Promise<void>;
-    /**
-     * Re-enable startup-state log lines. The startup banner suppresses them
-     * by default in pretty mode (it absorbs subscribe/presence into one
-     * "✓ Realtime" line). After the banner has rendered, main() calls this
-     * so any realtime events that arrive *after* the banner — e.g. a slow
-     * subscribe that missed the banner's 3 s deadline — log normally.
-     */
-    allowStartupLogs(): void;
-    private maybeResolveReady;
-    constructor(credentials: RealtimeCredentials, projectId: string, identity: PresenceIdentity, onCardBroadcast: CardBroadcastHandler, onAgentCommand?: AgentCommandHandler | undefined);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}

package/dist/watcher.js

@@ -1,153 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createClient } from "@supabase/supabase-js";
-import { isPretty, log } from "./log.js";
-const TAG = "watcher";
-/**
- * Subscribes to Supabase broadcast events on the board channel.
- * The harmony-api broadcasts card_update and card_created events
- * after every mutation — this works with the anon key (no RLS needed).
- */
-export class Watcher {
-    credentials;
-    projectId;
-    identity;
-    onCardBroadcast;
-    onAgentCommand;
-    channel = null;
-    presenceChannel = null;
-    supabase = null;
-    daemonId = randomUUID();
-    connected = false;
-    presenceTracked = false;
-    suppressStartupLogs = true;
-    readyResolve = null;
-    readyPromise = new Promise((resolve) => {
-        this.readyResolve = resolve;
-    });
-    get isConnected() {
-        return this.connected;
-    }
-    /** Resolves once both broadcast subscription is active AND presence is tracked. */
-    ready() {
-        return this.readyPromise;
-    }
-    /**
-     * Re-enable startup-state log lines. The startup banner suppresses them
-     * by default in pretty mode (it absorbs subscribe/presence into one
-     * "✓ Realtime" line). After the banner has rendered, main() calls this
-     * so any realtime events that arrive *after* the banner — e.g. a slow
-     * subscribe that missed the banner's 3 s deadline — log normally.
-     */
-    allowStartupLogs() {
-        this.suppressStartupLogs = false;
-    }
-    maybeResolveReady() {
-        if (this.connected && this.presenceTracked && this.readyResolve) {
-            this.readyResolve();
-            this.readyResolve = null;
-        }
-    }
-    constructor(credentials, projectId, identity, onCardBroadcast, onAgentCommand) {
-        this.credentials = credentials;
-        this.projectId = projectId;
-        this.identity = identity;
-        this.onCardBroadcast = onCardBroadcast;
-        this.onAgentCommand = onAgentCommand;
-    }
-    async start() {
-        // In pretty mode the startup banner absorbs realtime readiness into
-        // its "✓ Realtime" line, so this connect message is redundant noise.
-        if (!isPretty()) {
-            log.info(TAG, "Connecting to Supabase realtime (broadcast)...");
-        }
-        this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
-        // Presence channel — separate from the broadcast channel to avoid
-        // conflicting with frontend BoardContext's board-{projectId} subscription
-        const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
-        const channel = this.supabase
-            .channel(`board-${this.projectId}`)
-            .on("broadcast", { event: "card_update" }, (msg) => {
-            log.debug(TAG, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
-            this.onCardBroadcast({
-                event: "card_update",
-                payload: msg.payload ?? {},
-            });
-        })
-            .on("broadcast", { event: "card_created" }, (msg) => {
-            log.debug(TAG, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
-            this.onCardBroadcast({
-                event: "card_created",
-                payload: msg.payload ?? {},
-            });
-        })
-            .on("broadcast", { event: "agent_command" }, (msg) => {
-            const payload = msg.payload ?? {};
-            const cardId = payload.card_id;
-            const command = payload.command;
-            if (cardId && command) {
-                log.info(TAG, `Broadcast: agent_command ${command} for ${cardId}`);
-                this.onAgentCommand?.({ cardId, command });
-            }
-        })
-            .subscribe((status) => {
-            if (status === "SUBSCRIBED") {
-                this.connected = true;
-                if (!isPretty() || !this.suppressStartupLogs) {
-                    log.info(TAG, "Broadcast subscription active");
-                }
-                this.maybeResolveReady();
-            }
-            else if (status === "CHANNEL_ERROR") {
-                this.connected = false;
-                log.error(TAG, "Broadcast channel error — will rely on reconciliation");
-            }
-            else if (status === "TIMED_OUT") {
-                this.connected = false;
-                log.warn(TAG, "Broadcast subscription timed out — retrying...");
-            }
-            else if (status === "CLOSED") {
-                this.connected = false;
-            }
-        });
-        this.channel = channel;
-        // Subscribe presence channel for daemon online indicator
-        presenceChannel
-            .on("presence", { event: "sync" }, () => {
-            log.debug(TAG, "Presence sync");
-        })
-            .subscribe(async (status) => {
-            if (status === "SUBSCRIBED") {
-                await presenceChannel.track({
-                    daemonId: this.daemonId,
-                    startedAt: new Date().toISOString(),
-                    userId: this.identity.userId,
-                    userEmail: this.identity.userEmail,
-                    agentIdentifier: this.identity.agentIdentifier,
-                    agentName: this.identity.agentName,
-                });
-                if (!isPretty() || !this.suppressStartupLogs) {
-                    log.info(TAG, "Presence tracked on board-presence channel");
-                }
-                this.presenceTracked = true;
-                this.maybeResolveReady();
-            }
-        });
-        this.presenceChannel = presenceChannel;
-    }
-    async stop() {
-        if (this.presenceChannel) {
-            await this.supabase?.removeChannel(this.presenceChannel);
-            this.presenceChannel = null;
-        }
-        if (this.channel) {
-            await this.supabase?.removeChannel(this.channel);
-            this.channel = null;
-        }
-        if (this.supabase) {
-            await this.supabase.realtime.disconnect();
-            this.supabase = null;
-        }
-        this.connected = false;
-        log.info(TAG, "Broadcast subscription stopped");
-    }
-}

package/dist/worker.d.ts

@@ -1,53 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { Card, Column, Label, Subtask } from "@harmony/shared";
-import { type StateStore } from "./state-store.js";
-import { type AgentConfig, type WorkerState } from "./types.js";
-export declare class Worker {
-    private config;
-    private client;
-    private onDone;
-    private workspaceId;
-    private projectId;
-    private stateStore;
-    id: number;
-    state: WorkerState;
-    cardId: string | null;
-    branchName: string | null;
-    worktreePath: string | null;
-    startedAt: number | null;
-    private process;
-    private timeoutTimer;
-    private heartbeatTimer;
-    private progressTracker;
-    private lastSessionStats;
-    private aborted;
-    private sessionId;
-    private runId;
-    constructor(id: number, config: AgentConfig, client: HarmonyApiClient, _userEmail: string, onDone: (worker: Worker) => void, workspaceId: string, projectId: string, stateStore: StateStore);
-    private startHeartbeat;
-    private stopHeartbeat;
-    private recordPhase;
-    get tag(): string;
-    get isIdle(): boolean;
-    get isActive(): boolean;
-    /**
-     * Start working on a card. Runs the full lifecycle:
-     * PREPARING → RUNNING → COMPLETING → IDLE
-     */
-    run(card: Card, column: Column, labels: Label[], subtasks: Subtask[]): Promise<void>;
-    private recordOutcome;
-    /**
-     * Pause the current work by suspending the Claude process (SIGSTOP).
-     */
-    pause(): Promise<void>;
-    /**
-     * Resume the Claude process after a pause (SIGCONT).
-     */
-    resume(): Promise<void>;
-    /**
-     * Cancel the current work. Sends escalating signals to the Claude process.
-     */
-    cancel(): Promise<void>;
-    private spawnClaude;
-    private cleanup;
-}