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

package/dist/shared/resolve-fallbacks.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Resolve the final fallback model list to attempt for an OpenCode subagent
+ * call.
+ *
+ * Policy (decided 2026-05-10):
+ *   - If user configured explicit `fallback_models` in their magic-context.jsonc
+ *     for this agent: use ONLY those. Respects user intent, no surprise
+ *     providers.
+ *   - If user did NOT configure any: fall back to the plugin's builtin
+ *     provider-agnostic chain (`AGENT_MODEL_REQUIREMENTS`).
+ *
+ * The returned list does NOT include the primary model — it's the ordered
+ * list of *alternates* to try after the primary fails. Each entry is
+ * "provider/modelID" form.
+ *
+ * Duplicates and empty strings are filtered. Entries that don't match the
+ * "provider/modelID" shape (must contain a "/" with non-empty parts) are
+ * also dropped — defensive guard against malformed user config.
+ */
+export declare function resolveFallbackChain(agentName: string, userFallbacks: readonly string[] | string | undefined): string[];
+/**
+ * Parse a "provider/modelID" string into the OpenCode `model` object shape.
+ * Returns null on invalid input.
+ *
+ * Note: only splits on the FIRST "/" — modelID can legitimately contain slashes
+ * (e.g. `lemonade/GLM-4.7-Flash-GGUF/main`).
+ */
+export declare function parseProviderModel(spec: string): {
+    providerID: string;
+    modelID: string;
+} | null;
+//# sourceMappingURL=resolve-fallbacks.d.ts.map

package/dist/shared/resolve-fallbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-fallbacks.d.ts","sourceRoot":"","sources":["../../src/shared/resolve-fallbacks.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAChC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,GACtD,MAAM,EAAE,CAUV;AA2BD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO/F"}

package/dist/shared/rpc-client.d.ts

@@ -0,0 +1,17 @@
+export declare class MagicContextRpcClient {
+    private port;
+    private portDir;
+    private legacyPortFilePath;
+    private healthChecked;
+    constructor(storageDir: string, directory: string);
+    /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
+    call<T = Record<string, unknown>>(method: string, params?: Record<string, unknown>): Promise<T>;
+    /** Check if the RPC server is reachable. */
+    isAvailable(): Promise<boolean>;
+    private resolvePort;
+    private readPortFile;
+    private healthCheck;
+    private fetchWithTimeout;
+    reset(): void;
+}
+//# sourceMappingURL=rpc-client.d.ts.map

package/dist/shared/rpc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-client.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-client.ts"],"names":[],"mappings":"AAiBA,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,aAAa,CAAS;gBAElB,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,iFAAiF;IAC3E,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,OAAO,CAAC,CAAC,CAAC;IAiDb,4CAA4C;IACtC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;YASvB,WAAW;IAkCzB,OAAO,CAAC,YAAY;YA4BN,WAAW;YAWX,gBAAgB;IAU9B,KAAK,IAAI,IAAI;CAIhB"}

package/dist/shared/rpc-notifications.d.ts

@@ -0,0 +1,24 @@
+/**
+ * In-memory notification queue for server→TUI push.
+ * Replaces SQLite plugin_messages table.
+ *
+ * Also tracks whether a TUI client is actively connected (polling).
+ * The server plugin cannot use `process.env.OPENCODE_CLIENT` to detect TUI
+ * because the server runs in a separate process from the TUI client.
+ */
+export interface RpcNotification {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}
+/** Push a notification for TUI to pick up via polling. */
+export declare function pushNotification(type: string, payload: Record<string, unknown>, sessionId?: string): void;
+/** Return pending notifications after acking the client's last received id.
+ *  Updates lastDrainAt so isTuiConnected() reflects recent activity. */
+export declare function drainNotifications(lastReceivedId?: number): RpcNotification[];
+/** Whether a TUI client is actively polling for notifications.
+ *  Returns true only if the TUI has drained within the last 3 seconds.
+ *  This prevents stale-connected state after TUI closes or disconnects. */
+export declare function isTuiConnected(): boolean;
+//# sourceMappingURL=rpc-notifications.d.ts.map

