@mindstudio-ai/remy 0.1.287 → 0.1.289

package/dist/headless.js

@@ -1963,10 +1963,11 @@ function stripDollarKeys(envelope) {
 }
 
 // src/tools/common/searchGoogle.ts
+var FETCH_TOP_N = 5;
 var searchGoogleTool = {
   definition: {
     name: "searchGoogle",
-    description: "Search Google and return results. Use for research, finding documentation, looking up APIs, or any task where web search would help.",
+    description: "Search Google and return results. Use for research, finding documentation, looking up APIs, or any task where web search would help. The top results come back with their page content already included, so read those before reaching for scrapeWebUrl \u2014 you only need that for URLs this did not return, or for a result further down the list.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1981,7 +1982,15 @@ var searchGoogleTool = {
   async execute(input, context) {
     const query = input.query;
     return runMindstudioCli(
-      ["search-google", "--query", query, "--export-type", "json"],
+      [
+        "search-google",
+        "--query",
+        query,
+        "--export-type",
+        "json",
+        "--fetch-top-n",
+        String(FETCH_TOP_N)
+      ],
       {
         outputKey: "results",
         maxBuffer: SEARCH_MAX_BUFFER,
@@ -4750,9 +4759,10 @@ __export(searchGoogle_exports, {
   definition: () => definition,
   execute: () => execute
 });
+var FETCH_TOP_N2 = 5;
 var definition = {
   name: "searchGoogle",
-  description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, or find something specific if the the user has an explicit reference. Searching for and reading case studies is a great way to get information and context about a project\'s domain. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. Pick one or more URLs from the results and then use `scrapeWebUrl` to get their text content.',
+  description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, or find something specific if the the user has an explicit reference. Searching for and reading case studies is a great way to get information and context about a project\'s domain. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. The top results come back with their page content already included, so read those directly \u2014 only use `scrapeWebUrl` for a result further down the list, or for a URL this did not return.',
   inputSchema: {
     type: "object",
     properties: {
@@ -4766,7 +4776,15 @@ var definition = {
 };
 async function execute(input, onLog) {
   return runMindstudioCli(
-    ["search-google", "--query", input.query, "--export-type", "json"],
+    [
+      "search-google",
+      "--query",
+      input.query,
+      "--export-type",
+      "json",
+      "--fetch-top-n",
+      String(FETCH_TOP_N2)
+    ],
     {
       outputKey: "results",
       onLog,
@@ -5577,7 +5595,7 @@ var WIREFRAMES_DIR = "src/.wireframes";
 var UPLOAD_TIMEOUT_MS2 = 3e4;
 var definition10 = {
   name: "createWireframe",
-  description: "Create (or revise) a wireframe from self-contained HTML+CSS. The wireframe is saved to src/.wireframes/{slug}.html \u2014 reference it in your response and in specs as ![name](src/.wireframes/{slug}.html), with your notes in the surrounding prose. Calling again with the same slug overwrites the wireframe in place, so a revision keeps its path and existing references stay current.",
+  description: "Create (or revise) a wireframe from self-contained HTML+CSS. Call this while working to generate a sharable wireframe asset: the result returns the exact markdown reference line to paste into your response and into specs (like generateImages returns the image URL). Calling again with the same slug overwrites the wireframe in place, so a revision keeps its path and existing references stay current.",
   inputSchema: {
     type: "object",
     properties: {

package/dist/index.js

@@ -1509,16 +1509,17 @@ var init_runMindstudioCli = __esm({
 });
 
 // src/tools/common/searchGoogle.ts
-var searchGoogleTool;
+var FETCH_TOP_N, searchGoogleTool;
 var init_searchGoogle = __esm({
   "src/tools/common/searchGoogle.ts"() {
     "use strict";
     init_runMindstudioCli();
     init_runCli();
+    FETCH_TOP_N = 5;
     searchGoogleTool = {
       definition: {
         name: "searchGoogle",
-        description: "Search Google and return results. Use for research, finding documentation, looking up APIs, or any task where web search would help.",
+        description: "Search Google and return results. Use for research, finding documentation, looking up APIs, or any task where web search would help. The top results come back with their page content already included, so read those before reaching for scrapeWebUrl \u2014 you only need that for URLs this did not return, or for a result further down the list.",
         inputSchema: {
           type: "object",
           properties: {
@@ -1533,7 +1534,15 @@ var init_searchGoogle = __esm({
       async execute(input, context) {
         const query = input.query;
         return runMindstudioCli(
-          ["search-google", "--query", query, "--export-type", "json"],
+          [
+            "search-google",
+            "--query",
+            query,
+            "--export-type",
+            "json",
+            "--fetch-top-n",
+            String(FETCH_TOP_N)
+          ],
           {
             outputKey: "results",
             maxBuffer: SEARCH_MAX_BUFFER,
@@ -5819,7 +5828,15 @@ __export(searchGoogle_exports, {
 });
 async function execute(input, onLog) {
   return runMindstudioCli(
-    ["search-google", "--query", input.query, "--export-type", "json"],
+    [
+      "search-google",
+      "--query",
+      input.query,
+      "--export-type",
+      "json",
+      "--fetch-top-n",
+      String(FETCH_TOP_N2)
+    ],
     {
       outputKey: "results",
       onLog,
@@ -5828,15 +5845,16 @@ async function execute(input, onLog) {
     }
   );
 }
-var definition;
+var FETCH_TOP_N2, definition;
 var init_searchGoogle2 = __esm({
   "src/subagents/designExpert/tools/searchGoogle.ts"() {
     "use strict";
     init_runMindstudioCli();
     init_runCli();
+    FETCH_TOP_N2 = 5;
     definition = {
       name: "searchGoogle",
-      description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, or find something specific if the the user has an explicit reference. Searching for and reading case studies is a great way to get information and context about a project\'s domain. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. Pick one or more URLs from the results and then use `scrapeWebUrl` to get their text content.',
+      description: 'Search Google for web results. Reserch modern design trends in industries or verticals, "best [domain] apps 2026", ui patterns, or find something specific if the the user has an explicit reference. Searching for and reading case studies is a great way to get information and context about a project\'s domain. Prioritize authoritative sources like Figma and other design leaders, avoid random blog spam. The top results come back with their page content already included, so read those directly \u2014 only use `scrapeWebUrl` for a result further down the list, or for a URL this did not return.',
       inputSchema: {
         type: "object",
         properties: {
@@ -6878,7 +6896,7 @@ var init_createWireframe = __esm({
     UPLOAD_TIMEOUT_MS2 = 3e4;
     definition10 = {
       name: "createWireframe",
-      description: "Create (or revise) a wireframe from self-contained HTML+CSS. The wireframe is saved to src/.wireframes/{slug}.html \u2014 reference it in your response and in specs as ![name](src/.wireframes/{slug}.html), with your notes in the surrounding prose. Calling again with the same slug overwrites the wireframe in place, so a revision keeps its path and existing references stay current.",
+      description: "Create (or revise) a wireframe from self-contained HTML+CSS. Call this while working to generate a sharable wireframe asset: the result returns the exact markdown reference line to paste into your response and into specs (like generateImages returns the image URL). Calling again with the same slug overwrites the wireframe in place, so a revision keeps its path and existing references stay current.",
       inputSchema: {
         type: "object",
         properties: {

package/dist/prompt/skills/jewels.md

@@ -243,13 +243,19 @@ full report. The dataset report says whether the ledger is trainable (pairs with
 attached `trace` don't count), and a run produces a downloadable LoRA adapter plus a
 held-out agreement report: how often the trained model matched your team's decisions
 on pairs it never saw. The adapter and report land in the app's own file store
-(`models/` in the Files dashboard), so the user can download them there. Read
-`report.grading.agreement` — it is scored by the jewel's own grade function, the same
-grader as the pairs dashboard. The raw `agreement` field is a strict byte-level floor
-that undercounts whenever free-text fields differ; never quote it when `grading`
-exists (`mindstudio-prod jewels grade <runId>` re-grades if it is missing). The
-trained model is an artifact and a report for now; serving it inside the app is a
-later platform phase, so set that expectation honestly when a user asks.
+(`models/` in the Files dashboard), so the user can download them there. The
+agreement number is `report.grading.agreement` — scored by the jewel's own grade
+function, the same grader as the pairs dashboard; there is no other agreement field.
+A completed run without a `grading` block just hasn't been graded yet
+(`mindstudio-prod jewels grade <runId>` fills it). A completed run registers the
+app's tuned model as a real model id — `tuned/{appId}/{methodId}`, one stable id per
+method that retraining advances in place — and the latest complete run per method is
+automatically served on the platform's GPU pool, so that id works like any other
+model the moment training finishes. There is no special invoke tool: to sanity-check
+or demo a tuned model, make an ordinary generate-text call with that model id (the
+pool serves it with the exact template posture it was trained under). Promotion (the
+app actually switching a jewel onto its tuned model) is still a deliberate later
+step; do not wire a tuned model into app code unprompted.
 
 ## Arrival Triggers (`mindstudio.jewels.propose`)
 

package/dist/subagents/designExpert/prompts/instructions.md

@@ -16,7 +16,7 @@ Think about the ways you can truly elevate the design. Use image generation to c
 - After you've taken a screenshot, use analyze image to ask different questions about it - don't re-screenshot the page unnecessarily.
 - Match the image engine to the job: `renderImage` (a browser rendering HTML you author) for token-exact graphics — share cards, wordmarks, flat icon tiles; `generateImages` (an image model) for organic, photographic, and illustrated work. Don't ask the image model to hit exact hex codes or typography, and don't hand-write SVG path data — compose HTML/CSS and render it.
 - When you write user-facing copy (headlines, captions, labels, body text), hand it to `polishCopy` before finalizing. It tightens prose so it reads like a person wrote it rather than a machine, without changing what it says. Cheap and fast — use it on any copy that will ship.
-- Deliver wireframes with `createWireframe`. Include the `![name](src/.wireframes/{slug}.html)` line in your response where the wireframe belongs — it renders as a live preview, and the developer reads the file for the exact markup. Same slug = revise in place; new slug = new wireframe.
+- Build wireframes with `createWireframe` during your working phase as you work out a layout, component, or interaction. Creating wireframes is how you create interactive assets to share back to the user, like how you generate images. The result returns the exact `![name](src/.wireframes/{slug}.html)` reference line; paste it into your response where the wireframe belongs. It renders as a live preview, and the developer reads the file for the exact markup. Same slug = revise in place; new slug = new wireframe.
 
 ## Voice
 - No emoji, no filler.

package/dist/subagents/designExpert/prompts/ui-patterns.md

@@ -25,11 +25,11 @@ Some surfaces are deep enough to carry their own craft reference in <available_s
 
 ### Wireframes
 
-When you need to show a layout, component, interaction, or animation, create a wireframe with the `createWireframe` tool: pass a `name`, a kebab-case `slug`, a one-line `description`, and self-contained HTML+CSS. The wireframe is saved to `src/.wireframes/{slug}.html`, and you reference it as `![Feed Post Card](src/.wireframes/feed-post-card.html)` — include that line in your response wherever the wireframe belongs, with your notes in the surrounding prose. The reference line renders as a live visual preview, and the developer reads the file itself for the exact markup and CSS. A reference only renders once its wireframe exists, so make the `createWireframe` call for every reference you write — in the same response is fine.
+Wireframes are design artifacts you build while you work, in the same phase as screenshots and image generation. As you work out a layout, a card anatomy, an interaction, or a motion pattern, build it with `createWireframe`: a `name`, a kebab-case `slug`, a one-line `description`, and self-contained HTML+CSS. Sketching in HTML is how you think through spatial decisions, so by the time you write your direction, the wireframes that anchor it already exist. The tool result returns the exact markdown reference line (`![Feed Post Card](src/.wireframes/feed-post-card.html)`) — when you write your response, paste that line wherever the wireframe belongs, with your notes in the surrounding prose. The reference renders as a live visual preview, and the developer reads the file itself for the exact markup and CSS.
 
 Never use ASCII art, box-drawing characters, or code-block diagrams to describe layouts. Always use a wireframe instead, even if it's just grey rectangles with labels. A 20-line wireframe with placeholder boxes communicates proportions, spacing, and hierarchy better than any text diagram. For abstract layouts, use skeleton-style placeholders (grey boxes, rounded rects) rather than mocking up real content.
 
-Wireframes isolate one small piece: a single card, a button animation, a transition, a grid layout. Keep them to 60-80 lines of HTML+CSS. Past 100 lines, you're building too much. Never build full screens or pages. Most of your communication should be in words. Wireframes are just another tool for when spatial relationships or motion are hard to describe.
+Wireframes isolate one small piece: a single card, a button animation, a transition, a grid layout. Keep them to 60-80 lines of HTML+CSS. Past 100 lines, you're building too much. Never build full screens or pages. Most of your communication should be in words; build a wireframe whenever you're working out spatial relationships or motion — it's how you sketch.
 
 Wireframes render in a small transparent iframe. Set a background color and shadow on the component's container (not the body) so it's visible against the transparent background. Center it in the viewport. No annotations or labels inside the wireframe. Put notes in the surrounding markdown. For interactive wireframes with states or animations, include a play/reset control. No images.
 

package/package.json

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