@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/shared/assistant-message-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-message-extractor.d.ts","sourceRoot":"","sources":["../../src/shared/assistant-message-extractor.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AA8DD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAS3E;AAED,8FAA8F;AAC9F,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAOxF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAuB7D;AAED,mFAAmF;AACnF,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAOnE;AAED,kGAAkG;AAClG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAc7D"}

package/dist/shared/auto-update-provenance.d.ts

@@ -0,0 +1,9 @@
+export declare const AUTO_UPDATE_CHECK_STATE_FILENAME = "last-update-check.json";
+export interface AutoUpdateCheckState {
+    lastCheckedMs?: number;
+    updaterPinnedSpec?: string;
+    updaterPinnedAt?: number;
+}
+export declare function readAutoUpdateCheckState(path: string): AutoUpdateCheckState | null;
+export declare function isUpdaterPinnedSpec(state: AutoUpdateCheckState | null, configuredSpec: string): boolean;
+//# sourceMappingURL=auto-update-provenance.d.ts.map

package/dist/shared/auto-update-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update-provenance.d.ts","sourceRoot":"","sources":["../../src/shared/auto-update-provenance.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gCAAgC,2BAA2B,CAAC;AAEzE,MAAM,WAAW,oBAAoB;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAoBlF;AAED,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,oBAAoB,GAAG,IAAI,EAClC,cAAc,EAAE,MAAM,GACvB,OAAO,CAMT"}

package/dist/shared/bounded-session-map.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Bounded LRU map keyed by session id.
+ *
+ * Rationale: magic-context maintains several module-scope Maps that track
+ * per-session state (prepared injection cache, per-message token cache, etc.).
+ * These are cleared on the `session.deleted` event, but sessions that are
+ * never explicitly deleted — because OpenCode crashed, the user force-quit,
+ * the session was archived rather than deleted, or the session simply outlived
+ * the plugin process's interest in it — leak entries for the lifetime of the
+ * plugin process.
+ *
+ * In long-running OpenCode instances with thousands of sessions over time,
+ * an unbounded `Map<sessionId, LargeObject>` can retain tens of megabytes
+ * indefinitely. A session-scoped LRU with a generous cap (e.g. 100) covers
+ * any realistic working-set of active sessions a user actually cares about,
+ * while evicting cold session ids that will either never return or be
+ * rebuilt from durable SQLite state on their next transform pass.
+ *
+ * Implementation notes:
+ * - Built on `Map` which preserves insertion order. On every `set`/`get`
+ *   touch we delete+reinsert to move the key to the tail (most-recent).
+ * - Eviction drops the oldest entry (first in iteration order).
+ * - The cached value type is generic — callers decide what per-session state
+ *   to store. For injection/token state, all three properties of the cached
+ *   object are safe to throw away: they are either recomputable from the
+ *   messages array on the next pass, or reloadable from SQLite.
+ */
+export declare class BoundedSessionMap<V> {
+    private readonly maxEntries;
+    private readonly store;
+    constructor(maxEntries: number);
+    get(sessionId: string): V | undefined;
+    /**
+     * Peek without touching recency — useful for `has`-style checks that
+     * should not rearrange LRU order. Use sparingly; `get` is the normal
+     * access path.
+     */
+    peek(sessionId: string): V | undefined;
+    has(sessionId: string): boolean;
+    set(sessionId: string, value: V): void;
+    delete(sessionId: string): boolean;
+    clear(): void;
+    get size(): number;
+}
+//# sourceMappingURL=bounded-session-map.d.ts.map

package/dist/shared/bounded-session-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-session-map.d.ts","sourceRoot":"","sources":["../../src/shared/bounded-session-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAiB,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;gBAElC,UAAU,EAAE,MAAM;IAO9B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IASrC;;;;OAIG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAItC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAYtC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIlC,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACJ"}

package/dist/shared/builtin-commands.d.ts

