@cortexkit/opencode-magic-context 0.41.4 → 0.42.0

package/src/shared/child-session-teardown.ts

@@ -0,0 +1,66 @@
+import { shouldKeepSubagents } from "./keep-subagents";
+
+interface ChildSessionRequest {
+    path: { id: string };
+    query?: { directory: string };
+}
+
+interface ArchiveChildSessionRequest extends ChildSessionRequest {
+    body: { time: { archived: number } };
+}
+
+export interface ChildSessionTeardownClient {
+    session: {
+        delete(request: ChildSessionRequest): Promise<unknown>;
+    };
+}
+
+export interface TeardownChildSessionArgs {
+    client: ChildSessionTeardownClient;
+    sessionId: string | null;
+    sessionDirectory?: string;
+    promptSettled: boolean;
+    privacySensitive: boolean;
+    context: string;
+    log: (message: string) => void;
+}
+
+/**
+ * Retire a child only after its prompt helper resolves. An unresolved client call
+ * can leave OpenCode's server loop writing, so that row is archived for immediate
+ * UI hiding and retained until the age-gated sweep can delete it safely.
+ *
+ * OpenCode's generated v2 SDK models archival as `session.update` with
+ * `time.archived`; the plugin's legacy path/body client reaches the same PATCH
+ * endpoint, although its generated TypeScript body type does not yet expose time.
+ */
+export async function teardownChildSession(args: TeardownChildSessionArgs): Promise<void> {
+    const { client, sessionId, sessionDirectory, promptSettled, privacySensitive, context, log } =
+        args;
+    if (!sessionId) return;
+
+    const request: ChildSessionRequest = {
+        path: { id: sessionId },
+        ...(sessionDirectory ? { query: { directory: sessionDirectory } } : {}),
+    };
+
+    if (promptSettled && (privacySensitive || !shouldKeepSubagents())) {
+        await client.session.delete(request).catch((error: unknown) => {
+            log(`${context}: session cleanup failed: ${String(error)}`);
+        });
+        return;
+    }
+
+    if (!promptSettled) {
+        const archiveSession = client.session as unknown as {
+            update?: (request: ArchiveChildSessionRequest) => Promise<unknown>;
+        };
+        await archiveSession
+            .update?.({
+                ...request,
+                body: { time: { archived: Date.now() } },
+            })
+            .catch(() => {});
+        log(`${context}: prompt unsettled — session ${sessionId} left to the age-gated sweep`);
+    }
+}

package/src/shared/keep-subagents.ts

@@ -1,19 +1,14 @@
 /**
- * Debug / data-collection switch: when enabled, Magic Context does NOT delete
- * the child sessions it spawns for its own subagents (historian, dreamer,
- * sidekick, memory-migration, key-files, user-memory review, recomp).
+ * 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.
  *
- * By default these child sessions are deleted on success (only FAILED ones are
- * kept for debugging). With `keep_subagents: true` ALL of them are retained, so
- * their full transcript — prompt, tool calls, token usage, model output — stays
- * inspectable in OpenCode's session store / the dashboard. Intended for
- * short-term data collection (e.g. profiling what the dreamer actually does)
- * before the dreamer v2 overhaul, NOT for steady-state use — kept sessions
- * accumulate in the host's session DB until manually cleared.
+ * 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.
  *
- * Process-global, set once at boot from config (mirrors `harness.ts`). A
- * config change requires a restart to take effect. NEVER thread this through
- * per-call args — it's a coarse, boot-time debug toggle.
+ * Process-global, set once at boot from config (mirrors `harness.ts`). A config
+ * change requires a restart to take effect.
  */
 let keepSubagents = false;
 
@@ -22,7 +17,7 @@ export function setKeepSubagents(value: boolean): void {
     keepSubagents = value === true;
 }
 
-/** True when subagent child sessions should be retained (not deleted). */
+/** True when settled ordinary child sessions should be retained. */
 export function shouldKeepSubagents(): boolean {
     return keepSubagents;
 }

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

