opencode-orchestrator-plugin 1.0.0-beta.0

package/dist/tools/background.js

@@ -0,0 +1,198 @@
+import { tool } from "@opencode-ai/plugin/tool";
+const BACKGROUND_TASK_DESCRIPTION = "Launch a specialized agent in the background to perform research or implementation tasks.";
+const BACKGROUND_OUTPUT_DESCRIPTION = "Retrieve the results or status of a background task.";
+export class BackgroundManager {
+    tasks;
+    client;
+    pollingInterval;
+    constructor(ctx) {
+        this.tasks = new Map();
+        this.client = ctx.client;
+    }
+    async launch(input) {
+        if (!input.agent || input.agent.trim() === "") {
+            throw new Error("Agent parameter is required");
+        }
+        const createResult = await this.client.session.create({
+            body: {
+                parentID: input.parentSessionID,
+                title: `Background: ${input.description}`,
+            },
+        });
+        if (createResult.error) {
+            throw new Error(`Failed to create background session: ${createResult.error}`);
+        }
+        const sessionID = createResult.data.id;
+        const task = {
+            id: `bg_${Math.random().toString(36).substring(2, 10)}`,
+            sessionID,
+            parentSessionID: input.parentSessionID,
+            parentMessageID: input.parentMessageID,
+            description: input.description,
+            prompt: input.prompt,
+            agent: input.agent,
+            status: "running",
+            startedAt: new Date(),
+            progress: {
+                toolCalls: 0,
+                lastUpdate: new Date(),
+            },
+        };
+        this.tasks.set(task.id, task);
+        this.startPolling();
+        this.client.session.promptAsync({
+            path: { id: sessionID },
+            body: {
+                agent: input.agent,
+                tools: {
+                    "orchestrator_bg_task": false,
+                    "orchestrator_delegate": false,
+                },
+                parts: [{ type: "text", text: input.prompt }],
+            },
+        }).catch((error) => {
+            console.error("[Orchestrator] Background task error:", error);
+            task.status = "failed";
+            task.error = String(error);
+        });
+        return task;
+    }
+    async cancel(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return `Task not found: ${id}`;
+        if (task.status !== "running")
+            return `Task is not running (status: ${task.status})`;
+        task.status = "cancelled";
+        task.completedAt = new Date();
+        // Attempt to notify parent session
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: `[BACKGROUND TASK CANCELLED] Task "${task.description}" has been manually cancelled.` }],
+            },
+        }).catch(() => { });
+        return `Task ${id} cancelled successfully.`;
+    }
+    async pollRunningTasks() {
+        try {
+            const statusResult = await this.client.session.status();
+            const allStatuses = (statusResult.data ?? {});
+            for (const task of this.tasks.values()) {
+                if (task.status !== "running")
+                    continue;
+                const sessionStatus = allStatuses[task.sessionID];
+                if (sessionStatus?.type === "idle") {
+                    this.completeTask(task);
+                }
+            }
+            if (!this.hasRunningTasks()) {
+                this.stopPolling();
+            }
+        }
+        catch (e) {
+            console.error("[Orchestrator] Polling error:", e);
+        }
+    }
+    completeTask(task) {
+        task.status = "completed";
+        task.completedAt = new Date();
+        this.notifyParentSession(task);
+    }
+    async notifyParentSession(task) {
+        const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished. Use orchestrator_bg_output with task_id="${task.id}" to get results.`;
+        await this.client.session.prompt({
+            path: { id: task.parentSessionID },
+            body: {
+                parts: [{ type: "text", text: message }],
+            },
+        }).catch(() => { });
+    }
+    getTask(id) {
+        return this.tasks.get(id);
+    }
+    startPolling() {
+        if (this.pollingInterval)
+            return;
+        this.pollingInterval = setInterval(() => this.pollRunningTasks(), 3000);
+    }
+    stopPolling() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = undefined;
+        }
+    }
+    hasRunningTasks() {
+        return Array.from(this.tasks.values()).some(t => t.status === "running");
+    }
+}
+export function createBackgroundTask(manager) {
+    return tool({
+        description: BACKGROUND_TASK_DESCRIPTION,
+        args: {
+            description: tool.schema.string().describe("Short task description"),
+            prompt: tool.schema.string().describe("Full detailed prompt for the agent"),
+            agent: tool.schema.string().describe("Agent type to use"),
+        },
+        async execute(args, toolContext) {
+            const ctx = toolContext;
+            const task = await manager.launch({
+                description: args.description,
+                prompt: args.prompt,
+                agent: args.agent.trim(),
+                parentSessionID: ctx.sessionID,
+                parentMessageID: ctx.messageID,
+            });
+            return `Background task launched successfully. Task ID: ${task.id}`;
+        },
+    });
+}
+export function createBackgroundOutput(manager) {
+    return tool({
+        description: BACKGROUND_OUTPUT_DESCRIPTION,
+        args: {
+            task_id: tool.schema.string().describe("Task ID to get output from"),
+            block: tool.schema.boolean().optional().describe("Wait for completion"),
+            timeout: tool.schema.number().optional().describe("Max wait time in ms"),
+        },
+        async execute(args, toolContext) {
+            const task = manager.getTask(args.task_id);
+            if (!task)
+                return `Task not found: ${args.task_id}`;
+            if (args.block && task.status === "running") {
+                const startTime = Date.now();
+                const timeoutMs = Math.min(args.timeout ?? 60000, 600000);
+                while (Date.now() - startTime < timeoutMs) {
+                    await new Promise(r => setTimeout(r, 2000));
+                    if (manager.getTask(args.task_id)?.status === "completed")
+                        break;
+                }
+            }
+            if (task.status === "completed") {
+                const client = toolContext.client || manager.client;
+                const messagesResult = await client.session.messages({
+                    path: { id: task.sessionID },
+                });
+                const lastMessage = messagesResult.data
+                    ?.filter((m) => m.info.role === "assistant")
+                    .pop();
+                const responseText = lastMessage?.parts
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text).join("\n") || "No response.";
+                return `### Results for: ${task.description}\n\n${responseText}`;
+            }
+            return `Task status: ${task.status}. (Started at: ${task.startedAt.toISOString()})`;
+        },
+    });
+}
+export function createBackgroundCancel(manager) {
+    return tool({
+        description: "Cancel a running background task",
+        args: {
+            taskId: tool.schema.string().describe("Task ID to cancel"),
+        },
+        async execute(args) {
+            return await manager.cancel(args.taskId);
+        },
+    });
+}