@@ -0,0 +1,24 @@
+export declare function getMagicContextBuiltinCommands(compactionEnabled?: boolean): {
+    "mmc-status": {
+        template: string;
+        description: string;
+    };
+    "mmc-recomp": {
+        template: string;
+        description: string;
+    };
+    "mmc-wrapup": {
+        template: string;
+        description: string;
+    };
+    "mmc-flush": {
+        template: string;
+        description: string;
+    };
+    "mmc-memory-maintain": {
+        template: string;
+        description: string;
+    };
+};
+export type MagicContextBuiltinCommandName = keyof ReturnType<typeof getMagicContextBuiltinCommands>;
+//# sourceMappingURL=builtin-commands.d.ts.map

package/dist/shared/builtin-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-commands.d.ts","sourceRoot":"","sources":["../../src/shared/builtin-commands.ts"],"names":[],"mappings":"AAQA,wBAAgB,8BAA8B,CAAC,iBAAiB,UAAO;;;;;;;;;;;;;;;;;;;;;EAiCtE;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,UAAU,CACzD,OAAO,8BAA8B,CACxC,CAAC"}

package/dist/shared/cache-ttl-display.d.ts

@@ -0,0 +1,25 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { type ResolvedCacheTtl } from "./model-cache-ttl";
+export type CacheTtlDisplaySource = ResolvedCacheTtl["source"] | "session";
+export interface CacheTtlDisplay {
+    value: string;
+    source: CacheTtlDisplaySource;
+    modelKey: string | undefined;
+}
+export interface ResolveCacheTtlDisplayArgs {
+    frozen?: ResolvedCacheTtl;
+    configured: MagicContextConfig["cache_ttl"];
+    configuredExplicitly: boolean;
+    modelKey: string | undefined;
+    sessionValue: string;
+    /** Model key persisted with the last completed assistant response. */
+    sessionModelKey: string | null;
+}
+/**
+ * Resolve status-only TTL text without changing the scheduler's persisted truth.
+ * Use the session value only when its persisted model key matches the model being
+ * displayed; otherwise use live config because the session value may be for another model.
+ */
+export declare function resolveCacheTtlDisplay(args: ResolveCacheTtlDisplayArgs): CacheTtlDisplay;
+export declare function formatCacheTtlDisplay(display: CacheTtlDisplay): string;
+//# sourceMappingURL=cache-ttl-display.d.ts.map

package/dist/shared/cache-ttl-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-ttl-display.d.ts","sourceRoot":"","sources":["../../src/shared/cache-ttl-display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,mBAAmB,CAAC;AAEhF,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,qBAAqB,CAAC;IAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,0BAA0B;IACvC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAC5C,oBAAoB,EAAE,OAAO,CAAC;IAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,0BAA0B,GAAG,eAAe,CAqBxF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAQtE"}

package/dist/shared/cache-ttl-seed.d.ts

@@ -0,0 +1,10 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import type { Database } from "./sqlite";
+/** Seed only before a completed assistant response has made the session row authoritative. */
+export declare function seedSessionCacheTtlIfUnsynced(args: {
+    db: Database;
+    sessionId: string;
+    configured: MagicContextConfig["cache_ttl"];
+    modelKey: string;
+}): boolean;
+//# sourceMappingURL=cache-ttl-seed.d.ts.map

package/dist/shared/cache-ttl-seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-ttl-seed.d.ts","sourceRoot":"","sources":["../../src/shared/cache-ttl-seed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,8FAA8F;AAC9F,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAChD,EAAE,EAAE,QAAQ,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAWV"}

package/dist/shared/child-session-teardown.d.ts

@@ -0,0 +1,34 @@
+interface ChildSessionRequest {
+    path: {
+        id: string;
+    };
+    query?: {
+        directory: string;
+    };
+}
+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 declare function teardownChildSession(args: TeardownChildSessionArgs): Promise<void>;
+export {};
+//# sourceMappingURL=child-session-teardown.d.ts.map

