create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/public/js/background-work.js

@@ -10,6 +10,7 @@
   if (root) root.BackgroundWork = api;
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   const LABEL_MAX = 80;
+  const GLOBAL = typeof globalThis === 'undefined' ? null : globalThis;
 
   function tasksOf(work) {
     return work && Array.isArray(work.tasks) ? work.tasks : [];
@@ -27,9 +28,10 @@
     return 'bg ' + word + (allQuiet ? ' · quiet ' + ageText(tasks[0].activeAt, now) : '');
   }
 
-  function clip(label) {
+  function clip(label, max) {
     const text = String(label || '');
-    return text.length > LABEL_MAX ? text.slice(0, LABEL_MAX - 1) + '…' : text;
+    const limit = Number(max) > 0 ? Number(max) : LABEL_MAX;
+    return text.length > limit ? text.slice(0, limit - 1) + '…' : text;
   }
 
   function ageText(since, now) {
@@ -45,34 +47,151 @@
     return tasksOf(work).map((t) => ((t && t.type) || 'task') + ': ' + clip(t && t.label) + ' · ' + ageText(t && t.since, now) + (t && t.quiet === true ? ' · quiet ' + ageText(t.activeAt, now) : '')).join('\n');
   }
 
-  // Hover-card body: one row per task (type, label, age). fmt.cap(text, n) and fmt.age(ms) are the card's own
-  // formatters. Returns null when there is nothing to list.
+  // §6.4 operator stop: the client half of POST /api/sessions/:id/background/:taskId/stop. One pending
+  // entry per (session, task) is the whole client state of one stop — armed by the click's confirm, and
+  // ended either by a render for that session no longer listing the task id, or STOP_PENDING_MS later.
+  const STOP_PENDING_MS = 30_000;
+  const pendingStops = new Map();
+  let nowMs = () => Date.now();
+
+  // Test seam (no timer is ever armed here): the pending window and every label age read this clock.
+  function setClock(fn) {
+    nowMs = typeof fn === 'function' ? fn : () => Date.now();
+  }
+
+  function pendingKey(sessionId, taskId) {
+    return sessionId + '\u0000' + String(taskId);
+  }
+
+  function readPending(key) {
+    const entry = pendingStops.get(key);
+    if (!entry) return null;
+    if (nowMs() - entry.at >= STOP_PENDING_MS) {
+      pendingStops.delete(key);
+      return null;
+    }
+    return entry;
+  }
+
+  // A render for one session drops every pending stop whose task that render no longer lists.
+  function prunePending(sessionId, tasks) {
+    const prefix = sessionId + '\u0000';
+    const listed = new Set(tasks.map((t) => String(t && t.id)));
+    for (const key of Array.from(pendingStops.keys())) {
+      if (key.startsWith(prefix) && !listed.has(key.slice(prefix.length))) pendingStops.delete(key);
+    }
+  }
+
+  function stopPath(sessionId, taskId) {
+    return '/api/sessions/' + encodeURIComponent(sessionId) + '/background/' + encodeURIComponent(taskId) + '/stop';
+  }
+
+  function stopConfirmText(task, fmt) {
+    return 'Stop background shell ' + task.id + '?\n' + fmt.cap(task.label, LABEL_MAX) + '\nrunning ' + fmt.age(task.since);
+  }
+
+  function askStop(task, fmt) {
+    const ask = typeof fmt.confirm === 'function'
+      ? fmt.confirm
+      : (GLOBAL && typeof GLOBAL.confirm === 'function' ? GLOBAL.confirm.bind(GLOBAL) : null);
+    return typeof ask === 'function' && ask(stopConfirmText(task, fmt)) === true;
+  }
+
+  // A non-2xx body is the only place an `<error code>` comes from; an unreadable body falls back to the status.
+  async function failureCode(res) {
+    let payload = null;
+    try { payload = await res.json(); } catch (err) { payload = null; }
+    const code = payload && (payload.error || payload.code);
+    if (code) return String(code);
+    return Number(res.status) >= 400 ? 'http_' + Number(res.status) : 'request_failed';
+  }
+
+  async function stopOutcome(request, path) {
+    try {
+      const res = await request(path, { method: 'POST' });
+      if (!res || res.ok === false || Number(res.status) >= 400) return { ok: false, code: res ? await failureCode(res) : 'request_failed' };
+      return { ok: true, code: '' };
+    } catch (err) {
+      const code = err && (err.payload?.error || err.payload?.code || err.code);
+      if (code) return { ok: false, code: String(code) };
+      return { ok: false, code: Number(err && err.status) >= 400 ? 'http_' + Number(err.status) : 'request_failed' };
+    }
+  }
+
+  function showStopState(status, button, entry) {
+    status.textContent = entry.code ? 'not stopped: ' + entry.code : 'stopping…';
+    button.disabled = !entry.code;
+  }
+
+  function defaultRequest(path, options) {
+    if (!GLOBAL || typeof GLOBAL.fetch !== 'function') return Promise.reject(new Error('fetch unavailable'));
+    return GLOBAL.fetch(path, options);
+  }
+
+  // One click: confirm, one POST (no body), then "stopping…" until the row leaves the next render or 30 s pass.
+  async function stopTask(status, button, sessionId, task, fmt, request, ev) {
+    if (ev && typeof ev.preventDefault === 'function') ev.preventDefault();
+    if (ev && typeof ev.stopPropagation === 'function') ev.stopPropagation();
+    if (button.disabled === true) return null;
+    if (!askStop(task, fmt)) return null;
+    const key = pendingKey(sessionId, task.id);
+    pendingStops.set(key, { code: '', at: nowMs() });
+    showStopState(status, button, pendingStops.get(key));
+    const outcome = await stopOutcome(typeof request === 'function' ? request : defaultRequest, stopPath(sessionId, task.id));
+    // A render may already have dropped the row (the task left the set): keep whatever that render wrote.
+    if (!pendingStops.has(key)) return outcome;
+    pendingStops.set(key, { code: outcome.ok ? '' : outcome.code, at: nowMs() });
+    showStopState(status, button, pendingStops.get(key));
+    return outcome;
+  }
+
+  // One declared task line: type, label, age (+ quiet). A shell line of a known session also carries the
+  // operator Stop button and its status text. Shared by the hover card and the phone sheet.
+  function taskLine(doc, task, sessionId, fmt, request) {
+    const line = doc.createElement('div');
+    line.style.cssText = 'display:flex;gap:6px;margin-top:3px;font-size:12px;line-height:1.35;';
+    const type = doc.createElement('span');
+    type.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);';
+    type.textContent = String(task.type || 'task');
+    const label = doc.createElement('span');
+    label.dataset.tooltipBackgroundLabel = '1';
+    label.style.cssText = 'flex:1;min-width:0;overflow-wrap:anywhere;color:var(--fg,#e0e0e0);';
+    label.textContent = fmt.cap(task.label, LABEL_MAX);
+    const age = doc.createElement('span');
+    age.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);font-size:11px;';
+    age.textContent = fmt.age(task.since);
+    line.append(type, label, age);
+    if (task.quiet === true) {
+      const quiet = doc.createElement('span');
+      quiet.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);';
+      quiet.textContent = 'quiet ' + fmt.age(task.activeAt); // fmt.age takes a timestamp (stream-view _tooltipAge)
+      line.appendChild(quiet);
+    }
+    if (!sessionId || String(task.type || '') !== 'shell') return line;
+    const status = doc.createElement('span');
+    status.dataset.tooltipBackgroundStatus = '1';
+    status.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);';
+    const stop = doc.createElement('button');
+    stop.type = 'button';
+    stop.dataset.tooltipBackgroundStop = '1';
+    stop.textContent = 'Stop';
+    stop.style.cssText = 'flex:0 0 auto;padding:1px 7px;border:1px solid var(--border,#3a4159);border-radius:6px;background:transparent;color:var(--fg,#e0e0e0);font-size:11px;line-height:1.2;cursor:pointer;';
+    stop.addEventListener('click', (ev) => stopTask(status, stop, sessionId, task, fmt, request, ev));
+    line.append(stop, status);
+    const entry = readPending(pendingKey(sessionId, task.id));
+    if (entry) showStopState(status, stop, entry);
+    return line;
+  }
+
+  // Hover-card body: one row per task (type, label, age) and — with fmt.sessionId — a Stop control on shell
+  // rows. fmt.cap(text, n) and fmt.age(ms) are the card's own formatters. Returns null when nothing is listed.
   function tooltipBody(doc, work, fmt) {
     const tasks = tasksOf(work);
+    const sessionId = typeof fmt?.sessionId === 'string' ? fmt.sessionId : '';
+    if (sessionId) prunePending(sessionId, tasks);
     if (!tasks.length) return null;
     const body = doc.createElement('div');
-    for (const task of tasks) {
-      const line = doc.createElement('div');
-      line.style.cssText = 'display:flex;gap:6px;margin-top:3px;font-size:12px;line-height:1.35;';
-      const type = doc.createElement('span');
-      type.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);';
-      type.textContent = String(task.type || 'task');
-      const label = doc.createElement('span');
-      label.dataset.tooltipBackgroundLabel = '1';
-      label.style.cssText = 'flex:1;min-width:0;overflow-wrap:anywhere;color:var(--fg,#e0e0e0);';
-      label.textContent = fmt.cap(task.label, LABEL_MAX);
-      const age = doc.createElement('span');
-      age.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);font-size:11px;';
-      age.textContent = fmt.age(task.since);
-      line.append(type, label, age);
-      if (task.quiet === true) {
-        const quiet = doc.createElement('span');
-        quiet.style.cssText = 'flex:0 0 auto;color:var(--fg-dim,#727aa1);';
-        quiet.textContent = 'quiet ' + fmt.age(task.activeAt); // fmt.age takes a timestamp (stream-view _tooltipAge)
-        line.appendChild(quiet);
-      }
-      body.appendChild(line);
-    }
+    for (const task of tasks) body.appendChild(taskLine(doc, task, sessionId, fmt, fmt.request));
     return body;
   }
 
