summer-engine 3.3.0 → 3.4.1

package/dist/core/engine-install.d.ts

@@ -58,6 +58,22 @@ export declare function linuxEngineInstallDir(): string;
 export declare function macEnginePaths(env?: NodeJS.ProcessEnv): string[];
 export declare function windowsEnginePaths(env?: NodeJS.ProcessEnv): string[];
 export declare function linuxEnginePaths(): string[];
+/** Where `summer install` records the engine it installed last
+ *  (~/.summer/engine-install.json), so an install with --path is found later
+ *  without SUMMER_BIN. */
+export declare const ENGINE_INSTALL_FILE = "engine-install.json";
+export interface RecordedEngineInstall {
+    schemaVersion: 1;
+    /** The engine executable (on macOS the one inside Summer.app). */
+    binary: string;
+    version: string | null;
+    installedAt: string;
+}
+export declare function recordEngineInstall(binary: string, version: string | null): Promise<void>;
+/** The engine `summer install` installed last, or null (sync: findEngineBinary is). */
+export declare function recordedEngineBinary(): string | null;
+/** The bundle summer install writes on macOS: <path>/Summer.app, or the path itself when it names a .app. */
+export declare function macInstallDestination(customPath?: string): string;
 export declare function engineBinaryCandidates(os?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string[];
 /** First existing engine binary for this machine, or null. SUMMER_BIN /
  *  SUMMER_ENGINE_BINARY wins when set and present; a set-but-missing override

package/dist/core/engine-install.js

@@ -1,6 +1,7 @@
-import { existsSync, statSync } from "fs";
+import { existsSync, readFileSync, statSync } from "fs";
 import { homedir, platform } from "os";
 import { basename, join } from "path";
+import { getSummerDir, writeStoreJson } from "./store.js";
 /**
  * Where each platform's engine binary lives, shared by `summer install`,
  * `summer run`, and `summer doctor` so they can never disagree about what
@@ -95,6 +96,31 @@ export function windowsEnginePaths(env = process.env) {
 export function linuxEnginePaths() {
     return [join(linuxEngineInstallDir(), LINUX_ENGINE_BINARY_NAME)];
 }
+/** Where `summer install` records the engine it installed last
+ *  (~/.summer/engine-install.json), so an install with --path is found later
+ *  without SUMMER_BIN. */
+export const ENGINE_INSTALL_FILE = "engine-install.json";
+export async function recordEngineInstall(binary, version) {
+    const record = { schemaVersion: 1, binary, version, installedAt: new Date().toISOString() };
+    await writeStoreJson(ENGINE_INSTALL_FILE, record);
+}
+/** The engine `summer install` installed last, or null (sync: findEngineBinary is). */
+export function recordedEngineBinary() {
+    try {
+        const record = JSON.parse(readFileSync(join(getSummerDir(), ENGINE_INSTALL_FILE), "utf8"));
+        return record.schemaVersion === 1 && typeof record.binary === "string" && record.binary ? record.binary : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The bundle summer install writes on macOS: <path>/Summer.app, or the path itself when it names a .app. */
+export function macInstallDestination(customPath) {
+    if (!customPath?.trim())
+        return "/Applications/Summer.app";
+    const trimmed = customPath.trim().replace(/\/+$/, "");
+    return /\.app$/i.test(trimmed) ? trimmed : join(trimmed, "Summer.app");
+}
 export function engineBinaryCandidates(os = platform(), env = process.env) {
     const override = engineBinaryOverride(env)?.path;
     const platformPaths = os === "darwin"
@@ -102,7 +128,11 @@ export function engineBinaryCandidates(os = platform(), env = process.env) {
         : os === "linux"
             ? linuxEnginePaths()
             : windowsEnginePaths(env);
-    return override ? [override, ...platformPaths] : platformPaths;
+    // The engine summer install put in place last wins over the default
+    // locations (an install with --path next to an older /Applications copy).
+    const recorded = recordedEngineBinary();
+    const paths = recorded ? [recorded, ...platformPaths.filter((path) => path !== recorded)] : platformPaths;
+    return override ? [override, ...paths] : paths;
 }
 /** First existing engine binary for this machine, or null. SUMMER_BIN /
  *  SUMMER_ENGINE_BINARY wins when set and present; a set-but-missing override

package/dist/core/feedback/client.js

@@ -7,7 +7,7 @@
  * silent failure, never throws, never retries, never blocks the agent
  * for more than the timeout.
  *
- * Consent (SELF_IMPROVING_LIBRARY.md §3.4):
+ * Consent:
  * - SUMMER_NO_TELEMETRY=1 or DO_NOT_TRACK=1 → nothing is ever sent.
  * - First-run notice BEFORE the first event (CONTRACT §10): the first call
  *   ever made on a machine sends NOTHING and returns a one-paragraph notice

package/dist/core/hosted-mcp.d.ts

@@ -0,0 +1,115 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+/** The part of an MCP client the mount and the CLI use (a fake in tests). */
+export interface HostedClient {
+    listTools(params?: {
+        cursor?: string;
+    }): Promise<{
+        tools: Tool[];
+        nextCursor?: string;
+    }>;
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    listPrompts(params?: {
+        cursor?: string;
+    }): Promise<{
+        prompts: Array<{
+            name: string;
+            title?: string;
+            description?: string;
+            arguments?: Array<{
+                name: string;
+                description?: string;
+                required?: boolean;
+            }>;
+        }>;
+        nextCursor?: string;
+    }>;
+    getPrompt(params: {
+        name: string;
+        arguments?: Record<string, string>;
+    }): Promise<Record<string, unknown>>;
+    listResources(params?: {
+        cursor?: string;
+    }): Promise<{
+        resources: Array<{
+            uri: string;
+            name: string;
+            title?: string;
+            description?: string;
+            mimeType?: string;
+        }>;
+        nextCursor?: string;
+    }>;
+    readResource(params: {
+        uri: string;
+    }): Promise<Record<string, unknown>>;
+    close?(): Promise<void>;
+}
+export interface HostedConnectDependencies {
+    /** The hosted Summer Engine MCP URL (the store sign-in's resource). */
+    url: () => string;
+    token: () => Promise<string>;
+    connect: (url: string, token: () => Promise<string>) => Promise<HostedClient>;
+}
+export declare function connectHostedMcp(url: string, token: () => Promise<string>): Promise<HostedClient>;
+export declare const defaultHostedConnectDependencies: HostedConnectDependencies;
+/** True when this machine has a store sign-in on disk (no network). */
+export declare function hasStoreSignIn(): Promise<boolean>;
+export declare function listAllHostedTools(client: HostedClient): Promise<Tool[]>;
+/** Connect with the store sign-in, run fn, close. Throws OAuthError when not signed in. */
+export declare function withHostedMcp<T>(fn: (client: HostedClient) => Promise<T>, deps?: HostedConnectDependencies): Promise<T>;
+/** The text of a tool result, parsed as JSON when it is JSON. */
+export declare function hostedResultPayload(result: Record<string, unknown>): {
+    isError: boolean;
+    text: string;
+    json: Record<string, unknown> | null;
+};
+export type StoreAccessResult = {
+    status: "not_signed_in";
+    message: string;
+} | {
+    status: "ok";
+    games: number | null;
+} | {
+    status: "refused";
+    code: string | null;
+    message: string;
+    requestId?: string;
+} | {
+    status: "unreachable";
+    message: string;
+};
+/**
+ * Ask the store for the creator's games through the hosted MCP
+ * (summer_store_list_games): proves the store accepts this machine's sign-in.
+ */
+export declare function checkStoreAccess(timeoutMs?: number, deps?: HostedConnectDependencies): Promise<StoreAccessResult>;
+/** The hosted tool a CLI name means: the exact name, or a slug ("store-list-games" -> summer_store_list_games). */
+export declare function matchHostedTool(name: string, tools: readonly Tool[]): Tool | null;
+export type HostedToolsListing = {
+    status: "listed";
+    tools: Tool[];
+} | {
+    status: "not_signed_in";
+} | {
+    status: "unavailable";
+    message: string;
+};
+/** The hosted store and publishing tools, when this machine has a store sign-in. */
+export declare function listHostedToolsForCli(deps?: HostedConnectDependencies, signedIn?: () => Promise<boolean>): Promise<HostedToolsListing>;
+export type HostedCallOutcome = {
+    status: "called";
+    tool: string;
+    result: Record<string, unknown>;
+} | {
+    status: "not_found";
+} | {
+    status: "not_signed_in";
+} | {
+    status: "unavailable";
+    message: string;
+};
+/** Call a hosted tool by its name or slug with the store sign-in (one connection). */
+export declare function callHostedToolForCli(name: string, args: Record<string, unknown>, deps?: HostedConnectDependencies, signedIn?: () => Promise<boolean>): Promise<HostedCallOutcome>;

package/dist/core/hosted-mcp.js

@@ -0,0 +1,164 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { getStoreAccessToken, OAuthError, readStoredOAuthToken, resolveMcpResourceUrl } from "./oauth.js";
+import { TOOLKIT_VERSION } from "./version.js";
+/**
+ * A client for the hosted Summer Engine MCP (mcp.summerengine.com), signed in
+ * with the store sign-in ("summer login --store"). The local MCP mounts its
+ * tools (src/mcp/hosted-mount.ts); `summer tool` and `summer doctor` call it
+ * directly through the helpers below, so all three faces reach the same
+ * store and publishing tools.
+ */
+const CALL_TIMEOUT_MS = 120_000;
+export async function connectHostedMcp(url, token) {
+    const transport = new StreamableHTTPClientTransport(new URL(url), {
+        // A fresh (refreshed when near expiry) token on every request.
+        fetch: async (input, init) => {
+            const headers = new Headers(init?.headers);
+            headers.set("authorization", `Bearer ${await token()}`);
+            return fetch(input, { ...init, headers });
+        },
+    });
+    const client = new Client({ name: "summer-engine-local", version: TOOLKIT_VERSION });
+    await client.connect(transport);
+    const timeout = { timeout: CALL_TIMEOUT_MS };
+    return {
+        listTools: (params) => client.listTools(params),
+        callTool: (params) => client.callTool(params, undefined, timeout),
+        listPrompts: (params) => client.listPrompts(params),
+        getPrompt: (params) => client.getPrompt(params),
+        listResources: (params) => client.listResources(params),
+        readResource: (params) => client.readResource(params),
+        close: () => client.close(),
+    };
+}
+export const defaultHostedConnectDependencies = {
+    url: () => resolveMcpResourceUrl(),
+    token: () => getStoreAccessToken(),
+    connect: connectHostedMcp,
+};
+/** True when this machine has a store sign-in on disk (no network). */
+export async function hasStoreSignIn() {
+    return (await readStoredOAuthToken()) !== null;
+}
+export async function listAllHostedTools(client) {
+    const out = [];
+    let cursor;
+    for (let pages = 0; pages < 20; pages++) {
+        const result = await client.listTools(cursor ? { cursor } : undefined);
+        out.push(...(result.tools ?? []));
+        if (!result.nextCursor)
+            break;
+        cursor = result.nextCursor;
+    }
+    return out;
+}
+/** Connect with the store sign-in, run fn, close. Throws OAuthError when not signed in. */
+export async function withHostedMcp(fn, deps = defaultHostedConnectDependencies) {
+    const url = deps.url();
+    await deps.token();
+    const client = await deps.connect(url, deps.token);
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.close?.().catch(() => undefined);
+    }
+}
+/** The text of a tool result, parsed as JSON when it is JSON. */
+export function hostedResultPayload(result) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const text = content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+    let json = null;
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            json = parsed;
+    }
+    catch {
+        json = null;
+    }
+    if (!json && result.structuredContent && typeof result.structuredContent === "object") {
+        json = result.structuredContent;
+    }
+    return { isError: result.isError === true, text, json };
+}
+/**
+ * Ask the store for the creator's games through the hosted MCP
+ * (summer_store_list_games): proves the store accepts this machine's sign-in.
+ */
+export async function checkStoreAccess(timeoutMs = 8_000, deps = defaultHostedConnectDependencies) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ status: "unreachable", message: `no answer within ${Math.round(timeoutMs / 1000)} s` }), timeoutMs);
+        timer.unref?.();
+    });
+    const attempt = (async () => {
+        try {
+            const result = await withHostedMcp((client) => client.callTool({ name: "summer_store_list_games", arguments: {} }), deps);
+            const payload = hostedResultPayload(result);
+            if (payload.isError || payload.json?.ok === false) {
+                const code = typeof payload.json?.code === "string" ? payload.json.code : typeof payload.json?.error === "string" ? payload.json.error : null;
+                const message = typeof payload.json?.message === "string" ? payload.json.message : payload.text.slice(0, 300) || "the store refused the call";
+                const requestId = typeof payload.json?.requestId === "string" ? payload.json.requestId : undefined;
+                return { status: "refused", code, message, ...(requestId ? { requestId } : {}) };
+            }
+            const games = Array.isArray(payload.json?.games) ? payload.json.games.length : null;
+            return { status: "ok", games };
+        }
+        catch (error) {
+            if (error instanceof OAuthError && error.code === "store_login_required") {
+                return { status: "not_signed_in", message: error.message.replace(` ${error.recovery}`, "") };
+            }
+            if (error instanceof OAuthError)
+                return { status: "refused", code: error.code, message: error.message };
+            return { status: "unreachable", message: error instanceof Error ? error.message : String(error) };
+        }
+    })();
+    try {
+        return await Promise.race([attempt, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** The hosted tool a CLI name means: the exact name, or a slug ("store-list-games" -> summer_store_list_games). */
+export function matchHostedTool(name, tools) {
+    const needle = name.trim();
+    const asAlias = needle.startsWith("summer_") ? needle : `summer_${needle.replace(/-/g, "_")}`;
+    return tools.find((tool) => tool.name === needle) ?? tools.find((tool) => tool.name === asAlias) ?? null;
+}
+/** The hosted store and publishing tools, when this machine has a store sign-in. */
+export async function listHostedToolsForCli(deps = defaultHostedConnectDependencies, signedIn = hasStoreSignIn) {
+    if (!(await signedIn()))
+        return { status: "not_signed_in" };
+    try {
+        return { status: "listed", tools: await withHostedMcp(listAllHostedTools, deps) };
+    }
+    catch (error) {
+        if (error instanceof OAuthError && error.code === "store_login_required")
+            return { status: "not_signed_in" };
+        return { status: "unavailable", message: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Call a hosted tool by its name or slug with the store sign-in (one connection). */
+export async function callHostedToolForCli(name, args, deps = defaultHostedConnectDependencies, signedIn = hasStoreSignIn) {
+    if (!(await signedIn()))
+        return { status: "not_signed_in" };
+    try {
+        return await withHostedMcp(async (client) => {
+            const tool = matchHostedTool(name, await listAllHostedTools(client));
+            if (!tool)
+                return { status: "not_found" };
+            return { status: "called", tool: tool.name, result: await client.callTool({ name: tool.name, arguments: args }) };
+        }, deps);
+    }
+    catch (error) {
+        if (error instanceof OAuthError && error.code === "store_login_required")
+            return { status: "not_signed_in" };
+        return { status: "unavailable", message: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/core/launch-posture.d.ts

@@ -11,8 +11,8 @@
  *               or takes focus until the user clicks it.
  *   offscreen   `--summer-offscreen` (also `--summer-verify`) — never
  *               activates, never frontmost; on shipped engines an unfocusable
- *               window pushed off-screen where a sliver may stay visible
- *               (main.cpp says so), on the background-posture engine a
+ *               window pushed off-screen where a sliver may stay visible;
+ *               on the background-posture engine a
  *               no-Dock-icon accessory process. Used by RunVerification /
  *               offscreen play instances, never by `summer run`.
  *
@@ -96,6 +96,9 @@ export type BackgroundLaunchSupport = {
     reason: "version_unknown";
     version: null;
 };
+/** Whether `version` is `minimum` or newer; null when either is missing or
+ *  not x.y.z (an unknown version is never "too old" and never "new enough"). */
+export declare function isVersionAtLeast(version: string | null | undefined, minimum: string): boolean | null;
 /**
  * Whether the installed engine honours the background flag. The `--help`
  * probe answer (true/false) is definitive when it ran; a probe that could not
@@ -136,7 +139,7 @@ export interface DetectBackgroundSupportOptions {
 export declare function detectBackgroundLaunchSupport(binary: string, options?: DetectBackgroundSupportOptions): Promise<BackgroundLaunchSupport>;
 /**
  * The running engine's own word, once it is up: /api/health
- * `capabilities.launchPostures` (engine tool_net_thread.cpp, newer builds;
+ * `capabilities.launchPostures` (newer engine builds;
  * "focus" always, "background" / "offscreen" only where enforced). true /
  * false when advertised, null when the engine predates the advert.
  */

package/dist/core/launch-posture.js

@@ -11,8 +11,8 @@
  *               or takes focus until the user clicks it.
  *   offscreen   `--summer-offscreen` (also `--summer-verify`) — never
  *               activates, never frontmost; on shipped engines an unfocusable
- *               window pushed off-screen where a sliver may stay visible
- *               (main.cpp says so), on the background-posture engine a
+ *               window pushed off-screen where a sliver may stay visible;
+ *               on the background-posture engine a
  *               no-Dock-icon accessory process. Used by RunVerification /
  *               offscreen play instances, never by `summer run`.
  *
@@ -61,7 +61,7 @@
  * --help probe below runs against THAT binary (cache key: path + mtime + size).
  */
 import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { platform } from "node:os";
 import { getSummerDir } from "./auth.js";
@@ -100,6 +100,15 @@ function compareVersions(a, b) {
         return a.minor - b.minor;
     return a.patch - b.patch;
 }
+/** Whether `version` is `minimum` or newer; null when either is missing or
+ *  not x.y.z (an unknown version is never "too old" and never "new enough"). */
+export function isVersionAtLeast(version, minimum) {
+    const parsed = version ? parseVersion(version) : null;
+    const min = parseVersion(minimum);
+    if (!parsed || !min)
+        return null;
+    return compareVersions(parsed, min) >= 0;
+}
 /**
  * Whether the installed engine honours the background flag. The `--help`
  * probe answer (true/false) is definitive when it ran; a probe that could not
@@ -232,7 +241,7 @@ export async function detectBackgroundLaunchSupport(binary, options = {}) {
 }
 /**
  * The running engine's own word, once it is up: /api/health
- * `capabilities.launchPostures` (engine tool_net_thread.cpp, newer builds;
+ * `capabilities.launchPostures` (newer engine builds;
  * "focus" always, "background" / "offscreen" only where enforced). true /
  * false when advertised, null when the engine predates the advert.
  */
@@ -282,12 +291,16 @@ export function parseVelopackVersion(sqVersionText) {
     const match = sqVersionText.match(/<version>\s*([^<\s]+)\s*<\/version>/i);
     return match ? match[1].trim() : null;
 }
-/** Walk up from `.../Summer.app/Contents/MacOS/Summer` to the bundle. */
+/** Walk up from `.../Summer.app/Contents/MacOS/Summer` to the bundle. A
+ *  bundle unpacked without its `.app` folder (`<dir>/Contents/MacOS/Summer`)
+ *  reads as `<dir>`. */
 function macBundlePathFor(binary) {
     let current = dirname(binary);
     for (let depth = 0; depth < 4; depth++) {
         if (basename(current).endsWith(".app"))
             return current;
+        if (basename(current) === "Contents" && existsSync(join(current, "Info.plist")))
+            return dirname(current);
         const parent = dirname(current);
         if (parent === current)
             break;

package/dist/core/library-read.js

@@ -13,8 +13,7 @@
  *   reference  the markdown body
  *   example / collection   README.md / collection.yaml when present
  *
- * The LAST line of every load is the feedback footer
- * (SELF_IMPROVING_LIBRARY.md §3.1 "trigger placement"):
+ * The LAST line of every load is the feedback footer:
  *   — entry_id: <id>@<content_hash first 12>. If this entry is wrong, stale,
  *   or you deviate from it, report via summer_library_feedback.
  * The agent copies that entry_id verbatim into summer_library_feedback, so

package/dist/core/templates.d.ts

@@ -53,8 +53,7 @@ export declare function getTemplateRegistry(): readonly TemplateEntry[];
  */
 export declare function resolveTemplate(query: string, entries: readonly TemplateEntry[]): TemplateResolution;
 /** Seconds a network git call (`fetch`) may take before it is killed.
- *  `summer create` once hung 42 minutes inside a fetch
- *  (docs/design/archive/TK-VS-FOLD-2026-09-07.md, gap 4). */
+ *  `summer create` once hung 42 minutes inside a fetch. */
 export declare const FETCH_TIMEOUT_ENV = "SUMMER_FETCH_TIMEOUT_S";
 export declare const DEFAULT_FETCH_TIMEOUT_S = 120;
 /** The bound in force: FETCH_TIMEOUT_ENV when it is a positive number of

package/dist/core/templates.js

@@ -109,8 +109,7 @@ export function resolveTemplate(query, entries) {
 }
 // ---------- git ----------
 /** Seconds a network git call (`fetch`) may take before it is killed.
- *  `summer create` once hung 42 minutes inside a fetch
- *  (docs/design/archive/TK-VS-FOLD-2026-09-07.md, gap 4). */
+ *  `summer create` once hung 42 minutes inside a fetch. */
 export const FETCH_TIMEOUT_ENV = "SUMMER_FETCH_TIMEOUT_S";
 export const DEFAULT_FETCH_TIMEOUT_S = 120;
 /** The bound in force: FETCH_TIMEOUT_ENV when it is a positive number of

package/dist/mcp/hosted-mount.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type Tool } from "@modelcontextprotocol/sdk/types.js";
+import { type HostedClient, type HostedConnectDependencies } from "../core/hosted-mcp.js";
+export type { HostedClient };
 /**
  * One Summer Engine MCP. The cloud tools a creator's agent needs to publish
  * (projects, store page, build upload, submit for the owner's approval, the
@@ -11,65 +12,16 @@ import { type Tool } from "@modelcontextprotocol/sdk/types.js";
  * that server). A name the local MCP already has stays local (the engine and
  * generation tools keep their CLI-token path).
  *
- * Mounting is lazy: the server answers with the engine tools at once, and the
- * hosted tools appear when the mount finishes (tools/list_changed). Without a
- * store sign-in one tool, summer_store_tools, says how to sign in and mounts
- * on the next call.
+ * Mounting runs after connect. The first tools/list waits for a mount in
+ * progress (up to FIRST_LIST_WAIT_MS), so a host that lists tools once still
+ * sees the store tools; a slower mount adds them later (tools/list_changed).
+ * Without a store sign-in the mount fails at once, and one tool,
+ * summer_store_tools, says how to sign in and mounts on the next call.
  */
 export declare const STORE_TOOLS_STATUS = "summer_store_tools";
-/** The part of an MCP client the mount uses (a fake in tests). */
-export interface HostedClient {
-    listTools(params?: {
-        cursor?: string;
-    }): Promise<{
-        tools: Tool[];
-        nextCursor?: string;
-    }>;
-    callTool(params: {
-        name: string;
-        arguments?: Record<string, unknown>;
-    }): Promise<Record<string, unknown>>;
-    listPrompts(params?: {
-        cursor?: string;
-    }): Promise<{
-        prompts: Array<{
-            name: string;
-            title?: string;
-            description?: string;
-            arguments?: Array<{
-                name: string;
-                description?: string;
-                required?: boolean;
-            }>;
-        }>;
-        nextCursor?: string;
-    }>;
-    getPrompt(params: {
-        name: string;
-        arguments?: Record<string, string>;
-    }): Promise<Record<string, unknown>>;
-    listResources(params?: {
-        cursor?: string;
-    }): Promise<{
-        resources: Array<{
-            uri: string;
-            name: string;
-            title?: string;
-            description?: string;
-            mimeType?: string;
-        }>;
-        nextCursor?: string;
-    }>;
-    readResource(params: {
-        uri: string;
-    }): Promise<Record<string, unknown>>;
-}
-export interface HostedMountDependencies {
-    /** The hosted Summer Engine MCP URL (the store sign-in's resource). */
-    url: () => string;
-    token: () => Promise<string>;
-    connect: (url: string, token: () => Promise<string>) => Promise<HostedClient>;
-}
+/** How long the first tools/list waits for a mount in progress, so hosts that list once see the store tools. */
+export declare const FIRST_LIST_WAIT_MS = 5000;
+export type HostedMountDependencies = HostedConnectDependencies;
 export declare const defaultHostedMountDependencies: HostedMountDependencies;
 export interface HostedMountState {
     status: "idle" | "mounting" | "mounted" | "unavailable";
@@ -90,7 +42,9 @@ export interface HostedMountState {
  * reports each mounted tool's own JSON Schema rather than the passthrough one.
  * Returns mount(), which callers run after connect without awaiting it.
  */
-export declare function prepareHostedMount(server: McpServer, deps?: HostedMountDependencies): {
+export declare function prepareHostedMount(server: McpServer, deps?: HostedMountDependencies, options?: {
+    firstListWaitMs?: number;
+}): {
     mount: () => Promise<HostedMountState>;
     state: HostedMountState;
 };