summer-engine 2.3.0 → 2.5.0

package/dist/lib/skills-registry.js

@@ -7,10 +7,12 @@ export const AGENT_CLIENTS = [
     "cline",
     "roo-code",
     "gemini",
+    "github-copilot",
+    "vscode-copilot",
     "opencode",
 ];
 export const SKILL_CATEGORIES = [
-    "_meta",
+    "workflow",
     "2d-assets",
     "3d-assets",
     "video",
@@ -37,9 +39,10 @@ export const SKILL_CATEGORIES = [
 ];
 const ALL_CLIENTS = AGENT_CLIENTS;
 /**
- * Skills with `status: HAVE` in catalog.yaml. The catalog is the planning source
- * of truth (~85 skills); this TS registry is the install-time list (only skills
- * with shippable content). When a NEXT skill ships, mirror it here.
+ * Install-time skill registry — every skill installable via `summer skills install`.
+ * Must stay in sync with `.claude-plugin/plugin.json` (and sibling manifests) for
+ * Claude Code / Cursor / Codex plugin discovery. The `plugin-manifests.test.ts`
+ * test fails the build if a skill exists on disk but not in the manifest.
  */
 export const SKILL_REGISTRY = [
     {
@@ -904,4 +907,99 @@ export const SKILL_REGISTRY = [
         ],
         testScenario: "User wants 'a magical glow on a rune' — skill creates OmniLight3D with pulse-on-sin script + GPUParticles3D motes, uses additive billboard material from building blocks.",
     },
+    {
+        name: "brainstorming",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [],
+        testScenario: "User says 'let's make a game' — skill explores intent, scope, and references through one-question-at-a-time dialogue before any code or scene work begins.",
+    },
+    {
+        name: "investigating-bugs",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [],
+        testScenario: "Encountering a bug whose first fix didn't stick — skill forces hypothesis-driven root cause analysis before another patch attempt.",
+    },
+    {
+        name: "verification-before-completion",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [],
+        testScenario: "About to claim a feature is done — skill blocks the claim until verification commands have been run and their output reviewed.",
+    },
+    {
+        name: "writing-plans",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [],
+        testScenario: "User has a multi-step spec — skill produces a written plan with checkpoints before any implementation begins.",
+    },
+    {
+        name: "dispatching-parallel-agents",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [],
+        testScenario: "Facing 2+ independent tasks — skill prepares isolated, self-contained agent prompts and dispatches them in parallel.",
+    },
+    {
+        name: "writing-skills",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [],
+        testScenario: "User wants a new Summer skill — skill walks through frontmatter, body structure, and the auto-trigger discipline required for the skill to fire reliably.",
+    },
+    {
+        name: "playtesting-a-feature",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: true,
+        requiresMcpTools: [
+            "summer_play",
+            "summer_stop",
+            "summer_get_console",
+            "summer_get_debugger_errors",
+            "summer_get_diagnostics",
+        ],
+        testScenario: "Just finished a gameplay feature — skill drives a golden-path + edge-case playthrough with diagnostics capture before the feature can be marked done.",
+    },
+    {
+        name: "debugging-game-feel",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [
+            "summer_play",
+            "summer_stop",
+            "summer_inspect_node",
+        ],
+        testScenario: "User says 'the jump feels floaty' — skill isolates one variable at a time against a reference anchor, avoids compounding tweaks.",
+    },
+    {
+        name: "diagnosing-perf-regressions",
+        category: "workflow",
+        public: true,
+        clients: ALL_CLIENTS,
+        recommended: false,
+        requiresMcpTools: [
+            "summer_get_diagnostics",
+            "summer_play",
+            "summer_stop",
+        ],
+        testScenario: "FPS dropped from 60 to 30 — skill bisects recent changes, captures before/after diagnostics, identifies the regression cause before tuning.",
+    },
 ];

package/dist/lib/version-check.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Version drift detection helpers used by `summer doctor` and the MCP server
+ * boot path.
+ *
+ * Two checks are exposed:
+ *   - cli-version-current: compares installed package.json version against the
+ *     latest published `summer-engine` on the npm registry.
+ *   - skills-version-stale: reads a `.summer-version` marker written into the
+ *     skill install dir (per-agent) and compares against the current CLI.
+ *
+ * Both are designed to be silent on offline / network errors — we never want
+ * to false-alarm a user just because their wifi is flaky.
+ */
+export interface SemverParts {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export type DriftSeverity = "ok" | "warning" | "fail";
+export interface DriftClassification {
+    severity: DriftSeverity;
+    reason: "current" | "ahead" | "patch-only" | "minor-drift" | "major-drift" | "behind";
+}
+export declare function parseSemver(version: string): SemverParts | null;
+export declare function compareSemver(a: SemverParts, b: SemverParts): number;
+/**
+ * Classify drift between an installed and a target version.
+ *
+ *   ok        installed >= target, OR installed is behind only on patch
+ *             OR installed differs only in pre-release/build metadata.
+ *   warning   one minor version behind on the same major.
+ *   fail      two or more minors behind, or any major-version drift behind.
+ */
+export declare function classifyDrift(installed: SemverParts, target: SemverParts): DriftClassification;
+export interface RegistryFetchOptions {
+    /** Override the default fetch (used in tests). Must implement the global fetch shape. */
+    fetchImpl?: typeof fetch;
+    /** Override the timeout. */
+    timeoutMs?: number;
+    /** Override the URL (used in tests). */
+    url?: string;
+}
+export interface RegistryFetchResult {
+    ok: true;
+    version: string;
+}
+export interface RegistryFetchFailure {
+    ok: false;
+    reason: "registry-unreachable";
+    message?: string;
+}
+export declare function fetchLatestRegistryVersion(options?: RegistryFetchOptions): Promise<RegistryFetchResult | RegistryFetchFailure>;
+/**
+ * Build the `cli-version-current` doctor check. Pure helper so tests can drive
+ * registry responses through `fetchImpl` rather than touching the network.
+ */
+export interface CliVersionCheckInput {
+    installedVersion: string;
+    registry: RegistryFetchResult | RegistryFetchFailure;
+}
+export interface CliVersionCheckOutput {
+    status: DriftSeverity;
+    message: string;
+    details: Record<string, unknown>;
+}
+export declare function buildCliVersionCheck(input: CliVersionCheckInput): CliVersionCheckOutput;
+export declare const SKILL_VERSION_MARKER_FILENAME = ".summer-version";
+export interface SkillVersionMarker {
+    version: string;
+    installedAt: string;
+}
+export declare function readSkillMarker(dir: string): SkillVersionMarker | null;
+export declare function writeSkillMarker(dir: string, version: string, now?: Date): string;
+/**
+ * Candidate locations for skill-version markers. Listed roughly in order of
+ * how likely a Summer user is to have them populated. We probe every candidate,
+ * not just the first one — if multiple agents have markers, the most-stale one
+ * wins so we surface the worst case to the user.
+ */
+export interface SkillMarkerCandidate {
+    agent: string;
+    dir: string;
+}
+export declare function defaultSkillMarkerCandidates(): SkillMarkerCandidate[];
+export interface SkillsVersionCheckInput {
+    installedCliVersion: string;
+    candidates: SkillMarkerCandidate[];
+}
+export interface SkillsVersionCheckOutput {
+    status: DriftSeverity;
+    message: string;
+    details: Record<string, unknown>;
+}
+export declare function buildSkillsVersionCheck(input: SkillsVersionCheckInput): SkillsVersionCheckOutput;
+/**
+ * Helper used by the MCP server boot path to render a one-line drift notice.
+ * Returns null when no notice is needed (fresh, ahead, patch-only, offline).
+ */
+export interface BootDriftNotice {
+    installedVersion: string;
+    latestVersion: string;
+    agent?: string;
+    text: string;
+}
+export declare function buildBootDriftNotice(installedVersion: string, registry: RegistryFetchResult | RegistryFetchFailure, agent?: string): BootDriftNotice | null;
+export declare function markerMtime(dir: string): number | null;

package/dist/lib/version-check.js

@@ -0,0 +1,338 @@
+/**
+ * Version drift detection helpers used by `summer doctor` and the MCP server
+ * boot path.
+ *
+ * Two checks are exposed:
+ *   - cli-version-current: compares installed package.json version against the
+ *     latest published `summer-engine` on the npm registry.
+ *   - skills-version-stale: reads a `.summer-version` marker written into the
+ *     skill install dir (per-agent) and compares against the current CLI.
+ *
+ * Both are designed to be silent on offline / network errors — we never want
+ * to false-alarm a user just because their wifi is flaky.
+ */
+import { existsSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+const NPM_REGISTRY_LATEST_URL = "https://registry.npmjs.org/summer-engine/latest";
+const REGISTRY_FETCH_TIMEOUT_MS = 3000;
+export function parseSemver(version) {
+    if (!version)
+        return null;
+    // Strip any leading "v" and trim build / pre-release tags after the first hyphen.
+    const cleaned = version.trim().replace(/^v/, "").split(/[-+]/)[0];
+    const match = cleaned.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match)
+        return null;
+    const [, maj, min, pat] = match;
+    return {
+        major: Number(maj),
+        minor: Number(min),
+        patch: Number(pat),
+    };
+}
+export function compareSemver(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    return a.patch - b.patch;
+}
+/**
+ * Classify drift between an installed and a target version.
+ *
+ *   ok        installed >= target, OR installed is behind only on patch
+ *             OR installed differs only in pre-release/build metadata.
+ *   warning   one minor version behind on the same major.
+ *   fail      two or more minors behind, or any major-version drift behind.
+ */
+export function classifyDrift(installed, target) {
+    const cmp = compareSemver(installed, target);
+    if (cmp === 0)
+        return { severity: "ok", reason: "current" };
+    if (cmp > 0)
+        return { severity: "ok", reason: "ahead" };
+    // installed < target
+    if (installed.major < target.major) {
+        return { severity: "fail", reason: "major-drift" };
+    }
+    if (installed.minor === target.minor) {
+        // Same major + minor, target patch is higher → patch-only drift.
+        return { severity: "ok", reason: "patch-only" };
+    }
+    const minorDelta = target.minor - installed.minor;
+    if (minorDelta >= 2) {
+        return { severity: "fail", reason: "minor-drift" };
+    }
+    return { severity: "warning", reason: "minor-drift" };
+}
+export async function fetchLatestRegistryVersion(options = {}) {
+    const url = options.url ?? NPM_REGISTRY_LATEST_URL;
+    const timeoutMs = options.timeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS;
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        return { ok: false, reason: "registry-unreachable", message: "fetch unavailable" };
+    }
+    try {
+        const response = await fetchImpl(url, {
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { accept: "application/json" },
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                reason: "registry-unreachable",
+                message: `registry responded ${response.status}`,
+            };
+        }
+        const body = (await response.json());
+        if (typeof body.version !== "string") {
+            return {
+                ok: false,
+                reason: "registry-unreachable",
+                message: "registry payload missing version",
+            };
+        }
+        return { ok: true, version: body.version };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "registry-unreachable",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+const RECOMMENDED_REFRESH_COMMAND = "npx clear-npx-cache && npx -y summer-engine@latest setup <agent> --yes --force";
+export function buildCliVersionCheck(input) {
+    if (!input.registry.ok) {
+        return {
+            status: "ok",
+            message: "registry unreachable, skipping check",
+            details: {
+                installedVersion: input.installedVersion,
+                reason: input.registry.reason,
+            },
+        };
+    }
+    const installed = parseSemver(input.installedVersion);
+    const latest = parseSemver(input.registry.version);
+    if (!installed || !latest) {
+        // If we can't parse either side, don't false-alarm.
+        return {
+            status: "ok",
+            message: "could not compare versions",
+            details: {
+                installedVersion: input.installedVersion,
+                latestVersion: input.registry.version,
+                reason: "unparseable-version",
+            },
+        };
+    }
+    const drift = classifyDrift(installed, latest);
+    const baseDetails = {
+        installedVersion: input.installedVersion,
+        latestVersion: input.registry.version,
+    };
+    switch (drift.severity) {
+        case "ok":
+            return {
+                status: "ok",
+                message: drift.reason === "patch-only"
+                    ? `v${input.installedVersion} (latest ${input.registry.version}, patch-only)`
+                    : drift.reason === "ahead"
+                        ? `v${input.installedVersion} (ahead of latest ${input.registry.version})`
+                        : `v${input.installedVersion}`,
+                details: { ...baseDetails, reason: drift.reason },
+            };
+        case "warning":
+            return {
+                status: "warning",
+                message: `v${input.installedVersion} → v${input.registry.version} available`,
+                details: {
+                    ...baseDetails,
+                    recommendedAction: RECOMMENDED_REFRESH_COMMAND,
+                },
+            };
+        case "fail":
+            return {
+                status: "fail",
+                message: `v${input.installedVersion} is significantly behind v${input.registry.version}`,
+                details: {
+                    ...baseDetails,
+                    recommendedAction: RECOMMENDED_REFRESH_COMMAND,
+                },
+            };
+    }
+}
+// ---------------------------------------------------------------------------
+// Skill marker (.summer-version) helpers
+// ---------------------------------------------------------------------------
+export const SKILL_VERSION_MARKER_FILENAME = ".summer-version";
+export function readSkillMarker(dir) {
+    const path = join(dir, SKILL_VERSION_MARKER_FILENAME);
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version !== "string" || typeof parsed.installedAt !== "string") {
+            return null;
+        }
+        return { version: parsed.version, installedAt: parsed.installedAt };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSkillMarker(dir, version, now = new Date()) {
+    const path = join(dir, SKILL_VERSION_MARKER_FILENAME);
+    const payload = {
+        version,
+        installedAt: now.toISOString(),
+    };
+    writeFileSync(path, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+    return path;
+}
+export function defaultSkillMarkerCandidates() {
+    const home = homedir();
+    const candidates = [
+        { agent: "claude-code", dir: join(home, ".claude", "skills") },
+        { agent: "codex", dir: join(home, ".agents", "skills") },
+        { agent: "summer", dir: join(home, ".summer", "skills") },
+        { agent: "cline", dir: join(home, "Documents", "Cline", "Rules") },
+        { agent: "roo-code", dir: join(home, "Documents", "Roo", "Rules") },
+        {
+            agent: "gemini",
+            dir: join(home, ".gemini", "extensions", "summer-engine", "skills"),
+        },
+    ];
+    // OpenCode user-scope agent dir is OS-dependent.
+    if (platform() === "win32") {
+        const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+        candidates.push({
+            agent: "opencode",
+            dir: join(appData, "opencode", "agents", "summer"),
+        });
+    }
+    else {
+        const xdg = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+        candidates.push({
+            agent: "opencode",
+            dir: join(xdg, "opencode", "agents", "summer"),
+        });
+    }
+    return candidates;
+}
+export function buildSkillsVersionCheck(input) {
+    const cliParsed = parseSemver(input.installedCliVersion);
+    if (!cliParsed) {
+        return {
+            status: "ok",
+            message: "could not parse CLI version",
+            details: { reason: "unparseable-cli-version" },
+        };
+    }
+    const resolutions = [];
+    for (const candidate of input.candidates) {
+        const marker = readSkillMarker(candidate.dir);
+        if (!marker)
+            continue;
+        const markerSemver = parseSemver(marker.version);
+        if (!markerSemver)
+            continue;
+        const drift = classifyDrift(markerSemver, cliParsed);
+        const installedAtMs = Date.parse(marker.installedAt);
+        resolutions.push({
+            agent: candidate.agent,
+            dir: candidate.dir,
+            marker,
+            drift,
+            installedAtMs: Number.isFinite(installedAtMs) ? installedAtMs : 0,
+        });
+    }
+    if (resolutions.length === 0) {
+        return {
+            status: "ok",
+            message: "no skill marker yet (treated as fresh install)",
+            details: { reason: "no-marker" },
+        };
+    }
+    // Pick the worst (most-stale) marker. Severity rank fail > warning > ok;
+    // tiebreak by oldest installedAt.
+    const severityRank = { fail: 2, warning: 1, ok: 0 };
+    const worst = [...resolutions].sort((a, b) => {
+        const sevDiff = severityRank[b.drift.severity] - severityRank[a.drift.severity];
+        if (sevDiff !== 0)
+            return sevDiff;
+        return a.installedAtMs - b.installedAtMs;
+    })[0];
+    const baseDetails = {
+        agent: worst.agent,
+        skillsDir: worst.dir,
+        markerVersion: worst.marker.version,
+        installedAt: worst.marker.installedAt,
+        cliVersion: input.installedCliVersion,
+    };
+    switch (worst.drift.severity) {
+        case "ok":
+            return {
+                status: "ok",
+                message: `skills v${worst.marker.version} match CLI`,
+                details: baseDetails,
+            };
+        case "warning":
+            return {
+                status: "warning",
+                message: `skills v${worst.marker.version} are one minor version behind v${input.installedCliVersion}`,
+                details: {
+                    ...baseDetails,
+                    recommendedAction: skillsRefreshCommand(worst.agent),
+                },
+            };
+        case "fail":
+            return {
+                status: "fail",
+                message: `skills v${worst.marker.version} are significantly behind v${input.installedCliVersion}`,
+                details: {
+                    ...baseDetails,
+                    recommendedAction: skillsRefreshCommand(worst.agent),
+                },
+            };
+    }
+}
+function skillsRefreshCommand(agent) {
+    return `npx clear-npx-cache && npx -y summer-engine@latest setup ${agent} --yes --force`;
+}
+export function buildBootDriftNotice(installedVersion, registry, agent) {
+    if (!registry.ok)
+        return null;
+    const installed = parseSemver(installedVersion);
+    const latest = parseSemver(registry.version);
+    if (!installed || !latest)
+        return null;
+    const drift = classifyDrift(installed, latest);
+    if (drift.severity === "ok")
+        return null;
+    const agentSlug = agent ?? "<agent>";
+    const text = `[summer] CLI ${installedVersion} — latest ${registry.version}; ` +
+        `run \`npx clear-npx-cache && npx -y summer-engine@latest setup ${agentSlug} --yes --force\` to update.`;
+    return {
+        installedVersion,
+        latestVersion: registry.version,
+        agent,
+        text,
+    };
+}
+// Re-export for tests / callers that want to know the install marker's mtime.
+export function markerMtime(dir) {
+    const path = join(dir, SKILL_VERSION_MARKER_FILENAME);
+    if (!existsSync(path))
+        return null;
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/mcp/server.d.ts

@@ -1,4 +1,6 @@
 import { EngineApiClient } from "../lib/api-client.js";
+import { type BootDriftNotice } from "../lib/version-check.js";
+export declare function getCachedBootDriftNotice(): BootDriftNotice | null;
 export declare function getClient(): Promise<EngineApiClient>;
 export declare function resetClient(): void;
 export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -7,8 +7,25 @@ import { registerDebugTools } from "./tools/debug-tools.js";
 import { registerProjectTools } from "./tools/project-tools.js";
 import { registerAssetTools } from "./tools/asset-tools.js";
 import { registerGenerateTools } from "./tools/generate-tools.js";
+import { buildBootDriftNotice, fetchLatestRegistryVersion, } from "../lib/version-check.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
+let cachedBootDriftNotice = null;
+export function getCachedBootDriftNotice() {
+    return cachedBootDriftNotice;
+}
+/**
+ * Fire-and-forget probe of the npm registry on MCP boot. Caches the result for
+ * the session. We never await this in startup so a slow / offline registry
+ * never blocks tool registration. Tools that surface the notice should call
+ * `getCachedBootDriftNotice()` and skip silently when null.
+ */
+async function probeBootDrift() {
+    const registry = await fetchLatestRegistryVersion();
+    // Agent is unknown at the MCP layer; use a generic placeholder. Doctor still
+    // prescribes the correct agent-aware command via setup recommendations.
+    cachedBootDriftNotice = buildBootDriftNotice(version, registry);
+}
 let cachedClient = null;
 export async function getClient() {
     if (cachedClient) {
@@ -26,16 +43,80 @@ export async function getClient() {
 export function resetClient() {
     cachedClient = null;
 }
+/**
+ * Passive result-size observability. Monkey-patches server.tool() so every
+ * registered handler's serialized text payload is measured and logged to
+ * stderr in the existing `[summer-mcp]` JSON shape. The result itself is
+ * never modified — external coding agents (Claude Code, Cursor, Codex)
+ * manage their own context budgets, and silently truncating their tool
+ * results is the wrong shape (see #102 revert). If a specific tool turns
+ * out to produce pathological payloads in practice, the right fix is
+ * adding range/depth/filter parameters to that tool — not a blanket cap.
+ */
+function installResultSizeLogger(server) {
+    const original = server.tool.bind(server);
+    server.tool = function patchedTool(...args) {
+        if (args.length < 2)
+            return original(...args);
+        const name = args[0];
+        if (typeof name !== "string")
+            return original(...args);
+        const lastIdx = args.length - 1;
+        const handler = args[lastIdx];
+        if (typeof handler !== "function")
+            return original(...args);
+        const wrapped = async (...handlerArgs) => {
+            const result = await handler(...handlerArgs);
+            try {
+                if (result &&
+                    typeof result === "object" &&
+                    "content" in result &&
+                    Array.isArray(result.content)) {
+                    let chars = 0;
+                    for (const entry of result
+                        .content) {
+                        if (entry && entry.type === "text" && typeof entry.text === "string") {
+                            chars += entry.text.length;
+                        }
+                    }
+                    const bytes = Buffer.byteLength(result.content
+                        .filter((e) => e && e.type === "text" && typeof e.text === "string")
+                        .map((e) => e.text)
+                        .join(""), "utf8");
+                    const line = JSON.stringify({
+                        event: "mcp:result_size",
+                        tool_name: name,
+                        chars,
+                        bytes,
+                    });
+                    process.stderr.write(`[summer-mcp] ${line}\n`);
+                }
+            }
+            catch {
+                // Telemetry must never break the tool call.
+            }
+            return result;
+        };
+        const newArgs = [...args];
+        newArgs[lastIdx] = wrapped;
+        return original(...newArgs);
+    };
+}
 export async function startMcpServer() {
     const server = new McpServer({
         name: "summer-engine",
         version,
     });
+    // Passive observability: log result-size to stderr but do not modify
+    // results. See installResultSizeLogger above.
+    installResultSizeLogger(server);
     registerSceneTools(server);
     registerDebugTools(server);
     registerProjectTools(server);
     registerAssetTools(server);
     registerGenerateTools(server);
+    // Fire-and-forget — never block tool registration on the npm registry.
+    void probeBootDrift();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.stderr.write(`[summer-mcp] MCP server running v${version}.\n`);