package/dist/shared/child-session-teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-session-teardown.d.ts","sourceRoot":"","sources":["../../src/shared/child-session-teardown.ts"],"names":[],"mappings":"AAEA,UAAU,mBAAmB;IACzB,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACrB,KAAK,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CACjC;AAMD,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE;QACL,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC1D,CAAC;CACL;AAED,MAAM,WAAW,wBAAwB;IACrC,MAAM,EAAE,0BAA0B,CAAC;IACnC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BxF"}

package/dist/shared/commit-detection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Boolean hash test. Non-global (stateless), so this single instance is safe to
+ * reuse with `.test()` across call sites — only `/g` regexes carry `lastIndex`.
+ */
+export declare const COMMIT_HASH_TEST_PATTERN: RegExp;
+/**
+ * Commit-ACTION verbs, with common inflections, each fully word-boundary-anchored
+ * (so they don't match e.g. "commitment"/"merger"). Non-global → safe to share.
+ *
+ * Scope decision: this is the commit-action set the OpenCode + Pi note-nudge
+ * detectors used and pin in tests ("commit/cherry-pick/merge/rebase"). It does
+ * NOT include the bare nouns "hash"/"sha" that the historian's old hint regex
+ * carried — a parity test asserts "hash <hex>" alone must NOT count as a commit,
+ * and those nouns only ever gated a cosmetic hash-strip in historian summaries
+ * (never a trigger), so unifying to the action set is behavior-preserving where
+ * it matters.
+ */
+export declare const COMMIT_VERB_PATTERN: RegExp;
+/** True when a text part mentions a commit hash in a commit context. Used by the
+ *  OpenCode + Pi note-nudge detectors. */
+export declare function textMentionsRecentCommit(text: string): boolean;
+/**
+ * Fresh `/g` capturing, backtick-aware hash pattern for the historian's
+ * extract-and-strip path (matchAll + replace). Returned as a NEW instance per
+ * call: a `/g` regex carries `lastIndex`, so handing out a fresh one is
+ * bulletproof against accidental `.exec()` reuse across callers.
+ */
+export declare function createCommitHashExtractPattern(): RegExp;
+//# sourceMappingURL=commit-detection.d.ts.map

package/dist/shared/commit-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-detection.d.ts","sourceRoot":"","sources":["../../src/shared/commit-detection.ts"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAuC,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,QACsE,CAAC;AAEvG;0CAC0C;AAC1C,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/shared/config-diagnostics.d.ts

@@ -0,0 +1,30 @@
+export declare const CONFIG_WARNING_CLASS: {
+    readonly FILE_PARSE: "file-parse";
+    readonly FILE_IO: "file-io";
+    readonly INVALID_LEAF: "invalid-leaf";
+};
+export type ConfigWarningClass = (typeof CONFIG_WARNING_CLASS)[keyof typeof CONFIG_WARNING_CLASS];
+export interface ConfigParseFailure {
+    warningClass: typeof CONFIG_WARNING_CLASS.FILE_PARSE;
+    source: "user" | "project";
+    path: string;
+    line: number;
+    column: number;
+    message: string;
+    recovered: boolean;
+    warning: string;
+}
+export interface ConfigWarningDetail {
+    warningClass: ConfigWarningClass;
+    source?: "user" | "project";
+    path?: string;
+    line?: number;
+    column?: number;
+    message: string;
+}
+export declare function formatConfigParseStatusLine(failure: ConfigParseFailure): string;
+export declare function formatConfigParseNotice(failures: readonly ConfigParseFailure[]): string;
+/** Claim parse-failure notices once for each runtime surface in this process. */
+export declare function claimConfigParseFailuresOnce(surface: "opencode" | "pi", failures: readonly ConfigParseFailure[]): ConfigParseFailure[];
+export declare function resetClaimedConfigParseFailuresForTesting(): void;
+//# sourceMappingURL=config-diagnostics.d.ts.map