package/dist/shared/rpc-notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-notifications.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-notifications.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAUD,0DAA0D;AAC1D,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,SAAS,CAAC,EAAE,MAAM,GACnB,IAAI,CAMN;AAED;wEACwE;AACxE,wBAAgB,kBAAkB,CAAC,cAAc,SAAI,GAAG,eAAe,EAAE,CAMxE;AAED;;2EAE2E;AAC3E,wBAAgB,cAAc,IAAI,OAAO,CAExC"}

package/dist/shared/rpc-server.d.ts

@@ -0,0 +1,20 @@
+type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export declare class MagicContextRpcServer {
+    private server;
+    private port;
+    private handlers;
+    private portFilePath;
+    private portDir;
+    private startedAt;
+    constructor(storageDir: string, directory: string);
+    /** Register an RPC method handler. */
+    handle(method: string, handler: RpcHandler): void;
+    /** Start the server on a random port, write port to disk. */
+    start(): Promise<number>;
+    private warnIfOtherLiveInstance;
+    /** Stop the server and clean up port file. */
+    stop(): void;
+    private dispatch;
+}
+export {};
+//# sourceMappingURL=rpc-server.d.ts.map

package/dist/shared/rpc-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-server.ts"],"names":[],"mappings":"AAaA,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAExF,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAc;gBAEnB,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,sCAAsC;IACtC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAIjD,6DAA6D;IACvD,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAkD9B,OAAO,CAAC,uBAAuB;IAgB/B,8CAA8C;IAC9C,IAAI,IAAI,IAAI;IAYZ,OAAO,CAAC,QAAQ;CA4DnB"}

package/dist/shared/rpc-types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared types for RPC between server and TUI plugins.
+ * Both sides import these — no SQLite dependency.
+ */
+export interface SidebarSnapshot {
+    sessionId: string;
+    usagePercentage: number;
+    inputTokens: number;
+    contextLimit: number;
+    systemPromptTokens: number;
+    compartmentCount: number;
+    factCount: number;
+    memoryCount: number;
+    memoryBlockCount: number;
+    pendingOpsCount: number;
+    historianRunning: boolean;
+    compartmentInProgress: boolean;
+    sessionNoteCount: number;
+    readySmartNoteCount: number;
+    cacheTtl: string;
+    lastDreamerRunAt: number | null;
+    projectIdentity: string | null;
+    compartmentTokens: number;
+    factTokens: number;
+    memoryTokens: number;
+    /**
+     * Token estimate of real user/assistant discussion (text + reasoning +
+     * image parts) inside messages, excluding injected <session-history>
+     * blocks. Display layer shows this as "Conversation".
+     */
+    conversationTokens: number;
+    /**
+     * Token estimate of tool call I/O inside messages (tool_use, tool_result,
+     * tool, tool-invocation parts). Actionable — users can reduce via
+     * ctx_reduce. Display layer shows this as "Tool Calls".
+     */
+    toolCallTokens: number;
+    /**
+     * Measured token cost of tool schemas (description + JSON-schema
+     * parameters) OpenCode sends in the request `tools` parameter. Populated
+     * by the `tool.definition` plugin hook, keyed by
+     * `{providerID, modelID, agentName}`. Zero until the first turn after
+     * plugin startup measures the current agent's tool set. Display layer
+     * shows this as "Tool Definitions".
+     */
+    toolDefinitionTokens: number;
+    /**
+     * Effective execute-threshold percentage for this session's active model,
+     * after per-model resolution and the tokens→percentage conversion (when
+     * `execute_threshold_tokens` applies). Surfaces in the sidebar / status
+     * dialog header alongside `usagePercentage` so users can see how close
+     * the session is to triggering compaction. Defaults to `65` when no live
+     * model is known yet — matches the runtime fallback used by the
+     * scheduler and transform paths.
+     */
+    executeThreshold: number;
+    newWorkTokens?: number | null;
+    totalInputTokens?: number | null;
+}
+export interface StatusDetail extends SidebarSnapshot {
+    tagCounter: number;
+    activeTags: number;
+    droppedTags: number;
+    totalTags: number;
+    activeBytes: number;
+    lastResponseTime: number;
+    lastNudgeTokens: number;
+    lastNudgeBand: string;
+    lastTransformError: string | null;
+    isSubagent: boolean;
+    pendingOps: Array<{
+        tagId: number;
+        operation: string;
+    }>;
+    contextLimit: number;
+    cacheTtlMs: number;
+    cacheRemainingMs: number;
+    cacheExpired: boolean;
+    executeThreshold: number;
+    /**
+     * Which config source produced `executeThreshold`. "tokens" means
+     * execute_threshold_tokens matched for this session's model and was
+     * converted to a percentage. "percentage" means percentage config was used.
+     */
+    executeThresholdMode: "percentage" | "tokens";
+    /**
+     * When `executeThresholdMode === "tokens"`, the absolute clamped token value
+     * (≤ 80% × contextLimit) that will trigger execute. Undefined in percentage mode.
+     */
+    executeThresholdTokens?: number;
+    protectedTagCount: number;
+    nudgeInterval: number;
+    historyBudgetPercentage: number;
+    nextNudgeAfter: number;
+    historyBlockTokens: number;
+    compressionBudget: number | null;
+    compressionUsage: string | null;
+}
+export interface RpcNotificationMessage {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}
+//# sourceMappingURL=rpc-types.d.ts.map

