@12ui/design 0.2.80 → 0.2.82

package/dist/mcp-slate-ui-script-references.js

@@ -0,0 +1,102 @@
+/**
+ * The References tab: live screenshots of real, relevant websites (`view.sites`), gathered by the person's own agents
+ * and captured by the 12ui command line while a round waits on them. It is the Inspiration tab's gallery, large view
+ * and tray (mcp-slate-ui-script-inspiration-gallery.ts, mcp-slate-ui-script-inspiration-grid.ts) over the sites:
+ *
+ * - The sites arrive one by one while the tab is open (the status poll brings each, or the tab's own short watch below)
+ *   and join the end of the grid; nothing already shown moves.
+ * - A click selects or deselects a site exactly like an Inspiration reference (`toggleRef`: the selection for the next
+ *   round, or, while a round waits on the person, that round's references), with the same ring, check and tray.
+ * - The large view adds Open site, which opens the live page through the host.
+ * - Pictures load straight from their URLs (`imageUrl`, `thumbUrl`); where a server gives none (the local plugin) they
+ *   come through the reference tool like any reference.
+ * - Nothing yet: one short line, "Finding sites…" only while gathering is possible (the gather window is open and a
+ *   runner or the draw command holds a running round), else "No websites".
+ *
+ * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
+ */
+export const SLATE_UI_REFERENCES = String.raw `
+  // While the tab is open and the sites are still landing, it asks for the view every few seconds by itself (the
+  // status poll runs only while a request runs, and the local plugin gathers with none), for a few minutes at most.
+  var SITES_EXPECTED = 12;
+  var SITE_WATCH = { forMs: 300000, everyMs: 3000 };
+  var siteWatch = { runDir: null, until: 0, timer: null };
+  function armSiteWatch() {
+    if (state.view && state.view.runDir && siteWatch.runDir !== state.view.runDir) { siteWatch.runDir = state.view.runDir; siteWatch.until = Date.now() + SITE_WATCH.forMs; }
+  }
+  // Gathering is possible only while the gather window is open and a runner or the draw command holds a running round.
+  function stillFinding() {
+    return Date.now() < siteWatch.until && runningOps().some(function (op) { return !!(op.runner && op.runner.alive); });
+  }
+  function watchSites() {
+    if (siteWatch.timer !== null || !state.view || !state.view.runDir) return;
+    if (state.tab !== "references" || siteList().length >= SITES_EXPECTED || Date.now() > siteWatch.until || runningOps().length > 0) return;
+    siteWatch.timer = setTimeout(function () { siteWatch.timer = null; refreshOnce(); watchSites(); }, SITE_WATCH.everyMs);
+  }
+
+  function siteList() { return (state.view && state.view.sites) || []; }
+  function siteById(id) {
+    var sites = siteList();
+    for (var i = 0; i < sites.length; i++) if (sites[i].id === id) return sites[i];
+    return null;
+  }
+  function siteDomain(site) {
+    return String(site.sourceUrl).replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/[\/?#].*$/, "").replace(/^www\./, "");
+  }
+  function openSite(url) {
+    request("ui/open-link", { url: url }).catch(function (err) { setInspStatus(errText(err), "err"); });
+  }
+  // A site as the gallery shows it.
+  function siteItem(site) {
+    var item = { id: site.id, label: site.title + " (" + siteDomain(site) + ")", title: site.title, sourceUrl: site.sourceUrl,
+      aspect: "landscape", width: 1600, height: 1000, thumbUrl: site.thumbUrl || null, imageUrl: site.imageUrl || site.thumbUrl || null, srcset: "" };
+    if (!item.thumbUrl) item.load = function (img, size) { fillImage(img, wantReference(site.id, size === "thumb" ? "thumb" : "ref", false)); };
+    return item;
+  }
+
+  // ---- the tab ----
+  function buildReferencesShell(pane, where) {
+    pane.__built = true;
+    pane.__where = where;
+    pane.classList.add("insp", "refs", where);
+    var status = el("div", "status");
+    status.setAttribute("data-istatus", "");
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    var results = el("div", "results");
+    var gallery = createGallery({
+      where: where,
+      root: function () { return where === "card" ? results : null; },
+      isSelected: function (id) { return activeSelection().indexOf(id) >= 0; },
+      onToggle: toggleRef
+    });
+    var empty = el("div", "placeholder");
+    results.appendChild(gallery.node);
+    pane.__results = results;
+    pane.__gallery = gallery;
+    pane.__empty = empty;
+    pane.appendChild(status);
+    pane.appendChild(results);
+    pane.appendChild(buildTray(pane));
+    new ResizeObserver(function () { gallery.layout(); }).observe(results);
+  }
+  function renderReferences(pane, where) {
+    if (!state.view) return;
+    if (!pane.__built) buildReferencesShell(pane, where);
+    armSiteWatch();
+    var sites = siteList();
+    var has = sites.length > 0;
+    var emptyText = has ? "" : stillFinding() ? t("referencesFinding") : t("referencesNone");
+    pane.__empty.textContent = emptyText;
+    if (emptyText && !pane.__empty.parentNode) pane.__results.insertBefore(pane.__empty, pane.__gallery.node);
+    else if (!emptyText && pane.__empty.parentNode) pane.__empty.parentNode.removeChild(pane.__empty);
+    pane.__gallery.node.classList.toggle("hidden", !has);
+    // One list per workspace: a new site only joins its end.
+    if (has) pane.__gallery.set(state.view.runDir + ":sites", sites.map(siteItem));
+    pane.__gallery.layout();
+    pane.__gallery.sync();
+    syncTray(pane);
+    watchSites();
+  }
+`;
+//# sourceMappingURL=mcp-slate-ui-script-references.js.map