package/dist/shared/config-diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-diagnostics.d.ts","sourceRoot":"","sources":["../../src/shared/config-diagnostics.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAElG,MAAM,WAAW,kBAAkB;IAC/B,YAAY,EAAE,OAAO,oBAAoB,CAAC,UAAU,CAAC;IACrD,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,kBAAkB,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAK/E;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GAAG,MAAM,CAKvF;AAQD,iFAAiF;AACjF,wBAAgB,4BAA4B,CACxC,OAAO,EAAE,UAAU,GAAG,IAAI,EAC1B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GACxC,kBAAkB,EAAE,CAOtB;AAED,wBAAgB,yCAAyC,IAAI,IAAI,CAEhE"}

package/dist/shared/conflict-detector.d.ts

@@ -0,0 +1,139 @@
+import type { OpenCodeHostGeneration } from "./opencode-db-path";
+export interface ConflictResult {
+    /** Whether any blocking conflict was found */
+    hasConflict: boolean;
+    /** Human-readable reasons for each conflict */
+    reasons: string[];
+    /** Which conflicts were found — used for targeted fixes */
+    conflicts: {
+        compactionAuto: boolean;
+        compactionPrune: boolean;
+        dcpPlugin: boolean;
+        omoPreemptiveCompaction: boolean;
+        omoContextWindowMonitor: boolean;
+        omoAnthropicRecovery: boolean;
+    };
+    /**
+     * Resolved native compaction state observed during detection, for honest
+     * reporting in both MC modes. `auto`/`prune` reflect the OpenCode
+     * `compaction` block as resolved by the detector (env override, project
+     * then user, default-on). They are populated even when MC compaction is
+     * OFF (in which case they are NOT flagged as conflicts).
+     */
+    nativeCompaction: {
+        auto: boolean;
+        prune: boolean;
+    };
+}
+/**
+ * Resolved native compaction state, as reported by the host's own config
+ * resolution (ctx.client.config.get() — the same object `opencode debug
+ * config` prints). `auto`/`prune` are booleans; the OpenCode schema annotates
+ * `auto` with default `true` and `prune` with default `false`, so an absent
+ * compaction block resolves to `{ auto: true, prune: false }`.
+ */
+export interface ResolvedCompaction {
+    auto: boolean;
+    prune: boolean;
+    keepTokens?: number;
+    buffer?: number;
+}
+/**
+ * Options for {@link detectConflicts}.
+ *
+ * `compactionEnabled` is the boot-resolved Magic Context compaction mode
+ * (the result of {@link isCompactionEnabled} on the resolved user-tier
+ * config). It MUST be threaded through every production call site — plugin
+ * boot, setup, doctor, conflict-fixer — so the MC-mode decision is never
+ * re-derived at a call site. A call site that genuinely cannot supply it
+ * (e.g. a low-level native-config reader with no MC config handle) MUST
+ * omit it and accept the default `true` (mode-on) behavior, which preserves
+ * today's conflict semantics; it must never silently skip the check.
+ *
+ * `resolvedCompaction` is the host's RESOLVED native compaction state
+ * (fetched via {@link resolveCompactionForBoot}). When present, the
+ * file-based {@link checkCompaction} is NOT called — the resolved values are
+ * used directly. Absent means the file-based fallback is used. The
+ * OPENCODE_DISABLE_AUTOCOMPACT env short-circuit is applied on top of
+ * whichever arm produced the value.
+ *
+ * When `compactionEnabled` is `false` (compaction-off mode), OpenCode
+ * `compaction.auto=true` / `compaction.prune=true` are NOT plugin-disabling
+ * conflicts — native compaction is the user's chosen window manager. DCP
+ * and the three OMO conflict classes keep their existing policy in BOTH
+ * modes.
+ */
+export interface DetectConflictsOptions {
+    compactionEnabled?: boolean;
+    resolvedCompaction?: ResolvedCompaction;
+    hostGeneration?: OpenCodeHostGeneration;
+}
+/**
+ * Detect all conflicts that would prevent magic-context from working correctly.
+ * Checks: OpenCode compaction, DCP plugin, OMO conflicting hooks.
+ *
+ * `compactionEnabled` (default `true`) is the resolved MC compaction mode.
+ * When `false` (compaction-off mode), native `compaction.auto`/`prune` are
+ * reported in {@link ConflictResult.nativeCompaction} but are NOT flagged as
+ * conflicts — native compaction is the intended window manager in that mode.
+ *
+ * `resolvedCompaction` (optional) is the host's RESOLVED native compaction
+ * state from {@link resolveCompactionForBoot}. When present it is used
+ * directly and the file-based {@link checkCompaction} is skipped; when absent
+ * the file-based fallback runs unchanged.
+ */
+export declare function detectConflicts(directory: string, options?: DetectConflictsOptions): ConflictResult;
+/**
+ * Canonical npm package names that represent the conflicting plugin.
+ * Matched against the npm-style segment of each plugin entry, so:
+ *   - "@tarquinen/opencode-dcp"           ✓ direct match
+ *   - "@tarquinen/opencode-dcp@latest"    ✓ version suffix stripped
+ *   - "@tarquinen/opencode-dcp@^3.1.0"    ✓ semver suffix stripped
+ *   - "file:///path/to/opencode-dcp-fork" ✗ unrelated path
+ *
+ * forks/renames that don't ship the conflicting transform/system hooks are
+ * intentionally NOT matched.
+ */
+export declare const DCP_PACKAGE_NAMES: Set<string>;
+/**
+ * Match a plugin entry against a set of canonical npm package names.
+ *
+ * A plugin entry can be:
+ *   - "pkg-name"
+ *   - "pkg-name@version"
+ *   - "@scope/pkg-name"
+ *   - "@scope/pkg-name@version"
+ *   - "file://..." or other URL/path forms (never matched here)
+ *
+ * For the canonical-name path we only match the exact package name (with
+ * optional version suffix). file:// paths and forks with different
+ * package names are intentionally NOT matched — even if a path string
+ * happens to contain a substring like "oh-my-opencode" (e.g. forks like
+ * "oh-my-opencode-slim" published under a different package name).
+ */
+export declare function matchesPackageName(entry: string, canonicalNames: Set<string>): boolean;
+/** Extract the package-name string from a plugin entry.
+ *  OpenCode supports two forms:
+ *   - plain string:        "@scope/pkg@latest"
+ *   - tuple [name, opts]:  ["@scope/pkg@latest", { ... }]
+ *  Returns null for any other shape (numbers, objects, etc.). */
+export declare function extractPluginName(entry: unknown): string | null;
+/**
+ * Canonical OMO npm package names. The plugin publishes under both names as
+ * a versioned alias (latest 3.17.5 on npm at time of writing).
+ *
+ * Forks under a different package name (e.g. `oh-my-opencode-slim`,
+ * `oh-my-opencode-cli`, etc.) are intentionally NOT matched here — they
+ * don't ship the `preemptive-compaction`, `context-window-monitor`, or
+ * `anthropic-context-window-limit-recovery` hooks that conflict with
+ * Magic Context. See https://github.com/cortexkit/magic-context/issues/43.
+ *
+ * The legacy `@code-yeongyu/` scope is no longer used — both names are
+ * unscoped on npm.
+ */
+export declare const OMO_PACKAGE_NAMES: Set<string>;
+/**
+ * Generate a short conflict summary for ignored message display.
+ */
+export declare function formatConflictShort(result: ConflictResult): string;
+//# sourceMappingURL=conflict-detector.d.ts.map

