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

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/cli-operation-classifier.js

@@ -6,6 +6,8 @@ export function classifyCliOperation(args, env = process.env) {
     if (isMbUpgradeMode(args, env)) {
         return { mode: "mb_upgrade", operation, family, command, action };
     }
+    if (family === "run" && command === "reconcile" && !args.includes("--apply"))
+        return { mode: "read_only_diagnostics", operation, family, command, action };
     if (isRouterNative(args)) {
         return { mode: "router_native", operation, family, command, action };
     }
@@ -85,6 +87,8 @@ function isRouterNative(args) {
         return true;
     if (["engine", "version", "schema"].includes(first))
         return true;
+    if (first === "run" && args[1] === "reconcile")
+        return true;
     if (first === "storage" && args[1] === "migrate-writer")
         return true;
     return (first === "codex" && args[1] === "hook" && args[2] === "handle")

package/dist/services/cli-upgrade-allowlist.js

@@ -0,0 +1,27 @@
+import { parseCommandArgs } from "./lifecycle-command.js";
+/** Syntax eligibility only. Storage/project/RUN authority is checked separately. */
+export function isUpgradeAllowlisted(args) {
+    const parsed = parseCommandArgs(args), [family, command] = parsed.positional;
+    const option = (name) => {
+        const value = parsed.options.get(name)?.at(-1);
+        return value && value !== "__dd_flow_flag__" ? value : null;
+    };
+    if (family === "status")
+        return true;
+    if (family === "engine" && command === "resolve")
+        return true;
+    if (family === "migration" && ["impact", "plan", "report", "verify", "apply"].includes(command ?? ""))
+        return true;
+    if (family === "memory" && command === "permissions" && parsed.positional[2] === "preflight")
+        return true;
+    if (family === "run" && command === "start")
+        return option("flow-kind") === "mb-upgrade";
+    const bound = Boolean(option("run") || parsed.positional.some(value => value.startsWith("RUN-")));
+    if (family === "stage" && ["start", "pause", "resume", "finish"].includes(command ?? ""))
+        return bound;
+    if (family === "session" && ["status", "register", "stop", "usage"].includes(command ?? ""))
+        return bound;
+    if (family === "dashboard" && ["data", "render", "refresh", "open"].includes(command ?? ""))
+        return true;
+    return false;
+}

package/dist/services/discovery/agy-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverAgy = (input) => discoverExecutable("agy", ["agy"], input);

package/dist/services/discovery/codex-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverCodex = (input) => discoverExecutable("codex", ["codex"], input);

package/dist/services/discovery/droid-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverDroid = (input) => discoverExecutable("droid", ["droid"], input);

package/dist/services/discovery/grok-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverGrok = (input) => discoverExecutable("grok", ["grok"], input);

package/dist/services/discovery/opencode-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverOpenCode = (input) => discoverExecutable("opencode", ["opencode"], input);

package/dist/services/discovery/static.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AppError } from "../../shared/errors.js";
+/** Presence only: no child process, config/credential read, network or generative probe. */
+export function discoverExecutable(harness, names, input) {
+    const platform = input.platform ?? process.platform;
+    if (input.executable && !path.isAbsolute(input.executable))
+        throw new AppError("usage", "Explicit executable must be an absolute path", 2, { effect: "no_effect" });
+    const suffixes = platform === "win32" ? (input.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(suffix => /^\.[A-Za-z0-9]+$/.test(suffix)) : [""];
+    const paths = input.executable ? [input.executable] : (input.env.PATH ?? "").split(platform === "win32" ? ";" : path.delimiter)
+        .filter(directory => path.isAbsolute(directory)).flatMap(directory => names.flatMap(name => suffixes.map(suffix => path.join(directory, `${name}${suffix}`))));
+    const candidates = new Map();
+    let unreadable = false;
+    for (const file of paths) {
+        try {
+            if (!fs.statSync(file).isFile())
+                continue;
+            fs.accessSync(file, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+            candidates.set(fs.realpathSync(file), file);
+        }
+        catch (error) {
+            if (!["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+                unreadable = true;
+        }
+    }
+    const selected = candidates.size === 1;
+    return { harness, candidates: [...candidates.keys()].map(file => ({ path: file, version: null, selected })),
+        installed: selected ? "yes" : candidates.size > 1 || unreadable ? "unknown" : "no",
+        compatible: "unknown", protocol: "unknown", auth: "unknown", qualified: "unknown", evidence: [],
+        reason: selected ? "executable_present_no_qualification_probe" : candidates.size > 1 ? "multiple_installations_require_explicit_selection" : unreadable ? "filesystem_observation_incomplete" : "executable_not_found" };
+}

package/dist/services/discovery/zcode-discovery.js

@@ -0,0 +1,2 @@
+import { discoverExecutable } from "./static.js";
+export const discoverZcode = (input) => discoverExecutable("zcode", ["zcode"], input);

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";
 }
@@ -31,7 +30,7 @@ export function isRouterNativeCommand(args) {
         return true;
     if (args.includes("--help") || args.includes("-h"))
         return true;
-    return routerNativeFamilies.has(first) || first === "codex" && args[1] === "hook" && args[2] === "handle";
+    return first === "run" && args[1] === "reconcile" || routerNativeFamilies.has(first) || first === "codex" && args[1] === "hook" && args[2] === "handle";
 }
 export function installCurrentEngine(context, input = {}) {
     const installation = prepareInstallation(context, input);
@@ -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;