package/dist/tools/commands.d.ts

@@ -0,0 +1,11 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare const setupCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const newTrackCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const implementCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const statusCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare const revertCommand: (ctx: import("@opencode-ai/plugin").PluginInput) => ToolDefinition;
+export declare function createSetupTool(ctx: any): ToolDefinition;
+export declare function createNewTrackTool(ctx: any): ToolDefinition;
+export declare function createImplementTool(ctx: any): ToolDefinition;
+export declare function createStatusTool(ctx: any): ToolDefinition;
+export declare function createRevertTool(ctx: any): ToolDefinition;

package/dist/tools/commands.js

@@ -0,0 +1,80 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { createOrchestratorCommand } from "../utils/commandFactory.js";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const setupCommand = createOrchestratorCommand({
+    name: "orchestrator/setup.json",
+    description: "Directives lookup tool for scaffolding the project and setting up the Orchestrator environment",
+    args: {},
+});
+export const newTrackCommand = createOrchestratorCommand({
+    name: "orchestrator/newTrack.json",
+    description: "Directives lookup tool for planning a track, generating track-specific spec documents and updating the tracks file",
+    args: {
+        description: tool.schema.string().optional().describe("Brief description of the track (feature, bug fix, chore, etc.)"),
+    },
+    additionalContext: async (_ctx, args) => {
+        return {
+            args: args.description || "",
+        };
+    },
+});
+export const implementCommand = createOrchestratorCommand({
+    name: "orchestrator/implement.json",
+    description: "Directives lookup tool for executing the tasks defined in the specified track's plan",
+    args: {
+        track_name: tool.schema.string().optional().describe("Name or description of the track to implement"),
+    },
+    additionalContext: async (ctx, args) => {
+        const strategyFile = ctx.isOMOActive ? "delegate.md" : "manual.md";
+        const strategyPath = join(__dirname, "../prompts/strategies", strategyFile);
+        let strategySection = "";
+        try {
+            strategySection = await readFile(strategyPath, "utf-8");
+        }
+        catch (e) {
+            console.warn(`[Orchestrator] Failed to load strategy ${strategyFile}:`, e);
+            strategySection = "Error: Could not load execution strategy.";
+        }
+        return {
+            strategy_section: strategySection,
+            track_name: args.track_name || "",
+        };
+    },
+});
+export const statusCommand = createOrchestratorCommand({
+    name: "orchestrator/status.json",
+    description: "Directives lookup tool for displaying the current progress of the project",
+    args: {},
+});
+export const revertCommand = createOrchestratorCommand({
+    name: "orchestrator/revert.json",
+    description: "Directives lookup tool for reverting previous work",
+    args: {
+        target: tool.schema.string().optional().describe("Target to revert (e.g., 'track <track_id>', 'phase <phase_name>', 'task <task_name>')"),
+    },
+    additionalContext: async (_ctx, args) => {
+        return {
+            target: args.target || "",
+        };
+    },
+});
+// Export as functions for backward compatibility
+export function createSetupTool(ctx) {
+    return setupCommand(ctx);
+}
+export function createNewTrackTool(ctx) {
+    return newTrackCommand(ctx);
+}
+export function createImplementTool(ctx) {
+    return implementCommand(ctx);
+}
+export function createStatusTool(ctx) {
+    return statusCommand(ctx);
+}
+export function createRevertTool(ctx) {
+    return revertCommand(ctx);
+}

