akm-cli 0.10.261012-beta → 0.10.261014-beta

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

@@ -2,42 +2,24 @@
 // 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/.
 /**
- * GitHub Copilot CLI harness (P2 integration, plan §"The adapter contract").
- *
- * Per-harness barrel gathering the Copilot CLI integration surfaces:
- *   - agent command builder → ./agent-builder.ts    (copilotBuilder)
- *   - result extractor      → ./result-extractor.ts (copilotResultExtractor)
- *
- * It also defines {@link CopilotHarness}, the {@link AkmHarness} descriptor
- * that `HARNESS_REGISTRY` registers. This is the LOCAL Copilot CLI
- * (`copilot -p …`); the cloud "Copilot coding agent" is a separate, future
- * descriptor.
+ * GitHub Copilot CLI (`copilot`), the local headless CLI and not the cloud coding
+ * agent. `-p` runs one prompt; `--allow-all-tools` is what lets it run without
+ * asking for approval at each tool.
  */
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
-import { copilotBuilder } from "./agent-builder.js";
-import { copilotResultExtractor } from "./result-extractor.js";
-export { COPILOT_PLATFORM, copilotBuilder } from "./agent-builder.js";
-export { copilotResultExtractor } from "./result-extractor.js";
-/**
- * GitHub Copilot CLI (local headless CLI, not the cloud coding agent).
- *
- * Canonical id is `'copilot'`; no alias or distinct runtime identity.
- */
-export class CopilotHarness extends BaseHarness {
+import { withoutModelFlag, } from "../harness.js";
+export class CopilotHarness {
     id = "copilot";
     displayName = "GitHub Copilot CLI";
-    agentBuilder = copilotBuilder;
-    profile = { bin: "copilot", args: [], envPassthrough: ["GH_TOKEN", "GITHUB_TOKEN"] };
-    resultExtractor = copilotResultExtractor;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // Session-id env marker only. The matrix's other candidates (GH_TOKEN,
-    // bare COPILOT_* presence vars) are credential/presence flags that would
-    // stamp identity onto manual runs, so they are deliberately NOT registered
-    // (see `AkmHarness.identityEnv`).
-    identityEnv = ["COPILOT_SESSION_ID"];
-    capabilities = caps({
-        agentDispatch: true,
-        detection: true,
-    });
+    profile = { bin: "copilot", args: [] };
+    systemPrompt = false;
+    nativeAgent = false;
+    confinable = false;
+    build({ bin, args }, req) {
+        const argv = [bin, ...(req.model ? withoutModelFlag(args) : args)];
+        if (req.model)
+            argv.push("--model", req.model);
+        if (req.prompt !== undefined)
+            argv.push("--allow-all-tools", "-p", req.prompt);
+        return { argv };
+    }
 }

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

@@ -2,42 +2,26 @@
 // 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.
+ * Gemini CLI (`gemini`). `-p` runs one prompt headless. Autonomy flags
+ * (`--yolo`, `--approval-mode`) belong in the config's `args`, where the user opts in.
  */
-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 {
+import { withoutModelFlag, } from "../harness.js";
+export class GeminiHarness {
     id = "gemini";
     displayName = "Gemini CLI";
-    agentBuilder = geminiBuilder;
-    profile = { bin: "gemini", args: [], envPassthrough: ["GEMINI_API_KEY", "GOOGLE_API_KEY"] };
-    resultExtractor = geminiResultExtractor;
-    // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // 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).
+    profile = { bin: "gemini", args: [] };
+    // GEMINI_CLI=1 is stamped only on processes Gemini CLI spawns, so it means "running under
+    // gemini"; its value is a bare flag, not a session id.
     presenceEnv = ["GEMINI_CLI"];
-    capabilities = caps({
-        agentDispatch: true,
-        detection: true,
-    });
+    systemPrompt = false;
+    nativeAgent = false;
+    confinable = false;
+    build({ bin, args }, req) {
+        const argv = [bin, ...(req.model ? withoutModelFlag(args) : args)];
+        if (req.model)
+            argv.push("--model", req.model);
+        if (req.prompt !== undefined)
+            argv.push("-p", req.prompt);
+        return { argv };
+    }
 }

package/dist/integrations/harnesses/harness.js

@@ -0,0 +1,36 @@
+// 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/.
+/**
+ * The model the config's own `args` select, as `--model X` or `--model=X` (the
+ * last one wins).
+ */
+export function modelFromArgs(args) {
+    let model;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--model")
+            model = args[index + 1];
+        else if (arg?.startsWith("--model="))
+            model = arg.slice("--model=".length);
+    }
+    return model;
+}
+/** `args` without any `--model X` or `--model=X`, for a builder that adds the request's model itself, so it is passed once. */
+export function withoutModelFlag(args) {
+    const kept = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === "--model")
+            index += 1;
+        else if (!arg.startsWith("--model="))
+            kept.push(arg);
+    }
+    return kept;
+}
+/** `args` less a leading `subcommand` the builder writes itself, so an authored one is not doubled. */
+export function withoutLeading(args, subcommand) {
+    return args[0] === subcommand ? args.slice(1) : [...args];
+}

