@wolfx/opencode-magic-context 0.21.8-patch.1

package/dist/shared/data-path.d.ts

@@ -0,0 +1,121 @@
+import { type HarnessId } from "./harness";
+export declare function getDataDir(): string;
+/**
+ * Per-harness scratch directory under the OS temp dir.
+ *
+ * Layout:
+ *   - OpenCode: `${os.tmpdir()}/opencode/magic-context/`
+ *   - Pi:       `${os.tmpdir()}/pi/magic-context/`
+ *
+ * Why a per-harness subtree of `os.tmpdir()`:
+ *   1. OpenCode Desktop runs as an Electron app with a permission sandbox.
+ *      Writing to arbitrary tmp paths can trigger user-visible permission
+ *      prompts; the `${tmpdir}/opencode/` subtree is allow-listed by
+ *      OpenCode, so anything we put under it never asks for permission.
+ *   2. Splitting OpenCode from Pi keeps their logs and historian dump
+ *      directories cleanly separated. `doctor --issue` for each harness
+ *      reports diagnostics from the matching subtree, so an OpenCode
+ *      issue report never includes Pi log noise (and vice versa).
+ *   3. Pi has no permission sandbox, so the path choice is purely
+ *      cosmetic for Pi — it just keeps the layout symmetric.
+ *
+ * Pass an explicit `harness` only when the caller already knows the
+ * harness without relying on the global `setHarness()` state (e.g. the
+ * CLI's doctor commands, which target a specific harness regardless of
+ * which plugin is loaded). Production runtime callers should omit it so
+ * the helper picks up the boot-time harness automatically.
+ */
+export declare function getMagicContextTempDir(harness?: HarnessId): string;
+/**
+ * Standard log file path the plugin writes to. Pi and OpenCode write to
+ * SEPARATE logs under their respective harness subtrees so a single
+ * machine running both harnesses doesn't interleave session traces.
+ *
+ * The plugin's buffered logger calls this on every flush rather than
+ * caching, so `setHarness("pi")` taking effect after module load is
+ * reflected in the next flush.
+ */
+export declare function getMagicContextLogPath(harness?: HarnessId): string;
+/**
+ * Directory used for both historian validation-failure dumps and the
+ * existing-state offload XMLs that large historian/recomp passes write
+ * before invoking the model. Per-harness so dumps from different
+ * harnesses don't collide on filename and so `doctor --issue` for each
+ * harness reports only its own historian artifacts.
+ */
+export declare function getMagicContextHistorianDir(harness?: HarnessId): string;
+/**
+ * Project-local magic-context artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/`
+ *
+ * Used for artifacts that the historian/recomp pipeline writes during a run
+ * and that the model is asked to read via its native Read tool. OpenCode's
+ * `external_directory` permission system asks the user before reading any
+ * file outside the project directory or its worktree, which interrupts every
+ * historian run when artifacts live under `os.tmpdir()`. Writing under the
+ * project's own `.opencode/` subtree falls inside the project boundary and
+ * never triggers a permission prompt.
+ *
+ * The `.opencode/` parent dir is OpenCode's own per-project convention (used
+ * for project-local config, plans, dumps, plugin installs). Anchoring
+ * magic-context artifacts under `.opencode/magic-context/` keeps them
+ * co-located with related OpenCode metadata and makes them easy for users to
+ * locate when debugging.
+ *
+ * Logger does NOT use this — log files stay in the per-harness tmp subtree
+ * because they are written by the plugin process itself (no model-side Read
+ * tool call, no permission prompt) and span sessions/projects.
+ */
+export declare function getProjectMagicContextDir(directory: string): string;
+/**
+ * Project-local historian artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/historian/`
+ *
+ * Used for:
+ *   - existing-state offload XMLs that long historian/recomp passes write
+ *     before invoking the model (the model reads the file via Read tool)
+ *   - validation-failure dump XMLs preserved for debugging
+ *
+ * Callers must `mkdirSync(dir, { recursive: true })` before writing — the
+ * `.opencode/` parent may not exist on a fresh project, and write failures
+ * here must degrade gracefully (e.g. historian falls back to inline state).
+ */
+export declare function getProjectMagicContextHistorianDir(directory: string): string;
+export declare function getOpenCodeStorageDir(): string;
+/**
+ * Resolve the shared magic-context storage directory.
+ *
+ * Magic-context's own data (compartments, facts, memories, embeddings, dream
+ * runs, notes, etc.) lives at this path regardless of which harness loaded the
+ * plugin (OpenCode or Pi). This enables:
+ *   - Shared project memories across harnesses
+ *   - Shared embedding cache
+ *   - Shared Dreamer runs (one per project per machine)
+ *   - Future cross-harness session migration
+ *
+ * Layout: <XDG_DATA_HOME>/cortexkit/magic-context/
+ */
+export declare function getMagicContextStorageDir(): string;
+/**
+ * Legacy magic-context storage directory used by the OpenCode plugin before the
+ * shared cortexkit path. Used only for one-time migration of existing data into
+ * the new shared location. The legacy directory is left in place after copy so
+ * users can roll back if needed; manual cleanup is safe after one stable
+ * release.
+ */
+export declare function getLegacyOpenCodeMagicContextStorageDir(): string;
+/**
+ * Resolve OpenCode's cache base directory.
+ *
+ * OpenCode uses the `xdg-basedir` package, which — on every platform, including
+ * Windows — falls back to `<homedir>/.cache` when `XDG_CACHE_HOME` is unset.
+ * A previous Windows-specific branch that resolved to `%LOCALAPPDATA%` did not
+ * match OpenCode's own resolution and caused `doctor --force` to target a
+ * non-existent directory, leaving the real cache at `C:\Users\<user>\.cache`
+ * untouched.
+ */
+export declare function getCacheDir(): string;
+export declare function getOpenCodeCacheDir(): string;
+//# sourceMappingURL=data-path.d.ts.map