package/dist/mcp-slate-ui-script-references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-slate-ui-script-references.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-references.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF5C,CAAC"}

package/dist/mcp-slate-ui-script-remote.d.ts

@@ -2,17 +2,18 @@
  * What only the hosted target does (TARGET is "remote"): the words it says to the
  * agent, and the marked image an edit carries.
  *
- * The messages. The host wraps every app message as untrusted input, so each one
- * names what happened and carries no command, flag, path, price or credit word;
- * a Generate more or Edit click that the workspace runner on the person's Mac
- * will draw sends none (remoteAfterRun);
- * the agent confirms through the model-visible data tool, which returns the
- * server's own trusted text. Six messages exist, one per click (spec v2 9.2):
- * Generate more with new options, Generate more based on a design, Edit,
- * Select, Branch and Convert. The user's own words (a steer note, an edit instruction, the Branch
- * explanation) are never put in a message; the agent reads them from the data
- * tool, quoted. `runDir` is named in each because the tools take it and a
- * thread may hold several workspaces.
+ * The messages. The person sees each one in the thread as their own words, so it
+ * says only what they did ("I chose design C. Build it."), with no id, tool
+ * name, command, path, price or credit word; the runDir and the request go to
+ * the agent in the model context, which the host attaches unseen. The host
+ * wraps app messages as untrusted input, so the agent reads the request with the
+ * model-visible data tool, which returns the server's own trusted text.
+ * Choosing a design records the pick and a Convert hand-off, so the agent builds
+ * it. A Generate more, Edit or Continue that the workspace runner on the
+ * person's Mac draws sends no message (remoteAfterRun); the agent is told only
+ * when no runner takes it. The user's own words (a steer note, an edit
+ * instruction, the Branch explanation) are never put in a message; the agent
+ * reads them from the data tool, quoted.
  *
  * The marked image. The hosted server does no image work, so the screen
  * composites the strokes onto the parent itself and sends the result with the
@@ -21,7 +22,7 @@
  * the image's mean colour (as the local server chooses), round caps, a width of
  * 0.8 percent of the shorter side (at least 3 px), exported as a JPEG whose
  * quality steps down until it fits in 300 KiB, and whose size steps down if no
- * quality does. A canvas that cannot be read or exported is an error the dialog
+ * quality does. A canvas that cannot be read or exported is an error the edit bar
  * shows; the edit is not sent without the picture it asked for.
  *
  * Fragment of the view's script; String.raw, no backtick, no dollar-brace.

package/dist/mcp-slate-ui-script-remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-remote.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,QA8J3B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-remote.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,QAgL3B,CAAC"}

package/dist/mcp-slate-ui-script-remote.js

@@ -2,17 +2,18 @@
  * What only the hosted target does (TARGET is "remote"): the words it says to the
  * agent, and the marked image an edit carries.
  *
