@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/src/config/raw-loader.ts

@@ -4,6 +4,7 @@ import {
     linkSync,
     openSync,
     readFileSync,
+    realpathSync,
     renameSync,
     statSync,
     unlinkSync,
@@ -434,9 +435,13 @@ export function loadRawConfigFile(options: RawConfigLoadOptions): RawConfigLoadR
 
         let temporaryPath: string | undefined;
         try {
-            const mode = statSync(options.configPath).mode & 0o777;
+            // Write through a symlinked config (stow, chezmoi, home-manager keep
+            // it in a dotfiles repo): the temporary file is created next to the
+            // real file and renamed onto it, so the link itself stays a link.
+            const writePath = realpathSync(options.configPath);
+            const mode = statSync(writePath).mode & 0o777;
             writeExclusiveBackup(backupPath, observedBytes, mode);
-            temporaryPath = writeTemporaryCandidate(options.configPath, migration.bytes, mode);
+            temporaryPath = writeTemporaryCandidate(writePath, migration.bytes, mode);
             options.afterTemporaryWrite?.();
 
             const currentBytes = readFileSync(options.configPath);
@@ -456,7 +461,7 @@ export function loadRawConfigFile(options: RawConfigLoadOptions): RawConfigLoadR
                 continue;
             }
 
-            renameSync(temporaryPath, options.configPath);
+            renameSync(temporaryPath, writePath);
             return {
                 configPath: options.configPath,
                 bytes: migration.bytes,

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

@@ -6,6 +6,7 @@ import type {
     AGENTIC_DREAM_TASKS,
     DreamTaskName,
 } from "../../features/magic-context/dreamer/task-registry";
+import { toolTemplateError } from "../../shared/historian-tool-template";
 import { isValidPromptSurfaceModelKey } from "../../shared/prompt-surface";
 import { AgentOverrideConfigSchema } from "./agent-overrides";
 
@@ -490,7 +491,7 @@ const DreamTaskBaseConfigSchema = z
             .positive()
             .optional()
             .describe(
-                "Maximum cumulative prompt tokens (input + cache read + cache write) for one tool-loop child. Defaults vary by task.",
+                "Cumulative prompt-token investigation budget (input + cache read + cache write) for one tool-loop child. Defaults: 2,500,000 for map-memories and verify; 3,000,000 for verify-broad; other tool-loop tasks vary. Completed answers are retained even if their usage crosses the budget.",
             ),
     })
     .strict();