@@ -94,6 +213,52 @@
     }
   }
 
+  // Phone: the bottom sheet listing the declared tasks of the card the detail view shows, with the same
+  // per-task line + Stop control as the hover card. Every write is textContent and every request goes
+  // through the injected `request` (the phone's own private api()), never global fetch.
+  function openStopSheet(doc, card, tasks, opts) {
+    const sessionId = String((card && (card.id || card.sessionId)) || '');
+    const fmt = { cap: clip, age: (since) => ageText(since, nowMs()), confirm: opts.confirm, request: opts.request, sessionId };
+    const old = typeof doc.querySelector === 'function' ? doc.querySelector('[data-background-stop-sheet]') : null;
+    if (old && typeof old.remove === 'function') old.remove();
+    const overlay = doc.createElement('div');
+    overlay.dataset.backgroundStopSheet = '1';
+    overlay.style.cssText = 'position:fixed;inset:0;z-index:60;display:flex;align-items:flex-end;background:rgba(0,0,0,0.55);';
+    const panel = doc.createElement('div');
+    panel.style.cssText = 'flex:1;max-height:70vh;overflow:auto;background:var(--bg,#161a24);color:var(--fg,#e0e0e0);padding:12px 14px calc(14px + env(safe-area-inset-bottom));border-radius:14px 14px 0 0;';
+    const title = doc.createElement('div');
+    title.style.cssText = 'font-size:12px;font-weight:600;color:var(--fg-dim,#727aa1);margin-bottom:6px;';
+    title.textContent = 'Background work';
+    panel.appendChild(title);
+    for (const task of tasks) panel.appendChild(taskLine(doc, task, sessionId, fmt, opts.request));
+    const close = doc.createElement('button');
+    close.type = 'button';
+    close.textContent = 'Close';
+    close.style.cssText = 'display:block;width:100%;margin-top:12px;padding:9px;border:1px solid var(--border,#3a4159);border-radius:10px;background:transparent;color:var(--fg,#e0e0e0);font-size:13px;';
+    close.addEventListener('click', () => { if (typeof overlay.remove === 'function') overlay.remove(); });
+    panel.appendChild(close);
+    overlay.appendChild(panel);
+    (doc.body || doc.documentElement).appendChild(overlay);
+    return overlay;
+  }
+
+  // One delegated tap on #detail-status: only a card whose declared work holds a shell task opens the
+  // sheet; any other tap does nothing.
+  function installPhoneStop(opts = {}) {
+    const doc = opts.document || (GLOBAL && GLOBAL.document) || null;
+    if (!doc || typeof doc.addEventListener !== 'function') return null;
+    const handler = (ev) => {
+      const target = ev && ev.target;
+      if (!target || typeof target.closest !== 'function' || !target.closest('#detail-status')) return null;
+      const card = typeof opts.currentCard === 'function' ? opts.currentCard() : null;
+      const tasks = tasksOf(card && card.backgroundWork);
+      if (!tasks.some((t) => t && t.type === 'shell')) return null;
+      return openStopSheet(doc, card, tasks, opts);
+    };
+    doc.addEventListener('click', handler);
+    return handler;
+  }
+
   // Phone: the verdict chip text for a Running card declared by background work (else the verdict's own label).
   function chipText(card, rendered) {
     const reason = String((card && (card.bgReason || card.statusReason)) || '');
@@ -105,5 +270,9 @@
     return details.backgroundWork === undefined ? {} : { backgroundWork: details.backgroundWork || null, bgReason: String(details.statusReason || '') };
   }
 