- * The messages. The host wraps every app message as untrusted input, so each one
- * names what happened and carries no command, flag, path, price or credit word;
- * a Generate more or Edit click that the workspace runner on the person's Mac
- * will draw sends none (remoteAfterRun);
- * the agent confirms through the model-visible data tool, which returns the
- * server's own trusted text. Six messages exist, one per click (spec v2 9.2):
- * Generate more with new options, Generate more based on a design, Edit,
- * Select, Branch and Convert. The user's own words (a steer note, an edit instruction, the Branch
- * explanation) are never put in a message; the agent reads them from the data
- * tool, quoted. `runDir` is named in each because the tools take it and a
- * thread may hold several workspaces.
+ * The messages. The person sees each one in the thread as their own words, so it
+ * says only what they did ("I chose design C. Build it."), with no id, tool
+ * name, command, path, price or credit word; the runDir and the request go to
+ * the agent in the model context, which the host attaches unseen. The host
+ * wraps app messages as untrusted input, so the agent reads the request with the
+ * model-visible data tool, which returns the server's own trusted text.
+ * Choosing a design records the pick and a Convert hand-off, so the agent builds
+ * it. A Generate more, Edit or Continue that the workspace runner on the
+ * person's Mac draws sends no message (remoteAfterRun); the agent is told only
+ * when no runner takes it. The user's own words (a steer note, an edit
+ * instruction, the Branch explanation) are never put in a message; the agent
+ * reads them from the data tool, quoted.
  *
  * The marked image. The hosted server does no image work, so the screen
  * composites the strokes onto the parent itself and sends the result with the
@@ -21,37 +22,55 @@
  * the image's mean colour (as the local server chooses), round caps, a width of
  * 0.8 percent of the shorter side (at least 3 px), exported as a JPEG whose
  * quality steps down until it fits in 300 KiB, and whose size steps down if no