@@ -663,6 +664,21 @@ export type DreamerConfig = z.infer<typeof DreamerConfigSchema>;
  * the strict opencode, pi, and omp blocks; two_pass and disallowed_tools stay here.
  */
 export const HistorianConfigSchema = AgentMetadataSchema.extend({
+    expand_tools: z
+        .record(
+            z.string(),
+            z.union([
+                z.string().superRefine((value, ctx) => {
+                    const error = toolTemplateError(value);
+                    if (error) ctx.addIssue({ code: "custom", message: error });
+                }),
+                z.literal(false),
+            ]),
+        )
+        .optional()
+        .describe(
+            'Readable historian tool expansions, keyed by exact host tool name. Templates override built-in defaults; false disables an expansion. Supports ${input.path}, ${output.path}, bare ${output}, array [N], [*].field, .each("${field}"), .join("separator"), .count and final .truncate(N). Missing fields are empty; placeholders default to 300 characters, lists to 10 elements, expansions to 1000 characters. Valid in user and project config; affects historian/recomp and verbose ctx_expand only, never the wire or default ctx_expand transcript.',
+        ),
     opencode: OpenCodeHarnessBlockSchema.optional(),
     pi: PiHarnessBlockSchema.optional(),
     omp: OmpHarnessBlockSchema.optional(),
@@ -695,7 +711,7 @@ export const HistorianConfigSchema = AgentMetadataSchema.extend({
         .array(z.enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"]))
         .default([])
         .describe(
-            'OpenCode only. Tools to REMOVE from the historian\'s default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])',
+            "Legacy compatibility setting. Historians, recomp and editor passes always run with zero tools and locked permissions; this list no longer changes their tool surface. (default: [])",
         ),
 }).optional();
 export type HistorianConfig = NonNullable<z.infer<typeof HistorianConfigSchema>>;
@@ -771,7 +787,7 @@ const BaseEmbeddingConfigSchema = z
             .enum(["auto", "native", "wasm"])
             .default("auto")
             .describe(
-                "Local provider only: ONNX runtime selection. 'auto' uses native under Node and uses WASM under Bun versions before 1.4.0, where Bun's NAPI teardown race can panic on quit; native is restored automatically on Bun 1.4.0+. Set 'native' only to prefer speed while accepting that pre-1.4.0 Bun crash risk, or 'wasm' to avoid loading the native addon.",
+                "Local provider only: ONNX runtime selection. 'auto' uses native under Node and uses WASM under Bun versions before 1.4.0, where Bun's NAPI teardown race can panic on quit; native is restored automatically on Bun 1.4.0+. Inference runs in a dedicated worker. On Bun before 1.4.0, even explicit 'native' uses WASM because native worker teardown can crash the process. Set 'wasm' to avoid loading the native addon on newer hosts too.",
             ),
         local_dtype: z
             .enum([
@@ -1567,6 +1583,7 @@ export const LIVE_RELOAD_CONFIG_PATHS = [
     "historian.omp.fallback_models",
     "historian.omp.thinking_level",
     "historian.two_pass",
+    "historian.expand_tools",
     "historian.maxTokens",
     "historian_timeout_ms",
     "commit_cluster_trigger.enabled",

package/src/config/variable.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, sep } from "node:path";
+import { createTestTempDirFromPath } from "../shared/test-temp-dir";
 
 import { substituteConfigVariables } from "./variable";
 
@@ -10,7 +11,7 @@ describe("substituteConfigVariables", () => {
     let tmpDir: string;
 
     beforeEach(() => {
-        tmpDir = mkdtempSync(join(tmpdir(), "mc-variable-test-"));
+        tmpDir = createTestTempDirFromPath(join(tmpdir(), "mc-variable-test-"));
     });
 
     afterEach(() => {

package/src/features/magic-context/dreamer/cron.ts

@@ -13,9 +13,10 @@
  * NAMES are intentionally unsupported (smaller surface; add later if asked).
  * Empty string `""` means "never" and is handled by the caller, not here.
  *
- * Day matching uses Vixie OR-semantics: when BOTH dom and dow are restricted
- * (not `*`), a day matches if EITHER matches; when only one is restricted, only
- * that one is consulted; when neither is restricted, every day matches.
+ * Day matching follows Vixie cron: a dom or dow field that starts with `*`
+ * (`*` itself or a star-step such as `*\/2`) counts as unrestricted. When BOTH
+ * fields are restricted a day matches if EITHER matches; otherwise a day must
+ * match both sets, which for a plain `*` field means only the other one counts.
  *
  * Timezone: all matching is in the machine's LOCAL time — the dreamer's whole
  * purpose is "run while the user is asleep", which is a wall-clock concept.
@@ -30,7 +31,7 @@ export interface ParsedCron {
     dom: Set<number>;
     month: Set<number>;
     dow: Set<number>;
-    /** Original field token was not `*` — drives Vixie dom/dow OR-semantics. */
+    /** Field token does not start with `*` — drives Vixie dom/dow OR-semantics. */
     domRestricted: boolean;
     dowRestricted: boolean;
 }
@@ -145,8 +146,10 @@ export function parseCron(expression: string): ParseCronResult {
             dom: sets[2],
             month: sets[3],
             dow: sets[4],
-            domRestricted: tokens[2] !== "*",
-            dowRestricted: tokens[4] !== "*",
+            // Vixie cron treats any star-prefixed field (`*`, `*/2`) as
+            // unrestricted when choosing between OR and AND day matching.
+            domRestricted: !tokens[2].startsWith("*"),
+            dowRestricted: !tokens[4].startsWith("*"),
         },
     };
 }
@@ -160,9 +163,26 @@ function matchesDay(cron: ParsedCron, date: Date): boolean {
     const dom = cron.dom.has(date.getDate());
     const dow = cron.dow.has(date.getDay());
     if (cron.domRestricted && cron.dowRestricted) return dom || dow;
-    if (cron.domRestricted) return dom;
-    if (cron.dowRestricted) return dow;
-    return true;
+    return dom && dow;
+}
+
+/** Longest each month can be, counting Feb 29. */
+const MAX_DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+/**
+ * False when the day-of-month set fits in none of the cron's months (e.g.
+ * `0 0 31 2 *`, Feb 31), so the schedule can never fire. Lets nextOccurrence
+ * answer "never" at once instead of scanning ~2 million minutes on every
+ * evaluation. A restricted weekday under OR-matching always fires eventually.
+ */
+function dayOfMonthCanOccur(cron: ParsedCron): boolean {
+    if (cron.domRestricted && cron.dowRestricted) return true;
+    for (const month of cron.month) {
+        for (const day of cron.dom) {
+            if (day <= MAX_DAYS_IN_MONTH[month - 1]) return true;
+        }
+    }
+    return false;
 }
 
 /** True if `date`'s local civil fields match the cron. */
@@ -199,6 +219,7 @@ export function nextOccurrence(
     excludeCivilMinute?: string,
     maxSearchMs = MAX_SEARCH_MS,
 ): Date | null {
+    if (!dayOfMonthCanOccur(cron)) return null;
     const afterMs = after.getTime();
     // Align to the next whole minute strictly after `after` (never returns `after`).
     let cursorMs = Math.floor(afterMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;

package/src/features/magic-context/dreamer/task-registry.ts

@@ -30,12 +30,14 @@ export const CANONICAL_DREAM_TASKS = [
 export type DreamTaskName = (typeof CANONICAL_DREAM_TASKS)[number];
 
 /** Prompt-token ceilings informed by docs/reports/dreamer-token-usage.md.
- * Multi-memory batches need more room than a single primer investigation;
- * curate's 150-step tool loop warrants a larger allowance too. */
+ * Completed Gemini run usage predicts 20-memory mapping/verification batches
+ * at about 70% of their allowance
+ * (docs/reports/verify-token-budget-2026-09-30.md); curate and other tasks retain
+ * their separate allowances. */
 export const DREAM_TOOL_LOOP_TOKEN_BUDGETS = {
-    "map-memories": 1_500_000,
-    verify: 1_700_000,
-    "verify-broad": 1_700_000,
+    "map-memories": 2_500_000,
+    verify: 2_500_000,
+    "verify-broad": 3_000_000,
     curate: 1_500_000,
     retrospective: 300_000,
     "maintain-docs": 1_600_000,

package/src/shared/announcement.test.ts

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 /**
  * `announcement.ts` reads/writes a single `last_announced_version` file under
@@ -23,7 +24,7 @@ let tmpRoot = "";
 let originalXdg: string | undefined;
 
 beforeEach(() => {
-    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "mc-announcement-test-"));
+    tmpRoot = createTestTempDirFromPath(path.join(os.tmpdir(), "mc-announcement-test-"));
     originalXdg = process.env.XDG_DATA_HOME;
     process.env.XDG_DATA_HOME = tmpRoot;
 });

package/src/shared/assistant-message-extractor.test.ts

@@ -1,5 +1,31 @@
 import { describe, expect, test } from "bun:test";
-import { hasLengthCappedOutput } from "./assistant-message-extractor";
+import {
+    describeAssistantSettlement,
+    extractLatestAssistantText,
+    hasLengthCappedOutput,
+} from "./assistant-message-extractor";
+
+test("reasoning-only and tool-only turns stay out of manifest text and retain finish diagnostics", () => {
+    for (const [type, finish] of [
+        ["reasoning", "stop"],
+        ["tool", "tool-calls"],
+    ]) {
+        const messages = [
+            {
+                info: { role: "assistant", finish },
+                parts: [{ type, text: "private or tool data" }],
+            },
+        ];
+        expect(extractLatestAssistantText(messages)).toBeNull();
+        expect(describeAssistantSettlement(messages)).toContain(`finish=${finish}`);
+    }
+    expect(
+        describeAssistantSettlement({
+            tokenLog: { finish_reason: "length" },
+            reasoning: "private",
+        }),
+    ).toBe("finish=length, reasoning=true");
+});
 
 describe("hasLengthCappedOutput", () => {
     test("detects OpenCode assistant info.finish", () => {

package/src/shared/assistant-message-extractor.ts

@@ -127,3 +127,30 @@ export function hasLengthCappedOutput(value: unknown): boolean {
 
     return Object.values(value).some((item) => hasLengthCappedOutput(item));
 }
+
+/** Settlement metadata for diagnostics, never private reasoning as task output. */
+export function describeAssistantSettlement(output: unknown): string {
+    if (isRecord(output) && isRecord(output.tokenLog)) {
+        return `finish=${String(output.tokenLog.finish_reason ?? "unknown")}, reasoning=${typeof output.reasoning === "string" && output.reasoning.length > 0}`;
+    }
+    const latest = getLatestAssistantMessage(output);
+    const parts = Array.isArray(latest?.parts) ? latest.parts.filter(isRecord) : [];
+    return `finish=${latest?.info?.finish ?? "unknown"}, reasoning=${parts.some((part) => part.type === "reasoning")}, tools=${parts.filter((part) => part.type === "tool").length}`;
+}
+
+/** Describe persisted host/provider errors without losing structured status or message fields. */
+export function describeAssistantError(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (!isRecord(error)) return String(error);
+    const data = isRecord(error.data) ? error.data : error;
+    const message = typeof data.message === "string" ? data.message : undefined;
+    const status = data.statusCode ?? data.status;
+    const name =
+        typeof error.name === "string"
+            ? error.name
+            : typeof error.type === "string"
+              ? error.type
+              : undefined;
+    const description = [name, message].filter(Boolean).join(": ") || JSON.stringify(error);
+    return status === undefined ? description : `${description} (status=${String(status)})`;
+}

package/src/shared/background-batch-drain.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { drainBackgroundBatches } from "./background-batch-drain";
+
+test("background drain yields after each committed slice and resumes after its tick budget", async () => {
+    let clock = 0;
+    let remaining = 10;
+    let yields = 0;
+    const options = {
+        budgetMs: 3,
+        now: () => clock,
+        yieldFn: async () => {
+            yields++;
+            clock++;
+        },
+    };
+    const step = () => {
+        if (remaining === 0) return false;
+        remaining--;
+        return true;
+    };
+    expect(await drainBackgroundBatches(step, options)).toBe(3);
+    expect(yields).toBe(3);
+    expect(remaining).toBe(7);
+    expect(await drainBackgroundBatches(step, { ...options, budgetMs: 20 })).toBe(7);
+    expect(yields).toBe(10);
+    expect(remaining).toBe(0);
+});
+
+test("a busy background slice defers without rerunning a partially executed callback", async () => {
+    let attempts = 0;
+    expect(
+        await drainBackgroundBatches(() => {
+            attempts++;
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        }),
+    ).toBe(0);
+    expect(attempts).toBe(1);
+});

package/src/shared/background-batch-drain.ts

@@ -0,0 +1,29 @@
+import {
+    isTransientSqliteError,
+    withoutSqliteTransformPass,
+    withSqliteBackgroundWriter,
+} from "./sqlite";
+
+/** Drain committed slices without monopolizing the event loop or borrowing a
+ * foreground turn's lock-wait budget. A busy slice defers to the next timer tick. */
+export async function drainBackgroundBatches(
+    step: () => boolean,
+    options: { budgetMs?: number; now?: () => number; yieldFn?: () => Promise<void> } = {},
+): Promise<number> {
+    const now = options.now ?? (() => performance.now());
+    const deadline = now() + (options.budgetMs ?? 2000);
+    const yieldFn =
+        options.yieldFn ?? (() => new Promise<void>((resolve) => setTimeout(resolve, 0)));
+    let batches = 0;
+    while (now() < deadline) {
+        try {
+            if (!withoutSqliteTransformPass(() => withSqliteBackgroundWriter(step))) break;
+        } catch (error) {
+            if (isTransientSqliteError(error)) break;
+            throw error;
+        }
+        batches++;
+        await yieldFn();
+    }
+    return batches;
+}

package/src/shared/builtin-commands.ts

@@ -0,0 +1,50 @@
+import type { Config } from "@opencode-ai/sdk";
+
+// Keep command metadata independent of server features: config validation and
+// the separately shipped TUI need the same reserved command names.
+type BuiltinCommandConfig = NonNullable<Config["command"]>;
+
+const COMPACTION_ENABLED_PATH = `compaction${".enabled"}`;
+
+export function getMagicContextBuiltinCommands(compactionEnabled = true) {
+    const unavailableInCompactionOff = (command: string) =>
+        `Unavailable when ${COMPACTION_ENABLED_PATH} is false: /${command} manages compacted history.`;
+
+    return {
+        "ctx-status": {
+            template: "ctx-status",
+            description: "Show magic context status, pending queue, cache TTL, and debug info",
+        },
+        "ctx-recomp": {
+            template: "ctx-recomp",
+            description: compactionEnabled
+                ? "Rebuild compressed history from raw history (full or <start>-<end> range); memories are not changed"
+                : unavailableInCompactionOff("ctx-recomp"),
+        },
+        "ctx-wrapup": {
+            template: "ctx-wrapup",
+            description: compactionEnabled
+                ? "Compact older live history while keeping the newest messages raw"
+                : unavailableInCompactionOff("ctx-wrapup"),
+        },
+        "ctx-flush": {
+            template: "ctx-flush",
+            description: compactionEnabled
+                ? "Force-process all pending magic context operations immediately"
+                : unavailableInCompactionOff("ctx-flush"),
+        },
+        "ctx-dream": {
+            template: "ctx-dream",
+            description: "Run the hidden dreamer maintenance pass for this project now",
+        },
+        "ctx-embed": {
+            template: "ctx-embed",
+            description:
+                "Embedding status, or start/pause history compartment embedding (start | pause)",
+        },
+    } satisfies BuiltinCommandConfig;
+}
+
+export type MagicContextBuiltinCommandName = keyof ReturnType<
+    typeof getMagicContextBuiltinCommands
+>;

package/src/shared/console-diagnostics-fence.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+// OpenCode and Pi pass plugin stdout/stderr straight through to the operator's
+// terminal, so a `[magic-context]` line written with console.* lands in the
+// middle of someone else's UI. Diagnostics belong in the Magic Context log file
+// (shared/logger.ts). This fence scans production sources for console calls
+// whose arguments carry the `[magic-context]` tag.
+const repoRoot = resolve(import.meta.dir, "../../../../");
+const scannedRoots = ["packages/plugin/src", "packages/pi-plugin/src"];
+
+// Messages the operator is meant to read on the terminal. Each entry is a
+// repo-relative path plus a substring of the call's text, so a new console
+// call in an allow-listed file still trips the fence.
+const userFacingAllowList: Array<{ path: string; contains: string; why: string }> = [
+    {
+        path: "packages/plugin/src/v2/hooks/context.ts",
+        contains: "v2 host API unavailable",
+        why: "startup error: the host lacks the required session API; shown once with the minimum version",
+    },
+    {
+        path: "packages/plugin/src/plugin/tool-registry.ts",
+        contains: "persistent storage unavailable; disabling magic-context tools",
+        why: "startup error: storage failed to open, so no ctx_* tool is registered",
+    },
+    {
+        path: "packages/plugin/src/v2/hooks/context.ts",
+        contains: "v2 setup disabled by conflicting context hooks",
+        why: "startup error: another plugin's context hook disables Magic Context",
+    },
+    {
+        path: "packages/plugin/src/v2/hooks/context.ts",
+        contains: "v2 storage unavailable",
+        why: "startup error: storage failed to open; reported once per distinct failure",
+    },
+    {
+        path: "packages/plugin/src/shared/data-path.ts",
+        contains: "TEST BACKSTOP",
+        why: "fires only under NODE_ENV=test, where the logger is silent and imports this module",
+    },
+];
+
+// `[magic-context]` and `[magic-context][pi]`; the TUI's own `[magic-context-tui]`
+// debug lines run in the host's TUI process and are not covered here.
+const diagnosticTag = /\[magic-context\]/;
+
+const consoleCall = /\bconsole\.(?:warn|log|error|info|debug)\(/g;
+
+function isTestSource(relativePath: string): boolean {
+    return (
+        /\.test\.[cm]?[jt]sx?$/.test(relativePath) ||
+        relativePath.split("/").includes("__tests__") ||
+        relativePath.split("/").includes("test-support")
+    );
+}
+
+function listSources(dir: string): string[] {
+    const files: string[] = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules") continue;
+            files.push(...listSources(full));
+        } else if (/\.[cm]?[jt]sx?$/.test(entry.name)) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+
+/**
+ * Return the text of a call's argument list, starting just after its opening
+ * parenthesis. Quotes and template literals are skipped so a parenthesis in a
+ * message does not end the call early; `${...}` holes are scanned as code.
+ */
+function callArguments(source: string, openParen: number): string {
+    let depth = 1;
+    const stack: string[] = [];
+    let index = openParen + 1;
+    while (index < source.length && depth > 0) {
+        const char = source[index];
+        const quote = stack.at(-1);
+        if (quote === "'" || quote === '"') {
+            if (char === "\\") index++;
+            else if (char === quote) stack.pop();
+        } else if (quote === "`") {
+            if (char === "\\") index++;
+            else if (char === "`") stack.pop();
+            else if (char === "$" && source[index + 1] === "{") {
+                stack.push("{");
+                index++;
+            }
+        } else if (char === "'" || char === '"' || char === "`") {
+            stack.push(char);
+        } else if (char === "{" && stack.length > 0) {
+            stack.push("{");
+        } else if (char === "}" && quote === "{") {
+            stack.pop();
+        } else if (char === "(") {
+            depth++;
+        } else if (char === ")") {
+            depth--;
+        }
+        index++;
+    }
+    return source.slice(openParen + 1, index - 1);
+}
+
+function findTaggedConsoleCalls(): string[] {
+    const findings: string[] = [];
+    for (const root of scannedRoots) {
+        for (const file of listSources(resolve(repoRoot, root))) {
+            const relativePath = relative(repoRoot, file).split("\\").join("/");
+            if (isTestSource(relativePath)) continue;
+            const source = readFileSync(file, "utf8");
+            for (const match of source.matchAll(consoleCall)) {
+                const args = callArguments(source, match.index + match[0].length - 1);
+                if (!diagnosticTag.test(args)) continue;
+                const allowed = userFacingAllowList.some(
+                    (entry) => entry.path === relativePath && args.includes(entry.contains),
+                );
+                if (allowed) continue;
+                const line = source.slice(0, match.index).split("\n").length;
+                findings.push(`${relativePath}:${line}`);
+            }
+        }
+    }
+    return findings;
+}
+
+describe("console diagnostics fence", () => {
+    test("no production source writes [magic-context] diagnostics to the host console", () => {
+        expect(findTaggedConsoleCalls()).toEqual([]);
+    });
+
+    test("the scanner sees a tagged call nested in a template literal", () => {
+        const sample =
+            "console.warn(\n    `[${new Date().toISOString()}] [magic-context] x=${Math.round(1)}ms`,\n);";
+        const open = sample.indexOf("(");
+        expect(callArguments(sample, open)).toContain("[magic-context]");
+        const untagged = 'console.warn("plain (paren"); const s = "[magic-context]";';
+        expect(callArguments(untagged, untagged.indexOf("("))).not.toContain("[magic-context]");
+    });
+});

package/src/shared/data-path.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import {
@@ -15,6 +15,7 @@ import {
     getProjectMagicContextDir,
     getProjectMagicContextHistorianDir,
 } from "./data-path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 const savedEnv = {
     XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
@@ -286,7 +287,7 @@ describe("data-path", () => {
 
 describe("ensureCortexKitArtifactGitignore", () => {
     test("creates .cortexkit/.gitignore with a fenced magic-context block", () => {
-        const dir = mkdtempSync(path.join(os.tmpdir(), "mc-gi-"));
+        const dir = createTestTempDirFromPath(path.join(os.tmpdir(), "mc-gi-"));
         try {
             ensureCortexKitArtifactGitignore(dir);
             const gi = readFileSync(path.join(dir, ".cortexkit", ".gitignore"), "utf8");
@@ -299,7 +300,7 @@ describe("ensureCortexKitArtifactGitignore", () => {
     });
 
     test("is idempotent — a second call does not duplicate the block", () => {
-        const dir = mkdtempSync(path.join(os.tmpdir(), "mc-gi-"));
+        const dir = createTestTempDirFromPath(path.join(os.tmpdir(), "mc-gi-"));
         try {
             ensureCortexKitArtifactGitignore(dir);
             ensureCortexKitArtifactGitignore(dir);
@@ -312,7 +313,7 @@ describe("ensureCortexKitArtifactGitignore", () => {
     });
 
     test("preserves a sibling module's existing entries (appends, never clobbers)", () => {
-        const dir = mkdtempSync(path.join(os.tmpdir(), "mc-gi-"));
+        const dir = createTestTempDirFromPath(path.join(os.tmpdir(), "mc-gi-"));
         try {
             const ckDir = path.join(dir, ".cortexkit");
             mkdirSync(ckDir, { recursive: true });
@@ -333,7 +334,7 @@ describe("ensureCortexKitArtifactGitignore", () => {
     });
 
     test("does not ignore the project config — only the artifact dir", () => {
-        const dir = mkdtempSync(path.join(os.tmpdir(), "mc-gi-"));
+        const dir = createTestTempDirFromPath(path.join(os.tmpdir(), "mc-gi-"));
         try {
             ensureCortexKitArtifactGitignore(dir);
             const gi = readFileSync(path.join(dir, ".cortexkit", ".gitignore"), "utf8");

package/src/shared/embedding-activity.test.ts

@@ -0,0 +1,21 @@
+import { expect, test } from "bun:test";
+import { isEmbeddingHostBusy, observeEmbeddingActivity } from "./embedding-activity";
+
+test("background embedding gate tracks all active sessions and releases on idle or deletion", () => {
+    const status = (sessionID: string, type: string) =>
+        observeEmbeddingActivity({
+            type: "session.status",
+            properties: { sessionID, status: { type } },
+        });
+    expect(isEmbeddingHostBusy()).toBe(false);
+    status("embedding-gate-a", "busy");
+    status("embedding-gate-b", "retry");
+    expect(isEmbeddingHostBusy()).toBe(true);
+    status("embedding-gate-a", "idle");
+    expect(isEmbeddingHostBusy()).toBe(true);
+    observeEmbeddingActivity({
+        type: "session.deleted",
+        properties: { sessionID: "embedding-gate-b" },
+    });
+    expect(isEmbeddingHostBusy()).toBe(false);
+});