summer-engine 2.6.6 → 2.8.0

package/dist/lib/debug-report.js

@@ -0,0 +1,308 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { hostname, platform, release } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { EngineApiClient } from "./api-client.js";
+import { shapeEngineLogResponse } from "./log-filters.js";
+import { tildeify } from "./format.js";
+import { getMcpLogPath, readRecentMcpLogLines } from "./mcp-log.js";
+import { runDoctor } from "../commands/doctor.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../../package.json");
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function timestampForFile(date) {
+    return date.toISOString().replace(/[:.]/g, "-");
+}
+export function defaultDebugReportFilename(date = new Date()) {
+    return `summer-debug-report-${timestampForFile(date)}.md`;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function pickString(value, keys) {
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === "string" && candidate.length > 0)
+            return candidate;
+    }
+    return null;
+}
+function projectPathFromReport(report) {
+    return pickString(report.engine.health, ["project_path", "projectPath", "projectRoot", "project_root"]);
+}
+function resolveOutputPath(report, options) {
+    if (options.outputPath) {
+        return isAbsolute(options.outputPath)
+            ? options.outputPath
+            : resolve(process.cwd(), options.outputPath);
+    }
+    const baseDir = options.baseDir ?? projectPathFromReport(report) ?? process.cwd();
+    return join(baseDir, defaultDebugReportFilename(new Date(report.generatedAt)));
+}
+async function writeMarkdown(path, markdown) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, markdown, "utf-8");
+}
+async function safeCollect(label, fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        return {
+            ok: false,
+            label,
+            error: errorMessage(error),
+        };
+    }
+}
+function firstOpsResult(value) {
+    const root = asRecord(value);
+    const results = root?.results;
+    if (Array.isArray(results) && results.length > 0) {
+        return asRecord(results[0]);
+    }
+    return root;
+}
+function isGamePlaying(value) {
+    return firstOpsResult(value)?.playing === true;
+}
+async function collectConsole(client, maxConsoleLines) {
+    const raw = await client.executeOps([
+        { op: "GetConsoleOutput", max_lines: maxConsoleLines },
+    ]);
+    return shapeEngineLogResponse(raw, {
+        errorsOnly: false,
+        maxEntries: maxConsoleLines,
+    }).result;
+}
+async function collectDebugger(client, type, maxEntries) {
+    const op = {
+        op: "GetDebuggerErrors",
+        max_errors: maxEntries,
+        include_stack: true,
+    };
+    if (type === "warning")
+        op.type = "warning";
+    const raw = await client.executeOps([op]);
+    return shapeEngineLogResponse(raw, { maxEntries }).result;
+}
+async function collectPlaySession(client, options) {
+    const session = {
+        requested: true,
+        waitMs: options.playWaitMs,
+    };
+    session.before = await safeCollect("is-running-before", () => client.executeOps([{ op: "IsGameRunning" }]));
+    const wasPlaying = isGamePlaying(session.before);
+    session.wasPlayingBefore = wasPlaying;
+    if (wasPlaying) {
+        session.note =
+            "Game was already running. Collected current runtime diagnostics without clearing console, launching, or stopping.";
+    }
+    else {
+        session.clearConsole = await safeCollect("clear-console", () => client.executeOps([{ op: "ClearConsoleOutput" }]));
+        session.play = await safeCollect("play", () => client.play());
+    }
+    await sleep(options.playWaitMs);
+    session.diagnostics = await safeCollect("diagnostics-after-play", () => client.getDiagnostics());
+    session.console = await safeCollect("console-after-play", () => collectConsole(client, options.maxConsoleLines));
+    session.debuggerErrors = await safeCollect("debugger-errors-after-play", () => collectDebugger(client, "error", options.maxDebuggerEntries));
+    session.debuggerWarnings = await safeCollect("debugger-warnings-after-play", () => collectDebugger(client, "warning", options.maxDebuggerEntries));
+    if (!wasPlaying) {
+        session.stop = await safeCollect("stop", () => client.stop());
+    }
+    return session;
+}
+function redact(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redact(item));
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (/token|secret|password|authorization|cookie|api[-_]?key|hostname/i.test(key)) {
+            out[key] = "[REDACTED]";
+        }
+        else {
+            out[key] = redact(nested);
+        }
+    }
+    return out;
+}
+export function redactDebugReport(report) {
+    return redact(report);
+}
+function jsonBlock(value) {
+    return `\`\`\`json\n${JSON.stringify(redact(value), null, 2)}\n\`\`\``;
+}
+function doctorSummary(doctor) {
+    if (!doctor)
+        return "Doctor was skipped.";
+    return `${doctor.summary.failures} failures, ${doctor.summary.warnings} warnings, ${doctor.summary.ok} OK.`;
+}
+function issueText(issue) {
+    return issue && issue.trim().length > 0 ? issue.trim() : "No issue text provided.";
+}
+export function renderDebugReportMarkdown(report) {
+    const health = asRecord(report.engine.health);
+    const projectName = pickString(health, ["project_name", "projectName"]) ?? "unknown";
+    const projectPath = pickString(health, ["project_path", "projectPath"]) ?? "unknown";
+    const scene = pickString(health, ["scene", "scenePath", "scene_path"]) ?? "unknown";
+    return `# Summer Debug Report
+
+Generated: ${report.generatedAt}
+
+## Before Sending
+
+This report is meant for Summer Engine support or an assisting AI agent. It does not include auth tokens or project file contents, but it may include local paths, project names, console output, and stack traces. Review it before sending.
+
+## User Issue
+
+${issueText(report.issue)}
+
+## Quick Summary
+
+- Doctor: ${doctorSummary(report.doctor)}
+- Engine connected: ${report.engine.connected ? "yes" : "no"}
+- Project: ${projectName}
+- Project path: ${tildeify(projectPath)}
+- Scene: ${scene}
+
+## Environment
+
+${jsonBlock({
+        ...report.environment,
+        cwd: tildeify(report.environment.cwd),
+        hostname: report.environment.hostname ? "[local-hostname-present]" : "",
+    })}
+
+## Doctor Checks
+
+${report.doctor ? jsonBlock(report.doctor) : "Doctor was skipped."}
+
+## MCP Lifecycle Log
+
+Log path: ${tildeify(report.mcp.logPath)}
+
+${report.mcp.recentLog.length > 0 ? `\`\`\`jsonl\n${report.mcp.recentLog.join("\n")}\n\`\`\`` : "No MCP lifecycle log entries found."}
+
+## Engine Health
+
+${report.engine.health ? jsonBlock(report.engine.health) : report.engine.error ?? "Engine was not reachable."}
+
+## Project State
+
+${report.engine.project ? jsonBlock(report.engine.project) : "No project state collected."}
+
+## Scene State
+
+${report.engine.scene ? jsonBlock(report.engine.scene) : "No scene state collected."}
+
+## Diagnostics
+
+${report.engine.diagnostics ? jsonBlock(report.engine.diagnostics) : "No diagnostics collected."}
+
+## Console
+
+${report.engine.console ? jsonBlock(report.engine.console) : "No console output collected."}
+
+## Debugger Errors
+
+${report.engine.debuggerErrors ? jsonBlock(report.engine.debuggerErrors) : "No debugger errors collected."}
+
+## Debugger Warnings
+
+${report.engine.debuggerWarnings ? jsonBlock(report.engine.debuggerWarnings) : "No debugger warnings collected."}
+
+## Play Session
+
+${report.engine.playSession ? jsonBlock(report.engine.playSession) : "No play session requested. Re-run with --play if the issue only appears while the game is running."}
+
+## Agent Handoff Prompt
+
+\`\`\`text
+You are debugging a Summer Engine project. Use the Summer debug skill and this report as the starting evidence.
+
+User issue:
+${issueText(report.issue)}
+
+Process:
+1. Start with the collected diagnostics, console output, and debugger errors in this report.
+2. Form one specific hypothesis before editing.
+3. Ask before making project changes.
+4. After a fix, re-run the diagnostic that found the issue and update the report or final answer with the exact evidence.
+\`\`\`
+`;
+}
+export async function collectDebugReport(options = {}) {
+    const generatedAt = new Date().toISOString();
+    const includeDoctor = options.includeDoctor ?? true;
+    const report = {
+        generatedAt,
+        issue: options.issue?.trim() || null,
+        environment: {
+            cliVersion: version,
+            nodeVersion: process.version,
+            platform: platform(),
+            release: release(),
+            cwd: process.cwd(),
+            hostname: hostname(),
+        },
+        doctor: null,
+        mcp: {
+            logPath: getMcpLogPath(),
+            recentLog: [],
+        },
+        engine: {
+            connected: false,
+        },
+    };
+    if (includeDoctor) {
+        report.doctor = await runDoctor({ quiet: true });
+    }
+    report.mcp.recentLog = await readRecentMcpLogLines();
+    let client;
+    try {
+        client = await EngineApiClient.connect();
+        report.engine.connected = true;
+    }
+    catch (error) {
+        report.engine.error = errorMessage(error);
+        report.mcp.recentLog = await readRecentMcpLogLines();
+        return report;
+    }
+    const maxConsoleLines = options.maxConsoleLines ?? 200;
+    const maxDebuggerEntries = options.maxDebuggerEntries ?? 100;
+    report.engine.health = await safeCollect("health", () => client.health());
+    report.engine.project = await safeCollect("project-state", () => client.getProjectState());
+    report.engine.scene = await safeCollect("scene-state", () => client.getSceneState());
+    report.engine.diagnostics = await safeCollect("diagnostics", () => client.getDiagnostics());
+    report.engine.console = await safeCollect("console", () => collectConsole(client, maxConsoleLines));
+    report.engine.debuggerErrors = await safeCollect("debugger-errors", () => collectDebugger(client, "error", maxDebuggerEntries));
+    report.engine.debuggerWarnings = await safeCollect("debugger-warnings", () => collectDebugger(client, "warning", maxDebuggerEntries));
+    if (options.includePlaySession) {
+        report.engine.playSession = await collectPlaySession(client, {
+            playWaitMs: options.playWaitMs ?? 2500,
+            maxConsoleLines,
+            maxDebuggerEntries,
+        });
+    }
+    report.mcp.recentLog = await readRecentMcpLogLines();
+    return report;
+}
+export async function createDebugReportArtifact(options = {}) {
+    const report = await collectDebugReport(options);
+    const markdown = renderDebugReportMarkdown(report);
+    const path = resolveOutputPath(report, options);
+    await writeMarkdown(path, markdown);
+    return { path, markdown, report };
+}