-  return { pillText, titleLines, tooltipBody, syncTooltip, chipText, cardPatch, LABEL_MAX };
+  return {
+    pillText, titleLines, tooltipBody, syncTooltip, chipText, cardPatch, LABEL_MAX,
+    // §6.4 operator stop (client half).
+    taskLine, stopPath, installPhoneStop, setClock, STOP_PENDING_MS,
+  };
 });

package/template/coding-task-manager/public/js/coding-session-model-presentation.js

@@ -322,16 +322,24 @@
   // OWN properties win over the desktop `meta.*` representation, resolved PER FIELD, so an omitted
   // event/health can never borrow a conflicting value from another representation.
   const OWNER_CORE_KEYS = ['ctmSessionId', 'agentType', 'providerSessionId', 'processGeneration'];
-  const OWNER_AGENT_TYPES = ['claude', 'codex', 'gemini', 'opencode'];
+  const OWNER_AGENT_TYPES = ['claude', 'codex', 'gemini', 'opencode', 'dsh'];
   const AUTHORITY_KEYS = ['model_owner', 'model_observation_health', 'model_switch_event'];
   const HEALTH_STATUSES = ['current', 'restored', 'partial', 'unavailable'];
   const HEALTH_REASONS = ['restored', 'owner_unavailable', 'scan_partial', 'no_model_evidence',
-    'provider_read_failed', 'model_store_unavailable', 'invalid_observation', 'queue_full'];
+    'provider_read_failed', 'model_store_unavailable', 'invalid_observation', 'queue_full',
+    // WP-3 (§8 WP-3, §9 S-12b): a live, never-prompted OpenCode tab. The reason must be in this
+    // closed vocabulary or `normalizeHealth` rejects the receipt as an invalid observation.
+    'opencode_presession',
+    // WP-8 step 4 (§9b M-14): the same state for a DeepSeek Harness tab — the ACP child is up (or the
+    // create is still binding) but no completed turn has confirmed a model yet.
+    'dsh_presession'];
   const HEALTH_REASON_WORDS = {
     restored: 'restored from a stored snapshot', owner_unavailable: 'owner unavailable',
     scan_partial: 'scan partial', no_model_evidence: 'no model evidence',
     provider_read_failed: 'provider read failed', model_store_unavailable: 'model store unavailable',
     invalid_observation: 'invalid observation', queue_full: 'collector queue full',
+    opencode_presession: 'waiting for the first prompt',
+    dsh_presession: 'DeepSeek Harness is starting',
   };
   // The phase-appropriate owner of a pending model transition. queued/preparing and their
   // source-side preparation equivalents still run on the SOURCE owner; relaunching/awaiting_turn and
