akm-cli 0.9.0-beta.9 → 0.9.0-rc.1

package/dist/integrations/harnesses/gemini/result-extractor.js

@@ -0,0 +1,121 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Keys that may carry the final answer, in precedence order. `response` is
+ * Gemini's documented `--output-format json` envelope key.
+ */
+const TEXT_KEYS = ["response", "result", "text", "output", "content", "message"];
+/** Keys that may carry the harness-native session id, in precedence order. */
+const SESSION_KEYS = ["session_id", "sessionId", "conversation_id", "conversationId", "chat_id", "chatId"];
+/**
+ * Coerce a candidate value into text. Handles the shapes Gemini nests
+ * answers in: bare strings, `{content|text}` wrappers (assistant message
+ * objects), and arrays of `{type:"text",text}` content blocks (Gemini API
+ * `parts`-style lists). Depth-bounded: JSON.parse output is acyclic, but
+ * nesting is capped anyway so a pathological envelope cannot recurse
+ * unboundedly.
+ */
+function textOf(value, depth = 0) {
+    if (depth > 4)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        const parts = [];
+        for (const block of value) {
+            const t = textOf(block, depth + 1);
+            if (t)
+                parts.push(t);
+        }
+        return parts.length > 0 ? parts.join("\n") : undefined;
+    }
+    if (isRecord(value)) {
+        return textOf(value.content ?? value.text, depth + 1);
+    }
+    return undefined;
+}
+/** Extract the final-answer text from one parsed JSON value, if any. */
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isRecord(value))
+        return undefined;
+    for (const key of TEXT_KEYS) {
+        if (!(key in value))
+            continue;
+        const text = textOf(value[key]);
+        if (text !== undefined)
+            return text;
+    }
+    return undefined;
+}
+/** Extract a harness-native session id from one parsed JSON value, if any. */
+function extractSessionId(value) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of SESSION_KEYS) {
+        const candidate = value[key];
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return undefined;
+}
+/** JSON.parse that returns undefined instead of throwing. */
+function tryParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Normalize a raw gemini run result into `{ text, sessionId? }`.
+ * See the module doc for the three stdout shapes handled.
+ */
+export const geminiResultExtractor = (result) => {
+    // The raw result's own sessionId (SDK-style paths) is the fallback; an id
+    // found in the output stream wins because it is fresher.
+    const fallbackSessionId = result.sessionId;
+    const raw = result.stdout.trim();
+    // Shape 1 — whole stdout is one JSON document (spawn may have pre-parsed
+    // it when the profile requested parseOutput: "json").
+    const whole = result.parsed !== undefined ? result.parsed : raw.length > 0 ? tryParseJson(raw) : undefined;
+    if (whole !== undefined) {
+        const sessionId = extractSessionId(whole) ?? fallbackSessionId;
+        // Unknown envelope (no recognized text key — includes the error-only
+        // variant): fall back to raw stdout so downstream embedded-JSON parsing
+        // and failure handling still have the full material to work with.
+        const text = extractText(whole) ?? raw;
+        return { text, ...(sessionId ? { sessionId } : {}) };
+    }
+    // Shape 2 — JSONL event stream: last text-bearing event wins; first
+    // session-id-bearing event supplies the id. Non-JSON lines are banner
+    // noise and are skipped.
+    let lastText;
+    let streamSessionId;
+    let sawJsonLine = false;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        const event = tryParseJson(trimmed);
+        if (event === undefined)
+            continue;
+        sawJsonLine = true;
+        streamSessionId ??= extractSessionId(event);
+        const text = extractText(event);
+        if (text !== undefined)
+            lastText = text;
+    }
+    if (sawJsonLine) {
+        const sessionId = streamSessionId ?? fallbackSessionId;
+        return { text: lastText ?? raw, ...(sessionId ? { sessionId } : {}) };
+    }
+    // Shape 3 — plain text passthrough.
+    return { text: raw, ...(fallbackSessionId ? { sessionId: fallbackSessionId } : {}) };
+};

