@deksden-com/dd-flow-cli 0.9.0-beta.134 → 0.9.0-beta.135

package/dist/harness-runtime/vendor/opencode-client/service.d.ts

@@ -0,0 +1,52 @@
+/** Connection details for a local OpenCode service. */
+export type Endpoint = {
+    /** Base URL of the service. */
+    readonly url: string;
+    /** Authentication required by the service, when configured. */
+    readonly auth?: {
+        /** HTTP authentication scheme. */
+        readonly type: "basic";
+        /** Basic authentication username. */
+        readonly username: string;
+        /** Basic authentication password. */
+        readonly password: string;
+    };
+};
+/** Options used to discover the local OpenCode service. */
+export type DiscoverOptions = {
+    /** Absolute registration file path. Defaults to the XDG state directory. */
+    readonly file?: string;
+    /** Required exact service version or compatibility predicate. */
+    readonly version?: string | ((version: string) => boolean);
+};
+/** Reason ensuring the service requires a new process. */
+export type EnsureReason = "missing" | "version-mismatch";
+/** Options used to ensure the local OpenCode service is running. */
+export type EnsureOptions = DiscoverOptions & {
+    /** Service command and arguments. Defaults to `opencode serve --service`. */
+    readonly command?: ReadonlyArray<string>;
+    /** Environment variables added to the inherited service process environment. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Called once before spawning a new service process. */
+    readonly onStart?: (reason: EnsureReason, previousVersion?: string) => void;
+};
+/** Options used to stop the local OpenCode service. */
+export type StopOptions = {
+    /** Absolute registration file path. Defaults to the XDG state directory. */
+    readonly file?: string;
+    /** How to handle persistent terminals before stopping the service. */
+    readonly pty?: "clear" | "handoff";
+};
+/** Contents of the local service registration file. */
+export type Info = {
+    /** Unique service instance identifier. */
+    readonly id?: string;
+    /** OpenCode version served by the process. */
+    readonly version?: string;
+    /** Base URL advertised by the service. */
+    readonly url: string;
+    /** Operating system process identifier. */
+    readonly pid: number;
+    /** Private service password, when authentication is enabled. */
+    readonly password?: string;
+};

package/dist/harness-runtime/vendor/opencode-client/service.js

@@ -0,0 +1 @@
+import"./chunks/service-probe-qav6mfdz.js";

package/dist/harness-runtime/vendor/opencode-client/shared-events.d.ts

@@ -0,0 +1,11 @@
+export * as SharedEvents from "./shared-events.js";
+export type SubscribeOptions = {
+    readonly signal?: AbortSignal;
+    /** Reports transport activity on the shared stream, including keepalive frames that carry no event. */
+    readonly onActivity?: () => void;
+};
+export declare function make<A extends {
+    readonly type: string;
+}>(connect: (signal: AbortSignal, onActivity: () => void) => AsyncIterable<A>): {
+    subscribe(options?: SubscribeOptions): AsyncIterable<A>;
+};

package/dist/harness-runtime/vendor/opencode-client/shared-events.js

@@ -0,0 +1,8 @@
+import {
+  make7,
+  exports_shared_events
+} from "./chunks/service-probe-frbwqjmf.js";
+export {
+  exports_shared_events as SharedEvents,
+  make7 as make
+};

package/dist/harness-runtime/vendor/opencode-client/solid/connection.d.ts