@@ -504,12 +512,21 @@
     // tuple on a save -> load round trip (the bounded writer would have nothing to store, and
     // re-normalizing the stored claim would then read as a mismatch). `owner` is the resolver's own
     // validated tuple (`ownerTuple` copies), never the caller's object.
+    //
+    // WP-3 (§8 WP-3, §9 S-12b): `opencode_presession` is the producer saying "there is no owner yet,
+    // because OpenCode has not been prompted". It is kept ONLY when neither side names an owner; every
+    // other ownerless or mismatched annotation still degrades to `owner_unavailable`, so no claim can be
+    // borrowed from another owner.
+    const ownerless = !owner && !(declaredHealth && declaredHealth.owner)
+      && declaredHealth && (declaredHealth.reason === 'opencode_presession' || declaredHealth.reason === 'dsh_presession');
     const health = declaredHealth && diagnostic
       ? { status: declaredHealth.status, reason: declaredHealth.reason, owner: owner || null, lastSuccessRevision: declaredHealth.lastSuccessRevision }
       : declaredHealth
         ? (owner && declaredHealth.owner && sameOwner(declaredHealth.owner, owner)
           ? { status: declaredHealth.status, reason: declaredHealth.reason, owner, lastSuccessRevision: declaredHealth.lastSuccessRevision }
-          : { status: 'unavailable', reason: 'owner_unavailable', lastSuccessRevision: null })
+          : (ownerless
+            ? { status: 'unavailable', reason: declaredHealth.reason, lastSuccessRevision: null }
+            : { status: 'unavailable', reason: 'owner_unavailable', lastSuccessRevision: null }))
         : (owner ? missingHealth(owner) : null);
     return {
       owner,
@@ -652,6 +669,10 @@
     lead_default_unsupported: 'Claude Code’s default is its own setting.',
     lead_switch_in_flight: 'This session is already restarting for a model switch. Wait for it to finish.',
     lead_switch_relaunched: 'The session already restarted; it confirms on the next turn.',
+    // Carried over from the Codex lead-switch work: the two settled-phase refusals that otherwise
+    // render as a bare "HTTP 409".
+    lead_switch_recovery_in_flight: 'An earlier switch on this session is still being recovered. Wait for it to settle, then pick again.',
+    lead_transition_committing: 'A switch on this session is committing right now. Wait for it to settle, then pick again.',
     invalid_model_id: 'That model id is not valid.',
     invalid_scope: 'That scope is not valid.',
     session_not_found: 'This session is no longer open.',
@@ -661,11 +682,26 @@
     walle: 'Wall-E tabs pick their model in the Wall-E picker.',
     agent_unknown: 'CTM cannot switch this agent’s model.',
     no_resume_id: 'This session has not been restored yet, so its model cannot change. Open it first.',
-    source_launch_environment_unavailable: 'CTM cannot recover this session’s original launch environment (it was restored after a restart), so its model and effort are frozen. Close and reopen the session to switch.',
+  };
+  // D-6/§9 S-19: an unavailable launch environment names WHY (the server's `cause`, from
+  // LAUNCH_ENV_REASONS or 'no_capture'), so the sentence is per cause. An unknown or absent cause
+  // falls through to the server's own message and then the generic line — never a restart story
+  // (after D-3 a restart is never the cause).
+  const LAUNCH_ENV_CAUSE_SENTENCES = {
+    legacy_worker_private_env: 'Worker sessions keep their launch environment private; a worker’s model can’t be switched here.',
+    legacy_no_receipt: 'This session was launched by an older CTM without a launch receipt. Close and reopen it to switch.',
+    credential_keys: 'This session’s launch environment holds a credential CTM won’t carry across a host handoff. Close and reopen it to switch.',
+    too_many_entries: 'This session was launched with an environment CTM can’t carry. Close and reopen it to switch.',
+    too_many_bytes: 'This session was launched with an environment CTM can’t carry. Close and reopen it to switch.',
+    bad_key: 'This session was launched with an environment CTM can’t carry. Close and reopen it to switch.',
+    bad_value: 'This session was launched with an environment CTM can’t carry. Close and reopen it to switch.',
+    not_object: 'This session was launched with an environment CTM can’t carry. Close and reopen it to switch.',
+    no_capture: 'This session was attached outside CTM’s launcher, so its launch environment was never captured.',
   };
   function leadErrorMessage(status, body) {
     const b = body || {};
     if (b.code === MODEL_ACTION_SNAPSHOT_STALE_CODE) return MODEL_ACTION_SNAPSHOT_STALE_GUIDANCE;
+    if (b.code === 'lead_switch_unsupported' && b.reason === 'source_launch_environment_unavailable') return LAUNCH_ENV_CAUSE_SENTENCES[b.cause] || b.message || 'This session cannot switch its lead model.';
     if (b.code === 'lead_switch_unsupported') return UNSUPPORTED_SENTENCES[b.reason] || b.message || 'This session cannot switch its lead model.';
     // U-8: the routed refusals carry server facts (a reason / a message), so they are built here.
     if (b.code === 'lead_route_invalid') return 'That gateway route can’t run this model as your lead right now'
@@ -730,7 +766,18 @@
     const owner = modelAuthority(authority);
     if (!owner) return presentLegacyLeadModel(state, request, fallbackModelId);
     state = state && typeof state === 'object' && !Array.isArray(state) ? state : {};
-    return presentTypedLeadModel(state, request || null, owner);
+    const typed = presentTypedLeadModel(state, request || null, owner);
+    // WP-3: a never-prompted OpenCode tab has no owner yet, but CTM launched it with an explicit
+    // `--model` (the session's own model id). That launch model is SELECTED, not confirmed: it is
+    // verified by the first prompt's opencode:message observation, exactly like a pending switch.
+    // WP-8 step 4 (§9b M-14): a dsh tab is the same shape — the ACP child was created on a routed model
+    // (the session's own model id) and the first completed turn's `dsh:config-option` binds the owner.
+    if (typed.state === 'unknown' && !owner.owner && owner.health
+      && (owner.health.reason === 'opencode_presession' || owner.health.reason === 'dsh_presession')) {
+      const launchModel = isReservedModelAlias(fallbackModelId) ? null : optionalString(fallbackModelId);
+      if (launchModel) return { ...typed, modelId: launchModel, state: 'selected-awaiting-turn', selectedValue: launchModel, source: 'ctm:launch' };
+    }
+    return typed;
   }
 
   function nativeModelChipDecoration(presentation, modelState, currentModelId, hasCtmRequest, authority = null) {
@@ -769,6 +816,19 @@
     };
   }
 
