infinity-harness 2.6.5 → 2.6.6

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.6] — 2026-08-28
+
+Every phase shows its tracked work, tabs isolate it, and autopilot actually drives.
+
+### Fixed
+
+- **All phases now show the damn breakdown you asked for (`wdisplay` = truth).** Every enabled phase owns tracked work: `RESEARCH` gets its 3/5/7 tasks+subtasks (by depth) even when its doc gate already passes, `DEFINE/PLAN` get starters when their gate `feature-criteria` fails, visibility is the wizard's `display` policy (`goal/sprint/feature/task/subtask` levels) respected everywhere — the widget lane and the dashboard still render `... N above/below` windowed.
+
+- **Dashboard tabs: Goal(s) ▸ Phase(s).** Top nav filters the live plan without losing state: Goal tabs appear only when `goals.length >1` (if single goal, only Phase tabs), default = `activeTask`'s goal/phase otherwise `currentPhase`, persisted via `localStorage`, survives poll-refresh. Each feature card gets `data-phase` so phase tabs hide `phase-research` under `BUILD`, etc. `display.levels.goal/sprint/feature` still hide the tier chrome.
+
+- **Autopilot actually auto-pilots (any phase).** `infinity_validate` was allowlisted to `research/define/plan`; now any `phaseModes[phase]==autopilot` PASS auto-advances, seeds the next phase (`ensurePhaseSeeded`), arms `spawnWorkers` scoped to `currentPhase`, and the brief still drives the main session. Copilot still parks on `needsApproval==true`. Fixes: `RESEARCH complete → advanced research → DEFINE` now lands on a `DEFINE 2/2` seeded plan, not `0/0`.
+
+- **Seeding is per-phase, not per-first-feature.** `seedPhaseIfEmpty` previously appended to `list.features[0]` or first `phase==` match; with mixed phases it coalesced `research`+`define` into one `phase-research` feature. Now it reuses only `phase==cur` or creates `phase-<name>`, so `phase-research(5)` and `phase-define(2)` are separate cards and per-phase `computeProgress(phase)` tallies correctly. `src/loop.ts` special-cased `research` to always show (FAIL gated would leave it doc-only) and respects `approvalRejection` fingerprint (no seeding while a rejection stands, so `no-progress → give up` still fires).
+
+- **Seeding never dirties a converged walk or an approval rejection.** `decideNext` skips seeding when `approvalRejection` present (lets `rejection-unaddressed` escalate), and only seeds `define/plan/...` when their gate probes `overall==false`. Research exception: `feature-criteria` `no real features planned yet` (seeded scaffolding excluded) so define triggers correctly. The existing `convergence` walk `define→ship` still passes because its synthetic satisfiable gates probe PASS and seeded scaffolds are skipped.
+
+- **Widget dashboard URL: always visible.** Previously `renderWidget` only emitted `Dashboard: http://…` when `remoteServer` was live; now it always renders a hint `Dashboard: /infinity:dashboard → http://127.0.0.1:PORT` even without a server (OSC 8 hyperlink when live). You asked this twice last time and it was only half-wired.
+
+- **Blink that blinks.** `dashboard.css` `cardPulse` 1.2s whisper → 1s `cardPulse + phasePulse + textPulse` with `4px` ring + `16px` glow, active goal/sprint/feature boxes now use `font-weight:800` + stronger `taskBlink` (`2.5px` outline, `0.85s`). `prefers-reduced-motion` still disables.
+
+### Verified
+
+- `tsc --noEmit` clean, `34/34` unit, `pipeline/extension/convergence/dashboard/widget/stops/coldstart/escalation/goal/realpi` all pass in isolation and `npm run e2e` (live skipped) green; `bakr_test_2.6.5 define` retro-seeded to visible `RESEARCH(5)+DEFINE(2)` on dashboard (goal tabs hidden when one goal, phase tabs live).
+
 ## [2.6.5] — 2026-08-27
 
 Routing is honest about handoff, research knows how deep to go, and the human reads the same wiring the runner does.

package/extensions/infinity-harness/index.ts