- * quality does. A canvas that cannot be read or exported is an error the dialog
+ * quality does. A canvas that cannot be read or exported is an error the edit bar
  * shows; the edit is not sent without the picture it asked for.
  *
  * Fragment of the view's script; String.raw, no backtick, no dollar-brace.
  */
 export const SLATE_UI_REMOTE = String.raw `
-  // ---- the six messages ----
-  function remoteRunMessage(action, opId) {
-    var head;
+  // ---- the messages ----
+  // The person sees each message in the thread as their own words, so it says only what they did, in their words. What
+  // the agent needs to act (the runDir and the request) travels in the model context, which the host attaches to the
+  // message unseen; the agent then reads the request itself with the data tool, the trusted words.
+  function remoteTell(text, context) {
+    return updateModelContext("12ui Design workspace runDir " + state.view.runDir + ": " + context + " Read it with " + TOOLS.data + ".").then(function () {
+      return messageAgent(text);
+    });
+  }
+  function remoteRunMessage(action) {
+    if (action.kind === "continue") return "Draw the designs: I pressed Continue.";
     if (action.kind === "edit") {
       var parent = ver(action.versionId);
-      head = "I asked to edit " + (parent ? parent.label : "an option");
-    } else if (action.mode === "like") {
+      return "Draw my edit of " + (parent ? parent.label : "the design") + ".";
+    }
+    if (action.mode === "branch") {
+      var root = ver(action.fromVersionId);
+      return "Draw more pages of " + (root ? root.label : "the design") + ".";
+    }
+    if (action.mode === "like") {
       var from = ver(action.fromVersionId);
-      head = "I asked for more like " + (from ? from.label : "an option");
-    } else head = "I asked for new options";
-    return head + " in the Design workspace (request " + opId + ", runDir " + state.view.runDir + "). Please confirm it with " + TOOLS.data + ", then carry it out.";
-  }
-  function remoteSelectMessage(label) {
-    return "I selected " + label + " in the Design workspace (runDir " + state.view.runDir + "). Please confirm it with " + TOOLS.data + " and tell me its version id.";
-  }
-  function remoteHandoffMessage(kind, label, handoffId) {
-    return "I asked to " + (kind === "branch" ? "build from" : "convert") + " " + label + " in the Design workspace (request " + handoffId + ", runDir " + state.view.runDir + "). Please confirm it with " + TOOLS.data + ", then carry it out.";
+      return "Draw more like " + (from ? from.label : "that design") + ".";
+    }
+    return "Draw the new designs I asked for.";
   }
   // The run is recorded before the agent is told, and a host that refuses the message is shown, not thrown: the request
   // is on the server and the person can ask their agent for it.
   function remoteTellRun(action, opId) {
-    messageAgent(remoteRunMessage(action, opId)).then(function () {}, function (err) {
+    remoteTell(remoteRunMessage(action), "request " + opId + " waits for you.").then(function () {}, function (err) {
       setStatus(t("sentRefused", { detail: errText(err) }), "err");
     });
   }
+  // Choosing a design is asking for it to be built: the pick, then a Convert hand-off to HTML, then one message.
+  function remoteChoose(version, label) {
+    var handoffId = uuid4();
+    return callTool(TOOLS.handoff, {
+      runDir: state.view.runDir, handoffId: handoffId, kind: "convert", versionId: version.versionId, options: { engine: "local", output: "html" }
+    }).then(function (result) {
+      var sc = result.structuredContent || {};
+      if (sc.view) applyView(sc.view, true);
+      return remoteTell("I chose design " + label + ". Build it.", "the person chose design " + label + " (" + version.versionId + "); request " + handoffId + " waits for you.");
+    });
+  }
 
   // ---- the workspace runner: a click it draws is not a message in the thread ----
   // The run result says whether the workspace runner on the person's Mac holds the workspace (runner.alive). Then the

package/dist/mcp-slate-ui-script-remote.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-remote.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8JxC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-remote.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgLxC,CAAC"}

package/dist/mcp-slate-ui-script-scribble.d.ts

@@ -1,5 +1,5 @@
 /**
- * The scribble layer of the Edit dialog: a canvas exactly over the image where
+ * The scribble layer of the large view's edit: a canvas exactly over the image where
  * a pointer draws freehand strokes, with Undo and Clear. A stroke is a
  * polyline of integer permille points [x, y] (0 to 1000 of the displayed
  * image's width and height), so it does not depend on the size it was drawn
@@ -13,7 +13,7 @@
  * after the fact. A single click is a one-point stroke (a dot).
  *
  * Pointer only by design: the scribble is optional, and every other control
- * of the dialog works by keyboard.
+ * of the edit bar works by keyboard.
  */
 export declare const SLATE_UI_SCRIBBLE: string;
 //# sourceMappingURL=mcp-slate-ui-script-scribble.d.ts.map

package/dist/mcp-slate-ui-script-scribble.js

@@ -1,5 +1,5 @@
 /**
- * The scribble layer of the Edit dialog: a canvas exactly over the image where
+ * The scribble layer of the large view's edit: a canvas exactly over the image where
  * a pointer draws freehand strokes, with Undo and Clear. A stroke is a
  * polyline of integer permille points [x, y] (0 to 1000 of the displayed
  * image's width and height), so it does not depend on the size it was drawn
@@ -13,7 +13,7 @@
  * after the fact. A single click is a one-point stroke (a dot).
  *
  * Pointer only by design: the scribble is optional, and every other control
- * of the dialog works by keyboard.
+ * of the edit bar works by keyboard.
  */
 export const SLATE_UI_SCRIBBLE = String.raw `
   var SCRIBBLE_COLOR = "#ff2bd6";
@@ -56,20 +56,20 @@ export const SLATE_UI_SCRIBBLE = String.raw `
     d.strokes.pop();
     d.current = null;
     scribblePaint(d);
-    updateDialogUi();
+    scribbleChanged(d);
   }
   function scribbleClear(d) {
     if (d.committing) return;
     d.strokes = [];
     d.current = null;
     scribblePaint(d);
-    updateDialogUi();
+    scribbleChanged(d);
   }
 
   function scribbleAttach(wrap, d) {
     var canvas = document.createElement("canvas");
     canvas.className = "scribble";
-    canvas.setAttribute("aria-label", t("scribbleHint"));
+    canvas.setAttribute("aria-label", t("drawOnDesign"));
     d.canvas = canvas;
     wrap.appendChild(canvas);
     // The bitmap follows the size the image is shown at; the strokes repaint from their permille points.
@@ -95,7 +95,7 @@ export const SLATE_UI_SCRIBBLE = String.raw `
       if (canvas.setPointerCapture) { try { canvas.setPointerCapture(e.pointerId); } catch (err) { /* capture is best effort */ } }
       if (e.preventDefault) e.preventDefault();
       scribblePaint(d);