+  // WP-3 (§8): an OpenCode lead runs the FIXED gateway ref `ctm-lead/lead` (the route rides env +
+  // configPatch, R-1), so its OBSERVED model is the ref — never the route's model, which is what a
+  // routed Claude/Codex lead observes directly. A session's stored `lead_route.model` is the one source
+  // that names the route in both cases, so the chip label joins through it whenever the observed id is
+  // the gateway ref. Claude/Codex stay byte-identical: their provider/model is never `ctm-lead`.
+  function leadRouteDisplayId(session, modelId, providerId) {
+    const route = session && session.meta && session.meta.lead_route;
+    const id = String(modelId || '');
+    if (!route || !route.model) return id;
+    const isGatewayRef = String(providerId || '') === 'ctm-lead' || id === 'ctm-lead' || id.indexOf('ctm-lead/') === 0;
+    return isGatewayRef ? String(route.model) : id;
+  }
+
   function sessionModelChipView(presentation, modelState, currentModelId, hasActiveRequest, context, session) {
     presentation = presentation || {};
     // WP-0: the raw session `model_id` is a legacy fallback; the reserved delegate alias is never a
@@ -797,9 +857,10 @@
     const providerId = view
       ? (presentation.typed === true ? (view.providerId || null) : (view.providerId || legacyProviderId))
       : (presentation.providerId || legacyProviderId);
-    const label = modelId && typeof context.labelFor === 'function' ? context.labelFor(modelId) : '';
+    const labelModelId = leadRouteDisplayId(session, modelId, providerId);
+    const label = labelModelId && typeof context.labelFor === 'function' ? context.labelFor(labelModelId) : '';
     const modelText = modelId
-      ? ((typeof context.glyphFor === 'function' ? context.glyphFor(modelId, providerId) : '') + (label || modelId))
+      ? ((typeof context.glyphFor === 'function' ? context.glyphFor(labelModelId, providerId) : '') + (label || labelModelId))
       : (view && view.unknown || context.modelDetectionStale ? 'Model unavailable' : '(detecting…)');
     const tokenTitle = typeof context.tokenTitle === 'function' ? context.tokenTitle : function() { return ''; };
     const modelTitle = typeof context.modelTitle === 'function' ? context.modelTitle : function() { return ''; };
@@ -881,6 +942,46 @@
     return LAUNCH_EFFORT_RE.test(value) ? value : null;
   }
 