package/dist/shared/rpc-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-types.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;OAOG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,YAAa,SAAQ,eAAe;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,oBAAoB,EAAE,YAAY,GAAG,QAAQ,CAAC;IAC9C;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,sBAAsB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/shared/rpc-utils.d.ts

@@ -0,0 +1,19 @@
+export interface RpcPortFileRecord {
+    port: number;
+    pid: number;
+    started_at: number;
+}
+/**
+ * Stable hash for a project directory — scopes RPC port files per-project
+ * so multiple OpenCode instances don't collide.
+ */
+export declare function projectHash(directory: string): string;
+/** Directory containing per-process RPC discovery files for a project. */
+export declare function rpcPortDir(storageDir: string, directory: string): string;
+/** Per-process RPC port file path. */
+export declare function rpcPortFilePath(storageDir: string, directory: string, pid?: number): string;
+/** Legacy single-port file used by v0.18.0 and earlier. */
+export declare function legacyRpcPortFilePath(storageDir: string, directory: string): string;
+export declare function isPidAlive(pid: number): boolean;
+export declare function parseRpcPortFile(content: string, fallbackPid?: number): RpcPortFileRecord | null;
+//# sourceMappingURL=rpc-utils.d.ts.map

package/dist/shared/rpc-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-utils.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-utils.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,sCAAsC;AACtC,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,SAAc,GAAG,MAAM,CAEhG;AAED,2DAA2D;AAC3D,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAQ/C;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,iBAAiB,GAAG,IAAI,CAwB3F"}

package/dist/shared/sqlite-helpers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cross-runtime helpers that smooth over the small bun:sqlite ↔ better-sqlite3
+ * API differences without leaking either library into call sites.
+ */
+import type { Database } from "./sqlite";
+/**
+ * Close a database, ignoring errors.
+ *
+ * bun:sqlite supports `db.close(throwOnError = false)`. better-sqlite3 has
+ * only `db.close()` and throws on already-closed databases. This helper
+ * mirrors the bun "swallow errors" semantics for both runtimes — useful in
+ * test teardown and `finally` blocks where the caller doesn't care whether
+ * the close succeeded.
+ */
+export declare function closeQuietly(db: Database | null | undefined): void;
+//# sourceMappingURL=sqlite-helpers.d.ts.map

package/dist/shared/sqlite-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-helpers.d.ts","sourceRoot":"","sources":["../../src/shared/sqlite-helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAUlE"}

