@cortexkit/opencode-magic-context 0.40.1 → 0.41.1

package/src/shared/logger.test.ts

@@ -18,45 +18,121 @@ type LoggerScenarioResult = {
     };
 };
 
+type RotationScenarioResult = {
+    firstCurrent: string;
+    firstPredecessorFirstByte: number;
+    current: string;
+    predecessorFirstByte: number;
+    predecessorSize: number;
+    currentSize: number;
+    currentMode: number;
+    predecessorMode: number;
+    files: string[];
+};
+
+type HotPathScenarioResult = {
+    statCalls: number;
+};
+
 const loggerScenario = `
-import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs";
 import * as path from "node:path";
+import { mock } from "bun:test";
 
 const root = process.env.LOGGER_SCENARIO_ROOT;
 const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
-if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+const scenario = process.env.LOGGER_SCENARIO;
+if (!root || !loggerModuleUrl || !scenario) {
+    throw new Error("logger scenario environment is incomplete");
+}
 
-const logger = await import(loggerModuleUrl);
 const logPath = path.join(root, "nested", "magic-context.log");
 process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
-logger.log("first");
-logger.flushLogger();
-const healthyDiagnostics = logger.getLoggerDiagnostics();
-
-const logDirectory = path.dirname(logPath);
-if (process.env.LOGGER_SCENARIO === "recovery") {
-    const { rmSync } = await import("node:fs");
-    rmSync(logDirectory, { recursive: true, force: true });
-    logger.log("second");
-    logger.flushLogger();
+let statCalls = 0;
+if (scenario === "hot-path") {
+    mock.module("node:fs", () => ({
+        ...fs,
+        statSync: (...args) => {
+            statCalls++;
+            return fs.statSync(...args);
+        },
+    }));
 }
 
-// A directory used as the file target makes append fail deterministically on every platform.
-const failedPath = path.join(root, "unwritable-log-target");
-const { mkdirSync } = await import("node:fs");
-mkdirSync(failedPath, { recursive: true });
-process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
-logger.log("failed write");
-logger.flushLogger();
-const failedDiagnostics = logger.getLoggerDiagnostics();
-
-const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
-console.log(JSON.stringify({
-    exists: existsSync(logPath),
-    content,
-    healthyDiagnostics,
-    failedDiagnostics,
-}));
+const logger = await import(loggerModuleUrl);
+
+if (scenario === "rotation") {
+    const maxLogBytes = 32 * 1024 * 1024;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "o"));
+    fs.chmodSync(logPath, 0o600);
+    fs.writeFileSync(logPath + ".1", "prior predecessor");
+
+    logger.log("after first rotation");
+    logger.flushLogger();
+    const firstCurrent = fs.readFileSync(logPath, "utf8");
+    const firstPredecessorFirstByte = fs.readFileSync(logPath + ".1")[0];
+
+    // Switch paths once so the logger rechecks the primary path after this
+    // external replacement, as a different plugin process would require.
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "n"));
+    process.env.MAGIC_CONTEXT_LOG_PATH = path.join(root, "alternate.log");
+    logger.log("alternate path");
+    logger.flushLogger();
+    process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+    logger.log("after second rotation");
+    logger.flushLogger();
+
+    const predecessorPath = logPath + ".1";
+    console.log(JSON.stringify({
+        firstCurrent,
+        firstPredecessorFirstByte,
+        current: fs.readFileSync(logPath, "utf8"),
+        predecessorFirstByte: fs.readFileSync(predecessorPath)[0],
+        predecessorSize: fs.statSync(predecessorPath).size,
+        currentSize: fs.statSync(logPath).size,
+        currentMode: fs.statSync(logPath).mode & 0o777,
+        predecessorMode: fs.statSync(predecessorPath).mode & 0o777,
+        files: fs.readdirSync(path.dirname(logPath)).filter((name) => name.startsWith("magic-context.log")).sort(),
+    }));
+} else if (scenario === "hot-path") {
+    for (let index = 0; index < 20; index++) {
+        logger.log("hot-path-" + index);
+        logger.flushLogger();
+    }
+    console.log(JSON.stringify({ statCalls }));
+} else {
+    logger.log("first");
+    logger.log(
+        "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
+        { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
+    );
+    logger.flushLogger();
+    const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+    const logDirectory = path.dirname(logPath);
+    if (scenario === "recovery") {
+        fs.rmSync(logDirectory, { recursive: true, force: true });
+        logger.log("second");
+        logger.flushLogger();
+    }
+
+    // A directory used as the file target makes append fail deterministically on every platform.
+    const failedPath = path.join(root, "unwritable-log-target");
+    fs.mkdirSync(failedPath, { recursive: true });
+    process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+    logger.log("failed write");
+    logger.flushLogger();
+    const failedDiagnostics = logger.getLoggerDiagnostics();
+
+    const content = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
+    console.log(JSON.stringify({
+        exists: fs.existsSync(logPath),
+        content,
+        healthyDiagnostics,
+        failedDiagnostics,
+    }));
+}
 `;
 
 const scenarioRoots: string[] = [];
