@mindstudio-ai/remy 0.1.279 → 0.1.281

package/dist/headless.js

@@ -2897,13 +2897,13 @@ var lspDiagnosticsTool = {
 var restartProcessTool = {
   definition: {
     name: "restartProcess",
-    description: "Restart a managed sandbox process. Use this after running npm install or changing package.json to restart the dev server so it picks up new dependencies.",
+    description: 'Restart a managed sandbox process. "devServer": after running npm install or changing package.json in the app frontend, so the dev server picks up new dependencies. "methodsWorker": after upgrading @mindstudio-ai/agent in the methods package \u2014 the long-lived methods worker caches the SDK module and will not pick up the new version otherwise (method source and other dependencies are always fresh; only an SDK upgrade needs this).',
     inputSchema: {
       type: "object",
       properties: {
         name: {
           type: "string",
-          description: 'Process name to restart. Currently supported: "devServer".'
+          description: 'Process name to restart: "devServer" or "methodsWorker".'
         }
       },
       required: ["name"]
@@ -2912,7 +2912,9 @@ var restartProcessTool = {
   async execute(input) {
     const data = await lspRequest("/restart-process", { name: input.name });
     if (data.ok) {
-      await new Promise((resolve4) => setTimeout(resolve4, 5e3));
+      if (input.name !== "methodsWorker") {
+        await new Promise((resolve4) => setTimeout(resolve4, 5e3));
+      }
       return `Restarted ${input.name}.`;
     }
     return `Error: unexpected response: ${JSON.stringify(data)}`;

package/dist/index.js

@@ -4044,13 +4044,13 @@ var init_restartProcess = __esm({
     restartProcessTool = {
       definition: {
         name: "restartProcess",
-        description: "Restart a managed sandbox process. Use this after running npm install or changing package.json to restart the dev server so it picks up new dependencies.",
+        description: 'Restart a managed sandbox process. "devServer": after running npm install or changing package.json in the app frontend, so the dev server picks up new dependencies. "methodsWorker": after upgrading @mindstudio-ai/agent in the methods package \u2014 the long-lived methods worker caches the SDK module and will not pick up the new version otherwise (method source and other dependencies are always fresh; only an SDK upgrade needs this).',
         inputSchema: {
           type: "object",
           properties: {
             name: {
               type: "string",
-              description: 'Process name to restart. Currently supported: "devServer".'
+              description: 'Process name to restart: "devServer" or "methodsWorker".'
             }
           },
           required: ["name"]
@@ -4059,7 +4059,9 @@ var init_restartProcess = __esm({
       async execute(input) {
         const data = await lspRequest("/restart-process", { name: input.name });
         if (data.ok) {
-          await new Promise((resolve4) => setTimeout(resolve4, 5e3));
+          if (input.name !== "methodsWorker") {
+            await new Promise((resolve4) => setTimeout(resolve4, 5e3));
+          }
           return `Restarted ${input.name}.`;
         }
         return `Error: unexpected response: ${JSON.stringify(data)}`;

package/dist/prompt/compiled/interfaces.md

@@ -44,6 +44,7 @@ All fields are nested under the `"web"` key.
 | `devCommand` | `string` | `"npm run dev"` | Command to start the dev server |
 | `defaultPreviewMode` | `"desktop"` \| `"mobile"` | `"desktop"` | Default preview viewport in the editor. Set to `"mobile"` for mobile-first apps. |
 | `prerender` | `object` | — | Opt into prerendering the listed routes/patterns for crawlers/unfurlers. See "Prerendering" below. |
+| `mounts` | `array` | — | Serve other same-workspace apps under path prefixes of this app's hosts. See "Mounting other apps" below. |
 
 ### Frontend SDK
 
@@ -92,6 +93,16 @@ The project uses `"jsx": "react-jsx"` (automatic JSX transform) — do not `impo
 
 On deploy, the platform runs `npm install && npm run build` in the web directory and hosts the output on CDN.
 
+Two serving conventions: set the bundler's public path from `MS_ASSET_BASE_URL` (platform-set at build, unset locally), and take the router basename from `platform.basePath` — don't hardcode root-absolute URLs in app code.
+
+```ts
+// vite.config.ts
+base: process.env.MS_ASSET_BASE_URL || '/',
+
+// router
+createBrowserRouter(routes, { basename: platform.basePath || '/' });
+```
+
 #### Error Handling and Analytics
 
 The SDK automatically reports uncaught errors, unhandled promise rejections, and pageviews to a per-app dashboard the owner gets for free. No setup required. The analytics dashboard covers visits, unique visitors, top pages, referrers, UTM breakdowns, country-level geo, device/browser/OS, new vs returning, and live online count.
@@ -136,6 +147,10 @@ await prerender.invalidate(['/u/abc']); // omit arg to purge all
 
 `mindstudio-prod prerender` can help you verify/manage snapshots during development.
 
+### Mounting other apps
+
+Rare: `mounts` serves another same-workspace app under a path prefix of this app's hosts — `{ "web": { "mounts": [{ "path": "/docs", "app": "docs-site" }] } }` (`app` = the target's `custom_subdomain` or appId). The child is served first-class (its own bundle, session, backend) and needs no mount-specific config; the two serving conventions above are what make an app mountable.
+
 ## API Interface
 
 REST endpoints for external consumers — other services, mobile apps, integrations. This is separate from the web frontend's internal RPC (`@mindstudio-ai/interface` calls `/_/methods` directly and does not use the API interface). The API interface lives at `/_/api/` and exposes only the methods you choose to route.

package/dist/prompt/skills/files.md

@@ -1,6 +1,6 @@
 ---
 name: Files, Storage & CDN
-what: Per-app blob storage the database doesn't model — user uploads, generated documents, marketing images. Stores are private by default (reads authed by the app session, or short-lived signed share links) or deliberately public — public files are CDN-served on the app's own domain and images resize on the fly via query params (width, height, crop, format, dpr), so the frontend requests the size it displays instead of CSS-scaling originals. User uploads go client-direct: the backend mints a token and the browser uploads straight to storage, bytes never pass through a method. SDK actions that produce files (generateImage, generatePdf, …) can write straight into a store, and the CLI uploads build-time assets (heroes, logos, OG images) so binaries never land in git. One store is shared across dev and prod on purpose.
+what: Per-app blob storage the database doesn't model — user uploads, generated documents, marketing images. Stores are private by default (reads authed by the app session, or short-lived signed share links) or deliberately public — public files are CDN-served on the app's own domain with caching set per put via `cacheControl`, and images resize on the fly via query params (width, height, crop, format, dpr), so the frontend requests the size it displays instead of CSS-scaling originals. User uploads go client-direct: the backend mints a token and the browser uploads straight to storage, bytes never pass through a method. SDK actions that produce files (generateImage, generatePdf, …) can write straight into a store, and the CLI uploads build-time assets (heroes, logos, OG images) so binaries never land in git. One store is shared across dev and prod on purpose.
 when: Before defining a file store or writing any upload, download, share-link, or image-serving code — user uploads, generated documents, marketing assets, config blobs, anything durable the app stores outside the database.
 ---
 
@@ -45,7 +45,7 @@ const { files, cursor } = await Uploads.list({ prefix: 'reports/', limit: 100 })
 await Uploads.delete(key);
 ```
 
-- `put(content, { key?, contentType?, filename?, contentAddressed? })` → `StoredFile` (`{ key, url, size?, contentType?, updatedAt?, shareUrl() }`). Omit `key` → UUID; `contentAddressed: true` → a `<sha256>.<ext>` key (immutable/idempotent, for baked-in public assets).
+- `put(content, { key?, contentType?, filename?, contentAddressed?, cacheControl? })` → `StoredFile` (`{ key, url, size?, contentType?, updatedAt?, shareUrl() }`). Omit `key` → UUID; `contentAddressed: true` → a `<sha256>.<ext>` key (immutable/idempotent, for baked-in public assets). `cacheControl` sets a public object's CDN caching — defaults: auto-minted keys (UUID / content-addressed, never reused) → immutable cache-forever; named keys → `public, max-age=300`.
 - **`file.url`** is a plain relative string — don't await it. To display a user *their own* file, hand them `file.url`; don't `get()` the bytes and stream them yourself.
 - **`await file.shareUrl({ expiresIn })`** → an absolute signed link that works with **no session** (email / cross-site embed). Private stores only; default 24h.
 
@@ -85,7 +85,11 @@ Public files are world-readable, served on the app's own domain, and **images re
 
 Combine freely: `…/hero.jpg?w=200&h=200&fit=crop&fm=avif`.
 
-Lightweight-config pattern: a public store + a stable `key` is a file the frontend can `fetch` with no DB hit and the backend can overwrite (`Config.put(json, { key: 'config/latest.json' })`).
+### How public caching works
+
+A public `file.url` resolves through a short-lived redirect (cached ~5 min, stable target) to the CDN object, which is cached per its own `Cache-Control` — set at put time via `cacheControl`. Auto-minted keys (UUID / content-addressed / CLI uploads) are never reused, so they default to `public, max-age=31536000, immutable`; named (overwritable) keys default to `public, max-age=300`, so an overwrite is publicly visible within ~5 minutes. Tune per put: `'public, max-age=60'` for near-live data, `'no-store'` to revalidate every read, `immutable` for a named key you promise never to overwrite. Private files never edge-cache (reads are short-lived signed URLs).
+
+Lightweight-config pattern: a public store + a stable `key` is a file the frontend can `fetch` with no DB hit and the backend can overwrite (`Config.put(json, { key: 'config/latest.json' })`). Overwrites propagate within ~5 minutes by default — pass `cacheControl` if the app needs tighter freshness.
 
 ## Build-time / marketing assets
 

package/dist/prompt/skills/jewels.md

@@ -116,7 +116,13 @@ export default defineJewel(categorizeRecord, {
         maxTurns: 6,
       });
       if (!task.output.category) return { input: null, reasoning: task.output.rationale };
-      return { input: { recordId, category: task.output.category }, reasoning: task.output.rationale };
+      return {
+        input: { recordId, category: task.output.category },
+        reasoning: task.output.rationale,
+        // Preserves the model transcript with the pair: the training row,
+        // and at auto the audit trail.
+        trace: task.traceId,
+      };
     } catch (err) {
       // Couldn't produce conforming output; abstain with the evidence. Fail closed.
       return { input: null, reasoning: `Task agent failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -137,6 +143,7 @@ To preserve signal integrity, the task prompt inside `propose` addresses the mod
 - **Context is plain imports plus tools.** Prefetch what every run needs (the row, its history, the inventory of valid values) into the task input; expose the app's own read methods as tools for what the agent should decide to look up (precedent, comparables). Tool calls are recorded with the pair.
 - **Use `runTask` with `outputSchema` for the judgment.** Build enums at runtime: a candidate-id enum means the agent structurally cannot reference a row that doesn't exist, and a known-values enum means it cannot invent a category. Put `null` in the enum so abstention is a first-class output rather than a formatting accident.
 - **Catch everything; abstain on failure.** A jewel that can't decide returns `{ input: null, reasoning }` with the evidence. It never throws to say "I don't know."
+- **Attach the deciding task's trace.** `trace: task.traceId` on the success return preserves the full model transcript with the pair; use an array when the story has chapters (`trace: [first.traceId, escalation.traceId]`). Helper and formatting calls stay unattached; the attachment is the label for which run WAS the decision. A pair without a trace still grades, but it is thin as evidence and as training data.
 - **Propose a subset when that's the honest scope.** A jewel that never sets `assigneeId` and never proposes `closed` (it can't know a fix shipped) is expressing policy through its output shape.
 - **Reasoning is audit-log prose.** Two or three plain sentences a teammate would find useful; name the evidence. No headers, bullets, or emojis.
 
@@ -182,8 +189,8 @@ grade: async ({ proposed, actual }) => {
     });
     const c = rubric.output;
     return c.sameResolution && c.noContradiction
-      ? { verdict: 'agree' }
-      : { verdict: 'disagree', notes: `Failed: ${[!c.sameResolution && 'sameResolution', !c.noContradiction && 'noContradiction'].filter(Boolean).join(', ')}` };
+      ? { verdict: 'agree', trace: rubric.traceId }
+      : { verdict: 'disagree', notes: `Failed: ${[!c.sameResolution && 'sameResolution', !c.noContradiction && 'noContradiction'].filter(Boolean).join(', ')}`, trace: rubric.traceId };
   } catch (err) {
     return { verdict: 'skip', notes: `Judge failed: ${err instanceof Error ? err.message : String(err)}` };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.279",
+  "version": "0.1.281",
   "description": "Remy coding agent",
   "repository": {
     "type": "git",