create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/public/js/session-search-utils.js

@@ -10,6 +10,10 @@
   // a <script src="porter-stemmer.js"> tag (see public/index.html and
   // public/m/index.html) and hangs off `root.PorterStemmer`.
   const PorterStemmer = typeof require === 'function' ? require('./porter-stemmer') : root.PorterStemmer;
+  // The one command-to-agent rule (WP-2, S-8): the same UMD module the server re-exports. Under
+  // Node it is `require`d; in the browser it is loaded first via <script src="js/agent-command.js">
+  // (see public/index.html and public/m/index.html) and hangs off `root.CtmAgentCommand`.
+  const AgentCommand = typeof require === 'function' ? require('./agent-command') : root.CtmAgentCommand;
 
   const SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ig;
   const SEARCH_WRAP_RE = /^[\s"'`“”‘’]+|[\s"'`“”‘’,.;:!?)}\]]+$/g;
@@ -809,10 +813,11 @@
     opencode: 'OpenCode',
     cursor: 'Cursor',
     'claude-desktop': 'Claude Desktop',
+    dsh: 'DeepSeek Harness',
     shell: 'Shell / Other',
   };
 
-  const AGENT_FILTER_ORDER = ['codex', 'claude', 'walle', 'cursor', 'gemini', 'opencode', 'claude-desktop', 'shell'];
+  const AGENT_FILTER_ORDER = ['codex', 'claude', 'walle', 'cursor', 'gemini', 'opencode', 'dsh', 'claude-desktop', 'shell'];
 
   function normalizeRecentAgentType(value) {
     if (!value) return '';
@@ -826,6 +831,8 @@
     if (v === 'gemini-cli') return 'gemini';
     if (v === 'open-code' || v === 'opencode-cli') return 'opencode';
     if (v === 'cursor-agent' || v === 'cursor-cli') return 'cursor';
+    // WP-7 (S-54): the dsh aliases the server normalizes to `dsh` (lib/agent-capabilities.js).
+    if (v === 'deepseek-harness' || v === 'deepseek' || v === 'dsh') return 'dsh';
     if (v === 'terminal' || v === 'unknown' || v === 'other') return 'shell';
     return '';
   }
@@ -833,6 +840,11 @@
   function detectRecentAgentTypeFromText(value) {
     if (!value) return '';
     const v = String(value).toLowerCase();
+    // WP-7 (S-54): D-3 command-word match — `/x/dshell` must not read as dsh.
+    if (/^(?:\S*\/)?dsh(?:\s|$)/.test(v)) return 'dsh';
+    // WP-2 (S-8, D-4): the command word wins — `/x/codex/bin/claude` is `claude`, not `codex`.
+    // The substring fallbacks below stay for commands whose word names no agent.
+    const w = AgentCommand.agentTypeFromCommandWord(v); if (w) return w;
     if (v.includes('opencode') || v.includes('open-code')) return 'opencode';
     if (v.includes('cursor')) return 'cursor';
     if (v.includes('wall-e') || v.includes('walle')) return 'walle';
@@ -914,13 +926,17 @@
 
     const emptyMode = f.emptyMode || (f.showEmptyOnly ? 'only' : 'exclude');
     if (emptyMode === 'only' && !s.isEmpty) return false;
-    if (emptyMode === 'exclude' && s.isEmpty) return false;
+    // D-7: a starred row stays visible even when empty — the default 'exclude' mode
+    // hides only UNstarred empty rows. Recent rows carry `starred` (lib/recent-catalog-query.js).
+    if (emptyMode === 'exclude' && s.isEmpty && !s.starred) return false;
 
     const project = stripWorktreePath(f.project || '');
     if (project && stripWorktreePath(s.project || s.cwd || '') !== project) return false;
 
     const agent = normalizeRecentAgentType(f.agent || '');
     if (agent && !getRecentSessionAgentTypes(s).includes(agent)) return false;
+    // G-1: computer filter. null/undefined = all; '' = Local (no machine key); else an instanceId.
+    if (typeof f.machine === 'string' && String(s.machine || '').trim() !== f.machine) return false;
     return true;
   }
 

package/template/coding-task-manager/public/js/session-usage-view.js

