@cortexkit/opencode-magic-context 0.41.3 → 0.42.0

package/src/config/removed-agent-source-fence.test.ts

@@ -0,0 +1,56 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+const RETIRED_AGENT_NAME = ["side", "kick"].join("");
+const RETIRED_AGENT_PATTERN = new RegExp(RETIRED_AGENT_NAME, "gi");
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..");
+const WARNING_SOURCE = join(
+    REPO_ROOT,
+    "packages",
+    "plugin",
+    "src",
+    "config",
+    "removed-agent-config.ts",
+);
+const SOURCE_ROOTS = [
+    join(REPO_ROOT, "packages", "plugin", "src"),
+    join(REPO_ROOT, "packages", "pi-plugin", "src"),
+    join(REPO_ROOT, "packages", "cli", "src"),
+    join(REPO_ROOT, "packages", "dashboard", "src"),
+    join(REPO_ROOT, "packages", "dashboard", "src-tauri", "src"),
+];
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".rs", ".json"]);
+
+function sourceFiles(directory: string, files: string[] = []): string[] {
+    for (const entry of readdirSync(directory)) {
+        if (entry === "node_modules" || entry === "dist") continue;
+        const path = join(directory, entry);
+        const stat = statSync(path);
+        if (stat.isDirectory()) {
+            sourceFiles(path, files);
+            continue;
+        }
+        const extension = entry.slice(entry.lastIndexOf("."));
+        if (stat.isFile() && SOURCE_EXTENSIONS.has(extension)) files.push(path);
+    }
+    return files;
+}
+
+describe("retired agent source fence", () => {
+    it("keeps only the removed-config warning key literal", () => {
+        const offenses: string[] = [];
+        for (const file of SOURCE_ROOTS.flatMap((root) => sourceFiles(root))) {
+            const matches = readFileSync(file, "utf8").match(RETIRED_AGENT_PATTERN) ?? [];
+            const allowed = file === WARNING_SOURCE && matches.length === 1;
+            if (!allowed && matches.length > 0) {
+                offenses.push(`${relative(REPO_ROOT, file)} (${matches.length})`);
+            }
+        }
+
+        expect(offenses).toEqual([]);
+        expect(readFileSync(WARNING_SOURCE, "utf8").match(RETIRED_AGENT_PATTERN)).toHaveLength(1);
+    });
+});

package/src/config/schema/magic-context.test.ts

