@cortexkit/opencode-magic-context 0.31.4 → 0.32.0

package/dist/plugin/hooks/create-session-hooks.d.ts

@@ -10,47 +10,59 @@ import type { PluginContext } from "../types";
  */
 export declare function buildMagicContextHookConfig(pluginConfig: MagicContextPluginConfig): {
     protected_tags: number;
-    cache_ttl: string | {
-        [modelKey: string]: string;
-        default: string;
-    };
-    clear_reasoning_age: number;
-    toast_duration_ms: number | undefined;
     execute_threshold_percentage: number | {
         [modelKey: string]: number;
         default: number;
     };
-    execute_threshold_tokens: {
-        [modelKey: string]: number | undefined;
+    disabled_hooks?: string[];
+    command?: Record<string, {
+        template: string;
+        description?: string;
+        agent?: string;
+        model?: string;
+        subtask?: boolean;
+    }>;
+    enabled: boolean;
+    auto_update?: boolean;
+    language?: string;
+    historian?: import("../../config/schema").HistorianConfig;
+    dreamer?: import("../../config/schema").DreamerConfig;
+    cache_ttl: string | {
+        default: string;
+        [modelKey: string]: string;
+    };
+    toast_duration_ms?: number;
+    execute_threshold_tokens?: {
         default?: number;
-    } | undefined;
-    historian: {
-        two_pass: boolean;
-        disallowed_tools: ("*" | "read" | "aft_outline" | "aft_zoom" | "aft_search")[];
-        model?: string | undefined;
-        temperature?: number | undefined;
-        top_p?: number | undefined;
-        prompt?: string | undefined;
-        tools?: Record<string, boolean> | undefined;
-        disable?: boolean | undefined;
-        description?: string | undefined;
-        mode?: "subagent" | "primary" | "all" | undefined;
-        color?: string | undefined;
-        maxSteps?: number | undefined;
-        permission?: {
-            edit?: "deny" | "allow" | "ask" | undefined;
-            bash?: "deny" | "allow" | "ask" | Record<string, "deny" | "allow" | "ask"> | undefined;
-            webfetch?: "deny" | "allow" | "ask" | undefined;
-            doom_loop?: "deny" | "allow" | "ask" | undefined;
-            external_directory?: "deny" | "allow" | "ask" | undefined;
-        } | undefined;
-        maxTokens?: number | undefined;
-        variant?: string | undefined;
-        fallback_models?: string | string[] | undefined;
-        thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-    } | undefined;
+        [modelKey: string]: number | undefined;
+    };
+    clear_reasoning_age: number;
     history_budget_percentage: number;
     historian_timeout_ms: number;
+    commit_cluster_trigger: {
+        enabled: boolean;
+        min_clusters: number;
+    };
+    sqlite: {
+        cache_size_mb: number;
+        mmap_size_mb: number;
+    };
+    system_prompt_injection: {
+        enabled: boolean;
+        skip_signatures: string[];
+    };
+    temporal_awareness: boolean;
+    keep_subagents: boolean;
+    todowrite: {
+        enabled: boolean;
+        overlay: boolean;
+    };
+    smart_drops: boolean;
+    caveman_text_compression: {
+        enabled: boolean;
+        min_chars: number;
+    };
+    embedding: import("../../config/schema").EmbeddingConfig;
     memory: {
         enabled: boolean;
         injection_budget_tokens: number;
@@ -67,149 +79,10 @@ export declare function buildMagicContextHookConfig(pluginConfig: MagicContextPl
             max_commits: number;
         };
     };
-    sidekick: {
-        timeout_ms: number;
-        model?: string | undefined;
-        temperature?: number | undefined;
-        top_p?: number | undefined;
-        prompt?: string | undefined;
-        tools?: Record<string, boolean> | undefined;
-        disable?: boolean | undefined;
-        description?: string | undefined;
-        mode?: "subagent" | "primary" | "all" | undefined;
-        color?: string | undefined;
-        maxSteps?: number | undefined;
-        permission?: {
-            edit?: "deny" | "allow" | "ask" | undefined;
-            bash?: "deny" | "allow" | "ask" | Record<string, "deny" | "allow" | "ask"> | undefined;
-            webfetch?: "deny" | "allow" | "ask" | undefined;
-            doom_loop?: "deny" | "allow" | "ask" | undefined;
-            external_directory?: "deny" | "allow" | "ask" | undefined;
-        } | undefined;
-        maxTokens?: number | undefined;
-        variant?: string | undefined;
-        fallback_models?: string | string[] | undefined;
-        system_prompt?: string | undefined;
-        thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-    } | undefined;
-    dreamer: {
-        tasks: {
-            "map-memories": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            verify: {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            "verify-broad": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            curate: {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            "classify-memories": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            retrospective: {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            "maintain-docs": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            "evaluate-smart-notes": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-            "review-user-memories": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-                promotion_threshold?: number | undefined;
-            };
-            "promote-primers": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-                promotion_threshold?: number | undefined;
-            };
-            "refresh-primers": {
-                schedule: string;
-                timeout_minutes: number;
-                model?: string | undefined;
-                fallback_models?: string | string[] | undefined;
-                thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-            };
-        };
-        inject_docs: boolean;
-        model?: string | undefined;
-        temperature?: number | undefined;
-        top_p?: number | undefined;
-        prompt?: string | undefined;
-        tools?: Record<string, boolean> | undefined;
-        disable?: boolean | undefined;
-        description?: string | undefined;
-        mode?: "subagent" | "primary" | "all" | undefined;
-        color?: string | undefined;
-        maxSteps?: number | undefined;
-        permission?: {
-            edit?: "deny" | "allow" | "ask" | undefined;
-            bash?: "deny" | "allow" | "ask" | Record<string, "deny" | "allow" | "ask"> | undefined;
-            webfetch?: "deny" | "allow" | "ask" | undefined;
-            doom_loop?: "deny" | "allow" | "ask" | undefined;
-            external_directory?: "deny" | "allow" | "ask" | undefined;
-        } | undefined;
-        maxTokens?: number | undefined;
-        variant?: string | undefined;
-        fallback_models?: string | string[] | undefined;
-        thinking_level?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
-    } | undefined;
-    commit_cluster_trigger: {
-        enabled: boolean;
-        min_clusters: number;
-    };
-    system_prompt_injection: {
+    shadow_transform: {
         enabled: boolean;
-        skip_signatures: string[];
-    };
-    temporal_awareness: boolean;
-    caveman_text_compression: {
-        enabled: boolean;
-        min_chars: number;
     };
+    sidekick?: import("../../config/schema").SidekickConfig;
 };
 export declare function createSessionHooks(args: {
     ctx: PluginContext;

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA2B+uK,CAAC;;;;;;;;;;;;qBAAxxD,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAs6qC,CAAC;;;;;;EAD3+xC"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;mBACxE,CAAC;aAA2B,CAAC;aAA2B,CAAC;eACjD,CAAC;;;;;;;;;;;;;eA8Cgja,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAjCnka;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA2B+wL,CAAC;;;;;;;;;;;;qBAAxxD,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAA+trC,CAAC;;;;;;EADp0zC"}

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

@@ -1 +1 @@
-{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-server.ts"],"names":[],"mappings":"AAqBA,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AA0CxF;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAC7D,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAsC;IAMrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;gBAE7C,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;IAqF9B,6EAA6E;IAC7E,IAAI,IAAI,IAAI;IAuBZ,OAAO,CAAC,uBAAuB;IAgB/B;+CAC2C;YAC7B,WAAW;IAyDzB;8EAC0E;IAC1E,OAAO,CAAC,eAAe;CA+F1B"}
+{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-server.ts"],"names":[],"mappings":"AAqBA,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AA0CxF;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAC7D,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAsC;IAMrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;gBAE7C,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;IA6F9B,6EAA6E;IAC7E,IAAI,IAAI,IAAI;IAuBZ,OAAO,CAAC,uBAAuB;IAgB/B;+CAC2C;YAC7B,WAAW;IAyDzB;8EAC0E;IAC1E,OAAO,CAAC,eAAe;CA+F1B"}

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

@@ -66,6 +66,24 @@ export interface TagTranscriptOptions {
      * contentId) since all parts of a message share one fingerprint.
      */
     entryFingerprintByMessageId?: ReadonlyMap<string, string>;
+    /**
+     * Stable Pi message ids observed on a prior pass. Their immutable parts may
+     * reuse tag assignments while this pass still reapplies visible prefixes and
+     * rebuilds the complete set of messages affected by each tag.
+     */
+    reuseMessageIds?: ReadonlySet<string>;
+    /** Exact text/count pairs retained by Pi for safe lazy-token backfill reuse. */
+    textTokenCache?: Map<string, {
+        text: string;
+        tokenCount: number;
+    }>;
+    /** Exact tool-result text/count pairs retained under composite tag identity. */
+    toolTokenCache?: Map<string, {
+        text: string;
+        tokenCount: number;
+    }>;
+    /** Optional process-local benchmark callback; production callers omit it. */
+    onTiming?: (phase: "identity" | "prefix" | "targets" | "tokenCounting", elapsedMs: number) => void;
 }
 export interface TagTranscriptResult {
     targets: Map<number, TagTarget>;

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

@@ -1 +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;AAQzE,OAAO,EAAwB,KAAK,MAAM,EAAE,MAAM,kCAAkC,CAAC;AASrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACjC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;OAOG;IACH,2BAA2B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC;AA8DD,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,oBAAyB,GACnC,mBAAmB,CAiPrB"}
+{"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;AAQzE,OAAO,EAAwB,KAAK,MAAM,EAAE,MAAM,kCAAkC,CAAC;AASrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACjC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;OAOG;IACH,2BAA2B,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D;;;;OAIG;IACH,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,gFAAgF;IAChF,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,gFAAgF;IAChF,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnE,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,CACP,KAAK,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,eAAe,EAC1D,SAAS,EAAE,MAAM,KAChB,IAAI,CAAC;CACb;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC;AAuED,wBAAgB,aAAa,CACzB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,eAAe,EACnB,OAAO,GAAE,oBAAyB,GACnC,mBAAmB,CA2VrB"}

package/dist/tools/ctx-expand/constants.d.ts

@@ -1,3 +1,3 @@
-export declare const CTX_EXPAND_DESCRIPTION = "Recover the original conversation from your compacted history.\n\nOlder parts of this session are summarized into <compartment> blocks inside <session-history> \u2014 e.g. <compartment start=\"120\" end=\"245\" title=\"Fixed tagger collision\">. Each one replaces the raw messages in that ordinal range with a summary. When the summary isn't enough \u2014 you need exact wording, a specific value, an error message, or the reasoning behind a decision \u2014 expand the range:\n\nctx_expand(start=120, end=245)  \u2190 the compartment's own start/end attributes\n\nReturns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results \u2014 expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail \u2014 already visible in context, not expandable.\n\nTwo recovery modes for finer detail:\n- ctx_expand(start=120, end=245, verbose=true) \u2014 lists each message SEPARATELY with its ordinal [N] and a per-part preview (each tool call shown with its output size). Use this to find the exact message or tool call you want, then recover it in full by ordinal.\n- ctx_expand(message=138) \u2014 returns the FULL untruncated content of the message at that ordinal: every text part, and every tool call's complete input + output, read from stored history. This is the cheap way to get back a tool output you dropped with ctx_reduce \u2014 the original is still in storage even though the wire shows [dropped \u00A7N\u00A7]. If the message was deleted from history (session prune/revert), it says so.";
+export declare const CTX_EXPAND_DESCRIPTION = "Recover the original conversation from your compacted history.\n\nOlder parts of this session are summarized under `## start-end \u00B7 date \u00B7 title` headings inside <session-history> \u2014 e.g. `## 120-245 \u00B7 \u2026 \u00B7 Fixed tagger collision`. Each heading replaces the raw messages in that ordinal range with a summary. When the summary isn't enough \u2014 you need exact wording, a specific value, an error message, or the reasoning behind a decision \u2014 expand the range:\n\nctx_expand(start=120, end=245)  \u2190 the heading's start/end range\n\nReturns the raw transcript as [N] U:/A: lines, capped at ~15K tokens; an oversized range returns the head and tells you where to continue. Also works with ordinals from ctx_search message results \u2014 expand a window around a hit (e.g. start=N-10, end=N+5). Ranges after the last compartment are your live tail \u2014 already visible in context, not expandable.\n\nTwo recovery modes for finer detail:\n- ctx_expand(start=120, end=245, verbose=true) \u2014 lists each message SEPARATELY with its ordinal [N] and a per-part preview (each tool call shown with its output size). Use this to find the exact message or tool call you want, then recover it in full by ordinal.\n- ctx_expand(message=138) \u2014 returns the FULL untruncated content of the message at that ordinal: every text part, and every tool call's complete input + output, read from stored history. This is the cheap way to get back a tool output you dropped with ctx_reduce \u2014 the original is still in storage even though the wire shows [dropped \u00A7N\u00A7]. If the message was deleted from history (session prune/revert), it says so.";
 export declare const CTX_EXPAND_TOKEN_BUDGET = 15000;
 //# sourceMappingURL=constants.d.ts.map

package/dist/tools/ctx-expand/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/tools/ctx-expand/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,6oDAU6X,CAAC;AAEja,eAAO,MAAM,uBAAuB,QAAS,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/tools/ctx-expand/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,ipDAU6X,CAAC;AAEja,eAAO,MAAM,uBAAuB,QAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.31.4",
+  "version": "0.32.0",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/shared/rpc-server.ts

@@ -102,6 +102,14 @@ export class MagicContextRpcServer {
 
     /** Start the server on a random port, write port to disk. */
     async start(): Promise<number> {
+        if (typeof Bun === "undefined") {
+            // The only RPC consumer is the terminal-TUI sidebar, which exists only
+            // under the Bun runtime (OpenCode CLI). On Node/Electron (Desktop) there
+            // is no consumer, and Bun.serve would throw — skip cleanly instead of
+            // logging a misleading boot error.
+            log("rpc server skipped: Bun runtime not available (no TUI consumer)");
+            return 0;
+        }
         this.startedAt = Date.now();
         const self = this;
         const server = Bun.serve<WsData>({

package/src/shared/tag-transcript.test.ts

@@ -1,8 +1,12 @@
 /// <reference types="bun-types" />
 
 import { describe, expect, it } from "bun:test";
+import { runMigrations } from "../features/magic-context/migrations";
 import type { ContextDatabase } from "../features/magic-context/storage";
-import type { Tagger } from "../features/magic-context/tagger";
+import { initializeDatabase } from "../features/magic-context/storage-db";
+import type { Tagger, ToolTagAccounting } from "../features/magic-context/tagger";
+import { createTagger } from "../features/magic-context/tagger";
+import { Database } from "./sqlite";
 import { tagTranscript } from "./tag-transcript";
 import type { Transcript, TranscriptPart, TranscriptPartKind } from "./transcript";
 
@@ -11,6 +15,7 @@ class FakeTagger implements Tagger {
     private toolTags = new Map<string, number>();
     readonly owners: string[] = [];
     readonly byteSizes = new Map<number, number>();
+    private readonly toolAccounting = new Map<number, ToolTagAccounting>();
 
     assignTag(): number {
         return this.nextTag++;
@@ -40,6 +45,23 @@ class FakeTagger implements Tagger {
         return this.toolTags.get(`${ownerMsgId}\0${callId}`);
     }
 
+    getToolTagAccounting(
+        _sessionId: string,
+        callId: string,
+        ownerMsgId: string,
+    ): ToolTagAccounting | undefined {
+        const tag = this.getToolTag(_sessionId, callId, ownerMsgId);
+        return tag === undefined ? undefined : this.toolAccounting.get(tag);
+    }
+
+    setToolTagAccounting(
+        _sessionId: string,
+        tagNumber: number,
+        accounting: ToolTagAccounting,
+    ): void {
+        this.toolAccounting.set(tagNumber, accounting);
+    }
+
     bindTag(): void {}
 
     bindToolTag(_sessionId: string, callId: string, ownerMsgId: string, tagNumber: number): void {
@@ -123,18 +145,31 @@ class NonTextToolResultPart extends TestPart {
 class FakeDb {
     readonly byteSizeUpdates: Array<{ byteSize: number; sessionId: string; tagNumber: number }> =
         [];
+    readonly tokenCountUpdates: Array<{
+        sessionId: string;
+        tagNumber: number;
+        tokenCount: number;
+    }> = [];
 
     prepare(sql: string): { run: (...args: unknown[]) => void } {
         return {
             run: (...args: unknown[]) => {
-                if (!sql.startsWith("UPDATE tags SET byte_size =")) return;
-                const [byteSize, sessionId, tagNumber] = args;
+                const [value, sessionId, tagNumber] = args;
                 if (
-                    typeof byteSize === "number" &&
-                    typeof sessionId === "string" &&
-                    typeof tagNumber === "number"
+                    typeof value !== "number" ||
+                    typeof sessionId !== "string" ||
+                    typeof tagNumber !== "number"
                 ) {
-                    this.byteSizeUpdates.push({ byteSize, sessionId, tagNumber });
+                    return;
+                }
+                if (sql.startsWith("UPDATE tags SET byte_size =")) {
+                    this.byteSizeUpdates.push({ byteSize: value, sessionId, tagNumber });
+                } else if (sql.startsWith("UPDATE tags SET token_count =")) {
+                    this.tokenCountUpdates.push({
+                        sessionId,
+                        tagNumber,
+                        tokenCount: value,
+                    });
                 }
             },
         };
@@ -271,6 +306,217 @@ describe("tagTranscript tool aggregation", () => {
         expect(result.getText()).toBe(`[dropped §${nearestTag}§]`);
     });
 
+    it("reuses owner-scoped identities without collapsing duplicate callIds", () => {
+        const tagger = new FakeTagger();
+        const seedDb = new FakeDb();
+        const seedTranscript: Transcript = {
+            harness: "pi",
+            messages: [
+                {
+                    info: { id: "assistant-old", role: "assistant" },
+                    parts: [new TestPart("tool_use", "duplicate-call", '{"turn":1}')],
+                },
+                {
+                    info: { id: "user-old", role: "user" },
+                    parts: [new TestPart("tool_result", "duplicate-call", "old result")],
+                },
+                {
+                    info: { id: "assistant-new", role: "assistant" },
+                    parts: [new TestPart("tool_use", "duplicate-call", '{"turn":2}')],
+                },
+                {
+                    info: { id: "user-new", role: "user" },
+                    parts: [new TestPart("tool_result", "duplicate-call", "new result")],
+                },
+            ],
+            commit() {},
+        };
+        tagTranscript(
+            "session-duplicate-reuse",
+            seedTranscript,
+            tagger,
+            seedDb as unknown as ContextDatabase,
+        );
+
+        const reusedParts = {
+            oldUse: new TestPart("tool_use", "duplicate-call", '{"turn":1}'),
+            oldResult: new TestPart("tool_result", "duplicate-call", "old result"),
+            newUse: new TestPart("tool_use", "duplicate-call", '{"turn":2}'),
+            newResult: new TestPart("tool_result", "duplicate-call", "new result"),
+        };
+        const reusedTranscript: Transcript = {
+            harness: "pi",
+            messages: [
+                {
+                    info: { id: "assistant-old", role: "assistant" },
+                    parts: [reusedParts.oldUse],
+                },
+                {
+                    info: { id: "user-old", role: "user" },
+                    parts: [reusedParts.oldResult],
+                },
+                {
+                    info: { id: "assistant-new", role: "assistant" },
+                    parts: [reusedParts.newUse],
+                },
+                {
+                    info: { id: "user-new", role: "user" },
+                    parts: [reusedParts.newResult],
+                },
+            ],
+            commit() {},
+        };
+        const reuseDb = new FakeDb();
+        const reused = tagTranscript(
+            "session-duplicate-reuse",
+            reusedTranscript,
+            tagger,
+            reuseDb as unknown as ContextDatabase,
+            {
+                reuseMessageIds: new Set([
+                    "assistant-old",
+                    "user-old",
+                    "assistant-new",
+                    "user-new",
+                ]),
+            },
+        );
+
+        const oldTag = tagger.getToolTag(
+            "session-duplicate-reuse",
+            "duplicate-call",
+            "assistant-old",
+        );
+        const newTag = tagger.getToolTag(
+            "session-duplicate-reuse",
+            "duplicate-call",
+            "assistant-new",
+        );
+        expect(oldTag).toBeDefined();
+        expect(newTag).toBeDefined();
+        expect(oldTag).not.toBe(newTag);
+        expect(reused.targets.size).toBe(2);
+        expect(reusedParts.oldResult.getText()).toBe(`§${oldTag}§ old result`);
+        expect(reusedParts.newResult.getText()).toBe(`§${newTag}§ new result`);
+        expect(reuseDb.byteSizeUpdates).toEqual([]);
+    });
+
+    it("backfills a newly appended result after reusing its stable invocation", () => {
+        const tagger = new FakeTagger();
+        const callId = "late-result";
+        tagTranscript(
+            "session-late-result",
+            {
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                ],
+                commit() {},
+            },
+            tagger,
+            new FakeDb() as unknown as ContextDatabase,
+        );
+
+        const result = new TestPart("tool_result", callId, "late output");
+        const db = new FakeDb();
+        tagTranscript(
+            "session-late-result",
+            {
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                    {
+                        info: { id: "user-result", role: "user" },
+                        parts: [result],
+                    },
+                ],
+                commit() {},
+            },
+            tagger,
+            db as unknown as ContextDatabase,
+            { reuseMessageIds: new Set(["assistant-owner"]) },
+        );
+
+        const tag = tagger.getToolTag("session-late-result", callId, "assistant-owner");
+        expect(result.getText()).toBe(`§${tag}§ late output`);
+        expect(db.byteSizeUpdates.some((update) => update.tagNumber === tag)).toBe(true);
+    });
+
+    it("persists the same grown folded-result accounting with reuse or full derivation", () => {
+        interface AccountingRow {
+            tagNumber: number;
+            byteSize: number;
+            tokenCount: number;
+        }
+
+        const runScenario = (reuse: boolean): { before: AccountingRow; after: AccountingRow } => {
+            const db = new Database(":memory:");
+            initializeDatabase(db);
+            runMigrations(db);
+            const sessionId = reuse ? "session-grown-reuse" : "session-grown-derive";
+            const tagger = createTagger();
+            tagger.initFromDb(sessionId, db);
+            const callId = "folded-growth";
+            const makeTranscript = (resultText: string): Transcript => ({
+                harness: "pi",
+                messages: [
+                    {
+                        info: { id: "assistant-owner", role: "assistant" },
+                        parts: [new TestPart("tool_use", callId, '{"path":"a"}')],
+                    },
+                    {
+                        // Pi folds the tool result into this following user entry, so
+                        // reuse is decided from the user's stable id.
+                        info: { id: "user-fold-target", role: "user" },
+                        parts: [new TestPart("tool_result", callId, resultText)],
+                    },
+                ],
+                commit() {},
+            });
+            const readAccounting = (): AccountingRow => {
+                const row = db
+                    .prepare(
+                        "SELECT tag_number AS tagNumber, byte_size AS byteSize, token_count AS tokenCount FROM tags WHERE session_id = ? AND type = 'tool'",
+                    )
+                    .get(sessionId) as AccountingRow | null;
+                if (!row) throw new Error("missing tool accounting row");
+                return row;
+            };
+
+            tagTranscript(sessionId, makeTranscript("small result"), tagger, db);
+            const before = readAccounting();
+            const nextPassTagger = createTagger();
+            nextPassTagger.initFromDb(sessionId, db);
+            tagTranscript(
+                sessionId,
+                makeTranscript("larger result ".repeat(80)),
+                nextPassTagger,
+                db,
+                {
+                    reuseMessageIds: reuse
+                        ? new Set(["assistant-owner", "user-fold-target"])
+                        : undefined,
+                },
+            );
+            const after = readAccounting();
+            db.close();
+            return { before, after };
+        };
+
+        const reused = runScenario(true);
+        const derived = runScenario(false);
+        expect(reused.after.tagNumber).toBe(reused.before.tagNumber);
+        expect(reused.after.byteSize).toBeGreaterThan(reused.before.byteSize);
+        expect(reused.after.tokenCount).toBeGreaterThan(reused.before.tokenCount);
+        expect(reused.after).toEqual(derived.after);
+    });
+
     it("accounts non-text tool_result content when ranking tool output byte size", () => {
         const tagger = new FakeTagger();
         const db = new FakeDb();