@@ -7,6 +7,7 @@
 })(function() {
   'use strict';
   var fmt = (typeof window !== 'undefined' && window.CTMUsageFormat) || (typeof require === 'function' ? require('./usage-format.js') : null);
+  var pasted = (typeof window !== 'undefined' && window.PastedContent) || (typeof require === 'function' ? require('./pasted-content.js') : null);
   var RESTART_NOTICE = 'This server answers an older usage format — restart CTM.';
   var TABS = [['tasks', 'Tasks'], ['prompts', 'Prompts'], ['agents', 'Agents'], ['models', 'Models']];
   var CALLS_PAGE = 100;
@@ -511,7 +512,7 @@
     return '<div class="table-wrap"><table class="attribution"><thead>' + head + '</thead><tbody>' + body + '</tbody></table></div>';
   }
   function previewLabel(text) {
-    var label = String(text || '').replace(/^\s*<pasted_content(?:\s[^>]*)?>\s*/i, '').replace(/\s*<\/pasted_content>\s*$/i, '');
+    var label = pasted ? pasted.previewText(String(text || '')) : String(text || '');
     var command = /^\s*<command-name>\s*([^<]+)\s*<\/command-name>\s*$/i.exec(label);
     return (command ? command[1].trim() : label) || '(no text)';
   }

package/template/coding-task-manager/public/js/session-workspace-tracking.js

@@ -10,6 +10,8 @@
   const GIT_STATES = ['checking', 'known', 'unknown', 'unavailable'];
   const PROVENANCE = ['current-snapshot', 'last-observed', 'configured', 'unavailable'];
   const UNAVAILABLE_CODES = ['WORKSPACE_IDENTITY_CHANGED', 'WORKSPACE_IDENTITY_UNAVAILABLE'];
+  // The radar's closed level set (§6.3). `unknown` is not a level; anything outside render nothing.
+  const LANDING_LEVELS = ['L0', 'L1', 'L1*', 'L2', 'L3'];
   // What the existing details panel calls each provenance — never "current" for a branch that
   // did not come from a matching fresh snapshot (D-6/AC-3c).
   const PROVENANCE_LABELS = {
@@ -124,6 +126,46 @@
     }
     return { kind: 'unknown', ref: '', display: 'unknown', label: 'Workspace context unavailable' };
   }