@@ -23,7 +23,6 @@ describe("MagicContextConfigSchema", () => {
                 cache_ttl: "5m",
                 prompt_surface: { default: "full" },
                 execute_threshold_percentage: 65,
-                protected_tags: 20,
                 clear_reasoning_age: 50,
                 history_budget_percentage: DEFAULT_HISTORY_BUDGET_PERCENTAGE,
                 historian_timeout_ms: DEFAULT_HISTORIAN_TIMEOUT_MS,
@@ -46,7 +45,6 @@ describe("MagicContextConfigSchema", () => {
             expect(result.historian_timeout_ms).toBeGreaterThanOrEqual(10 * 60_000);
             expect(result.historian).toBeUndefined();
             expect(result.dreamer).toBeUndefined();
-            expect(result.sidekick).toBeUndefined();
             expect(result.pi).toBeUndefined();
             expect(result.mural).toEqual({ enabled: false });
         });
@@ -107,6 +105,7 @@ describe("MagicContextConfigSchema", () => {
                 },
                 temporal_awareness: false,
                 keep_subagents: false,
+                debug_rpc: false,
                 todowrite: {
                     enabled: false,
                     overlay: false,
@@ -145,15 +144,6 @@ describe("MagicContextConfigSchema", () => {
                 pi: {
                     subagent_extensions: ["@example/provider", "./extensions/local.ts"],
                 },
-                sidekick: {
-                    disable: false,
-                    model: "qwen-test",
-                    fallback_models: ["qwen-fallback"],
-                    temperature: 0.1,
-                    variant: "fast",
-                    timeout_ms: 12_000,
-                    system_prompt: "Custom prompt",
-                },
                 compaction: {
                     enabled: true,
                 },
@@ -177,19 +167,6 @@ describe("MagicContextConfigSchema", () => {
             ).toBe(false);
         });
 
-        it("applies sidekick defaults when the object is present", () => {
-            const result = MagicContextConfigSchema.parse({
-                sidekick: {
-                    model: "github-copilot/gpt-5.4",
-                },
-            });
-
-            expect(result.sidekick).toEqual({
-                model: "github-copilot/gpt-5.4",
-                timeout_ms: 30000,
-            });
-        });
-
         it("accepts disable on hidden agents and strips deprecated top-level enabled", () => {
             const result = MagicContextConfigSchema.parse({
                 historian: { disable: true },
@@ -203,14 +180,11 @@ describe("MagicContextConfigSchema", () => {
                         "maintain-docs": { schedule: "0 * * * *" },
                     },
                 },
-                sidekick: { disable: true, enabled: true },
             });
 
             expect(result.historian?.disable).toBe(true);
             expect(result.dreamer?.disable).toBe(true);
-            expect(result.sidekick?.disable).toBe(true);
             expect("enabled" in (result.dreamer as Record<string, unknown>)).toBe(false);
-            expect("enabled" in (result.sidekick as Record<string, unknown>)).toBe(false);
             expect(result.dreamer?.tasks["review-user-memories"].schedule).toBe("");
             expect(result.dreamer?.tasks["maintain-docs"].schedule).toBe("0 * * * *");
             expect(result.dreamer?.tasks["classify-memories"].schedule).toBe("0 6 * * *");
@@ -353,10 +327,6 @@ describe("MagicContextConfigSchema", () => {
                                 thinking_level: "inherit",
                             },
                         },
-                        sidekick: {
-                            model: "anthropic/work-sidekick",
-                            fallback_models: ["openai/work-sidekick-fallback"],
-                        },
                     },
                 },
             });
@@ -376,7 +346,6 @@ describe("MagicContextConfigSchema", () => {
                 { model: "opencode/work-historian-fallback", thinking_level: "inherit" },
             ]);
             expect(result.profiles?.work?.dreamer?.omp?.thinking_level).toBe("inherit");
-            expect(result.profiles?.work?.sidekick?.model).toBe("anthropic/work-sidekick");
         });
 
         it("rejects timeout_minutes in a dreamer profile", () => {
@@ -432,7 +401,7 @@ describe("MagicContextConfigSchema", () => {
                     },
                 },
                 { work: { dreamer: { tasks: { verify: { schedule: "0 3 * * *" } } } } },
-                { work: { sidekick: { timeout_ms: 60_000 } } },
+                { work: { dreamer: { timeout_ms: 60_000 } } },
             ];
 
             for (const profiles of profilesWithExcludedFields) {
@@ -667,17 +636,27 @@ describe("MagicContextConfigSchema", () => {
             ).toThrow();
         });
 
-        it("rejects protected_tags greater than 100", () => {
-            expect(() => MagicContextConfigSchema.parse({ protected_tags: 101 })).toThrow();
-        });
-
-        it("rejects protected_tags less than 1", () => {
-            expect(() => MagicContextConfigSchema.parse({ protected_tags: 0 })).toThrow();
+        it("accepts protected_tags at any value including 0 and 101 as deprecated inert key", () => {
+            expect(MagicContextConfigSchema.parse({ protected_tags: 101 }).protected_tags).toBe(
+                101,
+            );
+            expect(MagicContextConfigSchema.parse({ protected_tags: 0 }).protected_tags).toBe(0);
+            expect(MagicContextConfigSchema.parse({ protected_tags: 20 }).protected_tags).toBe(20);
         });
 
-        it("accepts protected_tags boundary values", () => {
-            expect(MagicContextConfigSchema.parse({ protected_tags: 1 }).protected_tags).toBe(1);
-            expect(MagicContextConfigSchema.parse({ protected_tags: 20 }).protected_tags).toBe(20);
+        it("enforces protected_tokens override range at both ends", () => {
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 3999 })).toThrow();
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 1_000_001 })).toThrow();
+            expect(() => MagicContextConfigSchema.parse({ protected_tokens: 30000.5 })).toThrow();
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 4000 }).protected_tokens,
+            ).toBe(4000);
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 1_000_000 }).protected_tokens,
+            ).toBe(1_000_000);
+            expect(
+                MagicContextConfigSchema.parse({ protected_tokens: 30000 }).protected_tokens,
+            ).toBe(30000);
         });
 
         it("rejects clear_reasoning_age below minimum", () => {

package/src/config/schema/magic-context.ts

@@ -1,7 +1,6 @@
 import { homedir } from "node:os";
 import { z } from "zod";
 import { isValidLanguageCode } from "../../agents/language-directive";
-import { DEFAULT_PROTECTED_TAGS } from "../../features/magic-context/defaults";
 import { isValidCron } from "../../features/magic-context/dreamer/cron";
 import type {
     AGENTIC_DREAM_TASKS,
@@ -446,27 +445,15 @@ const ProfileDreamerSchema = z
         omp: ProfileOmpModelBlockSchema.optional(),
     })
     .strict();
-const ProfileSidekickSchema = AgentOverrideConfigSchema.pick({
-    model: true,
-    fallback_models: true,
-    variant: true,
-})
-    .extend({
-        thinking_level: PiThinkingLevelSchema.describe(
-            "Pi thinking level for the sidekick model selection.",
-        ),
-    })
-    .strict();
 
 export const ConfigProfileSchema = z
     .object({
         historian: ProfileHistorianSchema.optional(),
         dreamer: ProfileDreamerSchema.optional(),
-        sidekick: ProfileSidekickSchema.optional(),
     })
     .strict()
     .describe(
-        "User-owned model-selection overlay. Only historian/dreamer harness model blocks and sidekick model-selection fields are allowed.",
+        "User-owned model-selection overlay. Only historian/dreamer harness model blocks are allowed.",
     );
 export type ConfigProfile = z.infer<typeof ConfigProfileSchema>;
 
@@ -626,15 +613,6 @@ export const DreamerConfigSchema = AgentMetadataSchema.extend({
 });
 export type DreamerConfig = z.infer<typeof DreamerConfigSchema>;
 
-export const SidekickConfigSchema = AgentOverrideConfigSchema.extend({
-    timeout_ms: z.number().default(30000).describe("Timeout for sidekick calls in milliseconds"),
-    system_prompt: z.string().optional().describe("Custom system prompt for sidekick"),
-    thinking_level: PiThinkingLevelSchema.describe(
-        "Pi only: explicit thinking level for sidekick subagent invocations. See historian.pi.thinking_level.",
-    ),
-}).optional();
-export type SidekickConfig = NonNullable<z.infer<typeof SidekickConfigSchema>>;
-
 /**
  * Historian metadata remains harness-independent. Only model resolution moves to
  * the strict opencode, pi, and omp blocks; two_pass and disallowed_tools stay here.
@@ -871,7 +849,8 @@ export interface MagicContextConfig {
      *  this overrides `execute_threshold_percentage` for that model. Useful for hard caps
      *  matching provider input limits. Values above 90% × context_limit are clamped with a warning. */
     execute_threshold_tokens?: { default?: number; [modelKey: string]: number | undefined };
-    protected_tags: number;
+    protected_tokens?: number;
+    protected_tags?: number;
     clear_reasoning_age: number;
     history_budget_percentage: number;
     historian_timeout_ms: number;
@@ -917,10 +896,12 @@ export interface MagicContextConfig {
      *  Graduated from `experimental.temporal_awareness`; default: true. */
     temporal_awareness: boolean;
     /** Debug: when true, keep the child sessions Magic Context spawns for its
-     *  own subagents (historian, dreamer, sidekick, memory-migration) instead
+     *  own subagents (historian, dreamer, memory-migration) instead
      *  of deleting them on success. For short-term inspection/data collection;
      *  kept sessions accumulate until manually cleared. Default false. */
     keep_subagents: boolean;
+    /** Enable loopback-only diagnostic RPCs that expose memory usage and heap snapshots. */
+    debug_rpc?: boolean;
     /**
      * When true (default), deterministic inoperability (schema fence, storage
      * open/migration failure) blocks the primary-session transform with a loud
@@ -1011,7 +992,6 @@ export interface MagicContextConfig {
             max_commits: number;
         };
     };
-    sidekick?: SidekickConfig;
 }
 
 export const MagicContextConfigSchema = z
@@ -1063,7 +1043,7 @@ export const MagicContextConfigSchema = z
             .describe(
                 "Output language for Magic Context's generated content and guidance, as a " +
                     '2-letter ISO 639-1 code (e.g. "tr", "es", "de", "ja", "pt"). When set, the ' +
-                    "historian, dreamer, sidekick, and the agent-guidance block instruct the model to " +
+                    "historian, dreamer, and the agent-guidance block instruct the model to " +
                     "write its PROSE in this language while keeping all structural tokens (XML tags, " +
                     "the five memory category names, code identifiers, file paths) in English. " +
                     "USER-LEVEL ONLY (ignored in project config for security). Unset = today's " +
@@ -1080,7 +1060,7 @@ export const MagicContextConfigSchema = z
                 "Select a named user-owned model profile. A valid project name overrides this user default; an empty string, null, or other non-string project value is ignored with a warning so the user selection still applies. Unknown names warn and use the base configuration.",
             ),
         profiles: ConfigProfilesSchema.optional().describe(
-            "User-level named model profiles. A profile may contain only historian/dreamer model, fallback_models, OpenCode variant, and Pi/OMP thinking_level fields plus sidekick model-selection fields; task execution policy (including timeout_minutes) is excluded. Project configs may select a name but cannot define profiles.",
+            "User-level named model profiles. A profile may contain only historian/dreamer model, fallback_models, OpenCode variant, and Pi/OMP thinking_level fields; task execution policy (including timeout_minutes) is excluded. Project configs may select a name but cannot define profiles.",
         ),
         historian: HistorianConfigSchema.describe(
             "Historian metadata plus independent strict OpenCode, Pi, and OMP execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode, historian.pi, or historian.omp.",
@@ -1153,14 +1133,22 @@ export const MagicContextConfigSchema = z
             .describe(
                 "Absolute token thresholds per model. When matched, overrides execute_threshold_percentage for that model. Accepts `default` for all models or per-model keys. Values above 90% × context_limit are clamped with a warning log. Min 5_000, max 2_000_000.",
             ),
-        protected_tags: z
+        protected_tokens: z
             .number()
-            .min(1)
-            .max(100)
+            .int()
+            .min(4000)
+            .max(1_000_000)
             .optional()
             .describe(
-                "Number of recent tags to protect from dropping (min: 1, max: 100, default: 20)",
+                "Positive integer token floor to protect from automatic reclaim (min: 4_000, max: 1_000_000). When omitted, the derived default is clamp(round(0.05 × usableSoft), min(16_000, round(0.08 × usableSoft)), 64_000).",
             ),
+        protected_tags: z
+            .unknown()
+            .optional()
+            .describe(
+                "Deprecated: number of recent tags to protect. Ignored for behaviour; use protected_tokens instead.",
+            )
+            .meta({ deprecated: true }),
         clear_reasoning_age: z
             .number()
             .min(10)
@@ -1294,7 +1282,13 @@ export const MagicContextConfigSchema = z
             .boolean()
             .default(false)
             .describe(
-                "Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect.",
+                "Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect.",
+            ),
+        debug_rpc: z
+            .boolean()
+            .default(false)
+            .describe(
+                "Developer-only: enable authenticated loopback RPCs for memory counters and heap snapshots. Disabled by default. USER-LEVEL ONLY and requires a restart.",
             ),
         fail_closed_blocking: z
             .boolean()
@@ -1459,13 +1453,28 @@ export const MagicContextConfigSchema = z
                 git_commit_indexing: { enabled: false, since_days: 365, max_commits: 2000 },
             })
             .describe("Cross-session memory configuration"),
-        sidekick: SidekickConfigSchema.describe(
-            "Optional sidekick agent configuration for session-start memory retrieval",
-        ),
     })
     .transform((data): MagicContextConfig => {
         return {
             ...data,
-            protected_tags: data.protected_tags ?? DEFAULT_PROTECTED_TAGS,
+            protected_tags: data.protected_tags as number | undefined,
         };
     });
+
+/**
+ * Derived default protected_tokens formula:
+ * clamp(round(0.05 × usableSoft), min(16000, round(0.08 × usableSoft)), 64000)
+ *
+ * Sizing table:
+ *   100k -> 8,000
+ *   200k -> 16,000
+ *   372k -> 18,600
+ *   872k -> 43,600
+ *   1M   -> 50,000
+ */
+export function deriveDefaultProtectedTokens(usableSoft: number): number {
+    const clampedUsable = Math.max(0, usableSoft);
+    const lowerBound = Math.min(16_000, Math.round(0.08 * clampedUsable));
+    const target = Math.round(0.05 * clampedUsable);
+    return Math.min(64_000, Math.max(lowerBound, target));
+}

package/src/shared/cache-ttl-display.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "bun:test";
+
+import { initializeDatabase } from "../features/magic-context/storage-db";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { resolveCacheTtlDisplay } from "./cache-ttl-display";
+import { seedSessionCacheTtlIfUnsynced } from "./cache-ttl-seed";
+import { Database } from "./sqlite";
+
+const modelKey = "anthropic/claude-opus-5";
+
+describe("resolveCacheTtlDisplay", () => {
+    it("shows config before the first message_end sync", () => {
+        expect(
+            resolveCacheTtlDisplay({
+                configured: { default: "5m", [modelKey]: "1h" },
+                configuredExplicitly: true,
+                modelKey,
+                sessionValue: "5m",
+                sessionModelKey: null,
+            }),
+        ).toEqual({ value: "1h", source: "config", modelKey });
+    });
+
+    it("discriminates config, session, and guessed default provenance", () => {
+        const configured = resolveCacheTtlDisplay({
+            configured: "1h",
+            configuredExplicitly: true,
+            modelKey,
+            sessionValue: "5m",
+            sessionModelKey: null,
+        });
+        const session = resolveCacheTtlDisplay({
+            configured: "1h",
+            configuredExplicitly: true,
+            modelKey,
+            sessionValue: "45m",
+            sessionModelKey: modelKey,
+        });
+        const fallback = resolveCacheTtlDisplay({
+            configured: "5m",
+            configuredExplicitly: false,
+            modelKey,
+            sessionValue: "5m",
+            sessionModelKey: null,
+        });
+
+        expect(configured.source).toBe("config");
+        expect(session).toEqual({ value: "45m", source: "session", modelKey });
+        expect(fallback).toEqual({ value: "5m", source: "default", modelKey });
+    });
+
+    it("seeds only an unsynced row and leaves a scheduler-owned row unchanged", () => {
+        const db = new Database(":memory:");
+        initializeDatabase(db);
+        try {
+            expect(
+                seedSessionCacheTtlIfUnsynced({
+                    db,
+                    sessionId: "ses-seed",
+                    configured: { default: "5m", [modelKey]: "1h" },
+                    modelKey,
+                }),
+            ).toBe(true);
+            expect(getOrCreateSessionMeta(db, "ses-seed").cacheTtl).toBe("1h");
+
+            updateSessionMeta(db, "ses-seed", {
+                cacheTtl: "45m",
+                lastObservedModelKey: modelKey,
+                lastResponseTime: 1,
+            });
+            expect(
+                seedSessionCacheTtlIfUnsynced({
+                    db,
+                    sessionId: "ses-seed",
+                    configured: "2h",
+                    modelKey,
+                }),
+            ).toBe(false);
+            expect(getOrCreateSessionMeta(db, "ses-seed").cacheTtl).toBe("45m");
+        } finally {
+            db.close();
+        }
+    });
+});

package/src/shared/cache-ttl-display.ts

@@ -0,0 +1,64 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { resolveModelConfigValue } from "./prompt-surface";
+
+export type CacheTtlDisplaySource = "config" | "session" | "default";
+
+export interface CacheTtlDisplay {
+    value: string;
+    source: CacheTtlDisplaySource;
+    modelKey: string | undefined;
+}
+
+export interface ResolveCacheTtlDisplayArgs {
+    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 function resolveCacheTtlDisplay(args: ResolveCacheTtlDisplayArgs): CacheTtlDisplay {
+    if (
+        (args.sessionModelKey && (!args.modelKey || args.sessionModelKey === args.modelKey)) ||
+        (!args.modelKey && !args.sessionModelKey && args.sessionValue !== "5m")
+    ) {
+        return {
+            value: args.sessionValue || "5m",
+            source: "session",
+            modelKey: args.modelKey ?? args.sessionModelKey ?? undefined,
+        };
+    }
+
+    if (typeof args.configured === "string") {
+        return {
+            value: args.configured,
+            source: args.configuredExplicitly ? "config" : "default",
+            modelKey: args.modelKey,
+        };
+    }
+
+    const matched = resolveModelConfigValue(args.configured, args.modelKey);
+    if (matched) {
+        return { value: matched.value, source: "config", modelKey: args.modelKey };
+    }
+
+    return {
+        value: args.configured.default ?? "5m",
+        source: "default",
+        modelKey: args.modelKey,
+    };
+}
+
+export function formatCacheTtlDisplay(display: CacheTtlDisplay): string {
+    if (display.source === "session") return `Cache TTL: ${display.value} (session)`;
+    if (display.source === "config") {
+        return `Cache TTL: ${display.value} (config for ${display.modelKey ?? "current model"})`;
+    }
+    return `Cache TTL: ${display.value} (default — no cache_ttl for ${display.modelKey ?? "unknown model"})`;
+}

package/src/shared/cache-ttl-seed.ts

@@ -0,0 +1,23 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { resolveModelConfigValue } from "./prompt-surface";
+import type { Database } from "./sqlite";
+
+/** Seed only before a completed assistant response has made the session row authoritative. */
+export function seedSessionCacheTtlIfUnsynced(args: {
+    db: Database;
+    sessionId: string;
+    configured: MagicContextConfig["cache_ttl"];
+    modelKey: string;
+}): boolean {
+    const meta = getOrCreateSessionMeta(args.db, args.sessionId);
+    if (meta.lastResponseTime !== 0 || meta.lastObservedModelKey !== null) return false;
+    const cacheTtl =
+        typeof args.configured === "string"
+            ? args.configured
+            : (resolveModelConfigValue(args.configured, args.modelKey)?.value ??
+              args.configured.default ??
+              "5m");
+    updateSessionMeta(args.db, args.sessionId, { cacheTtl });
+    return true;
+}