create-walle 0.10.1 → 0.10.3

package/template/coding-task-manager/public/js/message-renderer.js

@@ -324,6 +324,7 @@
     return MR.stripImageAttachmentMetadata(text);
   }
 
+  const _userPromptMarkdown = (t) => (typeof PastedContent !== 'undefined' && PastedContent ? PastedContent.toMarkdown(String(t || '')) : String(t || '')); // D-6 (WP-2): a USER card's paste wrapper → a literal fenced `text` block; typed text around it still renders as markdown, assistant rows never call this
   function _appendReviewAttachmentsHtml(message) {
     const html = MR.renderImageAttachmentsHtml(message);
     return html ? html : '';
@@ -2524,9 +2525,9 @@
     const metaCard = MR.renderMetaCardHtml(m, i);
     if (metaCard) return metaCard;
     const time = m.timestamp ? new Date(m.timestamp).toLocaleString() : '';
-    const displayText = _messageTextForDisplay(m.text || '');
+    const displayText = _messageTextForDisplay(m.role === 'user' ? _userPromptMarkdown(m.text || '') : (m.text || ''));
     const attachmentHtml = _appendReviewAttachmentsHtml(Object.assign({}, m, { text: m.text || '' }));
-    const textHtml = _formatDisplayTextHtml(m.text || '', attachmentHtml ? '<span class="msg-empty">(image attachment)</span>' : '');
+    const textHtml = _formatDisplayTextHtml(m.role === 'user' ? _userPromptMarkdown(m.text || '') : (m.text || ''), attachmentHtml ? '<span class="msg-empty">(image attachment)</span>' : '');
     const hasRenderedText = !!String(textHtml || '').trim();
     const needsCollapse = displayText.length > 1500 || displayText.split('\n').length > 30;
     const stripped = displayText.replace(/\[Tool: [^\]]+\]/g, '').trim();
@@ -3624,7 +3625,7 @@
       div.className = 'review-msg user';
       if (evt.data?.parentUuid) div.dataset.parentUuid = evt.data.parentUuid;
       div.appendChild(_makeHeader('You', time, text));
-      if (!_appendTextWithExpand(div, text, evt.data || evt)) return null;
+      if (!_appendTextWithExpand(div, _userPromptMarkdown(text), evt.data || evt)) return null;
       return div;
     }
 

package/template/coding-task-manager/public/js/model-picker.js

@@ -580,7 +580,9 @@
           }
         }
         updateRoleValues();
