akm-cli 0.8.1 → 0.9.0-beta.0

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

@@ -0,0 +1,59 @@
+// 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";
+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.
+ *
+ * Canonical id is `'opencode'`; it has no distinct runtime identity or alias.
+ */
+export class OpencodeHarness extends BaseHarness {
+    id = "opencode";
+    displayName = "OpenCode";
+    aliases = [];
+    // 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"];
+    capabilities = caps({
+        sessionLogs: true,
+        agentDispatch: true,
+        detection: true,
+        configImport: true,
+        runtimeIdentity: true,
+        v1Migration: true,
+    });
+}

package/dist/integrations/{session-logs/providers/opencode.js → harnesses/opencode/session-log.js}

@@ -4,7 +4,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { extractInlineRefMentions } from "../inline-refs";
+import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 function getOpenCodeBaseDir() {
     if (process.platform === "darwin") {
         return path.join(os.homedir(), "Library", "Application Support", "opencode");

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

@@ -0,0 +1,49 @@
+// 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 (#564).
+ *
+ * Per-harness barrel for the SDK-mode dispatch path:
+ *   - agent runner → ./sdk-runner.ts (runOpencodeSdk / runAgentSdk)
+ *
+ * It also defines {@link OpencodeSdkHarness}, the {@link AkmHarness} descriptor
+ * that `HARNESS_REGISTRY` registers.
+ *
+ * Unlike the CLI harnesses, the SDK path has no native session logs of its own
+ * (`capabilities.sessionLogs = false`): it dispatches via the embedded
+ * `@opencode-ai/sdk` and surfaces output directly rather than writing platform
+ * 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,
+    });
+}

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

