summer-engine 3.6.0 → 3.8.0

package/dist/core/capabilities/enable-plugin.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * summer_enable_plugin: enable an editor plugin (`res://addons/<name>/`) and
+ * report what really happened. Engines with Summer Apps support run the
+ * EnableEditorPlugin op until the plugin's `_enter_tree` has run and answer
+ * `enabled` (or a failure `code`); older engines only queue the enable and
+ * answer `deferred: true`, so this tool says the result is unknown instead of
+ * claiming success. One implementation for the MCP tool and `summer tool
+ * enable-plugin`.
+ */
+export declare const enablePluginArgsSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    plugin: string;
+    timeoutMs?: number | undefined;
+}, {
+    plugin: string;
+    timeoutMs?: number | undefined;
+}>;
+export declare function enablePluginOp(args: z.output<typeof enablePluginArgsSchema>): {
+    op: string;
+    [key: string]: unknown;
+};
+export declare const QUEUED_ONLY_NOTE: string;
+/** The engine's answer for EnableEditorPlugin, as one result an agent can trust. */
+export declare function interpretEnablePluginResult(raw: unknown): Record<string, unknown>;

package/dist/core/capabilities/enable-plugin.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { asRecord } from "../util/json.js";
+import { extractOpError } from "./engine-receipt.js";
+/**
+ * summer_enable_plugin: enable an editor plugin (`res://addons/<name>/`) and
+ * report what really happened. Engines with Summer Apps support run the
+ * EnableEditorPlugin op until the plugin's `_enter_tree` has run and answer
+ * `enabled` (or a failure `code`); older engines only queue the enable and
+ * answer `deferred: true`, so this tool says the result is unknown instead of
+ * claiming success. One implementation for the MCP tool and `summer tool
+ * enable-plugin`.
+ */
+export const enablePluginArgsSchema = z.object({
+    plugin: z
+        .string()
+        .min(1)
+        .max(200)
+        .describe("The plugin folder under res://addons/ (e.g. 'quest_tools') or its 'res://addons/<name>/plugin.cfg'"),
+    timeoutMs: z
+        .number()
+        .int()
+        .min(1000)
+        .max(120_000)
+        .optional()
+        .describe("How long the engine waits for the plugin to load (default 30000)"),
+});
+export function enablePluginOp(args) {
+    return { op: "EnableEditorPlugin", pluginPath: args.plugin.trim(), ...(args.timeoutMs ? { timeoutMs: args.timeoutMs } : {}) };
+}
+const FAILURE_HINTS = {
+    CFG_MISSING: "No plugin.cfg there. Check the folder name under res://addons/.",
+    CFG_PARSE_FAILED: "plugin.cfg does not parse. Fix it and enable again.",
+    NO_SCRIPT_KEY: "plugin.cfg needs a script= entry under [plugin].",
+    EMPTY_SCRIPT_PATH: "plugin.cfg needs a script= entry under [plugin].",
+    SCRIPT_MISSING: "The script plugin.cfg names does not exist.",
+    SCRIPT_LOAD_FAILED: "The plugin script did not load. Read summer_get_script_errors for it.",
+    SCRIPT_ERROR: "The plugin script has errors. Read summer_get_script_errors, fix them, and enable again.",
+    NOT_EDITOR_PLUGIN: "The plugin script must extend EditorPlugin.",
+    NOT_TOOL: "The plugin script must start with @tool.",
+    TIMEOUT: "The plugin did not finish loading in time (often a filesystem scan). Try again, or raise timeoutMs.",
+};
+export const QUEUED_ONLY_NOTE = "This Summer Engine build only queues the enable and does not report whether the plugin loaded. " +
+    "Check summer_get_debugger_errors and summer_get_script_errors for the plugin script before relying on it, or update Summer Engine for the real result.";
+/** The engine's answer for EnableEditorPlugin, as one result an agent can trust. */
+export function interpretEnablePluginResult(raw) {
+    const root = asRecord(raw) ?? {};
+    const results = Array.isArray(root.results) ? root.results : [];
+    const entry = asRecord(results.find((item) => asRecord(item)?.op === "EnableEditorPlugin") ?? results[0]) ?? root;
+    const addonPath = typeof entry.addonPath === "string" ? entry.addonPath : undefined;
+    const error = extractOpError(raw) ?? (entry.ok === false ? String(entry.error ?? "The plugin was not enabled.") : null);
+    if (error) {
+        const code = typeof entry.code === "string" ? entry.code : undefined;
+        return {
+            ok: false,
+            enabled: false,
+            ...(addonPath ? { addonPath } : {}),
+            ...(code ? { code } : {}),
+            error,
+            ...(code && FAILURE_HINTS[code] ? { hint: FAILURE_HINTS[code] } : {}),
+        };
+    }
+    if (entry.alreadyEnabled === true)
+        return { ok: true, enabled: true, alreadyEnabled: true, ...(addonPath ? { addonPath } : {}) };
+    if (entry.enabled === true) {
+        return {
+            ok: true,
+            enabled: true,
+            ...(addonPath ? { addonPath } : {}),
+            autoloadsRegistered: Array.isArray(entry.autoloadsRegistered) ? entry.autoloadsRegistered : [],
+            ...(typeof entry.elapsedMs === "number" ? { elapsedMs: entry.elapsedMs } : {}),
+        };
+    }
+    // Older engines: { ok: true, deferred: true } means "scheduled", not "loaded".
+    return { ok: true, enabled: null, queued: true, ...(addonPath ? { addonPath } : {}), note: QUEUED_ONLY_NOTE };
+}