-        if (activeTab === tab) { renderList(); renderDetail(); position(anchor, popover); }
+        // renderActions(): an action whose label depends on the loaded answer (the OpenCode mode verdict)
+        // must repaint when the answer lands, not only on open()/switchTab().
+        if (activeTab === tab) { renderList(); renderDetail(); position(anchor, popover); renderActions(); }
       }, function(err) {
         if (closed || gen !== st.gen) return;
         st.loading = false;

package/template/coding-task-manager/public/js/native-subagent-review.js

@@ -39,11 +39,16 @@
   };
   const safeErrorText = (error) => {
     const status = Number(error?.status);
-    const code = String(error?.code || '');
+    // WP-1b (§6/§8): the hub's forwarder answers a body code too, so the body is consulted when the
+    // error object itself carries none (the phone's api() names the parsed JSON `payload`/`body`).
+    const code = String(error?.code || error?.body?.code || '');
     // D-6 (§6e): the worker copy names the worker, never "child". Raw server text is never shown.
     const worker = state.source === 'worker';
     if (status === 409 || code === 'cursor_expired') return 'This transcript snapshot expired. Refresh to start a new snapshot.';
     if (status === 404 || code === 'child_not_found') return worker ? 'No transcript is recorded for this worker.' : 'This child transcript is no longer available.';
+    // WP-1b (AC-1d): a box-owned lead whose box is unreachable names the machine rather than the
+    // generic 503 copy — the box, not this hub, owns the transcript.
+    if (code === 'machine_unreachable') return `${error?.body?.machineName || 'The machine that owns this session'} is unreachable. Retry when ready.`;
     if (status === 503 || code === 'review_unavailable') return worker ? "This worker's transcript is currently unavailable. Retry when ready." : 'This child transcript is currently unavailable. Retry when ready.';
     if (code === 'source_missing') return 'This child transcript is no longer available.';
     if (code === 'private_scope_changed' || code.startsWith('owner_')) return 'Private access changed. Close this viewer and verify access before trying again.';
@@ -504,7 +509,15 @@
         if (legacyToken) headers.set('Authorization', `Bearer ${legacyToken}`);
         const path = worker ? workerEndpoint(leadId, cursor) : endpointFor(leadId, key, cursor);
         const response = await window.fetch(path, { method: 'GET', headers, signal });
-        if (!response.ok) throw Object.assign(new Error('native transcript request failed'), { status: response.status, code: response.status === 409 ? 'cursor_expired' : 'native_review_http_error' });
+        if (!response.ok) {
+          // WP-1b (§8): keep the refusal body (a JSON content type is the only case that can carry
+          // one; anything else — an HTML error page, an empty 503 — degrades to a null body).
+          let body = null;
+          if (String(response.headers?.get?.('content-type') || '').toLowerCase().includes('json')) {
+            try { body = await response.json(); } catch { body = null; }
+          }
+          throw Object.assign(new Error('native transcript request failed'), { status: response.status, code: response.status === 409 ? 'cursor_expired' : (body?.code || 'native_review_http_error'), body });
+        }
         const page = await response.json();
         if (signal.aborted || !isCapturedAccessCurrent()) {
           throw Object.assign(new Error('access changed'), { code: 'private_scope_changed' });

package/template/coding-task-manager/public/js/new-session-agent-grid.js

@@ -0,0 +1,346 @@
+'use strict';
+
+// S-43 (docs/deepseek-harness-acp-agent-2026-10-28.html §9): the New Session agent grid, extracted
+// VERBATIM out of index.html's inline script — that file is at its file-size ceiling
+// (lint/file-size.config.json) and WP-7 needs the offset. It carries the WP-7 additions:
+//
+//   * the DeepSeek Harness card (agent id `dsh`, between `gemini:` and `shell:`), whose icon is the
+//     same brand mark the sidebar/tab rows use (providerIconSvg('dsh') → the DeepSeek whale);
+//   * OQ-4: a Model select shown only while the dsh card is chosen, listing the routes that serve
+//     `anthropic-messages` from the catalog the model pickers already load
+//     (the paged coding-catalog feed — its `providers[]` rows carry `upstream_apis`), defaulting to
+//     "Auto (DeepSeek on Portkey)" (no `routeAlias`, the server picks the OQ-4 default) and
+//     offering dsh's own key as the explicit opt-out;
+//   * D-15 (WP-13b): the card is disabled ONLY when the picked machine's own registry row says the
+//     box does not have the harness (`agentPresence.dsh === false`). Unknown (null / missing) leaves
+//     the card enabled — the box answers for itself, and the server refuses a forwarded dsh create
+//     with `machine_agent_not_installed` on an explicit "no";
+//   * WP-10 (C-6/D-16): the MCP server selector is ENABLED for dsh like every other agent — the
+//     session's profile is forwarded on `session/new`/`session/resume`.
+//
+// The card table and the availability helper are the index.html originals, unchanged except for the
+// new dsh row; `providerIconSvg`, `_selectAgentCard` and `state` stay in the inline script and are
+// reached through the global object (the repo's hoist-safe client-globals contract).
+//
+//@provides: NewSessionAgentGrid
+//@needs: providerIconSvg, _selectAgentCard, _nsOnMcpProfileChange
+
+(function (root) {
+  var DSH_AGENT = 'dsh';
+  var DSH_CARD_ID = 'dsh:';
+  var DEFAULT_OPTION_LABEL = 'Auto (DeepSeek on Portkey)';
+  var OWN_KEY_LABEL = "DeepSeek (dsh's own key)";
+  var ANTHROPIC_MESSAGES = 'anthropic-messages';
+
+  // Agent card definitions. The `agent` key drives providerIconSvg() so the
+  // card icon renders the SAME brand mark that appears in the session-list
+  // sidebar and tab header — agent identity is one visual vocabulary across
+  // the whole UI. Single-letter fallbacks ('$', '>') stay for `shell` and
+  // `custom`, which aren't LLM-branded surfaces.
+  var AGENT_DEFS = [
+    { id: 'claude:', name: 'Claude Code', sub: 'Anthropic', color: '#D97757', agent: 'claude', detect: 'claude' },
+    { id: 'codex:',  name: 'Codex', sub: 'OpenAI', color: '#22c55e', agent: 'codex', detect: 'codex' },
+    { id: 'opencode:', name: 'OpenCode', sub: 'GLM 5.2', color: '#e0af68', agent: 'opencode', detect: 'opencode' },
+    { id: 'walle:',  name: 'Wall-E', sub: 'Smart routing', color: '#f59e0b', agent: 'walle', detect: null },
+    { id: 'cursor:', name: 'Cursor', sub: 'Anysphere', color: '#111827', accent: '#7aa2f7', agent: 'cursor', detect: 'cursor-agent' },
+    { id: 'gemini:', name: 'Gemini CLI', sub: 'Google', color: '#3b82f6', agent: 'gemini', detect: 'gemini' },
+    // WP-7 (AC-7a): DeepSeek Harness sits between Gemini CLI and Shell. It is a conv-only ACP agent
+    // (no CLI surface), so it is never PATH-detected; WP-13b/D-15 gates it per MACHINE instead (a
+    // box whose own registry row says `agentPresence.dsh === false` greys the card out).
+    { id: 'dsh:', name: 'DeepSeek Harness', sub: 'DeepSeek', color: '#4D6BFE', agent: 'dsh', detect: null },
+    { id: 'shell:',  name: 'Shell', sub: 'Terminal', color: '#6b7280', icon: '$', detect: null },
+  ];
+
+  var _agents = undefined;   // last /api/models/available-agents payload (undefined = not loaded yet)
+  var _dshRoutesState = 'idle';
+  var _wrapped = false;
+
+  function _doc() {
+    return root && root.document ? root.document : null;
+  }
+
+  function _el(id) {
+    var doc = _doc();
+    return doc ? doc.getElementById(id) : null;
+  }
+
+  // D-15: a box is selected in the machine grid ('' = This Mac).
+  function _remoteMachineSelected() {
+    var hidden = _el('ns-machine');
+    return !!(hidden && String(hidden.value || '').trim());
+  }
+
+  // WP-13b: the picked machine's registry row. The new-session machine picker (js/core/session-commands.js)
+  // already fetches GET /api/machines and keeps the rows in its module state, so the card reads THAT
+  // cache — no second fetch, and the two views can never disagree about a box. The binding is a
+  // top-level `const` in a classic script, so it is reached by its bare name under a guarded typeof
+  // (a `const` is never a window property), and only from CALL time — never at module-eval time.
+  function _machineRows() {
+    try {
+      var picker = (typeof _nsMachineState !== 'undefined') ? _nsMachineState : null;
+      return picker && Array.isArray(picker.machines) ? picker.machines : [];
+    } catch (_) {
+      return []; // expected: the picker module is not on this page — no rows, no per-machine verdict
+    }
+  }
+
+  function _selectedMachineRow() {
+    var hidden = _el('ns-machine');
+    var id = hidden ? String(hidden.value || '').trim() : '';
+    if (!id) return null;
+    var rows = _machineRows();
+    for (var i = 0; i < rows.length; i += 1) {
+      if (rows[i] && String(rows[i].instanceId || '') === id) return rows[i];
+    }
+    return null;
+  }
+
+  function _selectedMachineName() {
+    var row = _selectedMachineRow();
+    if (!row) return 'this machine';
+    return String(row.displayName || row.url || row.instanceId || 'this machine');
+  }
+
+  // D-15 (WP-13b): dsh is disabled on a remote machine ONLY when that machine's own row says it does
+  // not have the harness. Unknown (null / no row / a hub that never read the box) keeps the card
+  // enabled and selectable: the box is then asked for itself, and its refusal is the authority (P3
+  // "Unknown != Dead" — the hub must never invent a "no").
+  function _dshMissingOnMachine(def) {
+    if (!def || def.agent !== DSH_AGENT) return false;
+    var row = _selectedMachineRow();
+    return !!(row && row.agentPresence && row.agentPresence.dsh === false);
+  }
+
+  function _selectedAgentId() {
+    var hidden = _el('ns-agent');
+    var value = (hidden && hidden.value) || 'claude:';
+    return String(value).replace(/:$/, '');
+  }
+
+  function agentAvailability(agents, detectKey) {
+    if (!detectKey) return { known: true, available: true, path: null };
+    if (!agents) return { known: false, available: true, path: null };
+    var detail = agents.agents && agents.agents[detectKey] ? agents.agents[detectKey] : agents[detectKey];
+    if (detail && typeof detail === 'object') {
+      return { known: true, available: detail.available !== false, path: detail.path || detail.realpath || null };
+    }
+    if (typeof detail === 'boolean') return { known: true, available: detail, path: null };
+    return { known: false, available: true, path: null };
+  }
+
+  function renderAgentCards(agents) {
+    var grid = _el('ns-agent-grid');
+    if (!grid) return;
+    var doc = _doc();
+    var hidden = _el('ns-agent');
+    var selected = (hidden && hidden.value) || 'claude:';
+    var remote = _remoteMachineSelected();
+    grid.innerHTML = '';
+    AGENT_DEFS.forEach(function(def) {
+        var availability = agentAvailability(agents, def.detect);
+        var available = availability.available;
+        // D-15 (WP-13b): per-machine, not per-remote. Only an explicit "the box does not have it"
+        // greys the dsh card out; a local card (no machine picked) is never touched by this rule.
+        var remoteBlocked = remote && _dshMissingOnMachine(def);
+        var card = doc.createElement('div');
+        card.className = 'ns-agent-card' + (available ? '' : ' not-detected') + (remoteBlocked ? ' not-available' : '');
+        card.style.setProperty('--ns-card-accent', def.accent || def.color);
+        card.dataset.value = def.id;
+        if (remoteBlocked) {
+          card.title = 'DeepSeek Harness is not installed on ' + _selectedMachineName();
+          card.setAttribute('aria-disabled', 'true');
+          card.onclick = function() { /* D-15: the hub refuses a forwarded dsh create with machine_agent_not_installed */ };
+          grid.appendChild(card);
+          card.innerHTML =
+            '<div class="ns-card-icon" style="background:' + def.color + ';color:#fff;">'
+              + root.providerIconSvg(def.agent, 22) + '</div>'
+            + '<div class="ns-card-name">' + def.name + '</div>'
+            + '<div class="ns-card-sub">not installed on this machine</div>';
+          return;
+        }
+        if (availability.path) card.title = def.name + ': ' + availability.path;
+        else if (availability.known && available === false) card.title = def.name + ' CLI not detected on PATH. You can still select it; launch will show the real terminal error if the command is unavailable.';
+        // Render a real brand icon when the agent maps to one (claude/codex/
+        // gemini/opencode/walle/dsh); otherwise the textual fallback ($, >) stays.
+        // Inline color forces the brand tint regardless of theme — these
+        // tiles always show on the dark agent-picker background, never on
+        // an active highlight, so we don't need the dark-on-light invert
+        // that the session-list .active rule applies via currentColor.
+        var iconHtml = def.agent
+          ? '<div class="ns-card-icon" style="background:' + def.color + ';color:#fff;">'
+              + root.providerIconSvg(def.agent, 22) + '</div>'
+          : '<div class="ns-card-icon" style="background:' + def.color + '">' + def.icon + '</div>';
+        card.innerHTML =
+          iconHtml +
+          '<div class="ns-card-name">' + def.name + '</div>' +
+          '<div class="ns-card-sub">' + def.sub + (available === false ? ' (not found)' : '') + '</div>';
+        card.onclick = function() { _select(def.id); };
+        grid.appendChild(card);
+      });
+    // A machine switch can retire the card that was selected; fall back to the default agent rather
+    // than leaving a disabled card selected. Keyed on the SAME per-machine rule as the card above.
+    if (remote && AGENT_DEFS.some(function(def) { return def.id === selected && _dshMissingOnMachine(def); })) {
+      selected = 'claude:';
+      if (hidden) hidden.value = selected;
+    }
+    _select(selected);
+  }
+
+  function _select(value) {
+    if (typeof root._selectAgentCard === 'function') root._selectAgentCard(value);
+    else _syncDshRows(value);
+  }
+
+  function _optionsHtml() {
+    var html = '<option value="">' + DEFAULT_OPTION_LABEL + '</option>';
+    (_dshRoutes().routes || []).forEach(function(route) {
+      var label = (route.portkey ? 'Portkey · ' : '') + route.name + (route.model ? ' — ' + route.model : '');
+      html += '<option value="' + _attr(JSON.stringify({ routeAlias: route.routeAlias, model: route.model || '' })) + '">'
+        + _esc(label) + '</option>';
+    });
+    html += '<option value="' + _attr(JSON.stringify({ routeAlias: 'dsh-own-key' })) + '">' + _esc(OWN_KEY_LABEL) + '</option>';
+    return html;
+  }
+
+  function _esc(text) {
+    return String(text == null ? '' : text)
+      .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  }
+
+  // The JSON payload lives in an HTML attribute-style value, so the quotes are entity-encoded above;
+  // the DOM decodes them back before `dshRoutePick` reads the value.
+  function _attr(text) {
+    return _esc(text);
+  }
+
+  function _dshRoutes() {
+    return _dshRoutesState && typeof _dshRoutesState === 'object' ? _dshRoutesState : { routes: [] };
+  }
+
+  // OQ-4: only routes whose upstream serves `anthropic-messages` can carry dsh. The catalog's
+  // providers[] rows carry `upstream_apis` (the same field lib/session-create/proxy-route-readiness.js
+  // reads server-side), and items[].routes[] pairs a provider with the wire model ids it serves.
+  function _buildRoutes(payload) {
+    var providers = (payload && Array.isArray(payload.providers)) ? payload.providers : [];
+    var items = (payload && Array.isArray(payload.items)) ? payload.items : [];
+    var byRoute = {};
+    items.forEach(function(item) {
+      (Array.isArray(item && item.routes) ? item.routes : []).forEach(function(route) {
+        if (!route || !route.provider_id) return;
+        var key = String(route.provider_id);
+        if (!byRoute[key]) byRoute[key] = [];
+        if (route.model_id) byRoute[key].push(String(route.model_id));
+      });
+    });
+    return providers.filter(function(p) {
+      if (!p || !p.id) return false;
+      if (p.routable === false) return false;
+      var apis = Array.isArray(p.upstream_apis) ? p.upstream_apis : null;
+      return !!apis && apis.indexOf(ANTHROPIC_MESSAGES) >= 0;
+    }).map(function(p) {
+      var models = byRoute[String(p.id)] || [];
+      var deepseek = models.filter(function(id) { return /deepseek/i.test(id); })[0];
+      return {
+        routeAlias: String(p.id),
+        name: String(p.name || p.display_name || p.id),
+        model: deepseek || models[0] || '',
+        portkey: /portkey/i.test(String(p.id)) || String(p.connection_kind || '') === 'portkey',
+      };
+    });
+  }
+
+  function _ensureDshModelRow() {
+    var row = _el('ns-dsh-model-row');
+    if (row) return row;
+    var hidden = _el('ns-agent');
+    var doc = _doc();
+    if (!hidden || !hidden.parentNode || !doc) return null;
+    row = doc.createElement('div');
+    row.id = 'ns-dsh-model-row';
+    row.style.cssText = 'margin-top:8px;display:none;';
+    row.innerHTML = '<label for="ns-dsh-model" style="font-size:13px;">Model</label>'
+      + '<select id="ns-dsh-model" style="font-size:13px;width:100%;">' + _optionsHtml() + '</select>'
+      + '<span id="ns-dsh-model-hint" style="font-size:11px;color:var(--fg-dim,#565f89);display:block;margin-top:4px;">'
+      + 'Routed through CTM\'s model proxy. The default route is chosen server-side (D-11).</span>';
+    hidden.parentNode.insertBefore(row, hidden.nextSibling);
+    return row;
+  }
+
+  function _loadDshRoutes() {
+    if (_dshRoutesState === 'loading' || (_dshRoutesState && typeof _dshRoutesState === 'object')) return;
+    _dshRoutesState = 'loading';
+    // G-3: the paged catalog must be read through the SHARED loader (fetchAllModelPages in
+    // public/js/app/models-paged-client.js) — never with a bare fetch of a paged route.
+    if (typeof root.fetchAllModelPages !== 'function') {
+      _dshRoutesState = { routes: [] };
+      return;
+    }
+    root.fetchAllModelPages('/api/models/coding-catalog', { restartOnInvalidToken: true }).then(function(payload) {
+      var routes = _buildRoutes(payload);
+      _dshRoutesState = { routes: routes };
+      // Re-render the option list now that the route feed has landed, preserving the pick.
+      var select = _el('ns-dsh-model');
+      if (select) {
+        var previous = select.value;
+        select.innerHTML = _optionsHtml();
+        select.value = previous;
+      }
+    }).catch(function() {
+      // A catalog-less server keeps the Auto + own-key options — never a dead select.
+      _dshRoutesState = { routes: [] };
+    });
+  }
+
+  function _syncDshRows(value) {
+    var agentId = String(value || '').replace(/:$/, '');
+    var row = _ensureDshModelRow();
+    if (row) row.style.display = agentId === DSH_AGENT ? '' : 'none';
+    // WP-10 step A: dsh now forwards the session's MCP servers (session/new carries the same profile
+    // a Claude session gets), so the MCP selector is a normal, enabled control for it — the D-16
+    // disabled state and its tooltip are gone.
+    if (agentId === DSH_AGENT) _loadDshRoutes();
+  }
+
+  // The create payload's `{routeAlias, model}` (null when the default "Auto" option is chosen).
+  function dshRoutePick() {
+    var select = _el('ns-dsh-model');
+    var raw = select ? String(select.value || '') : '';
+    if (!raw) return null;
+    try {
+      var parsed = JSON.parse(raw);
+      if (parsed && parsed.routeAlias) return parsed;
+    } catch (_) { /* expected: a non-JSON value is not a route pick */ }
+    return null;
+  }
+
+  // Called once per modal open, in place of the inline block it was extracted from.
+  function open() {
+    if (!_wrapped && typeof root._selectAgentCard === 'function') {
+      var original = root._selectAgentCard;
+      var wrapped = function(value) { original(value); _syncDshRows(value); };
+      wrapped.__nsGridSyncsDsh = true;
+      root._selectAgentCard = wrapped;
+      _wrapped = true;
+    }
+    renderAgentCards(_agents);
+    var token = (root.state && root.state.token) || '';
+    return fetch('/api/models/available-agents?token=' + encodeURIComponent(token))
+      .then(function(r) { return r.json(); })
+      .then(function(agents) { _agents = agents; renderAgentCards(agents); })
+      .catch(function() { _agents = null; renderAgentCards(null); });
+  }
+
+  // A machine switch re-renders the grid (the dsh card's D-15 state depends on it).
+  function refresh() {
+    renderAgentCards(_agents);
+    return true;
+  }
+
+  root.NewSessionAgentGrid = {
+    render: renderAgentCards,
+    refresh: refresh,
+    open: open,
+    dshRoutePick: dshRoutePick,
+    _agentDefs: AGENT_DEFS,
+  };
+})(typeof window !== 'undefined' ? window : globalThis);

package/template/coding-task-manager/public/js/pasted-content.js

@@ -0,0 +1,236 @@
+/**
+ * PastedContent — the single recogniser of Claude Code's paste wrapper.
+ *
+ * Design: docs/hub-viewed-box-conv-freshness-and-paste-render-2026-10-31.html
+ *   §5 D-5 (one strict producer rule, no other file contains the literal
+ *   `<pasted_content` outside tests and docs), D-6 (`toMarkdown`, user cards),
+ *   D-7 (`unwrap`, terminal renderer + usage preview); §8 WP-1.
+ *
+ * Rule provenance: Claude Code's own wrapper, ported from martinus/wostuast
+ * PR #145 and verified on 97/97 real wrappers (§1d) — every real opener is a
+ * line that is exactly `<pasted_content id="hhhh">` with `hhhh` 4 lowercase
+ * hex, matched by a closer line with the same id. The 7 non-matching
+ * occurrences are lookalikes inside pasted code and stay typed text.
+ *
+ * Wrapper shape (all on line boundaries):
+ *   [≤2 '\n'] <pasted_content id="hhhh"> '\n' <body> '\n' </pasted_content id="hhhh"> [≤2 '\n']
+ * The opener's trailing '\n', the closer's leading '\n', and up to 2 further
+ * '\n' on each side belong to the wrapper. The body is the text strictly
+ * between the opener's trailing '\n' and the closer's leading '\n' — blank
+ * lines and lookalike tags inside it are body text, verbatim.
+ *
+ * UMD: `module.exports = api` under Node, `window.PastedContent = api` in the
+ * browser (same wrapper shape as public/js/walle-message-contract.js:1-5).
+ */
+(function(root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.PastedContent = api;
+})(typeof window !== 'undefined' ? window : globalThis, function() {
+  'use strict';
+
+  // A line that is EXACTLY the opener/closer tag, bounded by start-of-text or '\n' on the left
+  // and '\n' or end-of-text on the right. Not `/m` ^/$: JS multiline anchors also match next to
+  // '\r' (and U+2028/2029), which would accept a CRLF lookalike and leak '\r' into the body.
+  // Ids are exactly 4 lowercase hex chars.
+  var OPEN_LINE_RE = /(?<![^\n])<pasted_content id="([0-9a-f]{4})">(?![^\n])/g;
+  var CLOSE_LINE_RE = /(?<![^\n])<\/pasted_content id="([0-9a-f]{4})">(?![^\n])/g;
+
+  /** Consecutive '\n' immediately before `pos`, capped at 2. */
+  function newlinesBefore(s, pos) {
+    var k = 0;
+    while (k < 2 && pos - 1 - k >= 0 && s.charCodeAt(pos - 1 - k) === 10) k++;
+    return k;
+  }
+
+  /** Consecutive '\n' immediately after `pos`, capped at 2. */
+  function newlinesAfter(s, pos) {
+    var k = 0;
+    while (k < 2 && pos + k < s.length && s.charCodeAt(pos + k) === 10) k++;
+    return k;
+  }
+
+  /** Longest run of consecutive backticks anywhere in `str`. */
+  function longestBacktickRun(str) {
+    var best = 0;
+    var cur = 0;
+    for (var i = 0; i < str.length; i++) {
+      if (str.charCodeAt(i) === 96) {
+        cur++;
+        if (cur > best) best = cur;
+      } else {
+        cur = 0;
+      }
+    }
+    return best;
+  }
+
+  /** A fence long enough to contain any backtick run in `body`. */
+  function fenceFor(body) {
+    return '`'.repeat(Math.max(3, longestBacktickRun(body) + 1));
+  }
+
+  /**
+   * Split `text` into typed and paste segments.
+   *
+   * Linear: pass 1 collects closer line starts per id into ascending arrays;
+   * pass 2 walks the openers in order, using a per-id cursor into its closer
+   * array (advanced forward only, never rescanned) and skipping any opener
+   * that starts before the current scan cursor (so an opener inside a body is
+   * body text, not a new wrapper). No lazy `[\s\S]*?` body regex.
+   *
+   * @param {string} text raw user prompt text (null/undefined → '')
+   * @returns {Array<{kind:'typed'|'paste', text:string, id?:string}>}
+   *   Empty typed segments are omitted; no input → []. Concatenating the
+   *   segment texts plus the removed wrapper characters reproduces the input.
+   */
+  function segments(text) {
+    var s = text === null || text === undefined ? '' : String(text);
+    if (s === '') return [];
+
+    // Pass 1: closer line starts, per id, in ascending order.
+    var closers = Object.create(null);
+    var m;
+    CLOSE_LINE_RE.lastIndex = 0;
+    while ((m = CLOSE_LINE_RE.exec(s)) !== null) {
+      var cid = m[1];
+      if (!closers[cid]) closers[cid] = [];
+      closers[cid].push({ start: m.index, end: m.index + m[0].length });
+    }
+
+    // Pass 2: openers left to right; pair with the first later same-id closer.
+    var pairs = [];
+    var ptr = Object.create(null);
+    var cursor = 0; // scan resumes after each matched closer
+    OPEN_LINE_RE.lastIndex = 0;
+    while ((m = OPEN_LINE_RE.exec(s)) !== null) {
+      var oStart = m.index;
+      var oEnd = oStart + m[0].length;
+      if (oStart < cursor) continue; // inside a body already claimed
+      var id = m[1];
+      var list = closers[id];
+      if (!list) continue;
+      var i = ptr[id] || 0;
+      while (i < list.length && list[i].start <= oEnd) i++;
+      ptr[id] = i;
+      if (i >= list.length) continue;
+      var closer = list[i];
+      ptr[id] = i + 1;
+      cursor = closer.end;
+      pairs.push({
+        id: id,
+        openStart: oStart,
+        openEnd: oEnd,
+        closeStart: closer.start,
+        closeEnd: closer.end,
+      });
+    }
+
+    if (pairs.length === 0) return [{ kind: 'typed', text: s }];
+
+    // Removed wrapper spans: the tags, their owning '\n', and ≤2 further '\n'
+    // per side. Paste bodies are the text strictly between those.
+    var events = [];
+    for (var p = 0; p < pairs.length; p++) {
+      var pair = pairs[p];
+      var before = newlinesBefore(s, pair.openStart);
+      var after = newlinesAfter(s, pair.closeEnd);
+      events.push({ kind: 'removed', start: pair.openStart, end: pair.openEnd + 1 });
+      events.push({ kind: 'removed', start: pair.closeStart - 1, end: pair.closeEnd });
+      if (before > 0) events.push({ kind: 'removed', start: pair.openStart - before, end: pair.openStart });
+      if (after > 0) events.push({ kind: 'removed', start: pair.closeEnd, end: pair.closeEnd + after });
+      events.push({
+        kind: 'paste',
+        id: pair.id,
+        start: pair.openEnd + 1,
+        end: pair.closeStart - 1,
+      });
+    }
+    events.sort(function(a, b) {
+      if (a.start !== b.start) return a.start - b.start;
+      return a.kind === b.kind ? a.end - b.end : (a.kind === 'removed' ? -1 : 1);
+    });
+
+    var out = [];
+    var pos = 0;
+    for (var e = 0; e < events.length; e++) {
+      var ev = events[e];
+      if (ev.start < pos) {
+        // Overlap: two wrappers sharing owned newlines, or an empty body whose opener and closer
+        // removals touch. A removal still extends the consumed range; an empty paste emits nothing.
+        if (ev.kind === 'removed' && ev.end > pos) pos = ev.end;
+        continue;
+      }
+      if (ev.start > pos) out.push({ kind: 'typed', text: s.slice(pos, ev.start) });
+      if (ev.kind === 'paste') {
+        out.push({ kind: 'paste', text: s.slice(ev.start, ev.end), id: ev.id });
+      }
+      pos = ev.end;
+    }
+    if (pos < s.length) out.push({ kind: 'typed', text: s.slice(pos) });
+
+    var kept = [];
+    for (var k = 0; k < out.length; k++) {
+      if (out[k].kind === 'typed' && out[k].text === '') continue;
+      kept.push(out[k]);
+    }
+    return kept;
+  }
+
+  /**
+   * Body text only: the segments' texts joined with '\n\n'. D-7 (terminal
+   * renderer, usage preview). No wrapper → the input string unchanged.
+   */
+  function unwrap(text) {
+    var s = text === null || text === undefined ? '' : String(text);
+    var segs = segments(s);
+    if (segs.length <= 1 && (segs.length === 0 || segs[0].kind === 'typed')) return s;
+    return segs.map(function(seg) { return seg.text; }).join('\n\n');
+  }
+
+  /**
+   * Markdown for a USER card. D-6. Each paste becomes
+   *   fence + 'text\n' + body + '\n' + fence
+   * with fence = '`'.repeat(max(3, longestBacktickRun(body) + 1)); typed
+   * segments pass through unchanged; segments join with '\n\n'. No wrapper →
+   * the input string unchanged.
+   */
+  function toMarkdown(text) {
+    var s = text === null || text === undefined ? '' : String(text);
+    var segs = segments(s);
+    if (segs.length <= 1 && (segs.length === 0 || segs[0].kind === 'typed')) return s;
+    return segs.map(function(seg) {
+      if (seg.kind === 'typed') return seg.text;
+      var fence = fenceFor(seg.text);
+      return fence + 'text\n' + seg.text + '\n' + fence;
+    }).join('\n\n');
+  }
+
+  /**
+   * Label text for a PREVIEW, which is a truncated prefix of the prompt: unwrap every complete
+   * wrapper, then drop one leading opener line whose closer was cut off by the truncation (after
+   * unwrap, a leading opener can only remain because its closer is missing).
+   */
+  function previewText(text) {
+    var s = unwrap(text);
+    var m = /^\s*<pasted_content id="[0-9a-f]{4}">(?:\n|$)/.exec(s);
+    return m ? s.slice(m[0].length) : s;
+  }
+
+  /** True when `text` contains at least one recognised wrapper pair. */
+  function hasWrapper(text) {
+    var segs = segments(text);
+    for (var i = 0; i < segs.length; i++) {
+      if (segs[i].kind === 'paste') return true;
+    }
+    return false;
+  }
+
+  return Object.freeze({
+    segments: segments,
+    unwrap: unwrap,
+    toMarkdown: toMarkdown,
+    hasWrapper: hasWrapper,
+    previewText: previewText,
+  });
+});