@@ -0,0 +1,234 @@
+// 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 (migrated from `agent/sdk-runner.ts`, #564).
+ *
+ * Uses the 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.
+ *
+ * This is the runtime surface of the {@link OpencodeSdkHarness} (`id =
+ * 'opencode-sdk'`). It is the dispatch path for `sdkMode` profiles; it exposes
+ * no native session logs of its own (`capabilities.sessionLogs = false`).
+ */
+import { resolveSecret } from "../../../core/config/config.js";
+import { DEFAULT_AGENT_TIMEOUT_MS } from "../../agent/config.js";
+// Singleton server — started once per process, reused across calls
+let _server = null;
+/**
+ * Test-only seam: inject a fake {@link SdkServer} so `runOpencodeSdk` can be
+ * exercised without the real `@opencode-ai/sdk` (which would spin up a server).
+ * Pass `null` to clear. NOT part of the public runtime API — used only to
+ * assert the #564 bug fixes (systemPrompt/tools forwarding + timeout). The
+ * leading underscores mark it as internal.
+ */
+export function __setTestServer(server) {
+    _server = server;
+}
+/**
+ * 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;
+}
+/**
+ * Convert an `AgentDispatchRequest.tools` policy into the SDK's tool-allowlist
+ * shape (`{ [toolName]: boolean }`).
+ *
+ * #564 bug fix (2): the tool list was previously dropped entirely. The CLI
+ * builder passes tools as a comma-separated `--allowedTools` flag; the SDK
+ * instead wants a per-tool boolean map. A list/comma-string of tool names is
+ * treated as an allowlist (each name → true). A structured policy object whose
+ * values are already booleans is forwarded as-is.
+ *
+ * Returns `undefined` when there is nothing to forward, so an absent policy
+ * leaves the SDK's own defaults untouched (behaviour-preserving for callers
+ * that pass no tools).
+ */
+function toolsToSdkAllowlist(tools) {
+    if (tools === undefined || tools === null)
+        return undefined;
+    const names = [];
+    if (typeof tools === "string") {
+        names.push(...tools
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean));
+    }
+    else if (Array.isArray(tools)) {
+        for (const t of tools) {
+            if (typeof t === "string" && t.trim())
+                names.push(t.trim());
+        }
+    }
+    else if (typeof tools === "object") {
+        // Structured policy: forward boolean entries directly.
+        const out = {};
+        for (const [k, v] of Object.entries(tools)) {
+            if (typeof v === "boolean")
+                out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }
+    if (names.length === 0)
+        return undefined;
+    const out = {};
+    for (const n of names)
+        out[n] = true;
+    return out;
+}
+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",
+        };
+    }
+    // #564 bug fixes (1) + (2): forward systemPrompt and tools from the abstract
+    // dispatch request. Both were previously accepted on AgentDispatchRequest but
+    // silently dropped on the SDK path, so SDK-mode dispatch ignored agent-asset
+    // system prompts and tool policies entirely (the CLI path honours both).
+    const dispatch = opts.dispatch;
+    const system = dispatch?.systemPrompt;
+    const tools = toolsToSdkAllowlist(dispatch?.tools);
+    const body = { parts: [{ type: "text", text: prompt }] };
+    if (system)
+        body.system = system;
+    if (tools)
+        body.tools = tools;
+    // #564 bug fix (3): enforce a hard timeout like the CLI path (runAgent).
+    // Previously runOpencodeSdk() awaited session.prompt() with no timeout, so a
+    // hung SDK call (e.g. a stalled local-model endpoint) blocked the caller
+    // indefinitely while the CLI path would have killed the process. We resolve
+    // the same budget runAgent uses (opts.timeoutMs override → profile.timeoutMs
+    // → DEFAULT_AGENT_TIMEOUT_MS) and race the prompt against it. null disables
+    // the timer (parity with runAgent's "no timeout" contract). There is no
+    // OS process to SIGTERM/SIGKILL here, so on timeout we best-effort delete the
+    // session (the SDK's equivalent of reaping the in-flight work) and return a
+    // structured `timeout` failure with the same reason vocabulary as the CLI.
+    const timeoutMs = opts.timeoutMs !== undefined ? opts.timeoutMs : (profile.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS);
+    const setTimeoutImpl = opts.setTimeoutFn ?? setTimeout;
+    const clearTimeoutImpl = opts.clearTimeoutFn ?? clearTimeout;
+    let timer;
+    const TIMED_OUT = Symbol("opencode-sdk-timeout");
+    try {
+        const promptPromise = client.session.prompt({ path: { id: sessionId }, body });
+        const result = timeoutMs === null
+            ? await promptPromise
+            : await Promise.race([
+                promptPromise,
+                new Promise((resolve) => {
+                    timer = setTimeoutImpl(() => resolve(TIMED_OUT), timeoutMs);
+                }),
+            ]);
+        if (result === TIMED_OUT) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: "",
+                durationMs: Date.now() - start,
+                exitCode: null,
+                reason: "timeout",
+                error: `opencode-sdk agent "${profile.name}" timed out after ${timeoutMs}ms`,
+            };
+        }
+        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 {
+        if (timer !== undefined)
+            clearTimeoutImpl(timer);
+        // 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;

package/dist/integrations/harnesses/types.js

@@ -0,0 +1,43 @@
+// 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 base for harness descriptors (#566).
+ *
+ * Provides the default v1-profile-name matcher so the inference logic lives in
+ * ONE place instead of being duplicated across the old `guessAgentPlatform()`
+ * (config-migration) and the `name.includes("claude")` heuristic (setup). A
+ * concrete harness sets `id`/`aliases`/`capabilities` and, when its v1 profile
+ * names could be decorated (e.g. `"opencode-sdk-fast"`), `v1ProfilePrefixes`.
+ */
+export class BaseHarness {
+    runtimeId;
+    setupDetectionDir;
+    /**
+     * Lowercase prefixes that a decorated v1 profile name may start with and
+     * still belong to this harness (e.g. `["opencode-sdk"]`). The canonical id
+     * and aliases are always matched in addition to these; an empty list means
+     * only exact id/alias matches.
+     */
+    v1ProfilePrefixes = [];
+    matchesV1ProfileName(name) {
+        // Only harnesses with a v1→v2 mapping participate; others never claim a
+        // legacy profile name (so unknown names are dropped, not misclassified).
+        if (!this.capabilities.v1Migration)
+            return false;
+        const lower = name.trim().toLowerCase();
+        if (!lower)
+            return false;
+        if (lower === this.id.toLowerCase())
+            return true;
+        for (const alias of this.aliases) {
+            if (lower === alias.toLowerCase())
+                return true;
+        }
+        for (const prefix of this.v1ProfilePrefixes) {
+            if (lower.startsWith(prefix.toLowerCase()))
+                return true;
+        }
+        return false;
+    }
+}

package/dist/integrations/lockfile.js

@@ -3,24 +3,15 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { writeFileAtomic } from "../core/common";
-import { rethrowIfTestIsolationError } from "../core/errors";
-import { probeLock, releaseLock, tryAcquireLockSync } from "../core/file-lock";
-import { getDataDir } from "../core/paths";
-// ── Paths ───────────────────────────────────────────────────────────────────
-const LOCKFILE_NAME = "akm.lock";
-function getLockfilePath() {
-    return path.join(getDataDir(), LOCKFILE_NAME);
-}
+import { writeFileAtomic } from "../core/common.js";
+import { rethrowIfTestIsolationError } from "../core/errors.js";
+import { probeLock, releaseLock, tryAcquireLockSync } from "../core/file-lock.js";
+import { getDataDir, getLockfileLockPath, getLockfilePath } from "../core/paths.js";
 // ── Lock sentinel ────────────────────────────────────────────────────────────
 const LOCK_MAX_RETRIES = 3;
 const LOCK_RETRY_DELAY_MS = 100;
-function getLockSentinelPath() {
-    // The sentinel always lives next to the lock file it guards.
-    return `${path.join(getDataDir(), LOCKFILE_NAME)}.lck`;
-}
 async function acquireLockSentinel() {
-    const sentinelPath = getLockSentinelPath();
+    const sentinelPath = getLockfileLockPath();
     // Ensure the directory exists before attempting to create the sentinel.
     fs.mkdirSync(path.dirname(sentinelPath), { recursive: true });
     for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
@@ -40,7 +31,7 @@ async function acquireLockSentinel() {
     return false;
 }
 function releaseLockSentinel() {
-    releaseLock(getLockSentinelPath());
+    releaseLock(getLockfileLockPath());
 }
 // ── Read / Write ────────────────────────────────────────────────────────────
 export function readLockfile() {
@@ -61,7 +52,7 @@ export function readLockfile() {
 }
 export function writeLockfile(entries) {
     // Always write to $DATA — never to the legacy $CONFIG location.
-    const lockfilePath = path.join(getDataDir(), LOCKFILE_NAME);
+    const lockfilePath = getLockfilePath();
     const dir = path.dirname(lockfilePath);
     fs.mkdirSync(dir, { recursive: true });
     writeFileAtomic(lockfilePath, `${JSON.stringify(entries, null, 2)}\n`);

package/dist/integrations/session-logs/index.js

@@ -1,10 +1,25 @@
 // 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 { ClaudeCodeProvider } from "./providers/claude-code";
-import { OpenCodeProvider } from "./providers/opencode";
-export { extractInlineRefMentions } from "./inline-refs";
+import { getHarness, SESSION_LOG_HARNESSES } from "../harnesses/index.js";
+import { ClaudeCodeProvider } from "../harnesses/claude/session-log.js";
+import { OpenCodeProvider } from "../harnesses/opencode/session-log.js";
+export { extractInlineRefMentions } from "./inline-refs.js";
 const HARNESSES = [new ClaudeCodeProvider(), new OpenCodeProvider()];
+// #562: the unified HARNESS_REGISTRY is the single source of truth for which
+// harnesses expose session logs. Validate (behaviour-preserving) that every
+// session-log provider instantiated above resolves to a registry harness whose
+// `sessionLogs` capability is set — and via the id-normalization bridge, so a
+// provider named "claude-code" still maps to the canonical "claude" harness.
+// This turns a silently-drifting third registry into a startup invariant.
+for (const provider of HARNESSES) {
+    const harness = getHarness(provider.name);
+    if (!harness?.capabilities.sessionLogs) {
+        throw new Error(`[akm] session-log provider "${provider.name}" is not registered as a sessionLogs harness in HARNESS_REGISTRY (src/integrations/harnesses). Add it there.`);
+    }
+}
+// Touch the derived list so the dependency is explicit and tree-shake-safe.
+void SESSION_LOG_HARNESSES;
 const ERROR_PATTERNS = /error|failed|exception|cannot|undefined|null pointer|ENOENT|timeout/i;
 /**
  * Returns all available session log harnesses for the current machine.
@@ -51,19 +66,77 @@ export function aggregateSessionEvents(events) {
     }));
 }
 /**
- * Scan recent session logs from all available harnesses and return
- * repeated failure patterns that might warrant new AKM assets.
+ * Collect normalized session events from a set of harnesses for the health
+ * candidate scan (#568).
+ *
+ * Pipeline selection per harness (capability-gated):
+ *   - readSession-capable harness (`supportsReadSession !== false`): drive the
+ *     richer `listSessions()` + `readSession()` pipeline. `readSession` flattens
+ *     structured content — tool calls, assistant content blocks, thinking,
+ *     tool_result — into event text (e.g. ClaudeCodeProvider's `parseClaudeEvent`
+ *     surfaces `[tool:*]` / `[tool_result]` blocks that the legacy flat
+ *     `readEvents` scan drops entirely). This is what lets health advisories see
+ *     repeated tool failures / long runs that the flat scan hid.
+ *   - legacy-only harness (`supportsReadSession === false`): fall back to the
+ *     legacy flat `readEvents()` scan (behaviour-preserving).
+ *
+ * Extracted as a pure function (harnesses injected) so it is unit-testable
+ * without touching the real on-disk session-log locations.
+ *
+ * `maxSessionsPerHarness` bounds the rich path: `readSession()` reads each
+ * session file IN FULL (unlike the legacy flat scan, which only touched files
+ * with mtime ≥ sinceMs and skipped non-string content). On a machine with a
+ * deep `~/.claude/projects` history a 30-day window can hold hundreds of
+ * multi-MB session files, and reading+parsing every one in full made the
+ * health command (`akm health`, which calls this synchronously) blow past its
+ * latency budget. `listSessions()` returns summaries sorted newest-first, so
+ * capping to the most-recent N sessions per harness keeps the richer signal
+ * for what actually matters (recent activity) while bounding cost. The legacy
+ * flat-scan path is naturally cheaper and is left uncapped.
  */
-export function getExecutionLogCandidates(sinceDays = 7) {
-    const sinceMs = Date.now() - sinceDays * 24 * 60 * 60 * 1000;
+const DEFAULT_MAX_SESSIONS_PER_HARNESS = 50;
+export function collectSessionEvents(harnesses, sinceMs, maxSessionsPerHarness = DEFAULT_MAX_SESSIONS_PER_HARNESS) {
     const events = [];
-    for (const harness of getAvailableHarnesses()) {
+    for (const harness of harnesses) {
         try {
-            events.push(...harness.readEvents({ sinceMs }));
+            if (harness.supportsReadSession === false) {
+                // Legacy-only harness: only the flat event scan is available.
+                events.push(...harness.readEvents({ sinceMs }));
+                continue;
+            }
+            // Rich path: enumerate sessions cheaply, then read each one's full
+            // structured event stream. Falls back to readEvents if listSessions
+            // surfaces nothing (e.g. a harness that wired readSession but whose
+            // listSessions returns empty on this machine) so we never regress
+            // coverage relative to the legacy scan.
+            const summaries = harness.listSessions({ sinceMs });
+            if (summaries.length === 0) {
+                events.push(...harness.readEvents({ sinceMs }));
+                continue;
+            }
+            // summaries are newest-first; bound the full-file reads (see doc above).
+            for (const summary of summaries.slice(0, maxSessionsPerHarness)) {
+                try {
+                    const session = harness.readSession(summary);
+                    events.push(...session.events);
+                }
+                catch {
+                    // a single unreadable session is non-fatal
+                }
+            }
         }
         catch {
             // individual harness failures are non-fatal
         }
     }
+    return events;
+}
+/**
+ * Scan recent session logs from all available harnesses and return
+ * repeated failure patterns that might warrant new AKM assets.
+ */
+export function getExecutionLogCandidates(sinceDays = 7) {
+    const sinceMs = Date.now() - sinceDays * 24 * 60 * 60 * 1000;
+    const events = collectSessionEvents(getAvailableHarnesses(), sinceMs);
     return aggregateSessionEvents(events);
 }

package/dist/llm/call-ai.js

@@ -1,10 +1,10 @@
 // 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 { getDefaultLlmConfig } from "../core/config";
-import { warn } from "../core/warn";
-import { resolveAgentProfile, runAgent } from "../integrations/agent";
-import { chatCompletion } from "./client";
+import { getDefaultLlmConfig } from "../core/config/config.js";
+import { warn } from "../core/warn.js";
+import { resolveAgentProfile, runAgent } from "../integrations/agent/index.js";
+import { chatCompletion } from "./client.js";
 /**
  * Unified AI call: prefers the default agent profile, falls back to the
  * default LLM profile. When neither is configured, returns a structured