@@ -1225,40 +1225,33 @@ export default function (pi: ExtensionAPI): void {
       const lines = gate.checks
         .map((c) => `${c.advisory ? "·" : c.pass ? "+" : "x"} ${c.name}: ${c.detail}`)
         .join("\n");
-      // Research (and any other phase whose mode is autopilot) used to stall
-      // forever until someone typed "continue" because the brief said
-      // PASS→advance but no component actually advanced without the continuous
-      // loop armed. Fix that, but do NOT auto-advance BUILD verify-style
-      // phases that require real work (tests, coverage, clean tree) to have
-      // genuinely passed on the *next* phase's gate as well — otherwise a
-      // single infinity_validate hops build→verify→review.
-      // Only auto-advance doc/process phases whose gate is purely content (
-      // research, define, plan). BUILD and later require explicit validation.
+      // Autopilot means auto-pilot: when the gate passes and the current
+      // phase's phaseMode is autopilot, advance immediately (any phase). The
+      // old allowlist stalled real autopilot builds after RESEARCH → DEFINE.
+      // Copilot still parks via needsApproval check below.
       if (gate.overall && !params?.feature && !params?.task) {
-        const autoPhases: ReadonlySet<string> = new Set(["research", "define", "plan"]);
-        if (autoPhases.has(String(gate.phase))) {
-          try {
-            const { needsApproval } = await import("../../src/approval.ts");
-            const fresh = loadConfig(dir).config;
-            if (!needsApproval(fresh, fresh.currentPhase)) {
-              const { advancePhase } = await import("../../src/core/phases.ts");
-              const moved = await advancePhase(dir);
-              if (moved.ok && moved.to) {
-                refreshWidget(ctx as ExtensionContext);
-                const brief = await briefText(dir);
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: `Gate PASS on ${gate.phase} → advanced ${moved.from} → ${moved.to}\n${lines}\n\n${brief}`,
-                    },
-                  ],
-                  details: { ...gate, advanced: moved } as unknown as typeof gate,
-                };
-              }
+        try {
+          const { needsApproval } = await import("../../src/approval.ts");
+          const fresh = loadConfig(dir).config;
+          if (!needsApproval(fresh, fresh.currentPhase)) {
+            const { advancePhase, ensurePhaseSeeded } = await import("../../src/core/phases.ts");
+            const moved = await advancePhase(dir);
+            if (moved.ok && moved.to) {
+              try { ensurePhaseSeeded(dir, moved.to); } catch {}
+              refreshWidget(ctx as ExtensionContext);
+              const brief = await briefText(dir);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Gate PASS on ${gate.phase} → advanced ${moved.from} → ${moved.to}\n${lines}\n\n${brief}`,
+                  },
+                ],
+                details: { ...gate, advanced: moved } as unknown as typeof gate,
+              };
             }
-          } catch {}
-        }
+          }
+        } catch {}
       }
       return {
         content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinity-harness",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "description": "A pi agent extension that runs a gated build pipeline unattended \u2014 enforces phases, validates with deterministic gates, and keeps working for hours or days without losing the plan.",
   "type": "module",
   "keywords": [

package/src/core/gates.ts

@@ -336,8 +336,10 @@ async function checkNoEmptyDirs({ targetDir }: Ctx): Promise<CheckResult> {
 async function checkFeatureCriteria({ targetDir }: Ctx): Promise<CheckResult> {
   const { list } = loadFeatureList(targetDir);
   // Seeded starter features (phase-*) are scaffolding, not real features — ignore for criteria gate.
+  // Also: if no non-scaffold features exist yet, DEFINE has not been planned and must not PASS on a
+  // single phase-* dummy. Treat absent as FAIL with a distinct detail so callers seeding define know to act.
   const features = (list.features ?? []).filter((f) => !(f as { phase?: string }).phase);
-  if (features.length === 0) return fail("feature-criteria", "no features planned yet");
+  if (features.length === 0) return fail("feature-criteria", "no real features planned yet — run DEFINE");
   const missing = features.filter((f) => !(f.criteria ?? []).length).map((f) => f.id);
   return missing.length === 0
     ? pass("feature-criteria", `${features.length} feature(s) have criteria`)
@@ -381,10 +383,9 @@ type Check = (ctx: Ctx) => Promise<CheckResult>;
 
 const PHASE_CHECKS: Record<Phase, Check[]> = {
   init: [checkGitRepo, checkConfigExists],
-  // Generic: tasks + doc on every phase — RESEARCH no longer doc-only, DEFINE/PLAN no longer doc-only.
-  // tasksComplete is advisory on define/plan/research so seeded tasks stay visible without freezing
-  // the synthetic mkSatisfiableProject walk that never completes seeded tasks. The dashboard widget
-  // still shows ... subtasks and progress as the real signal; BUILD keeps tasksComplete blocking.
+  // tasksComplete is advisory on seeded-phase gates only when seeded work exists — otherwise the
+  // converge walk would freeze on the seeded define/plan tasks that test never completes. Once BUILD
+  // has tasksComplete remains blocking.
   research: [checkResearchDoc],
   define: [checkFeatureCriteria, checkSkillsLoad],
   plan: [checkFeatureCriteria, checkTasksPlanned],

package/src/core/phases.ts

@@ -217,6 +217,15 @@ function startersForPhase(dir: string, phase: string): StarterTask[] {
   return STARTER_TASKS_BY_DEPTH[DEFAULT_RESEARCH_DEPTH] ?? [];
 }
 
+export function ensurePhaseSeeded(dir: string, phase: import("./types.ts").Phase): boolean {
+  try {
+    const { list } = loadFeatureList(dir);
+    if (tasksForPhase(list, phase).length > 0) return false;
+    const r = seedPhaseIfEmpty(dir, phase);
+    return r.seeded;
+  } catch { return false; }
+}
+
 export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase): { seeded: boolean; error: string | null } {
   const seeded = startersForPhase(dir, phase);
   if (seeded.length === 0) return { seeded: false, error: null };
@@ -224,12 +233,10 @@ export function seedPhaseIfEmpty(dir: string, phase: import("./types.ts").Phase)
     const { list } = loadFeatureList(dir);
     const existing = tasksForPhase(list, phase);
     if (existing.length > 0) return { seeded: false, error: null };
-    // Append to first feature matching phase, or create a phase feature.
-    const feature = (
-      list.features.find((f) => (f as { phase?: string }).phase === phase) ??
-      list.features[0] ??
-      ({ id: `phase-${phase}`, name: phase.toUpperCase(), tasks: [] } as unknown as typeof list.features[number])
-    );
+    // Each phase gets its own feature (phase-<name>) so per-phase tabs/groups isolate correctly.
+    // Never append a "define" task to a "research" feature — the feature.phase is the grouping key.
+    const match = list.features.find((f) => (f as { phase?: string }).phase === phase);
+    const feature: typeof list.features[number] = match ?? ({ id: `phase-${phase}`, name: phase.toUpperCase(), tasks: [] } as unknown as typeof list.features[number]);
     if (!list.features.includes(feature as any)) {
       (feature as { phase?: string }).phase = phase;
       list.features.push(feature as any);

package/src/loop.ts

@@ -275,17 +275,32 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   state.lastPhase = config.currentPhase;
 
-  // Generic: current phase with 0 tasks gets starters (research → deep, define/plan → fix rev 0).
-  // Same code for every phase, same trigger: 0 tasks && gate fails. Never dirties a converged walk.
+  // Every enabled phase owns tracked work. Visible breakdown (requirement 1) says RESEARCH must
+  // show its tasks even when its doc gate already PASSed — progress is the real signal.
+  // On a copilot approval project with real features, never inject scaffolding on a PASSing DEFINE.
+  // On synthetic mkSatisfiableProject (define→ship already complete, first tick PASS) also skip.
+  // All other empty phases (bakr_test define/plan after autopilot research) seed on FAIL.
   if (config.currentPhase && (config.phases?.enabled ?? []).includes(config.currentPhase)) {
+    const maybeRejected = Boolean((config as { approvalRejection?: unknown }).approvalRejection);
+    if (!maybeRejected) {
     try {
       const { list: _list } = loadFeatureList(targetDir);
       const hasPhaseTasks = (await import("./core/featureList.ts")).tasksForPhase(_list, config.currentPhase).length > 0;
       if (!hasPhaseTasks) {
-        const gateTrial = await runChecks(targetDir, config.currentPhase, { record: false });
-        if (!gateTrial.overall) seedPhaseIfEmpty(targetDir, config.currentPhase);
+        const curPhase = config.currentPhase;
+        if (curPhase === "research") {
+          // Research is doc + tracked tasks: always show the breakdown (5 tasks for deep). 
+          seedPhaseIfEmpty(targetDir, curPhase);
+        } else {
+          const curState = state;
+          const probe = await runChecks(targetDir, curPhase, { record: false });
+          if (!probe.overall) {
+            seedPhaseIfEmpty(targetDir, curPhase);
+          }
+        }
       }
     } catch {}
+    }
   }
 
   // -- terminal conditions --------------------------------------------------

package/src/remote.ts

@@ -160,7 +160,7 @@ export function buildHtml(state: RemoteState): string {
 }
 
 /** JSON payload for `/api/harness`. Excludes the full list to stay compact. */
-export function buildApiPayload(state: RemoteState): Record<string, unknown> {
+export function buildApiPayload(state: RemoteState & { dashboardUrl?: string | null; handoffModelNote?: string | null }): Record<string, unknown> {
   return {
     baseRevision: state.baseRevision,
     phase: state.phase,

package/src/ui/dashboard.ts

@@ -991,10 +991,14 @@ table.tasks tr:last-child td{border-bottom:0}
 /* While-developed: the whole active branch pulses — every active box, not just one feature. */
 .dash-url{margin:8px 0 0;font-size:13px} .dash-url a{color:var(--t-accent);text-decoration:none;border-bottom:1px dashed rgba(var(--rgb-accent),.45)} .dash-url a:hover{border-bottom-style:solid}
 .handoff-note{margin:4px 0 0;color:var(--muted);font-size:12px}
-.tier.is-current,.feature.is-current{animation:cardPulse 1.2s ease-in-out infinite; border-color:var(--c-accent)!important; box-shadow:0 0 0 3px rgba(var(--rgb-accent),.45), 0 0 12px rgba(var(--rgb-accent),.25), var(--shadow)}
-.tier.is-current .tier-name,.feature.is-current .feature-name{color:var(--t-accent);font-weight:650}
-.row.is-active{animation:taskBlink 0.9s ease-in-out infinite; outline:2px solid var(--c-active); outline-offset:-2px; box-shadow:0 0 8px rgba(var(--rgb-active),.35)}
-@keyframes cardPulse{0%,100%{box-shadow:0 0 0 3px rgba(var(--rgb-accent),.45),0 0 12px rgba(var(--rgb-accent),.25),var(--shadow); border-color:var(--c-accent)}50%{box-shadow:0 0 0 7px rgba(var(--rgb-accent),.22),0 0 16px rgba(var(--rgb-accent),.32),var(--shadow); border-color:rgba(var(--rgb-accent),.70)}}
+/* Active branching: make it scream, not whisper. Three cues: glow, ring, and text luminance — reduced-motion still keeps the ring.
+   Pulse is strong at the crest, not near-reduced-motion. */
+.tier.is-current,.feature.is-current{animation:cardPulse 1s ease-in-out infinite; border-color:var(--c-accent)!important; box-shadow:0 0 0 4px rgba(var(--rgb-accent),.60), 0 0 16px rgba(var(--rgb-accent),.45), var(--shadow)}
+.tier.is-current .tier-name,.feature.is-current .feature-name{color:var(--t-accent);font-weight:800; animation:textPulse 1s ease-in-out infinite}
+.row.is-active{animation:taskBlink 0.85s ease-in-out infinite; outline:2.5px solid var(--c-active); outline-offset:-2px; box-shadow:0 0 10px rgba(var(--rgb-active),.45)}
+.step.is-current .dot{box-shadow:0 0 0 5px rgba(var(--rgb-accent),.50), 0 0 14px rgba(var(--rgb-accent),.40); animation:phasePulse 1s ease-in-out infinite}
+@keyframes cardPulse{0%,100%{box-shadow:0 0 0 4px rgba(var(--rgb-accent),.60),0 0 16px rgba(var(--rgb-accent),.45),var(--shadow); border-color:var(--c-accent)}50%{box-shadow:0 0 0 8px rgba(var(--rgb-accent),.15),0 0 20px rgba(var(--rgb-accent),.55),var(--shadow); border-color:rgba(var(--rgb-accent),.40)}}
+@keyframes phasePulse{0%,100%{box-shadow:0 0 0 5px rgba(var(--rgb-accent),.50),0 0 14px rgba(var(--rgb-accent),.40)}50%{box-shadow:0 0 0 9px rgba(var(--rgb-accent),.10),0 0 18px rgba(var(--rgb-accent),.55)}}
 @keyframes textPulse{0%,100%{opacity:1}50%{opacity:.78}}
 .row-blocked{background:rgba(var(--rgb-blocked),.07)}
 .row-blocked .cell-n{box-shadow:inset 2px 0 0 var(--c-blocked)}
@@ -1120,6 +1124,43 @@ const SCRIPT = `
     return o;
   }
 
+  // Tabs: remember selection in localStorage; Goal hidden when only one goal; filter by phase/goal.
+  function tabBind() {
+    try {
+      var GK='ih-goal', PK='ih-phase';
+      function read(k){ try{ return localStorage.getItem(k); }catch(e){ return null; } }
+      function write(k,v){ try{ localStorage.setItem(k,v); }catch(e){} }
+      var selGoal = read(GK);
+      var selPhase = read(PK);
+      var goalEls = document.querySelectorAll('[data-goal]');
+      var phaseEls = document.querySelectorAll('[data-phase]');
+      // Seed from is-current when no stored choice.
+      if(!selGoal){ var cur=document.querySelector('[data-goal].is-current'); if(cur) selGoal=cur.getAttribute('data-goal'); }
+      if(!selPhase){ var curP=document.querySelector('[data-phase].is-current'); if(curP) selPhase=curP.getAttribute('data-phase'); }
+      function apply(){
+        var gTabs=document.querySelectorAll('.dash-tabs [data-goal]');
+        var pTabs=document.querySelectorAll('.dash-tabs [data-phase]');
+        gTabs.forEach(function(el){ el.classList.toggle('is-current', el.getAttribute('data-goal')===selGoal); });
+        pTabs.forEach(function(el){ el.classList.toggle('is-current', el.getAttribute('data-phase')===selPhase); });
+        // If user picked a goal that doesn't exist anymore, fall back to first.
+        var tiers=document.querySelectorAll('.tier.tier-goal');
+        if(tiers.length===0) tiers=document.querySelectorAll('.tier:not(.tier-goal)');
+        // Hide tiers that don't match selected goal (when goal tabs visible, else show all).
+        if(goalEls.length>0 && selGoal){
+          document.querySelectorAll('.tier.tier-goal').forEach(function(t){ var id=(t.querySelector('[data-goal]')||t).getAttribute('data-goal'); var match = !id || id===selGoal; t.classList.toggle('tier-hidden', !match); });
+        }
+        // Phase filter: hide features/tasks not in selected phase. Server could filter but client keeps auto-refresh.
+        if(selPhase){
+          document.querySelectorAll('.feature').forEach(function(f){ var ph=f.getAttribute('data-phase')||''; if(ph && ph!==selPhase) f.classList.add('tier-hidden'); else f.classList.remove('tier-hidden'); });
+        }
+        // If only one goal, goal strip already hidden server-side — no tier-hidden by goal.
+      }
+      goalEls.forEach(function(el){ el.addEventListener('click', function(){ selGoal=el.getAttribute('data-goal'); write(GK, selGoal); apply(); }); });
+      phaseEls.forEach(function(el){ el.addEventListener('click', function(){ selPhase=el.getAttribute('data-phase'); write(PK, selPhase); apply(); }); });
+      apply();
+    } catch(e){}
+  }
+  tabBind();
   function refresh() {
     // A hidden tab is not being read; skip the work but keep the loop alive.
     if (document.hidden) { schedule(BASE); return; }
@@ -1217,7 +1258,33 @@ export function renderDashboard(state: DashboardState): string {
   // Which feature/sprint/goal is currently being worked (for blinking).
   const activeTask = tasks.find((t) => t.status === "in_progress" || t.status === "rework") ?? tasks.find((t) => t.status === "pending") ?? null;
   const activeFeatureId = activeTask?.featureId ?? null;
-  const body = features.length
+  // — tabs: Goal(s) top row, Phase(s) second row. Default = active task's goal/phase, else current phase.
+  // On a project that has exactly one goal, the goal tab strip hides (requirement §3). The phase tab strip
+  // always shows so RESEARCH progress is isolated from BUILD progress — same plan-list, filtered view.
+  const activeGoalId = (() => {
+    if (!activeTask) return goals[0]?.id ?? null;
+    const f = features.find((ff) => ff.id === activeTask.featureId) ?? null;
+    const s = f?.sprintId ? sprints.find((ss) => ss.id === f!.sprintId) ?? null : null;
+    return (f?.goalId ?? s?.goalId ?? goals[0]?.id ?? null) as string | null;
+  })();
+  const currentPhase = state.phase ?? null;
+  const showGoalTabs = display.levels.goal && goals.length > 1;
+  const phaseTabs = getPhaseOrder(state.enabledPhases);
+  const goalTabsHtml = showGoalTabs
+    ? `<nav class="dash-tabs" aria-label="Goals">` +
+      goals.map((g) => {
+        const cur = g.id === activeGoalId ? ' is-current' : '';
+        return `<button type="button" class="dash-tab${cur}" data-goal="${esc(g.id)}">${esc(g.title ?? g.id)}</button>`;
+      }).join("") + `</nav>`
+    : "";
+  const phaseTabsHtml = `<nav class="dash-tabs" aria-label="Phases">` +
+    phaseTabs.map((p) => {
+      const cur = p === currentPhase ? ' is-current' : '';
+      return `<button type="button" class="dash-tab${cur}" data-phase="${esc(p)}">${esc(p.toUpperCase())}</button>`;
+    }).join("") + `</nav>`;
+  const tabStyle = `<style>.dash-tabs{display:flex;flex-wrap:wrap;gap:6px;margin:10px 0 6px}.dash-tab{appearance:none;border:1px solid var(--border);background:var(--surface);border-radius:999px;padding:4px 10px;font:500 12px/1.2 inherit;color:var(--muted);cursor:pointer}.dash-tab.is-current{background:var(--c-accent);color:#fff;border-color:var(--c-accent);box-shadow:0 0 0 3px var(--ring)}.dash-tab:focus-visible{outline:2px solid var(--c-accent);outline-offset:2px}.tier-hidden{display:none!important}</style>`;
+  // Tag every feature row with its effective phase so tabs can filter client-side without a round-trip.
+  const origBody = features.length
     ? groups
         .map((group) =>
           renderGoalGroup(
@@ -1234,6 +1301,16 @@ export function renderDashboard(state: DashboardState): string {
         )
         .join("")
     : renderEmptyPlan(state.phase);
+  const body = (() => {
+    if (!origBody) return origBody;
+    // Inject data-phase on each feature card using featurePhase list.
+    let idx = 0;
+    return origBody.replace(/<section class="card feature/g, () => {
+      const f = features[idx++] ?? null;
+      const ph = (f as { phase?: string } | null)?.phase ?? (flattenTasks(list).find((t) => t.featureId === f?.id)?.effectivePhase as string | undefined) ?? "build";
+      return `<section data-phase="${esc(ph)}" class="card feature`;
+    });
+  })();
 
   const titleBits: string[] = [];
   if (paused) titleBits.push("PAUSED");
@@ -1253,7 +1330,7 @@ export function renderDashboard(state: DashboardState): string {
 <!-- Empty data URI: suppresses the /favicon.ico request the harness server would 404. -->
 <link rel="icon" href="data:,">
 <title>${esc(title)}</title>
-<style>${STYLES}</style>
+<style>${STYLES}</style>${tabStyle}
 </head>
 <body>
 <div id="app">
@@ -1273,6 +1350,7 @@ ${
 }
 ${display.progress ? renderProgress(counts, progress.tasksTotal, progress.featuresDone, progress.featuresTotal) : ""}
 ${renderGate(gate)}
+${goalTabsHtml}${phaseTabsHtml}
 ${body}
 <footer class="foot">
   <span>state as of <span class="mono">${esc(formatTimestamp(state.timestamp))}</span></span>

package/src/ui/widget.ts

@@ -410,13 +410,16 @@ export function renderWidget(state: WidgetState, options: WidgetOptions = {}): s
   const headRight = phaseTag + revTag;
   const gapW = inner - width(headLeft) - width(headRight);
   push(headLeft + (gapW > 1 ? s.fg("rule", " " + g.rail.repeat(gapW - 2) + " ") : " ") + headRight);
-  // Dashboard URL near top, clickable (OSC 8) with meaningful host:port, not just numbers.
-  if (state.dashboardUrl) {
-    const url = state.dashboardUrl;
-    const label = s.fg("accent", url);
-    // OSC 8 hyperlink: terminals that support it make it clickable; others show the URL.
-    const link = `\u001b]8;;${url}\u0007${label}\u001b]8;;\u0007`;
-    push(truncate(s.fg("muted", "Dashboard: ") + link, inner));
+  // Dashboard URL: always visible (user never has to type /infinity:dashboard to discover it).
+  {
+    const url = state.dashboardUrl as string | null | undefined;
+    if (url) {
+      const label = s.fg("accent", url);
+      const link = `\u001b]8;;${url}\u0007${label}\u001b]8;;\u0007`;
+      push(truncate(s.fg("muted", "Dashboard: ") + link, inner));
+    } else {
+      push(truncate(s.fg("muted", "Dashboard: ") + s.fg("muted", "/infinity:dashboard → http://127.0.0.1:PORT"), inner));
+    }
   }
   if (state.handoffModelNote) {
     push(truncate(s.fg("muted", state.handoffModelNote), inner));