@@ -67,9 +143,9 @@ afterEach(() => {
     }
 });
 
-async function runLoggerScenario(
-    scenario: "recovery" | "diagnostics",
-): Promise<LoggerScenarioResult> {
+async function runLoggerScenario<T>(
+    scenario: "recovery" | "diagnostics" | "rotation" | "hot-path",
+): Promise<T> {
     const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
     scenarioRoots.push(root);
     const child = Bun.spawn({
@@ -91,19 +167,53 @@ async function runLoggerScenario(
         new Response(child.stderr).text(),
     ]);
     expect(exitCode, stderr).toBe(0);
-    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+    return JSON.parse(stdout.trim()) as T;
 }
 
 describe("logger", () => {
     test("recreates a log directory removed while the process is running", async () => {
-        const result = await runLoggerScenario("recovery");
+        const result = await runLoggerScenario<LoggerScenarioResult>("recovery");
 
         expect(result.exists).toBe(true);
         expect(result.content).toContain("second");
     });
 
+    test("redacts secrets while preserving numeric diagnostics", async () => {
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
+
+        expect(result.content).toContain("tokens.input=45000");
+        expect(result.content).toContain('"totalInputTokens":132000');
+        expect(result.content).toContain("<REDACTED:api_key>");
+        expect(result.content).toContain("<REDACTED:authorization>");
+        expect(result.content).not.toContain("abcdefghijklmnopqrstuvwxyzABCDEFGH");
+        expect(result.content).not.toContain("abcdefghijklmnop");
+    });
+
+    test("rotates at the 32 MiB bound with one private predecessor", async () => {
+        const result = await runLoggerScenario<RotationScenarioResult>("rotation");
+        const maxLogBytes = 32 * 1024 * 1024;
+
+        expect(result.firstCurrent).toContain("after first rotation");
+        expect(result.firstPredecessorFirstByte).toBe("o".charCodeAt(0));
+        expect(result.current).toContain("after second rotation");
+        expect(result.predecessorFirstByte).toBe("n".charCodeAt(0));
+        expect(result.predecessorSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.currentSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.files).toEqual(["magic-context.log", "magic-context.log.1"]);
+        if (process.platform !== "win32") {
+            expect(result.currentMode).toBe(0o600);
+            expect(result.predecessorMode).toBe(0o600);
+        }
+    });
+
+    test("uses cached size between periodic rotation checks", async () => {
+        const result = await runLoggerScenario<HotPathScenarioResult>("hot-path");
+
+        expect(result.statCalls).toBeLessThanOrEqual(1);
+    });
+
     test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
-        const result = await runLoggerScenario("diagnostics");
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
 
         expect(result.healthyDiagnostics).toEqual({
             swallowedWriteCount: 0,

package/src/shared/logger.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getMagicContextLogPath } from "./data-path";
+import { sanitizeConfigValue, sanitizeDiagnosticText } from "./redaction";
 
 const isTestEnv = process.env.NODE_ENV === "test";
 
@@ -8,6 +9,12 @@ let buffer: string[] = [];
 let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
+const MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+const SIZE_CHECK_INTERVAL_FLUSHES = 64;
+
+let activeLogFile: string | null = null;
+let activeLogSize: number | null = null;
+let flushesSinceSizeCheck = 0;
 
 export interface LoggerDiagnostics {
     swallowedWriteCount: number;
@@ -22,7 +29,9 @@ let lastErrorTime: string | null = null;
 function recordSwallowedWrite(error: unknown): void {
     try {
         swallowedWriteCount++;
-        lastErrorMessage = error instanceof Error ? error.message : String(error);
+        lastErrorMessage = sanitizeDiagnosticText(
+            error instanceof Error ? error.message : String(error),
+        );
         lastErrorTime = new Date().toISOString();
     } catch {
         // Diagnostics must not make the logger throw either.
@@ -33,19 +42,126 @@ function ensureDir(filePath: string): void {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
+function isMissingFile(error: unknown): boolean {
+    return (
+        typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error as { code?: unknown }).code === "ENOENT"
+    );
+}
+
+function getCurrentLogSize(logFile: string): number {
+    if (
+        activeLogFile === logFile &&
+        activeLogSize !== null &&
+        flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES
+    ) {
+        return activeLogSize;
+    }
+
+    try {
+        const stat = fs.statSync(logFile);
+        if (!stat.isFile()) {
+            throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+        }
+        // Logs can contain diagnostic context, so tighten files created by older
+        // versions before copying or appending any new content.
+        fs.chmodSync(logFile, 0o600);
+        activeLogFile = logFile;
+        activeLogSize = stat.size;
+        flushesSinceSizeCheck = 0;
+        return stat.size;
+    } catch (error) {
+        if (!isMissingFile(error)) throw error;
+        activeLogFile = logFile;
+        activeLogSize = 0;
+        flushesSinceSizeCheck = 0;
+        return 0;
+    }
+}
+
+function capLogData(data: string): string {
+    if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES) return data;
+
+    // A single diagnostic payload must not defeat the on-disk bound. Cutting a
+    // Buffer can split UTF-8, so trim any replacement character expansion too.
+    let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+    while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+        bounded = bounded.slice(0, -1);
+    }
+    return bounded;
+}
+
+function writeBoundedPredecessor(logFile: string, predecessorPath: string, size: number): void {
+    const predecessorFd = fs.openSync(predecessorPath, "w", 0o600);
+    try {
+        // `openSync(..., "w")` preserves an existing file's mode, so set it
+        // before any copied diagnostic text reaches the predecessor.
+        fs.fchmodSync(predecessorFd, 0o600);
+        const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+        const sourceFd = fs.openSync(logFile, "r");
+        try {
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+            let remaining = bytesToCopy;
+            let position = Math.max(0, size - bytesToCopy);
+            while (remaining > 0) {
+                const bytesRead = fs.readSync(
+                    sourceFd,
+                    chunk,
+                    0,
+                    Math.min(chunk.length, remaining),
+                    position,
+                );
+                if (bytesRead === 0) break;
+                fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+                remaining -= bytesRead;
+                position += bytesRead;
+            }
+        } finally {
+            fs.closeSync(sourceFd);
+        }
+    } finally {
+        fs.closeSync(predecessorFd);
+    }
+}
+
+function rotateLogFile(logFile: string, size: number): void {
+    const predecessorPath = `${logFile}.1`;
+    writeBoundedPredecessor(logFile, predecessorPath, size);
+    // Keep the current inode in place so diagnostic readers can observe a
+    // shorter log during rotation instead of seeing the path disappear.
+    fs.truncateSync(logFile, 0);
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
         flushTimer = null;
     }
     if (buffer.length === 0) return;
-    const data = buffer.join("");
+    const bufferedData = buffer.join("");
     buffer = [];
     try {
+        const data = capLogData(bufferedData);
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
-        fs.appendFileSync(logFile, data);
+        let currentSize = getCurrentLogSize(logFile);
+        const dataSize = Buffer.byteLength(data);
+        if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+            rotateLogFile(logFile, currentSize);
+            currentSize = 0;
+        }
+        fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 0o600 });
+        activeLogFile = logFile;
+        activeLogSize = currentSize + dataSize;
+        flushesSinceSizeCheck++;
     } catch (error) {
+        activeLogFile = null;
+        activeLogSize = null;
+        flushesSinceSizeCheck = 0;
         recordSwallowedWrite(error);
     }
 }
@@ -66,9 +182,11 @@ export function log(message: string, data?: unknown): void {
             data === undefined
                 ? ""
                 : data instanceof Error
-                  ? ` ${data.message}${data.stack ? `\n${data.stack}` : ""}`
-                  : ` ${JSON.stringify(data)}`;
-        buffer.push(`[${timestamp}] ${message}${serialized}\n`);
+                  ? ` ${sanitizeDiagnosticText(
+                        `${data.message}${data.stack ? `\n${data.stack}` : ""}`,
+                    )}`
+                  : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
+        buffer.push(`[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}\n`);
         if (buffer.length >= BUFFER_SIZE_LIMIT) {
             flush();
         } else {

package/src/shared/model-resolution.test.ts

@@ -4,10 +4,29 @@ import {
     normalizeModelEntry,
     resolveDreamerTaskModel,
     resolveFallbackEntries,
+    resolveHistorianAgentOverrides,
     resolveHistorianModel,
 } from "./model-resolution";
 
 describe("model-resolution", () => {
+    test("keeps historian temperature opt-in while preserving explicit overrides", () => {
+        expect(resolveHistorianAgentOverrides(undefined)).toEqual({
+            maxTokens: 32_000,
+        });
+        expect(
+            resolveHistorianAgentOverrides({
+                temperature: 0.2,
+                maxTokens: 16_000,
+                opencode: { model: "google/flash", variant: "low" },
+            }),
+        ).toEqual({
+            temperature: 0.2,
+            maxTokens: 16_000,
+            model: "google/flash",
+            variant: "low",
+        });
+    });
+
     test("normalizes string and object entries to the same model identity", () => {
         expect(normalizeModelEntry("anthropic/sonnet", "opencode")).toEqual({
             model: "anthropic/sonnet",
@@ -36,6 +55,24 @@ describe("model-resolution", () => {
         ]);
     });
 
+    test("keeps the flash calibration available only as an explicit override", () => {
+        expect(
+            resolveHistorianAgentOverrides({
+                opencode: { model: { model: "google/flash", variant: "fast" } },
+                pi: { model: "pi/ignored" },
+                two_pass: true,
+            }),
+        ).toEqual({
+            maxTokens: 32_000,
+            two_pass: true,
+            model: "google/flash",
+            variant: "fast",
+        });
+        expect(
+            resolveHistorianAgentOverrides({ temperature: 0.1, maxTokens: 12_000 }),
+        ).toMatchObject({ temperature: 0.1, maxTokens: 12_000 });
+    });
+
     test("does not inherit a block qualifier into unqualified fallbacks", () => {
         const config = {
             historian: {

package/src/shared/model-resolution.ts

@@ -225,3 +225,10 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         ...(primary?.qualifier ? { variant: primary.qualifier } : {}),
     };
 }
+
+export function resolveHistorianAgentOverrides(agent: unknown): Record<string, unknown> {
+    return {
+        maxTokens: 32_000,
+        ...resolveOpenCodeAgentOverrides(agent),
+    };
+}

package/src/shared/redaction.ts

@@ -108,7 +108,7 @@ export function isSecretKey(key: string): boolean {
 }
 
 export function sanitizePathString(value: string): string {
-    const home = homedir();
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
     const username = userInfo().username;
     let sanitized = value;
     if (home) {
@@ -132,7 +132,7 @@ const SECRET_TEXT_PATTERNS: Array<{
         replacement: "<ANTHROPIC_API_KEY_REDACTED>",
     },
     {
-        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}/g,
+        pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{12,}/g,
         replacement: "<OPENAI_API_KEY_REDACTED>",
     },
     {

package/src/shared/rpc-types.ts

@@ -141,12 +141,17 @@ export interface SidebarSnapshot {
 }
 
 export interface StatusDetail extends SidebarSnapshot {
+    /** True when Rust authority has rerouted host tool and historian paths to the module. */
+    hostBackendsModuleSide?: boolean;
     /** User-owned model profile selected for this project, or null for the base config. */
     activeProfile: string | null;
     tagCounter: number;
     activeTags: number;
     droppedTags: number;
     totalTags: number;
+    /** False when Rust authority supplies only the exact total; active/dropped host-mirror
+     *  counts are not presented as module truth. Omitted by older RPC servers means true. */
+    tagCountsAuthoritative?: boolean;
     activeBytes: number;
     lastResponseTime: number;
     lastNudgeTokens: number;

package/src/shared/rust-mode-status.ts

@@ -0,0 +1,3 @@
+/** User-visible paths that move out of the host when Rust authority is active. */
+export const RUST_MODE_HOST_PATHS_LINE =
+    "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side";

package/src/shared/status-detail-text.test.ts

@@ -79,4 +79,17 @@ describe("formatStatusDetailMarkdown", () => {
 - **Tags:** 4 active, 1 dropped; 2 pending drops
 - **Execute threshold:** 65.0%`);
     });
+
+    test("shows module-routed host paths only in Rust-mode chat fallback", () => {
+        const rustStatus = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            hostBackendsModuleSide: true,
+        });
+        const tsStatus = formatStatusDetailMarkdown(STATUS_FIXTURE);
+
+        expect(rustStatus).toContain(
+            "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side",
+        );
+        expect(tsStatus).not.toContain("Host backends → MODULE");
+    });
 });

package/src/shared/status-detail-text.ts

@@ -1,4 +1,5 @@
 import type { StatusDetail } from "./rpc-types";
+import { RUST_MODE_HOST_PATHS_LINE } from "./rust-mode-status";
 
 function formatCount(value: number): string {
     return Math.round(value).toLocaleString();
@@ -39,6 +40,7 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
         `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
         `- **Cache lane:** ${formatCacheLane(detail)}`,
         `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,
+        ...(detail.hostBackendsModuleSide ? [`- ${RUST_MODE_HOST_PATHS_LINE}`] : []),
         `- **Memory:** ${formatCount(detail.memoryCount)} active; ${formatCount(detail.memoryBlockCount)} injected`,
         `- **Tags:** ${formatCount(detail.activeTags)} active, ${formatCount(detail.droppedTags)} dropped; ${formatCount(detail.pendingOpsCount)} pending drops`,
         `- **Execute threshold:** ${detail.executeThreshold.toFixed(1)}%${detail.executeThresholdClamped ? " (clamped)" : ""}`,

package/src/shared/subagent-runner.ts

@@ -67,6 +67,10 @@ export interface SubagentRunOptions {
     model?: string | undefined;
     fallbackModels?: readonly ModelInput[];
     timeoutMs?: number | undefined;
+    /** Sampling temperature for the provider request when the harness can enforce it. */
+    temperature?: number | undefined;
+    /** Requested output-token budget for the provider request. */
+    maxOutputTokens?: number | undefined;
     cwd?: string | undefined;
     signal?: AbortSignal | undefined;
     /**

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

@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import {
+    cleanupTestTempDir,
+    createTestTempDir,
+    sweepStaleTestTempDirs,
+    withTestTempDir,
+} from "./test-temp-dir";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+    for (const directory of tempDirs.splice(0)) cleanupTestTempDir(directory);
+});
+
+function createFixtureRoot(): string {
+    const { dir } = createTestTempDir("mc-test-temp-dir-helper-");
+    tempDirs.push(dir);
+    return dir;
+}
+
+describe("test temp directories", () => {
+    it("removes a root when its fixture callback throws", () => {
+        let directory = "";
+
+        expect(() =>
+            withTestTempDir("mc-test-temp-dir-helper-", (tempDir) => {
+                directory = tempDir;
+                throw new Error("fixture setup failed");
+            }),
+        ).toThrow("fixture setup failed");
+
+        expect(existsSync(directory)).toBe(false);
+    });
+
+    it("sweeps only aged directories with recognized prefixes", () => {
+        const root = createFixtureRoot();
+        const staleRecognized = join(root, "mc-config-secret-stale");
+        const freshRecognized = join(root, "mc-config-secret-fresh");
+        const staleBystander = join(root, "unrelated-tool-stale");
+        const nowMs = Date.now();
+
+        for (const directory of [staleRecognized, freshRecognized, staleBystander]) {
+            mkdirSync(directory);
+        }
+        utimesSync(staleRecognized, new Date(nowMs - 7_200_000), new Date(nowMs - 7_200_000));
+        utimesSync(staleBystander, new Date(nowMs - 7_200_000), new Date(nowMs - 7_200_000));
+
+        const removed = sweepStaleTestTempDirs({ tempDir: root, nowMs });
+
+        expect(removed).toEqual([staleRecognized]);
+        expect(existsSync(staleRecognized)).toBe(false);
+        expect(existsSync(freshRecognized)).toBe(true);
+        expect(existsSync(staleBystander)).toBe(true);
+    });
+});