@getforgeai/cli 0.1.0-beta.1

package/dist/orchestrator/connectors/native-vm-connector.js

@@ -0,0 +1,162 @@
+/**
+ * AgentConnector implementation that runs agents inside bubblewrap sandboxes
+ * within the shared native VM (Virtualization.framework via Swift N-API addon).
+ *
+ * Replaces the old vm-connector that used one VM per session with SSH streaming.
+ * This connector uses vsock for all communication and shares a single VM across
+ * all concurrent agent sessions.
+ */
+import { stopAgentProcess } from "./connector.js";
+import { getVmManager } from "../../vm/vm-manager-facade.js";
+import { vmLog } from "../../vm/log.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Build MCP config JSON that points to forge-mcp-relay running inside the sandbox.
+ * The relay connects to vminitd which bridges to the host via vsock.
+ */
+function buildMcpConfigJson(sessionIndex) {
+    const mcpPort = 20000 + sessionIndex;
+    return JSON.stringify({
+        mcpServers: {
+            forgeai: {
+                command: "node",
+                args: ["/opt/forgeai/forge-mcp-relay.mjs", String(mcpPort)],
+            },
+        },
+    }, null, 2);
+}
+function buildDefaultPrompt(skillName) {
+    return `You are a ForgeAI agent. Read and follow the ${skillName} skill in .claude/skills/${skillName}/SKILL.md to implement your assigned task.`;
+}
+function buildResumePrompt(basePrompt, ctx) {
+    const parts = [basePrompt];
+    if (ctx?.agentQuestion ?? ctx?.response) {
+        parts.push("\n\n## Human Interaction Resume\n");
+        if (ctx?.agentQuestion) {
+            parts.push(`**Your previous question:**\n${ctx.agentQuestion}\n`);
+        }
+        if (ctx?.response) {
+            parts.push(`**Human response:**\n${ctx.response}\n`);
+        }
+        parts.push("Continue your work using the human's response above. Do not re-ask the same question.");
+    }
+    return parts.join("\n");
+}
+/** Standard Claude CLI args for agent execution */
+function buildAgentArgs(mcpConfigPath, prompt) {
+    return [
+        "--dangerously-skip-permissions",
+        "--mcp-config",
+        mcpConfigPath,
+        "-p",
+        prompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--include-partial-messages",
+    ];
+}
+// ---------------------------------------------------------------------------
+// Connector
+// ---------------------------------------------------------------------------
+export const nativeVmConnector = {
+    name: "native-vm-claude-code",
+    async start(params) {
+        const sm = getVmManager();
+        // 1. Ensure the shared VM is booted
+        await sm.ensureVmRunning();
+        // 2. Create session (allocates index, host dirs)
+        const sessionId = await sm.createSession(params.taskId);
+        const session = sm.getSessionByTaskId(params.taskId);
+        // 3. Clone repo inside the VM
+        await sm.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
+        // 4. Prepare workspace files on the host (available in VM via VirtioFS)
+        const skillFiles = [];
+        if (params.skill) {
+            for (const file of params.skill.files) {
+                skillFiles.push({
+                    relativePath: `${params.skill.name}/${file.path}`,
+                    content: file.content,
+                });
+            }
+        }
+        sm.prepareWorkspace(sessionId, {
+            contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
+            mcpConfigJson: buildMcpConfigJson(session.sessionIndex),
+            skillFiles,
+        });
+        // 5. Copy workspace files from VirtioFS mount into the workspace inside VM
+        await sm.exec("bash", [
+            "-c",
+            [
+                `mkdir -p /sessions/${sessionId}/workspace/.forgeai /sessions/${sessionId}/workspace/.claude`,
+                `cp /sessions/${sessionId}/context.json /sessions/${sessionId}/workspace/.forgeai/context.json`,
+                `cp /sessions/${sessionId}/mcp_config.json /sessions/${sessionId}/workspace/.claude/mcp_config.json`,
+            ].join(" && "),
+        ]);
+        if (skillFiles.length > 0) {
+            await sm.exec("bash", [
+                "-c",
+                [
+                    `mkdir -p /sessions/${sessionId}/workspace/.claude/skills`,
+                    `cp -r /sessions/${sessionId}/skills/. /sessions/${sessionId}/workspace/.claude/skills/`,
+                ].join(" && "),
+            ]);
+        }
+        // 6. Spawn agent in bubblewrap sandbox
+        const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+        const agentArgs = buildAgentArgs("/workspace/.claude/mcp_config.json", prompt);
+        const env = {};
+        if (process.env.ANTHROPIC_API_KEY) {
+            env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+        }
+        vmLog.magenta("native-vm-connector", `Spawning agent in sandbox ${sessionId}`);
+        const proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs, env);
+        // Auto-destroy session on agent exit
+        proxy.once("exit", () => {
+            sm.destroySession(params.taskId).catch((err) => {
+                const message = err instanceof Error ? err.message : String(err);
+                vmLog.warn("native-vm-connector", `Cleanup failed for ${sessionId}: ${message}`);
+            });
+        });
+        return {
+            pid: proxy.pid,
+            process: proxy,
+            vmId: sessionId,
+        };
+    },
+    async stop(entry) {
+        // Stop the agent process using shared SIGTERM -> wait -> SIGKILL logic
+        await stopAgentProcess(entry);
+        // Destroy the VM session (cleanup sandbox + host files)
+        if (entry.vmId) {
+            const sm = getVmManager();
+            await sm.destroySession(entry.taskId);
+        }
+    },
+    async resume(params, ctx) {
+        const sm = getVmManager();
+        const session = sm.getSessionByTaskId(params.taskId);
+        // If the sandbox is still alive (idle window), spawn fresh agent in same session
+        if (session && session.status === "RUNNING") {
+            vmLog.cyan("native-vm-connector", `Resuming in existing sandbox ${session.id}`);
+            const basePrompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+            const agentArgs = buildAgentArgs("/workspace/.claude/mcp_config.json", buildResumePrompt(basePrompt, ctx));
+            const proxy = await sm.spawnAgent(params.taskId, "claude", agentArgs);
+            return {
+                pid: proxy.pid,
+                process: proxy,
+                vmId: session.id,
+            };
+        }
+        // No existing session — full start pipeline with resume context baked into prompt
+        const basePrompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+        return this.start({
+            ...params,
+            prompt: buildResumePrompt(basePrompt, ctx),
+        });
+    },
+};
+//# sourceMappingURL=native-vm-connector.js.map

