@cortexkit/opencode-magic-context 0.42.6 → 0.43.1

package/src/shared/host-limitations.ts

@@ -0,0 +1,43 @@
+import { USER_FACING_FAILURES, type UserFacingFailureKey } from "./user-facing-codes";
+
+/**
+ * Named things the host Magic Context is running in cannot do.
+ *
+ * A limitation is not a failed operation: it is a capability the current host
+ * lacks for as long as this process lives, so every status surface keeps
+ * printing it instead of showing it once and forgetting. Each one is an
+ * existing MC-* user-facing code, so the status dialog, the plain-text status
+ * summary and the sidebar all print the same sentence for it.
+ *
+ * Process-global on purpose. The surfaces that show these (the RPC status and
+ * sidebar handlers) are built without a reference to the adapter that
+ * discovered the limitation, and a limitation of the host is true for every
+ * session in the process rather than for one of them.
+ */
+const declared = new Set<UserFacingFailureKey>();
+
+/**
+ * Record a limitation of this host. Returns true only the first time a given
+ * limitation is declared, which is what callers use to log their explanation
+ * once instead of on every pass.
+ */
+export function declareHostLimitation(key: UserFacingFailureKey): boolean {
+    if (declared.has(key)) return false;
+    declared.add(key);
+    return true;
+}
+
+/** Limitations declared so far, in the order they were first declared. */
+export function activeHostLimitations(): UserFacingFailureKey[] {
+    return [...declared];
+}
+
+/** The MC-* codes for the declared limitations, for logs and reports. */
+export function activeHostLimitationCodes(): string[] {
+    return activeHostLimitations().map((key) => USER_FACING_FAILURES[key].code);
+}
+
+/** Test helper: forget every declared limitation so suites do not leak them. */
+export function __resetHostLimitations(): void {
+    declared.clear();
+}

package/src/shared/keep-subagents.ts

@@ -1,11 +1,11 @@
 /**
- * Debug / data-collection switch for settled ordinary child sessions
- * (historian and memory migration). Privacy-sensitive Dreamer and
- * smart-note children are still deleted after their prompts settle.
+ * Debug / data-collection switch for every settled Magic Context child session,
+ * including historian, Dreamer, smart-note, user-memory, and migration work.
  *
  * Unsettled children are never deleted inline because OpenCode's server loop may
- * still be writing after a client timeout or abort. They remain for the
- * age-gated sweep; privacy-sensitive rows are swept even when this switch is on.
+ * still be writing after a client timeout or abort. They remain archived for the
+ * age-gated sweep; archived privacy-sensitive rows are swept even when this
+ * switch is on.
  *
  * Process-global, set once at boot from config (mirrors `harness.ts`). A config
  * change requires a restart to take effect.
@@ -17,7 +17,7 @@ export function setKeepSubagents(value: boolean): void {
     keepSubagents = value === true;
 }
 
-/** True when settled ordinary child sessions should be retained. */
+/** True when every settled Magic Context child session should be retained. */
 export function shouldKeepSubagents(): boolean {
     return keepSubagents;
 }

package/src/shared/model-suggestion-retry.test.ts

@@ -225,6 +225,49 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         expect((abort.mock.calls[0]?.[0] as { path: { id: string } }).path.id).toBe("ses-test");
     });
 