package/dist/integrations/harnesses/index.js

@@ -11,8 +11,7 @@
  *
  * Adding a harness: create `./<id>/index.ts`, add its class here. Removing:
  * delete both. This module must stay free of runtime `core/config` imports
- * (config derives `VALID_HARNESS_IDS` from here), so a harness's heavy runner
- * (e.g. `opencode-sdk/sdk-runner.ts`) is imported by its caller, not here.
+ * (config derives `VALID_HARNESS_IDS` from here).
  */
 import { AiderHarness } from "./aider/index.js";
 import { AmazonqHarness } from "./amazonq/index.js";
@@ -21,28 +20,21 @@ 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 { OpenhandsHarness } from "./openhands/index.js";
 import { PiHarness } from "./pi/index.js";
-import { isSessionLogHarness } from "./types.js";
-export { isSessionLogHarness } from "./types.js";
 /**
- * The single registration point.
- *
- * Typed `as const` (not `AkmHarness[]`) so each entry keeps its literal `id`,
- * which lets `VALID_HARNESS_IDS` stay a literal tuple — `HarnessId`,
- * `z.enum(...)`, and the `platform` union all need the literal types.
+ * The registered harnesses, with each entry keeping its literal `id` so that
+ * `VALID_HARNESS_IDS` can stay a literal tuple (`HarnessId`, `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. 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([
+// committed JSON-schema enum order. The original [opencode, claude] 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).
+const REGISTERED = [
     new OpencodeHarness(),
     new ClaudeHarness(),
-    new OpencodeSdkHarness(),
     new CodexHarness(),
     new CopilotHarness(),
     new PiHarness(),
@@ -50,49 +42,26 @@ export const HARNESS_REGISTRY = Object.freeze([
     new AiderHarness(),
     new AmazonqHarness(),
     new OpenhandsHarness(),
-]);
+];
+/** The single registration point. */
+export const HARNESS_REGISTRY = Object.freeze([...REGISTERED]);
 /** Lookup by the one supported harness id. */
 export const HARNESS_BY_ID = new Map(HARNESS_REGISTRY.map((h) => [h.id, h]));
 /**
  * Canonical, ordered list of valid harness / platform ids. The Zod
- * `AgentPlatformSchema` enum, the agent-engine platform union, and
+ * `AgentPlatformSchema` enum, the harness 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. 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);
-const idsWith = (flag) => new Set(HARNESS_REGISTRY.filter(flag).map((h) => h.id));
-/** Harness ids whose `capabilities.agentDispatch` is `true`. */
-export const HARNESS_AGENT_DISPATCH_IDS = idsWith((h) => h.capabilities.agentDispatch);
-/** Harness ids that confine the model-work tool policy, so unattended model work may run on them. */
-export const HARNESS_MODEL_WORK_IDS = idsWith((h) => h.capabilities.modelWork);
-/** Harness ids that can run a named native agent, so an engine may name a default `agent`. */
-export const HARNESS_NATIVE_AGENT_IDS = idsWith((h) => h.capabilities.nativeAgent);
+export const VALID_HARNESS_IDS = Object.freeze(REGISTERED.map((h) => h.id));
+/** The platforms a `harnesses` entry may name: every harness in the registry. */
+export const HARNESS_CONFIG_PLATFORMS = VALID_HARNESS_IDS;
+/** Harnesses that expose readable native session logs. */
+export const SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter((h) => h.sessionLogProvider !== undefined);
+/** Harness ids that can run a named native agent, so a harness may name a default `agent`. */
+export const HARNESS_NATIVE_AGENT_IDS = new Set(HARNESS_REGISTRY.filter((h) => h.nativeAgent).map((h) => h.id));
 /**
  * Resolve an exact harness id to its descriptor, or `undefined` if unknown.
  */
 export function getHarness(id) {
     return HARNESS_BY_ID.get(id);
 }
