akm-cli 0.7.5 → 0.8.0-rc.6

package/dist/integrations/agent/prompts.js

@@ -1,3 +1,6 @@
+// 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/.
 /**
  * Shared prompt builders for proposal-producing agent commands (#226).
  *
@@ -23,13 +26,14 @@
  * during validation. We carry it through if the agent supplies it.
  */
 import { TYPE_DIRS } from "../../core/asset-spec";
+import { parseEmbeddedJsonResponse, stripCodeFences, stripThinkBlocks } from "../../core/parse";
 /**
  * Per-asset-type frontmatter / authoring hints surfaced in the prompt so
  * the agent can produce content that passes proposal validation. Kept tiny:
  * full schema docs live in `docs/` — these are nudges, not contracts.
  */
 const TYPE_HINTS = {
-    lesson: "lesson assets MUST start with frontmatter containing `description` and `when_to_use` keys (both non-empty). Body should be 1–3 short paragraphs of practical guidance.",
+    lesson: "lesson assets MUST start with frontmatter containing `description` and `when_to_use` keys (both non-empty). Body: 1–3 short paragraphs of practical guidance. A lesson is NOT a restatement of the source asset — it answers: When should I reach for this? What goes wrong without it? What did real use reveal that the asset itself doesn't say?",
     skill: "skill assets are stored as `skills/<name>/SKILL.md`. Frontmatter typically includes `name`, `description`, and `when_to_use`.",
     command: "command assets are markdown with optional frontmatter (`name`, `description`). The body is the prompt template the user invokes.",
     agent: "agent assets are markdown with frontmatter describing the agent role (`name`, `description`, optional `tools`, `model`).",
@@ -80,7 +84,15 @@ function fileWriteContract(draftFilePath) {
 export function buildReflectPrompt(input) {
     const sections = [];
     if (input.ref && input.type && input.name) {
-        sections.push(`You are reviewing an akm stash asset (${input.type}) called "${input.name}" and proposing an improved version.`);
+        // Change 2 — type-conditioned goal framing
+        const isLesson = input.type === "lesson";
+        const isSkill = input.type === "skill";
+        const goalSentence = isLesson
+            ? `Your task is to distill what usage signals reveal about this ${input.type} asset — when to reach for it, what goes wrong without it, and what real use has revealed that the asset itself does not say. Do not reproduce the source content; your proposal must add information the source does not contain.`
+            : isSkill
+                ? "Your task is to review this skill asset, identify what the feedback and related distilled lessons show is broken, missing, unclear, or durable enough to promote into long-term documentation, and produce a single improved proposal. If the strongest evidence points to companion reference material rather than the main SKILL.md, you may instead propose a skill-adjacent knowledge doc such as `knowledge:skills/<skill>/references/<topic>`."
+                : `Your task is to review this ${input.type} asset, identify what the feedback signals as broken, missing, or unclear, and produce an improved version. Do not reproduce the source content unchanged; your proposal must correct or add something the source lacks.`;
+        sections.push(goalSentence);
         sections.push(`Target ref: ${input.ref}`);
         sections.push(`Asset-type guidance: ${hintForType(input.type)}`);
     }
@@ -92,10 +104,35 @@ export function buildReflectPrompt(input) {
     if (input.task?.trim()) {
         sections.push(`Task / focus: ${input.task.trim()}`);
     }
+    // Change 3 & 4 — feedback moved before asset content; missing else branch added
+    if (input.feedback && input.feedback.length > 0) {
+        sections.push("Recent feedback / signals:");
+        for (const line of input.feedback)
+            sections.push(`- ${line}`);
+    }
+    else if (!input.ref) {
+        sections.push("Recent feedback / signals:");
+        sections.push("- (no feedback events recorded)");
+    }
+    else if (input.type === "skill" && input.relatedLessons && input.relatedLessons.length > 0) {
+        sections.push("No direct feedback events were recorded. Limit substantive changes to what is justified by the related distilled lessons below; do not speculate beyond that evidence.");
+    }
+    else {
+        // ref is set but no feedback — explicitly constrain scope to schema compliance
+        sections.push("No usage feedback recorded. Limit your proposal to schema and structural improvements only: missing required frontmatter fields, unclear `when_to_use`, ambiguous description, or broken formatting. Do not speculate about runtime weaknesses you have not observed.");
+    }
     if (input.assetContent?.trim()) {
-        sections.push("Current asset content (verbatim):");
+        // Cap at 12 000 chars to stay well under OS ARG_MAX when the prompt is
+        // passed as a CLI argument to opencode/claude. Large assets (wiki snapshots,
+        // long runbooks) would otherwise trigger E2BIG on posix_spawn.
+        const REFLECT_CONTENT_CAP = 12_000;
+        const body = input.assetContent.trimEnd();
+        const truncated = body.length > REFLECT_CONTENT_CAP;
+        sections.push(truncated
+            ? `Current asset content (first ${REFLECT_CONTENT_CAP} chars — full asset is ${body.length} chars):`
+            : "Current asset content (verbatim):");
         sections.push("```");
-        sections.push(input.assetContent.trimEnd());
+        sections.push(truncated ? `${body.slice(0, REFLECT_CONTENT_CAP)}\n... [truncated — focus on the visible portion]` : body);
         sections.push("```");
     }
     else if (input.ref) {
@@ -104,21 +141,78 @@ export function buildReflectPrompt(input) {
     else {
         sections.push("(No existing asset content was supplied.)");
     }
-    if (input.feedback && input.feedback.length > 0) {
-        sections.push("Recent feedback / signals:");
-        for (const line of input.feedback)
-            sections.push(`- ${line}`);
-    }
-    else if (!input.ref) {
-        sections.push("Recent feedback / signals:");
-        sections.push("- (no feedback events recorded)");
-    }
     if (input.schemaHints && input.schemaHints.length > 0) {
         sections.push("Schema / lint hints to address:");
         for (const line of input.schemaHints)
             sections.push(`- ${line}`);
     }
-    sections.push("Produce a single proposal that addresses the feedback and respects the asset-type contract.");
+    if (input.relatedLessons && input.relatedLessons.length > 0) {
+        sections.push("Related distilled lessons to evaluate for consolidation:");
+        for (const lesson of input.relatedLessons) {
+            sections.push(`Lesson ref: ${lesson.ref}`);
+            sections.push("```");
+            sections.push(lesson.content.trimEnd());
+            sections.push("```");
+        }
+        sections.push("Evaluate whether these lessons contain strong evidence of factual, repeatable guidance that should be promoted into long-term skill documentation.");
+        sections.push("Promote only guidance that is durable, generally applicable, and supported by repeated evidence. Do not copy anecdotal details, one-off incidents, or duplicate wording verbatim.");
+        sections.push("If the guidance belongs in the main skill instructions, update the skill proposal. If it belongs in a companion reference document, return a `knowledge:skills/<skill>/references/<topic>` proposal instead.");
+    }
+    if (input.rejectedProposals && input.rejectedProposals.length > 0) {
+        const lines = ["## Previously Rejected Proposals"];
+        lines.push("The following proposals for this ref were already reviewed and rejected. " +
+            "Do NOT reproduce the same content or the same structural shape. " +
+            "Your new proposal must meaningfully differ from each of these in its approach, framing, or evidence used.");
+        for (const rp of input.rejectedProposals) {
+            lines.push(`\nRef: ${rp.ref}`);
+            lines.push(`Rejection reason: ${rp.reason}`);
+            if (rp.contentPreview) {
+                lines.push("Rejected content preview:");
+                lines.push("```");
+                lines.push(rp.contentPreview);
+                lines.push("```");
+            }
+        }
+        sections.push(lines.join("\n"));
+    }
+    if (input.avoidPatterns && input.avoidPatterns.length > 0) {
+        sections.push(`## Avoid These Patterns\nPrevious assets in this run produced these errors — do not repeat them:\n${input.avoidPatterns.map((e) => `- ${e}`).join("\n")}`);
+    }
+    // R-1 / #372: Self-Refine (arXiv:2303.17651) — inject prior draft as critique target.
+    // On refinement iterations (iter > 0), the agent is shown its previous proposal
+    // and asked to self-critique and improve it rather than starting from scratch.
+    if (input.priorDraft?.trim()) {
+        sections.push("## Self-Refine: Critique and Improve\n" +
+            "The following is your previous draft proposal. " +
+            "Identify specific weaknesses: missing evidence, vague wording, incomplete frontmatter, " +
+            "or claims that duplicate existing content without adding new signal. " +
+            "Then produce an improved version that addresses those weaknesses. " +
+            "The revised proposal must be meaningfully better than the draft below — " +
+            "do not return the same content unchanged.\n\n" +
+            "Previous draft:\n```\n" +
+            input.priorDraft.trimEnd() +
+            "\n```");
+    }
+    sections.push("Produce a single proposal that addresses the feedback and respects the asset-type contract. If the proposal's frontmatter is missing `when_to_use`, you MUST generate one — a one-line trigger sentence describing exactly when a user should reach for this asset.");
+    // Content-preservation safety rails (#reflect-pipeline-fixes).
+    // These rules counter the observed failure modes where reflect rewrites
+    // asset content into shorter prose, drops concrete structure, or strips
+    // load-bearing frontmatter. Loud and explicit so small models follow.
+    if (input.ref && input.assetContent?.trim()) {
+        sections.push([
+            "## Content preservation rules (MUST follow)",
+            "1. PRESERVE ALL concrete content: code blocks, fenced snippets, CLI commands, numbered/bulleted checklists, tables, YAML/JSON examples, file paths, configuration keys, environment variable names, and CSS/HTML selectors. These are load-bearing — do NOT replace them with prose summaries.",
+            "2. PRESERVE the source asset's frontmatter. The post-processor reassembles the final asset from the original frontmatter plus your body. Do NOT emit `---` frontmatter delimiters at the top of `content` — start `content` with the markdown body (e.g. `# Heading` or the first paragraph). If you include frontmatter anyway, identity fields (`name`, `ref`, `id`, `slug`, `type`) will be reset to the original values.",
+            "3. DO NOT shrink the asset dramatically. The improved body must be at least 50% of the source body length. If you genuinely need to remove a major section, explain why in a comment line at the top of the body (e.g. `<!-- removed obsolete section X because ... -->`).",
+            "4. DO NOT pad the asset with speculative material. The improved body must be at most 200% of the source body length unless the feedback explicitly requests added sections.",
+            "5. Improve clarity of surrounding prose, fix structural issues, add missing required frontmatter fields. Do NOT rewrite a runbook into an essay.",
+        ].join("\n"));
+    }
+    if (!input.draftFilePath && input.ref) {
+        // Reinforce that the `ref` field is mandatory and must exactly match the target.
+        // Small models frequently omit `ref` from the response JSON, causing parse errors.
+        sections.push(`IMPORTANT: The JSON "ref" field is REQUIRED. It MUST be exactly: "${input.ref}"`);
+    }
     sections.push(input.draftFilePath ? fileWriteContract(input.draftFilePath) : RESPONSE_CONTRACT_JSON);
     return sections.join("\n\n");
 }
@@ -141,6 +235,33 @@ export function buildProposePrompt(input) {
     sections.push(input.draftFilePath ? fileWriteContract(input.draftFilePath) : RESPONSE_CONTRACT_JSON);
     return sections.join("\n\n");
 }
+/**
+ * Build the prompt for the schema repair pass in `akm improve`. Asks the
+ * agent to add the minimal required frontmatter to an asset that failed
+ * validation — without rewriting the body.
+ */
+export function buildSchemaRepairPrompt(input) {
+    const sections = [];
+    sections.push(`This ${input.type} asset failed schema validation with the error: "${input.reason}". ` +
+        `Your task is to fix the schema issue by adding or correcting the missing/invalid field(s) ` +
+        `while preserving all existing content.`);
+    sections.push(`Target ref: ${input.ref}`);
+    sections.push(`Schema requirements for ${input.type} assets: ${hintForType(input.type)}`);
+    const CONTENT_CAP = 3000;
+    const body = input.assetContent.trimEnd();
+    const truncated = body.length > CONTENT_CAP;
+    sections.push("Current asset content (first 3000 chars — sufficient to generate missing frontmatter):");
+    sections.push("```");
+    sections.push(truncated ? `${body.slice(0, CONTENT_CAP)}\n... [truncated]` : body);
+    sections.push("```");
+    sections.push("Produce the minimal fix: add ONLY the missing required frontmatter field(s). " +
+        "Do not rewrite the body unless it is empty. " +
+        "If `description` is missing, generate a concise one-sentence description from the content. " +
+        "If `when_to_use` is missing, generate a one-line trigger sentence. " +
+        "Preserve all existing frontmatter keys and the full body verbatim.");
+    sections.push(input.draftFilePath ? fileWriteContract(input.draftFilePath) : RESPONSE_CONTRACT_JSON);
+    return sections.join("\n\n");
+}
 /**
  * Parse agent stdout into a proposal payload. The agent contract requires a
  * single JSON object; anything else is reported as a parse error so callers
@@ -151,7 +272,8 @@ export function buildProposePrompt(input) {
  *  2. Prose preamble / postamble around the JSON object (handled by `extractEmbeddedJson`).
  */
 export function parseAgentProposalPayload(stdout) {
-    const trimmed = stripJsonFences(stdout).trim();
+    // Strip <think> blocks and fences, then attempt full parse with embedded fallback.
+    const trimmed = stripCodeFences(stripThinkBlocks(stdout)).trim();
     if (!trimmed)
         throw new Error("agent produced empty output");
     let parsed;
@@ -162,7 +284,7 @@ export function parseAgentProposalPayload(stdout) {
         // Agent output contains prose before/after the JSON object (e.g. a local
         // LLM that narrates before responding). Try extracting the first balanced
         // top-level `{…}` from the text rather than failing immediately.
-        const embedded = extractEmbeddedJson(trimmed);
+        const embedded = parseEmbeddedJsonResponse(trimmed);
         if (!embedded)
             throw directErr;
         parsed = embedded;
@@ -180,68 +302,22 @@ export function parseAgentProposalPayload(stdout) {
     if (parsed.frontmatter && typeof parsed.frontmatter === "object" && !Array.isArray(parsed.frontmatter)) {
         out.frontmatter = parsed.frontmatter;
     }
-    return out;
-}
-/**
- * Extract the first balanced top-level `{…}` object from `text`. Used as a
- * fallback when direct `JSON.parse` fails due to surrounding prose. Kept
- * local to `agent/` (mirrors `parseEmbeddedJsonResponse` in `src/llm/client.ts`
- * without importing across the one-way boundary — v1 spec §9.7).
- */
-function extractEmbeddedJson(text) {
-    for (let start = 0; start < text.length; start++) {
-        if (text[start] !== "{")
-            continue;
-        let depth = 0;
-        let inString = false;
-        let escaped = false;
-        for (let i = start; i < text.length; i++) {
-            const ch = text[i];
-            if (inString) {
-                if (escaped) {
-                    escaped = false;
-                }
-                else if (ch === "\\") {
-                    escaped = true;
-                }
-                else if (ch === '"') {
-                    inString = false;
-                }
-                continue;
-            }
-            if (ch === '"') {
-                inString = true;
-                continue;
-            }
-            if (ch === "{")
-                depth++;
-            if (ch === "}") {
-                depth--;
-                if (depth === 0) {
-                    try {
-                        return JSON.parse(text.slice(start, i + 1));
-                    }
-                    catch {
-                        break;
-                    }
-                }
-            }
-        }
+    // Phase 6A: extract optional `confidence` (number in [0, 1]). Clamp gently
+    // rather than reject — a model that returns 1.0 or 0 with extra precision
+    // (e.g. 1.0000001) should still surface a usable score. Anything that isn't
+    // a finite number is dropped so downstream `createProposal` can rely on the
+    // shape invariant.
+    if (typeof parsed.confidence === "number" && Number.isFinite(parsed.confidence)) {
+        const clamped = Math.max(0, Math.min(1, parsed.confidence));
+        out.confidence = clamped;
     }
-    return undefined;
+    return out;
 }
 /**
  * Strip `\`\`\`json … \`\`\`` fences and `<think>…</think>` reasoning blocks
- * from agent output. Mirrors `client.ts` but kept local to `agent/` per v1
- * spec §9.7 (one-way boundary — `agent/` does not import from `llm/`).
+ * from agent output. Thin wrapper around `core/parse` helpers, kept exported
+ * for backward compatibility (re-exported from `integrations/agent/index.ts`).
  */
 export function stripJsonFences(text) {
-    const stripped = text
-        .trim()
-        .replace(/<think>[\s\S]*?<\/think>/gi, "")
-        .trim();
-    const fenced = stripped.match(/^```(?:json)?\s*\n([\s\S]*?)\n```$/);
-    if (fenced)
-        return fenced[1] ?? stripped;
-    return stripped;
+    return stripCodeFences(stripThinkBlocks(text));
 }

package/dist/integrations/agent/runner.js

@@ -0,0 +1,151 @@
+// 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/.
+import { ConfigError } from "../../core/errors";
+function resolveEffectiveMode(entry, profileName, config) {
+    if (entry.mode)
+        return entry.mode;
+    // Infer from profile pool when profile is specified
+    if (profileName) {
+        if (config.profiles?.llm?.[profileName])
+            return "llm";
+        const agentProfile = config.profiles?.agent?.[profileName];
+        if (agentProfile) {
+            return agentProfile.platform === "opencode-sdk" ? "sdk" : "agent";
+        }
+    }
+    // Fall back to defaults
+    if (config.defaults?.llm)
+        return "llm";
+    if (config.defaults?.agent)
+        return "agent";
+    return "llm";
+}
+function resolveProfileName(entry, mode, config) {
+    if (entry.profile)
+        return entry.profile;
+    if (mode === "llm") {
+        const defaultName = config.defaults?.llm;
+        if (defaultName)
+            return defaultName;
+        throw new ConfigError(`No LLM profile configured. Set defaults.llm in config or specify profile in the process entry.`, "LLM_NOT_CONFIGURED", "Run `akm setup` or define a profile under `profiles.llm` and set `defaults.llm`.");
+    }
+    const defaultName = config.defaults?.agent;
+    if (defaultName)
+        return defaultName;
+    throw new ConfigError(`No agent profile configured. Set defaults.agent in config or specify profile in the process entry.`, "INVALID_CONFIG_FILE", "Run `akm setup` to configure an agent profile, or add one under `profiles.agent`.");
+}
+function buildLlmRunnerSpec(profileName, timeoutMs, config) {
+    const profile = config.profiles?.llm?.[profileName];
+    if (!profile) {
+        throw new ConfigError(`LLM profile "${profileName}" not found in profiles.llm.`, "LLM_NOT_CONFIGURED", `Available profiles: ${Object.keys(config.profiles?.llm ?? {}).join(", ") || "none"}. Run \`akm setup\` to configure.`);
+    }
+    return {
+        kind: "llm",
+        connection: profile,
+        ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
+    };
+}
+function buildAgentRunnerSpec(kind, profileName, timeoutMs, config) {
+    const profileConfig = config.profiles?.agent?.[profileName];
+    if (!profileConfig) {
+        throw new ConfigError(`Agent profile "${profileName}" not found in profiles.agent.`, "INVALID_CONFIG_FILE", `Available profiles: ${Object.keys(config.profiles?.agent ?? {}).join(", ") || "none"}. Run \`akm setup\` to configure.`);
+    }
+    // Validate mode/platform consistency
+    if (kind === "sdk" && profileConfig.platform !== "opencode-sdk") {
+        throw new ConfigError(`Mode "sdk" requires platform "opencode-sdk", but profiles.agent["${profileName}"].platform is "${profileConfig.platform}".`, "INVALID_CONFIG_FILE");
+    }
+    if (kind === "agent" && profileConfig.platform === "opencode-sdk") {
+        throw new ConfigError(`Mode "agent" requires platform "opencode" or "claude", but profiles.agent["${profileName}"].platform is "opencode-sdk".`, "INVALID_CONFIG_FILE");
+    }
+    const agentProfile = {
+        name: profileName,
+        bin: profileConfig.bin ?? profileName,
+        args: profileConfig.args ?? [],
+        stdio: "captured",
+        envPassthrough: [],
+        parseOutput: "text",
+        ...(profileConfig.model ? { model: profileConfig.model } : {}),
+        ...(profileConfig.workspace ? { workspace: profileConfig.workspace } : {}),
+    };
+    return {
+        kind,
+        profile: agentProfile,
+        ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
+    };
+}
+/**
+ * Resolve the runner used for "validation" passes on the `improve` section
+ * (Advantage D3 / Phase 4B — third model tier).
+ *
+ * Look-up order:
+ *   1. `profiles.improve.default.processes.validation` (preferred — lets users
+ *      wire a lower-cost classifier model for staleness detection, confidence
+ *      scoring, and lesson classification).
+ *   2. `defaults.llm` as a final fallback so callers always get a usable
+ *      runner when any LLM is configured.
+ *
+ * Returns `null` when neither is configured (callers may then skip the
+ * validation pass rather than throwing).
+ */
+export function resolveValidationRunner(config) {
+    const validation = config.profiles?.improve?.default?.processes?.validation;
+    if (validation && validation.enabled !== false && (validation.profile || validation.mode)) {
+        try {
+            const spec = resolveImproveProcessRunnerFromProfile(validation, config);
+            if (spec)
+                return spec;
+        }
+        catch {
+            // Fall through to defaults.llm below.
+        }
+    }
+    const defaultLlm = config.defaults?.llm;
+    if (defaultLlm) {
+        try {
+            return buildLlmRunnerSpec(defaultLlm, undefined, config);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export function resolveRunner(mode, profileName, config) {
+    if (mode === "llm")
+        return buildLlmRunnerSpec(profileName, undefined, config);
+    return buildAgentRunnerSpec(mode, profileName, undefined, config);
+}
+/**
+ * Resolve a RunnerSpec from an improve-profile process entry. Returns `null`
+ * when the entry is absent or provides no overrides — callers should fall
+ * back to the default per-process runner resolution path.
+ */
+export function resolveImproveProcessRunnerFromProfile(processConfig, config) {
+    if (!processConfig)
+        return null;
+    const { mode: explicitMode, profile, timeoutMs } = processConfig;
+    if (!explicitMode && !profile)
+        return null;
+    const mode = explicitMode ?? resolveEffectiveMode(processConfig, profile, config);
+    const profileName = profile ?? resolveProfileName(processConfig, mode, config);
+    if (mode === "llm") {
+        return buildLlmRunnerSpec(profileName, timeoutMs, config);
+    }
+    if (mode === "agent" || mode === "sdk") {
+        return buildAgentRunnerSpec(mode, profileName, timeoutMs, config);
+    }
+    return null;
+}
+/**
+ * Convenience accessor for callers that previously read
+ * `getProcessOptions("index", "staleness_detection", config).thresholdDays`.
+ * After the 0.8.0 migration, those values live on first-class config keys —
+ * see `config.index?.stalenessDetection?.thresholdDays` etc.
+ */
+export function getStalenessDetectionThresholdDays(config) {
+    return config.index?.stalenessDetection?.thresholdDays;
+}
+// Re-export `isProcessEnabled` from feature-gate.ts so callers that previously
+// imported it from runner.ts continue to work.
+export { isProcessEnabled } from "../../llm/feature-gate";

package/dist/integrations/agent/sdk-runner.js

@@ -0,0 +1,126 @@
+// 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 agent runner — uses embedded @opencode-ai/sdk instead of
+ * Bun.spawn. Requires no agent CLI binary to be installed. The user provides
+ * an OpenAI-compatible endpoint (or inherits from config.llm) for the SDK.
+ */
+import { resolveSecret } from "../../core/config";
+// Singleton server — started once per process, reused across calls
+let _server = null;
+/**
+ * Close the singleton OpenCode SDK server and reset the handle.
+ * Primarily for use in tests to ensure clean teardown between test runs.
+ */
+export function closeServer() {
+    try {
+        _server?.server.close();
+    }
+    catch {
+        /* ignore */
+    }
+    _server = null;
+}
+async function getOrStartServer(profile, llmConfig) {
+    if (_server)
+        return _server;
+    const { createOpencode } = await import("@opencode-ai/sdk").catch(() => {
+        throw new Error("OpenCode SDK not available. Install @opencode-ai/sdk or configure a CLI agent instead.");
+    });
+    // Resolve endpoint and model: profile fields take precedence over config.llm
+    const endpoint = profile.endpoint ?? llmConfig?.endpoint;
+    const apiKey = resolveSecret(profile.apiKey ?? llmConfig?.apiKey);
+    const model = profile.model;
+    const sdkConfig = {};
+    if (model)
+        sdkConfig.model = model;
+    if (endpoint || apiKey) {
+        // Configure a custom OpenAI-compatible provider
+        sdkConfig.provider = {
+            "akm-custom": {
+                npm: "@ai-sdk/openai-compatible",
+                options: {
+                    baseURL: endpoint?.replace(/\/chat\/completions$/, "").replace(/\/$/, ""),
+                    ...(apiKey ? { apiKey } : {}),
+                },
+            },
+        };
+        // Use the custom provider's model if not already qualified
+        if (model && !model.includes("/")) {
+            sdkConfig.model = `akm-custom/${model}`;
+        }
+    }
+    _server = (await createOpencode(Object.keys(sdkConfig).length > 0 ? { config: sdkConfig } : {}));
+    process.once("exit", () => {
+        closeServer();
+    });
+    if (!_server)
+        throw new Error("Failed to initialise OpenCode SDK server.");
+    return _server;
+}
+export async function runOpencodeSdk(profile, prompt, _opts = {}, llmConfig) {
+    const start = Date.now();
+    let client;
+    try {
+        ({ client } = await getOrStartServer(profile, llmConfig));
+    }
+    catch (e) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: String(e),
+            durationMs: Date.now() - start,
+            exitCode: 1,
+            reason: "spawn_failed",
+            error: String(e),
+        };
+    }
+    // One session per call — do NOT reuse (history accumulates, token costs grow)
+    const sessionRes = await client.session.create({ body: { title: "akm" } });
+    const sessionId = sessionRes.data?.id;
+    if (!sessionId) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: "Failed to create session",
+            durationMs: Date.now() - start,
+            exitCode: 1,
+            reason: "spawn_failed",
+            error: "Failed to create OpenCode session",
+        };
+    }
+    try {
+        const result = await client.session.prompt({
+            path: { id: sessionId },
+            body: { parts: [{ type: "text", text: prompt }] },
+        });
+        const parts = result.data?.parts ?? [];
+        const textPart = parts.find((p) => p.type === "text");
+        const stdout = textPart?.text ?? "";
+        return {
+            ok: true,
+            stdout,
+            stderr: "",
+            durationMs: Date.now() - start,
+            exitCode: 0,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: String(e),
+            durationMs: Date.now() - start,
+            exitCode: 1,
+            reason: "non_zero_exit",
+            error: String(e),
+        };
+    }
+    finally {
+        // Clean up session to prevent disk accumulation in ~/.local/share/opencode/
+        await client.session.delete({ path: { id: sessionId } }).catch(() => { });
+    }
+}
+/** @deprecated Use {@link runOpencodeSdk} instead. */
+export const runAgentSdk = runOpencodeSdk;