+  // WP-3b (§6.3): the landing-queue sub-view the same freshness gate publishes. Normalised here so
+  // a hand-built or older payload can never invent a position or a radar level, and `detailRows`
+  // never has to guess — an absent/`null` landing stays `null` (nothing to show).
+  function normaliseLanding(raw) {
+    if (!raw || typeof raw !== 'object') return null;
+    const radarRaw = raw.radar && typeof raw.radar === 'object' ? raw.radar : {};
+    const max = LANDING_LEVELS.includes(text(radarRaw.max)) ? text(radarRaw.max) : null;
+    const peers = (Array.isArray(radarRaw.with) ? radarRaw.with : [])
+      .filter((entry) => entry && typeof entry === 'object')
+      .map((entry) => ({ session: text(entry.session), branch: text(entry.branch), level: text(entry.level) }))
+      // A level outside the closed set is not a level, and a pair without a branch is not a pair.
+      .filter((entry) => entry.branch && LANDING_LEVELS.includes(entry.level));
+    return {
+      jobId: typeof raw.jobId === 'string' && raw.jobId ? raw.jobId : null,
+      // Only a string is a state word: a number/object would print as "[object Object]" in a row.
+      state: typeof raw.state === 'string' && raw.state.trim() ? raw.state.trim() : null,
+      position: typeof raw.position === 'number' && Number.isFinite(raw.position) ? raw.position : null,
+      total: typeof raw.total === 'number' && Number.isFinite(raw.total) ? raw.total : 0,
+      eta_s: typeof raw.eta_s === 'number' && Number.isFinite(raw.eta_s) ? raw.eta_s : null,
+      radar: { max, with: peers },
+    };
+  }
+  function landingEtaLabel(etaSeconds) {
+    return typeof etaSeconds === 'number' && Number.isFinite(etaSeconds)
+      ? `${Math.round(etaSeconds / 60)}m` : '';
+  }
+  // '#2 of 3 · queued · ETA 23m' — each clause is dropped when the payload does not carry it.
+  function landingJobLine(landing) {
+    const parts = [];
+    if (landing.position !== null) parts.push(`#${landing.position} of ${landing.total}`);
+    if (landing.state) parts.push(landing.state);
+    const eta = landingEtaLabel(landing.eta_s);
+    if (eta) parts.push(`ETA ${eta}`);
+    return parts.join(' · ');
+  }
+  // 'L3 with feat/x, L2 with feat/y' — the server sorts `with` strongest-first.
+  function landingRadarLine(radar) {
+    const peers = radar && Array.isArray(radar.with) ? radar.with : [];
+    return peers.map((entry) => `${entry.level} with ${entry.branch}`).join(', ');
+  }
   function present(tracking) {
     tracking = tracking || {};
     const selection = tracking.selection || {};
@@ -166,7 +208,7 @@
           && text(entry.workspaceIncarnation) === text(tracking.workspaceIncarnation)))
       .slice(0, 12);
     return {
-      tracking, selection, git, matching, freshness, branch, provenance,
+      tracking, selection, git, matching, freshness, branch, provenance, landing: normaliseLanding(tracking.landing),
       // Mirrors the projection's own derivation for payloads that predate `git.state`: a fresh
       // snapshot is only "known" when its tracked state is — an unmeasured snapshot is unknown,
       // never a clean 0-file reading.
@@ -243,6 +285,14 @@
     const activityCheckout = checkoutLabel(view.selection.lastActivityCheckout);
     const currentCheckout = checkoutLabel(view.git.checkout);
     if (activityCheckout && activityCheckout !== currentCheckout) rows.push(['Last activity checkout', activityCheckout]);
+    // WP-3b: the landing-queue rows. Each is omitted when the payload carries nothing to show, so a
+    // repo with no queue renders exactly the rows it always did.
+    if (view.landing) {
+      const job = landingJobLine(view.landing);
+      if (job) rows.push(['Landing job', job]);
+      const radar = landingRadarLine(view.landing.radar);
+      if (radar) rows.push(['Radar', radar]);
+    }
     return rows;
   }
   function checkoutLabel(checkout) {

package/template/coding-task-manager/public/js/state-sync-client.js

@@ -1083,7 +1083,16 @@
     const action = stateSyncFrameAction(baseline, frame);
     if (action === 'ignore') return action;
     if (action === 'request-keyframe') {
-      if (deps.requestKeyframe) deps.requestKeyframe('desync:base=' + frame.baseSeq + ',have=' + Number(baseline?.seq || 0));
+      // WP-2 (D-6, §6/S-14): ONE desync request per (session, committed baseline seq). A pipelined
+      // window can leave several base-mismatched deltas in flight after one desync, and every one
+      // of them lands here -- only the first asks, and it tells the server the baseline it holds.
+      // No timer and no reset hook: the answering keyframe moves baseline.seq, so the next desync
+      // carries a different haveSeq and requests on its own. deps.onSkipped still fires per frame.
+      const haveSeq = Number(baseline?.seq || 0);
+      if (!session || session._stateSyncDesyncReqHaveSeq !== haveSeq) {
+        if (session) session._stateSyncDesyncReqHaveSeq = haveSeq;
+        if (deps.requestKeyframe) deps.requestKeyframe('desync:base=' + frame.baseSeq + ',have=' + haveSeq, { haveSeq });
+      }
       if (typeof deps.onSkipped === 'function') deps.onSkipped('request-keyframe', frame);
       return action;
     }

package/template/coding-task-manager/public/js/stream-view.js

@@ -589,9 +589,10 @@ function _tooltipAgentLabel(session, anchorEl) {
     return { walle: 'Wall-E', codex: 'Codex', gemini: 'Gemini', claude: 'Claude Code', shell: 'Shell' }[agent] || _tooltipStatusLabel(agent);
   }
   const cmd = _tooltipText(session?.meta?.cmd).toLowerCase();
-  if (cmd.includes('codex')) return 'Codex';
-  if (cmd.includes('gemini')) return 'Gemini';
-  if (cmd.includes('claude')) return 'Claude Code';
+  // WP-2 (S-9, D-4): one command-word decision for every agent label.
+  const detected = window.CtmAgentCommand.detectAgentType(cmd);
+  const label = { claude: 'Claude Code', codex: 'Codex', gemini: 'Gemini', opencode: 'OpenCode', cursor: 'Cursor', dsh: 'DeepSeek Harness' }[detected];
+  if (label) return label;
   if (session?.meta?.type === 'walle') return 'Wall-E';
   return 'Session';
 }
@@ -794,7 +795,7 @@ function _syncStreamTooltipStatus() {
     const fresh = _tooltipStatusPill(session);
     if (pill.textContent !== fresh.textContent || pill.className !== fresh.className || pill.title !== fresh.title) pill.replaceWith(fresh);
   }