package/dist/shared/data-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-path.d.ts","sourceRoot":"","sources":["../../src/shared/data-path.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAEvD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAEhF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,IAAI,MAAM,CAEhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/shared/error-message.d.ts

@@ -0,0 +1,32 @@
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Produce a rich, safe-to-log description of any thrown value.
+ *
+ * Motivated by SDK errors whose `.message` is empty while `.name`/`toString()`
+ * carry the actual signal (e.g. `NotFoundError` with no message on OpenCode
+ * session-delete races). Using {@link getErrorMessage} alone erases that signal.
+ *
+ * Captures:
+ * - `name` from the Error (defaults to `constructor.name`)
+ * - `message` (may be empty)
+ * - first few stack frames
+ * - `String(error)` so objects and custom toString surfaces are visible
+ * - Common HTTP-shape fields (`status`, `statusCode`, `code`)
+ * - `cause` chain summary (first level only)
+ *
+ * Returns a compact, single-line-friendly string suitable for log lines,
+ * plus a structured object for callers that want individual fields.
+ */
+export interface ErrorDescription {
+    name: string;
+    message: string;
+    status?: string;
+    code?: string;
+    causeName?: string;
+    stackHead?: string;
+    stringForm: string;
+    /** Best short summary for human-readable logs. Never empty. */
+    brief: string;
+}
+export declare function describeError(error: unknown): ErrorDescription;
+//# sourceMappingURL=error-message.d.ts.map

package/dist/shared/error-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-message.d.ts","sourceRoot":"","sources":["../../src/shared/error-message.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEtD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;CACjB;AAaD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CA6D9D"}

package/dist/shared/format-bytes.d.ts

@@ -0,0 +1,2 @@
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=format-bytes.d.ts.map