package/dist/lib/engine.d.ts

@@ -1,5 +1,38 @@
-export declare function getApiToken(): Promise<string | null>;
-export declare function getApiPort(): Promise<number>;
+export interface EngineSelection {
+    instanceId?: string;
+    projectPath?: string;
+    cwd?: string;
+}
+export interface EngineDiscoveryOptions {
+    summerDir?: string;
+    nowMs?: number;
+}
+export interface EngineInstance {
+    schemaVersion: 1;
+    instanceId: string;
+    pid: number;
+    port: number;
+    token: string;
+    projectId?: string;
+    projectIdHash?: string;
+    resourceRoot: string;
+    projectName?: string;
+    heartbeatAt: number;
+    engineVersion?: string;
+}
+export interface EngineConnection {
+    port: number;
+    token: string;
+    health: EngineHealth;
+    instance?: EngineInstance;
+    selection: EngineSelection | null;
+    source: "registry" | "legacy";
+}
+export declare function getApiToken(summerDir?: string): Promise<string | null>;
+export declare function getApiPort(summerDir?: string): Promise<number>;
+export declare function findProjectRoot(startPath: string): Promise<string | null>;
+export declare function listEngineInstances(nowMs?: number, summerDir?: string): Promise<EngineInstance[]>;
+export declare function resolveEngineConnection(selection?: EngineSelection, options?: EngineDiscoveryOptions): Promise<EngineConnection>;
 export interface EngineHealth {
     ok: boolean;
     engine: string;

package/dist/lib/engine.js

@@ -1,19 +1,22 @@
-import { readFile } from "fs/promises";
-import { join } from "path";
+import { lstat, readFile, readdir, realpath, stat } from "fs/promises";
+import { dirname, join, resolve } from "path";
 import { getSummerDir } from "./auth.js";
 const DEFAULT_PORT = 6550;
-export async function getApiToken() {
+const INSTANCE_SCHEMA_VERSION = 1;
+const INSTANCE_STALE_MS = 180_000;
+const MAX_INSTANCE_FILE_BYTES = 64 * 1024;
+export async function getApiToken(summerDir = getSummerDir()) {
     try {
-        const token = await readFile(join(getSummerDir(), "api-token"), "utf-8");
+        const token = await readFile(join(summerDir, "api-token"), "utf-8");
         return token.trim() || null;
     }
     catch {
         return null;
     }
 }
-export async function getApiPort() {
+export async function getApiPort(summerDir = getSummerDir()) {
     try {
-        const port = await readFile(join(getSummerDir(), "api-port"), "utf-8");
+        const port = await readFile(join(summerDir, "api-port"), "utf-8");
         const parsed = parseInt(port.trim(), 10);
         return isNaN(parsed) ? DEFAULT_PORT : parsed;
     }
@@ -21,6 +24,237 @@ export async function getApiPort() {
         return DEFAULT_PORT;
     }
 }
+function stringFromUnknown(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function numberFromUnknown(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function processIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function canonicalPath(path) {
+    const absolute = resolve(path);
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+export async function findProjectRoot(startPath) {
+    let current = await canonicalPath(startPath);
+    try {
+        if (!(await stat(current)).isDirectory()) {
+            current = dirname(current);
+        }
+    }
+    catch {
+        return null;
+    }
+    while (true) {
+        try {
+            if ((await stat(join(current, "project.godot"))).isFile()) {
+                return current;
+            }
+        }
+        catch {
+            // Keep walking toward the filesystem root.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function parseEngineInstance(value) {
+    const record = asRecord(value);
+    if (!record || record.schemaVersion !== INSTANCE_SCHEMA_VERSION)
+        return null;
+    const instanceId = stringFromUnknown(record.instanceId);
+    const pid = numberFromUnknown(record.pid);
+    const port = numberFromUnknown(record.port);
+    const token = stringFromUnknown(record.token);
+    const resourceRoot = stringFromUnknown(record.resourceRoot);
+    const heartbeatAt = numberFromUnknown(record.heartbeatAt);
+    if (!instanceId ||
+        !pid ||
+        !Number.isInteger(pid) ||
+        !port ||
+        !Number.isInteger(port) ||
+        port < 1 ||
+        port > 65535 ||
+        !token ||
+        !resourceRoot ||
+        !heartbeatAt) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        instanceId,
+        pid,
+        port,
+        token,
+        projectId: stringFromUnknown(record.projectId),
+        projectIdHash: stringFromUnknown(record.projectIdHash),
+        resourceRoot,
+        projectName: stringFromUnknown(record.projectName),
+        heartbeatAt,
+        engineVersion: stringFromUnknown(record.engineVersion),
+    };
+}
+export async function listEngineInstances(nowMs = Date.now(), summerDir = getSummerDir()) {
+    const instancesDir = join(summerDir, "instances");
+    try {
+        const dirInfo = await lstat(instancesDir);
+        if (!dirInfo.isDirectory() || dirInfo.isSymbolicLink())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const entries = await readdir(instancesDir, { withFileTypes: true });
+    const instances = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json"))
+            continue;
+        const path = join(instancesDir, entry.name);
+        try {
+            const info = await lstat(path);
+            if (!info.isFile() ||
+                info.isSymbolicLink() ||
+                info.size > MAX_INSTANCE_FILE_BYTES) {
+                continue;
+            }
+            const parsed = parseEngineInstance(JSON.parse(await readFile(path, "utf-8")));
+            if (!parsed || !processIsAlive(parsed.pid))
+                continue;
+            if (nowMs - parsed.heartbeatAt * 1000 > INSTANCE_STALE_MS)
+                continue;
+            parsed.resourceRoot = await canonicalPath(parsed.resourceRoot);
+            instances.push(parsed);
+        }
+        catch {
+            // One malformed or concurrently-replaced entry must not hide other editors.
+        }
+    }
+    return instances.sort((a, b) => a.resourceRoot.localeCompare(b.resourceRoot) ||
+        a.instanceId.localeCompare(b.instanceId));
+}
+function formatInstances(instances) {
+    return instances
+        .map((instance) => {
+        const label = instance.projectName
+            ? `${instance.projectName} (${instance.resourceRoot})`
+            : instance.resourceRoot;
+        return `  - ${label} [${instance.instanceId}]`;
+    })
+        .join("\n");
+}
+async function connectionForInstance(instance, selection) {
+    const health = await checkEngineHealth(instance.port);
+    if (!health) {
+        throw new Error(`Summer Engine instance ${instance.instanceId} is not responding on port ${instance.port}.`);
+    }
+    if (health.instanceId !== instance.instanceId) {
+        throw new Error(`Summer Engine registry identity changed on port ${instance.port}; refusing to connect to the wrong editor.`);
+    }
+    if (instance.projectIdHash &&
+        health.projectIdHash &&
+        instance.projectIdHash !== health.projectIdHash) {
+        throw new Error(`Summer Engine project identity changed on port ${instance.port}; refusing to connect to the wrong project.`);
+    }
+    return {
+        port: instance.port,
+        token: instance.token,
+        health,
+        instance,
+        selection: { ...selection },
+        source: "registry",
+    };
+}
+export async function resolveEngineConnection(selection = {}, options = {}) {
+    const summerDir = options.summerDir ?? getSummerDir();
+    const explicitInstanceId = stringFromUnknown(selection.instanceId);
+    const explicitProjectPath = stringFromUnknown(selection.projectPath);
+    const cwd = stringFromUnknown(selection.cwd);
+    const requestedProjectRoot = explicitProjectPath
+        ? await findProjectRoot(explicitProjectPath)
+        : !explicitInstanceId && cwd
+            ? await findProjectRoot(cwd)
+            : null;
+    if (explicitProjectPath && !requestedProjectRoot) {
+        throw new Error(`No project.godot found at or above ${resolve(explicitProjectPath)}.`);
+    }
+    const instances = await listEngineInstances(options.nowMs ?? Date.now(), summerDir);
+    let candidates = instances;
+    if (explicitInstanceId) {
+        candidates = candidates.filter((instance) => instance.instanceId === explicitInstanceId);
+    }
+    if (requestedProjectRoot) {
+        const canonicalRoot = await canonicalPath(requestedProjectRoot);
+        candidates = candidates.filter((instance) => instance.resourceRoot === canonicalRoot);
+    }
+    if (explicitInstanceId || requestedProjectRoot) {
+        if (candidates.length === 1) {
+            return connectionForInstance(candidates[0], {
+                ...selection,
+                projectPath: requestedProjectRoot ?? selection.projectPath,
+            });
+        }
+        if (candidates.length > 1) {
+            throw new Error(`More than one Summer editor matches this project. Select one with \`summer mcp --instance <id>\`:\n${formatInstances(candidates)}`);
+        }
+        const canUseLegacyForInferredProject = instances.length === 0 &&
+            !explicitInstanceId &&
+            !explicitProjectPath &&
+            Boolean(requestedProjectRoot);
+        if (!canUseLegacyForInferredProject) {
+            const target = explicitInstanceId
+                ? `instance ${explicitInstanceId}`
+                : `project ${requestedProjectRoot}`;
+            throw new Error(`No running Summer editor matches ${target}. Open that project in Summer Engine and retry.`);
+        }
+    }
+    if (instances.length === 1) {
+        return connectionForInstance(instances[0], selection);
+    }
+    if (instances.length > 1) {
+        throw new Error("Multiple Summer editors are running and this agent is not inside a Summer project. " +
+            "Start the agent from the project directory, or pass `summer mcp --project <path>`.\n" +
+            formatInstances(instances));
+    }
+    const [port, token] = await Promise.all([
+        getApiPort(summerDir),
+        getApiToken(summerDir),
+    ]);
+    if (!token) {
+        throw new Error("Summer Engine is not running (no api-token found). Open Summer Engine first.");
+    }
+    const health = await checkEngineHealth(port);
+    if (!health) {
+        throw new Error(`Summer Engine is not responding on port ${port}. Make sure it's open.`);
+    }
+    return {
+        port,
+        token,
+        health,
+        selection: null,
+        source: "legacy",
+    };
+}
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value

package/dist/lib/game-task-plan.js

@@ -249,7 +249,7 @@ function inferSkills(mode, target, goal) {
         addSkill(routes, "design-mechanic", "Implement the core shooting/combat loop.", 230);
         addSkill(routes, "design-level", "Shape the arena, spawn space, cover, and pacing.", 210);
     }
-    addSkill(routes, "gdscript-patterns", "Use direct host file edits for scripts, then verify through MCP.", 90);
+    addSkill(routes, "gdscript-patterns", "Use guarded Summer file tools for scripts, then verify through MCP.", 90);
     addSkill(routes, "verification-before-completion", "Do not finish without a clean verification story.", 80);
     return routes
         .sort((a, b) => b.weight - a.weight)
@@ -350,7 +350,7 @@ export function buildGameTaskPlan(options) {
         verification,
         principles: [
             "The agent should build a playable game slice, not a static demo.",
-            "Use host file edits for code/data/docs; use MCP for live scene state, imports, inspector values, play, and diagnostics.",
+            "Use identity-bound Summer file tools for code/data/docs and Summer scene tools for live hierarchy/inspector changes.",
             "Reuse/import assets before paid generation unless the user explicitly wants custom output.",
             "Prefer exact IDs and structured tool results over search guesses after asset creation.",
             "Verify through the engine before claiming completion.",
@@ -358,8 +358,8 @@ export function buildGameTaskPlan(options) {
         recommendedSkills: inferSkills(mode, target, goal),
         mcpToolPlan: buildMcpToolPlan(mode, target, assetPolicy, verification, goal),
         hostFileWork: [
-            "Write and edit .gd/.cs scripts directly with host file tools.",
-            "Use direct file edits for JSON, markdown, project notes, and simple resources.",
+            "Read and mutate project text through summer_read_file, summer_replace_text, and guarded summer_write_file.",
+            "Use create_only:true for new files and an engine sha256 receipt for overwrites.",
             "Read relevant .summer memory files when project context reports them.",
         ],
         userGates: buildUserGates(mode, assetPolicy),

package/dist/lib/mcp-boot-notice.d.ts

@@ -0,0 +1,3 @@
+import type { BootDriftNotice } from "./version-check.js";
+export declare function getCachedBootDriftNotice(): BootDriftNotice | null;
+export declare function setCachedBootDriftNotice(notice: BootDriftNotice | null): void;

package/dist/lib/mcp-boot-notice.js

@@ -0,0 +1,7 @@
+let cachedBootDriftNotice = null;
+export function getCachedBootDriftNotice() {
+    return cachedBootDriftNotice;
+}
+export function setCachedBootDriftNotice(notice) {
+    cachedBootDriftNotice = notice;
+}

package/dist/lib/mcp-log.d.ts

@@ -0,0 +1,3 @@
+export declare function getMcpLogPath(): string;
+export declare function appendMcpLogEvent(event: string, details?: Record<string, unknown>): void;
+export declare function readRecentMcpLogLines(maxLines?: number): Promise<string[]>;