-/**
- * Default agent-profile name for a detected harness id (#566).
- *
- * Used by `akm setup`'s headless/recommended-config path so a newly added
- * dispatch-capable harness gets a usable default profile name (its canonical
- * id) instead of falling through a hardcoded if-chain with no default. Returns
- * `undefined` for `"none"` or any id that is unknown / not agent-dispatch
- * capable.
- */
-export function defaultProfileName(detected) {
-    const h = HARNESS_BY_ID.get(detected);
-    if (!h?.capabilities.agentDispatch)
-        return undefined;
-    return h.id;
-}

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

@@ -2,120 +2,152 @@
 // 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 agent command builder (migrated from `agent/builders.ts`, #564).
+ * OpenCode command builder: the `opencode run` CLI of the opencode harness
+ * (#1244), for both majors, treated like the Claude and Codex CLIs. The user's
+ * OpenCode owns its config, logins and sessions; akm hands it a prompt and reads
+ * the reply from stdout.
  *
- * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
- * argv the `opencode` CLI expects. This is the OpenCode-specific slice of the
- * builder strategy; the shared infrastructure (`AgentCommandBuilder`,
- * `getCommandBuilder`, the default builder, flag/tool helpers) stays in
- * `agent/builders.ts`, which imports this builder back into `BUILTIN_BUILDERS`.
+ * The prompt goes on stdin: `opencode run` alters an argv message (quotes change,
+ * inner quotes are escaped) and a prompt that starts with `-` could be taken for
+ * a flag; stdin is read verbatim. akm closes it after the write, which the CLI
+ * needs: with stdin open it waits for more input.
  *
- * The builder's `platform` stays `'opencode'` (the canonical harness id). The
- * one thing that depends on the OpenCode major (`./version.ts`, one cached
- * `--version` run per binary) is `--standalone`, added on OpenCode 2 only; the
- * OpenCode 1 argv is byte-identical to the pre-OpenCode-2 builder's.
+ * Agent work adds nothing: `opencode run`, the authored args as written, `--model` when akm
+ * names one, `--agent` when the asset names one, and the prompt on stdin. The run is the
+ * user's own, on their OpenCode as they have it set up.
+ *
+ * Model work is akm's own process. It sets `OPENCODE_DISABLE_FREE_MODELS` (OpenCode 2.1.2 and
+ * later, where the variable first appears): with no usable provider, OpenCode 2 would
+ * otherwise send akm's data to its hosted free model. The variable deletes every zero-cost
+ * model of the `opencode` and `opencode-go` providers, so it has no place on agent work,
+ * where it would override a model the user chose. On OpenCode 2 model work also gets
+ * `--standalone`, which keeps the run to one process that ends with it (the default attaches
+ * to a background service that outlives the CLI, is shared across users on one port, ignores
+ * inline config and replays killed sessions at every start), and `--title`, which names the
+ * session and spares the second model request that would otherwise generate a title.
+ *
+ * A binary whose version cannot be read runs model work as OpenCode 1, with one warning that says so.
+ *
+ * Model work drops the config's `args`, keeping the model they name, as the
+ * Claude and Codex shells do. On OpenCode 2 it runs as {@link MODEL_WORK_AGENT},
+ * an agent defined inline for the run whose tools are limited to reading and
+ * searching, added to the user's own inline config; OpenCode 1 cannot be
+ * restricted and runs it unrestricted, with a one-line warning.
  */