package/dist/shared/format-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-bytes.d.ts","sourceRoot":"","sources":["../../src/shared/format-bytes.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/dist/shared/format-threshold.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Format an execute-threshold percentage for human-facing display.
+ *
+ * `executeThreshold` in the snapshot is always a percentage number, but it
+ * comes from two very different config paths:
+ *   1. `execute_threshold_percentage` (or its model-keyed variant) — user
+ *      configures an integer like 65 directly. We must render exactly that.
+ *   2. `execute_threshold_tokens` — user configures absolute token cap (e.g.
+ *      128000). The resolver in `event-resolvers.ts` divides that by the
+ *      model's context limit (`(128000 / 907788) * 100`) and the result is
+ *      a long float like `14.099783080260304` that overflows the TUI cell
+ *      (issue #90).
+ *
+ * Behaviour:
+ *   - Integer input (≤0.05 fractional drift) renders without decimals.
+ *   - Anything else is rendered with one decimal digit, which is precise
+ *     enough to convey the configured token budget without smearing across
+ *     two lines in a narrow sidebar.
+ *
+ * Returns the formatted percentage WITHOUT the trailing `%` so callers can
+ * compose richer strings like `47.5% / 65%` consistently.
+ */
+export declare function formatThresholdPercent(value: number | undefined | null): string;
+//# sourceMappingURL=format-threshold.d.ts.map

package/dist/shared/format-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-threshold.d.ts","sourceRoot":"","sources":["../../src/shared/format-threshold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAK/E"}

package/dist/shared/harness.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Identifier for the host harness this plugin is running inside.
+ *
+ * Magic Context's SQLite database lives at a vendor-scoped path
+ * (`~/.local/share/cortexkit/magic-context/`) so OpenCode and Pi can share
+ * project memories, embedding cache, dreamer runs, and other project-scoped
+ * state. Session-scoped tables carry a `harness` column populated from this
+ * module so we can disambiguate which harness wrote each session row,
+ * filter by harness in the dashboard, and (eventually) migrate sessions
+ * between harnesses.
+ *
+ * Each plugin entry point sets this once at boot, before any DB write
+ * happens:
+ * - OpenCode plugin: relies on the default ("opencode") — no setHarness call
+ *   needed
+ * - Pi plugin: calls `setHarness("pi")` before opening the database
+ *
+ * NEVER read this from configuration or session state — it is a
+ * boot-time constant per plugin instance. Cross-harness leakage is a
+ * correctness bug, not a feature.
+ */
+export type HarnessId = "opencode" | "pi";
+/**
+ * Set the harness identifier for this plugin instance. Must be called once
+ * at boot before any DB write happens. Subsequent calls with a different
+ * value throw to prevent accidental mid-session swaps that would corrupt
+ * the harness column and break per-harness session scoping.
+ *
+ * Calling with the same value as the current is a no-op (safe to call
+ * defensively).
+ */
+export declare function setHarness(value: HarnessId): void;
+/**
+ * Get the current harness identifier. Used by storage modules when
+ * INSERTing session-scoped rows so each row is correctly attributed.
+ */
+export declare function getHarness(): HarnessId;
+/**
+ * Test-only helper to reset harness state between test cases. Do NOT call
+ * from production code paths.
+ */
+export declare function _resetHarnessForTesting(): void;
+//# sourceMappingURL=harness.d.ts.map

package/dist/shared/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../src/shared/harness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,IAAI,CAAC;AAK1C;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAQjD;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,SAAS,CAEtC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C"}

package/dist/shared/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./logger";
+export * from "./model-requirements";
+export * from "./model-suggestion-retry";
+export * from "./normalize-sdk-response";
+export * from "./resolve-fallbacks";
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

package/dist/shared/internal-initiator-marker.d.ts

@@ -0,0 +1,2 @@
+export declare const OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+//# sourceMappingURL=internal-initiator-marker.d.ts.map

package/dist/shared/internal-initiator-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-initiator-marker.d.ts","sourceRoot":"","sources":["../../src/shared/internal-initiator-marker.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,oCAAoC,CAAC"}

package/dist/shared/jsonc-parser.d.ts

@@ -0,0 +1,8 @@
+export declare function stripJsonComments(content: string): string;
+export declare function parseJsonc<T = unknown>(content: string): T;
+export declare function readJsoncFile<T = unknown>(filePath: string): T | null;
+export declare function detectConfigFile(basePath: string): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+};
+//# sourceMappingURL=jsonc-parser.d.ts.map