package/dist/shared/conflict-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-detector.d.ts","sourceRoot":"","sources":["../../src/shared/conflict-detector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAyBjE,MAAM,WAAW,cAAc;IAC3B,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IACrB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,2DAA2D;IAC3D,SAAS,EAAE;QACP,cAAc,EAAE,OAAO,CAAC;QACxB,eAAe,EAAE,OAAO,CAAC;QACzB,SAAS,EAAE,OAAO,CAAC;QACnB,uBAAuB,EAAE,OAAO,CAAC;QACjC,uBAAuB,EAAE,OAAO,CAAC;QACjC,oBAAoB,EAAE,OAAO,CAAC;KACjC,CAAC;IACF;;;;;;OAMG;IACH,gBAAgB,EAAE;QACd,IAAI,EAAE,OAAO,CAAC;QACd,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;CACL;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,sBAAsB;IACnC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,cAAc,CAAC,EAAE,sBAAsB,CAAC;CAC3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,sBAAsB,GACjC,cAAc,CAwFhB;AA4JD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,aAAuC,CAAC;AAOtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAoBtF;AAED;;;;iEAIiE;AACjE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI/D;AAiDD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,aAAiD,CAAC;AA2FhF;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAWlE"}

package/dist/shared/conflict-fixer.d.ts

