@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/src/shared/status-view.ts

@@ -18,6 +18,12 @@ import { formatCacheTtlDisplay } from "./cache-ttl-display";
 import { type ConfigParseFailure, formatConfigParseStatusLine } from "./config-diagnostics";
 import { formatThresholdPercent } from "./format-threshold";
 import type { TailHygieneStatus } from "./rpc-types";
+import {
+    type StatusCheck,
+    type StatusUnavailableReason,
+    type StatusVersions,
+    statusVersionNotice,
+} from "./status-view-check";
 import { formatTailHygiene } from "./tail-hygiene-status";
 import {
     renderUserFacingFailure,
@@ -140,6 +146,7 @@ export interface StatusViewSource {
      * backlog that silently never falls.
      */
     readonly dreamerUnsupportedTasks?: readonly string[];
+    readonly dreamerSkipped?: readonly string[];
     /**
      * Set when the last background maintenance pass stopped before finishing.
      * Shown so "the dreamer has nothing to do" and "the dreamer never got to
@@ -159,9 +166,31 @@ export interface StatusViewSource {
     readonly compactionEnabled?: boolean;
     /** Failure codes to print under the sections, already selected by the host. */
     readonly warnings?: readonly UserFacingFailureKey[];
+    /**
+     * Set when this server migrated the shared store at startup while other
+     * OpenCode servers (these PIDs, from their RPC discovery records) could not
+     * be checked; if one was an older build still running, it now reads a
+     * store newer than it supports.
+     */
+    readonly unconfirmedMigrationHolders?: {
+        readonly pids: readonly number[];
+        readonly fromVersion: number;
+        readonly toVersion: number;
+    };
     readonly hiddenVariantWarnings?: readonly string[];
 }
 
+declare const checkedStatusViewSource: unique symbol;
+
+/**
+ * A `StatusViewSource` that has passed `checkStatusViewSource`. The brand exists
+ * only in the type system: `buildStatusView` accepts nothing else, so a payload
+ * cannot reach the view model without going through the check.
+ */
+export type CheckedStatusViewSource = StatusViewSource & {
+    readonly [checkedStatusViewSource]: true;
+};
+
 export interface StatusViewOptions {
     /** Plugin version shown next to the title. */
     readonly version: string;
@@ -475,11 +504,17 @@ function historyRows(source: StatusViewSource, now: number): StatusRow[] {
     return rows;
 }
 
-/** One row naming every Dreamer task this host cannot run, or nothing when it runs them all. */
+/** Availability rows for unsupported tasks and explicitly disabled/unavailable runs. */
 function dreamerUnsupportedRows(source: StatusViewSource): StatusRow[] {
     const unsupported = source.dreamerUnsupportedTasks ?? [];
-    if (unsupported.length === 0) return [];
+    const skipped: StatusRow[] = (source.dreamerSkipped ?? []).map((value) => ({
+        label: "Dreamer skipped",
+        value,
+        tone: "muted",
+    }));
+    if (unsupported.length === 0) return skipped;
     return [
+        ...skipped,
         {
             label: "Dreamer unavailable",
             value: `${unsupported.join(", ")} (${userFacingFailureCode("dream_task_needs_tool_loop")})`,
@@ -627,7 +662,16 @@ function statusSections(source: StatusViewSource, now: number): StatusSection[]
 }
 
 function warningBlock(source: StatusViewSource): StatusWarning[] {
+    const holders = source.unconfirmedMigrationHolders;
     return [
+        ...(holders && holders.pids.length > 0
+            ? [
+                  {
+                      text: `Magic Context upgraded its database from v${holders.fromVersion} to v${holders.toVersion} while OpenCode PID ${holders.pids.join(", ")} could not be checked. If an older OpenCode is still open, quit all OpenCode processes and start again.`,
+                      tone: "error" as const,
+                  },
+              ]
+            : []),
         ...(source.hiddenVariantWarnings ?? []).map((text) => ({ text, tone: "warning" as const })),
         ...(source.configReloadFailure
             ? [
@@ -651,8 +695,11 @@ function warningBlock(source: StatusViewSource): StatusWarning[] {
     ];
 }
 
-/** Builds the full status view from one snapshot. */
-export function buildStatusView(source: StatusViewSource, options: StatusViewOptions): StatusView {
+/** Builds the full status view from one checked snapshot. */
+export function buildStatusView(
+    source: CheckedStatusViewSource,
+    options: StatusViewOptions,
+): StatusView {
     const now = options.now ?? Date.now();
     const off = !compactionEnabled(source);
     const tone = off ? "accent" : pressureTone(source.usagePercentage);
@@ -699,6 +746,131 @@ export function buildStatusView(source: StatusViewSource, options: StatusViewOpt
     };
 }
 
+/** Short name for the reason, shown on the headline and in the reason row. */
+function unavailableLabel(reason: StatusUnavailableReason): string {
+    if (reason.kind === "rpc_error") return "server did not answer";
+    if (reason.kind === "not_tracked") {
+        return reason.cause === "home_directory" ? "home directory" : "memory paused";
+    }
+    if (reason.kind === "malformed") return "incomplete status data";
+    return "view error";
+}
+
+/** Full-width sentences explaining the reason and what to do about it. */
+function unavailableExplanation(
+    reason: StatusUnavailableReason,
+    versionNotice: string | null,
+): string[] {
+    const persists = "If this persists after a restart, report it with magic-context.log attached.";
+    if (reason.kind === "rpc_error") {
+        return [
+            `The Magic Context server did not return status: ${reason.message}`,
+            renderUserFacingFailure("status_unavailable", "plain"),
+        ];
+    }
+    if (reason.kind === "not_tracked" && reason.cause === "home_directory") {
+        return [
+            "This is your home directory, so Magic Context keeps no project history or memory here.",
+            "Set allow_home_project in magic-context.jsonc to opt in.",
+        ];
+    }
+    if (reason.kind === "not_tracked") {
+        return [
+            "Magic Context could not work out a project identity for this directory, so its memory features are paused.",
+            'magic-context.log names the cause (search for "memory features paused"), for example a git command that failed.',
+        ];
+    }
+    if (reason.kind === "malformed") {
+        return [
+            `The status reply is missing, or has unexpected values for: ${reason.fields.join(", ")}.`,
+            versionNotice ? "The version difference above is the likely cause." : persists,
+        ];
+    }
+    return [`The status view could not be drawn: ${reason.message}`, persists];
+}
+
+/**
+ * The view drawn instead of the status when there is no usable snapshot. It has
+ * the same shape as a full view (headline, sections, warnings, footer), so a
+ * host draws it with the same code and cannot crash on a missing part.
+ */
+export function buildUnavailableStatusView(
+    reason: StatusUnavailableReason,
+    versions: StatusVersions | null,
+    options: StatusViewOptions,
+): StatusView {
+    const label = unavailableLabel(reason);
+    const versionNotice = statusVersionNotice(versions);
+    const rows: StatusRow[] = [{ label: "Reason", value: label, tone: "warning" }];
+    if (versions) {
+        rows.push(
+            { label: "Server", value: versions.server ?? "not reported", tone: "muted" },
+            { label: "UI", value: versions.ui, tone: "muted" },
+        );
+    }
+    return {
+        title: "⚡ Magic Context Status",
+        version: `v${options.version}`,
+        headline: {
+            left: { text: "Status unavailable", tone: "error" },
+            right: { text: label, tone: "muted" },
+        },
+        windowLine: null,
+        bar: [],
+        breakdown: [],
+        hygiene: null,
+        sections: [{ title: "Status unavailable", labelWidth: 8, rows }],
+        warnings: [
+            ...(versionNotice ? [{ text: versionNotice, tone: "error" as const }] : []),
+            ...unavailableExplanation(reason, versionNotice).map((text) => ({
+                text,
+                tone: "warning" as const,
+            })),
+        ],
+        footer: "Esc to close",
+    };
+}
+
+/**
+ * The view for one checked status result: the full status, or the
+ * "status unavailable" view naming why there is none. A version difference
+ * between the server and this UI is named in both. This never throws, so a
+ * host can call it inside a render without guarding it.
+ */
+export function buildStatusViewFor(
+    check: StatusCheck<unknown>,
+    options: StatusViewOptions,
+): StatusView {
+    if (check.state === "unavailable") {
+        return buildUnavailableStatusView(check.reason, check.versions, options);
+    }
+    try {
+        const view = buildStatusView(check.source, options);
+        const versionNotice = statusVersionNotice(check.versions);
+        const notices: StatusWarning[] = [
+            ...(versionNotice ? [{ text: versionNotice, tone: "warning" as const }] : []),
+            ...(check.ignoredFields.length > 0
+                ? [
+                      {
+                          text: `Ignored status fields with an unexpected shape: ${check.ignoredFields.join(", ")}`,
+                          tone: "warning" as const,
+                      },
+                  ]
+                : []),
+        ];
+        return notices.length > 0 ? { ...view, warnings: [...notices, ...view.warnings] } : view;
+    } catch (error) {
+        return buildUnavailableStatusView(
+            {
+                kind: "view_error",
+                message: error instanceof Error ? error.message : String(error),
+            },
+            check.versions,
+            options,
+        );
+    }
+}
+
 /** Pads one row to its section's label column; values print flush right. */
 export function formatStatusRowText(row: StatusRow, labelWidth: number, width: number): string {
     const label = row.label.padEnd(labelWidth);

package/src/shared/storage-busy.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -8,10 +8,11 @@ import {
     withAsyncPrivilegedWriter,
     withPrivilegedWriter,
 } from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 describe("writer acquisition", () => {
     test("exhausted async admission preserves the foreground budget and never invokes the callback", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mc-writer-budget-"));
+        const dir = createTestTempDirFromPath(join(tmpdir(), "mc-writer-budget-"));
         const path = join(dir, "context.db");
         const blocker = new Database(path);
         blocker.exec(

package/src/shared/tag-owner-id.test.ts

@@ -0,0 +1,33 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { contentTagOwnerMessageId } from "./tag-owner-id";
+
+const DIGEST_A = "a".repeat(64);
+const DIGEST_B = "0123456789abcdef".repeat(4);
+
+describe("contentTagOwnerMessageId", () => {
+    it("strips positional text and file suffixes", () => {
+        expect(contentTagOwnerMessageId("pi-msg-1:p0")).toBe("pi-msg-1");
+        expect(contentTagOwnerMessageId("pi-msg-1:p12")).toBe("pi-msg-1");
+        expect(contentTagOwnerMessageId("pi-msg-1:file3")).toBe("pi-msg-1");
+    });
+
+    it("strips a content-derived text suffix", () => {
+        expect(contentTagOwnerMessageId(`pi-msg-1:mc-text-v1:${DIGEST_A}:${DIGEST_B}:o0`)).toBe(
+            "pi-msg-1",
+        );
+        expect(
+            contentTagOwnerMessageId(`m:with:colons:mc-text-v1:${DIGEST_A}:${DIGEST_B}:o7`),
+        ).toBe("m:with:colons");
+    });
+
+    it("leaves an id with no content suffix unchanged", () => {
+        expect(contentTagOwnerMessageId("pi-msg-1")).toBe("pi-msg-1");
+        expect(contentTagOwnerMessageId("pi-msg-1:pfile")).toBe("pi-msg-1:pfile");
+        // A marker without the digest shape is not a content-derived id.
+        expect(contentTagOwnerMessageId("pi-msg-1:mc-text-v1:not-hex")).toBe(
+            "pi-msg-1:mc-text-v1:not-hex",
+        );
+    });
+});

package/src/shared/tag-owner-id.ts

@@ -0,0 +1,29 @@
+/**
+ * Content tag ids name the message that owns them plus a suffix that picks one
+ * part of it. Two suffix families exist:
+ *
+ * - positional: `<messageId>:p<N>` for the Nth text part, `<messageId>:file<N>`
+ *   for the Nth file part;
+ * - content-derived (Pi, after the text of a message drifts):
+ *   `<messageId>:mc-text-v1:<vector digest>:<content digest>:o<occurrence>`.
+ *
+ * Anything that groups tags by message has to strip both, or a content-derived
+ * tag is treated as belonging to a message that does not exist.
+ */
+
+export const TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
+
+const POSITIONAL_CONTENT_SUFFIX = /:(?:p|file)\d+$/;
+const CONTENT_DERIVED_TEXT_SUFFIX = /:mc-text-v1:[0-9a-f]+:[0-9a-f]+:o\d+$/;
+
+/**
+ * The owning message id of a content tag id. An id with neither suffix is
+ * returned unchanged: it already is the message id.
+ */
+export function contentTagOwnerMessageId(contentId: string): string {
+    const positional = POSITIONAL_CONTENT_SUFFIX.exec(contentId);
+    if (positional) return contentId.slice(0, positional.index);
+    const derived = CONTENT_DERIVED_TEXT_SUFFIX.exec(contentId);
+    if (derived) return contentId.slice(0, derived.index);
+    return contentId;
+}

package/src/shared/tag-transcript.ts

@@ -67,9 +67,11 @@ import {
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
 import { toolInputStringBytes } from "../hooks/magic-context/tool-input-size";
+import { TEXT_TAG_IDENTITY_MARKER } from "./tag-owner-id";
 import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript";
 
-export const TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
+// Re-exported so existing importers keep one source for the marker.
+export { TEXT_TAG_IDENTITY_MARKER };
 
 export interface TagTranscriptOptions {
     /**
@@ -972,7 +974,14 @@ function applyTextPrefixAndTarget(args: TagTextPartArgs, tagId: number, text: st
     }
 
     const targetStart = args.timing ? performance.now() : 0;
-    args.targets.set(tagId, buildTextTarget(args.part, args.message));
+    args.targets.set(
+        tagId,
+        buildTextTarget(
+            args.part,
+            args.message,
+            args.skipPrefixInjection ? "" : prependTag(tagId, ""),
+        ),
+    );
     if (args.timing) args.timing.targets += performance.now() - targetStart;
 }
 
@@ -1307,8 +1316,10 @@ function buildAggregateTarget(
 function buildTextTarget(
     part: TranscriptPart,
     message: { info: { id?: string; role: string } },
+    textPrefix: string,
 ): TagTarget {
     return {
+        textPrefix,
         setContent(content: string): boolean {
             return part.setText(content);
         },

package/src/shared/test-temp-dir-policy.test.ts

@@ -0,0 +1,33 @@
+import { expect, it } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+const packagesRoot = resolve(import.meta.dir, "../../..");
+
+function testFiles(directory: string): string[] {
+    return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(directory, entry.name);
+        return entry.isDirectory()
+            ? testFiles(path)
+            : /\.(test|spec)\.[cm]?[jt]sx?$/.test(entry.name)
+              ? [path]
+              : [];
+    });
+}
+
+it("source tests allocate temporary directories only through the registered helper", () => {
+    // Ban the raw API name, including imports and aliases, rather than just one
+    // spelling of a call. Nested fixtures also need registration on setup failure.
+    const rawApi = new RegExp("\\b" + "mk" + "dtemp(?:Sync)?\\b");
+    const violations = readdirSync(packagesRoot, { withFileTypes: true }).flatMap((entry) => {
+        if (!entry.isDirectory()) return [];
+        const src = join(packagesRoot, entry.name, "src");
+        try {
+            return testFiles(src).filter((path) => rawApi.test(readFileSync(path, "utf8")));
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+            throw error;
+        }
+    });
+    expect(violations.map((path) => relative(packagesRoot, path))).toEqual([]);
+});

package/src/shared/test-temp-dir.test.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import {
     cleanupTestTempDir,
     createTestTempDir,
+    createTestTempDirFromPath,
     sweepStaleTestTempDirs,
     withTestTempDir,
 } from "./test-temp-dir";
@@ -21,6 +22,32 @@ function createFixtureRoot(): string {
 }
 
 describe("test temp directories", () => {
+    it("rejects labels that could escape the system temp directory", () => {
+        for (const label of [
+            "",
+            ".",
+            "..",
+            "../outside-",
+            "nested/path-",
+            "nested\\path-",
+            "nul\0-",
+        ]) {
+            expect(() => createTestTempDir(label)).toThrow("single path segments");
+        }
+    });
+    it("cleans and sweeps previously unknown labels", () => {
+        const root = createFixtureRoot();
+        const dir = createTestTempDirFromPath(join(root, "previously-unlisted-"));
+        expect(existsSync(dir)).toBe(true);
+        const old = new Date(Date.now() - 7_200_000);
+        utimesSync(dir, old, old);
+        expect(sweepStaleTestTempDirs({ tempDir: root })).toContain(dir);
+        expect(existsSync(dir)).toBe(false);
+        cleanupTestTempDir(dir);
+        const fixture = createTestTempDir("another-unlisted-");
+        fixture.cleanup();
+        expect(existsSync(fixture.dir)).toBe(false);
+    });
     it("removes a root when its fixture callback throws", () => {
         let directory = "";
 

package/src/shared/test-temp-dir.ts

@@ -44,7 +44,8 @@ export const TEST_TEMP_DIR_PREFIXES = [
     "mc-test-db-backstop-",
 ] as const;
 
-export type TestTempDirPrefix = (typeof TEST_TEMP_DIR_PREFIXES)[number];
+export type TestTempDirPrefix = string;
+const OWNED_PREFIX = "mc-test-owned-";
 
 type AfterAll = (callback: () => void) => void;
 type SweepOptions = {
@@ -55,18 +56,18 @@ type SweepOptions = {
 
 const registeredTempDirs = new Set<string>();
 let lifecycleCleanupInstalled = false;
+let exitCleanupInstalled = false;
 
 function hasRecognizedPrefix(name: string): boolean {
-    return TEST_TEMP_DIR_PREFIXES.some((prefix) => name.startsWith(prefix));
+    return (
+        name.startsWith(OWNED_PREFIX) ||
+        TEST_TEMP_DIR_PREFIXES.some((prefix) => name.startsWith(prefix))
+    );
 }
 
 function isRegisteredTempDir(directory: string): boolean {
     const resolvedDirectory = resolve(directory);
-    return (
-        registeredTempDirs.has(resolvedDirectory) &&
-        dirname(resolvedDirectory) === resolve(tmpdir()) &&
-        hasRecognizedPrefix(basename(resolvedDirectory))
-    );
+    return registeredTempDirs.has(resolvedDirectory);
 }
 
 /**
@@ -78,17 +79,36 @@ export function createTestTempDir(
     prefix: TestTempDirPrefix,
     nameSuffix = "",
 ): { dir: string; cleanup: () => void } {
-    const dir = resolve(mkdtempSync(join(tmpdir(), `${prefix}${nameSuffix}`)));
-    registeredTempDirs.add(dir);
+    const label = prefix + nameSuffix;
+    if (!label || label === "." || label === ".." || /[/\\\0]/.test(label)) {
+        throw new Error("Test temp directory labels must be single path segments");
+    }
+    const dir = createTestTempDirFromPath(join(tmpdir(), `${prefix}${nameSuffix}`));
     return { dir, cleanup: () => cleanupTestTempDir(dir) };
 }
 
-/** Removes one registered test root and forgets it even when best-effort removal fails. */
+/**
+ * Registers fixtures with an explicit parent (including ADV_ROOT and nested roots).
+ * A common namespace lets the stale sweep recognize every system-temp fixture,
+ * without maintaining a list of caller-supplied labels.
+ */
+export function createTestTempDirFromPath(prefixPath: string): string {
+    const dir = resolve(
+        mkdtempSync(join(dirname(prefixPath), `${OWNED_PREFIX}${basename(prefixPath)}`)),
+    );
+    registeredTempDirs.add(dir);
+    if (!exitCleanupInstalled) {
+        exitCleanupInstalled = true;
+        process.once("exit", cleanupRegisteredTestTempDirs);
+    }
+    return dir;
+}
+
+/** Removes one registered test root; busy roots remain registered for an exit retry. */
 export function cleanupTestTempDir(directory: string): void {
     const resolvedDirectory = resolve(directory);
     if (!isRegisteredTempDir(resolvedDirectory)) return;
 
-    registeredTempDirs.delete(resolvedDirectory);
     try {
         rmSync(resolvedDirectory, {
             recursive: true,
@@ -96,6 +116,7 @@ export function cleanupTestTempDir(directory: string): void {
             maxRetries: 10,
             retryDelay: 100,
         });
+        registeredTempDirs.delete(resolvedDirectory);
     } catch {
         // A process can still hold a file open on Windows. The next startup sweep retries it.
     }
@@ -131,7 +152,10 @@ export function installTestTempDirCleanup(afterAll: AfterAll): void {
     if (lifecycleCleanupInstalled) return;
     lifecycleCleanupInstalled = true;
     afterAll(cleanupRegisteredTestTempDirs);
-    process.once("exit", cleanupRegisteredTestTempDirs);
+    if (!exitCleanupInstalled) {
+        exitCleanupInstalled = true;
+        process.once("exit", cleanupRegisteredTestTempDirs);
+    }
 }
 
 /**

package/src/shared/tui-config.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 const roots: string[] = [];
 afterEach(() => {
@@ -12,7 +13,7 @@ afterEach(() => {
 
 describe("ensureTuiPluginEntry", () => {
     it("preserves tuple dev-path plugin entry and does not add @latest", async () => {
-        const root = mkdtempSync(join(tmpdir(), "mc-tui-"));
+        const root = createTestTempDirFromPath(join(tmpdir(), "mc-tui-"));
         roots.push(root);
         const devPath = "/Work/magic-context/packages/plugin";
         const tuiPath = join(root, "tui.json");
@@ -33,7 +34,7 @@ describe("ensureTuiPluginEntry", () => {
     });
 
     it("upgrades bare npm name to @latest while preserving tuple options", async () => {
-        const root = mkdtempSync(join(tmpdir(), "mc-tui-npm-"));
+        const root = createTestTempDirFromPath(join(tmpdir(), "mc-tui-npm-"));
         roots.push(root);
         const tuiPath = join(root, "tui.json");
         writeFileSync(
@@ -56,7 +57,7 @@ describe("ensureTuiPluginEntry", () => {
     });
 
     it("creates tui.jsonc (not tui.json) on a fresh install", async () => {
-        const root = mkdtempSync(join(tmpdir(), "mc-tui-fresh-"));
+        const root = createTestTempDirFromPath(join(tmpdir(), "mc-tui-fresh-"));
         roots.push(root);
 
         const { ensureTuiPluginEntry } = await import("./tui-config");
@@ -73,7 +74,7 @@ describe("ensureTuiPluginEntry", () => {
     });
 
     it("writes into the existing tui.jsonc when both files exist", async () => {
-        const root = mkdtempSync(join(tmpdir(), "mc-tui-both-"));
+        const root = createTestTempDirFromPath(join(tmpdir(), "mc-tui-both-"));
         roots.push(root);
         // A real user config in tui.jsonc plus a leftover empty tui.json.
         writeFileSync(

package/src/shared/tui-preferences.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { parse } from "comment-json";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 import {
     __resetTuiPreferencesWatchTestHooks,
     __setTuiPreferencesWatchTestHooks,
@@ -25,7 +26,7 @@ const ENV_KEYS = [TUI_PREFS_FILE_ENV, "OPENCODE_CONFIG_DIR", "XDG_CONFIG_HOME"];
 
 beforeEach(async () => {
     for (const key of ENV_KEYS) savedEnv[key] = process.env[key];
-    dir = await mkdtemp(join(tmpdir(), "mc-tui-prefs-test-"));
+    dir = await createTestTempDirFromPath(join(tmpdir(), "mc-tui-prefs-test-"));
     file = join(dir, "tui-preferences.jsonc");
     process.env[TUI_PREFS_FILE_ENV] = file;
 });