package/dist/shared/jsonc-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonc-parser.d.ts","sourceRoot":"","sources":["../../src/shared/jsonc-parser.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA6DzD;AA6CD,wBAAgB,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAG1D;AAED,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAChD,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CAChB,CAaA"}

package/dist/shared/logger.d.ts

@@ -0,0 +1,10 @@
+export declare function log(message: string, data?: unknown): void;
+export declare function sessionLog(sessionId: string, message: string, data?: unknown): void;
+/**
+ * Resolve the current log file path. The path is harness-aware (see
+ * {@link getMagicContextLogPath}) and re-evaluated on every call, so callers
+ * who format diagnostic output with this value always see the path the next
+ * flush will actually use.
+ */
+export declare function getLogFilePath(): string;
+//# sourceMappingURL=logger.d.ts.map

package/dist/shared/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/shared/logger.ts"],"names":[],"mappings":"AAuDA,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAmBzD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAEnF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC"}

package/dist/shared/model-requirements.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Provider-agnostic fallback chain entry.
+ * Each entry specifies a model and the providers to try in priority order.
+ * Follows oh-my-opencode's FallbackEntry pattern — `opencode` acts as a
+ * catch-all proxy provider and is listed last in most entries.
+ */
+export type FallbackEntry = {
+    providers: string[];
+    model: string;
+    variant?: string;
+};
+export type AgentModelRequirement = {
+    fallbackChain: FallbackEntry[];
+};
+export declare const AGENT_MODEL_REQUIREMENTS: Record<string, AgentModelRequirement>;
+/**
+ * Expand a provider-agnostic fallback chain into a flat `provider/model` list
+ * that OpenCode's agent config accepts as `fallback_models`.
+ */
+export declare function expandFallbackChain(chain: FallbackEntry[]): string[];
+/**
+ * Get the expanded fallback_models list for an agent.
+ * Returns undefined if no requirement is defined.
+ */
+export declare function getAgentFallbackModels(agent: string): string[] | undefined;
+//# sourceMappingURL=model-requirements.d.ts.map

package/dist/shared/model-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-requirements.d.ts","sourceRoot":"","sources":["../../src/shared/model-requirements.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IACxB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAChC,aAAa,EAAE,aAAa,EAAE,CAAC;CAClC,CAAC;AAqCF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAM1E,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CAQpE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAI1E"}

package/dist/shared/model-suggestion-retry.d.ts

@@ -0,0 +1,68 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+type PromptBody = {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    [key: string]: unknown;
+};
+type PromptArgs = {
+    path: {
+        id: string;
+    };
+    body: PromptBody;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+};
+export interface PromptRetryOptions {
+    timeoutMs?: number;
+    /** External abort signal — cancels the in-flight LLM prompt immediately when aborted */
+    signal?: AbortSignal;
+    /**
+     * Ordered list of "provider/modelID" alternates to try if the primary call
+     * (and its single-suggestion retry) fails. Empty / undefined = no fallback
+     * iteration (legacy behavior).
+     *
+     * Fallback policy:
+     *   - Each fallback gets the FULL `timeoutMs` budget (per-attempt, not total).
+     *   - Suggestion-retry runs inside each attempt (so "did you mean X?" errors
+     *     still self-heal at the primary AND at each fallback).
+     *   - Iteration stops immediately on abort/timeout/context-overflow errors —
+     *     fallbacks won't help and the caller's emergency-recovery path needs
+     *     to handle these.
+     *   - On all-failed, the LAST error is thrown (matches legacy behavior when
+     *     `fallbackModels` is empty).
+     */
+    fallbackModels?: readonly string[];
+    /**
+     * Identifier for structured logging (e.g. "dreamer:consolidate",
+     * "historian", "compressor", "sidekick"). Helps correlate fallback
+     * attempts to a specific call site in `magic-context.log`. Defaults to
+     * "subagent" if not provided.
+     */
+    callContext?: string;
+}
+export interface ModelSuggestionInfo {
+    providerID: string;
+    modelID: string;
+    suggestion: string;
+}
+export declare function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null;
+/**
+ * Run an OpenCode subagent prompt with model fallback support.
+ *
+ * Attempts the configured primary model first (whatever `args.body.model` or
+ * the registered agent default resolves to), then iterates through
+ * `options.fallbackModels` if provided. Each attempt internally retries once on
+ * the SDK's "model not found, did you mean X?" suggestion. Aborts, timeouts,
+ * and context-overflow errors short-circuit the fallback loop because retrying
+ * the same prompt against another model won't help.
+ *
+ * Behavior with `fallbackModels` empty/undefined is identical to the pre-v0.18
+ * single-suggestion retry — fully backward-compatible for callers that haven't
+ * been updated to thread a chain.
+ */
+export declare function promptSyncWithModelSuggestionRetry(client: Client, args: PromptArgs, options?: PromptRetryOptions): Promise<void>;
+export {};
+//# sourceMappingURL=model-suggestion-retry.d.ts.map