package/dist/tools/commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/commands.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSetupTool, createNewTrackTool, createImplementTool, createStatusTool, createRevertTool, } from "./commands.js";
+import { readFile } from "fs/promises";
+// Mock fs/promises
+vi.mock("fs/promises", () => ({
+    readFile: vi.fn(),
+}));
+describe("Command Tools", () => {
+    let mockCtx;
+    let mockToolContext;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockCtx = {
+            directory: "/test/project",
+            isOMOActive: false,
+        };
+        mockToolContext = {
+            sessionID: "test-session",
+            messageID: "test-message",
+        };
+        // Default mocks - must use triple quotes for the regex in commandFactory
+        vi.mocked(readFile).mockResolvedValue(`
+description = "Test command"
+prompt = """
+Test prompt content
+"""
+`);
+    });
+    describe("createSetupTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createSetupTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for scaffolding the project and setting up the Orchestrator environment");
+        });
+        it("should return directives JSON string when executed", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Setup"
+prompt = """Setup Prompt"""
+`);
+            const tool = createSetupTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Setup Prompt" });
+        });
+    });
+    describe("createNewTrackTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createNewTrackTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for planning a track, generating track-specific spec documents and updating the tracks file");
+        });
+        it("should have optional description argument", () => {
+            const tool = createNewTrackTool(mockCtx);
+            expect(tool.args).toHaveProperty("description");
+        });
+        it("should replace description in directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "New Track"
+prompt = """Track description: {{args}}"""
+`);
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({ description: "Login feature" }, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Track description: Login feature" });
+        });
+    });
+    describe("createImplementTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createImplementTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for executing the tasks defined in the specified track's plan");
+        });
+        it("should have optional track_name argument", () => {
+            const tool = createImplementTool(mockCtx);
+            expect(tool.args).toHaveProperty("track_name");
+        });
+        it("should replace track_name in directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Implement"
+prompt = """Track: {{track_name}}"""
+`);
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({ track_name: "auth-track" }, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Track: auth-track" });
+        });
+        it("should include strategy section in directives", async () => {
+            vi.mocked(readFile).mockImplementation(async (path) => {
+                if (typeof path === 'string' && path.endsWith("manual.md")) {
+                    return "Manual Strategy";
+                }
+                return `
+description = "Implement"
+prompt = """Strategy: {{strategy_section}}"""
+`;
+            });
+            const tool = createImplementTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Strategy: Manual Strategy" });
+        });
+    });
+    describe("createStatusTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createStatusTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for displaying the current progress of the project");
+        });
+        it("should execute and return directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Status"
+prompt = """Status Prompt"""
+`);
+            const tool = createStatusTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Status Prompt" });
+        });
+    });
+    describe("createRevertTool", () => {
+        it("should create a tool with correct description", () => {
+            const tool = createRevertTool(mockCtx);
+            expect(tool.description).toBe("Directives lookup tool for reverting previous work");
+        });
+        it("should replace target in directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Revert"
+prompt = """Target: {{target}}"""
+`);
+            const tool = createRevertTool(mockCtx);
+            const result = await tool.execute({ target: "track 1" }, mockToolContext);
+            expect(JSON.parse(result)).toEqual({ directives: "Target: track 1" });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should return error in directives if readFile fails", async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error("File not found"));
+            const tool = createSetupTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result).directives).toContain("SYSTEM ERROR: Failed to load prompt");
+        });
+    });
+    describe("Prompt Replacement", () => {
+        it("should replace standard variables in directives", async () => {
+            vi.mocked(readFile).mockResolvedValue(`
+description = "Test"
+prompt = """Templates: {{templatesDir}}"""
+`);
+            const tool = createNewTrackTool(mockCtx);
+            const result = await tool.execute({}, mockToolContext);
+            expect(JSON.parse(result).directives).toContain("Templates:");
+        });
+    });
+});

package/dist/tools/delegate.d.ts

@@ -0,0 +1,3 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+export declare function createDelegationTool(ctx: PluginInput): ToolDefinition;

package/dist/tools/delegate.js

@@ -0,0 +1,45 @@
+import { tool } from "@opencode-ai/plugin/tool";
+export function createDelegationTool(ctx) {
+    return tool({
+        description: "Delegate a specific task to a specialized subagent",
+        args: {
+            task_description: tool.schema.string().describe("Summary of the work"),
+            subagent_type: tool.schema.string().describe("The name of the agent to call"),
+            prompt: tool.schema.string().describe("Detailed instructions for the subagent"),
+        },
+        async execute(args, toolContext) {
+            // 1. Create a sub-session linked to the current one
+            const createResult = await ctx.client.session.create({
+                body: {
+                    parentID: toolContext.sessionID,
+                    title: `${args.task_description} (Delegated to ${args.subagent_type})`,
+                },
+            });
+            if (createResult.error)
+                return `Error: ${createResult.error}`;
+            const sessionID = createResult.data.id;
+            // 2. Send the prompt to the subagent
+            await ctx.client.session.prompt({
+                path: { id: sessionID },
+                body: {
+                    agent: args.subagent_type,
+                    tools: {
+                        "orchestrator_delegate": false,
+                    },
+                    parts: [{ type: "text", text: args.prompt }],
+                },
+            });
+            // 3. Fetch and return the assistant's response
+            const messagesResult = await ctx.client.session.messages({
+                path: { id: sessionID },
+            });
+            const lastMessage = messagesResult.data
+                ?.filter((m) => m.info.role === "assistant")
+                .pop();
+            const responseText = lastMessage?.parts
+                .filter((p) => p.type === "text")
+                .map((p) => p.text).join("\n") || "No response.";
+            return `${responseText}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`;
+        },
+    });
+}

package/dist/utils/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function bootstrap(ctx: any): Promise<void>;

package/dist/utils/bootstrap.js

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, copyFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function bootstrap(ctx) {
+    const opencodeConfigDir = join(homedir(), ".config", "opencode");
+    const targetAgentDir = join(opencodeConfigDir, "agent");
+    const targetCommandDir = join(opencodeConfigDir, "command");
+    const sourcePromptsDir = join(__dirname, "../prompts");
+    const sourceAgentFile = join(sourcePromptsDir, "agent/orchestrator.md");
+    const sourceCommandsDir = join(sourcePromptsDir, "commands");
+    let installedAnything = false;
+    // 1. Ensure directories exist
+    if (!existsSync(targetAgentDir))
+        mkdirSync(targetAgentDir, { recursive: true });
+    if (!existsSync(targetCommandDir))
+        mkdirSync(targetCommandDir, { recursive: true });
+    // 2. Install/Update Agent
+    const targetAgentFile = join(targetAgentDir, "orchestrator.md");
+    if (existsSync(sourceAgentFile)) {
+        copyFileSync(sourceAgentFile, targetAgentFile);
+        installedAnything = true;
+    }
+    // 3. Install/Update Commands
+    if (existsSync(sourceCommandsDir)) {
+        const commands = readdirSync(sourceCommandsDir);
+        for (const cmdFile of commands) {
+            const targetCmdFile = join(targetCommandDir, cmdFile);
+            copyFileSync(join(sourceCommandsDir, cmdFile), targetCmdFile);
+            installedAnything = true;
+        }
+    }
+    if (installedAnything) {
+        // Do not await toasts during bootstrapping as the TUI might not be ready
+        ctx.client.tui.showToast({
+            body: {
+                title: "Orchestrator",
+                message: "First-run setup: Orchestrator agent and commands installed globally. Please restart OpenCode to enable slash commands.",
+                variant: "info",
+                duration: 5000
+            }
+        }).catch(() => { });
+    }
+}

package/dist/utils/commandFactory.d.ts

@@ -0,0 +1,11 @@
+import { type PluginInput } from "@opencode-ai/plugin";
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+interface OrchestratorCommandConfig {
+    name: string;
+    description: string;
+    args: Record<string, any>;
+    requiresSetup?: boolean;
+    additionalContext?: (ctx: PluginInput, args: any) => Promise<Record<string, string>>;
+}
+export declare function createOrchestratorCommand(config: OrchestratorCommandConfig): (ctx: PluginInput) => ToolDefinition;
+export {};

package/dist/utils/commandFactory.js

@@ -0,0 +1,69 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { join, dirname } from "path";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function loadPrompt(filename, replacements = {}) {
+    const pathsToTry = [
+        join(__dirname, "..", "prompts", filename),
+        join(__dirname, "..", "..", filename),
+    ];
+    let content = "";
+    for (const p of pathsToTry) {
+        try {
+            content = await readFile(p, "utf-8");
+            break;
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    if (!content) {
+        console.error(`[Orchestrator] Error loading prompt ${filename}: Not found in any tried paths`);
+        return {
+            prompt: `SYSTEM ERROR: Failed to load prompt ${filename}`,
+            description: "Error loading command",
+        };
+    }
+    try {
+        const parsed = JSON.parse(content);
+        const description = parsed.description || "Orchestrator Command";
+        let promptText = parsed.prompt || "";
+        if (!promptText)
+            throw new Error(`Could not parse prompt text from ${filename}`);
+        const defaults = {
+            templatesDir: join(dirname(dirname(__dirname)), "templates"),
+        };
+        const finalReplacements = { ...defaults, ...replacements };
+        for (const [key, value] of Object.entries(finalReplacements)) {
+            promptText = promptText.replaceAll(`{{${key}}}`, value || "");
+        }
+        return { prompt: promptText, description };
+    }
+    catch (error) {
+        console.error(`[Orchestrator] Error parsing prompt ${filename}:`, error);
+        return {
+            prompt: `SYSTEM ERROR: Failed to parse prompt ${filename}`,
+            description: "Error parsing command",
+        };
+    }
+}
+export function createOrchestratorCommand(config) {
+    return (ctx) => {
+        return tool({
+            description: config.description,
+            args: config.args,
+            async execute(args) {
+                const additionalContext = config.additionalContext
+                    ? await config.additionalContext(ctx, args)
+                    : {};
+                const replacements = { ...additionalContext };
+                const { prompt } = await loadPrompt(config.name, replacements);
+                return JSON.stringify({
+                    directives: prompt
+                });
+            },
+        });
+    };
+}

package/dist/utils/stateManager.d.ts

@@ -0,0 +1,10 @@
+export interface SetupState {
+    last_successful_step: string;
+}
+export declare class StateManager {
+    private statePath;
+    constructor(workDir: string);
+    ensureOrchestratorDir(): void;
+    readState(): SetupState;
+    writeState(step: string): void;
+}

package/dist/utils/stateManager.js

@@ -0,0 +1,30 @@
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+export class StateManager {
+    statePath;
+    constructor(workDir) {
+        this.statePath = join(workDir, "orchestrator", "setup_state.json");
+    }
+    ensureOrchestratorDir() {
+        const dir = join(this.statePath, "..");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    readState() {
+        if (!existsSync(this.statePath)) {
+            return { last_successful_step: "" };
+        }
+        try {
+            return JSON.parse(readFileSync(this.statePath, "utf-8"));
+        }
+        catch (e) {
+            return { last_successful_step: "" };
+        }
+    }
+    writeState(step) {
+        this.ensureOrchestratorDir();
+        const state = { last_successful_step: step };
+        writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    }
+}