@fkqfkq123/opencode-autopilot 0.1.0

package/dist/packages/runtime/src/attach/attach-service.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowEventStore } from "../events/workflow-event-store";
+import type { TickScheduler } from "../scheduling/tick-scheduler";
+import type { SessionActivityMonitor } from "../sessions/session-activity-monitor";
+import type { WorkflowStateStore } from "../state/workflow-state-store";
+export interface AttachService {
+    attach(workflowId: string): Promise<void>;
+}
+export declare class DefaultAttachService implements AttachService {
+    private readonly stateStore;
+    private readonly sessionActivityMonitor;
+    private readonly tickScheduler;
+    private readonly eventStore;
+    constructor(stateStore: WorkflowStateStore, sessionActivityMonitor: SessionActivityMonitor, tickScheduler: TickScheduler, eventStore: WorkflowEventStore);
+    attach(workflowId: string): Promise<void>;
+}

package/dist/packages/runtime/src/attach/attach-service.js

@@ -0,0 +1,31 @@
+export class DefaultAttachService {
+    stateStore;
+    sessionActivityMonitor;
+    tickScheduler;
+    eventStore;
+    constructor(stateStore, sessionActivityMonitor, tickScheduler, eventStore) {
+        this.stateStore = stateStore;
+        this.sessionActivityMonitor = sessionActivityMonitor;
+        this.tickScheduler = tickScheduler;
+        this.eventStore = eventStore;
+    }
+    async attach(workflowId) {
+        const workflow = await this.stateStore.getWorkflow(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${workflowId}`);
+        }
+        await this.sessionActivityMonitor.start(workflowId);
+        await this.eventStore.append({
+            workflowId,
+            type: "workflow.attached",
+            at: new Date().toISOString(),
+            payload: {
+                phase: workflow.phase,
+                status: workflow.status,
+            },
+        });
+        if (workflow.phase !== "done" && workflow.phase !== "blocked") {
+            await this.tickScheduler.requestTick(workflowId, "workflow attached");
+        }
+    }
+}

package/dist/packages/runtime/src/bootstrap/create-harness.d.ts

@@ -0,0 +1,33 @@
+import { type OpencodeSessionClient } from "../../../adapters/opencode/src/opencode-session-client";
+import { FileSystemArtifactEvaluator } from "../artifacts/file-system-artifact-evaluator";
+import { DefaultAttachService } from "../attach/attach-service";
+import { DefaultWorkflowEngine } from "../engine/default-workflow-engine";
+import { FileSystemWorkflowEventStore } from "../events/file-system-workflow-event-store";
+import { ImmediateTickScheduler } from "../scheduling/immediate-tick-scheduler";
+import { DefaultSessionActivityMonitor } from "../sessions/session-activity-monitor";
+import { FileSystemSessionCoordinator } from "../sessions/file-system-session-coordinator";
+import { FileSystemHumanActionStore } from "../state/file-system-human-action-store";
+import { FileSystemWorkflowStateStore } from "../state/file-system-workflow-state-store";
+import { DefaultHumanActionService } from "../state/human-action-service";
+import { DefaultWorkflowWorkspace } from "../workspace/workflow-workspace";
+export interface CreateHarnessOptions {
+    sessionClient?: OpencodeSessionClient;
+    opencodeBaseUrl?: string;
+    opencodePassword?: string;
+}
+export declare function createHarness(baseDir: string, options?: CreateHarnessOptions): Promise<{
+    stateStore: FileSystemWorkflowStateStore;
+    humanActionStore: FileSystemHumanActionStore;
+    artifactEvaluator: FileSystemArtifactEvaluator;
+    eventStore: FileSystemWorkflowEventStore;
+    sessionCoordinator: FileSystemSessionCoordinator;
+    tickScheduler: ImmediateTickScheduler;
+    engine: DefaultWorkflowEngine;
+    humanActionService: DefaultHumanActionService;
+    attachService: DefaultAttachService;
+    sessionActivityMonitor: DefaultSessionActivityMonitor;
+    sessionClient: OpencodeSessionClient;
+    workspace: DefaultWorkflowWorkspace;
+    resolvedConfig: import("../config/workflow-config").ResolvedWorkflowConfig;
+    skillRegistry: Map<string, string>;
+}>;

package/dist/packages/runtime/src/bootstrap/create-harness.js

@@ -0,0 +1,79 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { HttpOpencodeSessionClient, InMemoryOpencodeSessionClient, } from "../../../adapters/opencode/src/opencode-session-client";
+import { DefaultPhaseTransition } from "../../../core/src/transitions/default-phase-transition";
+import { FileSystemArtifactEvaluator } from "../artifacts/file-system-artifact-evaluator";
+import { DefaultAttachService } from "../attach/attach-service";
+import { buildSkillRegistryWithWarnings } from "../config/skill-registry";
+import { resolveWorkflowConfig } from "../config/workflow-config";
+import { DefaultWorkflowEngine } from "../engine/default-workflow-engine";
+import { FileSystemWorkflowEventStore } from "../events/file-system-workflow-event-store";
+import { BasicRecoveryClassifier } from "../recovery/basic-recovery-classifier";
+import { ImmediateTickScheduler } from "../scheduling/immediate-tick-scheduler";
+import { DefaultSessionActivityMonitor } from "../sessions/session-activity-monitor";
+import { FileSystemSessionCoordinator } from "../sessions/file-system-session-coordinator";
+import { FileSystemHumanActionStore } from "../state/file-system-human-action-store";
+import { FileSystemWorkflowStateStore } from "../state/file-system-workflow-state-store";
+import { DefaultHumanActionService } from "../state/human-action-service";
+import { NoopSubtaskTracker } from "../subtasks/noop-subtask-tracker";
+import { DefaultWorkflowWorkspace } from "../workspace/workflow-workspace";
+export async function createHarness(baseDir, options = {}) {
+    await mkdir(join(baseDir, "workflows"), { recursive: true });
+    const workspace = new DefaultWorkflowWorkspace(baseDir);
+    const resolvedConfig = await resolveWorkflowConfig({
+        projectConfigFile: workspace.workflowConfigFile(),
+    });
+    const skillRegistryResult = await buildSkillRegistryWithWarnings(resolvedConfig.skillRoots);
+    const skillRegistry = skillRegistryResult.registry;
+    resolvedConfig.warnings.push(...skillRegistryResult.warnings);
+    const httpOptions = options.opencodeBaseUrl
+        ? {
+            baseUrl: options.opencodeBaseUrl,
+            ...(options.opencodePassword ? { password: options.opencodePassword } : {}),
+        }
+        : null;
+    const sessionClient = options.sessionClient
+        ?? (httpOptions
+            ? new HttpOpencodeSessionClient(httpOptions)
+            : new InMemoryOpencodeSessionClient());
+    const stateStore = new FileSystemWorkflowStateStore(workspace);
+    const humanActionStore = new FileSystemHumanActionStore(workspace);
+    const artifactEvaluator = new FileSystemArtifactEvaluator(workspace);
+    const eventStore = new FileSystemWorkflowEventStore(workspace);
+    const sessionCoordinator = new FileSystemSessionCoordinator(workspace, sessionClient);
+    const tickScheduler = new ImmediateTickScheduler();
+    const engine = new DefaultWorkflowEngine({
+        stateStore,
+        humanActionStore,
+        artifactEvaluator,
+        phaseTransition: new DefaultPhaseTransition(),
+        sessionCoordinator,
+        recoveryClassifier: new BasicRecoveryClassifier(),
+        subtaskTracker: new NoopSubtaskTracker(),
+        tickScheduler,
+        eventStore,
+        workspace,
+        resolvedConfig,
+        skillRegistry,
+    });
+    tickScheduler.setHandler((workflowId) => engine.tick(workflowId));
+    const sessionActivityMonitor = new DefaultSessionActivityMonitor(baseDir, stateStore, sessionCoordinator, tickScheduler);
+    const humanActionService = new DefaultHumanActionService(humanActionStore, stateStore, artifactEvaluator, tickScheduler, eventStore);
+    const attachService = new DefaultAttachService(stateStore, sessionActivityMonitor, tickScheduler, eventStore);
+    return {
+        stateStore,
+        humanActionStore,
+        artifactEvaluator,
+        eventStore,
+        sessionCoordinator,
+        tickScheduler,
+        engine,
+        humanActionService,
+        attachService,
+        sessionActivityMonitor,
+        sessionClient,
+        workspace,
+        resolvedConfig,
+        skillRegistry,
+    };
+}

package/dist/packages/runtime/src/bootstrap/initialize-workflow.d.ts

@@ -0,0 +1,8 @@
+import type { FileSystemArtifactEvaluator } from "../artifacts/file-system-artifact-evaluator";
+import type { WorkflowStateStore } from "../state/workflow-state-store";
+export declare function initializeWorkflow(args: {
+    workflowId: string;
+    stateStore: WorkflowStateStore;
+    artifactEvaluator: FileSystemArtifactEvaluator;
+    userRequest?: string;
+}): Promise<void>;

package/dist/packages/runtime/src/bootstrap/initialize-workflow.js

@@ -0,0 +1,33 @@
+export async function initializeWorkflow(args) {
+    const { workflowId, stateStore, artifactEvaluator, userRequest } = args;
+    const existing = await stateStore.getWorkflow(workflowId);
+    if (existing) {
+        return;
+    }
+    const now = new Date().toISOString();
+    const workflow = {
+        workflowId,
+        phase: "spec_refinement",
+        status: "pending",
+        approved: false,
+        iteration: 0,
+        maxIterations: 3,
+        blockReason: null,
+        activeSessionId: null,
+        phaseEnteredAt: now,
+        updatedAt: now,
+    };
+    const runtime = {
+        workflowId,
+        preferredForegroundSessionId: null,
+        recoveryState: "idle",
+        waitingHumanActionId: null,
+        consecutiveFailures: 0,
+        refinementAttempts: 0,
+        refinementLastDispatchSummary: null,
+        refinementEscalationReason: null,
+    };
+    await stateStore.saveWorkflow(workflow);
+    await stateStore.saveRuntime(runtime);
+    await artifactEvaluator.ensureDefault(workflowId, userRequest);
+}

package/dist/packages/runtime/src/commands/create-opencode-workflow-commands.d.ts

@@ -0,0 +1,12 @@
+import type { WorkflowPluginCommandAdapter } from "./opencode-plugin-command-adapter";
+import type { WorkflowChannelCommand } from "./workflow-command-runner";
+export interface WorkflowPluginCommandDefinition {
+    name: WorkflowChannelCommand;
+    description: string;
+    execute(args: {
+        workflowId: string;
+        payload?: string;
+        foregroundSessionId?: string;
+    }): Promise<string>;
+}
+export declare function createOpencodeWorkflowCommands(adapter: WorkflowPluginCommandAdapter): WorkflowPluginCommandDefinition[];

package/dist/packages/runtime/src/commands/create-opencode-workflow-commands.js

@@ -0,0 +1,24 @@
+const COMMAND_DESCRIPTIONS = {
+    "workflow-open": "Open or initialize a workflow channel and attach to it.",
+    "workflow-attach": "Attach to an existing workflow channel.",
+    "workflow-status": "Render the current workflow status block.",
+    "workflow-answer": "Answer workflow clarification questions.",
+    "workflow-approve": "Approve the current workflow plan or decision.",
+    "workflow-resume": "Resume a blocked workflow.",
+    "workflow-back": "Leave the workflow channel without stopping the workflow.",
+};
+export function createOpencodeWorkflowCommands(adapter) {
+    return Object.keys(COMMAND_DESCRIPTIONS).map((name) => ({
+        name,
+        description: COMMAND_DESCRIPTIONS[name],
+        async execute(args) {
+            const response = await adapter.execute({
+                command: name,
+                workflowId: args.workflowId,
+                ...(args.payload !== undefined ? { payload: args.payload } : {}),
+                ...(args.foregroundSessionId ? { foregroundSessionId: args.foregroundSessionId } : {}),
+            });
+            return response.text;
+        },
+    }));
+}

package/dist/packages/runtime/src/commands/default-workflow-command-runner.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowCommandResult, WorkflowCommandRunner } from "./workflow-command-runner";
+export declare class DefaultWorkflowCommandRunner implements WorkflowCommandRunner {
+    run(args: Parameters<WorkflowCommandRunner["run"]>[0]): Promise<WorkflowCommandResult>;
+}

package/dist/packages/runtime/src/commands/default-workflow-command-runner.js

@@ -0,0 +1,343 @@
+import { initializeWorkflow } from "../bootstrap/initialize-workflow";
+import { renderHumanActionBlock } from "../presentation/human-action-renderer";
+import { buildWorkflowOpenRequest } from "./workflow-open-request";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+function extractSection(content, heading) {
+    const start = content.indexOf(heading);
+    if (start === -1) {
+        return "";
+    }
+    const afterHeading = start + heading.length;
+    const nextHeading = content.slice(afterHeading).match(/\n##\s+/);
+    const end = nextHeading && typeof nextHeading.index === "number"
+        ? afterHeading + nextHeading.index
+        : content.length;
+    return content.slice(afterHeading, end).trim();
+}
+async function buildStatusEnhancements(args) {
+    const { harness, workflow, events } = args;
+    const evaluation = await harness.artifactEvaluator.evaluate(workflow);
+    const artifactContent = await readFile(harness.workspace.phaseArtifactFile(workflow.workflowId, workflow.phase), "utf8").catch(() => "");
+    const lines = [];
+    const relevantSession = await harness.sessionCoordinator.getRelevantSession(workflow.workflowId);
+    const storedSession = relevantSession.sessionId
+        ? await harness.sessionCoordinator.getStoredSession(workflow.workflowId, relevantSession.sessionId)
+        : null;
+    if (evaluation.summary) {
+        lines.push(`Phase summary: ${evaluation.summary}`);
+    }
+    if (storedSession?.sessionId) {
+        lines.push(`Worker session: ${storedSession.sessionId}`);
+        lines.push(`Worker session phase: ${storedSession.phase}`);
+        lines.push(`Worker session status: ${relevantSession.status}`);
+        lines.push(`Execution mode: ${storedSession.isForegroundPreferred ? "foreground session reuse" : "detached background workflow session"}`);
+    }
+    if (storedSession?.lastDispatchMode) {
+        lines.push(`Dispatch mode: ${storedSession.lastDispatchMode}`);
+    }
+    if (storedSession?.lastStatusBeforeDispatch) {
+        lines.push(`Status before dispatch: ${storedSession.lastStatusBeforeDispatch}`);
+    }
+    if (evaluation.missing.length > 0) {
+        lines.push(`Missing signals: ${evaluation.missing.join(" | ")}`);
+    }
+    if (workflow.phase === "develop") {
+        const changedFiles = extractSection(artifactContent, "## 修改文件");
+        const selfCheck = extractSection(artifactContent, "## 自检结果");
+        if (changedFiles) {
+            lines.push(`Code changes: ${changedFiles}`);
+        }
+        if (selfCheck) {
+            lines.push(`Self-check: ${selfCheck}`);
+        }
+    }
+    if (workflow.phase === "review") {
+        const scope = extractSection(artifactContent, "## 检查范围");
+        const issues = extractSection(artifactContent, "## 发现的问题");
+        const regression = extractSection(artifactContent, "## Regression 风险评估");
+        if (scope) {
+            lines.push(`Review scope: ${scope}`);
+        }
+        if (issues) {
+            lines.push(`Findings: ${issues}`);
+        }
+        if (regression) {
+            lines.push(`Regression risk: ${regression}`);
+        }
+        if (workflow.status === "in_progress" && evaluation.reportStatus === "unknown") {
+            lines.push("Waiting reason: review artifact has not produced a final pass/fail conclusion yet.");
+        }
+    }
+    if (workflow.phase === "test") {
+        const strategy = extractSection(artifactContent, "## 测试策略");
+        const failures = extractSection(artifactContent, "## 失败项");
+        const regression = extractSection(artifactContent, "## Regression 验证");
+        if (strategy) {
+            lines.push(`Test strategy: ${strategy}`);
+        }
+        if (failures) {
+            lines.push(`Failures: ${failures}`);
+        }
+        if (regression) {
+            lines.push(`Regression verification: ${regression}`);
+        }
+        if (workflow.status === "in_progress" && evaluation.reportStatus === "unknown") {
+            lines.push("Waiting reason: test artifact has not produced a final pass/fail conclusion yet.");
+        }
+    }
+    if (workflow.phase === "plan") {
+        const summary = extractSection(artifactContent, "## 需求摘要");
+        const impact = extractSection(artifactContent, "## 影响范围");
+        const coreFiles = extractSection(artifactContent, "## 核心修改文件");
+        const risk = extractSection(artifactContent, "## 风险评估");
+        if (summary) {
+            lines.push(`Plan summary: ${summary}`);
+        }
+        if (impact) {
+            lines.push(`Impact scope: ${impact}`);
+        }
+        if (coreFiles) {
+            lines.push(`Core files: ${coreFiles}`);
+        }
+        if (risk) {
+            lines.push(`Plan risks: ${risk}`);
+        }
+        if (workflow.status === "waiting_human") {
+            lines.push("Approval preview: review the plan summary, impacted scope, core files, and risks before approving.");
+        }
+    }
+    if (workflow.phase === "done" || workflow.status === "completed") {
+        lines.push("Workflow completed: all workflow phases reached terminal success state.");
+        if (evaluation.summary) {
+            lines.push(`Completion summary: ${evaluation.summary}`);
+        }
+    }
+    const lastPhaseChange = [...events].reverse().find((event) => event.type === "phase.changed");
+    if (lastPhaseChange?.payload?.from && lastPhaseChange.payload?.to) {
+        lines.push(`Last transition: ${String(lastPhaseChange.payload.from)} -> ${String(lastPhaseChange.payload.to)}`);
+    }
+    const recentEvents = events.slice(-3);
+    if (recentEvents.length > 0) {
+        lines.push(`Recent events: ${recentEvents.map((event) => event.type).join(" -> ")}`);
+    }
+    return lines;
+}
+function clarificationFilePath(harness, workflowId) {
+    return join(harness.workspace.workflowsRoot(), "..", "clarifications", `${workflowId}.json`);
+}
+async function renderClarificationIfAny(harness, workflowId) {
+    const pending = await readPendingClarification(harness, workflowId);
+    if (!pending) {
+        return null;
+    }
+    return {
+        ok: true,
+        output: [
+            pending.prompt,
+            ...pending.options,
+        ].join("\n"),
+        events: [],
+    };
+}
+async function savePendingClarification(harness, workflowId, payload) {
+    const filePath = clarificationFilePath(harness, workflowId);
+    await mkdir(join(harness.workspace.workflowsRoot(), "..", "clarifications"), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+async function readPendingClarification(harness, workflowId) {
+    try {
+        return JSON.parse(await readFile(clarificationFilePath(harness, workflowId), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function clearPendingClarification(harness, workflowId) {
+    try {
+        await rm(clarificationFilePath(harness, workflowId));
+    }
+    catch {
+        return;
+    }
+}
+function buildIntentPromptFromChoice(choice, rawPayload) {
+    const normalized = choice.trim();
+    if (normalized.includes("启动") || normalized.includes("workflow") || normalized.includes("开始")) {
+        return `请直接启动完整 workflow。
+${rawPayload}`;
+    }
+    if (normalized.includes("分析") || normalized.includes("提炼")) {
+        return `请先分析文档并提炼需求。
+${rawPayload}`;
+    }
+    if (normalized.includes("补全") || normalized.includes("完善")) {
+        return `请先补全文档缺失内容，再决定是否启动 workflow。
+${rawPayload}`;
+    }
+    if (normalized.includes("总结") || normalized.includes("查看")) {
+        return `请只查看并总结文档。
+${rawPayload}`;
+    }
+    if (normalized.startsWith("1")) {
+        return `请直接启动完整 workflow。
+${rawPayload}`;
+    }
+    if (normalized.startsWith("2")) {
+        return `请先分析文档并提炼需求。
+${rawPayload}`;
+    }
+    if (normalized.startsWith("3")) {
+        return `请先补全文档缺失内容，再决定是否启动 workflow。
+${rawPayload}`;
+    }
+    return `请只查看并总结文档。
+${rawPayload}`;
+}
+export class DefaultWorkflowCommandRunner {
+    async run(args) {
+        const { harness, command, workflowId, payload, foregroundSessionId } = args;
+        if (command === "workflow-open") {
+            const openRequest = await buildWorkflowOpenRequest(payload, process.cwd());
+            if (openRequest.needsClarification) {
+                await savePendingClarification(harness, workflowId, {
+                    rawPayload: payload ?? "",
+                    prompt: openRequest.clarificationQuestion ?? "我需要先确认你的意图。",
+                    options: openRequest.clarificationOptions ?? [],
+                });
+                const outputLines = [openRequest.clarificationQuestion ?? "我需要先确认你的意图。"];
+                if (openRequest.clarificationOptions && openRequest.clarificationOptions.length > 0) {
+                    outputLines.push(...openRequest.clarificationOptions);
+                }
+                return {
+                    ok: true,
+                    output: outputLines.join("\n"),
+                    events: [],
+                };
+            }
+            await initializeWorkflow({
+                workflowId,
+                stateStore: harness.stateStore,
+                artifactEvaluator: harness.artifactEvaluator,
+                userRequest: openRequest.userRequest,
+            });
+            if (foregroundSessionId) {
+                await harness.stateStore.updateRuntime(workflowId, {
+                    preferredForegroundSessionId: foregroundSessionId,
+                });
+            }
+            await harness.attachService.attach(workflowId);
+        }
+        else if (command === "workflow-attach") {
+            const clarification = await renderClarificationIfAny(harness, workflowId);
+            if (clarification) {
+                return clarification;
+            }
+            if (foregroundSessionId) {
+                await harness.stateStore.updateRuntime(workflowId, {
+                    preferredForegroundSessionId: foregroundSessionId,
+                });
+            }
+            await harness.attachService.attach(workflowId);
+        }
+        else if (command === "workflow-answer") {
+            let answers = null;
+            if (payload) {
+                try {
+                    const parsed = JSON.parse(payload);
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        answers = parsed;
+                    }
+                }
+                catch {
+                    answers = null;
+                }
+            }
+            if (answers) {
+                await harness.humanActionService.answer(workflowId, answers);
+            }
+            else {
+                const pending = await readPendingClarification(harness, workflowId);
+                if (!pending) {
+                    throw new Error("workflow_answer received non-JSON payload but no pending clarification was found");
+                }
+                const intentPrompt = buildIntentPromptFromChoice(payload ?? "", pending.rawPayload);
+                await clearPendingClarification(harness, workflowId);
+                await initializeWorkflow({
+                    workflowId,
+                    stateStore: harness.stateStore,
+                    artifactEvaluator: harness.artifactEvaluator,
+                    userRequest: intentPrompt,
+                });
+                if (foregroundSessionId) {
+                    await harness.stateStore.updateRuntime(workflowId, {
+                        preferredForegroundSessionId: foregroundSessionId,
+                    });
+                }
+                await harness.attachService.attach(workflowId);
+            }
+        }
+        else if (command === "workflow-approve") {
+            if (foregroundSessionId) {
+                await harness.stateStore.updateRuntime(workflowId, {
+                    preferredForegroundSessionId: foregroundSessionId,
+                });
+            }
+            await harness.humanActionService.approve(workflowId);
+            await harness.attachService.attach(workflowId);
+        }
+        else if (command === "workflow-resume") {
+            if (foregroundSessionId) {
+                await harness.stateStore.updateRuntime(workflowId, {
+                    preferredForegroundSessionId: foregroundSessionId,
+                });
+            }
+            await harness.humanActionService.resume(workflowId);
+            await harness.attachService.attach(workflowId);
+        }
+        else if (command === "workflow-back") {
+            await harness.sessionActivityMonitor.stop(workflowId);
+            const events = await harness.eventStore.list(workflowId);
+            return {
+                ok: true,
+                output: `Returned from workflow channel for ${workflowId}. Your workflow continues and can be re-attached later.`,
+                events,
+            };
+        }
+        const workflow = await harness.stateStore.getWorkflow(workflowId);
+        const runtime = await harness.stateStore.getRuntime(workflowId);
+        const humanAction = await harness.humanActionStore.getCurrent(workflowId);
+        const events = await harness.eventStore.list(workflowId);
+        const clarification = await readPendingClarification(harness, workflowId);
+        if (!workflow) {
+            if (clarification) {
+                return {
+                    ok: true,
+                    output: [clarification.prompt, ...clarification.options].join("\n"),
+                    events: [],
+                };
+            }
+            throw new Error(`Workflow not found: ${workflowId}`);
+        }
+        const enhancementLines = await buildStatusEnhancements({
+            harness,
+            workflow,
+            events,
+        });
+        return {
+            ok: true,
+            output: [
+                renderHumanActionBlock({
+                    workflow,
+                    runtime,
+                    humanAction,
+                    clarification: clarification
+                        ? { prompt: clarification.prompt, options: clarification.options }
+                        : null,
+                    phaseDetails: enhancementLines,
+                }),
+            ].join("\n"),
+            events,
+        };
+    }
+}

package/dist/packages/runtime/src/commands/opencode-plugin-command-adapter.d.ts

@@ -0,0 +1,20 @@
+import type { WorkflowChannelCommand, WorkflowCommandRunner } from "./workflow-command-runner";
+export interface WorkflowPluginCommandRequest {
+    command: WorkflowChannelCommand;
+    workflowId: string;
+    payload?: string;
+    foregroundSessionId?: string;
+}
+export interface WorkflowPluginCommandResponse {
+    ok: boolean;
+    text: string;
+}
+export interface WorkflowPluginCommandAdapter {
+    execute(request: WorkflowPluginCommandRequest): Promise<WorkflowPluginCommandResponse>;
+}
+export declare class DefaultWorkflowPluginCommandAdapter implements WorkflowPluginCommandAdapter {
+    private readonly runner;
+    private readonly harnessFactory;
+    constructor(runner: WorkflowCommandRunner, harnessFactory: () => Promise<Awaited<ReturnType<typeof import("../bootstrap/create-harness").createHarness>>>);
+    execute(request: WorkflowPluginCommandRequest): Promise<WorkflowPluginCommandResponse>;
+}

package/dist/packages/runtime/src/commands/opencode-plugin-command-adapter.js

@@ -0,0 +1,22 @@
+export class DefaultWorkflowPluginCommandAdapter {
+    runner;
+    harnessFactory;
+    constructor(runner, harnessFactory) {
+        this.runner = runner;
+        this.harnessFactory = harnessFactory;
+    }
+    async execute(request) {
+        const harness = await this.harnessFactory();
+        const result = await this.runner.run({
+            harness,
+            command: request.command,
+            workflowId: request.workflowId,
+            ...(request.payload !== undefined ? { payload: request.payload } : {}),
+            ...(request.foregroundSessionId ? { foregroundSessionId: request.foregroundSessionId } : {}),
+        });
+        return {
+            ok: result.ok,
+            text: result.output,
+        };
+    }
+}

package/dist/packages/runtime/src/commands/workflow-command-runner.d.ts

@@ -0,0 +1,19 @@
+import type { createHarness } from "../bootstrap/create-harness";
+import type { WorkflowEventRecord } from "../events/workflow-event-store";
+export type WorkflowChannelCommand = "workflow-open" | "workflow-attach" | "workflow-status" | "workflow-answer" | "workflow-approve" | "workflow-resume" | "workflow-back";
+export interface WorkflowCommandResult {
+    ok: boolean;
+    output: string;
+    events: WorkflowEventRecord[];
+}
+type Harness = Awaited<ReturnType<typeof createHarness>>;
+export interface WorkflowCommandRunner {
+    run(args: {
+        harness: Harness;
+        command: WorkflowChannelCommand;
+        workflowId: string;
+        payload?: string;
+        foregroundSessionId?: string;
+    }): Promise<WorkflowCommandResult>;
+}
+export {};

package/dist/packages/runtime/src/commands/workflow-command-runner.js

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

package/dist/packages/runtime/src/commands/workflow-open-request.d.ts

@@ -0,0 +1,10 @@
+export interface WorkflowOpenRequest {
+    userRequest: string;
+    prompt: string;
+    docPaths: string[];
+    projectContext?: string;
+    needsClarification: boolean;
+    clarificationQuestion?: string;
+    clarificationOptions?: string[];
+}
+export declare function buildWorkflowOpenRequest(payload: string | undefined, workspaceRoot: string): Promise<WorkflowOpenRequest>;