@@ -0,0 +1,37 @@
+import type { OpenCodeClient, OpenCodeEvent } from "../promise";
+export type ClientConnectionStatus = "connected" | "connecting" | "reconnecting";
+export type ClientConnectionEvent = {
+    readonly type: "client.connection";
+    readonly created: number;
+    readonly data: {
+        readonly status: "connecting" | "connected" | "disconnected" | "reconnecting";
+        readonly attempt: number;
+        readonly error?: string;
+    };
+};
+export type ClientConnectionOptions = {
+    readonly reconnect?: (signal: AbortSignal) => Promise<OpenCodeClient>;
+    readonly onEvent: (event: OpenCodeEvent) => void;
+    readonly flushInterval?: number;
+    readonly pageLifecycle?: boolean;
+    /**
+     * Abort and reconnect a stream that receives no bytes for this long. The server writes a keepalive
+     * comment every 15 seconds, so a quiet but healthy stream never trips this.
+     */
+    readonly idleTimeout?: number;
+    readonly log?: {
+        readonly debug?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
+        readonly info?: (message: string, data?: Readonly<Record<string, unknown>>) => void;
+    };
+};
+export declare const defaultIdleTimeout = 45000;
+export declare const foregroundIdleThreshold = 20000;
+export declare function createClientConnection(initialApi: OpenCodeClient, options: ClientConnectionOptions): {
+    status: () => ClientConnectionStatus;
+    attempt: () => number;
+    error: () => string | undefined;
+    internal: {
+        history: () => ClientConnectionEvent[];
+        resync: (reason: string) => void;
+    };
+};

package/dist/harness-runtime/vendor/opencode-client/solid/connection.js

@@ -0,0 +1,10 @@
+import {
+  defaultIdleTimeout2,
+  foregroundIdleThreshold2,
+  createClientConnection2
+} from "../chunks/service-probe-ydhz1zrh.js";
+export {
+  createClientConnection2 as createClientConnection,
+  defaultIdleTimeout2 as defaultIdleTimeout,
+  foregroundIdleThreshold2 as foregroundIdleThreshold
+};

package/dist/harness-runtime/vendor/opencode-client/solid/data.d.ts