package/dist/shared/sqlite.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SQLite chokepoint — runtime-detected backend selection.
+ *
+ * The same shipped plugin artifact must run under two different runtimes:
+ *   - Bun (current OpenCode releases) → uses `bun:sqlite` (built-in, fast)
+ *   - Node (OpenCode beta + future Pi plugin) → uses `better-sqlite3`
+ *
+ * Bun cannot load `better-sqlite3` (oven-sh/bun#4290), and Node has no
+ * `bun:sqlite` module. Static imports of either would crash at parse time
+ * in the wrong runtime, so we use dynamic imports gated by runtime detection.
+ *
+ * The Function-constructor wrapper around `import()` defeats bundler static
+ * analysis — without it, esbuild/bun build would try to resolve both modules
+ * during the bundle step, including the one that doesn't exist in the build
+ * runtime.
+ *
+ * Both libraries expose ~95% API parity:
+ *   - new Database(path, { readonly?: boolean })
+ *   - db.prepare(sql).run/get/all
+ *   - db.exec(multistatement)
+ *   - db.transaction(fn) → wrapped function
+ *   - db.close()
+ *
+ * The 5% that differs (db.query, db.run, db.close(boolean), Database.open)
+ * is either rewritten to common-subset patterns or hidden behind the helpers
+ * in `./sqlite-helpers.ts`.
+ */
+import type BetterSqlite3 from "better-sqlite3";
+export declare const Database: typeof BetterSqlite3;
+/** Instance type alias used by helpers and storage modules. */
+export type Database = BetterSqlite3.Database;
+/**
+ * Statement instance type used for WeakMap caches throughout the codebase.
+ *
+ * We deliberately use the variadic Statement<unknown[], unknown> shape rather
+ * than `ReturnType<Database["prepare"]>` because the latter resolves through
+ * a conditional return type in @types/better-sqlite3 that confuses TypeScript
+ * about how many arguments .run/.get/.all accept. With this explicit type,
+ * cached statements accept any number of bind args (matching bun:sqlite's
+ * historical behavior in this codebase).
+ */
+export type Statement = BetterSqlite3.Statement<unknown[], unknown>;
+//# sourceMappingURL=sqlite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/shared/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAC;AAsFhD,eAAO,MAAM,QAAQ,EAAE,OAAO,aAA4B,CAAC;AAE3D,+DAA+D;AAC/D,MAAM,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC"}

package/dist/shared/stable-json.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Process-local deterministic JSON serialization for JSON-like plain
+ * objects. Keys are sorted by code-point order (NOT locale-sensitive).
+ *
+ * Contract:
+ * - Stable for plain objects, arrays, primitives, and `null`.
+ * - `undefined` serialized as the string "undefined".
+ * - Circular references serialized as the string `"[Circular]"`.
+ * - **NOT** a canonical cross-runtime / cross-locale JSON serializer.
+ *   Two different runtimes that disagree on `JSON.stringify` of primitives
+ *   (none known today) would produce different output.
+ *
+ * Used for:
+ * - `tool_definition_measurements` fingerprint hashing
+ * - `pending_compaction_marker_state` CAS comparison
+ *
+ * If a future use case needs true canonical JSON (e.g. cross-process
+ * signing), build a separate utility — do NOT widen this contract.
+ */
+export declare function stableStringify(value: unknown, seen?: WeakSet<object>): string;
+//# sourceMappingURL=stable-json.d.ts.map

package/dist/shared/stable-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable-json.d.ts","sourceRoot":"","sources":["../../src/shared/stable-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,kBAAwB,GAAG,MAAM,CAiBpF"}

package/dist/shared/subagent-runner.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Cross-harness subagent runner abstraction.
+ *
+ * Magic Context spawns three kinds of subagents — historian, dreamer, sidekick —
+ * each as a child "session" with its own model/prompt/tools. OpenCode and Pi
+ * have very different APIs for this:
+ *
+ *   - OpenCode: `client.session.create({parentID}) → client.session.prompt() →
+ *     client.session.messages() → client.session.delete()`. The plugin runs
+ *     in-process with the OpenCode server and uses its SDK client directly.
+ *
+ *   - Pi: no in-process child-session API. Instead `pi --print --mode=json`
+ *     spawns a non-interactive subprocess that emits structured JSON events
+ *     and exits when the agent loop finishes. Sessions are JSONL files on
+ *     disk, optionally addressed via `--session <path>`.
+ *
+ * The runner interface below normalizes both into the same shape so the
+ * actual subagent business logic (historian XML parsing, dreamer task loop,
+ * sidekick augmentation) can stay harness-agnostic. Each harness ships its
+ * own runner implementation; agents take a `SubagentRunner` as a dep instead
+ * of reaching for `client.session.*` directly.
+ *
+ * Step 5a (this commit) defines the contract and ships `PiSubagentRunner`.
+ * Step 5b will refactor the OpenCode-side spawn paths in
+ * `compartment-runner-historian.ts`, `dreamer/runner.ts`, and
+ * `sidekick/agent.ts` onto an `OpenCodeSubagentRunner` so both harnesses
+ * share the agent business logic instead of duplicating it. Until 5b lands,
+ * OpenCode keeps its existing direct `client.session.*` calls untouched —
+ * the runner contract is purely additive on the OpenCode side.
+ */
+/**
+ * Configuration for one subagent invocation.
+ *
+ * Mirrors the union of OpenCode's `session.create` + `session.prompt` body
+ * fields and Pi's `--print` CLI flags, picking the shared subset that all
+ * three subagent kinds (historian, dreamer, sidekick) actually use today.
+ *
+ * Fields:
+ * - `agent`: harness-specific agent name. OpenCode looks this up in its
+ *   agent registry (`HISTORIAN_AGENT`, `DREAMER_AGENT`, `SIDEKICK_AGENT`).
+ *   Pi has no concept of "agent name" beyond config, so this is ignored
+ *   on the Pi side and used only by `OpenCodeSubagentRunner`.
+ * - `systemPrompt`: full system prompt for this child run. Replaces (not
+ *   appends to) any harness-default system prompt.
+ * - `userMessage`: the single user-turn prompt. Subagent runs are always
+ *   one-shot — no multi-turn conversation in the child.
+ * - `model`: provider/model identifier in the canonical "provider/model"
+ *   shape (e.g. "anthropic/claude-sonnet-4-7"). Each runner is responsible
+ *   for translating to its harness's native model selection.
+ * - `fallbackModels`: ordered list of models to try if `model` fails. Both
+ *   harnesses retry on transient model failures.
+ * - `timeoutMs`: hard cap on the child run. The runner aborts the child on
+ *   exceeding this and returns `{ ok: false, reason: "timeout" }`.
+ * - `cwd`: working directory for the child. OpenCode uses this for
+ *   `query.directory`; Pi uses it as the spawn cwd so that `--cwd`-aware
+ *   tools see the right project root.
+ * - `signal`: optional AbortSignal so callers can cancel an in-flight run
+ *   (used by dreamer's lease-renewal-aborts-on-loss path).
+ */
+export interface SubagentRunOptions {
+    agent: string;
+    systemPrompt: string;
+    userMessage: string;
+    model?: string | undefined;
+    fallbackModels?: readonly string[];
+    timeoutMs?: number | undefined;
+    cwd?: string | undefined;
+    signal?: AbortSignal | undefined;
+    /**
+     * Pi only: explicit thinking level, passed as `--thinking <level>` to the
+     * Pi subprocess. OpenCode ignores this field — thinking/reasoning is
+     * controlled via `variant` in the OpenCode agent config instead.
+     *
+     * Required when the configured historian/dreamer model supports reasoning
+     * (e.g. github-copilot/gpt-5.4) because Pi's own default resolution may
+     * pick a value the provider rejects. Set to "off" to disable thinking for
+     * speed (local models), or "medium"/"high" for better quality.
+     */
+    thinkingLevel?: string | undefined;
+    /**
+     * Optional progress callback. The runner invokes it for milestone events
+     * during the run: spawn, first event received, terminal stop reason
+     * detected, child exit. Used by historian/dreamer/sidekick to write
+     * lifecycle entries to the magic-context.log without polluting the
+     * normal stdout stream.
+     *
+     * Implementations must be non-throwing and fast — they're called on the
+     * runner's hot path. Errors are swallowed.
+     */
+    onProgress?: (event: SubagentProgressEvent) => void;
+    /** Optional token accounting metadata. When present, harness runners persist subagent_invocations. */
+    accountingSessionId?: string | undefined;
+    accountingSubagent?: "historian" | "historian_editor" | "compressor" | "dreamer" | "sidekick" | "user_memory_review" | "recomp" | undefined;
+    accountingTask?: string | null | undefined;
+    accountingParentInvocationId?: number | null | undefined;
+}
+/**
+ * Progress events emitted by a runner during a run. Distinct from the final
+ * `SubagentRunResult` — these are mid-run milestones plus (optionally) every
+ * raw event the underlying harness emits, so callers can write a complete
+ * trace to the log when diagnosing hangs.
+ *
+ * Categories:
+ * - `spawned` / `child_exit` / `stderr` — process lifecycle.
+ * - `first_event` — convenience: first event received from the child, useful
+ *   for measuring auth/network warmup time.
+ * - `terminal` — runner detected the final assistant turn (Pi: assistant
+ *   message_end with terminal stopReason and no toolCall; OpenCode: SDK
+ *   `agent_end` equivalent).
+ * - `raw_event` — every parsed event from the harness's structured output
+ *   stream (Pi NDJSON / OpenCode SDK events). Emitted unconditionally so
+ *   debug logs can capture the full timeline. The `event` payload is
+ *   harness-shaped — callers should treat it as `unknown` and log it raw.
+ */
+export type SubagentProgressEvent = {
+    type: "spawned";
+    argv: readonly string[];
+    pid: number | undefined;
+} | {
+    type: "first_event";
+    eventType: string;
+    ms: number;
+} | {
+    type: "raw_event";
+    eventType: string | undefined;
+    event: unknown;
+    ms: number;
+} | {
+    type: "terminal";
+    stopReason: string | undefined;
+    textLength: number;
+    hasToolCall: boolean;
+    ms: number;
+} | {
+    type: "stderr";
+    chunk: string;
+} | {
+    type: "child_exit";
+    code: number | null;
+    signal: string | null;
+    ms: number;
+};
+/**
+ * Result of one subagent invocation.
+ *
+ * The runner contract is "fail soft": transient errors, timeouts, model
+ * failures, and aborts all surface as `{ ok: false, reason }` with a
+ * machine-readable reason and a human-readable message. Throwing is
+ * reserved for programmer errors (bad arguments, missing dependencies)
+ * that the agent code couldn't have caused.
+ *
+ * Fields:
+ * - `ok`: true iff the child produced a final assistant message.
+ * - `assistantText`: concatenated text content from the final assistant
+ *   message, with leading/trailing whitespace trimmed. Empty string if the
+ *   child finished but produced no text (rare — usually means the model
+ *   only emitted tool calls and we didn't follow up).
+ * - `reason`: failure category, one of:
+ *     - `"timeout"`: hit `timeoutMs` before the child finished
+ *     - `"abort"`: caller's `signal` was triggered
+ *     - `"model_failed"`: every configured model + fallback returned an error
+ *     - `"truncated"`: child stopped because model output hit length limits
+ *     - `"spawn_failed"`: subprocess couldn't start (Pi only — binary missing,
+ *       permission denied, etc.)
+ *     - `"non_zero_exit"`: child exited unsuccessfully before a final answer
+ *     - `"no_assistant"`: child completed without a final assistant message
+ *     - `"parse_failed"`: child emitted output we couldn't parse (Pi only —
+ *       JSON malformed or unexpected event ordering)
+ * - `error`: human-readable detail; safe to log, may include stack info.
+ * - `durationMs`: wall-clock time from runner-call to runner-return.
+ * - `meta`: optional harness-specific debug payload. Currently unused; left
+ *   here so the OpenCode runner can surface the child session ID for log
+ *   correlation when Step 5b lands.
+ */
+export type SubagentRunResult = {
+    ok: true;
+    assistantText: string;
+    durationMs: number;
+    meta?: Record<string, unknown>;
+} | {
+    ok: false;
+    reason: "timeout" | "abort" | "model_failed" | "truncated" | "spawn_failed" | "non_zero_exit" | "no_assistant" | "parse_failed";
+    error: string;
+    durationMs: number;
+    meta?: Record<string, unknown>;
+};
+/**
+ * Abstract runner contract.
+ *
+ * Each harness ships a single instance — the OpenCode plugin wires
+ * `OpenCodeSubagentRunner` and the Pi plugin wires `PiSubagentRunner` in
+ * its `extension` boot path. Agent code (historian, dreamer, sidekick)
+ * receives the runner as a dep and never reaches for harness-specific
+ * client APIs directly.
+ */
+export interface SubagentRunner {
+    /** Human-readable harness name, for logging (`"opencode"` or `"pi"`). */
+    readonly harness: string;
+    /**
+     * Run one subagent invocation to completion.
+     *
+     * Always resolves with a `SubagentRunResult` — never throws for
+     * runtime/transport/model failures. Throwing is reserved for caller
+     * misuse (e.g. missing required option fields).
+     */
+    run(options: SubagentRunOptions): Promise<SubagentRunResult>;
+}
+//# sourceMappingURL=subagent-runner.d.ts.map

package/dist/shared/subagent-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-runner.d.ts","sourceRoot":"","sources":["../../src/shared/subagent-runner.ts"],"names":[],"mappings":"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"}

package/dist/shared/system-directive.d.ts

@@ -0,0 +1,3 @@
+export declare function isSystemDirective(text: string): boolean;
+export declare function removeSystemReminders(text: string): string;
+//# sourceMappingURL=system-directive.d.ts.map

package/dist/shared/system-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-directive.d.ts","sourceRoot":"","sources":["../../src/shared/system-directive.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/shared/tag-transcript.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Harness-agnostic tagging over the Transcript interface.
+ *
+ * This is a deliberately minimal alternative to the OpenCode-specific
+ * `tag-messages.ts` that operates on `MessageLike[]`. The OpenCode flow
+ * carries 380+ lines of accumulated complexity:
+ *
+ *   - source-content persistence (for cross-pass detag/restore behavior),
+ *   - tool-call indexing across separate "tool" and "tool_result" parts,
+ *   - reasoning-byte tracking for historian projection,
+ *   - file-part stable IDs,
+ *   - existing-tag resolver with content-id fallback.
+ *
+ * Most of that is OpenCode-specific (cache stability across multi-pass
+ * transforms, AI SDK part-id semantics, file part shapes). Pi's
+ * `pi.on("context", ...)` fires once per LLM call with a complete
+ * `AgentMessage[]`, so we can use a simpler tagging contract:
+ *
+ *   1. Walk the transcript in order.
+ *   2. For each tag-eligible part (text, tool_use, tool_result), assign
+ *      a tag number via the shared `Tagger`.
+ *   3. Inject `§N§ ` prefix into the visible text (unless skipped).
+ *   4. Build a `TagTarget` so `applyPendingOperations` from
+ *      `apply-operations.ts` can replace this part with a sentinel when
+ *      a queued drop fires.
+ *
+ * Tool drops aggregate by call_id across both invocation and result
+ * occurrences (mirrors OpenCode tag-messages.ts:196-220). When a drop
+ * fires for a tool tag, BOTH the assistant `toolCall`/`tool_use` part
+ * and the user `toolResult`/`tool_result` part are mutated together so
+ * the LLM sees consistent dropped state. Without this aggregation:
+ *
+ *   - Tool tag byte_size reflects only the args (~58 bytes for a `read`)
+ *     because the FIRST occurrence (invocation) is tagged first and
+ *     `assignTag` short-circuits the SECOND occurrence (result, ~4KB)
+ *     to the same tag without updating byte_size.
+ *   - Drops touch only the second occurrence (last write wins on
+ *     `targets.set`), leaving the first in original form.
+ *
+ * Reuses unchanged from the OpenCode path:
+ *
+ *   - `Tagger` (DB-backed counter + assignment store).
+ *   - `applyPendingOperations` (operates on `Map<number, TagTarget>`).
+ *   - `applyFlushedStatuses` (same).
+ *   - Tag prefix primitives (`prependTag`, `stripTagPrefix`, `byteSize`).
+ */
+import type { ContextDatabase } from "../features/magic-context/storage";
+import type { Tagger } from "../features/magic-context/tagger";
+import type { TagTarget } from "../hooks/magic-context/tag-messages";
+import type { Transcript } from "./transcript";
+export interface TagTranscriptOptions {
+    /**
+     * When true, skip injecting `§N§` prefix into visible text. Tags
+     * still get assigned in the DB so historian/drops can reference
+     * them; the agent just doesn't see the markers. Used when
+     * `ctx_reduce_enabled: false` (agent has no `ctx_reduce` tool to
+     * act on the markers). Cache-safe because skip behavior is
+     * consistent across passes.
+     */
+    skipPrefixInjection?: boolean;
+}
+export interface TagTranscriptResult {
+    targets: Map<number, TagTarget>;
+}
+export declare function tagTranscript(sessionId: string, transcript: Transcript, tagger: Tagger, db: ContextDatabase, options?: TagTranscriptOptions): TagTranscriptResult;
+//# sourceMappingURL=tag-transcript.d.ts.map

package/dist/shared/tag-transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-transcript.d.ts","sourceRoot":"","sources":["../../src/shared/tag-transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAM/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACjC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC;AAyDD,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,oBAAyB,GACnC,mBAAmB,CAqKrB"}