package/dist/integrations/harnesses/index.js

@@ -17,9 +17,22 @@
  * harness in #563/#564; this step only owns ids + capability membership and
  * wires the existing call sites to consult it (behaviour-preserving).
  */
+import { AiderHarness } from "./aider/index.js";
+import { AmazonqHarness } from "./amazonq/index.js";
 import { ClaudeHarness } from "./claude/index.js";
+import { CodexHarness } from "./codex/index.js";
+import { CopilotHarness } from "./copilot/index.js";
+import { GeminiHarness } from "./gemini/index.js";
 import { OpencodeHarness } from "./opencode/index.js";
-import { OpencodeSdkHarness } from "./opencode-sdk/index.js";
+// Import the descriptor from its LEAF module, not the per-harness barrel: the
+// barrel re-exports `./sdk-runner` (which imports `core/config`, and
+// `core/config/config-types` derives `VALID_HARNESS_IDS` back from this file).
+// Importing the class through the barrel would form an initialization cycle
+// that throws a TDZ error when the barrel is the first module loaded in a fresh
+// graph (see ./opencode-sdk/harness.ts). This keeps the registry a config-leaf.
+import { OpencodeSdkHarness } from "./opencode-sdk/harness.js";
+import { OpenhandsHarness } from "./openhands/index.js";
+import { PiHarness } from "./pi/index.js";
 // Each harness descriptor (ClaudeHarness, OpencodeHarness, OpencodeSdkHarness)
 // lives in its own per-harness directory alongside that harness's session-log
 // reader, agent builder, config importer, and/or SDK runner (#563/#564). They
@@ -33,13 +46,22 @@ import { OpencodeSdkHarness } from "./opencode-sdk/index.js";
  * `z.enum(...)`, and the `platform` union all need the literal types.
  */
 // Order is significant: VALID_HARNESS_IDS derives from this array and feeds the
-// committed JSON-schema enum order. Kept as [opencode, claude, opencode-sdk] to
-// match the pre-unification VALID_HARNESS_IDS so the generated schema does not
-// drift (behaviour-preserving, #562).
+// committed JSON-schema enum order. The original [opencode, claude,
+// opencode-sdk] prefix is preserved so the pre-unification portion of the
+// generated schema enum does not reorder (#562); the seven P2 harness adapters
+// (plan §"Capability matrix") are appended after it, which extends the enum
+// additively (schemas/akm-config.json is regenerated in lockstep).
 export const HARNESS_REGISTRY = Object.freeze([
     new OpencodeHarness(),
     new ClaudeHarness(),
     new OpencodeSdkHarness(),
+    new CodexHarness(),
+    new CopilotHarness(),
+    new PiHarness(),
+    new GeminiHarness(),
+    new AiderHarness(),
+    new AmazonqHarness(),
+    new OpenhandsHarness(),
 ]);
 /** Lookup by canonical id. */
 export const HARNESS_BY_ID = new Map(HARNESS_REGISTRY.map((h) => [h.id, h]));
@@ -60,9 +82,8 @@ const HARNESS_BY_ANY_ID = (() => {
 })();
 /**
  * Canonical, ordered list of valid harness / platform ids. The Zod
- * `AgentPlatformSchema` enum, the `AgentProfileConfigV2` platform union,
- * `parseAgentProfilesMapV2`'s membership check, and setup's `DetectedHarness`
- * union all derive from this so they cannot drift.
+ * `AgentPlatformSchema` enum, the `AgentProfileConfig` platform union, and
+ * setup's `DetectedHarness` union all derive from this so they cannot drift.
  */
 export const VALID_HARNESS_IDS = Object.freeze(HARNESS_REGISTRY.map((h) => h.id));
 /** Harnesses that expose readable native session logs. */

package/dist/integrations/harnesses/opencode/agent-builder.js