package/dist/orchestrator/connectors/opencode-connector.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConnector } from "./connector.js";
+export declare const openCodeConnector: AgentConnector;
+//# sourceMappingURL=opencode-connector.d.ts.map

package/dist/orchestrator/connectors/opencode-connector.js

@@ -0,0 +1,39 @@
+import { spawn } from "node:child_process";
+import { stopAgentProcess } from "./connector.js";
+function buildDefaultPrompt(skillName) {
+    return `You are a ForgeAI agent. Read and follow the ${skillName} skill in .opencode/skills/${skillName}/SKILL.md to implement your assigned task.`;
+}
+function spawnOpenCode(params, prompt) {
+    const child = spawn("opencode", ["--mcp-config", params.mcpConfigPath, "-p", prompt], {
+        cwd: params.worktreePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    if (child.pid === undefined) {
+        throw new Error("Failed to spawn opencode process — no PID assigned");
+    }
+    return { pid: child.pid, process: child };
+}
+export const openCodeConnector = {
+    name: "opencode",
+    async start(params) {
+        return spawnOpenCode(params, params.prompt ?? buildDefaultPrompt(params.skillName));
+    },
+    stop: stopAgentProcess,
+    async resume(params, ctx) {
+        const basePrompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+        const parts = [basePrompt];
+        if (ctx?.agentQuestion || ctx?.response) {
+            parts.push("\n\n## Human Interaction Resume\n");
+            if (ctx.agentQuestion) {
+                parts.push(`**Your previous question:**\n${ctx.agentQuestion}\n`);
+            }
+            if (ctx.response) {
+                parts.push(`**Human response:**\n${ctx.response}\n`);
+            }
+            parts.push("Continue your work using the human's response above. Do not re-ask the same question.");
+        }
+        return spawnOpenCode(params, parts.join("\n"));
+    },
+};
+//# sourceMappingURL=opencode-connector.js.map

package/dist/orchestrator/connectors/vm-connector.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConnector } from "./connector.js";
+export declare const vmConnector: AgentConnector;
+//# sourceMappingURL=vm-connector.d.ts.map

package/dist/orchestrator/connectors/vm-connector.js

@@ -0,0 +1,139 @@
+import { stopAgentProcess } from "./connector.js";
+import { getVmManager } from "../../vm/vm-manager.js";
+import { vmLog } from "../../vm/log.js";
+function buildDefaultPrompt(skillName) {
+    return `You are a ForgeAI agent. Read and follow the ${skillName} skill in .claude/skills/${skillName}/SKILL.md to implement your assigned task.`;
+}
+function buildResumePrompt(basePrompt, ctx) {
+    const parts = [basePrompt];
+    if (ctx?.agentQuestion || ctx?.response) {
+        parts.push("\n\n## Human Interaction Resume\n");
+        if (ctx.agentQuestion) {
+            parts.push(`**Your previous question:**\n${ctx.agentQuestion}\n`);
+        }
+        if (ctx.response) {
+            parts.push(`**Human response:**\n${ctx.response}\n`);
+        }
+        parts.push("Continue your work using the human's response above. Do not re-ask the same question.");
+    }
+    return parts.join("\n");
+}
+/** MCP tunnel port inside the VM (must match MCP_TUNNEL_PORT in vm-manager) */
+const VM_MCP_PORT = 19876;
+function buildMcpConfigJson() {
+    // MCP config points to a Node.js one-liner that connects to the
+    // reverse-tunneled TCP port where the host's `forge mcp` is listening.
+    const config = {
+        mcpServers: {
+            forgeai: {
+                command: "node",
+                args: [
+                    "-e",
+                    `const s=require("net").createConnection(${VM_MCP_PORT},"127.0.0.1");process.stdin.pipe(s);s.pipe(process.stdout);s.on("error",()=>process.exit(1));`,
+                ],
+            },
+        },
+    };
+    return JSON.stringify(config, null, 2);
+}
+export const vmConnector = {
+    name: "vm-claude-code",
+    async start(params) {
+        const vmManager = getVmManager();
+        // 1. Create session
+        const sessionId = await vmManager.createSession(params.taskId, {
+            repoUrl: params.repoUrl,
+            branch: params.taskBranch,
+            workflowBaseBranch: params.workflowBaseBranch,
+            workflowContext: params.workflowContext,
+        });
+        // 2. Boot VM
+        await vmManager.bootVm(sessionId);
+        // 3. Clone repo + checkout branch inside VM (creates branch if it doesn't exist)
+        await vmManager.cloneRepo(sessionId, params.repoUrl, params.taskBranch, params.workflowBaseBranch);
+        // 4. Prepare workspace (context, skills, MCP config)
+        const skillFiles = [];
+        if (params.skill) {
+            for (const file of params.skill.files) {
+                skillFiles.push({
+                    relativePath: `${params.skill.name}/${file.path}`,
+                    content: file.content,
+                });
+            }
+        }
+        await vmManager.prepareWorkspace(sessionId, {
+            contextJson: JSON.stringify(params.taskContext ?? {}, null, 2),
+            mcpConfigJson: buildMcpConfigJson(),
+            skillFiles,
+        });
+        // 5. Spawn agent inside VM (with MCP bridge on host via reverse tunnel)
+        const prompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+        const agentArgs = [
+            "--dangerously-skip-permissions",
+            "--mcp-config",
+            "/workspace/.claude/mcp_config.json",
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+        ];
+        vmLog.magenta("vm-connector", `Spawning agent in VM ${sessionId}\n  prompt="${prompt.slice(0, 200)}${prompt.length > 200 ? "..." : ""}"`);
+        const agent = await vmManager.spawnAgent(sessionId, "claude", agentArgs, {
+            taskId: params.taskId,
+            projectId: params.projectId,
+            orgId: params.orgId,
+            workflowId: params.workflowContext?.workflowId,
+            stepId: params.workflowContext?.stepId,
+        });
+        return {
+            pid: agent.pid,
+            process: agent.process,
+            vmId: sessionId,
+        };
+    },
+    async stop(entry) {
+        // Stop the agent process using shared logic
+        await stopAgentProcess(entry);
+        // Destroy the VM session
+        if (entry.vmId) {
+            const vmManager = getVmManager();
+            await vmManager.destroySession(entry.vmId);
+        }
+    },
+    async resume(params, ctx) {
+        const vmManager = getVmManager();
+        const session = vmManager.getSession(params.taskId);
+        // If VM is still running (idle window), spawn fresh agent in same VM
+        if (session && session.status === "RUNNING") {
+            vmLog.cyan("vm-connector", `Resuming agent in existing VM ${session.id} for task ${params.taskId}`);
+            const basePrompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+            const resumePrompt = buildResumePrompt(basePrompt, ctx);
+            const agentArgs = [
+                "--dangerously-skip-permissions",
+                "--mcp-config",
+                "/workspace/.claude/mcp_config.json",
+                "-p",
+                resumePrompt,
+                "--output-format",
+                "stream-json",
+                "--verbose",
+                "--include-partial-messages",
+            ];
+            const agent = await vmManager.spawnAgent(session.id, "claude", agentArgs);
+            return {
+                pid: agent.pid,
+                process: agent.process,
+                vmId: session.id,
+            };
+        }
+        // VM not running — full start pipeline
+        vmLog.cyan("vm-connector", `No running VM for task ${params.taskId}, starting fresh`);
+        // Rebuild params with resume context baked into prompt
+        const basePrompt = params.prompt ?? buildDefaultPrompt(params.skillName);
+        const resumePrompt = buildResumePrompt(basePrompt, ctx);
+        return this.start({ ...params, prompt: resumePrompt });
+    },
+};
+//# sourceMappingURL=vm-connector.js.map

package/dist/orchestrator/dispatch-queue.d.ts

@@ -0,0 +1,43 @@
+import type { DispatchParams } from "./agent-spawner.js";
+export type DrainContext = {
+    spawnAgent: (params: DispatchParams) => Promise<void>;
+};
+/**
+ * In-memory FIFO queue that buffers incoming task:dispatch events
+ * when the agent registry is at capacity.
+ *
+ * Global singleton — agent slots are machine-level, shared across all org connections.
+ */
+export declare class DispatchQueue {
+    private readonly queue;
+    private readonly maxSize;
+    private paused;
+    private resumeTimer;
+    constructor(maxSize?: number);
+    /**
+     * Pause the queue (e.g. due to billing cooldown).
+     * While paused, drainNext() is a no-op and spawnAgent calls should be skipped.
+     * Optionally schedule auto-resume based on a future reset timestamp.
+     */
+    pause(resetAt?: string): void;
+    resume(): void;
+    isPaused(): boolean;
+    enqueue(params: DispatchParams): void;
+    /**
+     * Pop head of queue and attempt to spawn via the provided context.
+     * If spawn fails, the item is NOT re-enqueued (spawn errors are terminal).
+     *
+     * DEVIATION FROM SPEC (subtask 1.3): The original spec suggested "re-enqueue at head"
+     * on spawn failure. This is intentionally NOT implemented because:
+     * - Re-enqueuing failed spawns creates infinite retry loops (spawn will fail again)
+     * - Better to fail fast with observable logs than silently retry
+     * - Spawn failures are terminal errors (bad git state, missing config, etc.)
+     * - If the spawn environment recovers, the next dispatch event will retry
+     */
+    drainNext(ctx: DrainContext): Promise<void>;
+    size(): number;
+    clear(): void;
+}
+/** Global singleton instance */
+export declare const dispatchQueue: DispatchQueue;
+//# sourceMappingURL=dispatch-queue.d.ts.map

package/dist/orchestrator/dispatch-queue.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+const DEFAULT_MAX_QUEUE_SIZE = 20;
+/**
+ * In-memory FIFO queue that buffers incoming task:dispatch events
+ * when the agent registry is at capacity.
+ *
+ * Global singleton — agent slots are machine-level, shared across all org connections.
+ */
+export class DispatchQueue {
+    queue = [];
+    maxSize;
+    paused = false;
+    resumeTimer = null;
+    constructor(maxSize = DEFAULT_MAX_QUEUE_SIZE) {
+        this.maxSize = maxSize;
+    }
+    /**
+     * Pause the queue (e.g. due to billing cooldown).
+     * While paused, drainNext() is a no-op and spawnAgent calls should be skipped.
+     * Optionally schedule auto-resume based on a future reset timestamp.
+     */
+    pause(resetAt) {
+        this.paused = true;
+        if (this.resumeTimer) {
+            clearTimeout(this.resumeTimer);
+            this.resumeTimer = null;
+        }
+        if (resetAt) {
+            const resumeMs = new Date(resetAt).getTime() - Date.now() + 60_000; // +1min buffer
+            if (resumeMs > 0 && resumeMs < 86_400_000) {
+                this.resumeTimer = setTimeout(() => {
+                    this.resume();
+                    console.log(chalk.green("[dispatch-queue] Cooldown expired — queue auto-resumed"));
+                }, resumeMs);
+            }
+        }
+        console.log(chalk.yellow("[dispatch-queue] Queue paused (billing cooldown)"));
+    }
+    resume() {
+        this.paused = false;
+        if (this.resumeTimer) {
+            clearTimeout(this.resumeTimer);
+            this.resumeTimer = null;
+        }
+        console.log(chalk.green("[dispatch-queue] Queue resumed"));
+    }
+    isPaused() {
+        return this.paused;
+    }
+    enqueue(params) {
+        if (this.queue.length >= this.maxSize) {
+            const dropped = this.queue.shift();
+            console.warn(chalk.yellow(`[dispatch-queue] Queue full (${this.maxSize}), dropping oldest dispatch for task ${dropped?.taskId}`));
+        }
+        this.queue.push(params);
+        console.log(chalk.dim(`[dispatch-queue] Enqueued task ${params.taskId} (queue size: ${this.queue.length})`));
+    }
+    /**
+     * Pop head of queue and attempt to spawn via the provided context.
+     * If spawn fails, the item is NOT re-enqueued (spawn errors are terminal).
+     *
+     * DEVIATION FROM SPEC (subtask 1.3): The original spec suggested "re-enqueue at head"
+     * on spawn failure. This is intentionally NOT implemented because:
+     * - Re-enqueuing failed spawns creates infinite retry loops (spawn will fail again)
+     * - Better to fail fast with observable logs than silently retry
+     * - Spawn failures are terminal errors (bad git state, missing config, etc.)
+     * - If the spawn environment recovers, the next dispatch event will retry
+     */
+    async drainNext(ctx) {
+        if (this.paused) {
+            console.log(chalk.dim("[dispatch-queue] Drain skipped — queue is paused"));
+            return;
+        }
+        if (this.queue.length === 0)
+            return;
+        const next = this.queue.shift();
+        console.log(chalk.dim(`[dispatch-queue] Draining next: task ${next.taskId} (remaining: ${this.queue.length})`));
+        await ctx.spawnAgent(next);
+    }
+    size() {
+        return this.queue.length;
+    }
+    clear() {
+        const count = this.queue.length;
+        this.queue.length = 0;
+        if (count > 0) {
+            console.log(chalk.dim(`[dispatch-queue] Cleared ${count} queued dispatches`));
+        }
+    }
+}
+/** Global singleton instance */
+export const dispatchQueue = new DispatchQueue();
+//# sourceMappingURL=dispatch-queue.js.map

package/dist/orchestrator/resume-handler.d.ts

@@ -0,0 +1,34 @@
+import type { AgentRegistry } from "./agent-registry.js";
+import type { createRestClient } from "../lib/rest-client.js";
+import type { createSocketClient } from "../lib/socket-client.js";
+import type { DispatchQueue } from "./dispatch-queue.js";
+export type ResumePayload = {
+    taskId: string;
+    projectId?: string;
+    orgId: string;
+    response?: string;
+    /** Original agent question (before clear) — for context in the resume prompt */
+    agentQuestion?: string;
+    /** Original task command from skill pipeline — so the agent keeps its instruction */
+    taskCommand?: string;
+    skillSlug?: string;
+    taskSlug?: string;
+    projectSlug?: string;
+    taskBranch?: string;
+    repoUrl?: string;
+};
+export type ResumeContext = {
+    restClient: ReturnType<typeof createRestClient>;
+    socketClient: ReturnType<typeof createSocketClient>;
+    agentType: string;
+    agentSlots: number;
+    registry: AgentRegistry;
+    queue: DispatchQueue;
+};
+/**
+ * Handle a task:resume event — uses VM-based execution to resume an agent.
+ * The VM connector handles environment setup (boot, clone, workspace, spawn).
+ * Uses slot reservation to prevent over-allocation during async pipeline.
+ */
+export declare function handleResume(payload: ResumePayload, ctx: ResumeContext): Promise<void>;
+//# sourceMappingURL=resume-handler.d.ts.map

package/dist/orchestrator/resume-handler.js

@@ -0,0 +1,159 @@
+import chalk from "chalk";
+import { DEFAULT_SKILL_NAME, resolveConnector, attachProcessHandlers, spawnAgent, } from "./agent-spawner.js";
+import { pullSkill } from "../lib/skill-manager.js";
+import { getVmManager } from "../vm/vm-manager-facade.js";
+// Helper: Stop and replace existing agent for same taskId
+async function stopExistingAgent(payload, registry) {
+    const existingEntry = registry.getByTaskId(payload.taskId);
+    if (existingEntry?.status === "RUNNING") {
+        console.log(chalk.cyan(`[resume] Stopping existing agent for task ${payload.taskId} (PID: ${existingEntry.pid}) before resume`));
+        registry.unregister(payload.taskId);
+        try {
+            const connector = resolveConnector(existingEntry.connectorName);
+            await connector.stop(existingEntry);
+        }
+        catch (err) {
+            console.warn(chalk.yellow(`[resume] Error stopping old agent for ${payload.taskId}: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+}
+// Helper: Handle case when no slot capacity available
+function enqueueWhenNoCapacity(payload, ctx) {
+    console.warn(chalk.yellow(`[resume] No capacity for task ${payload.taskId}, enqueuing`));
+    if (payload.projectId) {
+        ctx.queue.enqueue({
+            taskId: payload.taskId,
+            projectId: payload.projectId,
+            assigneeId: "",
+            orgId: payload.orgId,
+            taskSlug: payload.taskSlug,
+            projectSlug: payload.projectSlug,
+        });
+    }
+    ctx.socketClient.emitAgentStatus({
+        agentId: payload.taskId,
+        status: "QUEUED",
+    });
+}
+/**
+ * Handle a task:resume event — uses VM-based execution to resume an agent.
+ * The VM connector handles environment setup (boot, clone, workspace, spawn).
+ * Uses slot reservation to prevent over-allocation during async pipeline.
+ */
+export async function handleResume(payload, ctx) {
+    const { registry } = ctx;
+    // Guard: if a spawn is already in flight for this taskId, skip
+    if (registry.hasPendingReservation(payload.taskId)) {
+        console.log(chalk.dim(`[resume] Spawn already in flight for task ${payload.taskId}, skipping duplicate`));
+        return;
+    }
+    // Stop-and-replace: if an agent is already running for this taskId,
+    // stop it first to prevent two agents in the same environment.
+    await stopExistingAgent(payload, registry);
+    // Reserve slot (atomic capacity check)
+    if (!registry.reserveSlot(payload.taskId)) {
+        enqueueWhenNoCapacity(payload, ctx);
+        return;
+    }
+    try {
+        if (!payload.projectId) {
+            throw new Error(`Cannot resume task ${payload.taskId} — no projectId provided`);
+        }
+        const validatedPayload = payload;
+        // Check if VM session exists (same-CLI detection)
+        const sm = getVmManager();
+        const session = sm.getSessionByTaskId(payload.taskId);
+        const isSameCli = session?.status === "RUNNING";
+        if (isSameCli) {
+            console.log(chalk.cyan(`[resume] Same-CLI resume for task ${payload.taskId} — VM session exists`));
+        }
+        else {
+            console.log(chalk.cyan(`[resume] Cross-CLI resume for task ${payload.taskId} — will boot new VM`));
+        }
+        // Pull skill on host
+        const resumeSkillName = payload.skillSlug ?? DEFAULT_SKILL_NAME;
+        const skill = await pullSkill(resumeSkillName, ctx.restClient);
+        // Resolve connector
+        const connector = resolveConnector(ctx.agentType);
+        const taskSlug = payload.taskSlug ?? payload.taskId;
+        const taskBranch = payload.taskBranch ?? taskSlug;
+        // If no session exists, try to fetch snapshot for --continue resume
+        let sessionSnapshotBase64;
+        if (!isSameCli) {
+            try {
+                const snapshotData = await new Promise((resolve) => {
+                    const timeout = setTimeout(() => resolve(null), 10_000);
+                    ctx.socketClient.socket.emit("workflow:step:snapshot:fetch", { workflowId: payload.taskId, stepId: payload.taskId }, (data) => {
+                        clearTimeout(timeout);
+                        resolve(data);
+                    });
+                });
+                if (snapshotData?.snapshot) {
+                    sessionSnapshotBase64 = snapshotData.snapshot;
+                    console.log(chalk.cyan(`[resume] Snapshot found for task ${payload.taskId} — will restore with --continue`));
+                }
+            }
+            catch {
+                // No snapshot available
+            }
+        }
+        const vmSpawnParams = {
+            taskId: validatedPayload.taskId,
+            projectId: validatedPayload.projectId,
+            orgId: validatedPayload.orgId,
+            workingDir: "/workspace",
+            mcpConfigPath: "/workspace/.claude/mcp_config.json",
+            skillName: skill?.name ?? resumeSkillName,
+            prompt: validatedPayload.taskCommand,
+            repoUrl: payload.repoUrl,
+            taskBranch,
+            skill: skill ? { name: skill.name, files: skill.files } : undefined,
+            sessionSnapshotBase64,
+        };
+        const result = await connector.resume(vmSpawnParams, {
+            response: validatedPayload.response,
+            agentQuestion: validatedPayload.agentQuestion,
+        });
+        // Confirm slot + register + attach handlers
+        registry.confirmSlot(payload.taskId, {
+            taskId: payload.taskId,
+            pid: result.pid,
+            process: result.process,
+            connectorName: connector.name,
+            workingDir: "/workspace",
+            orgId: payload.orgId,
+            startedAt: new Date().toISOString(),
+            status: "RUNNING",
+            vmId: result.vmId,
+        });
+        ctx.socketClient.emitAgentStatus({
+            agentId: payload.taskId,
+            status: "RUNNING",
+        });
+        console.log(chalk.green(`[resume] Agent resumed for task ${payload.taskId} (PID: ${result.pid}, same-cli: ${isSameCli})`));
+        // Attach process handlers
+        const boundSpawnAgent = (p) => spawnAgent(p, {
+            restClient: ctx.restClient,
+            socketClient: ctx.socketClient,
+            agentType: ctx.agentType,
+            agentSlots: ctx.agentSlots,
+            queue: ctx.queue,
+        });
+        attachProcessHandlers(result.process, {
+            taskId: payload.taskId,
+            projectId: validatedPayload.projectId,
+            registry: ctx.registry,
+            socketClient: ctx.socketClient,
+            restClient: ctx.restClient,
+            queue: ctx.queue,
+            spawnAgentFn: boundSpawnAgent,
+            label: "resume",
+            agentSlots: ctx.agentSlots,
+        });
+    }
+    catch (err) {
+        registry.releaseSlot(payload.taskId);
+        throw err;
+    }
+}
+//# sourceMappingURL=resume-handler.js.map