@bongos/core 1.24.95 → 1.24.96

package/modules/autonomy/db.js

@@ -429,6 +429,53 @@ async function removeRunner({ builderId, host }) {
   return r ? { host: r.host, session_id: r.session_id ? String(r.session_id) : null } : null;
 }
 
+// ── one goal, seen from the builder's runner (task 1005243) ──────────────────
+//
+// readRunnerGoalStats — what the game's runner card says about ONE goal: how
+// many tasks there the builder's runner has shipped, the tokens those sessions
+// spent, their average length, and how many tasks are still to build. All of it
+// is the ledger's answer: a runner's claim carries `autonomous` (set by the
+// server from the claiming session, core_295), a shipped claim is outcome
+// 'shipped', and a session's tokens and length are what ship.js uploaded to
+// session_records. SCOPED TO ONE BUILDER, like the heartbeat read: nobody reads
+// another builder's runner.
+//
+// ITS COST. `mine` starts from the caller's claims through core_263's
+// idx_claims_builder_history (builder_id, claimed_at), so it reads one builder's
+// claims, never the table; session_records goes through idx_session_records_builder,
+// and the tasks count through the goal's own rows. The card asks only while it is
+// open (home-runner.js, every 15 s while the tab is visible).
+async function readRunnerGoalStats(builderId, goalId) {
+  const { rows } = await pool.query(
+    `WITH mine AS (
+       SELECT DISTINCT c.task_id
+         FROM claims c JOIN tasks t ON t.id = c.task_id
+        WHERE c.builder_id = $1 AND c.autonomous AND c.outcome = 'shipped' AND t.goal_id = $2
+     ), spent AS (
+       SELECT COALESCE(SUM(sr.total_tokens), 0)::bigint AS tokens,
+              AVG(sr.duration_seconds) FILTER (WHERE sr.duration_seconds > 0) AS avg_s
+         FROM session_records sr
+        WHERE sr.builder_id = $1 AND sr.task_ids && ARRAY(SELECT task_id FROM mine)
+     )
+     SELECT (SELECT COUNT(*) FROM mine)::int AS tasks_done,
+            spent.tokens, spent.avg_s,
+            -- what is left is told only for a goal the project opened to runners, so
+            -- the read is no window onto a goal's size the caller could not send to
+            CASE WHEN EXISTS (SELECT 1 FROM autonomy_allowed_goals WHERE goal_id = $2)
+                 THEN (SELECT COUNT(*) FROM tasks WHERE goal_id = $2 AND status IN ('ready', 'active'))::int END AS tasks_left
+       FROM spent`,
+    [builderId, goalId]
+  );
+  const r = rows[0] || {};
+  const avg = r.avg_s == null ? null : Math.round(Number(r.avg_s));
+  return {
+    tasks_done: Number(r.tasks_done) || 0,
+    tokens: Number(r.tokens) || 0,
+    avg_task_seconds: Number.isFinite(avg) && avg > 0 ? avg : null,
+    tasks_left: r.tasks_left == null ? null : Number(r.tasks_left) || 0,
+  };
+}
+
 module.exports = {
   recordAutonomyRun,
   lastAutonomyHead,
@@ -449,4 +496,5 @@ module.exports = {
   setBuilderGoals,
   setBuilderPause,
   readAllRunnerScopes,
+  readRunnerGoalStats,
 };

package/modules/autonomy/routes/autonomy.js

@@ -376,6 +376,21 @@ module.exports = function buildAutonomyRouter() {
     }
   });
 
+  // ONE GOAL, SEEN FROM THE CALLER'S RUNNER (task 1005243): the game's runner
+  // card on Home — tasks it shipped there, the tokens they took, the average
+  // task length and what is left, so the card can say roughly how long the rest
+  // takes. Read-only and the caller's own, behind `autonomy.run` like the picks.
+  router.get('/autonomy/me/goals/:goalId/stats', auth.requireBuilder, auth.requirePermission('autonomy.run'), async (req, res) => {
+    const goalId = Number(req.params.goalId);
+    if (!Number.isSafeInteger(goalId) || goalId <= 0) return res.fail('goal_id_invalid', { status: 400, message: 'goal id must be a positive integer' });
+    try {
+      res.json({ goal_id: goalId, ...(await db.readRunnerGoalStats(req.builder.id, goalId)) });
+    } catch (err) {
+      log.error('[gds] GET /autonomy/me/goals/:goalId/stats', err);
+      res.fail('runner_stats_unreadable', { status: 503, message: 'could not read the runner stats' });
+    }
+  });
+
   // The owner pauses or resumes ONE builder's runner without throwing the master
   // switch. Same atom as the kill switch: stopping a machine is the same act
   // whether it is everyone's or one person's, and the paused builder must not be

package/modules/government/catalog.js

