@wolfx/opencode-magic-context 0.21.8 → 0.22.1-patch.0

package/src/shared/announcement.test.ts

@@ -8,8 +8,11 @@ import * as path from "node:path";
  * `getMagicContextStorageDir()`. The behavior we test:
  *   1. `markAnnouncementSeen` then `readLastAnnouncedVersion` round-trips
  *   2. `shouldShowAnnouncement` returns false after a matching mark
- *   3. `shouldShowAnnouncement` returns true after a non-matching mark
- *   4. Empty-version inputs are no-ops (don't crash, don't write garbage)
+ *   3. `shouldShowAnnouncement` returns true after a non-matching (older) mark
+ *   4. `shouldShowAnnouncement` seeds state + returns false on first run / wiped
+ *      sandbox (no prior file), so fresh installs and ephemeral envs aren't
+ *      spammed with a changelog (issue #99)
+ *   5. Empty-version inputs are no-ops (don't crash, don't write garbage)
  *
  * We isolate writes by pointing `XDG_DATA_HOME` at a temp dir before requiring
  * the module fresh per test, since the module captures the storage path at
@@ -32,7 +35,8 @@ afterEach(() => {
         process.env.XDG_DATA_HOME = originalXdg;
     }
     try {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
+        // maxRetries/retryDelay ride out transient EBUSY/EPERM on Windows.
+        fs.rmSync(tmpRoot, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
     } catch {
         // best-effort
     }
@@ -110,9 +114,14 @@ describe("shouldShowAnnouncement gating", () => {
         expect(shouldShowAnnouncement()).toBe(false);
     });
 
-    test("returns true when the live version was never marked", async () => {
+    test("seeds state and returns false on first run / wiped sandbox (issue #99)", async () => {
         const mod = await import(`./announcement?t=${Date.now()}-none`);
-        const { ANNOUNCEMENT_VERSION, ANNOUNCEMENT_FEATURES, shouldShowAnnouncement } = mod;
+        const {
+            ANNOUNCEMENT_VERSION,
+            ANNOUNCEMENT_FEATURES,
+            shouldShowAnnouncement,
+            readLastAnnouncedVersion,
+        } = mod;
 
         if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0) {
             // When empty, the gate is always false regardless of state
@@ -120,8 +129,15 @@ describe("shouldShowAnnouncement gating", () => {
             return;
         }
 
-        // No mark has been written in this fresh tmpRoot, so the gate is open
-        expect(shouldShowAnnouncement()).toBe(true);
+        // No mark exists yet (fresh install or ephemeral/wiped sandbox). The
+        // gate must NOT announce — it seeds the state to the current version and
+        // returns false, so first-run users and disposable containers are never
+        // spammed with a changelog they have no context for.
+        expect(readLastAnnouncedVersion()).toBe("");
+        expect(shouldShowAnnouncement()).toBe(false);
+        // The seed was written, so a subsequent check stays quiet too.
+        expect(readLastAnnouncedVersion()).toBe(ANNOUNCEMENT_VERSION);
+        expect(shouldShowAnnouncement()).toBe(false);
     });
 
     test("returns true when a different (older) version is marked", async () => {

package/src/shared/announcement.ts

@@ -23,19 +23,18 @@ import { getMagicContextStorageDir } from "./data-path";
  * Bump only when there are user-visible changes worth a startup dialog.
  * Does NOT need to match the published package version.
  */
-export const ANNOUNCEMENT_VERSION = "0.21.7";
+export const ANNOUNCEMENT_VERSION = "0.22.0";
 
 /**
  * Short, user-facing bullet strings. Keep each line ~80 chars or shorter so the
  * TUI dialog renders cleanly without horizontal scroll on a typical terminal.
  */
 export const ANNOUNCEMENT_FEATURES: ReadonlyArray<string> = [
-    "Pi parity sweep: 44 audit findings fixed, including a critical SHIP-BLOCKER where /ctx-flush did not drain the pending Pi compaction queue.",
-    "Pi historian recovery fix: empty/no-op historian returns now clear emergency recovery so sessions cannot loop forever at 95%.",
-    "trimPiMessagesToBoundary now sweeps non-contiguous tool-result orphans, fixing provider 400s after compaction in long Pi sessions.",
-    "Hidden subagent tool isolation: historian, dreamer, and sidekick can no longer spawn subagents or run unsafe tools.",
-    "TUI sidebar and /ctx-status header now show execute threshold inline: '47.5% / 65%' on the left, '475K / 1.0M' on the right.",
-    "doctor --issue now caps GitHub issue bodies at ~60KB with a dedicated 'Recent errors' section so reports stay submittable.",
+    "NOW ON BY DEFAULT — Temporal awareness: the agent sees elapsed-time markers (e.g. +2h 15m) between messages and dated compartments, so it knows how long ago things happened. Opt out with temporal_awareness: false.",
+    "NOW ON BY DEFAULT — Auto-search hints: each turn a background ctx_search whispers a compact 'vague recall' when something relevant exists in your memories, past conversation, or git history. No full content injected. Opt out with memory.auto_search.enabled: false.",
+    "Experimental features graduated to stable config: temporal_awareness and caveman_text_compression are now top-level keys; auto_search and git_commit_indexing moved under memory.* . Run `doctor` to migrate old experimental.* settings (your opt-ins/opt-outs are preserved).",
+    "git_commit_indexing (make project history semantically searchable) stays opt-in — enable with memory.git_commit_indexing.enabled: true.",
+    "Audit hardening across both harnesses: memory config-bypass fix, supersede-delta cache-stability fixes, and dashboard correctness fixes.",
 ];
 
 /**
@@ -90,8 +89,31 @@ export function markAnnouncementSeen(version: string): void {
  * True when the configured `ANNOUNCEMENT_VERSION` has not yet been dismissed
  * AND there is at least one feature to show. Used by both the TUI dialog path
  * and the Desktop ignored-message fallback.
+ *
+ * First-run / sandbox handling: when NO state file exists yet, we seed it to the
+ * current `ANNOUNCEMENT_VERSION` and return false instead of announcing. This
+ * covers two cases that previously spammed the dialog (issue #99):
+ *   - Fresh installs: a brand-new user shouldn't be shown a changelog of release
+ *     bullets they have no context for — they need onboarding, not patch notes.
+ *   - Ephemeral/sandbox environments (Docker, CI, disposable dev containers)
+ *     where the storage dir is wiped between launches: without the seed, the
+ *     missing file made the announcement re-show on every single startup.
+ * Real upgrades still announce exactly once: an existing user already has a
+ * state file at the prior version, so the version mismatch shows the dialog and
+ * dismissing it advances the file to the current version.
+ *
+ * The seed is a deliberate write side-effect on the "no file" branch — folding
+ * it here (rather than a separate startup call) makes every caller path (plugin
+ * startup, Pi startup, TUI rpc pull) consistent with no ordering dependency.
  */
 export function shouldShowAnnouncement(): boolean {
     if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0) return false;
-    return readLastAnnouncedVersion() !== ANNOUNCEMENT_VERSION;
+    const lastVersion = readLastAnnouncedVersion();
+    if (!lastVersion) {
+        // No prior state: fresh install or wiped sandbox. Seed to current and
+        // skip the announcement so we never pester first-run / ephemeral envs.
+        markAnnouncementSeen(ANNOUNCEMENT_VERSION);
+        return false;
+    }
+    return lastVersion !== ANNOUNCEMENT_VERSION;
 }

package/src/shared/conflict-detector.test.ts

@@ -46,8 +46,21 @@ describe("detectConflicts", () => {
             else process.env[k] = v;
         }
         // Test directories live under tmpdir(); cleanup is best-effort.
-        rmSync(projectDir, { recursive: true, force: true });
-        rmSync(userConfigDir, { recursive: true, force: true });
+        try {
+            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
+        try {
+            rmSync(userConfigDir, {
+                recursive: true,
+                force: true,
+                maxRetries: 10,
+                retryDelay: 100,
+            });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     });
 
     function writeProjectConfig(plugins: Array<string | [string, unknown]>): void {
@@ -182,7 +195,7 @@ describe("detectConflicts", () => {
     });
 
     it("returns no conflicts for unrelated plugins", () => {
-        writeProjectConfig(["@cortexkit/opencode-magic-context@latest", "some-other-plugin"]);
+        writeProjectConfig(["@wolfx/opencode-magic-context@latest", "some-other-plugin"]);
         const result = detectConflicts(projectDir);
         expect(result.hasConflict).toBe(false);
     });
@@ -195,7 +208,7 @@ describe("detectConflicts", () => {
     describe("tuple plugin entries (issue #49)", () => {
         it("does not crash when a plugin is defined as a [name, options] tuple", () => {
             writeProjectConfig([
-                "@cortexkit/opencode-magic-context@latest",
+                "@wolfx/opencode-magic-context@latest",
                 ["@plannotator/opencode@latest", { workflow: "plan-agent" }],
             ]);
             expect(() => detectConflicts(projectDir)).not.toThrow();
@@ -203,7 +216,7 @@ describe("detectConflicts", () => {
 
         it("detects DCP conflict when DCP is expressed as a tuple", () => {
             writeProjectConfig([
-                "@cortexkit/opencode-magic-context@latest",
+                "@wolfx/opencode-magic-context@latest",
                 ["@tarquinen/opencode-dcp@latest", {}],
             ]);
             const result = detectConflicts(projectDir);
@@ -223,7 +236,7 @@ describe("detectConflicts", () => {
                     "@plannotator/opencode@latest",
                     { workflow: "plan-agent", planningAgents: ["plan"] },
                 ],
-                "@cortexkit/opencode-magic-context@latest",
+                "@wolfx/opencode-magic-context@latest",
             ]);
             const result = detectConflicts(projectDir);
             expect(result.hasConflict).toBe(false);

package/src/shared/conflict-detector.ts

@@ -365,7 +365,7 @@ export function formatConflictShort(result: ConflictResult): string {
         "",
         ...result.reasons.map((r) => `• ${r}`),
         "",
-        "Fix: run `npx @cortexkit/opencode-magic-context@latest doctor`",
+        "Fix: run `npx @wolfx/opencode-magic-context@latest doctor`",
     ];
     return lines.join("\n");
 }

package/src/shared/conflict-fixer.test.ts

@@ -38,7 +38,11 @@ describe("fixConflicts", () => {
             if (value === undefined) delete process.env[key];
             else process.env[key] = value;
         }
-        rmSync(root, { recursive: true, force: true });
+        try {
+            rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     });
 
     it("preserves JSONC comments and tuple plugin entries while removing canonical DCP", () => {
@@ -50,7 +54,7 @@ describe("fixConflicts", () => {
   "plugin": [
     ["@plannotator/opencode@latest", { "workflow": "plan-agent" }],
     ["@tarquinen/opencode-dcp@latest", { "enabled": true }],
-    "@cortexkit/opencode-magic-context@latest"
+    "@wolfx/opencode-magic-context@latest"
   ],
   "compaction": {
     // keep this compaction comment
@@ -76,7 +80,7 @@ describe("fixConflicts", () => {
         expect(updated.compaction).toEqual({ auto: false, prune: false });
         expect(updated.plugin).toEqual([
             ["@plannotator/opencode@latest", { workflow: "plan-agent" }],
-            "@cortexkit/opencode-magic-context@latest",
+            "@wolfx/opencode-magic-context@latest",
         ]);
     });
 

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

@@ -121,20 +121,19 @@ describe("data-path", () => {
         expect(shared).toContain("cortexkit");
     });
 
-    test("getProjectMagicContextDir composes <project>/.opencode/magic-context", () => {
-        // Project-local artifacts (historian state file, failure dumps) live
-        // inside the project so OpenCode's external_directory permission system
-        // treats them as project-internal. Without this, historian's Read tool
-        // would trigger a permission prompt on every run when artifacts lived
-        // under os.tmpdir().
+    test("getProjectMagicContextDir composes <project>/.magic-context", () => {
+        // Project-local artifacts live inside the project so OpenCode's
+        // external_directory permission system treats them as project-internal.
+        // Without this, historian's Read tool would trigger a permission prompt
+        // on every run when artifacts lived under os.tmpdir().
         expect(getProjectMagicContextDir("/Users/me/Work/proj")).toBe(
-            path.join("/Users/me/Work/proj", ".opencode", "magic-context"),
+            path.join("/Users/me/Work/proj", ".magic-context"),
         );
     });
 
     test("getProjectMagicContextHistorianDir appends historian/", () => {
         expect(getProjectMagicContextHistorianDir("/Users/me/Work/proj")).toBe(
-            path.join("/Users/me/Work/proj", ".opencode", "magic-context", "historian"),
+            path.join("/Users/me/Work/proj", ".magic-context", "historian"),
         );
     });
 
@@ -145,7 +144,7 @@ describe("data-path", () => {
         // project-local historian dir.
         process.env.XDG_DATA_HOME = "/tmp/custom-data";
         expect(getProjectMagicContextDir("/some/project")).toBe(
-            path.join("/some/project", ".opencode", "magic-context"),
+            path.join("/some/project", ".magic-context"),
         );
     });
 
@@ -153,7 +152,7 @@ describe("data-path", () => {
         // path.join normalizes redundant separators so callers don't need to
         // worry about how the project directory was constructed.
         expect(getProjectMagicContextDir("/some/project/")).toBe(
-            path.join("/some/project/", ".opencode", "magic-context"),
+            path.join("/some/project/", ".magic-context"),
         );
     });
 });

package/src/shared/data-path.ts

@@ -62,34 +62,31 @@ export function getMagicContextHistorianDir(harness: HarnessId = getHarness()):
 /**
  * Project-local magic-context artifact directory.
  *
- * Layout: `<project-directory>/.opencode/magic-context/`
+ * Layout: `<project-directory>/.magic-context/`
  *
  * Used for artifacts that the historian/recomp pipeline writes during a run
  * and that the model is asked to read via its native Read tool. OpenCode's
  * `external_directory` permission system asks the user before reading any
  * file outside the project directory or its worktree, which interrupts every
  * historian run when artifacts live under `os.tmpdir()`. Writing under the
- * project's own `.opencode/` subtree falls inside the project boundary and
- * never triggers a permission prompt.
+ * project's own `.magic-context/` subtree falls inside the project boundary
+ * and never triggers a permission prompt.
  *
- * The `.opencode/` parent dir is OpenCode's own per-project convention (used
- * for project-local config, plans, dumps, plugin installs). Anchoring
- * magic-context artifacts under `.opencode/magic-context/` keeps them
- * co-located with related OpenCode metadata and makes them easy for users to
- * locate when debugging.
+ * Using a harness-agnostic name (`/.magic-context/` rather than
+ * `/.opencode/`) ensures the same path works for both OpenCode and Pi.
  *
  * Logger does NOT use this — log files stay in the per-harness tmp subtree
  * because they are written by the plugin process itself (no model-side Read
  * tool call, no permission prompt) and span sessions/projects.
  */
 export function getProjectMagicContextDir(directory: string): string {
-    return path.join(directory, ".opencode", "magic-context");
+    return path.join(directory, ".magic-context");
 }
 
 /**
  * Project-local historian artifact directory.
  *
- * Layout: `<project-directory>/.opencode/magic-context/historian/`
+ * Layout: `<project-directory>/.magic-context/historian/`
  *
  * Used for:
  *   - existing-state offload XMLs that long historian/recomp passes write
@@ -97,8 +94,9 @@ export function getProjectMagicContextDir(directory: string): string {
  *   - validation-failure dump XMLs preserved for debugging
  *
  * Callers must `mkdirSync(dir, { recursive: true })` before writing — the
- * `.opencode/` parent may not exist on a fresh project, and write failures
- * here must degrade gracefully (e.g. historian falls back to inline state).
+ * `.magic-context/` parent may not exist on a fresh project, and write
+ * failures here must degrade gracefully (e.g. historian falls back to inline
+ * state).
  */
 export function getProjectMagicContextHistorianDir(directory: string): string {
     return path.join(getProjectMagicContextDir(directory), "historian");

package/src/shared/models-dev-cache.test.ts

@@ -39,7 +39,11 @@ describe("models-dev-cache", () => {
             if (v === undefined) delete process.env[k];
             else process.env[k] = v;
         }
-        rmSync(tempDir, { recursive: true, force: true });
+        try {
+            rmSync(tempDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
         clearModelsDevCache();
     });
 
@@ -234,7 +238,7 @@ describe("models-dev-cache", () => {
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBeUndefined();
     });
 
-    test("API cache takes priority over file cache", async () => {
+    test("takes the larger limit when both layers know the model (API larger)", async () => {
         // Seed file layer with one value.
         const opencodeDir = join(tempDir, "opencode");
         mkdirSync(opencodeDir, { recursive: true });
@@ -248,7 +252,7 @@ describe("models-dev-cache", () => {
         // Sanity: file layer returns 100000 before API refresh.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(100000);
 
-        // Mock client providing DIFFERENT value via API.
+        // Mock client providing a LARGER value via API.
         const mockClient = {
             config: {
                 providers: async () => ({
@@ -267,7 +271,7 @@ describe("models-dev-cache", () => {
         };
         await refreshModelLimitsFromApi(mockClient);
 
-        // API value wins.
+        // Larger (API) value wins.
         expect(getModelsDevContextLimit("anthropic", "claude-4")).toBe(1000000);
 
         const state = getModelsDevCacheState();
@@ -275,6 +279,70 @@ describe("models-dev-cache", () => {
         expect(state.apiCount).toBe(1);
     });
 
+    test("file value wins when the live API reports a smaller (wrong) limit (issue #117)", async () => {
+        // The ollama-cloud scenario: models.dev has the correct large window, but
+        // ollama reports its tiny default num_ctx via the live /config/providers
+        // API. The larger, correct file value must win so pressure isn't bogus.
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: { "deepseek-v4-pro": { limit: { context: 1048576 } } },
+                },
+            }),
+        );
+
+        const mockClient = {
+            config: {
+                providers: async () => ({
+                    data: {
+                        providers: [
+                            {
+                                id: "ollama-cloud",
+                                models: {
+                                    // Bogus tiny default num_ctx from ollama.
+                                    "deepseek-v4-pro": { limit: { context: 8192 } },
+                                },
+                            },
+                        ],
+                    },
+                }),
+            },
+        };
+        await refreshModelLimitsFromApi(mockClient);
+
+        // Larger (file/models.dev) value wins, not the tiny live-API value.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro")).toBe(1048576);
+    });
+
+    test("matches a tagged ollama model against its tag-less models.dev entry (issue #117)", () => {
+        // ollama invokes cloud models with a tag (deepseek-v4-pro:cloud) while
+        // models.dev stores them tag-less (deepseek-v4-pro).
+        const opencodeDir = join(tempDir, "opencode");
+        mkdirSync(opencodeDir, { recursive: true });
+        writeFileSync(
+            join(opencodeDir, "models.json"),
+            JSON.stringify({
+                "ollama-cloud": {
+                    models: {
+                        "deepseek-v4-pro": { limit: { context: 1048576 } },
+                        // A legitimately-tagged model must still match exactly.
+                        "gemma3:27b": { limit: { context: 131072 } },
+                    },
+                },
+            }),
+        );
+
+        // Tagged invocation falls back to the tag-less entry.
+        expect(getModelsDevContextLimit("ollama-cloud", "deepseek-v4-pro:cloud")).toBe(1048576);
+        // Exact tagged match still wins (no wrongful collapse).
+        expect(getModelsDevContextLimit("ollama-cloud", "gemma3:27b")).toBe(131072);
+        // Unknown tagged model with no tag-less base stays undefined.
+        expect(getModelsDevContextLimit("ollama-cloud", "nonexistent:cloud")).toBeUndefined();
+    });
+
     test("refreshModelLimitsFromApi tolerates empty/malformed responses", async () => {
         // Undefined data.
         await refreshModelLimitsFromApi({

package/src/shared/models-dev-cache.ts

@@ -298,19 +298,58 @@ export async function refreshModelLimitsFromApi(client: OpencodeClientLike): Pro
  * Returns `undefined` if neither layer knows the model.
  */
 export function getModelsDevContextLimit(providerID: string, modelID: string): number | undefined {
-    const key = `${providerID}/${modelID}`;
-
-    if (apiCache) {
-        const fromApi = apiCache.get(key)?.limit;
-        if (typeof fromApi === "number") return fromApi;
-    }
-
     const now = Date.now();
     if (!fileCache || now - fileLastAttempt > RELOAD_INTERVAL_MS) {
         fileLastAttempt = now;
         fileCache = loadModelsDevMetadataFromFile();
     }
-    return fileCache.get(key)?.limit;
+
+    const fromApi = lookupLimitWithTagFallback(apiCache, providerID, modelID);
+    const fromFile = lookupLimitWithTagFallback(fileCache, providerID, modelID);
+
+    // When BOTH layers know the model, take the LARGER limit. Providers never
+    // under-report their real window, so a suspiciously small value — e.g.
+    // ollama reporting its default `num_ctx` (4k/8k) for a cloud model via the
+    // live `/config/providers` API — must not override the correct, larger
+    // models.dev value. A genuinely smaller real limit (provider actually
+    // rejects at N) is captured separately via the overflow-detection path
+    // (detectedContextLimit), not here. (issue #117)
+    if (typeof fromApi === "number" && typeof fromFile === "number") {
+        return Math.max(fromApi, fromFile);
+    }
+    return fromApi ?? fromFile;
+}
+
+/**
+ * Look up a model's limit in one cache layer, with an ollama-style tag-suffix
+ * fallback.
+ *
+ * models.dev stores some models WITH a colon tag (e.g. `gemma3:27b`,
+ * `deepseek-v3.1:671b`) and ollama-cloud base models WITHOUT one
+ * (`deepseek-v4-pro`). But ollama invokes cloud models with a tag at runtime
+ * (`deepseek-v4-pro:cloud`), so OpenCode reports the tagged id. An exact-only
+ * match therefore misses → falls back to the 128k default → wrong pressure
+ * denominator (issue #117).
+ *
+ * Strategy: exact match first (never collapses a legitimately-tagged model),
+ * then retry once with the last `:tag` segment stripped.
+ */
+function lookupLimitWithTagFallback(
+    cache: Map<string, CachedModelMetadata> | null,
+    providerID: string,
+    modelID: string,
+): number | undefined {
+    if (!cache) return undefined;
+    const exact = cache.get(`${providerID}/${modelID}`)?.limit;
+    if (typeof exact === "number") return exact;
+
+    const colonIdx = modelID.lastIndexOf(":");
+    if (colonIdx > 0) {
+        const baseModel = modelID.slice(0, colonIdx);
+        const fallback = cache.get(`${providerID}/${baseModel}`)?.limit;
+        if (typeof fallback === "number") return fallback;
+    }
+    return undefined;
 }
 
 /** Clear in-memory caches (for testing). */

package/src/shared/opencode-compaction-detector.test.ts

@@ -18,7 +18,11 @@ describe("opencode-compaction-detector", () => {
     });
 
     afterEach(() => {
-        rmSync(tmpDir, { recursive: true, force: true });
+        try {
+            rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
         delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
     });
 
@@ -30,7 +34,11 @@ describe("opencode-compaction-detector", () => {
             const result = isOpenCodeAutoCompactionEnabled(emptyDir);
 
             expect(result).toBe(true);
-            rmSync(emptyDir, { recursive: true, force: true });
+            try {
+                rmSync(emptyDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            } catch {
+                /* Ignore EBUSY on Windows */
+            }
         });
     });
 

package/src/shared/rpc-client.test.ts

@@ -1,10 +1,11 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { MagicContextRpcClient } from "./rpc-client";
-import { rpcPortFilePath } from "./rpc-utils";
+import { MagicContextRpcServer } from "./rpc-server";
+import { parseRpcPortFile, rpcPortFilePath } from "./rpc-utils";
 
 interface TestServer {
     port: number;
@@ -19,7 +20,11 @@ afterEach(async () => {
         await server.close();
     }
     for (const dir of tempDirs.splice(0)) {
-        rmSync(dir, { recursive: true, force: true });
+        try {
+            rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
     }
 });
 
@@ -116,6 +121,52 @@ describe("MagicContextRpcClient", () => {
         expect(await client.call<{ value: string }>("value")).toEqual({ value: "second" });
     });
 
+    test("authenticates against a real server with the published token", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-auth";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        server.handle("ping", async () => ({ pong: true }));
+        await server.start();
+        try {
+            const client = new MagicContextRpcClient(storageDir, directory);
+            // Real round-trip: client must read the token from the port file and
+            // send it as Bearer auth, or the server returns 401.
+            expect(await client.call<{ pong: boolean }>("ping")).toEqual({ pong: true });
+        } finally {
+            server.stop();
+        }
+    });
+
+    test("a request without the token is rejected 401 by the server", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo-noauth";
+        const server = new MagicContextRpcServer(storageDir, directory);
+        server.handle("ping", async () => ({ pong: true }));
+        const port = await server.start();
+        try {
+            // Sanity: the port file carries a non-empty token.
+            const record = parseRpcPortFile(
+                readFileSync(rpcPortFilePath(storageDir, directory), "utf-8"),
+            );
+            expect(typeof record?.token).toBe("string");
+            expect((record?.token ?? "").length).toBeGreaterThan(0);
+
+            // A raw fetch with no Authorization header must be rejected.
+            const res = await fetch(`http://127.0.0.1:${port}/rpc/ping`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: "{}",
+            });
+            expect(res.status).toBe(401);
+
+            // Health stays open (no token required) for discovery.
+            const health = await fetch(`http://127.0.0.1:${port}/health`);
+            expect(health.status).toBe(200);
+        } finally {
+            server.stop();
+        }
+    });
+
     test("gives up when the port file points at a dead server", async () => {
         const storageDir = makeTempDir();
         const directory = "/repo";