+    test("timeout with a resolving transport still aborts the child", async () => {
+        const abort = mock(async () => ({}));
+        const client = createClient(
+            mock(async () => ({})),
+            abort,
+        );
+        const transport = Object.assign(
+            ({ signal }: { signal?: AbortSignal }) =>
+                new Promise<void>((resolve) => signal?.addEventListener("abort", () => resolve())),
+            { childSessionId: "child-test" },
+        );
+        await expect(
+            promptSyncWithModelSuggestionRetry(client, createArgs(), {
+                timeoutMs: 10,
+                transport,
+            }),
+        ).rejects.toThrow("prompt timed out after 10ms");
+        expect(abort).toHaveBeenCalledTimes(1);
+        expect((abort.mock.calls[0]?.[0] as { path: { id: string } }).path.id).toBe("child-test");
+    });
+
+    test("external abort with a resolving transport still aborts the child", async () => {
+        const controller = new AbortController();
+        const abort = mock(async () => ({}));
+        const client = createClient(
+            mock(async () => ({})),
+            abort,
+        );
+        const transport = Object.assign(
+            ({ signal }: { signal?: AbortSignal }) =>
+                new Promise<void>((resolve) => signal?.addEventListener("abort", () => resolve())),
+            { childSessionId: "child-test" },
+        );
+        setTimeout(() => controller.abort(), 10);
+        await expect(
+            promptSyncWithModelSuggestionRetry(client, createArgs(), {
+                signal: controller.signal,
+                transport,
+            }),
+        ).rejects.toThrow("prompt aborted by external signal");
+        expect(abort).toHaveBeenCalledTimes(1);
+    });
+
     // External abort (e.g. dreamer lease loss) mid-flight must also stop the
     // server-side loop, not just our fetch.
     test("external abort fires session.abort on the child session", async () => {
@@ -350,6 +393,49 @@ describe("promptSyncWithModelSuggestionRetry", () => {
 });
 
 describe("promptSyncWithValidatedOutputRetry", () => {
+    test("surfaces a host-recorded assistant refusal even when the row has no text", async () => {
+        const client = createClient(mock(async () => ({})));
+        const refusal =
+            "UnknownError: custody accounts exhausted: provider=synthetic accounts=main:cooldown";
+
+        await expect(
+            promptSyncWithValidatedOutputRetry(client, createArgs(), {
+                fetchOutput: async () => [
+                    {
+                        info: {
+                            role: "assistant",
+                            time: { created: 1 },
+                            finish: "stop",
+                            tokens: { output: 0 },
+                        },
+                        parts: [],
+                    },
+                    {
+                        info: { role: "assistant", time: { created: 2 }, error: refusal },
+                        parts: [],
+                    },
+                ],
+                validateOutput: () => {
+                    throw new Error("empty_completion");
+                },
+            }),
+        ).rejects.toMatchObject({
+            message: `Host recorded assistant error: ${refusal}`,
+            transient: true,
+        });
+    });
+
+    test("keeps a real empty completion without an assistant error on the normal validation path", async () => {
+        const client = createClient(mock(async () => ({})));
+        await expect(
+            promptSyncWithValidatedOutputRetry(client, createArgs(), {
+                fetchOutput: async () => [{ info: { role: "assistant" }, parts: [] }],
+                validateOutput: () => {
+                    throw new Error("empty_completion");
+                },
+            }),
+        ).rejects.toThrow("empty_completion");
+    });
     test("valid first model returns without trying fallbacks", async () => {
         const prompt = mock(async () => ({}));
         const messages = mock(async () => "primary-output");

package/src/shared/model-suggestion-retry.ts

@@ -1,6 +1,10 @@
 import type { createOpencodeClient } from "@opencode-ai/sdk";
 
 import { detectOverflow } from "../features/magic-context/overflow-detection";
+import {
+    extractLatestAssistantFailure,
+    extractLatestAssistantText,
+} from "./assistant-message-extractor";
 import { log } from "./logger";
 import type { ModelInput } from "./model-resolution";
 import { sanitizeDiagnosticText } from "./redaction";
@@ -254,6 +258,18 @@ async function promptWithTimeout(
         clearTimeout(timeout);
         signal?.removeEventListener("abort", onExternalAbort);
     }
+    // Some transports resolve with an error result when their fetch is aborted.
+    // A resolved fetch does not mean the server-side child run has stopped.
+    if (signal?.aborted || controller.signal.aborted) {
+        if (!transport || transport.childSessionId) {
+            await abortChildRun(client, transport?.childSessionId ?? args.path.id);
+        }
+        throw new Error(
+            signal?.aborted
+                ? "prompt aborted by external signal"
+                : `prompt timed out after ${timeoutMs}ms`,
+        );
+    }
 }
 
 /**
@@ -587,6 +603,19 @@ async function attemptAndValidate<TOutput, TValidated>(
     }
 
     try {
+        if (!extractLatestAssistantText(output)) {
+            const assistantFailure = extractLatestAssistantFailure(output);
+            if (assistantFailure) {
+                const error = new Error(
+                    `Host recorded assistant error: ${String(assistantFailure.error)}`,
+                );
+                Object.assign(error, {
+                    name: "DreamerProviderOutputFailureError",
+                    transient: true,
+                });
+                throw error;
+            }
+        }
         const validated = await options.validateOutput(output, attempt);
         return { output, validated, attempt };
     } catch (error) {

package/src/shared/models-dev-cache.ts

@@ -601,6 +601,11 @@ export function modelSupportsVision(providerID: string, modelID: string): boolea
         : false;
 }
 
+export function getSdkOutputLimit(providerID: string, modelID: string): number | undefined {
+    loadPersistedApiCacheOnce();
+    return lookupMetadataWithTagFallback(apiCache, providerID, modelID)?.outputLimit;
+}
+
 export function getSdkInputLimit(providerID: string, modelID: string): number | undefined {
     loadPersistedApiCacheOnce();
     if (!apiCache) return undefined;

package/src/shared/opencode-config-dir.ts

@@ -9,19 +9,64 @@ export type {
     OpenCodeConfigPaths,
 } from "./opencode-config-dir-types";
 
-function getCliConfigDir(): string {
-    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-    if (envConfigDir) {
-        return resolve(envConfigDir);
-    }
+/**
+ * The user's home directory, preferring `$HOME` over the cached value.
+ *
+ * `os.homedir()` reads `$HOME` once when the process starts and never again,
+ * so a test (or a wrapper) that sets `HOME` afterwards would otherwise be
+ * silently ignored and we would read the developer's real config. `$HOME` is
+ * normally unset on Windows, where the cached value is the right answer.
+ */
+function resolveHomeDir(): string {
+    return process.env.HOME?.trim() || homedir();
+}
 
+/**
+ * OpenCode's GLOBAL config directory: `$XDG_CONFIG_HOME/opencode`, falling
+ * back to `~/.config/opencode` (on every platform, Windows included — OpenCode
+ * does not use %APPDATA%).
+ *
+ * This helper names the loader's XDG layer, not every OpenCode surface called
+ * "config". In 1.18.30, `Global.Path.config` is the pure-XDG path
+ * (`packages/core/src/global.ts:13`) and the loader merges it once at
+ * `packages/opencode/src/config/config.ts:412-413`. Its later directories loop
+ * accepts only `.opencode` paths or the exact `OPENCODE_CONFIG_DIR` value
+ * (`config.ts:437-441`), so the XDG layer is skipped there and the env path is
+ * merged last. The detector mirrors that loader order via
+ * {@link getOpenCodeConfigDirs}.
+ *
+ * Service consumers see a different value: `Global.make()` injects
+ * `Flag.OPENCODE_CONFIG_DIR ?? Path.config` as `config`
+ * (`packages/core/src/global.ts:64`), so setting the env var replaces the
+ * service's value even though the loader still merges the XDG layer.
+ */
+export function getOpenCodeGlobalConfigDir(): string {
     if (process.platform === "win32") {
-        return join(homedir(), ".config", "opencode");
+        return join(resolveHomeDir(), ".config", "opencode");
     }
 
-    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+    return join(process.env.XDG_CONFIG_HOME || join(resolveHomeDir(), ".config"), "opencode");
+}
+
+function getEnvConfigDir(): string | undefined {
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+    return envConfigDir ? resolve(envConfigDir) : undefined;
+}
+
+function getCliConfigDir(): string {
+    return getEnvConfigDir() ?? getOpenCodeGlobalConfigDir();
 }
 
+/**
+ * The single directory Magic Context WRITES its OpenCode-side config into.
+ *
+ * `OPENCODE_CONFIG_DIR` wins here on purpose: among the directories OpenCode
+ * reads it has the highest precedence, so a setting written there is the one
+ * that takes effect. Do NOT use this to decide what OpenCode RESOLVED — for
+ * that you must read every directory in {@link getOpenCodeConfigDirs}, because
+ * a value the user set in the global directory is still live when
+ * `OPENCODE_CONFIG_DIR` points somewhere that does not override it.
+ */
 export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
     return getCliConfigDir();
 }
@@ -36,3 +81,31 @@ export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenC
         omoConfig: join(configDir, "magic-context.jsonc"),
     };
 }
+
+/**
+ * Every user-tier directory OpenCode reads config from, ordered from LOWEST to
+ * HIGHEST precedence — later entries override earlier ones, which is the order
+ * OpenCode merges them in.
+ *
+ * Verified against the opencode 1.18.30 binary (`ConfigPaths.directories` plus
+ * the global loader in `Config.loadInstanceState`) and confirmed on a live host
+ * with `opencode debug config`:
+ *
+ *   1. `$XDG_CONFIG_HOME/opencode` — always read, whatever the environment says
+ *   2. `~/.opencode`               — always scanned, even outside a project
+ *   3. `$OPENCODE_CONFIG_DIR`      — appended last, so it wins ties
+ *
+ * The important part is that entry 3 is an ADDITION, not a replacement. A
+ * launcher that exports `OPENCODE_CONFIG_DIR` to a directory holding only
+ * plugin scaffolding does not stop OpenCode from reading the user's real
+ * config in entry 1 — so neither may we.
+ *
+ * Project-level directories are deliberately not included: they depend on the
+ * working directory and are resolved by the caller that knows it.
+ */
+export function getOpenCodeConfigDirs(): string[] {
+    const dirs = [getOpenCodeGlobalConfigDir(), join(resolveHomeDir(), ".opencode")];
+    const envDir = getEnvConfigDir();
+    if (envDir) dirs.push(envDir);
+    return [...new Set(dirs)];
+}

package/src/shared/opencode-db-path.test.ts

@@ -10,6 +10,7 @@ import {
     formatOpenCodeDbDoctorLine,
     formatOpenCodeDbMissingBanner,
     formatOpenCodeDbMissingStatusLine,
+    hasV1MessageTables,
     openCodeDbPathExists,
     resetOpenCodeDbPathStateForTesting,
     resolveOpenCodeDbPath,
@@ -253,6 +254,83 @@ describe("resolveOpenCodeDbPath", () => {
         }
     });
 
+    it("reports v1 message capability on a migrated store accepted by both readers", () => {
+        const { openCodeDir } = useDataHome();
+        const migratedPath = join(openCodeDir, "migrated-v2.db");
+        const migrated = new Database(migratedPath);
+        try {
+            // Captured from an OpenCode 2.0.7 store that the v2 host migrated from a 1.18.x
+            // store: it keeps the v1 `message`/`part` tables beside its own schema, so it
+            // carries BOTH generations. `session_v2` is written only by an OpenCode 2 host
+            // (the 1.18.31 binary never references it). Keep this table list as observed.
+            for (const table of [
+                "account",
+                "account_state",
+                "control_account",
+                "credential",
+                "event",
+                "event_sequence",
+                "instruction_blob",
+                "instruction_entry",
+                "instruction_state",
+                "kv",
+                "message",
+                "migration",
+                "part",
+                "permission",
+                "project",
+                "project_directory",
+                "session",
+                "session_inbox",
+                "session_message",
+                "session_pending",
+                "session_share",
+                "session_v2",
+                "todo",
+                "workspace",
+                "worktree",
+            ]) {
+                migrated.exec(`CREATE TABLE ${table}(id TEXT)`);
+            }
+            expect(hasV1MessageTables(migrated)).toBe(true);
+            expect(() => assertOpenCodeStoreGeneration(migrated, "v2", migratedPath)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(migrated, "v1", migratedPath)).not.toThrow();
+        } finally {
+            migrated.close();
+        }
+    });
+
+    it("reads a fresh OpenCode 2 store as v2 only", () => {
+        const { openCodeDir } = useDataHome();
+        const freshV2Path = join(openCodeDir, "fresh-v2.db");
+        const freshV2 = new Database(freshV2Path);
+        try {
+            // Captured from a new OpenCode 2.0.7 data directory: no v1 message tables.
+            for (const table of [
+                "account",
+                "event",
+                "migration",
+                "permission",
+                "project",
+                "session_inbox",
+                "session_message",
+                "session_pending",
+                "session_v2",
+                "workspace",
+            ]) {
+                freshV2.exec(`CREATE TABLE ${table}(id TEXT)`);
+            }
+            expect(hasV1MessageTables(freshV2)).toBe(false);
+            expect(detectOpenCodeStoreGeneration(freshV2)).toBe("v2");
+            expect(() => assertOpenCodeStoreGeneration(freshV2, "v2", freshV2Path)).not.toThrow();
+            expect(() => assertOpenCodeStoreGeneration(freshV2, "v1", freshV2Path)).toThrow(
+                "expected v1, found v2",
+            );
+        } finally {
+            freshV2.close();
+        }
+    });
+
     it("treats a store with no schema yet as empty rather than as a conflicting host", () => {
         const { openCodeDir } = useDataHome();
         const freshPath = join(openCodeDir, "fresh.db");

package/src/shared/opencode-db-path.ts

@@ -12,10 +12,25 @@ export interface ResolveOpenCodeDbPathOptions {
     env?: NodeJS.ProcessEnv;
 }
 
+/**
+ * Decide the host generation from the version the executable reports, never
+ * from its name (the public installer places OpenCode 2 at
+ * `~/.opencode/bin/opencode` with a tiny `opencode2` shim beside it). The raw
+ * `--version` stdout carries a program-name prefix ("opencode v2.0.12"), so the
+ * major is the first digit run, not `parseInt` of the whole string.
+ *
+ * OpenCode 2's pre-GA betas were published under the old scope as
+ * `@opencode-ai/*@0.0.0-beta-<n>` (verified: `0.0.0-beta-19234` ships the V2
+ * `host`/`promise`/`effect` contract and the `compaction` hook); at GA the line
+ * moved to `@opencode/*@2.0.x`. A major of 0 therefore does not mean 1.x: the
+ * beta and dev pre-release shapes are OpenCode 2.
+ */
 export function openCodeHostGenerationFromVersion(
     version: string | null | undefined,
 ): OpenCodeHostGeneration {
-    const major = Number.parseInt(version?.match(/\d+/)?.[0] ?? "", 10);
+    const text = version ?? "";
+    if (/(?:^|\s|v)0\.0\.0-(?:beta|dev)-/.test(text)) return "v2";
+    const major = Number.parseInt(text.match(/\d+/)?.[0] ?? "", 10);
     return Number.isFinite(major) && major >= 2 ? "v2" : "v1";
 }
 
@@ -214,12 +229,21 @@ function schemaTableNames(
 ): Set<string> {
     const rows = db
         .prepare(
-            `SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message')`,
+            `SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message', 'session_v2')`,
         )
         .all() as Array<{ name?: unknown }>;
     return new Set(rows.flatMap((row) => (typeof row.name === "string" ? [row.name] : [])));
 }
 
+/** Whether the schema has the legacy message tables required by v1-only readers. */
+export function hasV1MessageTables(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): boolean {
+    const tables = schemaTableNames(db, schema);
+    return tables.has("message") && tables.has("part");
+}
+
 /**
  * Detect the persisted host schema.
  *
@@ -240,6 +264,28 @@ export function detectOpenCodeStoreGeneration(
     return "unknown";
 }
 
+/**
+ * A store the OpenCode 2 host migrated from a v1 store keeps the v1 `message`/`part` tables
+ * beside its own schema, so it carries BOTH generations and `detectOpenCodeStoreGeneration`
+ * (which must keep calling a 1.18.x store v1) reports v1. `session_v2` is written only by an
+ * OpenCode 2 host (1.18.x never creates it), so a store with it and `session_message` is
+ * readable by v2 readers regardless of any v1 tables it also kept.
+ */
+function hasMigratedV2Schema(tables: Set<string>): boolean {
+    return tables.has("session_message") && tables.has("session_v2");
+}
+
+/** A native OpenCode 2 store, or a v1 store an OpenCode 2 host has migrated. */
+function isOpenCodeV2Store(
+    db: OpenCodeStoreSchemaDatabase,
+    schema: "main" | "oc_backfill" = "main",
+): boolean {
+    return (
+        detectOpenCodeStoreGeneration(db, schema) === "v2" ||
+        hasMigratedV2Schema(schemaTableNames(db, schema))
+    );
+}
+
 /** Refuse before a generation-specific query can read the other host's schema. */
 export function assertOpenCodeStoreGeneration(
     db: OpenCodeStoreSchemaDatabase,
@@ -249,6 +295,7 @@ export function assertOpenCodeStoreGeneration(
 ): void {
     const actual = detectOpenCodeStoreGeneration(db, schema);
     if (actual === expected) return;
+    if (expected === "v2" && isOpenCodeV2Store(db, schema)) return;
     // A store with none of these tables has no schema YET — a host that has not written its
     // first row, or a fresh data directory. That is "nothing to read", not a conflicting host,
     // and readers have always treated it as empty. Refusing here made every reader throw before

package/src/shared/opencode-host-generation.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "bun:test";
+import { openCodeHostGenerationFromVersion } from "./opencode-db-path";
+
+// The generation is decided from the version the executable reports, never
+// from its name: the public installer puts OpenCode 2 at ~/.opencode/bin/opencode
+// with a tiny `opencode2` shim beside it, so the name says nothing. The raw
+// `--version` stdout carries a program-name prefix ("opencode v2.0.12"); a
+// parser that feeds that to Number.parseInt reads NaN and demotes every
+// standalone 2.x install to 1.x (AFT hit this on a clean VM, 2026-09-21).
+// OpenCode 2's pre-GA betas were `@opencode-ai/*@0.0.0-beta-<n>` — the V2 line
+// wearing the old scope's version string — so a major of 0 is v2, not v1.
+describe("OpenCode host generation from --version output", () => {
+    it.each([
+        ["opencode v2.0.12", "v2"],
+        ["v2.0.12", "v2"],
+        ["2.0.12", "v2"],
+        ["opencode v2.0.12\n", "v2"],
+        ["opencode 1.18.31", "v1"],
+        ["1.18.31", "v1"],
+        ["0.0.0-beta-19234", "v2"],
+        ["opencode v0.0.0-beta-19234", "v2"],
+        ["0.0.0-dev-42", "v2"],
+        ["0.9.3", "v1"],
+        [null, "v1"],
+        ["", "v1"],
+    ])("%p → %s", (raw, expected) => {
+        expect(openCodeHostGenerationFromVersion(raw)).toBe(expected);
+    });
+});