@@ -128,7 +128,7 @@ const PERMISSIONS = [
   // "runner operators" should be able to compose one. It can never widen the fence
   // — the project allowlist and the kill switch stay behind autonomy.fence.manage —
   // so delegating it delegates only "whose machine may work the allowed goals".
-  { key: 'autonomy.run', system: false, floor: 'metic', guards: 'PUT /autonomy/me/goals (a builder\'s own runner scope); also decides whether GET /autonomy/fence answers enabled for the caller' },
+  { key: 'autonomy.run', system: false, floor: 'metic', guards: 'PUT /autonomy/me/goals (a builder\'s own runner scope) and GET /autonomy/me/goals/:goalId/stats (its numbers on one goal); also decides whether GET /autonomy/fence answers enabled for the caller' },
   // BV1.R21 (task 1003608, goal 1000086). ADR 0250 §6 amends ADR 0157 for exactly
   // this key: `version.create` returns to the Archon floor.
   //

package/modules/hall-ui/public/home-city-draw.js

@@ -297,6 +297,8 @@
       const a = it.a, x0 = a.x, y0 = a.y, x1 = x0 + FOOT, y1 = y0 + FOOT, base = 4;
       const d = doneAt(a, t), built = Math.max(2, (d.build + d.art) * m.px), clad = d.art * m.px;
       const site = sites[a.id], who = site ? m.people[site.builder] : null, agent = !!(site && (site.agent || (who && who.agent)));
+      // your runner sent here (task 1005243): its marker stands in for the agent's face
+      const mine = latest && o.runner && o.runner.goal === a.id ? o.runner.state : null;
       const wait = latest ? (m.waiting[a.id] || 0) : 0;
       const g = [];
       g.push(...box(x0 - 0.12, y0 - 0.12, x1 + 0.12, y1 + 0.12, 0, base, I.plinth));
@@ -330,12 +332,13 @@
         const hx = mx + 1.8;
         g.push(line(P(hx, my, ct), P(hx, my, top - 6), I.steel, 1));
         g.push(node('g', { class: 'hc-slab' }, box(hx - 0.3, my - 0.2, hx + 0.3, my + 0.2, top - 38, 3, I.slab)));
-        if (who) over.push({ k: 'face', p: P(mx + 0.9, my, ct + 30), who, agent, a });
+        if (who && !mine) over.push({ k: 'face', p: P(mx + 0.9, my, ct + 30), who, agent, a });
       }
+      if (mine) over.push({ k: 'runner', p: site ? P(x0 + 1.4, y0 + 0.5, top + 86) : P((x0 + x1) / 2, (y0 + y1) / 2, top + 40), state: mine, a });
       if (wait) over.push({ k: 'dot', p: P((x0 + x1) / 2, (y0 + y1) / 2, top + (site ? 12 : 22)), a, n: wait });
       const shipped = Math.round(d.build + d.art), byArt = Math.round(d.art);
       const tip = `${shipped} shipped${byArt ? ` · ${byArt} by artists` : ''}${who ? ` · ${agent ? `${who.name}'s agent` : who.name} on site` : ''} · click to open the goal`;
-      out.push(node('a', { href: `/goals#/goal/${encodeURIComponent(a.id)}`, class: 'hc-tower', 'aria-label': `${a.title}: ${shipped} shipped. Open the goal.`, 'data-tip': a.title, 'data-tip-body': tip }, g));
+      out.push(node('a', { href: `/goals#/goal/${encodeURIComponent(a.id)}`, class: 'hc-tower' + (o.picked === a.id ? ' hc-tower--picked' : ''), 'data-goal': a.id, 'aria-label': `${a.title}: ${shipped} shipped. Open the goal.`, 'data-tip': a.title, 'data-tip-body': tip }, g));
       // the cloud at its foot, over this tower and under the next one forward
       if (cloudy) out.push(puff(x1 - 0.5, y1 - 0.5, 62));
     });