+  // WP-3 (codex-native-subagent-pick-enforcement-2026-10-28.html §5 D-6, §6, §9 S-8): the PASSIVE
+  // lead-row chip, shared by the desktop row and the phone card. Like `launchEffortOf` it is a pure,
+  // host-free rule defined once at module scope and returned by BOTH the factory and the module
+  // surface, so a client can render it without constructing a presenter (the desktop and the phone
+  // both load this file, neither may require() it). It is a LABEL only: no click handler, no new WS
+  // message, and it never states what a child ran.
+  //
+  // The rule reads the fact the LAUNCH recorded (`subagent_pick.native_subagents`, WP-1's v58
+  // projection) and never re-derives it from today's rule: only the exact `'disabled'` value yields a
+  // chip. `''` is a KNOWN "not denied", `null`/absent is unknown (a pre-v58 row), and a malformed
+  // value never claims a deny. Callers gate it to Codex rows; a Claude launch never carries the fact.
+  function nativeSubagentChip(subagentPick) {
+    if (!subagentPick || typeof subagentPick !== 'object' || Array.isArray(subagentPick)) return null;
+    if (subagentPick.native_subagents !== 'disabled') return null;
+    return {
+      text: 'native sub-agents off',
+      title: 'The saved delegate pick is a routed worker; this launch refuses spawn_agent. /delegate runs the pick. '
+        + 'To use native sub-agents, pick a native model and relaunch.',
+    };
+  }
+
+  // The desktop lead row's DOM half, kept here so the one-line call in index.html adds no lines to the
+  // hard-ceilinged page: a Codex row gets a sibling span after the model chip when the recorded launch
+  // fact says native sub-agents were refused, and the span is removed again once the rule yields null.
+  function syncNativeSubagentChip(chip, session, agent) {
+    if (!chip || !chip.parentElement) return null;
+    var host = chip.parentElement;
+    var node = host.querySelector('.model-chip-native-off');
+    var view = agent === 'codex' ? nativeSubagentChip(session && session.meta && session.meta.subagent_pick) : null;
+    if (!view) { if (node) node.remove(); return null; }
+    if (!node) {
+      node = document.createElement('span');
+      node.className = 'model-chip model-chip-native-off';
+      host.insertBefore(node, chip.nextSibling);
+    }
+    node.textContent = view.text;
+    node.title = view.title;
+    return node;
+  }
+
   // WP-5 (§8 AC-0/AC-2/AC-2b/AC-4/AC-5/AC-6b): every sentence about what /delegate RESOLVES and
   // what this session's native subagents were CONFIGURED with is a pure rule here, shared by the
   // desktop chip and the phone sheet (both load this file). The picker supplies its own words and