@@ -0,0 +1,20 @@
+import { type ConflictResult } from "./conflict-detector";
+/**
+ * Options for {@link fixConflicts}.
+ *
+ * `compactionEnabled` is the boot-resolved MC compaction mode (the result of
+ * {@link isCompactionEnabled} on the resolved user-tier config). When `false`
+ * (compaction-off mode), the fixer MUST NOT flip `compaction.auto`/`prune` to
+ * `false` — native compaction fields are left byte-for-byte as found, because
+ * native compaction (or nothing) is the user's chosen window manager. DCP and
+ * OMO hook fixes keep their existing policy in BOTH modes.
+ *
+ * Default `true` (mode-on) preserves today's fix behavior for call sites that
+ * cannot supply the resolved mode; they fail toward mode-on, never silently
+ * skipping the fix.
+ */
+export interface FixConflictsOptions {
+    compactionEnabled?: boolean;
+}
+export declare function fixConflicts(directory: string, conflicts: ConflictResult["conflicts"], options?: FixConflictsOptions): string[];
+//# sourceMappingURL=conflict-fixer.d.ts.map

package/dist/shared/conflict-fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-fixer.d.ts","sourceRoot":"","sources":["../../src/shared/conflict-fixer.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,KAAK,cAAc,EAItB,MAAM,qBAAqB,CAAC;AAyJ7B;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,wBAAgB,YAAY,CACxB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,EACtC,OAAO,CAAC,EAAE,mBAAmB,GAC9B,MAAM,EAAE,CA6GV"}

package/dist/shared/context-limit-provenance.d.ts

@@ -0,0 +1,3 @@
+export type ContextLimitProvenance = "prompt_only" | "combined" | "unknown";
+export declare function normalizeContextLimitProvenance(value: unknown): ContextLimitProvenance;
+//# sourceMappingURL=context-limit-provenance.d.ts.map

package/dist/shared/context-limit-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-limit-provenance.d.ts","sourceRoot":"","sources":["../../src/shared/context-limit-provenance.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5E,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAGtF"}

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

