akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

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

@@ -0,0 +1,120 @@
+// 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/.
+/**
+ * Gemini CLI agent command builder (P2, plan §"The adapter contract" step 2 /
+ * §"Capability matrix").
+ *
+ * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
+ * headless argv the `gemini` CLI expects. Per the capability matrix the
+ * headless invocation is:
+ *
+ *   gemini -p "<prompt>"
+ *
+ * with `--output-format json` for structured output, `--model <m>` for model
+ * selection, and `--resume <id>` for resume; resume is not built here because
+ * `AgentDispatchRequest` carries no session id. The `GEMINI_CLI=1` identity
+ * env marker is likewise registry-side (`AkmHarness.identityEnv` /
+ * `agent-identity.ts`), not a builder concern.
+ *
+ * Platform-specific mapping decisions (all localized here, per the adapter
+ * contract):
+ *
+ * - **systemPrompt** — Gemini CLI has no system-prompt flag in headless mode
+ *   (system text comes from `GEMINI.md` context files / `GEMINI_SYSTEM_MD`),
+ *   so the system prompt is folded into the `-p` payload ahead of the task
+ *   prompt, separated by a blank line. `assertNotFlag` still guards it so a
+ *   `--`-prefixed system prompt cannot turn the front of the `-p` value into
+ *   a flag.
+ * - **schema** — the matrix places Gemini in the "via prompt+validate" tier
+ *   (no native `--output-schema` equivalent, unlike Codex — so no temp-file
+ *   plumbing here), so the JSON Schema is passed through the prompt: a
+ *   directive matching the engine's wording (`step-work.ts`
+ *   `buildUnitPrompt`) is appended to the `-p` payload, and
+ *   `--output-format json` is emitted so stdout is the documented JSON
+ *   envelope the gemini result extractor normalizes. The engine's shared
+ *   retry-until-valid loop performs the actual validation.
+ * - **tools** — a string/array tool policy maps to repeated
+ *   `--allowed-tools <t>` flags (Gemini's run-without-confirmation
+ *   allowlist). A *structured* policy object is NOT expressible as Gemini
+ *   flags; it is deliberately dropped without widening to an auto-approve
+ *   flag (never silently widen a restriction). With no policy at all,
+ *   NOTHING is emitted — the matrix's headless shape is the bare
+ *   `gemini -p "<p>"`; autonomy flags (`--yolo`, `--approval-mode`) belong in
+ *   `profile.args` where the operator opts in explicitly.
+ *
+ * Registered: `geminiBuilder` is `GeminiHarness.agentBuilder` (`./index.ts`),
+ * one of the ten harnesses `HARNESS_REGISTRY` constructs
+ * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
+ * that registry, so this builder is reachable under the `"gemini"` platform
+ * name without any further wiring.
+ */
+import { assertNotFlag, resolveDispatchModel, } from "../../agent/builder-shared.js";
+/** Canonical harness/platform id used for model-alias resolution. */
+export const GEMINI_PLATFORM = "gemini";
+/**
+ * Split a tool policy into individual tool names for `--allowed-tools`.
+ * Strings are comma-separated lists; arrays are taken as-is. Structured
+ * policy objects return `undefined` (not expressible as Gemini flags — see
+ * module doc).
+ */
+function toolPolicyEntries(tools) {
+    if (typeof tools === "string") {
+        return tools
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean);
+    }
+    if (Array.isArray(tools)) {
+        return tools.map((t) => t.trim()).filter(Boolean);
+    }
+    return undefined;
+}
+/**
+ * Assemble the `-p` payload: optional system prompt, the task prompt, and —
+ * when a schema is requested — the same schema directive the workflow
+ * engine's prompt assembly uses, so both dispatch paths speak one dialect.
+ */
+function buildPromptPayload(req) {
+    const sections = [];
+    if (req.systemPrompt)
+        sections.push(req.systemPrompt);
+    sections.push(req.prompt);
+    if (req.schema) {
+        sections.push(`Respond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(req.schema)}`);
+    }
+    return sections.join("\n\n");
+}
+/**
+ * Gemini CLI builder.
+ * Command shape:
+ *   gemini [--model <m>] [--allowed-tools <t> ...]
+ *          [--output-format json] -p "<systemPrompt?\n\nprompt\n\nschema?>"
+ */
+export const geminiBuilder = {
+    platform: GEMINI_PLATFORM,
+    build(profile, req) {
+        assertNotFlag(req.systemPrompt, "systemPrompt");
+        assertNotFlag(req.model, "model");
+        const args = [...profile.args];
+        if (req.model) {
+            const resolved = resolveDispatchModel(req, profile, GEMINI_PLATFORM);
+            args.push("--model", resolved);
+        }
+        if (req.tools) {
+            // Structured policy objects (entries === undefined) emit NO flags:
+            // dropping a restriction must never widen to auto-approval.
+            for (const tool of toolPolicyEntries(req.tools) ?? []) {
+                assertNotFlag(tool, "tools entry");
+                args.push("--allowed-tools", tool);
+            }
+        }
+        if (req.schema) {
+            // Structured unit: ask for the documented JSON envelope so the result
+            // extractor can pull the final message + session id deterministically.
+            args.push("--output-format", "json");
+        }
+        args.push("-p", buildPromptPayload(req));
+        return { argv: [profile.bin, ...args] };
+    },
+};

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