-import { modelFromArgs, resolveDispatchModel, } from "../../agent/builder-shared.js";
-import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-import { MODEL_WORK_AGENT_INFERENCE, opencodeInferenceConfig } from "./model-config.js";
-import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "./model-work-agent.js";
-import { detectOpencodeMajor } from "./version.js";
+import { asRecord, parseJsonc } from "../../../core/common.js";
+import { warnOnce } from "../../../core/warn.js";
+import { modelFromArgs, withoutLeading, withoutModelFlag, } from "../harness.js";
+import { detectOpencodeMajor, isOpencode2 } from "./version.js";
+/** The agent OpenCode 2 runs akm's model work as, limited to reading and searching; the name also marks those sessions in the user's history (`./session-log-v2.ts`). */
+export const MODEL_WORK_AGENT = "akm-model-work";
 /**
- * OpenCode 2's `run` attaches to a shared background service by default,
- * starting it when absent and leaving it running after the run; `--standalone`
- * runs a private server that exits with the run (and reads the
- * `OPENCODE_CONFIG_CONTENT` model work travels in, which the service ignores).
- * OpenCode 1 has no such flag. An engine whose own `args` name `--server`
- * chose that server, so it gets no `--standalone`. `--auto` is never passed:
- * a non-interactive run rejects a permission request, on both majors.
+ * The agent's definition, in OpenCode 2's native shape, passed inline so it merges over the user's config and is
+ * never written anywhere. Its permission rules are default-deny with the reading tools allowed after it (the last
+ * matching rule wins; measured on OpenCode 2.1.2): `*` denied removes every tool, one a plugin registers that akm has
+ * never heard of included, and the allows give back `read`, `glob` and `grep` and, when the akm plugin is installed,
+ * `akm_search`, `akm_show` and `akm_curate`. Nothing else is allowed. This limits the tools; a plugin's own `setup`
+ * and hooks still run.
  */
-const STANDALONE_FLAG = "--standalone";
-function standalone(major, flags) {
-    if (major !== 2)
-        return [];
-    const chosen = flags.some((arg) => arg === STANDALONE_FLAG || arg === "--server" || arg.startsWith("--server="));
-    return chosen ? [] : [STANDALONE_FLAG];
-}
+const MODEL_WORK_AGENT_DEFINITION = {
+    mode: "primary",
+    permissions: [
+        { action: "*", resource: "*", effect: "deny" },
+        ...["read", "glob", "grep", "akm_search", "akm_show", "akm_curate"].map((action) => ({
+            action,
+            resource: "*",
+            effect: "allow",
+        })),
+    ],
+};
+const CONFIG_CONTENT_ENV = "OPENCODE_CONFIG_CONTENT";
 /**
- * The flags before the `--` separator of an ordinary dispatch: the engine's
- * `args` (without any `--model` when the request names one), then `--agent`
- * and `--model`. Both majors spell these the same way.
+ * The inline config model work runs with: the user's own `OPENCODE_CONFIG_CONTENT` as it is, with akm's agent set on
+ * `agents.akm-model-work`, the one key akm's definition wins. OpenCode 2 reads that native `agents` map over the
+ * legacy `agent` one, so a same-named entry the user keeps in `agent` is left out rather than left to conflict. The
+ * child's value is built from the parent's, so a provider, model or key the user keeps only there stays. It is read as
+ * OpenCode reads it, as JSONC (comments and trailing commas), and written back as JSON; content that reads only once
+ * its `{env:NAME}` references are replaced (one written outside a string) is read the way OpenCode replaces them
+ * ({@link withEnvReferences}). Content that is not valid JSONC holding an object either way is left out, with one
+ * warning.
  */