@@ -907,7 +1008,16 @@
 
     // AC-3/AC-6b: this refusal is about THIS transport and only about native subagents. It is not an
     // account or login claim, and it never promises that the saved selection already ran.
-    function subagentReasonSentence(reason) {
+    //
+    // WP-2 (§5 D-4, §6, §8 AC-2a): `launch` is the launch-time projection the caller already holds
+    // (`session.meta.subagent_pick`). When that launch RECORDED the deny (`native_subagents ===
+    // 'disabled'`) the sentence states what this process did about native sub-agents and the remedy;
+    // every other value — `''` (a known "not denied"), `null`/absent (a pre-v58 row, which must never
+    // be described as denied), or malformed — keeps today's reason-keyed sentences unchanged.
+    function subagentReasonSentence(reason, launch) {
+      if (launch && launch.native_subagents === 'disabled') {
+        return 'native sub-agents are off for this launch (spawn_agent is refused) because the saved pick is a routed worker — /delegate runs it. To use native sub-agents, pick a native model here and relaunch.';
+      }
       var code = String(reason || '');
       if (code === 'codex_lead_not_on_proxy') {
         return 'this transport can’t redirect native subagents — use /delegate for an external worker; no lead account or model change is required';
@@ -917,6 +1027,16 @@
       if (code === 'codex_inherit_unenforceable') {
         return 'Codex can’t enforce follow-lead routing for its native subagents — use /delegate for an external worker';
       }
+      // subagent-pick-unreachable-origin-2026-10-28 R-6: the route exists; THIS machine can't dial its server.
+      if (code === 'origin_unreachable') {
+        return 'the picked route’s server can’t be reached from this machine — use /delegate with a route this machine can reach';
+      }
+      // WP-4/WP-5 R-10 (docs/opencode-lead-and-delegate-model-selection-2026-10-28.html §5 R-10, §9 S-12):
+      // an OpenCode lead's routed worker is started by the Wall-E MCP server inside the session. Without
+      // it, CTM refuses the launch instead of implying the CLI's own subagents can run a routed model.
+      if (code === 'opencode_routed_requires_mcp') {
+        return 'OpenCode’s built-in subagents can’t run a routed worker model — routed workers need the Wall-E MCP server in this session';
+      }
       if (code.indexOf('route_') === 0) return 'the picked route can’t serve this agent (' + code + ')';
       return code;
     }
@@ -1012,7 +1132,9 @@
       var launchEffort = launchEffortOf(projected);
       var text;
       if (launchKind === 'unservable') {
-        text = 'Native subagents: CLI default — ' + subagentReasonSentence(projected && projected.reason);
+        // WP-2: the launch pick itself carries the recorded fact (`native_subagents`), so the sentence
+        // is keyed on what THIS process did rather than on today's rule.
+        text = 'Native subagents: CLI default — ' + subagentReasonSentence(projected && projected.reason, projected);
       } else if (launchKind === 'none') {
         // M-6: a failed Wall-E read with no mirrored row is not the same as "no pick".
         text = (projected && projected.reason === 'read_failed')
@@ -1105,6 +1227,9 @@
 
     return {
       subagentReasonSentence: subagentReasonSentence,
+      // WP-3 (§6): the passive chip rides the factory surface too, so a caller that already holds a
+      // presenter (the phone sheet, the desktop picker) reads both rules from the same object.
+      nativeSubagentChip: nativeSubagentChip,
       subagentLine: subagentLine,
       nativeEffortNote: nativeEffortNote,
       delegateEffortNote: delegateEffortNote,
@@ -1114,7 +1239,10 @@
     };
   }
 
-  return { presentLeadModel, presentLeadModelCompat, nativeModelChipDecoration, sessionModelChipView, requestTransitionPresentation, requestToastPresentation, createDelegateRoutePresentation, createDelegationPresentation, launchEffortOf,
+  return { presentLeadModel, presentLeadModelCompat, nativeModelChipDecoration, sessionModelChipView, leadRouteDisplayId, requestTransitionPresentation, requestToastPresentation, createDelegateRoutePresentation, createDelegationPresentation, launchEffortOf,
+    // WP-3: the passive native-subagents-off chip — module-level like `launchEffortOf`, so the desktop
+    // row and the phone card render it straight off the shared surface they both load.
+    nativeSubagentChip, syncNativeSubagentChip,
     // WP-2A: the Lead action's bounded error copy — pure, no private-runtime lookup.
     leadErrorMessage,
     // WP1C: the ONE owner/health/event normalizer and the shared lead status/detail lines.