@@ -0,0 +1,48 @@
+// 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/.
+/**
+ * Gemini CLI harness (P2 integration, plan §"The adapter contract").
+ *
+ * Per-harness barrel gathering the Gemini CLI integration surfaces:
+ *   - agent command builder → ./agent-builder.ts    (geminiBuilder)
+ *   - result extractor      → ./result-extractor.ts (geminiResultExtractor)
+ *
+ * It also defines {@link GeminiHarness}, the {@link AkmHarness} descriptor
+ * that `HARNESS_REGISTRY` registers. Dispatch-only: no native session-log
+ * reader or config importer yet.
+ */
+import { caps } from "../shared.js";
+import { BaseHarness } from "../types.js";
+import { geminiBuilder } from "./agent-builder.js";
+import { geminiResultExtractor } from "./result-extractor.js";
+export { GEMINI_PLATFORM, geminiBuilder } from "./agent-builder.js";
+export { geminiResultExtractor } from "./result-extractor.js";
+/**
+ * Gemini CLI.
+ *
+ * Canonical id is `'gemini'`; no alias or distinct runtime identity.
+ */
+export class GeminiHarness extends BaseHarness {
+    id = "gemini";
+    displayName = "Gemini CLI";
+    aliases = [];
+    agentBuilder = geminiBuilder;
+    resultExtractor = geminiResultExtractor;
+    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
+    // akm spawns the `gemini` CLI locally per unit ⇒ local-runner.
+    pattern = "local-runner";
+    // `--output-format json` emits a documented JSON envelope akm parses, then
+    // validates against the node schema ⇒ native-json tier.
+    structuredOutput = "native-json";
+    // The matrix's identity marker: Gemini CLI stamps GEMINI_CLI=1 only on
+    // processes it spawns, so it genuinely means "running under gemini" (it is
+    // not a user-profile config var) — but its VALUE ("1") is a bare flag, not
+    // a session id, so it is registered as `presenceEnv` (harness inference
+    // only), never `identityEnv` (whose values persist as agent_session_id).
+    presenceEnv = ["GEMINI_CLI"];
+    capabilities = caps({
+        agentDispatch: true,
+        detection: true,
+    });
+}

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/ids.js

@@ -0,0 +1,24 @@
+// 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/.
+export const HARNESS_ID_TABLE = [
+    { id: "opencode", agentDispatch: true },
+    { id: "claude", agentDispatch: true },
+    { id: "opencode-sdk", agentDispatch: true },
+    { id: "codex", agentDispatch: true },
+    { id: "copilot", agentDispatch: true },
+    { id: "pi", agentDispatch: true },
+    { id: "gemini", agentDispatch: true },
+    { id: "aider", agentDispatch: true },
+    { id: "amazonq", agentDispatch: true },
+    { id: "openhands", agentDispatch: true },
+];
+/**
+ * Canonical, ordered list of valid harness / platform ids — the
+ * dependency-free counterpart of `./index.ts`'s `VALID_HARNESS_IDS` (which
+ * remains the barrel's own derivation for its own consumers). Both are
+ * asserted equal at `HARNESS_REGISTRY` construction time.
+ */
+export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id));
+/** Harness ids whose `capabilities.agentDispatch` is `true`. */
+export const HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));