@@ -344,6 +347,7 @@
 
     over.forEach((v, n) => {
       if (v.k === 'face') { out.push(avatarNode(v.p, v.who, v.agent, v.a, I, n, node, line, circle)); return; }
+      if (v.k === 'runner') { out.push(runnerNode(v.p, v.state, v.a, I, node, line, circle)); return; }
       const cx = v.p[0] - 30, cy = v.p[1];
       out.push(node('g', { class: 'hc-wait', 'data-tip': v.a.title, 'data-tip-body': `${v.n} waiting on you` }, [
         circle(cx, cy, 11, { fill: 'var(--accent)', stroke: 'var(--bg-card)', 'stroke-width': 2.5 }),
@@ -607,6 +611,24 @@
     return node('g', { class: 'hc-face-pin', 'data-tip': agent ? `${who.name}'s agent` : who.name, 'data-tip-body': a.title }, g);
   }
 
+  // Your Autobongos runner on the tower it was sent to (task 1005243): the agent's robot face,
+  // ringed in the state it is in. Working wears the accent ring that turns (CSS, under the
+  // Kill Switch); resting a dashed ring; starting the info ring; ready a soft ring; off no ring
+  // and a faded face. The words for each are the visor's card, never this mark alone.
+  // The same words the visor's card puts on the device's face (runner-button.js buttonState).
+  const RUNNER_WORDS = { working: 'Running', resting: 'Resting', starting: 'Starting…', ready: 'Ready', off: 'Recalled' };
+  function runnerNode(p, state, a, I, node, line, circle) {
+    const x = p[0], y = p[1];
+    const st = RUNNER_WORDS[state] ? state : 'off';
+    return node('g', { class: `hc-runner hc-runner--${st}`, 'data-goal': a.id, 'data-tip': 'Your runner', 'data-tip-body': `${RUNNER_WORDS[st]} · ${a.title}` }, [
+      line([x, y + 18], [x, y + 32], I.steel, 1),
+      circle(x, y, 21, { class: 'hc-runner__ring', fill: 'none', 'stroke-width': 2.5 }),
+      circle(x, y, 16, { class: 'hc-runner__face', fill: I.avAgent, stroke: 'var(--bg-card)', 'stroke-width': 3 }),
+      node('rect', { class: 'hc-runner__ink', x: r1(x - 7), y: r1(y - 5), width: 14, height: 11, rx: 3, fill: 'none', stroke: I.avInk, 'stroke-width': 1.5 }),
+      circle(x - 3, y + 0.5, 1.5, { class: 'hc-runner__eye', fill: I.avInk }), circle(x + 3, y + 0.5, 1.5, { class: 'hc-runner__eye', fill: I.avInk }),
+    ]);
+  }
+
   function initial(name) { const s = String(name || '').trim(); return s ? s[0].toUpperCase() : '?'; }
   // a stable spread for an idea's place in the sky (FNV-1a over its id)
   function hash(s) { let h = 2166136261; for (const c of String(s)) { h ^= c.charCodeAt(0); h = Math.imul(h, 16777619); } return Math.abs(h); }

package/modules/hall-ui/public/home-city.css

@@ -38,6 +38,20 @@ html[data-game="on"] body[data-page="home"] .page-head--hall .page-head__h { wid
 .hc-svg a:focus { outline: none; }
 .hc-svg a:focus-visible .hc-face { filter: brightness(1.35); }
 .hc-svg .hc-tower:hover .hc-face { filter: brightness(1.3); }
+/* game mode, your runner (task 1005243): the tower picked for the visor's card is lit and edged
+   in the accent; your runner's marker is the agent's face in a ring that says its state */
+.hc-svg .hc-tower--picked .hc-face { filter: brightness(1.2); stroke: var(--accent); stroke-width: 2px; }
+.hc-svg .hc-runner { cursor: pointer; }
+.hc-svg .hc-runner__ring { stroke: var(--ink-soft); stroke-opacity: .5; stroke-width: 3.5px; }
+/* yours, not anyone's agent: the accent face, the dark ink on it */
+.hc-svg .hc-runner__face { fill: var(--accent); }
+.hc-svg .hc-runner__ink { stroke: var(--accent-on); }
+.hc-svg .hc-runner__eye { fill: var(--accent-on); }
+.hc-svg .hc-runner--working .hc-runner__ring { stroke: var(--accent); stroke-opacity: 1; stroke-dasharray: 22 10; transform-box: fill-box; transform-origin: center; animation: hc-turn 6s linear infinite; }
+.hc-svg .hc-runner--starting .hc-runner__ring { stroke: var(--info); stroke-opacity: 1; stroke-dasharray: 4 6; }
+.hc-svg .hc-runner--resting .hc-runner__ring { stroke: var(--info); stroke-opacity: .9; stroke-dasharray: 2 5; }
+.hc-svg .hc-runner--off { opacity: .55; }
+.hc-svg .hc-runner--off .hc-runner__ring { stroke-opacity: 0; }
 /* the core and the museum stay quiet on the builder's Home so the new buildings lead;
    each comes back to full colour under the pointer or the keyboard */
 .hc-svg .hc-quiet { opacity: .62; filter: saturate(.3); transition: opacity .3s, filter .3s; }
@@ -110,6 +124,7 @@ html[data-theme="dark"] .home-city.hc-is-sky { background: linear-gradient(color
 
 /* live, and nothing more: a crane's slab climbs, this week's ideas glow (20s+) */
 @keyframes hc-lift { 0%, 12% { transform: translateY(0); } 55%, 70% { transform: translateY(-24px); } 100% { transform: translateY(0); } }
+@keyframes hc-turn { to { transform: rotate(360deg); } }
 @keyframes hc-glow { 0%, 100% { opacity: .55; } 50% { opacity: 1; } }
 @keyframes hc-live { 0% { box-shadow: 0 0 0 0 color-mix(in srgb, var(--ok) 55%, transparent); } 100% { box-shadow: 0 0 0 8px transparent; } }
 .hc-slab { animation: hc-lift 20s ease-in-out infinite; }

package/modules/hall-ui/public/home-city.js

@@ -104,7 +104,8 @@
     const svg = host.querySelector('.hc-svg');
     const sky = craft() === 'ideating';
     const draw = sky ? Draw.skySvg : Draw.citySvg;
-    const out = draw(model, atLive(t) ? model.W - 1 : t, { mode: mode(), gov: window.GovCity || null });
+    const R = window.OTBHomeRunner; // your runner on its tower, and the tower picked for it (home-runner.js)
+    const out = draw(model, atLive(t) ? model.W - 1 : t, { mode: mode(), gov: window.GovCity || null, runner: R ? R.marker() : null, picked: R ? R.picked() : null });
     host.classList.toggle('hc-is-sky', sky);
     svg.setAttribute('aria-label', sky ? SKY_LABEL : CITY_LABEL);
     host.querySelector('#home-city-h').textContent = sky ? 'The project\'s ideas this week' : 'The project this week';
@@ -354,6 +355,7 @@
     new MutationObserver(() => { if (model) drawScene(); }).observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
     document.addEventListener('otb:craft', () => { if (model) { drawScene(); drawLadder(); } });
     window.addEventListener('resize', () => { if (model) drawLadder(); });
+    document.addEventListener('otb:home-runner', () => { if (model) drawScene(); });
     registerScene();
     load();
   }

package/modules/hall-ui/public/home-runner.js

@@ -0,0 +1,248 @@
+// modules/hall-ui/public/home-runner.js — your Autobongos runner on Home's city
+// (task 1005243, goal 1000142).
+//
+// WHY. Owner direction, 2026-11-12: running your runner should feel like putting a
+// builder on a building in a base-building game. In game mode you tap a tower (a
+// goal), the visor offers "Send runner here", and the tower then carries your
+// runner's marker; tap it again and the visor shows what it has done there and
+// "Recall runner". The owner chose that a runner works ONE tower at a time, so
+// sending it sets your goal picks to that one goal.
+//
+// THE RULES IT KEEPS.
+//   - ADR 0403: the scene is the view and the visor is the control. The tower only
+//     gets picked; every button is on the glass (OTBVisor.focus).
+//   - The server decides who may run a runner: GET /autonomy/fence answers
+//     scope.may_run, and only then is a tower pickable. Signed out, a rank without
+//     `autonomy.run`, or classic mode: towers stay plain links and nothing is new.
+//   - Every write is a route Settings already uses: PUT /autonomy/me/goals and
+//     POST /autonomy/runners/:host/run. The numbers come from GET
+//     /autonomy/me/goals/:id/stats (the ledger: runner claims shipped there, the
+//     tokens their sessions took, the tasks still ready).
+//   - The device's face (working, resting until, off…) is runner-button.js's
+//     buttonState, the same decision the Settings card draws.
+//
+// The decision (cardFor, stateOf) is PURE and exported for node tests; the wiring
+// below it only runs in a browser.
+(function (root) {
+  'use strict';
+
+  const RB = () => (root && root.OTBRunnerButton) || (typeof require === 'function' ? require('./runner-button.js') : null);
+
+  // ---------- pure ----------
+
+  // The device that speaks for "your runner": one that is working, else one that is
+  // switched on, else the most recently seen (the server's order).
+  function leadDevice(runners) {
+    const list = Array.isArray(runners) ? runners.filter(Boolean) : [];
+    return list.find((r) => r.health && r.health.workingTaskId) ||
+      list.find((r) => r.run_requested !== false) || list[0] || null;
+  }
+  function anyOn(runners) { return (Array.isArray(runners) ? runners : []).some((r) => r && r.run_requested !== false); }
+
+  // The goal the runner is sent to: exactly one pick. Several picks (made in Settings)
+  // is not one tower, so no tower carries the marker until the builder sends it.
+  function assignedGoal(fence) {
+    const g = fence && fence.scope && Array.isArray(fence.scope.goals) ? fence.scope.goals : [];
+    return g.length === 1 ? String(g[0]) : null;
+  }
+
+  // The marker's state, from the device's face: working | resting | starting | ready | off.
+  function stateOf({ runners, fence, nowMs } = {}) {
+    const d = leadDevice(runners);
+    if (!d || !anyOn(runners)) return 'off';
+    const b = RB().buttonState({ runner: d, fence, nowMs });
+    if (d.health && d.health.workingTaskId && b.status === 'Running') return 'working';
+    if (/^Resting/.test(b.status)) return 'resting';
+    if (b.status === 'Starting…' || b.status === 'Updating…') return 'starting';
+    if (b.status === 'Running' || b.status === 'Ready') return 'ready';
+    return 'off';
+  }
+
+  // 1.2M tokens, 340k tokens, 900 tokens.
+  function tokensText(n) {
+    const v = Number(n) || 0;
+    if (v >= 1e6) return `${(v / 1e6).toFixed(v >= 1e7 ? 0 : 1).replace(/\.0$/, '')}M tokens`;
+    if (v >= 1e3) return `${Math.round(v / 1e3)}k tokens`;
+    return `${Math.round(v)} tokens`;
+  }
+  // "about 40 min", "about 3 h", "about 2 days": an estimate, so rounded like one.
+  function aboutText(seconds) {
+    const s = Number(seconds);
+    if (!Number.isFinite(s) || s <= 0) return '';
+    const min = s / 60;
+    if (min < 60) return `about ${Math.max(5, Math.round(min / 5) * 5)} min`;
+    const h = min / 60;
+    if (h < 36) return `about ${Math.round(h)} h`;
+    return `about ${Math.round(h / 24)} days`;
+  }
+  function plural(n, one, many) { return `${n} ${n === 1 ? one : many}`; }
+
+  // What the visor's card says for one tower. Returns null when the viewer has no
+  // runner to send (the tower then stays a plain link), else
+  //   { title, status: { text, tone }, lines: [string], lead: { label, act } | null }
+  // act: 'send' | 'recall' | 'setup' | 'open'.
+  function cardFor({ goal, runners, fence, stats, nowMs = Date.now(), titleOf } = {}) {
+    if (!goal || !fence || !fence.scope || fence.scope.may_run !== true) return null;
+    const id = String(goal.id);
+    const title = goal.title || `Goal ${id}`;
+    const nameOf = (g) => (typeof titleOf === 'function' && titleOf(g)) || `goal ${g}`;
+    const list = Array.isArray(runners) ? runners : [];
+    const st = stats || null;
+    const done = st ? Number(st.tasks_done) || 0 : 0;
+    const left = st ? Number(st.tasks_left) || 0 : null;
+    const eta = st && left ? aboutText(left * (Number(st.avg_task_seconds) || 0)) : '';
+    const leftLine = left == null ? null : left === 0 ? 'Nothing ready to build here right now.' : `${plural(left, 'task', 'tasks')} ready${eta ? ` · ${eta} for your runner` : ''}`;
+    const doneLine = st && done ? `${plural(done, 'task', 'tasks')} done here · ${tokensText(st.tokens)}` : null;
+
+    if (!list.length) {
+      return { title, status: { text: 'No runner yet', tone: 'neutral' },
+        lines: ['Set it up on your PC once, then send it to any tower.'], lead: { label: 'Set up a runner', act: 'setup' } };
+    }
+    const allowed = fence.project && Array.isArray(fence.project.goals) ? fence.project.goals.map(String) : [];
+    if (!allowed.includes(id)) {
+      return { title, status: { text: 'Closed to runners', tone: 'neutral' },
+        lines: ['The project has not opened this goal to runners yet.'], lead: { label: 'Open the goal', act: 'open' } };
+    }
+    const here = assignedGoal(fence) === id;
+    const on = anyOn(list);
+    if (here && on) {
+      const b = RB().buttonState({ runner: leadDevice(list), fence, nowMs });
+      const face = b.status ? `${b.status}${b.countdown ? ` · ${b.countdown}` : ''}` : 'Off';
+      return { title, status: { text: face, tone: b.tone || 'neutral' },
+        lines: [b.sub, doneLine, leftLine].filter(Boolean), lead: { label: 'Recall runner', act: 'recall' } };
+    }
+    const where = on && assignedGoal(fence) ? `Your runner is at ${nameOf(assignedGoal(fence))}` :
+      on ? 'Your runner is working on several goals' : 'Your runner is resting';
+    return { title, status: { text: here ? 'Recalled' : where, tone: 'neutral' },
+      lines: [doneLine, leftLine].filter(Boolean), lead: { label: 'Send runner here', act: 'send' } };
+  }
+
+  const api = { cardFor, stateOf, assignedGoal, leadDevice, tokensText, aboutText };
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  if (!root || typeof document === 'undefined') return;
+  root.OTBHomeRunnerLib = api;
+
+  // ---------- the wiring (browser only) ----------
+  const API = '/api/bongos';
+  const POLL_MS = 15000;
+  let fence = null, runners = [], picked = null, stats = null, busy = false, error = '', timer = null;
+  let client = null;
+  function http() {
+    if (!client && root.BongosClient) client = root.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+    return client;
+  }
+  async function req(method, path, body) {
+    const c = http();
+    if (!c) return null;
+    try { return await c.request(method, API + path, body ? { body } : undefined); } catch (_) { return null; }
+  }
+  function game() { return document.documentElement.dataset.game === 'on'; }
+  function mayRun() { return !!(fence && fence.scope && fence.scope.may_run === true); }
+  function active() { return game() && mayRun() && !!root.OTBVisor && typeof root.OTBVisor.focus === 'function'; }
+  function towerOf(id) { return document.querySelector(`.home-city .hc-tower[data-goal="${CSS.escape(String(id))}"]`); }
+  function titleOf(id) { const t = towerOf(id); return t ? t.getAttribute('data-tip') : null; }
+
+  // What home-city.js draws: the marker on the assigned tower, and the picked tower.
+  function marker() {
+    if (!active()) return null;
+    const goal = assignedGoal(fence);
+    return goal ? { goal, state: stateOf({ runners, fence, nowMs: Date.now() }) } : null;
+  }
+  function changed() { document.dispatchEvent(new CustomEvent('otb:home-runner')); }
+
+  async function readState() {
+    const [f, r] = await Promise.all([req('GET', '/autonomy/fence'), req('GET', '/autonomy/runners')]);
+    fence = f && f.ok && f.data ? f.data : null;
+    runners = r && r.ok && r.data && Array.isArray(r.data.runners) ? r.data.runners : [];
+  }
+  async function readStats() {
+    if (!picked) return;
+    const s = await req('GET', `/autonomy/me/goals/${encodeURIComponent(picked)}/stats`);
+    stats = s && s.ok && s.data ? s.data : null;
+  }
+
+  function show() {
+    const V = root.OTBVisor;
+    if (!V || typeof V.focus !== 'function') return;
+    if (!picked || !active()) { V.focus(null); return; }
+    const card = cardFor({ goal: { id: picked, title: titleOf(picked) }, runners, fence, stats, nowMs: Date.now(), titleOf });
+    if (!card) { V.focus(null); return; }
+    const lead = card.lead ? { label: busy ? (card.lead.act === 'recall' ? 'Recalling…' : 'Sending…') : card.lead.label, busy, run: () => act(card.lead.act) } : null;
+    V.focus({ key: `runner:${picked}`, title: card.title, status: card.status, lines: error ? [error].concat(card.lines) : card.lines, lead, onClose: unpick });
+  }
+
+  async function act(what) {
+    if (busy || !picked) return;
+    if (what === 'open') { root.location.assign(`/goals#/goal/${encodeURIComponent(picked)}`); return; }
+    if (what === 'setup') { root.location.assign('/settings#autobongos'); return; }
+    busy = true; error = ''; show();
+    let ok = true;
+    if (what === 'send') {
+      const g = await req('PUT', '/autonomy/me/goals', { goal_ids: [Number(picked)] });
+      ok = !!(g && g.ok);
+      if (ok) {
+        const outs = await Promise.all(runners.filter((r) => r.run_requested === false)
+          .map((r) => req('POST', `/autonomy/runners/${encodeURIComponent(r.host)}/run`, { run: true })));
+        ok = outs.every((o) => o && o.ok);
+      }
+    } else if (what === 'recall') {
+      const outs = await Promise.all(runners.filter((r) => r.run_requested !== false)
+        .map((r) => req('POST', `/autonomy/runners/${encodeURIComponent(r.host)}/run`, { run: false })));
+      ok = outs.every((o) => o && o.ok);
+    }
+    if (!ok) error = what === 'send' ? 'Could not send your runner. Try again.' : 'Could not recall your runner. Try again.';
+    await readState();
+    await readStats();
+    busy = false;
+    show();
+    changed();
+  }
+
+  function pick(id) {
+    picked = String(id); stats = null; error = '';
+    show(); changed();
+    readStats().then(() => { if (picked === String(id)) show(); });
+  }
+  // The visor's card closed (Escape, its close mark, or a tap on open ground).
+  function unpick() {
+    if (!picked) return;
+    picked = null; stats = null; error = '';
+    changed();
+  }
+
+  // A tap on a tower in game mode picks it instead of leaving the page; a tap on open
+  // ground lets the pick go. Capture, so it runs before the tower's own link.
+  function onClick(e) {
+    if (!active()) return;
+    const city = e.target.closest && e.target.closest('.home-city .hc-svg');
+    if (!city) return;
+    const t = e.target.closest('.hc-tower[data-goal], .hc-runner[data-goal]');
+    if (!t) { if (picked && !e.target.closest('a')) { root.OTBVisor.focus(null); unpick(); } return; }
+    e.preventDefault();
+    const id = t.getAttribute('data-goal');
+    if (picked === id) return;
+    pick(id);
+  }
+
+  async function refresh() {
+    await readState();
+    if (picked) await readStats();
+    if (picked) show();
+    changed();
+  }
+  function poll() {
+    clearTimeout(timer);
+    timer = setTimeout(async () => {
+      if (!document.hidden && game() && mayRun() && runners.length) await refresh();
+      poll();
+    }, POLL_MS);
+  }
+
+  function start() {
+    document.addEventListener('click', onClick, true);
+    refresh().then(poll);
+  }
+  root.OTBHomeRunner = { marker, picked: () => (active() ? picked : null), refresh };
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', start);
+  else start();
+})(typeof window !== 'undefined' ? window : null);

package/modules/hall-ui/public/index.html

@@ -19,11 +19,11 @@
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link rel="stylesheet" href="/builders/style.css?v=2026-11-11-helm4d">
-  <link rel="stylesheet" href="/builders/visor.css?v=2026-11-11-helm4c">
+  <link rel="stylesheet" href="/builders/visor.css?v=2026-11-12-runner">
   <link rel="stylesheet" href="/builders/welcome-boot.css?v=2026-11-07-brand-mark">
   <link rel="stylesheet" href="/builders/shell-game.css?v=2026-11-11-view2">
   <link rel="stylesheet" href="/builders/hall-ask.css">
-  <link rel="stylesheet" href="/builders/home-city.css?v=2026-11-11-helm4c">
+  <link rel="stylesheet" href="/builders/home-city.css?v=2026-11-12-runner">
   <link rel="stylesheet" href="/builders/home-gallery.css">
   <link rel="stylesheet" href="/builders/home-idea-box.css">
 </head>
@@ -116,7 +116,7 @@
 <script src="/builders/shell.js?v=2026-11-11-view2" defer></script>
 <script src="/builders/hall-dialog.js" defer></script>
 <!-- task 1005148: the visor (glass over the scene, game mode only; ADR 0399), after the shell and hall-dialog.js -->
-<script src="/builders/visor.js?v=2026-11-11-helm3" defer></script>
+<script src="/builders/visor.js?v=2026-11-12-runner" defer></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- task 2166: the shared component kit (window.OTBKit) — pager/ledger/rail.
@@ -138,10 +138,13 @@
 <script src="/builders/city-draw.js" defer></script>
 <!-- task 1005196: the hour of the city's sky (sets the --sky-now-* tokens the city spends) -->
 <script src="/builders/sky-time.js?v=2026-11-11-helm4" defer></script>
-<script src="/builders/home-city-draw.js?v=2026-11-11-helm4d" defer></script>
+<script src="/builders/home-city-draw.js?v=2026-11-12-runner" defer></script>
 <script src="/builders/home-gallery.js" defer></script>
 <script src="/builders/home-idea-box.js" defer></script>
-<script src="/builders/home-city.js?v=2026-11-10-visor" defer></script>
+<!-- task 1005243: your runner on Home's towers (game mode; the visor carries its card and button) -->
+<script src="/builders/runner-button.js" defer></script>
+<script src="/builders/home-runner.js" defer></script>
+<script src="/builders/home-city.js?v=2026-11-12-runner" defer></script>
 <!-- task 1003455: the shared blocker-row renderer (window.OTBBlockersLib), read by
      both goal-inbox.js's attention-inbox slice below and the /blockers page.
      Loaded BEFORE goal-inbox.js, which calls it while rendering. -->

package/modules/hall-ui/public/visor.css

@@ -169,5 +169,32 @@ html[data-game="on"] .visor:not([hidden]) {
 .visor__row--hint:hover { color: var(--ink-soft); }
 .visor__sheet .visor__key { color: var(--ink-soft); background: none; }
 
+/* the card for what the scene picked (task 1005243): Home's tower and your runner on it. Centred
+   over the accent button it hands its one action to, the night panel between two strong
+   hairlines like the sheet, never wider than a short paragraph. The words are the scene's facts;
+   the status dot is the hall's status vocabulary (--ok / --warn / --info), never a colour of its own. */
+.visor__focus {
+  position: absolute; left: 50%; bottom: calc(var(--visor-inset-bottom) + 72px); transform: translateX(-50%);
+  pointer-events: auto; box-sizing: border-box; width: min(20rem, calc(100vw - 2 * var(--ds-space-gutter-narrow)));
+  padding: var(--ds-space-xs) var(--ds-space-sm) var(--ds-space-sm); background: var(--bg-card);
+  border: 0 solid var(--rule); border-left-width: var(--line-strong); border-right-width: var(--line-strong);
+}
+.visor__focus-head { display: flex; align-items: center; justify-content: space-between; gap: var(--ds-space-xs); }
+.visor__focus-title {
+  margin: 0; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  font-family: var(--name-face); font-weight: var(--name-weight); text-transform: var(--name-case);
+  font-size: var(--ds-text-xl); letter-spacing: var(--name-space); color: var(--ink);
+}
+.visor__focus-status { display: flex; align-items: center; gap: var(--ds-space-xs); margin: 2px 0 0; font-size: var(--ds-text-md); color: var(--ink); }
+.visor__focus-status i { width: 10px; height: 10px; flex: none; background: var(--rule); }
+.visor__focus-status--ok i { background: var(--ok); }
+.visor__focus-status--warn i { background: var(--warn); }
+.visor__focus-status--info i { background: var(--info); }
+.visor__focus-status--danger i { background: var(--danger); }
+.visor__focus-lines { list-style: none; margin: var(--ds-space-xs) 0 0; padding: 0; color: var(--ink-soft); font-size: var(--ds-text-sm); line-height: 1.45; }
+.visor__focus-lines li + li { margin-top: 2px; }
+.visor__focus .visor__key { color: var(--ink-soft); background: none; }
+.visor__main--lead[aria-busy="true"] { cursor: progress; background: var(--accent-lift); }
+
 /* a phone (640px and narrower): the rules live in style.css’s shared phone block, so the
    visor adds no breakpoint of its own (the design-count ratchet). */

package/modules/hall-ui/public/visor.js

@@ -151,6 +151,64 @@
     render();
   }
 
+  // ---------- what the scene has picked (task 1005243) ----------
+  // A scene that picks something (Home's tower) hands the visor a small card about it:
+  // a title, one status, a few lines, and at most one action. The action becomes the
+  // accent button while the card is up (ADR 0403 §4: a scene's lead action reaches the
+  // accent button); the character's own main action is back when the card closes.
+  // The scene paints the pick; the visor paints the words and the button.
+  var focus = null;
+  function setFocus(f) {
+    var was = focus;
+    if (!f || typeof f !== 'object' || !f.title) focus = null;
+    else {
+      var lead = f.lead && f.lead.label && typeof f.lead.run === 'function' ? { label: String(f.lead.label), run: f.lead.run, busy: !!f.lead.busy } : null;
+      focus = {
+        key: String(f.key || f.title), title: String(f.title),
+        status: f.status && f.status.text ? { text: String(f.status.text), tone: String(f.status.tone || 'neutral') } : null,
+        lines: (Array.isArray(f.lines) ? f.lines : []).filter(Boolean).map(String).slice(0, 4),
+        lead: lead, onClose: typeof f.onClose === 'function' ? f.onClose : null,
+      };
+    }
+    if (focus && !was) document.addEventListener('keydown', onFocusKey, true);
+    if (!focus && was) document.removeEventListener('keydown', onFocusKey, true);
+    render();
+  }
+  // Closed by the person (Escape or the close mark): the scene is told, so it unpicks.
+  function dropFocus() {
+    var f = focus;
+    if (!f) return;
+    setFocus(null);
+    if (f.onClose) f.onClose();
+  }
+  // Escape closes the card before it reaches the options menu, but never while the sheet
+  // is open: the sheet's own capture listener takes that press.
+  function onFocusKey(e) {
+    if (!focus || sheet || e.key !== 'Escape' || !shown()) return;
+    e.preventDefault();
+    e.stopPropagation();
+    dropFocus();
+  }
+  var TONES = { ok: 1, warn: 1, info: 1, neutral: 1, danger: 1 };
+  function focusHtml() {
+    if (!focus) return '';
+    var st = focus.status;
+    return '<div class="visor__focus" role="group" aria-label="' + esc(focus.title) + '" aria-live="polite" data-visor-focus>' +
+      '<div class="visor__focus-head"><p class="visor__focus-title">' + esc(focus.title) + '</p>' +
+        '<button class="visor__close" type="button" data-visor-unfocus aria-label="Close">' + keyHtml('Esc') + '</button></div>' +
+      (st ? '<p class="visor__focus-status visor__focus-status--' + (TONES[st.tone] ? st.tone : 'neutral') + '"><i aria-hidden="true"></i>' + esc(st.text) + '</p>' : '') +
+      (focus.lines.length ? '<ul class="visor__focus-lines">' + focus.lines.map(function (l) { return '<li>' + esc(l) + '</li>'; }).join('') + '</ul>' : '') +
+      '</div>';
+  }
+  function mainHtml(main) {
+    if (focus && focus.lead) {
+      return '<button class="visor__main visor__main--lead" type="button" data-visor-lead' + (focus.lead.busy ? ' aria-busy="true"' : '') + '>' +
+        '<span>' + esc(focus.lead.label) + '</span></button>';
+    }
+    return '<a class="visor__main" data-visor-act="' + esc(main.id) + '" ' + actionAttrs(main) + '>' +
+      '<span>' + esc(main.label) + '</span>' + keyHtml(main.key) + '</a>';
+  }
+
   // ---------- drawing ----------
   var root = null, sheet = null, returnFocus = null;
   var NS = 'http://www.w3.org/2000/svg';
@@ -197,14 +255,14 @@
     return frameSvg() +
       (scene.place ? '<p class="visor__place">' + esc(scene.place) + '</p>' : '') +
       progressHtml() +
+      focusHtml() +
       '<div class="visor__foot">' +
         '<div class="visor__me">' +
           (sprite ? '<img class="visor__sprite" src="' + esc(sprite) + '" alt="" width="32" height="32" decoding="async">' : '') +
           '<span class="visor__who"><span class="visor__name">' + esc(NAMES[id]) + '</span>' +
           '<span class="visor__credits" data-visor-credits>' + creditsHtml(n) + '</span></span>' +
         '</div>' +
-        '<a class="visor__main" data-visor-act="' + esc(main.id) + '" ' + actionAttrs(main) + '>' +
-          '<span>' + esc(main.label) + '</span>' + keyHtml(main.key) + '</a>' +
+        mainHtml(main) +
         '<div class="visor__hints">' + scene.actions.map(function (a, i) { return a.lead ? placeHintHtml(a, i) : ''; }).join('') + acts.slice(1).map(hintHtml).join('') +
           '<button class="visor__hint visor__hint--sheet" type="button" data-visor-sheet aria-expanded="false" aria-controls="visor-sheet">' +
             '<span class="visor__dots" aria-hidden="true"></span>' + keyHtml(SHEET_KEY) + '<span>Actions</span></button>' +
@@ -328,6 +386,8 @@
     var t = e.target && e.target.closest ? e.target : null;
     if (!t) return;
     if (t.closest('[data-visor-close]')) { closeSheet(true); return; }
+    if (t.closest('[data-visor-unfocus]')) { dropFocus(); return; }
+    if (t.closest('[data-visor-lead]')) { if (focus && focus.lead && !focus.lead.busy) { closeSheet(false); focus.lead.run(); } return; }
     if (t.closest('[data-visor-sheet]')) { openSheet(); return; }
     var sc = t.closest('[data-visor-scene]');
     if (sc && scene) { var a = scene.actions[Number(sc.getAttribute('data-visor-scene'))]; closeSheet(false); if (a) a.run(); return; }
@@ -389,6 +449,9 @@
 
   window.OTBVisor = {
     scene: registerScene,
+    // a scene's pick: OTBVisor.focus({ title, status, lines, lead: { label, run }, onClose }) or focus(null)
+    focus: setFocus,
+    focused: function () { return focus ? focus.key : null; },
     render: render,
     open: openSheet,
     close: function () { closeSheet(true); },