package/dist/core/capabilities/seeing/args.d.ts

@@ -306,7 +306,7 @@ export declare const frameShotArgsSchema: z.ZodObject<{
     render: z.ZodOptional<z.ZodEnum<["sheet", "best", "none"]>>;
     max_size: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    shot: "detail" | "establishing" | "eye_level" | "low_angle" | "corridor";
+    shot: "establishing" | "eye_level" | "low_angle" | "detail" | "corridor";
     spawn?: string | undefined;
     scenePath?: string | undefined;
     fov?: number | undefined;
@@ -326,7 +326,7 @@ export declare const frameShotArgsSchema: z.ZodObject<{
     max_soft_fraction?: number | undefined;
     save_bookmark?: boolean | undefined;
 }, {
-    shot: "detail" | "establishing" | "eye_level" | "low_angle" | "corridor";
+    shot: "establishing" | "eye_level" | "low_angle" | "detail" | "corridor";
     spawn?: string | undefined;
     scenePath?: string | undefined;
     fov?: number | undefined;

package/dist/core/capabilities/seeing/seeing.d.ts

@@ -230,4 +230,4 @@ export interface CorridorScanFloor {
 }
 export declare function scanFloorText(floor: CorridorScanFloor, subject: Aabb): string;
 export declare function frameShot(client: SeeingClient, args: FrameShotArgs): Promise<SeeingResult>;
-export declare const SHOT_TYPE_DEFAULTS: Record<"detail" | "establishing" | "eye_level" | "low_angle" | "corridor", import("./candidates.js").ShotDefaults>;
+export declare const SHOT_TYPE_DEFAULTS: Record<"establishing" | "eye_level" | "low_angle" | "detail" | "corridor", import("./candidates.js").ShotDefaults>;

package/dist/core/capabilities/sfx-choices.d.ts

@@ -7,6 +7,8 @@ import { z } from "zod";
  * POST /api/mcp/generate/audio/choices makes the versions and a choice set,
  * the person listens and approves one or more on the Studio page
  * /studio/choices/<id>, and GET /api/mcp/choices/<id> reads the decision.
+ * The server queues the page for the person's open Studio tab itself
+ * (studioTab.queued); only when no tab took it does this open a browser.
  * An approval makes that model the person's default for later
  * summer_generate_audio sound_effects calls without a modelId.
  *
@@ -58,17 +60,9 @@ export interface GatewayReply {
     error?: string;
     status: number;
 }
-export type StudioOpenOutcome = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-};
 export interface SfxChoicesDeps {
     post(endpoint: string, body: Record<string, unknown>, timeoutMs: number): Promise<GatewayReply>;
     get(endpoint: string, params: URLSearchParams, timeoutMs: number): Promise<GatewayReply>;
-    /** Move the person's open Studio tab to a /studio path (reviewUrl: the same page as a full URL). */
-    studioOpen(path: string, reviewUrl: string): Promise<StudioOpenOutcome>;
     openUrl(url: string): Promise<unknown>;
     canOpenBrowser(): boolean;
 }
@@ -77,13 +71,6 @@ export type ShownIn = "studio_tab" | "browser" | "not_opened";
 export declare function canOpenReviewUrl(url: string): boolean;
 /** False where a browser launch cannot reach the person: CI, or Linux with no display. */
 export declare function defaultCanOpenBrowser(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
-/**
- * Move the person's open Studio tab through the hosted Summer Engine MCP's
- * summer_studio_open (needs the store sign-in). Only for the production site:
- * the hosted MCP moves tabs on summerengine.com, so a review page on another
- * origin (a preview deploy, local web dev) is opened in the browser instead.
- */
-export declare function openInStudioTab(path: string, reviewUrl: string): Promise<StudioOpenOutcome>;
 export declare function sfxChoicesRequestBody(args: z.output<typeof sfxChoicesArgsSchema>): Record<string, unknown>;
 export declare function generateSfxChoices(args: z.output<typeof sfxChoicesArgsSchema>, deps: SfxChoicesDeps): Promise<Record<string, unknown>>;
 export declare function choicesEndpoint(choiceSetId: string): string;

package/dist/core/capabilities/sfx-choices.js

@@ -1,6 +1,4 @@
 import { z } from "zod";
-import { hasStoreSignIn, hostedResultPayload, withHostedMcp } from "../hosted-mcp.js";
-import { resolveMcpResourceUrl } from "../oauth.js";
 /**
  * Sound-effect choices (summer_generate_sfx_choices + summer_get_choices).
  *
@@ -9,6 +7,8 @@ import { resolveMcpResourceUrl } from "../oauth.js";
  * POST /api/mcp/generate/audio/choices makes the versions and a choice set,
  * the person listens and approves one or more on the Studio page
  * /studio/choices/<id>, and GET /api/mcp/choices/<id> reads the decision.
+ * The server queues the page for the person's open Studio tab itself
+ * (studioTab.queued); only when no tab took it does this open a browser.
  * An approval makes that model the person's default for later
  * summer_generate_audio sound_effects calls without a modelId.
  *
@@ -22,7 +22,6 @@ export const CHOICES_ENDPOINT_PREFIX = "/api/mcp/choices/";
 /** Three models run in parallel on the server; the slowest decides. */
 export const SFX_CHOICES_TIMEOUT_MS = 240_000;
 export const MAX_CHOICES_WAIT_SECONDS = 50;
-const STUDIO_OPEN_TIMEOUT_MS = 20_000;
 export const sfxChoicesArgsSchema = z.object({
     text: z
         .string()
@@ -48,7 +47,7 @@ export const sfxChoicesArgsSchema = z.object({
     open: z
         .boolean()
         .default(true)
-        .describe("Show the choices page to the person (their open Studio tab, else the browser). false: only return the URL"),
+        .describe("Show the choices page in the browser when no open Studio tab took it. false: no browser, only return the URL"),
 });
 export const getChoicesArgsSchema = z.object({
     choiceSetId: z.string().min(1).max(200).describe("The choiceSetId from summer_generate_sfx_choices"),
@@ -90,70 +89,28 @@ export function defaultCanOpenBrowser(env = process.env, platform = process.plat
         return false;
     return true;
 }
-/**
- * Move the person's open Studio tab through the hosted Summer Engine MCP's
- * summer_studio_open (needs the store sign-in). Only for the production site:
- * the hosted MCP moves tabs on summerengine.com, so a review page on another
- * origin (a preview deploy, local web dev) is opened in the browser instead.
- */
-export async function openInStudioTab(path, reviewUrl) {
-    if (!isSummerHost(hostOf(reviewUrl)))
-        return { ok: false, reason: "review_page_not_on_summerengine_com" };
-    let resource;
-    try {
-        resource = resolveMcpResourceUrl();
-    }
-    catch {
-        return { ok: false, reason: "hosted_mcp_url_invalid" };
-    }
-    if (!isSummerHost(hostOf(resource)))
-        return { ok: false, reason: "hosted_mcp_not_summerengine_com" };
-    if (!(await hasStoreSignIn()))
-        return { ok: false, reason: "no_store_sign_in" };
-    let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ ok: false, reason: "studio_tab_timeout" }), STUDIO_OPEN_TIMEOUT_MS);
-        timer.unref?.();
-    });
-    const attempt = (async () => {
-        try {
-            const result = await withHostedMcp((client) => client.callTool({ name: "summer_studio_open", arguments: { path } }));
-            const payload = hostedResultPayload(result);
-            if (payload.isError || payload.json?.ok === false) {
-                const code = typeof payload.json?.error === "string" ? payload.json.error : "studio_open_failed";
-                return { ok: false, reason: code };
-            }
-            return { ok: true };
-        }
-        catch (error) {
-            return { ok: false, reason: error instanceof Error ? error.message : String(error) };
-        }
-    })();
-    try {
-        return await Promise.race([attempt, timeout]);
-    }
-    finally {
-        clearTimeout(timer);
-    }
+/** The server's studioTab answer: queued for the person's open tab, or why not. Missing on older servers. */
+function studioTabAnswer(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    return {
+        queued: record.queued === true,
+        ...(typeof record.reason === "string" ? { reason: record.reason } : {}),
+    };
 }
-async function showChoicesPage(reviewUrl, studioPath, deps) {
-    let studioTab;
-    if (studioPath) {
-        const moved = await deps.studioOpen(studioPath, reviewUrl);
-        if (moved.ok)
-            return { shown: "studio_tab" };
-        studioTab = moved.reason;
-    }
+async function showChoicesPage(reviewUrl, studioTab, deps) {
+    const notQueued = studioTab ? (studioTab.reason ?? "not_queued") : undefined;
     if (!canOpenReviewUrl(reviewUrl))
-        return { shown: "not_opened", studioTab, browser: "not_a_summer_url" };
+        return { shown: "not_opened", studioTab: notQueued, browser: "not_a_summer_url" };
     if (!deps.canOpenBrowser())
-        return { shown: "not_opened", studioTab, browser: "no_browser_here" };
+        return { shown: "not_opened", studioTab: notQueued, browser: "no_browser_here" };
     try {
         await deps.openUrl(reviewUrl);
-        return { shown: "browser", studioTab };
+        return { shown: "browser", studioTab: notQueued };
     }
     catch (error) {
-        return { shown: "not_opened", studioTab, browser: error instanceof Error ? error.message : String(error) };
+        return { shown: "not_opened", studioTab: notQueued, browser: error instanceof Error ? error.message : String(error) };
     }
 }
 // ---------------------------------------------------------------------------
@@ -198,9 +155,14 @@ export async function generateSfxChoices(args, deps) {
             hint: "Read failed[] for each model's error. Fix the request (a longer durationSeconds, a plainer description) or call summer_generate_audio with one modelId.",
         };
     }
-    const shown = args.open
-        ? await showChoicesPage(reviewUrl, studioPath, deps)
-        : { shown: "not_opened", browser: "open_false" };
+    // The server queued the Studio-tab open already; that happens even with
+    // open:false, so report it rather than hide it.
+    const studioTab = studioTabAnswer(data.studioTab);
+    const shown = studioTab?.queued
+        ? { shown: "studio_tab" }
+        : args.open
+            ? await showChoicesPage(reviewUrl, studioTab, deps)
+            : { shown: "not_opened", browser: "open_false" };
     const count = clips.length;
     const where = shown.shown === "studio_tab"
         ? "I opened them in your Summer Studio tab"

package/dist/core/capabilities/tool-dispatch.js

@@ -30,7 +30,7 @@ import { lookupApiDocs } from "./api-docs.js";
 import { BOARD_ENDPOINT, boardArgsSchema, boardQuery } from "./board.js";
 import { IMAGE_GENERATION_TIMEOUT_MS, imageGenerationArgsSchema, saveGeneratedImage } from "./image-generation.js";
 import { buildMotionRequestBody, motionGenerationArgsSchema } from "./motion-generation.js";
-import { defaultCanOpenBrowser, generateSfxChoices, getChoices, getChoicesArgsSchema, openInStudioTab, sfxChoicesArgsSchema, } from "./sfx-choices.js";
+import { defaultCanOpenBrowser, generateSfxChoices, getChoices, getChoicesArgsSchema, sfxChoicesArgsSchema, } from "./sfx-choices.js";
 import { ImportHdriError, importHdriArgsSchema, importPolyHavenHdri } from "./hdri-import.js";
 import { FABRICATE_FALLBACK, buildFabricateMeshOp, fabricateArgsSchema } from "./fabricate-mesh.js";
 import { buildUiActionsOp, buildUiActivateOp, buildUiScreenshotOp, buildUiTreeOp, executeUiOp, uiActionsArgsSchema, uiActivateArgsSchema, uiScreenshotArgsSchema, uiScreenshotCaption, uiScreenshotImage, uiTreeArgsSchema, withUiFailureDetails, } from "./ui-control.js";
@@ -47,12 +47,11 @@ import { getAuthToken } from "../auth.js";
 import open from "open";
 import { openArgsSchema, runOpen } from "./navigation/open.js";
 import { shapeEngineLogResponse } from "../log-filters.js";
-import { listCreatorReleases, publishCreator, } from "./creator.js";
 import { exportGame } from "./export-game.js";
 import { exportTemplates } from "./export-templates.js";
 import { captureGameplay } from "./capture-gameplay.js";
 import { publishBuild } from "./publish-build.js";
-import { CONFIG_KEYS, getConfigValue, isConfigKey, readSummerConfig, resolveGatewayUrl, setConfigValue, unsetConfigValue, } from "../config.js";
+import { resolveGatewayUrl } from "../config.js";
 import { createDebugReportArtifact } from "./debug-report.js";
 import { buildGameTaskPlan, gameTaskPlanInputSchema } from "./game-task-plan.js";
 import { buildProjectContext, projectContextInputSchema, projectSettingValue, } from "./project-context.js";
@@ -77,6 +76,8 @@ import { attachToSurface, attachToSurfaceArgsSchema, connectPorts, connectPortsA
 import { readLibraryEntry, readLibraryInputSchema } from "../library-read.js";
 import { runSearchLibrary, searchLibraryInputSchema } from "../library-search.js";
 import { TOOLKIT_VERSION as CLI_VERSION } from "../version.js";
+import { APP_DOCK_FALLBACK, appCall, appCallArgsSchema, appCreate, appCreateArgsSchema, appData, appDataArgsSchema, appDockArgsSchema, appDockOp, appEvents, appEventsArgsSchema, appGet, appGetArgsSchema, appGuide, appGuideArgsSchema, appList, appListArgsSchema, appPage, appPageArgsSchema, appScreenshot, appScreenshotArgsSchema, appUpdate, appUpdateArgsSchema, appPublish, appPublishArgsSchema, appReportGap, appReportGapArgsSchema, appsGateway, appTools, appToolsArgsSchema, } from "./apps.js";
+import { enablePluginArgsSchema, enablePluginOp, interpretEnablePluginResult } from "./enable-plugin.js";
 /** Dispatch-level failure with a user-facing message (no stack needed). */
 export class ToolDispatchError extends Error {
 }
@@ -405,11 +406,18 @@ async function gatewayReply(call) {
         return { error: error.message, status: 0 };
     }
 }
+/** summer tool app-screenshot: the PNG goes to `out` (default ./summer-app-screenshot.png), not into the printed JSON. */
+async function cliScreenshot(args, deps) {
+    const shot = await appScreenshot({ ...args, out: args.out ?? "summer-app-screenshot.png" }, deps);
+    if (shot.ok !== true || !("image" in shot))
+        return shot;
+    const { image: _image, ...report } = shot;
+    return report;
+}
 function sfxChoicesDeps() {
     return {
         post: (endpoint, body, timeoutMs) => gatewayReply(() => gatewayPost(endpoint, body, timeoutMs)),
         get: (endpoint, params, timeoutMs) => gatewayReply(() => gatewayGet(endpoint, params, timeoutMs)),
-        studioOpen: (path, reviewUrl) => openInStudioTab(path, reviewUrl),
         openUrl: (url) => open(url),
         canOpenBrowser: () => defaultCanOpenBrowser(),
     };
@@ -674,56 +682,6 @@ export const TOOL_DISPATCH = [
         ...(typeof args.waitSeconds === "number" ? { waitSeconds: args.waitSeconds } : {}),
         face: "cli",
     })),
-    entry("summer_creator_publish", "Deprecated: publish a .pck to the legacy creator API; use publish-build", false, (args) => publishCreator({
-        project: optStr(args, "project"),
-        artifact: optStr(args, "artifact"),
-        version: optStr(args, "version"),
-        manifest: optStr(args, "manifest"),
-        projectId: optStr(args, "projectId"),
-        channel: optStr(args, "channel"),
-        notes: optStr(args, "notes"),
-        confirm: args.confirm === true,
-        face: "cli",
-    })),
-    entry("summer_creator_releases", "Deprecated: list releases on the legacy creator API; use summer_store_releases", false, (args) => listCreatorReleases({
-        projectId: optStr(args, "projectId"),
-        limit: typeof args.limit === "number" ? args.limit : 20,
-        cursor: optStr(args, "cursor"),
-        face: "cli",
-    })),
-    entry("summer_creator_config", "Read or update the shared non-secret Summer configuration", false, async (args) => {
-        const action = str(args, "action");
-        if (action === "list") {
-            const config = await readSummerConfig();
-            return {
-                ok: true,
-                values: Object.fromEntries(CONFIG_KEYS.map((name) => [name, getConfigValue(config, name) ?? null])),
-            };
-        }
-        const key = optStr(args, "key");
-        if (!key || !isConfigKey(key)) {
-            throw new ToolDispatchError(`A valid key is required. Use one of ${CONFIG_KEYS.join(", ")}.`);
-        }
-        if (action === "get") {
-            return { ok: true, key, value: getConfigValue(await readSummerConfig(), key) ?? null };
-        }
-        if (args.confirm !== true) {
-            throw new ToolDispatchError(`Changing ${key} requires confirmation. Retry with "confirm": true after the user approves the exact change.`);
-        }
-        if (action === "set") {
-            const value = optStr(args, "value");
-            if (value === undefined) {
-                throw new ToolDispatchError(`A value is required for ${key}.`);
-            }
-            const config = await setConfigValue(key, value);
-            return { ok: true, key, value: getConfigValue(config, key) };
-        }
-        if (action === "unset") {
-            const config = await unsetConfigValue(key);
-            return { ok: true, key, value: getConfigValue(config, key) ?? null };
-        }
-        throw new ToolDispatchError(`Unknown action "${action}". Use list, get, set, or unset.`);
-    }),
     // --- debug ---
     entry("summer_get_diagnostics", "Overview of editor console and runtime debugger errors/warnings", true, async (args, ctx) => requireEngineSuccess(await (await ctx.engine()).getDiagnostics())),
     entry("summer_get_console", "Read recent editor Output panel messages (deduplicated)", true, async (args, ctx) => {
@@ -958,6 +916,45 @@ export const TOOL_DISPATCH = [
             throw new ToolResultError(result, String(result.error));
         return result;
     }),
+    // Summer Apps (core/capabilities/apps.ts): the same functions as the MCP face.
+    ...[
+        ["summer_app_guide", "Read the Summer Apps build guide (SDK, manifest, kit, layout, design, examples)", appGuideArgsSchema, appGuide],
+        ["summer_app_list", "List the Summer Apps in the person's workspaces", appListArgsSchema, appList],
+        ["summer_app_create", "Create a scratch Summer App and open it in Summer Studio", appCreateArgsSchema, appCreate],
+        ["summer_app_publish", "Publish a new version of a Summer App from a folder or files", appPublishArgsSchema, appPublish],
+        ["summer_app_get", "Read a Summer App's manifest, files and data summary", appGetArgsSchema, appGet],
+        ["summer_app_update", "Rename a Summer App or keep, archive or restore it", appUpdateArgsSchema, appUpdate],
+        ["summer_app_events", "Wait for events a Summer App sends to agents", appEventsArgsSchema, appEvents],
+        ["summer_app_page", "Read or use the open app's declared fields and buttons", appPageArgsSchema, appPage],
+        ["summer_app_data", "Read or write a Summer App's shared data", appDataArgsSchema, appData],
+        ["summer_app_screenshot", "See a Summer App rendered (read-only) with its console and errors; out saves the PNG", appScreenshotArgsSchema, cliScreenshot],
+        ["summer_app_tools", "List a Summer App's agent tools", appToolsArgsSchema, appTools],
+        ["summer_app_call", "Run a Summer App's agent tool in the person's open app", appCallArgsSchema, appCall],
+        ["summer_app_report_gap", "Report an SDK capability a Summer App needed", appReportGapArgsSchema, appReportGap],
+    ].map(([name, summary, schema, run]) => entry(name, summary, false, async (args) => {
+        const result = await run(parseToolArgs(schema, args, name.replace(/^summer_/, "").replace(/_/g, "-")), { request: appsGateway("cli", name) });
+        if (result.ok !== true)
+            throw new ToolResultError(result, String(result.error));
+        return result;
+    })),
+    entry("summer_enable_plugin", "Enable an editor plugin and report whether it really loaded", true, async (args, ctx) => {
+        const parsed = parseToolArgs(enablePluginArgsSchema, args, "enable-plugin");
+        const result = interpretEnablePluginResult(await (await ctx.engine()).executeOps([enablePluginOp(parsed)]));
+        if (result.ok !== true)
+            throw new ToolResultError(result, String(result.error));
+        return result;
+    }),
+    entry("summer_app_dock", "Dock a Summer App in the editor, close its dock, or list docks", true, async (args, ctx) => {
+        const parsed = parseToolArgs(appDockArgsSchema, args, "app-dock");
+        if (parsed.action !== "list" && !parsed.appId)
+            throw new ToolDispatchError(`${parsed.action} needs appId`);
+        const op = appDockOp(parsed);
+        const client = await ctx.engine();
+        const missing = missingEngineOpResult(client, op.op, APP_DOCK_FALLBACK);
+        if (missing)
+            throw new ToolResultError({ ...missing }, missing.error);
+        return requireEngineSuccess(await client.executeOps([op]));
+    }),
     entry("summer_generate_3d", "Generate a 3D model (optional auto-rig + animations)", false, async (args) => {
         const options = {
             ...(args.options ?? {}),

package/dist/core/capability-skew.js

@@ -49,6 +49,10 @@ export const CLI_KNOWN_OP_NEEDS = [
     // engine's one-table op; the other three are the legacy
     // fallbacks on engines that predate it.
     "Navigate", "OpenResource", "FocusDock", "RevealInFileSystem",
+    // Summer Apps editor docks (summer_app_dock: core/capabilities/apps.ts)
+    "OpenAppDock", "CloseAppDock", "ListAppDocks",
+    // summer_enable_plugin (core/capabilities/enable-plugin.ts)
+    "EnableEditorPlugin",
     // Project + input
     "ProjectSetting", "InputMapAddAction", "InputMapBind",
     // Files (summer_write_file / summer_replace_text / summer_create_scene)

package/dist/core/config.d.ts

@@ -3,13 +3,8 @@ export interface SummerConfig {
     gateway?: {
         url?: string;
     };
-    creator?: {
-        apiUrl?: string;
-        projectId?: string;
-        channel?: string;
-    };
 }
-export declare const CONFIG_KEYS: readonly ["gateway.url", "creator.apiUrl", "creator.projectId", "creator.channel"];
+export declare const CONFIG_KEYS: readonly ["gateway.url"];
 export type ConfigKey = (typeof CONFIG_KEYS)[number];
 export declare function readSummerConfig(): Promise<SummerConfig>;
 export declare function getConfigValue(config: SummerConfig, key: ConfigKey): string | undefined;
@@ -27,4 +22,3 @@ export declare function isConfigKey(value: string): value is ConfigKey;
  * Returns an origin-like base without a trailing slash.
  */
 export declare function resolveGatewayUrl(): Promise<string>;
-export declare function getCreatorApiUrl(): Promise<string>;

package/dist/core/config.js

@@ -1,13 +1,7 @@
 import { readStoreJson, writeStoreJson } from "./store.js";
 const CONFIG_FILE = "config.json";
 const DEFAULT_GATEWAY_URL = "https://www.summerengine.com";
-const DEFAULT_CREATOR_API_URL = "https://summercraft.ai";
-export const CONFIG_KEYS = [
-    "gateway.url",
-    "creator.apiUrl",
-    "creator.projectId",
-    "creator.channel",
-];
+export const CONFIG_KEYS = ["gateway.url"];
 function emptyConfig() {
     return { schemaVersion: 1 };
 }
@@ -39,90 +33,30 @@ function validateGatewayUrl(value) {
     }
     return parsed.toString().replace(/\/+$/, "");
 }
-function validateCreatorApiUrl(value) {
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        throw new Error('creator.apiUrl must be a complete URL. Recovery: use "summer config set creator.apiUrl https://summercraft.ai".');
-    }
-    const local = parsed.hostname === "localhost" ||
-        parsed.hostname === "127.0.0.1" ||
-        parsed.hostname === "[::1]";
-    if (parsed.protocol !== "https:" && !(local && parsed.protocol === "http:")) {
-        throw new Error("creator.apiUrl must use HTTPS (HTTP is allowed only for localhost). Recovery: set an HTTPS URL and retry.");
-    }
-    if (parsed.username ||
-        parsed.password ||
-        parsed.pathname !== "/" ||
-        parsed.search ||
-        parsed.hash) {
-        throw new Error("creator.apiUrl must be an origin without credentials, a path, query parameters, or fragments.");
-    }
-    return parsed.origin;
-}
 function validateValue(key, value) {
     const clean = value.trim();
     if (!clean) {
         throw new Error(`Cannot set ${key} to an empty value. Recovery: provide a value, or run "summer config unset ${key}".`);
     }
-    if (key === "gateway.url")
-        return validateGatewayUrl(clean);
-    if (key === "creator.apiUrl")
-        return validateCreatorApiUrl(clean);
-    if (key === "creator.channel" && !/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(clean)) {
-        throw new Error("creator.channel may contain letters, numbers, dots, underscores, and hyphens. Recovery: choose a channel such as production or preview.");
-    }
-    if (key === "creator.projectId" && clean.length > 128) {
-        throw new Error("creator.projectId is too long. Recovery: copy the project ID from the Summer creator dashboard and retry.");
-    }
-    return clean;
+    return validateGatewayUrl(clean);
 }
 export function getConfigValue(config, key) {
-    if (key === "gateway.url")
-        return config.gateway?.url;
-    if (key === "creator.apiUrl")
-        return config.creator?.apiUrl;
-    if (key === "creator.projectId")
-        return config.creator?.projectId;
-    return config.creator?.channel;
+    return config.gateway?.url;
 }
 export async function setConfigValue(key, rawValue) {
     const config = await readSummerConfig();
     const value = validateValue(key, rawValue);
-    if (key === "gateway.url") {
-        config.gateway = { ...config.gateway, url: value };
-    }
-    else if (key === "creator.apiUrl") {
-        config.creator = { ...config.creator, apiUrl: value };
-    }
-    else if (key === "creator.projectId") {
-        config.creator = { ...config.creator, projectId: value };
-    }
-    else {
-        config.creator = { ...config.creator, channel: value };
-    }
+    config.gateway = { ...config.gateway, url: value };
     await writeStoreJson(CONFIG_FILE, config);
     return config;
 }
 export async function unsetConfigValue(key) {
     const config = await readSummerConfig();
-    if (key === "gateway.url" && config.gateway)
+    if (config.gateway)
         delete config.gateway.url;
-    if (key === "creator.apiUrl" && config.creator)
-        delete config.creator.apiUrl;
-    if (key === "creator.projectId" && config.creator) {
-        delete config.creator.projectId;
-    }
-    if (key === "creator.channel" && config.creator)
-        delete config.creator.channel;
     if (config.gateway && Object.keys(config.gateway).length === 0) {
         delete config.gateway;
     }
-    if (config.creator && Object.keys(config.creator).length === 0) {
-        delete config.creator;
-    }
     await writeStoreJson(CONFIG_FILE, config);
     return config;
 }
@@ -147,7 +81,3 @@ export async function resolveGatewayUrl() {
     const configured = config.gateway?.url?.trim();
     return configured ? validateGatewayUrl(configured) : DEFAULT_GATEWAY_URL;
 }
-export async function getCreatorApiUrl() {
-    const config = await readSummerConfig();
-    return config.creator?.apiUrl ?? DEFAULT_CREATOR_API_URL;
-}

package/dist/mcp/hosted-mount.js

@@ -1,4 +1,4 @@
-import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { connectHostedMcp } from "../core/hosted-mcp.js";
 import { getStoreAccessToken, OAuthError, resolveMcpResourceUrl } from "../core/oauth.js";
@@ -79,6 +79,18 @@ export function prepareHostedMount(server, deps = defaultHostedMountDependencies
             };
         });
     }
+    // tools/call for a name the server does not know yet: a hosted tool whose mount
+    // is still running (an agent that calls before it lists). Wait for that mount,
+    // at most the first-list cap, then dispatch; an unknown name still errors.
+    const callTool = handlers.get("tools/call");
+    if (callTool) {
+        server.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            const name = request.params?.name;
+            if (typeof name === "string" && !(name in registries._registeredTools))
+                await waitForMount(firstListWaitMs);
+            return (await callTool(request, extra));
+        });
+    }
     let statusTool = null;
     let running = null;
     /** Wait for a mount in progress, at most ms; returns at once when none runs. */

package/dist/mcp/server.d.ts

@@ -11,7 +11,8 @@ export declare const getCachedBootDriftNotice: typeof getCachedNotice;
  * turn and would otherwise learn the hard way. Kept under 600 characters so
  * it costs a few hundred tokens once; the full operating guide stays in the
  * summer_agent_playbook prompt / summer_get_agent_playbook tool. The last
- * sentence names the publishing path and the owner-approval rule.
+ * sentence names the publishing path, the owner-approval rule and where
+ * review feedback is read.
  */
 export declare const SUMMER_MCP_INSTRUCTIONS: string;
 export declare function configureMcpEngineSelection(selection?: EngineSelection): void;