package/dist/shared/model-suggestion-retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-suggestion-retry.d.ts","sourceRoot":"","sources":["../../src/shared/model-suggestion-retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAM7D,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtD,KAAK,UAAU,GAAG;IACd,KAAK,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF,KAAK,UAAU,GAAG;IACd,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wFAAwF;IACxF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACtB;AAiBD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CA4C/E;AAuID;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kCAAkC,CACpD,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,kBAAuB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgFf"}

package/dist/shared/models-dev-cache.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Resolve per-model context limits to match whatever OpenCode itself sees.
+ *
+ * Two layers:
+ *
+ *   1. API cache (primary): populated asynchronously via
+ *      `client.config.providers()`. OpenCode's own provider service merges
+ *      the live models.dev cache file, its compiled-in snapshot fallback,
+ *      opencode.json custom provider overrides, and derived experimental
+ *      modes. Whatever OpenCode reports is the source of truth.
+ *
+ *   2. File cache (fallback): read-from-disk parse of OpenCode's
+ *      `models.json` plus `opencode.json(c)` custom provider entries.
+ *      Used during cold starts before the API cache warms up and in any
+ *      code path that cannot reach the SDK client.
+ *
+ * The public getter (`getModelsDevContextLimit()`) is synchronous: it checks
+ * the API cache first, then the file cache. The plugin warms the API cache
+ * once from `src/index.ts` at startup. Runtime retries are reserved for the
+ * issue #77 cache-regression recovery path.
+ */
+interface OpencodeClientLike {
+    config: {
+        providers: () => Promise<{
+            data?: {
+                providers?: unknown;
+            };
+        }>;
+    };
+}
+/**
+ * Asynchronously refresh the API-layer cache from OpenCode's SDK.
+ *
+ * Call this at plugin startup and from the issue #77 regression-recovery path.
+ * OpenCode's `/config/providers` endpoint returns every provider with full
+ * model metadata — including `limit.context` — resolved through the same path
+ * OpenCode itself uses (live cache + compiled-in snapshot + opencode.json
+ * overrides + derived experimental modes).
+ *
+ * Safe to call concurrently; only overwrites the cache on success.
+ */
+export declare function refreshModelLimitsFromApi(client: OpencodeClientLike): Promise<void>;
+/**
+ * Returns the context limit for a provider/model.
+ *
+ * Lookup order:
+ *   1. API cache (populated by {@link refreshModelLimitsFromApi}). Matches
+ *      what OpenCode sees exactly, including snapshot-only models.
+ *   2. File cache (parsed from models.json + opencode.json overrides).
+ *      Used before the API cache warms and as a last resort.
+ *
+ * Returns `undefined` if neither layer knows the model.
+ */
+export declare function getModelsDevContextLimit(providerID: string, modelID: string): number | undefined;
+/** Clear in-memory caches (for testing). */
+export declare function clearModelsDevCache(): void;
+/** Inspection helpers (for logging / debugging). */
+export declare function getModelsDevCacheState(): {
+    apiLoaded: boolean;
+    apiCount: number;
+    apiAgeMs: number;
+    fileCount: number;
+};
+export {};
+//# sourceMappingURL=models-dev-cache.d.ts.map