@@ -0,0 +1,211 @@
+import type { AgentInfo, CommandInfo, ConfigEntry, SessionFormCancelInput, FormInfo, SessionFormReplyInput, IntegrationInfo, LocationRef, McpResource, McpServer, ModelInfo, ModelRef, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, SessionInboxCompaction, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
+import { type SessionPromptInput } from "../promise";
+export type DataSessionStatus = "idle" | "running";
+/**
+ * Where a pending user prompt stands relative to the runner: `starting` is promoted at the next idle boundary,
+ * `steering` waits for the next step boundary of an execution that already delivered input, `stranded` outlived an
+ * execution that ended without delivering it, and `queued` waits for every steer to drain.
+ */
+export type DataPendingStatus = "starting" | "steering" | "stranded" | "queued";
+type OpenCodeEventMap = {
+    [Type in OpenCodeEvent["type"]]: Extract<OpenCodeEvent, {
+        type: Type;
+    }>;
+};
+export type CreateDataInput = {
+    readonly api: () => OpenCodeClient;
+    readonly directory: string;
+    /** Raw-message window used for an initial transcript read. Older pages retain their normal size. */
+    readonly initialMessageLimit?: () => number;
+    readonly event: {
+        readonly on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
+        readonly listen: (handler: (event: {
+            name: OpenCodeEvent["type"];
+            details: OpenCodeEvent;
+        }) => void) => () => void;
+    };
+    readonly connection?: {
+        readonly status: () => "connected" | "connecting" | "reconnecting";
+    };
+    /** Receives failed event-driven reads. Explicit reads still reject to their caller. */
+    readonly onError?: (error: unknown) => void;
+};
+export declare const settleMs = 150;
+export type FormWithLocation = FormInfo & {
+    readonly location?: LocationRef;
+};
+type ShellWithLocation = ShellInfo & {
+    readonly location: LocationRef;
+};
+export declare function locationKey(location: LocationRef): string;
+export declare function createData(config: CreateDataInput): {
+    on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
+    listen: (handler: (event: {
+        name: OpenCodeEvent["type"];
+        details: OpenCodeEvent;
+    }) => void) => () => void;
+    session: {
+        list(): SessionInfo[];
+        get(sessionID: string): SessionInfo;
+        creating(sessionID: string): boolean;
+        remember(info: SessionInfo): void;
+        setStatus(sessionID: string, status: DataSessionStatus): void;
+        root(sessionID: string): string;
+        family(sessionID: string): string[];
+        /** Clear heavy cached data for the root and all known descendants. */
+        evict(sessionID: string): void;
+        cost(sessionID: string): number;
+        status(sessionID: string): DataSessionStatus;
+        active(): string[];
+        input: {
+            list(sessionID: string): string[];
+            has(sessionID: string, inboxID: string): boolean;
+        };
+        pending: {
+            list(sessionID: string): SessionInboxInfo[];
+            status(sessionID: string, inboxID: string): DataPendingStatus | undefined;
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        create(input: {
+            id?: string;
+            title?: string;
+            agent?: string;
+            model?: ModelRef;
+            location?: LocationRef;
+            projectID?: string;
+        }): {
+            id: string;
+            request: Promise<SessionInfo>;
+        };
+        compact(input: {
+            sessionID: string;
+            model?: ModelRef;
+        }): Promise<SessionInboxCompaction>;
+        prompt(input: SessionPromptInput & {
+            gate?: Promise<unknown>;
+            prepare?: () => Promise<unknown>;
+        }): Promise<import("../promise").SessionInboxUser>;
+        sync(sessionID: string, options?: {
+            children?: boolean;
+        }): Promise<void>;
+        invalidate(sessionID: string): void;
+        message: {
+            list(sessionID: string): SessionMessageInfo[];
+            get(sessionID: string, messageID: string): SessionMessageInfo | undefined;
+            sync(sessionID: string): Promise<void>;
+            more(sessionID: string): boolean;
+            loading(sessionID: string): boolean;
+            loadMore(sessionID: string, options?: {
+                all?: boolean;
+                signal?: AbortSignal;
+                /** Runs synchronously inside the store-publication batch. */
+                beforePublish?: () => void;
+            }): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        permission: {
+            list(sessionID: string): PermissionRequest[];
+            sessions(): string[];
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+            reply(input: PermissionReplyInput): Promise<void>;
+        };
+        form: {
+            list(sessionID: string, ref?: LocationRef): FormWithLocation[] | undefined;
+            sessions(): string[];
+            sync(sessionID: string, ref?: LocationRef): Promise<void>;
+            invalidate(sessionID: string, ref?: LocationRef): void;
+            reply(input: SessionFormReplyInput, ref?: LocationRef): Promise<void>;
+            cancel(input: SessionFormCancelInput, ref?: LocationRef): Promise<void>;
+        };
+    };
+    project: {
+        list(): Project[];
+        get(projectID: string): Project;
+        sync(): Promise<void>;
+        invalidate(): void;
+        permission: {
+            list(projectID: string): PermissionSavedInfo[];
+            sync(projectID: string): Promise<void>;
+            invalidate(projectID: string): void;
+        };
+    };
+    shell: {
+        list(location?: LocationRef): ShellWithLocation[];
+        listBySession(sessionID: string): ShellWithLocation[];
+        get(id: string): ShellWithLocation | undefined;
+        sync: (ref?: LocationRef) => Promise<void>;
+        invalidate: (ref?: LocationRef) => void;
+    };
+    location: {
+        info(ref?: LocationRef): import("../promise").LocationPublicInfo | undefined;
+        default(): LocationRef;
+        syncInfo(ref?: LocationRef): Promise<void>;
+        sync(ref?: LocationRef): Promise<void>;
+        invalidate(ref?: LocationRef): void;
+        vcs: {
+            info: (ref?: LocationRef) => VcsInfo | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        agent: {
+            list: (ref?: LocationRef) => AgentInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        command: {
+            list: (ref?: LocationRef) => CommandInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        config: {
+            list: (ref?: LocationRef) => ConfigEntry[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        integration: {
+            list: (ref?: LocationRef) => IntegrationInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        mcp: {
+            server: {
+                list: (ref?: LocationRef) => McpServer[] | undefined;
+                sync: (ref?: LocationRef) => Promise<void>;
+                invalidate: (ref?: LocationRef) => void;
+            };
+            resource: {
+                list: (ref?: LocationRef) => McpResource[] | undefined;
+                sync: (ref?: LocationRef) => Promise<void>;
+                invalidate: (ref?: LocationRef) => void;
+            };
+        };
+        model: {
+            list: (ref?: LocationRef) => ModelInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        provider: {
+            list: (ref?: LocationRef) => ProviderInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        reference: {
+            list: (ref?: LocationRef) => ReferenceInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+        websearch: {
+            list(location?: LocationRef): WebSearchProvider[] | undefined;
+            refresh(ref?: LocationRef): Promise<void>;
+        };
+        skill: {
+            list: (ref?: LocationRef) => SkillInfo[] | undefined;
+            sync: (ref?: LocationRef) => Promise<void>;
+            invalidate: (ref?: LocationRef) => void;
+        };
+    };
+};
+export type Data = ReturnType<typeof createData>;
+export {};

package/dist/harness-runtime/vendor/opencode-client/solid/data.js

@@ -0,0 +1,18 @@
+import {
+  settleMs2,
+  locationKey2,
+  createData2
+} from "../chunks/service-probe-9vdz0zwn.js";
+import"../chunks/service-probe-m2eywc8w.js";
+import"../chunks/service-probe-wjyeq25y.js";
+import"../chunks/service-probe-vyas3vgt.js";
+import"../chunks/service-probe-ecs5ftka.js";
+import"../chunks/service-probe-1y4a697q.js";
+import"../chunks/service-probe-nwcpakzx.js";
+import"../chunks/service-probe-vt9jbch8.js";
+import"../chunks/service-probe-frbwqjmf.js";
+export {
+  createData2 as createData,
+  locationKey2 as locationKey,
+  settleMs2 as settleMs
+};

package/dist/harness-runtime/vendor/opencode-client/solid/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./data";
+export * from "./connection";
+export * from "./pty";

package/dist/harness-runtime/vendor/opencode-client/solid/index.js

@@ -0,0 +1,32 @@
+import"../chunks/service-probe-nwcpakzx.js";
+import"../chunks/service-probe-ecs5ftka.js";
+import"../chunks/service-probe-vt9jbch8.js";
+import"../chunks/service-probe-vyas3vgt.js";
+import"../chunks/service-probe-frbwqjmf.js";
+import"../chunks/service-probe-1y4a697q.js";
+import"../chunks/service-probe-wjyeq25y.js";
+import"../chunks/service-probe-m2eywc8w.js";
+import {
+  settleMs2,
+  locationKey2,
+  createData2
+} from "../chunks/service-probe-9vdz0zwn.js";
+import {
+  defaultIdleTimeout2,
+  foregroundIdleThreshold2,
+  createClientConnection2
+} from "../chunks/service-probe-ydhz1zrh.js";
+import {
+  createPtyClient2,
+  createPersistentPtyClient2
+} from "../chunks/service-probe-gne7h7mq.js";
+export {
+  createClientConnection2 as createClientConnection,
+  createData2 as createData,
+  createPersistentPtyClient2 as createPersistentPtyClient,
+  createPtyClient2 as createPtyClient,
+  defaultIdleTimeout2 as defaultIdleTimeout,
+  foregroundIdleThreshold2 as foregroundIdleThreshold,
+  locationKey2 as locationKey,
+  settleMs2 as settleMs
+};

package/dist/harness-runtime/vendor/opencode-client/solid/pty.d.ts

@@ -0,0 +1,22 @@
+import type { ExperimentalPersistentPtyConnectTokenInput, OpenCodeClient, PtyConnectTokenInput } from "../promise";
+export type PtyClientOptions = {
+    readonly url: string;
+    readonly openSocket?: (url: URL) => WebSocket;
+};
+export type PtyConnectInput = {
+    readonly ptyID: PtyConnectTokenInput["ptyID"];
+    readonly location?: PtyConnectTokenInput["location"];
+    readonly cursor?: number;
+};
+export type PersistentPtyConnectInput = {
+    readonly ptyID: ExperimentalPersistentPtyConnectTokenInput["ptyID"];
+    readonly cursor: number;
+    readonly attachmentID: string;
+    readonly takeover?: boolean;
+};
+export declare function createPtyClient(api: OpenCodeClient, options: PtyClientOptions): {
+    connect(input: PtyConnectInput): Promise<WebSocket>;
+};
+export declare function createPersistentPtyClient(api: OpenCodeClient, options: PtyClientOptions): {
+    connect(input: PersistentPtyConnectInput): Promise<WebSocket>;
+};

package/dist/harness-runtime/vendor/opencode-client/solid/pty.js

@@ -0,0 +1,8 @@
+import {
+  createPtyClient2,
+  createPersistentPtyClient2
+} from "../chunks/service-probe-gne7h7mq.js";
+export {
+  createPersistentPtyClient2 as createPersistentPtyClient,
+  createPtyClient2 as createPtyClient
+};

package/dist/harness-runtime/vendor/opencode-plugin.mjs

@@ -0,0 +1,3 @@
+export function define(plugin) {
+    return plugin;
+}

package/dist/services/engines.js

@@ -19,7 +19,6 @@ import { allRunEngineBindings, locateRunRoot, readRunEngineBinding, runEngineBin
 export const engineManifestSchemaId = "dd-flow/engine-manifest@1";
 const routerNativeFamilies = new Set(["engine", "version", "schema"]);
 const sourceFile = fileURLToPath(import.meta.url);
-const packageRequire = createRequire(sourceFile);
 export function isEngineMode(env) {
     return env.DD_FLOW_ENGINE_MODE === "1";
 }
@@ -716,7 +715,7 @@ function copyPackageSnapshot(packageRoot, target) {
     }
 }
 /** The same source inventory drives validation and copying; no staging writes. */
-function packageSnapshotFiles(packageRoot) {
+export function packageSnapshotFiles(packageRoot) {
     const files = new Map();
     const collect = (source, relative, skipNodeModules = false) => {
         if (!fs.statSync(source).isDirectory()) {
@@ -739,8 +738,9 @@ function packageSnapshotFiles(packageRoot) {
             continue;
         collect(from, item);
     }
-    const queue = [{ sourceRoot: packageRoot, targetRoot: "", ancestors: new Set() }];
-    const copied = new Set();
+    const queue = [{ sourceRoot: packageRoot, targetRoot: "" }];
+    const placed = new Map();
+    const virtualRoot = path.resolve(path.sep, "dd-flow-snapshot");
     while (queue.length > 0) {
         const current = queue.shift();
         if (!current)
@@ -749,15 +749,19 @@ function packageSnapshotFiles(packageRoot) {
             const sourceRoot = resolvePackageRoot(dependency, current.sourceRoot);
             if (!sourceRoot)
                 throw new AppError("engine_install_failed", `Cannot resolve runtime dependency: ${dependency}`, 1);
-            const targetRoot = path.join(current.targetRoot, "node_modules", dependency);
-            const copyKey = `${sourceRoot}\n${targetRoot}`;
-            if (copied.has(copyKey))
+            // Standard Node lookup permits hoisting identical selected packages.
+            // Copying a shared DAG under every parent makes SDK snapshots grow
+            // exponentially; conflicting versions still need their own local slot.
+            const search = createRequire(path.join(virtualRoot, current.targetRoot, "package.json")).resolve.paths(dependency) ?? [];
+            const candidates = search.filter(directory => directory.startsWith(`${virtualRoot}${path.sep}`))
+                .map(directory => path.relative(virtualRoot, path.join(directory, dependency)));
+            const existing = candidates.find(candidate => placed.has(candidate));
+            if (existing && placed.get(existing) === sourceRoot)
                 continue;
-            copied.add(copyKey);
+            const targetRoot = existing ? path.join(current.targetRoot, "node_modules", dependency) : path.join("node_modules", dependency);
+            placed.set(targetRoot, sourceRoot);
             collect(sourceRoot, targetRoot, true);
-            if (current.ancestors.has(sourceRoot))
-                continue;
-            queue.push({ sourceRoot, targetRoot, ancestors: new Set([...current.ancestors, sourceRoot]) });
+            queue.push({ sourceRoot, targetRoot });
         }
     }
     return files;
@@ -806,20 +810,14 @@ function readProductionDependencies(packageRoot) {
     }
 }
 function resolvePackageRoot(name, from) {
-    try {
-        let current = path.dirname(packageRequire.resolve(name, { paths: [from] }));
-        while (true) {
-            if (fs.existsSync(path.join(current, "package.json")))
-                return fs.realpathSync(current);
-            const parent = path.dirname(current);
-            if (parent === current)
-                return null;
-            current = parent;
-        }
-    }
-    catch {
-        return null;
+    // Inspect package roots through Node's lookup paths, not the require entry:
+    // production dependencies can expose only an ESM import condition.
+    for (const directory of createRequire(path.join(from, "package.json")).resolve.paths(name) ?? []) {
+        const candidate = path.join(directory, name);
+        if (fs.existsSync(path.join(candidate, "package.json")))
+            return fs.realpathSync(candidate);
     }
+    return null;
 }
 function inferInstallSource(packageRoot, ddFlowHome) {
     const normalized = path.resolve(packageRoot);

package/dist/services/eval-snapshots.js

@@ -998,7 +998,7 @@ function nativeDaemonFile(file) {
         return false;
     try {
         const state = JSON.parse(fs.readFileSync(file, "utf8"));
-        return typeof state.daemon_id === "string" && /^dd-(codex|zcode|grok|agy|opencode|droid)\/daemon-state@1$/.test(String(state.schema_id));
+        return typeof state.daemon_id === "string" && (/^dd-(codex|zcode|grok|agy|opencode|droid)\/daemon-state@1$/.test(String(state.schema_id)) || state.schema_id === "dd-opencode/daemon-state@2");
     }
     catch {
         return false;

package/dist/services/external-work-launch.js

@@ -123,7 +123,7 @@ export async function launchExternalWork(context, input) {
             prompted = await call(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], null);
         }
         catch (error) {
-            if (runtimeHarness(resolved.worker) !== "codex-desktop")
+            if (!["codex-desktop", "opencode-server"].includes(runtimeHarness(resolved.worker)))
                 throw error;
             const retained = context.db.get("SELECT adapter_receipt_json FROM work_launches WHERE operation_id = ?", [operationId]);
             const capacityIntents = retained?.adapter_receipt_json ? JSON.parse(retained.adapter_receipt_json).capacity_intents ?? [] : [];

package/dist/services/hooks.js

@@ -843,7 +843,7 @@ function handleControlledToolEvent(context, input, event, harness) {
         });
         return { ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session: nativeSessionIdentity(harness, providerSessionId), ...(nativeParentId ? { parent_session: nativeSessionIdentity(harness, nativeParentId) } : {}) };
     }
-    if (!command || !(droid ? ["Execute"] : ["bash", "Bash", "run_command", "run_terminal_command", "RunTerminalCommand"]).includes(toolName)) {
+    if (!command || !(droid ? ["Execute"] : ["bash", "Bash", "shell", "run_command", "run_terminal_command", "RunTerminalCommand"]).includes(toolName)) {
         return { ok: true, observed: false, reason: command ? "non_bash_tool" : "event_not_participating" };
     }
     const lifecycle = lifecycleFacts(command);

package/dist/services/merge-server.js

@@ -164,7 +164,7 @@ async function dispatch(context, input) {
             prompted = await adapterCall(["session", "prompt", "--session-id", sessionId, "--prompt-file", promptFile, ...common], null, `MERGE ${input.request.merge_request_id} Session ${sessionId} is still running`);
         }
         catch (error) {
-            if (runtimeHarness(input.profile) !== "codex-desktop")
+            if (!["codex-desktop", "opencode-server"].includes(runtimeHarness(input.profile)))
                 throw error;
             const capacityIntents = (retained.capacity_intents ?? []);
             const capacityFailures = (retained.capacity_failures ?? []);

package/dist/services/run-controller-recovery.js

@@ -211,10 +211,10 @@ export async function resumeControllerSession(context, row, manifest, state, ass
         receipt = await sendAck(dispatch.operation_id, dispatch.prompt);
     }
     catch (error) {
-        if (runtimeHarness(session.profile) !== "codex-desktop")
+        if (!["codex-desktop", "opencode-server"].includes(runtimeHarness(session.profile)))
             throw error;
         const continuationText = `Continue the same retained Session and recovery generation. First inspect the current RUN recovery state; only if the exact ACK still awaits acceptance, execute the exact standalone acceptance command below once. Never deliver it again after acceptance. Then stop at the original Stage or Work-graph boundary.\n\n${dispatch.prompt}`;
-        const inspect = (args, operationId) => runHarnessAdapter({ executable: manifest.adapters["codex-desktop"].executable,
+        const inspect = (args, operationId) => runHarnessAdapter({ executable: manifest.adapters[runtimeHarness(session.profile)].executable,
             args, env: controllerEnvironment(executionContext, manifest, session), runtimeOwner: session.owner, operationId, timeoutMs: 30_000 });
         const resumed = await continueCodexCapacity({ error, sessionId: session.id, operationId: dispatch.operation_id, allowSettledDescendants: true, continuationText,
             retainedIntents: () => {

package/dist/services/run-controller.js

@@ -578,12 +578,12 @@ async function executeController(context, row, manifest, state, assertOwnership,
                 receipt = await send(text, firstOperationId);
             }
             catch (error) {
-                if (runtimeHarness(session.profile) !== "codex-desktop")
+                if (!["codex-desktop", "opencode-server"].includes(runtimeHarness(session.profile)))
                     throw error;
                 const resumeCommand = hitl ? text.split("\n\n")[1] : undefined;
                 if (hitl && !resumeCommand?.includes(" stage resume "))
                     throw error;
-                const inspect = (args, id) => runHarnessAdapter({ executable: manifest.adapters["codex-desktop"].executable,
+                const inspect = (args, id) => runHarnessAdapter({ executable: manifest.adapters[runtimeHarness(session.profile)].executable,
                     args, env: controllerEnvironment(context, manifest, session), runtimeOwner: session.owner, operationId: id, timeoutMs: 30_000, signal: cancellation.signal });
                 const resumed = await continueCodexCapacity({ error, sessionId: session.id, operationId: firstOperationId, signal: cancellation.signal, allowSettledDescendants: true, atomicIntent: true,
                     retainedIntents: () => context.db.all("SELECT receipt_json FROM run_controller_operations WHERE controller_id = ? AND generation = ?", [row.controller_id, row.generation])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.134",
+  "version": "0.9.0-beta.135",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",
@@ -41,6 +41,8 @@
     "release:publish": "node scripts/publish-release.mjs"
   },
   "devDependencies": {
+    "@opencode/client": "2.0.28",
+    "@opencode/plugin": "2.0.28",
     "@changesets/cli": "^2.31.0",
     "@eslint/js": "^9.39.1",
     "@types/node": "^24.10.1",
@@ -51,6 +53,7 @@
   },
   "dependencies": {
     "ajv": "^8.20.0",
+    "jsonc-parser": "3.3.1",
     "shell-quote": "^1.10.0",
     "smol-toml": "^1.6.1",
     "tree-sitter": "0.25.1",