package/dist/integrations/harnesses/index.js

@@ -12,14 +12,26 @@
  * This module is a dependency-graph LEAF: it imports nothing from
  * `core/config`. `core/config/config-types.ts` derives `VALID_HARNESS_IDS`
  * from here, which keeps the import direction acyclic (config ← harnesses).
- *
- * Implementations (session-log readers, agent profiles) are migrated under each
- * 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 { HARNESS_ID_TABLE } from "./ids.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";
+import { isSessionLogHarness } from "./types.js";
+export { isSessionLogHarness } from "./types.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,14 +45,40 @@ 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; the seven P2 harness adapters 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(),
 ]);
+// Construction-time drift guard (WI-9.8 KILL 3, D.3 edge B): ./ids.ts's
+// HARNESS_ID_TABLE is config's dependency-free mirror of (id, agentDispatch)
+// for every registered harness, kept out of core/config's import graph so
+// config doesn't have to import this (heavier) barrel. Assert they match so
+// the mirror can never silently drift — a new/reordered/recapability'd
+// harness that forgets to update ./ids.ts fails loudly here instead of
+// quietly breaking config's platform validation.
+if (HARNESS_REGISTRY.length !== HARNESS_ID_TABLE.length) {
+    throw new Error(`harnesses/ids.ts HARNESS_ID_TABLE has ${HARNESS_ID_TABLE.length} entries but HARNESS_REGISTRY has ${HARNESS_REGISTRY.length} — update ids.ts to match.`);
+}
+HARNESS_REGISTRY.forEach((h, i) => {
+    const expected = HARNESS_ID_TABLE[i];
+    if (!expected || expected.id !== h.id || expected.agentDispatch !== h.capabilities.agentDispatch) {
+        throw new Error(`harnesses/ids.ts HARNESS_ID_TABLE[${i}] (${expected?.id ?? "<missing>"}, agentDispatch=${expected?.agentDispatch}) ` +
+            `does not match HARNESS_REGISTRY[${i}] (${h.id}, agentDispatch=${h.capabilities.agentDispatch}) — update ids.ts to match.`);
+    }
+});
 /** Lookup by canonical id. */
 export const HARNESS_BY_ID = new Map(HARNESS_REGISTRY.map((h) => [h.id, h]));
 /**
@@ -60,12 +98,17 @@ const HARNESS_BY_ANY_ID = (() => {
 })();
 /**
  * Canonical, ordered list of valid harness / platform ids. The Zod
- * `AgentPlatformSchema` enum, the `AgentProfileConfig` platform union, and
+ * `AgentPlatformSchema` enum, the agent-engine 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. */
-export const SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.sessionLogs);
+/**
+ * Harnesses that expose readable native session logs. Narrowed via the
+ * {@link isSessionLogHarness} type-predicate (rather than a plain boolean
+ * callback) so `sessionLogProvider` is known-present on every element — see
+ * that function's doc comment for why a plain predicate doesn't narrow here.
+ */
+export const SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter(isSessionLogHarness);
 /** Harnesses that can be dispatched as an agent CLI / SDK. */
 export const AGENT_DISPATCH_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.agentDispatch);
 /** Harnesses that can import an existing harness config into akm. */