@@ -33,7 +33,7 @@ export const opencodeBuilder = {
             args.push("--system-prompt", req.systemPrompt);
         }
         if (req.model) {
-            const resolved = resolveModel(req.model, "opencode", profile.modelAliases);
+            const resolved = resolveModel(req.model, "opencode", profile.modelAliases, profile.globalModelAliases);
             args.push("--model", resolved);
         }
         args.push("--");

package/dist/integrations/harnesses/opencode/index.js

@@ -1,23 +1,9 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * OpenCode harness (#564).
- *
- * Per-harness barrel that gathers the OpenCode integration surfaces previously
- * scattered across the codebase:
- *   - session-log reader     → ./session-log.ts   (OpenCodeProvider)
- *   - agent command builder  → ./agent-builder.ts (opencodeBuilder)
- *   - config importer        → ./config-import.ts (openCodeImporter)
- *
- * It also defines {@link OpencodeHarness}, the {@link AkmHarness} descriptor
- * that `HARNESS_REGISTRY` registers.
- *
- * id normalization: OpenCode's canonical id (`'opencode'`) is also its runtime
- * identity and session-log provider name — there is no historical split (unlike
- * Claude Code's 'claude' vs 'claude-code'), so no alias bridge is needed.
- */
 import { BaseHarness } from "../types.js";
+import { opencodeBuilder } from "./agent-builder.js";
+import { OpenCodeProvider } from "./session-log.js";
 export { opencodeBuilder } from "./agent-builder.js";
 export { openCodeImporter } from "./config-import.js";
 export { OpenCodeProvider } from "./session-log.js";
@@ -48,6 +34,21 @@ export class OpencodeHarness extends BaseHarness {
     // `v1ProfilePlatform()` resolves most-specific-id-first, so "opencode-sdk-*"
     // is claimed by OpencodeSdkHarness before this prefix can over-match it.
     v1ProfilePrefixes = ["opencode"];
+    agentBuilder = opencodeBuilder;
+    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
+    // This entry is the CLI spawn path (`opencode run …`): akm launches the
+    // harness locally per unit ⇒ local-runner. (The SDK path is the separate
+    // `opencode-sdk` harness.)
+    pattern = "local-runner";
+    // The CLI path emits plain text — no JSON stream akm consumes — so the
+    // engine uses the prompt-injected schema + embedded-JSON extraction tier
+    // (the matrix's "via prompt+validate"). The SDK entry is native-json.
+    structuredOutput = "none";
+    // `opencode run --session <id>` continues a previous session.
+    resume = { flag: "--session", takesSessionId: true };
+    // Session-id env marker for run attribution.
+    identityEnv = ["OPENCODE_SESSION_ID"];
+    sessionLogProvider = () => new OpenCodeProvider();
     capabilities = caps({
         sessionLogs: true,
         agentDispatch: true,

package/dist/integrations/harnesses/opencode/session-log.js

@@ -4,6 +4,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { openDatabase } from "../../../storage/database.js";
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 function getOpenCodeBaseDir() {
     if (process.platform === "darwin") {
@@ -12,20 +13,49 @@ function getOpenCodeBaseDir() {
     return path.join(os.homedir(), ".local", "share", "opencode");
 }
 /**
- * Opencode storage layout (observed 2026-05):
- *   <base>/storage/session/<projectId>/<sessionId>.json    — metadata
- *   <base>/storage/message/<sessionId>/<messageId>.json    — one per message
+ * Opencode storage layouts:
+ *
+ *   SQLite (current, observed 2026-06): `<base>/opencode.db` — a Drizzle-managed
+ *   database with `session` / `message` / `part` tables. Message text lives in
+ *   `part` rows (`data` JSON, `type: "text"`); `message.data` holds role/timing.
+ *   This is the layout current opencode builds write; it is preferred whenever
+ *   `opencode.db` exists.
+ *
+ *   JSON files (legacy, observed 2026-05): `<base>/storage/session/<projectId>/
+ *   <sessionId>.json` (metadata) + `<base>/storage/message/<sessionId>/
+ *   <messageId>.json` (one per message). Read only when `opencode.db` is absent.
  *
  * Older builds wrote logs directly into `<base>/log/` and `<base>/*.log`;
  * those are still scanned by {@link OpenCodeProvider.readEvents} for
  * backward compatibility with the existing failure-pattern aggregator.
  */
+/** Filename of opencode's SQLite session store, relative to its base dir. */
+const OPENCODE_DB_FILENAME = "opencode.db";
 export class OpenCodeProvider {
     name = "opencode";
     #baseDir = getOpenCodeBaseDir();
     isAvailable() {
         return fs.existsSync(this.#baseDir);
     }
+    /** Absolute path to opencode's SQLite store under `base`. */
+    #dbPath(base) {
+        return path.join(base, OPENCODE_DB_FILENAME);
+    }
+    /**
+     * Directories/files opencode writes session data under. Returns the base dir
+     * when the SQLite store (`opencode.db`) exists, the legacy JSON session root
+     * (`<base>/storage/session`) when present, or both during a migration overlap.
+     * Empty when neither exists. See {@link SessionLogHarness.watchRoots}.
+     */
+    watchRoots() {
+        const roots = [];
+        if (fs.existsSync(this.#dbPath(this.#baseDir)))
+            roots.push(this.#baseDir);
+        const sessionRoot = path.join(this.#baseDir, "storage", "session");
+        if (fs.existsSync(sessionRoot))
+            roots.push(sessionRoot);
+        return roots;
+    }
     *readEvents(input) {
         // Legacy behavior: stream raw log lines from the top-level dir and `log/`
         // subdirectory. Kept to keep `getExecutionLogCandidates` working without
@@ -82,6 +112,9 @@ export class OpenCodeProvider {
     listSessions(input = {}) {
         const base = input.location ?? this.#baseDir;
         const sinceMs = input.sinceMs ?? 0;
+        const dbPath = this.#dbPath(base);
+        if (fs.existsSync(dbPath))
+            return this.#listSessionsFromDb(dbPath, sinceMs);
         const sessionRoot = path.join(base, "storage", "session");
         if (!fs.existsSync(sessionRoot))
             return [];
@@ -142,6 +175,8 @@ export class OpenCodeProvider {
         return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
     }
     readSession(ref) {
+        if (path.basename(ref.filePath) === OPENCODE_DB_FILENAME)
+            return this.#readSessionFromDb(ref);
         let meta = {};
         try {
             meta = JSON.parse(fs.readFileSync(ref.filePath, "utf8"));
@@ -199,6 +234,141 @@ export class OpenCodeProvider {
             inlineRefs,
         };
     }
+    /**
+     * List sessions from the SQLite store. `filePath` on each summary is the
+     * `opencode.db` path so {@link readSession} can route back to the DB reader.
+     * Returns `[]` (never throws) when the DB is unreadable or lacks the expected
+     * schema — callers treat a missing harness as "no sessions".
+     */
+    #listSessionsFromDb(dbPath, sinceMs) {
+        let db;
+        try {
+            db = openDatabase(dbPath, { readonly: true, create: false });
+        }
+        catch {
+            return [];
+        }
+        try {
+            const rows = db
+                .prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC")
+                .all(sinceMs);
+            return rows.map((r) => {
+                const startedAt = typeof r.time_created === "number" ? r.time_created : undefined;
+                const endedAt = typeof r.time_updated === "number" ? r.time_updated : undefined;
+                const title = typeof r.title === "string" && r.title.length > 0 ? r.title : undefined;
+                const projectHint = typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined;
+                return {
+                    harness: this.name,
+                    sessionId: r.id,
+                    filePath: dbPath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                };
+            });
+        }
+        catch {
+            // Missing `session` table / unexpected schema — treat as no sessions.
+            return [];
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Read one session from the SQLite store. Message text lives in `part` rows
+     * (`type: "text"`); `message.data` carries role + timing. One event per
+     * message, text-parts concatenated in time order. Returns empty events
+     * (never throws) when the DB is unreadable.
+     */
+    #readSessionFromDb(ref) {
+        const emptyRef = { harness: this.name, sessionId: ref.sessionId, filePath: ref.filePath };
+        let db;
+        try {
+            db = openDatabase(ref.filePath, { readonly: true, create: false });
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        try {
+            const meta = db
+                .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
+                .get(ref.sessionId);
+            const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
+            const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
+            const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
+            const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
+            const messages = db
+                .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            const parts = db
+                .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            // Group text-part bodies by their parent message.
+            const textByMessage = new Map();
+            for (const part of parts) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(part.data);
+                }
+                catch {
+                    continue;
+                }
+                if (parsed?.type !== "text")
+                    continue;
+                const text = parsed.text;
+                if (typeof text !== "string" || text.length < 1)
+                    continue;
+                const bucket = textByMessage.get(part.message_id) ?? [];
+                bucket.push(text);
+                textByMessage.set(part.message_id, bucket);
+            }
+            const events = [];
+            const inlineRefs = [];
+            for (const message of messages) {
+                let mdata = {};
+                try {
+                    mdata = JSON.parse(message.data);
+                }
+                catch {
+                    // role/timing unavailable — fall through with defaults
+                }
+                const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+                const mtime = mdata.time?.created;
+                const ts = typeof mtime === "number"
+                    ? mtime
+                    : typeof message.time_created === "number"
+                        ? message.time_created
+                        : undefined;
+                const text = (textByMessage.get(message.id) ?? []).join("\n").trim();
+                if (text.length < 1)
+                    continue;
+                events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
+                inlineRefs.push(...extractInlineRefMentions(text, ts));
+            }
+            events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+            return {
+                ref: {
+                    harness: this.name,
+                    sessionId: ref.sessionId,
+                    filePath: ref.filePath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                },
+                events,
+                inlineRefs,
+            };
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        finally {
+            db.close();
+        }
+    }
     /**
      * Derive opencode base dir from a session metadata file path so a caller
      * passing a custom `--location` can still find the message dir.

package/dist/integrations/harnesses/opencode-sdk/harness.js

@@ -0,0 +1,65 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * OpenCode SDK harness DESCRIPTOR (#564).
+ *
+ * This module is a dependency-graph LEAF: it imports only the harness base
+ * types (`../types`) and nothing from `core/config` or the SDK runner. Keeping
+ * the descriptor separate from the runtime runner (`./sdk-runner`, which pulls
+ * `core/config`) is load-bearing: `HARNESS_REGISTRY` in `../index.ts` imports
+ * this class from HERE, not from the per-harness barrel (`./index.ts`). The
+ * barrel additionally re-exports `runOpencodeSdk`/`closeServer` from
+ * `./sdk-runner`; that re-export makes the barrel transitively depend on
+ * `core/config`, and `core/config/config-types` derives `VALID_HARNESS_IDS`
+ * back from `../index.ts`. If the registry imported the class through the
+ * barrel, that cycle would evaluate `../index.ts` (and `new
+ * OpencodeSdkHarness()`) while the barrel — and hence this class binding — was
+ * still initializing, throwing a temporal-dead-zone "Cannot access
+ * 'OpencodeSdkHarness' before initialization" whenever the barrel is the first
+ * module loaded in a fresh graph (e.g. the workflow-exec subprocess entry).
+ * Importing the descriptor from this leaf keeps the registry a config-leaf and
+ * breaks the cycle.
+ */
+import { BaseHarness } from "../types.js";
+function caps(c) {
+    return {
+        sessionLogs: false,
+        agentDispatch: false,
+        detection: false,
+        configImport: false,
+        runtimeIdentity: false,
+        v1Migration: false,
+        ...c,
+    };
+}
+/**
+ * OpenCode SDK (embedded-SDK dispatch path).
+ *
+ * Dispatch-only: no native session logs, but detected at setup and migrated
+ * from v1 profile names.
+ */
+export class OpencodeSdkHarness extends BaseHarness {
+    id = "opencode-sdk";
+    displayName = "OpenCode SDK";
+    aliases = [];
+    // Decorated v1 profile names like "opencode-sdk-fast" belong to the SDK path.
+    v1ProfilePrefixes = ["opencode-sdk"];
+    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
+    // Embedded-SDK dispatch on this machine ⇒ local-runner (the matrix's
+    // "local (sdk/cli)" row, SDK half).
+    pattern = "local-runner";
+    // `session.prompt` returns structured SDK events/messages; akm extracts the
+    // final message then validates against the node schema ⇒ native-json tier.
+    structuredOutput = "native-json";
+    // No `resume` flag: session reuse is programmatic — the SDK session id is
+    // stored opportunistically on the unit row and passed back to
+    // `session.prompt`, not replayed via a CLI flag.
+    // No `identityEnv`: the SDK runs in-process; it does not mark a child
+    // process environment with a session id of its own.
+    capabilities = caps({
+        agentDispatch: true,
+        detection: true,
+        v1Migration: true,
+    });
+}

package/dist/integrations/harnesses/opencode-sdk/index.js

@@ -5,10 +5,15 @@
  * OpenCode SDK harness (#564).
  *
  * Per-harness barrel for the SDK-mode dispatch path:
- *   - agent runner → ./sdk-runner.ts (runOpencodeSdk / runAgentSdk)
+ *   - descriptor → ./harness.ts ({@link OpencodeSdkHarness}, the
+ *     {@link AkmHarness} that `HARNESS_REGISTRY` registers)
+ *   - agent runner → ./sdk-runner.ts (runOpencodeSdk)
  *
- * It also defines {@link OpencodeSdkHarness}, the {@link AkmHarness} descriptor
- * that `HARNESS_REGISTRY` registers.
+ * The descriptor lives in its own leaf module (`./harness.ts`) rather than
+ * here so that the registry can import the class WITHOUT pulling in
+ * `./sdk-runner` (and its `core/config` dependency) — see the header of
+ * `./harness.ts` for the temporal-dead-zone cycle this avoids. This barrel is
+ * the runtime entry point that re-exports both.
  *
  * Unlike the CLI harnesses, the SDK path has no native session logs of its own
  * (`capabilities.sessionLogs = false`): it dispatches via the embedded
@@ -16,34 +21,5 @@
  * session files. It is still detected at setup and migrated from v1 profile
  * names. Canonical id is `'opencode-sdk'` with no alias.
  */
-import { BaseHarness } from "../types.js";
-export { closeServer, runAgentSdk, runOpencodeSdk } from "./sdk-runner.js";
-function caps(c) {
-    return {
-        sessionLogs: false,
-        agentDispatch: false,
-        detection: false,
-        configImport: false,
-        runtimeIdentity: false,
-        v1Migration: false,
-        ...c,
-    };
-}
-/**
- * OpenCode SDK (embedded-SDK dispatch path).
- *
- * Dispatch-only: no native session logs, but detected at setup and migrated
- * from v1 profile names.
- */
-export class OpencodeSdkHarness extends BaseHarness {
-    id = "opencode-sdk";
-    displayName = "OpenCode SDK";
-    aliases = [];
-    // Decorated v1 profile names like "opencode-sdk-fast" belong to the SDK path.
-    v1ProfilePrefixes = ["opencode-sdk"];
-    capabilities = caps({
-        agentDispatch: true,
-        detection: true,
-        v1Migration: true,
-    });
-}
+export { OpencodeSdkHarness } from "./harness.js";
+export { closeServer, runOpencodeSdk } from "./sdk-runner.js";