create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/public/js/machine-pool-shared.js

@@ -364,10 +364,16 @@ function machineFormatPct(value) {
 }
 
 // WP-4: a reachable box whose Claude/Codex CLI is signed out says so on its card. Same labels on both
-// surfaces.
-var MACHINE_AGENT_LABELS = { claude: 'Claude', codex: 'Codex' };
+// surfaces. WP-13b adds the DeepSeek Harness label — it has no CTM sign-in (S-88), so it is listed
+// from the box's own presence verdict instead of a sign-in state.
+var MACHINE_AGENT_LABELS = { claude: 'Claude', codex: 'Codex', dsh: 'DeepSeek Harness' };
 
-function machineAgentText(agents) {
+// `presence` is the registry row's `agentPresence` ({ dsh: true|false|null }) — the box's own answer
+// to "do you have the DeepSeek Harness" (WP-13b, D-15). dsh has no sign-in state, so it is named
+// ONLY when the box explicitly said it has it (`=== true`); false and null (unknown / never read)
+// add nothing, exactly as an unknown sign-in state adds nothing above. claude/codex output is
+// byte-identical to its pre-WP-13b self whether or not `presence` is passed.
+function machineAgentText(agents, presence) {
   if (!agents || typeof agents !== 'object') return '';
   var parts = [];
   ['claude', 'codex'].forEach(function (key) {
@@ -375,6 +381,7 @@ function machineAgentText(agents) {
     if (state === 'signed_in') parts.push(MACHINE_AGENT_LABELS[key] + ' signed in');
     else if (state === 'signed_out') parts.push(MACHINE_AGENT_LABELS[key] + ' signed out');
   });
+  if (presence && presence.dsh === true) parts.push(MACHINE_AGENT_LABELS.dsh);
   return parts.join(' · ');
 }
 
@@ -396,6 +403,508 @@ function machineGpuText(gpu) {
   return parts.join(' · ');
 }
 
+// WP-1 (docs/lid-closed-pool-host-always-on-2026-10-25.html §6/§8): the Power fact — what the kernel
+// actually did. On battery the box WILL sleep when the lid closes, so say so before the count matters;
+// on AC (or an unknown source) report how many DISTINCT times it slept in the last 24 h and how long
+// ago the last one was. history is the oldest-first sample list; now is the caller's clock (never read
+// here, matching machineLoadLine). The 24 h window is half-open on the far edge (> now - 24h) and
+// inclusive of now, so a sleep exactly 24 h ago has aged out.
+function machinePowerText(sample, history, now) {
+  if (sample == null || sample.power == null) return '';
+  var power = sample.power;
+  if (power.onAC === false) return 'On battery — lid close will sleep it';
+  var prefix = power.onAC === true ? 'AC · ' : '';
+  var nowMs = Number(now);
+  var windowStart = nowMs - 24 * 60 * 60 * 1000;
+  var rows = machineHistoryRows(history).concat([sample]);
+  var seen = {};
+  var count = 0;
+  var last = null;
+  for (var i = 0; i < rows.length; i += 1) {
+    var row = rows[i];
+    var value = row && row.power ? Number(row.power.lastSleepAt) : NaN;
+    if (!Number.isFinite(value) || value <= windowStart || value > nowMs) continue;
+    var key = String(value);
+    if (seen[key]) continue;
+    seen[key] = true;
+    count += 1;
+    if (last == null || value > last) last = value;
+  }
+  if (count === 0) return prefix + 'no sleep in 24 h';
+  return prefix + 'slept ' + count + '× in 24 h (last ' + machineAgoText(last, nowMs) + ')';
+}
+
+// ── WP-3 fleet line (docs/fleet-auto-update-pooled-machines-2026-10-26.html §8) ─────────────────
+// ONE line per machine row saying what the hub's reconciler last decided about that box. `null` is
+// a real answer — say nothing — when no reconciler pass has run for this instance (`fleet` is null)
+// or when the health line already carries the state (`unreachable`): a status is never invented.
+// The desktop card ("mpc-fleet") and the phone card ("mp-fleet") render these same bytes. Short
+// shas are the first 7 characters; a missing one is the literal "unknown", never an empty string.
+var MACHINE_FLEET_UNKNOWN_SHA = 'unknown';
+
+function machineFleetSha7(value) {
+  var sha = String(value == null ? '' : value).trim();
+  return sha ? sha.slice(0, 7) : MACHINE_FLEET_UNKNOWN_SHA;
+}
+
+// `already_attempted` reads the hub's own record of the attempt it already made on this box.
+// A verdict the hub has not taught us yet is NOT a proven success: it stays muted.
+function machineFleetVerdictLine(lastVerdict, buildSha7) {
+  var verdict = String((lastVerdict && lastVerdict.verdict) || '');
+  var reason = String((lastVerdict && lastVerdict.reason) || '');
+  var suffix = reason ? ': ' + reason : '';
+  if (verdict === 'updated') return { text: 'Up to date · ' + buildSha7, tone: 'ok' };
+  if (verdict === 'rolled_back') return { text: 'Update rolled back' + suffix, tone: 'warn' };
+  if (verdict === 'manual_intervention') return { text: 'Update failed — needs a manual fix' + suffix, tone: 'warn' };
+  if (verdict === 'refused') return { text: 'Update refused' + suffix, tone: 'warn' };
+  if (verdict === 'timeout') return { text: 'Update timed out', tone: 'warn' };
+  return { text: 'Behind — waits for the next hub commit', tone: 'muted' };
+}
+
+// WP-3 (docs/fleet-origin-main-sync-skill-2026-10-31.html §5 R-1, §6.2): the `origin_sync` line.
+// The box syncs itself from origin (the hub never bundles to it), so the only facts worth showing are
+// the box's OWN: is the new build running yet, and where does its main stand against origin.
+// `n` is printed raw — ahead/behind are integers from `git rev-list --left-right --count`, and the
+// "—" keeps a null (no tracking ref yet) from reading as 0.
+function machineOriginCount(value) {
+  return (value === null || value === undefined || value === '') ? '—' : String(value);
+}
+
+// The last sync verdict plus WHEN (relative, via machineAgoText; the ISO string when the stamp is not
+// a time we can read; "never" when the box has never recorded one).
+function machineOriginLastSync(lastSync) {
+  if (!lastSync || typeof lastSync !== 'object') return 'never';
+  var verdict = String(lastSync.verdict || '') || 'unknown';
+  var at = lastSync.at;
+  var ms = Date.parse(String(at == null ? '' : at));
+  if (Number.isFinite(ms)) return verdict + ' ' + machineAgoText(ms);
+  return verdict + ' ' + (at == null || at === '' ? 'never' : String(at));
+}
+
+// `origin_sync` reads the box's own head/runningSha/originSync (the hub row carries them verbatim).
+// First match wins (AC-3d): a new build on disk is a restart, then behind / ahead / level.
+function machineOriginSyncLine(fleet) {
+  var runSha7 = machineFleetSha7(fleet.runningSha);
+  var os = fleet.originSync && typeof fleet.originSync === 'object' ? fleet.originSync : {};
+  var title = 'running ' + runSha7 + ' · origin ahead/behind '
+    + machineOriginCount(os.ahead) + '/' + machineOriginCount(os.behind)
+    + ' · last sync ' + machineOriginLastSync(os.lastSync);
+  var head = fleet.head == null ? '' : String(fleet.head);
+  var running = fleet.runningSha == null ? '' : String(fleet.runningSha);
+  var line;
+  if (head && running && head !== running) line = { text: 'New build on disk — restarts when idle', tone: 'pending' };
+  else if (Number(os.behind) > 0) line = { text: Number(os.behind) + ' behind origin — pulls within 15 min', tone: 'pending' };
+  else if (Number(os.ahead) > 0) line = { text: Number(os.ahead) + ' unpublished — land sync publishes them', tone: 'pending' };
+  else line = { text: 'In sync with origin · ' + runSha7, tone: 'ok' };
+  return { text: line.text, tone: line.tone, title: title };
+}
+
+// Rules in precedence order, first match wins (FLEET_HUB_REASONS, lib/fleet-hub.js). An unknown
+// reason falls through to null rather than guessing.
+function machineFleetLine(machine) {
+  var fleet = machine && machine.fleet;
+  if (!fleet || typeof fleet !== 'object') return null;
+  var reason = String(fleet.reason || '');
+  if (reason === 'unreachable') return null;
+  // WP-3: a self-syncing box has its own line (and its own tooltip) — the hub's `target` is not what
+  // its card should be comparing against.
+  if (reason === 'origin_sync') return machineOriginSyncLine(fleet);
+  var buildSha7 = machineFleetSha7(machine.build && machine.build.sha);
+  var targetSha7 = machineFleetSha7(fleet.target);
+  var title = 'running ' + buildSha7 + ' · hub ' + targetSha7;
+  if (fleet.lastVerdict) {
+    var lastReason = String(fleet.lastVerdict.reason || '');
+    title += ' · last: ' + String(fleet.lastVerdict.verdict || '') + (lastReason ? ' ' + lastReason : '');
+  }
+  var line;
+  if (reason === 'current') line = { text: 'Up to date · ' + buildSha7, tone: 'ok' };
+  else if (reason === 'sending' || reason === 'updating' || fleet.inFlight) line = { text: 'Updating to ' + targetSha7 + '…', tone: 'pending' };
+  else if (reason === 'restart_pending') line = { text: 'New build on disk — restarts when idle', tone: 'pending' };
+  else if (reason === 'busy') line = { text: 'Behind — waits for idle sessions', tone: 'pending' };
+  else if (reason === 'cooldown') line = { text: 'Behind — next update after the 3 h cooldown', tone: 'pending' };
+  else if (reason === 'behind' || reason === 'another_box_updating') line = { text: 'Behind — queued', tone: 'pending' };
+  else if (reason === 'already_attempted') line = machineFleetVerdictLine(fleet.lastVerdict, buildSha7);
+  else if (reason === 'not_git') line = { text: 'Not a git checkout — not auto-updated', tone: 'muted' };
+  else if (reason === 'not_main') line = { text: 'Not on main — not auto-updated', tone: 'muted' };
+  else if (reason === 'dirty') line = { text: 'Local changes — not auto-updated', tone: 'muted' };
+  else if (reason === 'diverged') line = { text: 'Has commits the hub lacks — not auto-updated', tone: 'muted' };
+  else return null;
+  return { text: line.text, tone: line.tone, title: title };
+}
+
+// ── WP-4 hub-bridge access (docs/remote-session-hub-bridge-2026-10-30.html §6.2 / R-4/R-5/R-9/R-11) ─
+// ONE copy of the Access block's DOM-free half: the effective policy (R-11), the three row texts
+// (grants / open asks / audit), the block and banner markup, and the request bodies the writes send.
+// The desktop Machines page (js/app/machines-page.js) and the phone Machines card (m/app.js) both
+// call these; each passes its own escaper and its own class names, because the two DOM trees have
+// always used different prefixes (`mpc-*` vs `mp-*`) and neither class set is styled anywhere.
+//
+// Everything here is pure: no DOM, no fetch, no clock (every caller passes `now`). The delegated
+// event wiring, the fetches and the toast copy stay in the surface that owns them.
+
+var MACHINES_PAGE_AUDIT_LIMIT = 20;
+var MACHINES_PAGE_TRUST_VALUES = ['ask', 'always', 'never'];
+var MACHINES_PAGE_TRUST_DEFAULT = 'ask';
+// R-13's timed grant — the TTL a pending ask's "For 1 hour" buttons are answered with (D-1).
+var MACHINES_PAGE_GRANT_TTL_SEC = 3600;
+var HUB_BRIDGE_DENY_LABEL = 'Deny';
+var HUB_BRIDGE_REVOKE_LABEL = 'Revoke';
+// WP-2 (docs/hub-bridge-approval-scopes-2026-11-01.html §6.3, D-1/D-3): the four answers to an ask are
+// the product of a SCOPE (this session / every session of the asking machine) and a DURATION (1 hour,
+// held in memory / always, persisted in the trust file). The machine scope travels as the `'*'` caller
+// id on the wire, in memory and on disk. No answer writes machine trust, so none changes the mesh.
+var HUB_BRIDGE_ALL_SESSIONS = '*';
+var HUB_BRIDGE_GRANT_GROUPS = [
+  { key: 'hour', label: 'For 1 hour', choices: ['session-hour', 'machine-hour'] },
+  { key: 'always', label: 'Always', choices: ['session-always', 'machine-always'] },
+];
+var HUB_BRIDGE_GRANT_CHOICES = {
+  'session-hour': { scope: 'session', always: false, label: 'This session', primary: true },
+  'machine-hour': { scope: 'machine', always: false, label: 'All sessions' },
+  'session-always': { scope: 'session', always: true, label: 'This session' },
+  'machine-always': { scope: 'machine', always: true, label: 'All sessions' },
+};
+var HUB_BRIDGE_TIER_VERBS = { read: 'read files', exec: 'run commands', browser: 'use the browser' };
+var HUB_BRIDGE_FOOT_NOTE = 'Change later on the Machines page';
+// The head's lock: an inline SVG (14 px, stroke currentColor) — no emoji, no external asset.
+var HUB_BRIDGE_LOCK_SVG = '<svg class="hbb-lock" width="14" height="14" viewBox="0 0 24 24" fill="none"'
+  + ' stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"'
+  + ' aria-hidden="true" focusable="false"><rect x="4" y="10" width="16" height="11" rx="2"></rect>'
+  + '<path d="M8 10V7a4 4 0 0 1 8 0v3"></path></svg>';
+
+// The desktop's class names. A caller overrides what it needs through `opts.classes`.
+var MACHINE_ACCESS_CLASSES = Object.freeze({
+  block: 'mpc-access',
+  head: 'mpc-access-head',
+  list: 'mpc-access-list',
+  rowPending: 'mpc-pending',
+  rowGrant: 'mpc-grant',
+  rowAudit: 'mpc-audit',
+  text: 'mpc-access-text',
+  btn: 'mpc-btn mpc-access-btn',
+  btnDanger: 'mpc-btn mpc-access-btn mpc-danger',
+  trust: 'mpc-trust',
+  trustSelect: 'mpc-trust-select',
+  trustAll: 'mpc-trust-all',
+  // The approval prompt's own structural classes (§6.5). They are `hbb-*` on BOTH surfaces — the two
+  // surfaces differ only in the stylesheet that dresses them (public/css/app.css vs public/m/app.css).
+  // NOTE: `bannerHead` (not `head`) because `head` above is the Access block's own header row.
+  grants: 'hbb-grants',
+  grantLabel: 'hbb-label',
+  grantSeg: 'hbb-seg',
+  grantBtn: 'hbb-btn',
+  grantPrimary: 'hbb-primary',
+  detail: 'hbb-detail',
+  deny: 'hbb-deny',
+  foot: 'hbb-foot',
+  note: 'hbb-note',
+  bannerHead: 'hbb-head',
+  icon: 'hbb-icon',
+  tier: 'hbb-tier',
+});
+
+// The phone's class names (public/m/app.js). Same structure, same hooks, different prefix.
+var MACHINE_ACCESS_CLASSES_PHONE = Object.freeze(Object.assign({}, MACHINE_ACCESS_CLASSES, {
+  block: 'mp-access',
+  head: 'mp-access-head',
+  list: 'mp-access-list',
+  rowPending: 'mp-access-row mp-access-pending',
+  rowGrant: 'mp-access-row mp-access-grant',
+  rowAudit: 'mp-access-row mp-access-audit',
+  text: 'mp-access-text',
+  btn: 'mp-btn',
+  btnDanger: 'mp-btn mp-danger',
+  trust: 'mp-access-trust',
+  trustSelect: '',
+  trustAll: 'mp-access-trust-all',
+}));
+
+function machineAccessClasses(overrides) {
+  if (!overrides || typeof overrides !== 'object') return MACHINE_ACCESS_CLASSES;
+  return Object.assign({}, MACHINE_ACCESS_CLASSES, overrides);
+}
+
+// The escaper a caller hands in is the surface's own (desktop mEsc / phone esc). This fallback is
+// the phone's own map, so a bare vm realm still renders escaped text rather than raw server bytes.
+function machineEscape(value) {
+  return String(value == null ? '' : value).replace(/[&<>"']/g, function (ch) {
+    return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[ch];
+  });
+}
+
+function machineAccessEsc(opts) {
+  return (opts && typeof opts.esc === 'function') ? opts.esc : machineEscape;
+}
+
+/** "45s" / "12m" / "3h" — the age/ttl unit every Access row prints. */
+function machineSpanText(totalSeconds) {
+  var secs = Math.max(0, Math.round(Number(totalSeconds) || 0));
+  if (secs < 60) return secs + 's';
+  if (secs < 3600) return Math.round(secs / 60) + 'm';
+  return Math.round(secs / 3600) + 'h';
+}
+
+/** The session short id every Access row prints (8 chars, like the tab strip). */
+function machineShortId(value) {
+  return String(value || '').slice(0, 8);
+}
+
+/** R-11: a machine's effective policy — its own row when it is one of the three values, else the default. */
+function machineEffectiveTrust(trust, instanceId) {
+  var id = String(instanceId || '');
+  if (trust && trust.machines && Object.prototype.hasOwnProperty.call(trust.machines, id)) {
+    var own = String(trust.machines[id]);
+    if (MACHINES_PAGE_TRUST_VALUES.indexOf(own) !== -1) return own;
+  }
+  var dflt = trust && String(trust.default || '');
+  return MACHINES_PAGE_TRUST_VALUES.indexOf(dflt) !== -1 ? dflt : MACHINES_PAGE_TRUST_DEFAULT;
+}
+
+function machineTrustOptionsHtml(trust, instanceId, opts) {
+  var esc = machineAccessEsc(opts);
+  var current = machineEffectiveTrust(trust, instanceId);
+  return [['ask', 'Ask'], ['always', 'Always'], ['never', 'Never']].map(function (pair) {
+    return '<option value="' + esc(pair[0]) + '"' + (pair[0] === current ? ' selected' : '') + '>' + esc(pair[1]) + '</option>';
+  }).join('');
+}
+
+// R-11's per-machine select. The id rides a data attribute (not an inline handler), so one delegated
+// listener per surface serves every render, and a repaint can never strand a handler.
+function machineTrustSelectHtml(instanceId, trust, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var cls = classes.trustSelect ? ' class="' + esc(classes.trustSelect) + '"' : '';
+  return '<label class="' + esc(classes.trust) + '">Can use this Mac:'
+    + '<select' + cls + ' data-hub-bridge-trust="' + esc(String(instanceId || '')) + '"'
+    + ' aria-label="Can use this Mac">'
+    + machineTrustOptionsHtml(trust, instanceId, opts) + '</select></label>';
+}
+
+/** R-13's page switch: 'always' on, 'ask' off. */
+function machineTrustAllHtml(trust, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var on = !!(trust && String(trust.default || '') === 'always');
+  return '<label class="' + esc(classes.trustAll) + '">'
+    + '<input type="checkbox"' + (on ? ' checked' : '') + ' data-hub-bridge-trust-all> Trust all my machines</label>';
+}
+
+/**
+ * One active grant: tier, whose session it covers, how long is left, [Revoke]. A machine-scope row is
+ * written `'*'` on the wire, so the row says "all sessions"; an `always` row has no ttl at all.
+ */
+function machineGrantRowHtml(row, now, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var r = row || {};
+  var left = Math.max(0, Math.round((Number(r.expiresAt || 0) - Number(now || 0)) / 1000));
+  var who = String(r.callerSessionId || '') === HUB_BRIDGE_ALL_SESSIONS ? 'all sessions' : machineShortId(r.callerSessionId);
+  var when = r.always === true ? 'always' : machineSpanText(left) + ' left';
+  var text = String(r.tier || '') + ' · ' + who + ' · ' + when;
+  return '<div class="' + esc(classes.rowGrant) + '" data-grant-tier="' + esc(r.tier) + '">'
+    + '<span class="' + esc(classes.text) + '">' + esc(text) + '</span>'
+    + '<button type="button" class="' + esc(classes.btn) + '" data-hub-bridge="revoke"'
+    + ' data-machine-id="' + esc(r.machineId) + '"'
+    + ' data-session-id="' + esc(r.callerSessionId) + '"'
+    + ' data-tier="' + esc(r.tier) + '">' + esc(HUB_BRIDGE_REVOKE_LABEL) + '</button>'
+    + '</div>';
+}
+
+/** The verb the sentence and every title use for a tier; an unknown tier is shown as its raw word. */
+function hubBridgeTierVerb(tier) {
+  var word = String(tier || '');
+  return HUB_BRIDGE_TIER_VERBS[word] || word;
+}
+
+/** The asking machine's name, or the same fallback the sentence uses. */
+function hubBridgeMachineName(row) {
+  return String((row || {}).machineName || '') || 'another machine';
+}
+
+/**
+ * The full answer one grant button spells out (D-7), e.g. "Allow this session to read files on this Mac
+ * for 1 hour" / "Allow every session on Box-1 to run commands on this Mac until revoked". An unknown or
+ * empty key is the narrowest grant (session + 1 hour), so a stale button can never widen a permission.
+ */
+function hubBridgeGrantTitle(row, key) {
+  var r = row || {};
+  var choice = HUB_BRIDGE_GRANT_CHOICES[key] || HUB_BRIDGE_GRANT_CHOICES['session-hour'];
+  var who = choice.scope === 'machine' ? 'every session on ' + hubBridgeMachineName(r) : 'this session';
+  var when = choice.always ? 'until revoked' : 'for 1 hour';
+  return 'Allow ' + who + ' to ' + hubBridgeTierVerb(r.tier) + ' on this Mac ' + when;
+}
+
+/**
+ * The two labelled segmented pairs (D-7, D-10): "For 1 hour" and "Always", each [This session | All
+ * sessions]. Only 1 hour · This session is filled. Each pair is a role="group" labelled by the span
+ * beside it, whose id is unique per pending row, so a page full of asks still names each pair once.
+ */
+function hubBridgeGrantChoicesHtml(row, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var r = row || {};
+  var id = String(r.id || '');
+  return '<div class="' + esc(classes.grants) + '">' + HUB_BRIDGE_GRANT_GROUPS.map(function (group) {
+    var labelId = 'hbg-' + id + '-' + group.key;
+    return '<span class="' + esc(classes.grantLabel) + '" id="' + esc(labelId) + '">' + esc(group.label) + '</span>'
+      + '<div class="' + esc(classes.grantSeg) + '" role="group" aria-labelledby="' + esc(labelId) + '">'
+      + group.choices.map(function (key) {
+        var choice = HUB_BRIDGE_GRANT_CHOICES[key];
+        var title = hubBridgeGrantTitle(r, key);
+        return '<button type="button" class="' + esc(classes.grantBtn) + (choice.primary ? ' ' + esc(classes.grantPrimary) : '') + '"'
+          + ' data-hub-bridge="allow" data-grant="' + esc(key) + '" data-pending-id="' + esc(id) + '"'
+          + ' title="' + esc(title) + '" aria-label="' + esc(title) + '">' + esc(choice.label) + '</button>';
+      }).join('')
+      + '</div>';
+  }).join('') + '</div>';
+}
+
+/** One open ask: the text line as before, the two grant groups, and Deny set apart (D-8). */
+function machinePendingRowHtml(row, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var r = row || {};
+  var id = String(r.id || '');
+  var text = String(r.tier || '') + ' · ' + String(r.op || '') + (r.summary ? ' · ' + String(r.summary) : '');
+  return '<div class="' + esc(classes.rowPending) + '" data-pending-id="' + esc(id) + '">'
+    + '<span class="' + esc(classes.text) + '">' + esc(text) + '</span>'
+    + hubBridgeGrantChoicesHtml(r, opts)
+    + '<button type="button" class="' + esc(classes.deny) + '" data-hub-bridge="deny"'
+    + ' data-pending-id="' + esc(id) + '">' + esc(HUB_BRIDGE_DENY_LABEL) + '</button>'
+    + '</div>';
+}
+
+/** One audit line: op, session short id, ok/code, age. */
+function machineAuditRowHtml(row, now, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var r = row || {};
+  var age = machineSpanText((Number(now || 0) - (Number(r.at) || 0)) / 1000);
+  var verdict = r.ok === true ? 'ok' : ('fail' + (r.code ? ' ' + String(r.code) : ''));
+  var text = String(r.op || '') + ' · ' + machineShortId(r.callerSessionId) + ' · ' + verdict + ' · ' + age + ' ago';
+  return '<div class="' + esc(classes.rowAudit) + '" data-audit-ok="' + (r.ok === true ? 'true' : 'false') + '">'
+    + '<span class="' + esc(classes.text) + '">' + esc(text) + '</span>'
+    + '</div>';
+}
+
+/**
+ * R-13's Access block. `data` is already-fetched: { trust, grants, pending, audit, now }, all of it
+ * filtered to this machine by the caller (or by machineAccessRowsFor below).
+ */
+function machineAccessBlockHtml(machineId, data, opts) {
+  var id = String(machineId || '');
+  if (!id) return '';
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var input = data || {};
+  var now = Number(input.now || 0);
+  var pending = (Array.isArray(input.pending) ? input.pending : []).map(function (row) { return machinePendingRowHtml(row, opts); }).join('');
+  var grants = (Array.isArray(input.grants) ? input.grants : []).map(function (row) { return machineGrantRowHtml(row, now, opts); }).join('');
+  var audit = (Array.isArray(input.audit) ? input.audit : []).slice(0, MACHINES_PAGE_AUDIT_LIMIT)
+    .map(function (row) { return machineAuditRowHtml(row, now, opts); }).join('');
+  return '<div class="' + esc(classes.block) + '" data-machine-id="' + esc(id) + '">'
+    + '<div class="' + esc(classes.head) + '">' + machineTrustSelectHtml(id, input.trust, opts) + '</div>'
+    + (pending ? '<div class="' + esc(classes.list) + '">' + pending + '</div>' : '')
+    + (grants ? '<div class="' + esc(classes.list) + '">' + grants + '</div>' : '')
+    + (audit ? '<div class="' + esc(classes.list) + '">' + audit + '</div>' : '')
+    + '</div>';
+}
+
+/** The rows of one machine out of the hub's whole table (one host's rows, never another's). */
+function machineAccessRowsFor(rows, machineId) {
+  var id = String(machineId || '');
+  return (Array.isArray(rows) ? rows : []).filter(function (row) {
+    return row && String(row.machineId || '') === id;
+  });
+}
+
+// ── AC-2g / D-6: the approval banner ─────────────────────────────────────────────────────────────
+/**
+ * "This session on <machineName> wants to <verb> on this Mac" — the ONE banner sentence (D-6). The
+ * summary is NOT part of it: the prompt shows it on its own monospace detail line, so the sentence
+ * stays readable and nothing has to fit inside parentheses.
+ */
+function hubBridgeBannerText(row) {
+  var r = row || {};
+  return 'This session on ' + hubBridgeMachineName(r) + ' wants to ' + hubBridgeTierVerb(r.tier) + ' on this Mac';
+}
+
+function hubBridgeBannerHtml(row, opts) {
+  var esc = machineAccessEsc(opts);
+  var classes = machineAccessClasses(opts && opts.classes);
+  var r = row || {};
+  var id = String(r.id || '');
+  var summary = String(r.summary || '');
+  return '<div class="' + esc(classes.bannerHead) + '">'
+    + '<span class="' + esc(classes.icon) + '">' + HUB_BRIDGE_LOCK_SVG + '</span>'
+    + '<span class="hub-bridge-banner-text">This session on <b>' + esc(hubBridgeMachineName(r)) + '</b>'
+    + ' wants to <b>' + esc(hubBridgeTierVerb(r.tier)) + '</b> on this Mac</span>'
+    + '<span class="' + esc(classes.tier) + '">' + esc(String(r.tier || '')) + '</span>'
+    + '</div>'
+    + (summary ? '<code class="' + esc(classes.detail) + '">' + esc(summary) + '</code>' : '')
+    + hubBridgeGrantChoicesHtml(r, opts)
+    + '<div class="' + esc(classes.foot) + '">'
+    + '<span class="' + esc(classes.note) + '">' + esc(HUB_BRIDGE_FOOT_NOTE) + '</span>'
+    + '<button type="button" class="' + esc(classes.deny) + '" data-hub-bridge="deny"'
+    + ' data-pending-id="' + esc(id) + '">' + esc(HUB_BRIDGE_DENY_LABEL) + '</button>'
+    + '</div>';
+}
+
+// ── the request bodies (§6.2) ────────────────────────────────────────────────────────────────────
+function hubBridgeTrustBody(instanceId, value) {
+  var body = { machines: {} };
+  body.machines[String(instanceId || '')] = String(value || '');
+  return body;
+}
+
+function hubBridgeTrustAllBody(on) {
+  return { default: on ? 'always' : 'ask' };
+}
+
+/**
+ * The ask's OWN machine/session/tier is what is granted — never the card's id — and the answer key says
+ * which scope and duration (D-1). A machine-scope answer carries `'*'` as the caller session; an
+ * `always` answer carries `always: true` and no ttl; the 1 h answers carry the clamped ttl. An unknown
+ * or missing key is the narrowest grant, so a stale button can never widen a permission.
+ */
+function hubBridgeGrantBody(row, fallbackMachineId, key) {
+  var r = row || {};
+  var choice = HUB_BRIDGE_GRANT_CHOICES[key] || HUB_BRIDGE_GRANT_CHOICES['session-hour'];
+  var body = {
+    machineId: String(r.machineId || fallbackMachineId || ''),
+    callerSessionId: choice.scope === 'machine' ? HUB_BRIDGE_ALL_SESSIONS : String(r.callerSessionId || ''),
+    tier: String(r.tier || ''),
+  };
+  if (choice.always) body.always = true;
+  else body.ttlSec = MACHINES_PAGE_GRANT_TTL_SEC;
+  return body;
+}
+
+/**
+ * The ONE call that answers an ask, as [path, init]. Every one of the four answers POSTs a grant of the
+ * ask's own tier — none writes trust, so none changes the box's policy or its mesh membership (D-2).
+ */
+function hubBridgeAnswerCall(row, fallbackMachineId, key) {
+  return ['/api/hub-bridge/grants', { method: 'POST', body: hubBridgeGrantBody(row, fallbackMachineId, key) }];
+}
+
+function hubBridgeRevokeBody(instanceId, callerSessionId, tier) {
+  return {
+    machineId: String(instanceId || ''),
+    callerSessionId: String(callerSessionId || ''),
+    tier: String(tier || ''),
+  };
+}
+
+function hubBridgeDenyPath(pendingId) {
+  return '/api/hub-bridge/pending/' + encodeURIComponent(String(pendingId || '')) + '/deny';
+}
+
+// The keys one surface binds for the delegated listeners above: the trust select and the page switch
+// are `change`, the three actions are `click`.
+var HUB_BRIDGE_TRUST_HOOK = '[data-hub-bridge-trust], [data-hub-bridge-trust-all]';
+var HUB_BRIDGE_ACTION_HOOK = '[data-hub-bridge]';
+
 if (typeof module === 'object' && module.exports) {
   module.exports = {
     MACHINE_STATS_STALE_MS: MACHINE_STATS_STALE_MS,
@@ -432,5 +941,51 @@ if (typeof module === 'object' && module.exports) {
     machineAgentText: machineAgentText,
     machineTaskLine: machineTaskLine,
     machineGpuText: machineGpuText,
+    machinePowerText: machinePowerText,
+    MACHINE_FLEET_UNKNOWN_SHA: MACHINE_FLEET_UNKNOWN_SHA,
+    machineFleetSha7: machineFleetSha7,
+    machineFleetVerdictLine: machineFleetVerdictLine,
+    machineFleetLine: machineFleetLine,
+    // WP-4 hub-bridge access (R-4/R-5/R-9/R-11/R-13, AC-2g)
+    MACHINES_PAGE_AUDIT_LIMIT: MACHINES_PAGE_AUDIT_LIMIT,
+    MACHINES_PAGE_TRUST_VALUES: MACHINES_PAGE_TRUST_VALUES,
+    MACHINES_PAGE_TRUST_DEFAULT: MACHINES_PAGE_TRUST_DEFAULT,
+    MACHINES_PAGE_GRANT_TTL_SEC: MACHINES_PAGE_GRANT_TTL_SEC,
+    HUB_BRIDGE_ALL_SESSIONS: HUB_BRIDGE_ALL_SESSIONS,
+    HUB_BRIDGE_GRANT_GROUPS: HUB_BRIDGE_GRANT_GROUPS,
+    HUB_BRIDGE_GRANT_CHOICES: HUB_BRIDGE_GRANT_CHOICES,
+    HUB_BRIDGE_TIER_VERBS: HUB_BRIDGE_TIER_VERBS,
+    HUB_BRIDGE_FOOT_NOTE: HUB_BRIDGE_FOOT_NOTE,
+    HUB_BRIDGE_DENY_LABEL: HUB_BRIDGE_DENY_LABEL,
+    HUB_BRIDGE_REVOKE_LABEL: HUB_BRIDGE_REVOKE_LABEL,
+    MACHINE_ACCESS_CLASSES: MACHINE_ACCESS_CLASSES,
+    MACHINE_ACCESS_CLASSES_PHONE: MACHINE_ACCESS_CLASSES_PHONE,
+    HUB_BRIDGE_TRUST_HOOK: HUB_BRIDGE_TRUST_HOOK,
+    HUB_BRIDGE_ACTION_HOOK: HUB_BRIDGE_ACTION_HOOK,
+    machineAccessClasses: machineAccessClasses,
+    machineEscape: machineEscape,
+    machineSpanText: machineSpanText,
+    machineShortId: machineShortId,
+    machineEffectiveTrust: machineEffectiveTrust,
+    machineTrustOptionsHtml: machineTrustOptionsHtml,
+    machineTrustSelectHtml: machineTrustSelectHtml,
+    machineTrustAllHtml: machineTrustAllHtml,
+    machineGrantRowHtml: machineGrantRowHtml,
+    machinePendingRowHtml: machinePendingRowHtml,
+    machineAuditRowHtml: machineAuditRowHtml,
+    machineAccessBlockHtml: machineAccessBlockHtml,
+    machineAccessRowsFor: machineAccessRowsFor,
+    hubBridgeBannerText: hubBridgeBannerText,
+    hubBridgeTierVerb: hubBridgeTierVerb,
+    hubBridgeMachineName: hubBridgeMachineName,
+    hubBridgeGrantTitle: hubBridgeGrantTitle,
+    hubBridgeGrantChoicesHtml: hubBridgeGrantChoicesHtml,
+    hubBridgeBannerHtml: hubBridgeBannerHtml,
+    hubBridgeTrustBody: hubBridgeTrustBody,
+    hubBridgeTrustAllBody: hubBridgeTrustAllBody,
+    hubBridgeGrantBody: hubBridgeGrantBody,
+    hubBridgeAnswerCall: hubBridgeAnswerCall,
+    hubBridgeRevokeBody: hubBridgeRevokeBody,
+    hubBridgeDenyPath: hubBridgeDenyPath,
   };
 }

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;