package/dist/shared/models-dev-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-dev-cache.d.ts","sourceRoot":"","sources":["../../src/shared/models-dev-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAUH,UAAU,kBAAkB;IACxB,MAAM,EAAE;QACJ,SAAS,EAAE,MAAM,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE;gBAAE,SAAS,CAAC,EAAE,OAAO,CAAA;aAAE,CAAA;SAAE,CAAC,CAAC;KAChE,CAAC;CACL;AA+LD;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAchG;AAED,4CAA4C;AAC5C,wBAAgB,mBAAmB,IAAI,IAAI,CAK1C;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,IAAI;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB,CAOA"}

package/dist/shared/native-binding.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Native-binding resolver for Electron-runtime mismatches.
+ *
+ * Why this module exists
+ * ----------------------
+ * `better-sqlite3` uses raw v8/nan bindings, so its compiled `.node` file is
+ * locked to a specific NODE_MODULE_VERSION (Node-API ABI revision). When
+ * OpenCode Desktop (Electron 41 → ABI 145) loads a plugin whose `node_modules`
+ * was populated by `bun install` / `npm install` under a different runtime,
+ * the fetched prebuild is for `node-vNNN` (e.g. ABI 137 for Node 22) and
+ * Electron refuses to load it with:
+ *
+ *   The module '...better_sqlite3.node' was compiled against a different
+ *   Node.js version using NODE_MODULE_VERSION 137. This version of Node.js
+ *   requires NODE_MODULE_VERSION 145.
+ *
+ * `onnxruntime-node` (used by `@huggingface/transformers` for local
+ * embeddings) is N-API v3 and is ABI-stable across runtimes, so it does NOT
+ * have this problem. Only `better-sqlite3` is affected.
+ *
+ * What this does
+ * --------------
+ * On plugin load, before constructing any `Database`:
+ *
+ *  1. If we are NOT running under Electron (`process.versions.electron` is
+ *     unset), return null. Bun uses `bun:sqlite` and never reaches this code;
+ *     Pi/Node-CLI install matching Node-vNNN prebuilds via npm, which work
+ *     natively against the on-disk binary.
+ *
+ *  2. If we ARE on Electron, locate the `.node` file path that
+ *     `better-sqlite3`'s default `bindings()` lookup would try first. Probe
+ *     its ABI by attempting a sandboxed `process.dlopen`. If it succeeds
+ *     (Electron-compatible), return null — the default lookup will work.
+ *
+ *  3. Otherwise, look for a cached Electron prebuild at
+ *     `<XDG_CACHE_HOME>/cortexkit/native-bindings/better-sqlite3/v<version>/electron-v<abi>-<platform>-<arch>/better_sqlite3.node`.
+ *     Download it from the `WiseLibs/better-sqlite3` GitHub release if
+ *     missing, extract with `nanotar` (pure-JS, ~45 KB, zero deps), validate
+ *     the ABI, and return the absolute path.
+ *
+ * The caller (`sqlite.ts`) then passes this path through `better-sqlite3`'s
+ * documented `nativeBinding` constructor option:
+ *
+ *   new Database(filename, { nativeBinding: <our cached path> })
+ *
+ * `better-sqlite3` calls `require()` directly on that path, bypassing the
+ * normal `bindings()` lookup chain. This is a first-class API the maintainer
+ * added for exactly this kind of cross-runtime extension scenario — see
+ * `node_modules/better-sqlite3/lib/database.js` `nativeBinding` handling.
+ *
+ * Why we don't replace the on-disk binary
+ * ---------------------------------------
+ * An earlier iteration copied the cached Electron binary over the in-tree
+ * `node_modules/.../better_sqlite3.node`. That worked but mutates a shared
+ * resource: in monorepo dev setups (or any case where multiple runtimes
+ * share one `node_modules`), a Pi process opening the plugin from the same
+ * workspace would then load the Electron-ABI binary and fail. Returning a
+ * separate cached path keeps the on-disk file untouched so each runtime
+ * sees the binary it needs.
+ *
+ * Failure modes
+ * -------------
+ * If GitHub is unreachable (corporate firewall, offline laptop, rate limit)
+ * AND no cached binary exists, this throws. The caller (sqlite.ts →
+ * openDatabase) surfaces a `storage unavailable` error and Magic Context
+ * disables itself for the run. The user can connect to the network and
+ * restart, or wait for a cached binary from a previous successful launch.
+ */
+/**
+ * Resolve the absolute path to a `better-sqlite3` `.node` binary that the
+ * current runtime can load.
+ *
+ *   - Returns `null` outside Electron (Bun uses `bun:sqlite`; Pi/Node CLI
+ *     loads matching prebuilds from `node_modules` natively).
+ *   - Returns `null` on Electron when the on-disk binary already matches
+ *     the runtime's ABI (rare but possible — a future OpenCode build that
+ *     post-install-rebuilds for Electron would hit this fast path).
+ *   - Returns the cached/downloaded prebuild path on Electron when the
+ *     on-disk binary's ABI doesn't match.
+ *
+ * The returned path is suitable as the `nativeBinding` option to
+ * `new Database(filename, { nativeBinding })`. better-sqlite3 calls `require()`
+ * directly on it, bypassing the default `bindings()` lookup chain — this is
+ * a documented public API in better-sqlite3, not an internal hack.
+ */
+export declare function resolveBetterSqliteNativeBinding(): Promise<string | null>;
+//# sourceMappingURL=native-binding.d.ts.map