@@ -71,7 +71,7 @@ export interface PromptRetryOptions {
     fallbackModels?: readonly ModelInput[];
     /**
      * Identifier for structured logging (e.g. "dreamer:consolidate",
-     * "historian", "compressor", "sidekick"). Helps correlate fallback
+     * "historian", "compressor", "dreamer"). Helps correlate fallback
      * attempts to a specific call site in `magic-context.log`. Defaults to
      * "subagent" if not provided.
      */

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

@@ -0,0 +1,196 @@
+/// <reference types="bun-types" />
+
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    formatOpenCodeDbDoctorLine,
+    formatOpenCodeDbMissingBanner,
+    formatOpenCodeDbMissingStatusLine,
+    openCodeDbPathExists,
+    resetOpenCodeDbPathStateForTesting,
+    resolveOpenCodeDbPath,
+} from "./opencode-db-path";
+
+const ORIGINAL_ENV = {
+    XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+    OPENCODE_DB: process.env.OPENCODE_DB,
+    OPENCODE_DISABLE_CHANNEL_DB: process.env.OPENCODE_DISABLE_CHANNEL_DB,
+    OPENCODE_CHANNEL: process.env.OPENCODE_CHANNEL,
+};
+const tempDirs: string[] = [];
+
+function restore(name: keyof typeof ORIGINAL_ENV): void {
+    const value = ORIGINAL_ENV[name];
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+}
+
+afterEach(() => {
+    restore("XDG_DATA_HOME");
+    restore("OPENCODE_DB");
+    restore("OPENCODE_DISABLE_CHANNEL_DB");
+    restore("OPENCODE_CHANNEL");
+    resetOpenCodeDbPathStateForTesting();
+    for (const directory of tempDirs.splice(0)) rmSync(directory, { recursive: true, force: true });
+});
+
+function useDataHome(): { dataHome: string; openCodeDir: string } {
+    const dataHome = mkdtempSync(join(tmpdir(), "opencode-db-path-"));
+    const openCodeDir = join(dataHome, "opencode");
+    mkdirSync(openCodeDir, { recursive: true });
+    tempDirs.push(dataHome);
+    process.env.XDG_DATA_HOME = dataHome;
+    delete process.env.OPENCODE_DB;
+    delete process.env.OPENCODE_DISABLE_CHANNEL_DB;
+    delete process.env.OPENCODE_CHANNEL;
+    resetOpenCodeDbPathStateForTesting();
+    return { dataHome, openCodeDir };
+}
+
+function createCandidate(openCodeDir: string, name: string, mtimeMs: number): string {
+    const path = join(openCodeDir, name);
+    writeFileSync(path, "sqlite fixture");
+    const time = new Date(mtimeMs);
+    utimesSync(path, time, time);
+    return path;
+}
+
+describe("resolveOpenCodeDbPath", () => {
+    it("honors absolute and relative OPENCODE_DB overrides before every other source", () => {
+        const { openCodeDir } = useDataHome();
+        const absolute = join(openCodeDir, "elsewhere.db");
+        process.env.OPENCODE_DB = absolute;
+        process.env.OPENCODE_DISABLE_CHANNEL_DB = "true";
+        process.env.OPENCODE_CHANNEL = "dev";
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: absolute,
+            source: "OPENCODE_DB",
+            channel: null,
+        });
+
+        process.env.OPENCODE_DB = "relative.db";
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: join(openCodeDir, "relative.db"),
+            source: "OPENCODE_DB",
+            channel: null,
+        });
+    });
+
+    it("treats OPENCODE_DB=:memory: as an explicit but absent store", () => {
+        useDataHome();
+        process.env.OPENCODE_DB = ":memory:";
+        const resolution = resolveOpenCodeDbPath();
+        expect(resolution).toEqual({ path: ":memory:", source: "OPENCODE_DB", channel: null });
+        expect(openCodeDbPathExists(resolution)).toBe(false);
+    });
+
+    it("uses the default DB when channel databases are disabled", () => {
+        const { openCodeDir } = useDataHome();
+        process.env.OPENCODE_DISABLE_CHANNEL_DB = "1";
+        process.env.OPENCODE_CHANNEL = "dev";
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: join(openCodeDir, "opencode.db"),
+            source: "default",
+            channel: null,
+        });
+    });
+
+    it("honors an OPENCODE_CHANNEL visible to the plugin", () => {
+        const { openCodeDir } = useDataHome();
+        process.env.OPENCODE_CHANNEL = "dev";
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: join(openCodeDir, "opencode-dev.db"),
+            source: "channel",
+            channel: "dev",
+        });
+    });
+
+    for (const selectedName of [
+        "opencode.db",
+        "opencode-local.db",
+        "opencode-dev.db",
+        "opencode-nightly.db",
+    ]) {
+        it(`discovers ${selectedName} when it is the newest existing candidate`, () => {
+            const { openCodeDir } = useDataHome();
+            const names = [
+                "opencode.db",
+                "opencode-local.db",
+                "opencode-dev.db",
+                "opencode-nightly.db",
+            ];
+            for (const [index, name] of names.entries()) {
+                createCandidate(openCodeDir, name, name === selectedName ? 10_000 : 1_000 + index);
+            }
+
+            expect(resolveOpenCodeDbPath()).toEqual({
+                path: join(openCodeDir, selectedName),
+                source: "discovered",
+                channel:
+                    selectedName === "opencode.db"
+                        ? null
+                        : selectedName.slice("opencode-".length, -".db".length),
+            });
+        });
+    }
+
+    it("uses candidate order as the deterministic tie-breaker for equal mtimes", () => {
+        const { openCodeDir } = useDataHome();
+        for (const name of ["opencode-local.db", "opencode-dev.db", "opencode.db"]) {
+            createCandidate(openCodeDir, name, 5_000);
+        }
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: join(openCodeDir, "opencode.db"),
+            source: "discovered",
+            channel: null,
+        });
+    });
+
+    it("returns the default path by value when no candidate exists", () => {
+        const { openCodeDir } = useDataHome();
+        const resolution = resolveOpenCodeDbPath();
+        expect(resolution).toEqual({
+            path: join(openCodeDir, "opencode.db"),
+            source: "default",
+            channel: null,
+        });
+        expect(openCodeDbPathExists(resolution)).toBe(false);
+    });
+
+    it("re-probes discovery when the memoized chosen file disappears", () => {
+        const { openCodeDir } = useDataHome();
+        const primary = createCandidate(openCodeDir, "opencode-local.db", 2_000);
+        const fallback = createCandidate(openCodeDir, "opencode.db", 1_000);
+        expect(resolveOpenCodeDbPath().path).toBe(primary);
+
+        unlinkSync(primary);
+        expect(resolveOpenCodeDbPath()).toEqual({
+            path: fallback,
+            source: "discovered",
+            channel: null,
+        });
+    });
+
+    it("formats the missing banner, status, and doctor lines by value", () => {
+        const { openCodeDir } = useDataHome();
+        const lookedFor = [
+            join(openCodeDir, "opencode.db"),
+            join(openCodeDir, "opencode-local.db"),
+            join(openCodeDir, "opencode-dev.db"),
+            join(openCodeDir, "opencode-<channel>.db"),
+        ].join(", ");
+        const resolution = resolveOpenCodeDbPath();
+
+        expect(formatOpenCodeDbMissingBanner(resolution)).toBe(
+            `Magic Context cannot find OpenCode's session database (looked for ${lookedFor}). History compaction (historian) and the mid-turn valve are disabled until it is found; set OPENCODE_DB if OpenCode stores it elsewhere.`,
+        );
+        expect(formatOpenCodeDbMissingStatusLine(resolution)).toBe(
+            `OpenCode DB: MISSING (looked for ${lookedFor}). History compaction (historian) and the mid-turn valve are disabled; set OPENCODE_DB if OpenCode stores it elsewhere.`,
+        );
+        expect(formatOpenCodeDbDoctorLine(resolution)).toBe(
+            `FAIL OpenCode session database: not found (looked for ${lookedFor}); set OPENCODE_DB if OpenCode stores it elsewhere.`,
+        );
+    });
+});

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