@@ -0,0 +1,176 @@
+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 harnesses keeps their logs and historian dump directories
+ *      cleanly separated. `doctor --issue` for each harness reports diagnostics
+ *      from the matching subtree, so issue reports do not include another
+ *      harness's log noise.
+ *   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. Each harness writes to a
+ * separate log under its own subtree so a machine running multiple harnesses
+ * does not interleave session traces.
+ *
+ * The plugin's buffered logger calls this on every flush rather than
+ * caching, so the boot-time `setHarness()` call 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>/.mmc/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 `.mmc/` subtree falls inside the project boundary and
+ * never triggers a permission prompt.
+ *
+ * `.mmc/` is the shared MMC per-project dir (also holds the
+ * project config `mmc.jsonc`). Because these artifacts are transient
+ * debug dumps that shouldn't dirty the user's repo, the first write also drops
+ * a fenced-block `.gitignore` entry ignoring this subdir (see
+ * ensureMmcArtifactGitignore) while leaving `*.jsonc` config tracked.
+ *
+ * Migration note: artifacts used to live under `.opencode/magic-context/`. We
+ * cut the write path forward only — old transient dumps are git-ignored and
+ * regenerated, so they are intentionally NOT migrated (left to be cleaned).
+ *
+ * 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;
+/**
+ * Ensure `<project>/.mmc/.gitignore` ignores Magic Context's transient
+ * artifact subdir (`magic-context/`) without touching anything else in the
+ * shared `.mmc/` dir — the project config `mmc.jsonc` stays
+ * tracked, and any sibling module's (e.g. AFT's) entries are preserved.
+ *
+ * Uses the shared MMC fenced-block convention: each module owns exactly
+ * its `# >>> mmc:<module>` … `# <<< mmc:<module>` block and appends
+ * it idempotently (no-op when its own guard line is already present). This lets
+ * multiple mmc modules coexist in one `.gitignore` without clobbering.
+ *
+ * Best-effort: a write failure never blocks an artifact write (the caller
+ * already degrades gracefully on its own write failures).
+ */
+export declare function ensureMmcArtifactGitignore(directory: string): void;
+/**
+ * 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
+ *
+ * Resolution precedence: test isolation, MMC_STORAGE_DIR, XDG data
+ * home, then the platform default. The explicit override is a complete storage
+ * directory and must be absolute so every process on a host selects one store.
+ *
+ * TEST-ISOLATION GUARD. `openDatabase()` has been guarded in
+ * `resolveDatabasePath()` since the 2026-06-01 (v26) and 2026-06-19 (v41)
+ * incidents, in which unisolated tests migrated the user's REAL shared DB.
+ * Every OTHER caller bypassed that guard — notably the CLI doctors, which
+ * build `join(getMagicContextStorageDir(), "context.db")` themselves and run
+ * `PRAGMA integrity_check` against it. A test that deletes XDG_DATA_HOME to
+ * exercise path fallbacks cannot restore isolation by setting
+ * `process.env.HOME`: bun caches `os.homedir()` at startup, so `getDataDir()`
+ * still resolves to the real home. MMC_TEST_DATA_DIR — set by
+ * `packages/plugin/test-preload.ts`, and restored by any test that touches it
+ * — is honored here, so the preload's "cannot be defeated" guarantee holds for
+ * every caller, not just `openDatabase()`. It is never set in production.
+ *
+ * CWD-INDEPENDENT BACKSTOP. The preload only runs when `bun test`'s CWD has a
+ * bunfig wiring `[test] preload`. A run from a dir WITHOUT that wiring (a
+ * package missing its bunfig, or a brand-new one) executes every *.test.ts with
+ * NO preload, and this resolver would hand back the REAL shared path — which is
+ * how the live DB reached v41. Bun sets NODE_ENV=test for EVERY `bun test`
+ * regardless of CWD, and production never sets it, so that window redirects to
+ * a memoized throwaway dir instead. It lives here rather than in
+ * `resolveDatabasePath()` so direct callers (the CLI doctors' own
+ * `PRAGMA integrity_check`, announcements, the models.dev cache) are covered
+ * too — they never go through the DB resolver.
+ *
+ * In production, MMC_STORAGE_DIR takes precedence over XDG_DATA_HOME.
+ * Test isolation remains authoritative so an ambient override cannot redirect
+ * a test into a user's real shared database.
+ */
+export type MagicContextStorageSource = "test isolation" | "environment override" | "XDG_DATA_HOME" | "platform default";
+export interface MagicContextStorageResolution {
+    path: string;
+    source: MagicContextStorageSource;
+}
+export declare function getMagicContextStorageResolution(): MagicContextStorageResolution;
+export declare function getMagicContextStorageDir(): string;
+/**
+ * Legacy magic-context storage directory used by the OpenCode plugin before the
+ * shared mmc 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":"AAGA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AAGvD,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,CAOhF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,SAAwB,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAkBlE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,MAAM,yBAAyB,GAC/B,gBAAgB,GAChB,sBAAsB,GACtB,eAAe,GACf,kBAAkB,CAAC;AAEzB,MAAM,WAAW,6BAA6B;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,yBAAyB,CAAC;CACrC;AAED,wBAAgB,gCAAgC,IAAI,6BAA6B,CAoChF;AAED,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AA8BD;;;;;;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