package/dist/shared/native-binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-binding.d.ts","sourceRoot":"","sources":["../../src/shared/native-binding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AA2IH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gCAAgC,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuF/E"}

package/dist/shared/normalize-sdk-response.d.ts

@@ -0,0 +1,5 @@
+export interface NormalizeSDKResponseOptions {
+    preferResponseOnMissingData?: boolean;
+}
+export declare function normalizeSDKResponse<TData>(response: unknown, fallback: TData, options?: NormalizeSDKResponseOptions): TData;
+//# sourceMappingURL=normalize-sdk-response.d.ts.map

package/dist/shared/normalize-sdk-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-sdk-response.d.ts","sourceRoot":"","sources":["../../src/shared/normalize-sdk-response.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,2BAA2B;IACxC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACzC;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,EACtC,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,KAAK,EACf,OAAO,CAAC,EAAE,2BAA2B,GACtC,KAAK,CA2BP"}

package/dist/shared/opencode-compaction-detector.d.ts

@@ -0,0 +1,2 @@
+export declare function isOpenCodeAutoCompactionEnabled(directory: string): boolean;
+//# sourceMappingURL=opencode-compaction-detector.d.ts.map

package/dist/shared/opencode-compaction-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-compaction-detector.d.ts","sourceRoot":"","sources":["../../src/shared/opencode-compaction-detector.ts"],"names":[],"mappings":"AAqBA,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAsB1E"}

package/dist/shared/opencode-config-dir-types.d.ts

@@ -0,0 +1,14 @@
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+export type OpenCodeConfigDirOptions = {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
+};
+export type OpenCodeConfigPaths = {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+};
+//# sourceMappingURL=opencode-config-dir-types.d.ts.map

package/dist/shared/opencode-config-dir-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-config-dir-types.d.ts","sourceRoot":"","sources":["../../src/shared/opencode-config-dir-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAEjE,MAAM,MAAM,wBAAwB,GAAG;IACnC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/shared/opencode-config-dir.d.ts

@@ -0,0 +1,5 @@
+import type { OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
+export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths, } from "./opencode-config-dir-types";
+export declare function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string;
+export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
+//# sourceMappingURL=opencode-config-dir.d.ts.map

package/dist/shared/opencode-config-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-config-dir.d.ts","sourceRoot":"","sources":["../../src/shared/opencode-config-dir.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEjG,YAAY,EACR,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,GACtB,MAAM,6BAA6B,CAAC;AAerC,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,MAAM,CAE/E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,mBAAmB,CAS7F"}

package/dist/shared/record-type-guard.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=record-type-guard.d.ts.map

package/dist/shared/record-type-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-type-guard.d.ts","sourceRoot":"","sources":["../../src/shared/record-type-guard.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}