@@ -0,0 +1,215 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
+export type OpenCodeDbPathSource = "OPENCODE_DB" | "channel" | "default" | "discovered";
+
+export interface OpenCodeDbPathResolution {
+    path: string;
+    source: OpenCodeDbPathSource;
+    channel: string | null;
+}
+
+export interface OpenCodeDbReadFailure extends OpenCodeDbPathResolution {
+    message: string;
+}
+
+interface CachedResolution {
+    key: string;
+    resolution: OpenCodeDbPathResolution;
+    existed: boolean;
+}
+
+let cachedResolution: CachedResolution | null = null;
+let lastReadFailure: OpenCodeDbReadFailure | null = null;
+const claimedDiagnostics = new Set<string>();
+
+function openCodeDataDir(): string {
+    return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
+}
+
+function environmentKey(dataDir: string): string {
+    return [
+        dataDir,
+        process.env.OPENCODE_DB ?? "",
+        process.env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
+        process.env.OPENCODE_CHANNEL ?? "",
+    ].join("\0");
+}
+
+function channelPath(dataDir: string, channel: string): string {
+    return ["latest", "beta", "prod"].includes(channel)
+        ? join(dataDir, "opencode.db")
+        : join(dataDir, `opencode-${channel}.db`);
+}
+
+function discoveredCandidateNames(dataDir: string): string[] {
+    const names = ["opencode.db", "opencode-local.db", "opencode-dev.db"];
+    try {
+        const discovered = readdirSync(dataDir, { withFileTypes: true })
+            .filter((entry) => /^opencode-.+\.db$/.test(entry.name) && !names.includes(entry.name))
+            .map((entry) => entry.name)
+            .sort();
+        names.push(...discovered);
+    } catch {
+        // A missing or unreadable data directory has no discovered candidates.
+    }
+    return names;
+}
+
+function discoverOpenCodeDb(dataDir: string): OpenCodeDbPathResolution {
+    const candidates = discoveredCandidateNames(dataDir).map((name, order) => {
+        const path = join(dataDir, name);
+        try {
+            const metadata = statSync(path);
+            return metadata.isFile() ? { path, order, mtimeMs: metadata.mtimeMs } : null;
+        } catch {
+            return null;
+        }
+    });
+    const existing = candidates
+        .filter((candidate): candidate is NonNullable<typeof candidate> => candidate !== null)
+        .sort((left, right) => right.mtimeMs - left.mtimeMs || left.order - right.order)[0];
+
+    if (!existing) {
+        return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
+    }
+
+    const name = existing.path.slice(dataDir.length + 1);
+    const channel =
+        name === "opencode.db" ? null : name.slice("opencode-".length, -".db".length) || null;
+    return { path: existing.path, source: "discovered", channel };
+}
+
+function resolveFresh(dataDir: string): OpenCodeDbPathResolution {
+    const explicit = process.env.OPENCODE_DB;
+    if (explicit !== undefined && explicit.length > 0) {
+        if (explicit === ":memory:") {
+            return { path: explicit, source: "OPENCODE_DB", channel: null };
+        }
+        return {
+            path: isAbsolute(explicit) ? explicit : join(dataDir, explicit),
+            source: "OPENCODE_DB",
+            channel: null,
+        };
+    }
+
+    const disableChannelDb = process.env.OPENCODE_DISABLE_CHANNEL_DB;
+    if (disableChannelDb === "1" || disableChannelDb === "true") {
+        return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
+    }
+
+    const channel = process.env.OPENCODE_CHANNEL;
+    if (channel !== undefined && channel.length > 0) {
+        return { path: channelPath(dataDir, channel), source: "channel", channel };
+    }
+
+    return discoverOpenCodeDb(dataDir);
+}
+
+/** Resolve an explicit DB override first, then channel paths; discover candidates when the compiled channel is unknown. */
+export function resolveOpenCodeDbPath(): OpenCodeDbPathResolution {
+    const dataDir = openCodeDataDir();
+    const key = environmentKey(dataDir);
+    if (
+        cachedResolution?.key === key &&
+        (!cachedResolution.existed || existsSync(cachedResolution.resolution.path))
+    ) {
+        if (cachedResolution.existed) return cachedResolution.resolution;
+        // An absent result is re-probed so a DB created after plugin boot is detected.
+    }
+
+    const resolution = resolveFresh(dataDir);
+    cachedResolution = {
+        key,
+        resolution,
+        existed: resolution.path !== ":memory:" && existsSync(resolution.path),
+    };
+    return resolution;
+}
+
+export function openCodeDbPathExists(
+    resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
+): boolean {
+    return resolution.path !== ":memory:" && existsSync(resolution.path);
+}
+
+export function getOpenCodeDbProbeDescriptions(
+    resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
+): string[] {
+    if (resolution.source === "OPENCODE_DB") return [resolution.path];
+    if (
+        resolution.source === "channel" ||
+        process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" ||
+        process.env.OPENCODE_DISABLE_CHANNEL_DB === "true"
+    ) {
+        return [resolution.path];
+    }
+    const dataDir = openCodeDataDir();
+    return [
+        join(dataDir, "opencode.db"),
+        join(dataDir, "opencode-local.db"),
+        join(dataDir, "opencode-dev.db"),
+        join(dataDir, "opencode-<channel>.db"),
+    ];
+}
+
+function lookedForText(resolution: OpenCodeDbPathResolution): string {
+    return getOpenCodeDbProbeDescriptions(resolution).join(", ");
+}
+
+export function formatOpenCodeDbMissingBanner(
+    resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
+): string {
+    return `Magic Context cannot find OpenCode's session database (looked for ${lookedForText(resolution)}). History compaction (historian) and the mid-turn valve are disabled until it is found; set OPENCODE_DB if OpenCode stores it elsewhere.`;
+}
+
+export function formatOpenCodeDbMissingStatusLine(
+    resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
+): string {
+    return `OpenCode DB: MISSING (looked for ${lookedForText(resolution)}). History compaction (historian) and the mid-turn valve are disabled; set OPENCODE_DB if OpenCode stores it elsewhere.`;
+}
+
+export function formatOpenCodeDbDoctorLine(
+    resolution: OpenCodeDbPathResolution = resolveOpenCodeDbPath(),
+): string {
+    return `FAIL OpenCode session database: not found (looked for ${lookedForText(resolution)}); set OPENCODE_DB if OpenCode stores it elsewhere.`;
+}
+
+export function formatOpenCodeDbReadFailureStatusLine(failure: OpenCodeDbReadFailure): string {
+    return `OpenCode DB: READ FAILED (path=${failure.path}, source=${failure.source}) — ${failure.message}`;
+}
+
+export function recordOpenCodeDbReadFailure(
+    resolution: OpenCodeDbPathResolution,
+    error: unknown,
+): OpenCodeDbReadFailure {
+    const message = error instanceof Error ? error.message : String(error);
+    lastReadFailure = { ...resolution, message };
+    return lastReadFailure;
+}
+
+export function clearOpenCodeDbReadFailure(path?: string): void {
+    if (path === undefined || lastReadFailure?.path === path) lastReadFailure = null;
+}
+
+export function getOpenCodeDbReadFailure(): OpenCodeDbReadFailure | null {
+    return lastReadFailure;
+}
+
+export function claimOpenCodeDbDiagnosticOnce(
+    surface: string,
+    resolution: OpenCodeDbPathResolution,
+): boolean {
+    const key = `${surface}\0${resolution.path}\0${resolution.source}`;
+    if (claimedDiagnostics.has(key)) return false;
+    claimedDiagnostics.add(key);
+    return true;
+}
+
+/** Test-only reset for process memoization and once-only diagnostics. */
+export function resetOpenCodeDbPathStateForTesting(): void {
+    cachedResolution = null;
+    lastReadFailure = null;
+    claimedDiagnostics.clear();
+}