@@ -90,29 +133,6 @@ export function getHarness(id) {
 export function normalizeHarnessId(id) {
     return HARNESS_BY_ANY_ID.get(id)?.id ?? id;
 }
-/**
- * Resolve a legacy v1 agent-profile name to its v2 platform id (#566).
- *
- * v1 agent profiles never carried an explicit `platform`; it had to be inferred
- * from the profile name. This is the SINGLE registry-backed resolver that
- * replaces both the old standalone `guessAgentPlatform()` in config-migration
- * and the `name.includes("claude") ? "claude" : "opencode"` heuristic in setup.
- * Each harness owns its own `matchesV1ProfileName()`; an unknown name matches no
- * harness and returns `undefined`, so the caller drops it instead of silently
- * defaulting to `'opencode'`.
- *
- * Harnesses are consulted most-specific-id-first (longest id wins) so a
- * decorated name like `"opencode-sdk-fast"` resolves to `'opencode-sdk'` rather
- * than being over-matched by OpenCode's `"opencode"` prefix.
- */
-const V1_RESOLUTION_ORDER = [...HARNESS_REGISTRY].sort((a, b) => b.id.length - a.id.length);
-export function v1ProfilePlatform(name) {
-    for (const h of V1_RESOLUTION_ORDER) {
-        if (h.matchesV1ProfileName(name))
-            return h.id;
-    }
-    return undefined;
-}
 /**
  * Default agent-profile name for a detected harness id (#566).
  *

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

@@ -14,8 +14,7 @@
  * pre-migration `opencodeBuilder`. The builder's `platform` stays `'opencode'`
  * (the canonical harness id).
  */
-import { assertNotFlag } from "../../agent/builder-shared.js";
-import { resolveModel } from "../../agent/model-aliases.js";
+import { assertNotFlag, resolveDispatchModel } from "../../agent/builder-shared.js";
 /**
  * OpenCode builder.
  * Command shape: opencode run [--system-prompt "..."] [--model <m>] "<prompt>"
@@ -28,13 +27,32 @@ export const opencodeBuilder = {
     build(profile, req) {
         assertNotFlag(req.systemPrompt, "systemPrompt");
         assertNotFlag(req.model, "model");
-        const args = [...profile.args]; // starts with ["run"]
+        let configuredModel;
+        const args = req.model ? [] : [...profile.args];
+        if (req.model) {
+            for (let index = 0; index < profile.args.length; index += 1) {
+                const arg = profile.args[index];
+                if (arg === undefined)
+                    continue;
+                if (arg === "--model") {
+                    configuredModel = profile.args[index + 1];
+                    index += 1;
+                }
+                else if (arg.startsWith("--model=")) {
+                    configuredModel = arg.slice("--model=".length);
+                }
+                else {
+                    args.push(arg);
+                }
+            }
+        }
         if (req.systemPrompt) {
             args.push("--system-prompt", req.systemPrompt);
         }
         if (req.model) {
-            const resolved = resolveModel(req.model, "opencode", profile.modelAliases, profile.globalModelAliases);
-            args.push("--model", resolved);
+            const resolved = resolveDispatchModel(req, profile, "opencode");
+            const provider = configuredModel?.split("/", 1)[0];
+            args.push("--model", provider && !resolved.includes("/") ? `${provider}/${resolved}` : resolved);
         }
         args.push("--");
         args.push(req.prompt);

package/dist/integrations/harnesses/opencode/config-import.js

@@ -15,9 +15,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-function homeDir() {
-    return process.env.HOME ?? process.env.USERPROFILE ?? "";
-}
+import { homeDir } from "../shared.js";
 /**
  * Imports LLM config from an OpenCode installation.
  *

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

@@ -1,38 +1,13 @@
 // 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 { caps } from "../shared.js";
 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";
-function caps(c) {
-    return {
-        sessionLogs: false,
-        agentDispatch: false,
-        detection: false,
-        configImport: false,
-        runtimeIdentity: false,
-        v1Migration: false,
-        ...c,
-    };
-}
 /**
  * OpenCode.
  *
@@ -45,17 +20,24 @@ export class OpencodeHarness extends BaseHarness {
     // Home-relative config dir scanned by `akm setup` (#567). OpenCode has a
     // session-log provider, so offering it as a stash source is functional.
     setupDetectionDir = ".config/opencode";
-    // Decorated v1 profile names like "opencode-fast" still belong to OpenCode.
-    // `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";
+    // Session-id env marker for run attribution.
+    identityEnv = ["OPENCODE_SESSION_ID"];
+    sessionLogProvider = () => new OpenCodeProvider();
     capabilities = caps({
         sessionLogs: true,
         agentDispatch: true,
         detection: true,
         configImport: true,
         runtimeIdentity: true,
-        v1Migration: true,
     });
 }