-function ordinaryFlags(profile, req) {
-    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") {
-                index += 1;
-            }
-            else if (!arg.startsWith("--model=")) {
-                args.push(arg);
-            }
-        }
+function modelWorkConfig() {
+    const content = process.env[CONFIG_CONTENT_ENV]?.trim();
+    const user = content ? userConfig(content) : undefined;
+    if (content && !user) {
+        warnOnce("opencode-config-content", `${CONFIG_CONTENT_ENV} is not valid JSONC holding an object, so OpenCode model work runs without it.`);
+    }
+    const config = {
+        ...user,
+        agents: { ...asRecord(user?.agents), [MODEL_WORK_AGENT]: MODEL_WORK_AGENT_DEFINITION },
+    };
+    const legacy = asRecord(user?.agent);
+    if (legacy && Object.hasOwn(legacy, MODEL_WORK_AGENT)) {
+        const { [MODEL_WORK_AGENT]: _replaced, ...others } = legacy;
+        config.agent = others;
     }
-    if (req.agent) {
-        args.push("--agent", req.agent);
+    return JSON.stringify(config);
+}
+function userConfig(content) {
+    return jsoncObject(content) ?? jsoncObject(withEnvReferences(content));
+}
+function jsoncObject(content) {
+    try {
+        return asRecord(parseJsonc(content));
     }
-    if (req.model) {
-        args.push("--model", resolveDispatchModel(req, profile, "opencode"));
+    catch {
+        return undefined;
     }
-    return args;
 }
 /**
- * OpenCode builder: `opencode run [--standalone] [--agent <name>] [--model <m>] -- "<prompt>"`
- * (`--standalone` on OpenCode 2 only).
- *
- * `opencode run` has no system-prompt option (1.18.25 prints its usage and
- * exits 1 on `--system-prompt`), so the shared lowerer composes a persona
- * into the prompt.
- *
- * Tool policy is omitted: opencode manages tool access through its own agent
- * config files, not via CLI flags. The one exception is the model-work tool
- * policy: the builder injects its confined agent through
- * `OPENCODE_CONFIG_CONTENT` and selects it with `--agent`. That command is
- * akm's own: the engine's `args` are left out, because one such as `--attach`
- * or `--dir` would move the run out of the injected config or the scratch
- * working directory. Only the model they name is kept.
- *
- * Model work's agent carries the request's inference options
- * (`./model-config.ts`). Any other dispatch injects nothing and carries none, so
- * the model's own opencode config applies: set inference there.
+ * `{env:NAME}` replaced as OpenCode replaces it in this variable before it parses it (`ConfigVariable.substitute`):
+ * by the variable's value, or nothing when it is unset or empty, as written where the result reads as JSONC, else
+ * escaped as the inside of a JSON string. A `{file:path}` is left for the OpenCode akm runs, which replaces it against
+ * its own directory, as it would in-process.
  */
+function withEnvReferences(content) {
+    const replaced = (escaped) => content.replace(/\{env:([^}]+)\}/g, (_, name) => {
+        const value = process.env[name] || "";
+        return escaped ? JSON.stringify(value).slice(1, -1) : value;
+    });
+    const raw = replaced(false);
+    try {
+        parseJsonc(raw);
+        return raw;
+    }
+    catch {
+        return replaced(true);
+    }
+}
+const NO_FREE_MODELS = { OPENCODE_DISABLE_FREE_MODELS: "1" };
 export const opencodeBuilder = {
-    platform: "opencode",
-    personaChannel: "prompt",
-    lower: createAgentRequestLowerer({
-        adapter: "opencode",
-        personaChannel: "prompt",
-        tools: "none",
-        inference: MODEL_WORK_AGENT_INFERENCE,
-    }),
-    build(profile, req) {
-        const major = detectOpencodeMajor(profile.bin).major;
-        if (req.modelWork) {
-            const model = req.model ?? modelFromArgs(profile.args);
-            const { agentOptions } = opencodeInferenceConfig(req.inference, true);
-            return {
-                argv: [
-                    profile.bin,
-                    "run",
-                    ...standalone(major, []),
-                    "--agent",
-                    MODEL_WORK_OPENCODE_AGENT,
-                    ...(model ? ["--model", model] : []),
-                    "--",
-                    req.prompt,
-                ],
-                env: {
-                    ...modelWorkPluginEnv(),
-                    OPENCODE_CONFIG_CONTENT: JSON.stringify(modelWorkOpencodeConfig(agentOptions)),
-                },
-            };
+    build({ bin, args }, req) {
+        const agent = req.agent ? ["--agent", req.agent] : [];
+        const model = req.model ? ["--model", req.model] : [];
+        if (req.prompt === undefined) {
+            // An interactive launch is the TUI, which `run` (headless) is not.
+            const authored = withoutLeading(args, "run");
+            return { argv: [bin, ...(req.model ? withoutModelFlag(authored) : authored), ...agent, ...model] };
+        }
+        if (!req.modelWork) {
+            return { argv: [bin, ...(req.model ? withoutModelFlag(args) : args), ...agent, ...model], stdin: req.prompt };
+        }
+        const oc2 = isOpencode2(bin);
+        if (!oc2 && detectOpencodeMajor(bin).reportedMajor === undefined) {
+            warnOnce(`opencode-version-unreadable:${bin}`, `Could not read the version of ${bin}, so akm runs its model work as OpenCode 1: no --standalone (an OpenCode 2 would attach to its shared background service) and unrestricted. Check \`${bin} --version\`.`);
+        }
+        if (!oc2) {
+            warnOnce("opencode-1-model-work", "OpenCode 1 cannot restrict its tools, so model work on it runs unrestricted, in a scratch directory. OpenCode 2 limits its tools to reading and searching.");
         }
-        const flags = ordinaryFlags(profile, req);
-        return { argv: [profile.bin, ...flags, ...standalone(major, flags), "--", req.prompt] };
+        const named = req.model ?? modelFromArgs(args);
+        return {
+            argv: [
+                bin,
+                "run",
+                ...(oc2 ? ["--standalone", "--title", "akm", "--agent", MODEL_WORK_AGENT] : []),
+                ...(named ? ["--model", named] : []),
+            ],
+            env: { ...NO_FREE_MODELS, ...(oc2 ? { [CONFIG_CONTENT_ENV]: modelWorkConfig() } : {}) },
+            stdin: req.prompt,
+        };
     },
 };

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

@@ -1,55 +1,33 @@
 // 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'), so no alias bridge is needed.
- */
-import { OPENCODE_ENV_PASSTHROUGH } from "../../../core/spawn-env.js";
-import { caps } from "../shared.js";
-import { BaseHarness } from "../types.js";
 import { opencodeBuilder } from "./agent-builder.js";
-import { openCodeImporter } from "./config-import.js";
 import { OpenCodeProvider } from "./session-log.js";
+import { isOpencode2, OPENCODE_BIN } from "./version.js";
 export { opencodeBuilder } from "./agent-builder.js";
-export { openCodeImporter } from "./config-import.js";
 export { OpenCodeProvider } from "./session-log.js";
 /**
  * OpenCode.
  *
  * Canonical id is `'opencode'`; it has no distinct runtime identity or alias.
  */
-export class OpencodeHarness extends BaseHarness {
+export class OpencodeHarness {
     id = "opencode";
     displayName = "OpenCode";
     // 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";
-    agentBuilder = opencodeBuilder;
-    configImporter = openCodeImporter;
-    profile = { bin: "opencode", args: ["run"], envPassthrough: OPENCODE_ENV_PASSTHROUGH };
+    build = opencodeBuilder.build;
+    profile = { bin: OPENCODE_BIN, args: ["run"] };
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
     // Session-id env marker for run attribution.
     identityEnv = ["OPENCODE_SESSION_ID"];
     sessionLogProvider = () => new OpenCodeProvider();
-    capabilities = caps({
-        sessionLogs: true,
-        agentDispatch: true,
-        detection: true,
-        modelWork: true,
-        nativeAgent: true,
-        configImport: true,
-    });
+    systemPrompt = false;
+    nativeAgent = true;
+    // Model work has its tools limited to reading and searching on OpenCode 2 only: its CLI takes an agent defined
+    // inline for the run (./agent-builder.ts), OpenCode 1's cannot be restricted and runs it unrestricted, with a warning.
+    // Lowering asks for the limited run either way; setup asks whether the installed OpenCode can give it.
+    confinable = true;
+    confinableInstalled = (bin) => isOpencode2(bin);
 }