-  if (typeof BackgroundWork !== 'undefined') BackgroundWork.syncTooltip(tooltip, session._statusRow?.backgroundWork, { cap: _tooltipCap, age: _tooltipAge }, (body) => _tooltipSection('Background work', body));
+  if (typeof BackgroundWork !== 'undefined') BackgroundWork.syncTooltip(tooltip, session._statusRow?.backgroundWork, { cap: _tooltipCap, age: _tooltipAge, sessionId: session.id }, (body) => _tooltipSection('Background work', body));
   const footer = tooltip.querySelector('[data-tooltip-footer]');
   if (footer) {
     const text = _tooltipFooterBits(session).join(' | ');
@@ -941,7 +942,7 @@ async function showStreamTooltip(sessionId, anchorEl, opts = {}) {
     _tooltipAppendAiSummary(content, summary.aiSummary, currentTask);
 
     _tooltipAppendProgress(content, summary.progress);
-    if (typeof BackgroundWork !== 'undefined') BackgroundWork.syncTooltip(content, session?._statusRow?.backgroundWork, { cap: _tooltipCap, age: _tooltipAge }, (body) => _tooltipSection('Background work', body));
+    if (typeof BackgroundWork !== 'undefined') BackgroundWork.syncTooltip(content, session?._statusRow?.backgroundWork, { cap: _tooltipCap, age: _tooltipAge, sessionId: session?.id }, (body) => _tooltipSection('Background work', body));
 
     _streamState._tooltipFooterTail = [];
     if (summary.turnCount) _streamState._tooltipFooterTail.push(String(summary.turnCount) + ' turns');

package/template/coding-task-manager/public/js/terminal/conv-only-session.js

@@ -0,0 +1,287 @@
+'use strict';
+
+// WP-7 (S-52/S-57, AC-7b): the client capability table (CLIENT_AGENT_CAPABILITIES in index.html,
+// reached through _ctmAgentCapsForSession / _clientAgentCaps) is the single source of truth for
+// "does this session have a CLI (PTY/xterm) surface at all". dsh is conv-only, so its tab never
+// builds an xterm — the rule is capability-driven, never agent-name-driven.
+function _sessionClientCapsFor(id) {
+  const s = id && state.sessions.get(id);
+  if (!s && !id) return null;
+  if (typeof _ctmAgentCapsForSession === 'function') {
+    try {
+      const caps = _ctmAgentCapsForSession(id);
+      if (caps) return caps;
+    } catch (e) { /* expected: fall through to the session meta */ }
+  }
+  const meta = (s && s.meta) || {};
+  const at = meta.agentType || meta.agent_type || meta.type;
+  if (typeof _clientAgentCaps === 'function' && at) return _clientAgentCaps(at);
+  return null;
+}
+
+function _sessionCliUnavailable(id) {
+  const caps = _sessionClientCapsFor(id);
+  return !!(caps && caps.surfaces && caps.surfaces.cli && caps.surfaces.cli.available === false);
+}
+
+// The conv-only client shape: a `.term-container` (what setSessionView/activateTab expect) with no
+// xterm, no PTY bootstrap and no pending attach. `createConversationView`/`setSessionView` mount the
+// only surface such a session has.
+function _ensureConvOnlySessionClientShape(id, meta) {
+  if (!id) return null;
+  const existing = state.sessions.get(id);
+  if (existing && existing._convOnly === true && existing.container
+      && existing.container.classList && existing.container.classList.contains('term-container')) {
+    existing.meta = { ...(existing.meta || {}), ...(meta || {}) };
+    return existing;
+  }
+  if (existing) {
+    _terminalReleaseSessionAttachmentSources(existing);
+    _disposeSessionClientSurface(existing);
+  }
+  let container = document.getElementById('term-' + id);
+  if (!container) {
+    container = document.createElement('div');
+    document.getElementById('terminal-area').appendChild(container);
+  }
+  container.className = 'term-container';
+  container.id = 'term-' + id;
+  container.dataset.sessionId = id;
+  setPaneVisible(container, _sessionSurfaceShouldBeVisible(id));
+  // The same conversation view createTerminal() mounts inside every terminal container — the only
+  // surface a conv-only session has.
+  if (typeof createConversationView === 'function' && !container.querySelector('.conversation-view')) {
+    const view = createConversationView(id);
+    // The composer sits under the view in the container's flex column: the view takes the rest.
+    Object.assign(view.style, { height: 'auto', flex: '1 1 auto', minHeight: '0' });
+    container.appendChild(view);
+  }
+  _ensureConvOnlyComposer(id, container);
+  const s = {
+    ...(existing || {}),
+    _id: id,
+    meta: { ...((existing && existing.meta) || {}), ...(meta || {}) },
+    container,
+    term: null,
+    fitAddon: null,
+    needsTerminal: false,
+    needsAttach: false,
+    _convOnly: true,
+  };
+  state.sessions.set(id, s);
+  _ensureConvOnlyModelControl(id, container);
+  if (typeof setSessionView === 'function') {
+    // expected: setSessionView needs a mounted conv view factory; the session surface falls back to
+    // the next frame's render, so a throw here is not a lost session.
+    try { setSessionView(id, 'conv'); } catch (e) { /* expected: conv surface mounts on the next frame */ }
+  }
+  return s;
+}
+
+// WP-7b: a conv-only tab gets the shared agent composer (AgentUIPrimitives.createComposer, the same
+// primitive Wall-E's composer wraps). Send rides the generic submit-prompt path (window.submitPrompt,
+// as the Queue Builder does); Stop is the generic interrupt-session the server maps to ACP cancel.
+const CONV_ONLY_TERMINAL_STATUSES = new Set(['completed', 'failed', 'blocked', 'cancelled', 'rejected']);
+
+function _convOnlyCaps(id) {
+  const caps = _sessionClientCapsFor(id);
+  return (caps && caps.input) || {};
+}
+
+// WP-11 (D-20): attach is a CAPABILITY, not a preference. `_convOnlyCaps(id).attachments` is true
+// exactly when the session's LIVE child advertised `promptCapabilities.image` — the server row
+// carries that as `imageInput` (lib/acp/dsh-session-runtime.js → lib/session-create/dsh-session.js
+// → server.js `_sessionPayload.agentCapabilities.input`), which _ctmAgentCapsForSession merges over
+// the static table. Until that projection lands the static `dsh` row's `attachments:false` wins, so
+// the button hides and SAYS WHY (AC-11b/AC-11e).
+const CONV_ONLY_ATTACH_DISABLED_TITLE =
+  'Images are unavailable: this DeepSeek Harness agent did not advertise image prompt support.';
+const CONV_ONLY_ATTACH_TITLE = 'Attach images';
+// id → the images uploaded for that session's NEXT prompt. Cleared once the prompt is accepted, so a
+// refused prompt keeps them for a retry.
+const _convOnlyImages = new Map();
+
+function _convOnlyAttachAllowed(id) {
+  return _convOnlyCaps(id).attachments === true;
+}
+
+function _convOnlyImageExtension(type) {
+  const t = String(type || '').toLowerCase();
+  if (t === 'image/jpeg' || t === 'image/jpg') return '.jpg';
+  if (t === 'image/webp') return '.webp';
+  if (t === 'image/gif') return '.gif';
+  return '.png';
+}
+
+// The desktop terminal composer's own upload, through the SAME two shared client modules it uses
+// (public/index.html `_terminalUploadPastedImage`): window.CTMImage.normalizeForProvider, then
+// window.CTMUploader against CTM's one upload store with the terminal path's `defer_row=1` row.
+// Neither the normalizer nor the uploader is re-implemented here, and the ref list this returns is
+// the shape lib/session-image-refs.js already resolves (`filename` is the served basename).
+async function _convOnlyUploadImage(file, ordinal) {
+  const source = 'conv-image-' + Date.now() + '-' + ordinal + _convOnlyImageExtension(file && file.type);
+  const normalized = window.CTMImage && typeof window.CTMImage.normalizeForProvider === 'function'
+    ? await window.CTMImage.normalizeForProvider(file, { filename: source, useWorker: window.CTM_IMAGE_WORKER_NORMALIZE === true })
+    : { blob: file, filename: source, mimeType: (file && file.type) || 'image/png' };
+  const filename = normalized.filename || source;
+  const data = await window.CTMUploader.upload({
+    url: '/api/images/upload?prompt_id=0&defer_row=1&source=terminal-path&filename=' +
+      encodeURIComponent(filename) + '&token=' + encodeURIComponent(state.token || ''),
+    method: 'POST',
+    headers: { 'Content-Type': normalized.mimeType || (file && file.type) || 'image/png' },
+    body: normalized.blob || file,
+  });
+  if (!data || !data.filename) throw new Error((data && data.error) || 'Image upload failed');
+  return {
+    id: data.id || null,
+    filename: data.filename,
+    path: data.path || '',
+    url: '/api/images/file/' + encodeURIComponent(data.filename),
+    mimeType: normalized.mimeType || (file && file.type) || 'image/png',
+    kind: 'image',
+    status: 'ready',
+  };
+}
+
+// The manifest the desktop composer writes when a prompt with images is accepted: the SAME route and
+// the same body (`_terminalRecordSessionImageRefs`, index.html). The join in lib/session-image-refs.js
+// matches a manifest to the user row that names its `[Image #N]` token within five minutes.
+async function _convOnlyRecordImageRefs(id, images, promptText) {
+  const response = await fetch('/api/sessions/' + encodeURIComponent(id) + '/image-refs?token=' + encodeURIComponent(state.token || ''), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    keepalive: true,
+    body: JSON.stringify({
+      sessionId: id,
+      submissionId: '',
+      submittedAt: Date.now(),
+      promptText: String(promptText || '').slice(0, 4096),
+      images: images.map((att) => ({
+        id: att.id || null, attachmentId: att.attachmentId || null, revision: null,
+        label: att.label || '', filename: att.filename || '', path: att.path || '', url: att.url || '',
+        confirmation: 'confirmed',
+      })),
+    }),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok || data.ok === false) throw new Error(data.error || 'Could not record session image references');
+  return data;
+}
+
+function _convOnlyUpdateAttachTitle(id, composer) {
+  const attach = composer && composer.querySelector('.agent-ui-button.subtle');
+  if (!attach) return;
+  const count = (_convOnlyImages.get(id) || []).length;
+  attach.title = count ? CONV_ONLY_ATTACH_TITLE + ' (' + count + ' attached)' : CONV_ONLY_ATTACH_TITLE;
+}
+
+async function _convOnlyAttachImages(id, files, composer) {
+  if (!_convOnlyAttachAllowed(id)) return false;
+  const incoming = Array.from(files || []).filter((file) => file && /^image\//i.test(String(file.type || '')));
+  if (!incoming.length) return false;
+  const images = _convOnlyImages.get(id) || [];
+  for (let index = 0; index < incoming.length; index += 1) {
+    try {
+      const uploaded = await _convOnlyUploadImage(incoming[index], images.length + 1);
+      uploaded.label = '[Image #' + (images.length + 1) + ']';
+      images.push(uploaded);
+      _convOnlyImages.set(id, images);
+    } catch (error) {
+      // HANDLE: one unreadable/failed file never blocks the composer or the other files.
+      console.warn('[conv-only] image upload failed:', error && error.message ? error.message : error);
+    }
+  }
+  _convOnlyUpdateAttachTitle(id, composer);
+  return images.length > 0;
+}
+
+function _ensureConvOnlyComposer(id, container) {
+  const primitives = typeof AgentUIPrimitives !== 'undefined' ? AgentUIPrimitives : null;
+  if (!primitives || typeof primitives.createComposer !== 'function') return null;
+  const existing = container.querySelector(':scope > .conv-only-composer');
+  if (existing) return existing;
+  const composer = primitives.createComposer({
+    className: 'conv-only-composer',
+    placeholder: 'Message the agent…',
+    accept: 'image/*',
+    // WP-11 (D-20): the Attach button opens the primitive's own hidden file input; the files go
+    // through CTM's upload store (see _convOnlyUploadImage) and ride the next prompt's
+    // `attachments`, exactly like the desktop composer's.
+    onFiles: (files) => { void _convOnlyAttachImages(id, files, composer); },
+    onSubmit: (_mode, text) => _convOnlySubmit(id, composer, text),
+    // Escape also calls onStop; only a running turn has anything to interrupt.
+    onStop: () => { if (_convOnlyRunning(composer) && typeof send === 'function') send({ type: 'interrupt-session', id }); },
+  });
+  const attach = composer.querySelector('.agent-ui-button.subtle');
+  if (attach) {
+    const allowed = _convOnlyAttachAllowed(id);
+    attach.hidden = !allowed;
+    attach.title = allowed ? CONV_ONLY_ATTACH_TITLE : CONV_ONLY_ATTACH_DISABLED_TITLE;
+    attach.setAttribute('aria-label', attach.title);
+  }
+  container.appendChild(composer);
+  return composer;
+}
+
+// WP-8 step 4: a conv-only tab has no `.session-toolbar`, so the shared model chip (the one every
+// terminal tab gets) leads the composer's action row; the chip refresh paths find it inside the
+// session container (_findSessionModelChip). It needs the registered session, so it mounts after
+// state.sessions.set.
+function _ensureConvOnlyModelControl(id, container) {
+  const actions = container.querySelector(':scope > .conv-only-composer .agent-ui-composer-actions');
+  if (!actions || actions.querySelector('.model-switch-control') || typeof createSessionModelControl !== 'function') return;
+  const control = createSessionModelControl(id);
+  if (control) actions.insertBefore(control, actions.firstChild);
+}
+
+function _convOnlyRunning(composer) {
+  return !!composer && composer.primaryButton.dataset.sendMode !== 'send';
+}
+
+// The text the provider AND the transcript see. The `[Image #N]` labels lead it exactly the way the
+// desktop composer's canonical prompt carries them: lib/session-image-refs.js attaches a recorded
+// manifest to the user row that NAMES the token, so an image prompt whose text omits it would
+// reload without thumbnails even though the bytes reached the agent.
+function _convOnlyWireText(value, images) {
+  const labels = images.map((att, index) => att.label || ('[Image #' + (index + 1) + ']'));
+  return labels.length ? labels.join(' ') + ' ' + value : value;
+}
+
+function _convOnlyAfterSubmit(id, composer, images, wireText, draft, record) {
+  if (!images.length) return;
+  const refused = !!(record && record.ok === false) || String((record && record.status) || '') === 'failed';
+  if (refused) return; // HANDLE: the server refused it; keep the images and the draft for a retry.
+  _convOnlyImages.delete(id);
+  _convOnlyUpdateAttachTitle(id, composer);
+  void _convOnlyRecordImageRefs(id, images, wireText).catch((error) => {
+    // REPORT: the prompt is already delivered; a manifest write only costs the reload thumbnail.
+    console.warn('[conv-only] session image ref recording failed:', error && error.message ? error.message : error);
+  });
+}
+
+function _convOnlySubmit(id, composer, text) {
+  const value = String(text || '').trim();
+  if (!value || typeof window.submitPrompt !== 'function') return;
+  // No queue capability (dsh: input.queue false): a second prompt waits for the turn to end.
+  if (_convOnlyRunning(composer) && _convOnlyCaps(id).queue !== true) return;
+  const images = (_convOnlyImages.get(id) || []).slice();
+  const wireText = _convOnlyWireText(value, images);
+  composer.input.value = '';
+  composer.setRunningState(true, 'queue', false);
+  Promise.resolve(window.submitPrompt(id, wireText, { source: 'web', attachments: images })).then(
+    (record) => _convOnlyAfterSubmit(id, composer, images, wireText, value, record),
+    () => {
+      // HANDLE: the prompt never left the client; give the text back and drop the running state.
+      composer.input.value = value;
+      composer.setRunningState(false, 'queue', false);
+    },
+  );
+}
+
+function _convOnlyHandleSubmitStatus(msg) {
+  const id = msg && msg.id;
+  const s = id && state.sessions.get(id);
+  if (!s || s._convOnly !== true || !CONV_ONLY_TERMINAL_STATUSES.has(String(msg.status || ''))) return;
+  const composer = s.container && s.container.querySelector(':scope > .conv-only-composer');
+  if (composer) composer.setRunningState(false, 'queue', false);
+}

package/template/coding-task-manager/public/js/terminal/runtime-09.js

@@ -982,6 +982,8 @@ function _terminalSkillAutocompletePath(id, trigger) {
   if (agentType && agentType !== 'shell') params.set('agent', agentType);
   const cwd = s?.meta?.cwd || s?.cwd || s?.meta?.project || s?.project || '';
   if (cwd) params.set('cwd', cwd);
+  // remote-agent-skills WP-9 (S-9): a session on another machine gets that machine's skill list.
+  if (id) params.set('sessionId', String(id));
   return `/skills/autocomplete?${params.toString()}`;
 }
 

package/template/coding-task-manager/public/js/terminal/runtime-10.js

@@ -1431,20 +1431,20 @@ async function _terminalRaceAttachmentFreeze(id, draft, Draft, started, attachme
   }
 }
 
-// The deadline-outcome handler for _terminalRaceAttachmentFreeze's 'deadline' result: flips
-// the draft to indeterminate (some attachments already froze) or aborts it (none did),
+// The deadline-outcome handler for _terminalRaceAttachmentFreeze's 'deadline' result: aborts
+// the submission (R-2: Enter is never forwarded on this path, so nothing was committed to the
+// provider and the draft is presumed aborted -- the chips return to attached/unconfirmed),
 // renders, records the metric, flushes any input queued during the freeze wait, and toasts.
 // Top-level for the same size-ratchet reason as its caller.
 function _terminalHandleAttachmentSubmissionDeadline(id, draft, Draft, frozenCount, attachmentCount, deps) {
-  if (frozenCount > 0) Draft.markIndeterminate(draft, 'Image send timed out before Enter');
-  else Draft.abortSubmission(draft, 'deadline');
+  const outcome = Draft.failSubmission(draft, 'Image send timed out before Enter');
   // F-E (review fix wave): this used to be a bare flush AFTER deps.renderDraft, whose own first
   // statement already settled -- so it saw an empty buffer and outcome:'deadline' was
   // unreachable. Settle with the outcome BEFORE the render (Enter is NOT forwarded here, so
   // this is also where the Enter boundary ends).
   _terminalSettleAttachmentDeferredInput(id, 'submission-deadline', 'deadline');
   deps.renderDraft(id);
-  deps.metric(id, 'submission_deadline', { attachmentCount, frozen: frozenCount });
+  deps.metric(id, 'submission_deadline', { attachmentCount, frozen: frozenCount, outcome });
   if (typeof toast === 'function') {
     toast('Image send timed out — press Enter to try again', {
       type: 'warning', duration: 4000, key: 'terminal-attachment-submission-deadline',

package/template/coding-task-manager/public/js/terminal/runtime-12.js

@@ -569,6 +569,12 @@ function _pruneTerminalHotCache(activeId, opts) {
   }
   const protectedIds = new Set();
   if (activeId) protectedIds.add(activeId);
+  // WP-2 (docs/box-session-client-diag-and-reader-jump-2026-11-01.html): `activeId` is NOT always
+  // the tab on screen -- createTerminal (index.html:14908) prunes with the id of a BACKGROUND
+  // terminal it just built on a sessions-list update, which parked the on-screen reader (view
+  // snapped to bottom). The on-screen tab is skipped in the park and eviction loops below (its
+  // reader and WebGL renderer survive); it is NOT added to `protectedIds`, so the budget is unchanged.
+  const activeTabId = state.activeTab || null;
   if (state.splitRoot) {
     try {
       allLeaves(state.splitRoot).forEach(leaf => {
@@ -592,6 +598,7 @@ function _pruneTerminalHotCache(activeId, opts) {
   // split-teardown) as the rest of this function.
   for (const sid of liveIds) {
     if (protectedIds.has(sid)) continue; // R-3: never park activeTab or a split-visible pane by visibility/prune alone
+    if (activeTabId && sid === activeTabId) continue; // WP-2: the tab on screen keeps its reader no matter which id this pass was called with
     try { window.TerminalHistoryViewport?.park(sid, 'prune'); } catch { /* expected: best-effort -- a park failure here must never block the prune pass itself */ }
   }
 
@@ -600,7 +607,7 @@ function _pruneTerminalHotCache(activeId, opts) {
   let disposedCount = 0;
   for (const sid of [...state.terminalHotOrder]) {
     if (nonProtectedLiveCount <= liveBudget) break;
-    if (protectedIds.has(sid)) continue;
+    if (protectedIds.has(sid) || (activeTabId && sid === activeTabId)) continue; // WP-2: the on-screen tab keeps its renderer too
     const s = state.sessions.get(sid);
     if (s && !s._exited) {
       _releaseWarmTerminalRenderer(s, 'hot-cache-live');

package/template/coding-task-manager/public/js/terminal/runtime-16.js

@@ -42,6 +42,10 @@ function _requestStateSyncKeyframe(id, options) {
     requestToken,
     priority: opts.priority === true,
     reason: String(opts.reason || '').slice(0, 48), // report-only
+    // WP-2 (D-6, §6/S-7): the client's own committed baseline seq, so the server can recognise a
+    // request its already-in-flight keyframe answers. Sent only when valid -- an omitted haveSeq
+    // means "old client" and is served exactly as today, while an explicit 0 means "no baseline".
+    ...(Number.isSafeInteger(opts.haveSeq) && opts.haveSeq >= 0 ? { haveSeq: opts.haveSeq } : {}),
   }) === true;
 }
 

package/template/coding-task-manager/public/js/terminal/runtime-20.js

@@ -1463,7 +1463,7 @@ function _ensureTerminalSessionClientShape(id, meta) {
     _disposeWalleSessionController(id, 'surface-replaced');
     state.sessions.delete(id);
     _presentationStore.removeSession(id);
-    if (warmLive) createTerminal(id, { active: false });
+    if (warmLive) createTerminal(id, { active: false, agentType: meta?.agentType || meta?.type || '', agentCapabilities: meta?.agentCapabilities || null });
     else _createTerminalStub(id);
     existing = state.sessions.get(id);
   }