-      updateDialogUi();
+      scribbleChanged(d);
     });
     canvas.addEventListener("pointermove", function (e) {
       if (!d.current) return;
@@ -106,7 +106,7 @@ export const SLATE_UI_SCRIBBLE = String.raw `
       d.current.push(p);
       scribblePaint(d);
     });
-    function finish() { d.current = null; updateDialogUi(); }
+    function finish() { d.current = null; scribbleChanged(d); }
     canvas.addEventListener("pointerup", finish);
     canvas.addEventListener("pointercancel", finish);
   }

package/dist/mcp-slate-ui-script-select.d.ts

@@ -1,16 +1,11 @@
 /**
- * Select and the two hand-offs. Select acts at once: no dialog, and no reason
- * (the pick tool takes none from here). It records the pick and then tells the
- * agent, best effort. Branch and Convert (dialogs, in
- * mcp-slate-ui-script-dialog.ts) end here: they record the request with the
- * hand-off tool, under an id minted when the dialog opened, and then tell the
- * agent to read it.
+ * Select (Build this). It acts at once: no dialog, and no reason (the pick tool
+ * takes none from here). It records the pick and then tells the agent, best
+ * effort; exporting another format is something the person asks the agent for.
  *
  * What the agent is told names what happened and carries no command, no flag
  * and no backtick: the host wraps app messages as untrusted input, so the
- * agent confirms with the model-visible data tool. The user's own words (the
- * Branch explanation) are never put in a message; the agent reads them from
- * the record.
+ * agent confirms with the model-visible data tool.
  */
 export declare const SLATE_UI_SELECT: string;
 //# sourceMappingURL=mcp-slate-ui-script-select.d.ts.map

package/dist/mcp-slate-ui-script-select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-select.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-select.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,QAyD3B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-select.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-select.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,QAsC3B,CAAC"}

package/dist/mcp-slate-ui-script-select.js

@@ -1,16 +1,11 @@
 /**
- * Select and the two hand-offs. Select acts at once: no dialog, and no reason
- * (the pick tool takes none from here). It records the pick and then tells the
- * agent, best effort. Branch and Convert (dialogs, in
- * mcp-slate-ui-script-dialog.ts) end here: they record the request with the
- * hand-off tool, under an id minted when the dialog opened, and then tell the
- * agent to read it.
+ * Select (Build this). It acts at once: no dialog, and no reason (the pick tool
+ * takes none from here). It records the pick and then tells the agent, best
+ * effort; exporting another format is something the person asks the agent for.
  *
  * What the agent is told names what happened and carries no command, no flag
  * and no backtick: the host wraps app messages as untrusted input, so the
- * agent confirms with the model-visible data tool. The user's own words (the
- * Branch explanation) are never put in a message; the agent reads them from
- * the record.
+ * agent confirms with the model-visible data tool.
  */
 export const SLATE_UI_SELECT = String.raw `
   function samePick(version) {
@@ -19,55 +14,36 @@ export const SLATE_UI_SELECT = String.raw `
     return !!p && p.intact !== false && !!version && p.versionId === version.versionId;
   }
 
-  // What the agent is told, one wording per target: the local plugin's asks the agent to confirm through its tools, the
-  // hosted one is spec v2 9.2, and the browser's is only a record (its decision reaches the agent as the command's result).
+  // What the agent is told, one wording per target: the local plugin's asks the agent to confirm through its tools, and
+  // the browser's is only a record (its decision reaches the agent as the command's result). The hosted target words
+  // its own (remoteChoose, remoteTellHandoff).
   function selectMessage(label, rev) {
-    if (TARGET === "remote") return remoteSelectMessage(label);
     if (TARGET === "browser") return browserSelectMessage(label);
     return "I selected " + label + " in the Design workspace (rev " + rev + "). " +
       "Please confirm it with " + TOOLS.data + " for runDir " + state.view.runDir + ", and tell me its version id, path and sha256.";
   }
-  function handoffMessage(kind, label, handoffId, rev) {
-    if (TARGET === "remote") return remoteHandoffMessage(kind, label, handoffId);
-    if (TARGET === "browser") return browserHandoffMessage(kind, label, handoffId);
-    return "I asked to " + (kind === "branch" ? "build from" : "convert") + " " + label + " in the Design workspace (rev " + rev + ", request " + handoffId + "). " +
-      "Please confirm it with " + TOOLS.data + " for runDir " + state.view.runDir + ", then carry it out and ask me before anything that uses my 12ui credits.";
-  }
 
   function doSelect(version) {
     // The button is disabled in these cases; the guard keeps a stray click (a script, a stale focus) from sending a second pick.
     if (!version || state.busy || samePick(version) || !pickable(version)) return;
     state.busy = true;
     syncControls();
-    setStatus(t("recording"));
+    setStatus("", "");
     callTool(TOOLS.pick, { runDir: state.view.runDir, versionId: version.versionId }).then(function (result) {
       var sc = result.structuredContent || {};
       if (sc.view) applyView(sc.view, true);
       var label = sc.pick ? sc.pick.label : version.label;
       var rev = sc.rev !== undefined ? sc.rev : state.view.rev;
-      return messageAgent(selectMessage(label, rev)).then(function () {
-        setStatus(t("selectedLine", { label: label }), "ok");
+      var told = TARGET === "remote" ? remoteChoose(version, label) : messageAgent(selectMessage(label, rev));
+      return told.then(function () {
+        // The ring and check on the chosen design say it; no line repeats it.
+        setStatus("", "");
       }, function (err) {
         setStatus(t("selectedRefused", { label: label, detail: errText(err) }), "err");
       });
     }, function (err) {
       setStatus(t("couldNotSelect", { detail: errText(err) }), "err");
-    }).then(function () { state.busy = false; syncControls(); });
-  }
-
-  // Record a Branch or Convert request for the shown version, then tell the agent. Resolves once the agent has been
-  // told (or the host refused, which is shown but not thrown); rejects on a recording error so the dialog can show it.
-  function sendHandoff(kind, version, handoffId, options) {
-    return callTool(TOOLS.handoff, { runDir: state.view.runDir, handoffId: handoffId, kind: kind, versionId: version.versionId, options: options }).then(function (result) {
-      var sc = result.structuredContent || {};
-      if (sc.view) applyView(sc.view, true);
-      var rev = sc.rev !== undefined ? sc.rev : state.view.rev;
-      return messageAgent(handoffMessage(kind, version.label, handoffId, rev)).then(function () {
-        setStatus(t("sent"), "ok");
-      }, function (err) {
-        setStatus(t("sentRefused", { detail: errText(err) }), "err");
-      });
-    });
+    }).then(function () { state.busy = false; renderAll(); });
   }
 `;
 //# sourceMappingURL=mcp-slate-ui-script-select.js.map

package/dist/mcp-slate-ui-script-select.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-select.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-select.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDxC,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-select.js","sourceRoot":"","sources":["../src/mcp-slate-ui-script-select.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCxC,CAAC"}

package/dist/mcp-slate-ui-script-stage.d.ts

@@ -1,14 +1,8 @@
 /**
- * The fullscreen workspace: on the left the selection (the Generate more tile
- * on top, where the next round will land, its panel under it, then compact
- * thumbnails grouped by round, newest first, each option with its versions as
- * chips; one column that scrolls as a whole), in the middle one large image,
- * and under it one row of actions at the right: Edit, Branch and Convert, then
- * Select (primary) at the far right. Nothing else shows until a button is
- * clicked; the dialogs live in mcp-slate-ui-script-dialog.ts. One band above
- * the image says what is running (on the local plugin; on the hosted server
- * the person's agent says it), stopped or failed, with Resume when the work
- * can resume. Mounted only in fullscreen.
+ * The fullscreen workspace: the prompt card, the tab row (the tabs, the quiet selected count and the icon that leaves
+ * full screen), then the selected tab. Designs is the same tab as the
+ * card's (mcp-slate-ui-script-designs.ts) with every round shown and more room per tile; the large view
+ * (mcp-slate-ui-script-viewer.ts) covers the workspace when a design is opened. Mounted only in fullscreen.
  */
 export declare const SLATE_UI_STAGE: string;
 //# sourceMappingURL=mcp-slate-ui-script-stage.d.ts.map

package/dist/mcp-slate-ui-script-stage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-slate-ui-script-stage.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-stage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,QAoL1B,CAAC"}
+{"version":3,"file":"mcp-slate-ui-script-stage.d.ts","sourceRoot":"","sources":["../src/mcp-slate-ui-script-stage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAyE1B,CAAC"}