@synap-core/cli 1.13.0 → 1.13.1-next.20261102.246dc73

package/dist/commands/statusline.js

@@ -1,18 +1,33 @@
 /**
- * synap statusline — full 3-line ANSI status for the Claude Code statusLine.
+ * synap statusline — full 4-line ANSI status for the Claude Code statusLine.
  *
  * Two modes, both via `synap statusline`:
  *
  *   RENDER (default)   Parse the Claude Code JSON from stdin, read the pod
- *                      cache file (NO network), compose 3 ANSI lines, print,
- *                      exit. Always instant. If the cache is stale it spawns a
- *                      detached refresh (fire-and-forget) so the NEXT render is
- *                      fresh — this render never blocks on the network.
+ *                      cache files and local state (NO network), compose 4
+ *                      ANSI lines, print, exit. Always instant. If a cache is
+ *                      stale it spawns a detached refresh (fire-and-forget) so
+ *                      the NEXT render is fresh — this render never blocks on
+ *                      the network.
  *
- *   REFRESH (--refresh) Fetch pod data in a single parallel burst and write the
- *                      cache. Lock-guarded so only one refresh runs at a time.
- *                      On error/429, the last good cache is preserved (the dot
- *                      goes stale, not blank).
+ *   REFRESH (--refresh) Fetch pod data in parallel bursts and write the caches.
+ *                      Lock-guarded so only one refresh of each cache runs at a
+ *                      time. On error/429, the last good cache is preserved
+ *                      (the dot goes stale, not blank). Also catches the
+ *                      conversation's transcript index up (local, no network).
+ *
+ * Two pod caches: the pod-WIDE fields (workspaces, skills, needs-you, identity,
+ * entity totals) in ONE shared file, refreshed at most once per REFRESH_TTL
+ * whatever the number of conversations; the CONVERSATION's own fields (its lens
+ * workspace, bound session, project) in a file per Claude Code session id, so
+ * a conversation never shows the session another conversation refreshed last
+ * (each one used to, when all of it lived in the one shared file).
+ *
+ * The 4th line says what the conversation is doing now and what it waits on:
+ * first from the synap-bridge plugin's per-conversation status file (what the
+ * pod says, lib/bridge-status.ts), else from Claude Code's process registry,
+ * the transcript index (lib/transcript-index.ts) and `synap wait` state files
+ * (lib/now-line.ts) — all local files.
  *
  * Why: Claude Code calls the statusline on every render (debounced ~300ms +
  * periodic refresh). Fetching live pod data synchronously per render hammers
@@ -21,34 +36,40 @@
  */
 import fs from "node:fs";
 import os from "node:os";
-import { execSync, spawn } from "node:child_process";
+import path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
 import { resolveHubConfig, hubGet } from "../lib/hub-client.js";
 import { resolveActiveLens } from "../lib/session-lens.js";
 import { describeLens } from "../lib/describe-lens.js";
 import { getSurfaceAgentKey, SURFACE_NAMES } from "../lib/pod.js";
-const CACHE_FILE = "/tmp/synap-statusline-cache.json";
+import { age, buildNowLine, readRegistry } from "../lib/now-line.js";
+import { buildBridgeLine, readBridgeStatus } from "../lib/bridge-status.js";
+import { defaultTranscriptPath, indexLockPath, loadIndex, saveIndex, updateIndex, } from "../lib/transcript-index.js";
+import { pidAlive, pruneWaits, readWaits } from "../lib/wait-state.js";
+import { BOLD_BLUE as BB, BOLD_GREEN as G, BOLD_RED as R, BOLD_YELLOW as Y, CYAN as C, DIM as D, MAGENTA as M, RESET as X, osc8, safeText, } from "../lib/term.js";
+const CACHE_FILE = "/tmp/synap-statusline-cache.json"; // pod-wide fields, shared by every conversation
 const LOCK_FILE = "/tmp/synap-statusline-refresh.lock";
+/** A session id as a file-name part. */
+function convKey(claudeSessionId) {
+    return (claudeSessionId ?? "").replace(/[^A-Za-z0-9_-]/g, "") || "_nosession";
+}
+export function convCacheFile(claudeSessionId) {
+    return `/tmp/synap-statusline-conv-${convKey(claudeSessionId)}.json`;
+}
+function convLockFile(claudeSessionId) {
+    return `/tmp/synap-statusline-conv-${convKey(claudeSessionId)}.lock`;
+}
+/** Render reads at most this many new transcript bytes; more is left to the detached refresh. */
+const RENDER_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
 // The pod sits behind a strict edge rate-limiter (15-min window) shared with
 // the agent's own traffic on the same key. Keep statusline cost minimal:
 // refresh at most once per 120s; the burst is ~4-6 GETs (workspaces, skills,
-// session, proposals, + conditional project/identity). Fold new fields into an
+// session, needs-you, + conditional project/identity). Fold new fields into an
 // existing call rather than adding to the burst.
 const REFRESH_TTL_MS = 120_000;
 const LOCK_STALE_MS = 30_000; // a lock older than this is considered dead
-// ── ANSI + OSC 8 helpers ───────────────────────────────────────────────
-const G = "\x1b[01;32m"; // green bold
-const Y = "\x1b[01;33m"; // yellow bold
-const R = "\x1b[01;31m"; // red bold
-const C = "\x1b[36m"; // cyan
-const BB = "\x1b[01;34m"; // bold blue — used for the pinned PROJECT (prominence)
-const M = "\x1b[35m"; // magenta
-const D = "\x1b[2m"; // dim
-const X = "\x1b[0m"; // reset
-function osc8(url, text) {
-    if (!url)
-        return text;
-    return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
-}
+// ── Colour helpers (codes and OSC 8 in lib/term.ts) ────────────────────
+// BB, bold blue, is the pinned PROJECT's colour (prominence).
 function ctxColor(pct) {
     if (pct >= 80)
         return R;
@@ -74,10 +95,13 @@ function compact(n) {
         return `${(n / 1000).toFixed(0)}K`;
     return String(n);
 }
+function emptyConv() {
+    return { ts: 0, attemptedTs: 0, ok: false, podUrl: "", activeWorkspaceId: "", projectName: "", projectId: "", sessionGoal: "", sessionId: "" };
+}
 function emptyCache() {
     return {
         ts: 0, attemptedTs: 0, ok: false, podUrl: "", activeWorkspaceId: "", workspaces: [], projectName: "", projectId: "",
-        skillCount: 0, proposalCount: 0, proposalsFetched: false, sessionGoal: "", sessionId: "", totalEntities: 0,
+        skillCount: 0, needsYouCount: 0, needsYouTruncated: false, needsYouFetched: false, sessionGoal: "", sessionId: "", totalEntities: 0,
         actingAgentLabel: "", identityMismatch: false,
     };
 }
@@ -89,33 +113,55 @@ function findSurfaceLabelForKey(hubApiKey) {
     }
     return null;
 }
-function readCache() {
+function readJson(file) {
     try {
-        return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+        return JSON.parse(fs.readFileSync(file, "utf-8"));
     }
     catch {
         return null;
     }
 }
+/** Missing, or its last attempt is older than the TTL. The backoff clock is the last ATTEMPT, not the last success (see PodCache). */
+function isDue(c) {
+    return !c || Date.now() - (c.attemptedTs ?? c.ts) > REFRESH_TTL_MS;
+}
 // ── Detached refresh trigger (fire-and-forget) ─────────────────────────
-function lockIsFresh() {
+function lockIsFresh(file = LOCK_FILE) {
     try {
-        return Date.now() - fs.statSync(LOCK_FILE).mtimeMs < LOCK_STALE_MS;
+        return Date.now() - fs.statSync(file).mtimeMs < LOCK_STALE_MS;
     }
     catch {
         return false;
     }
 }
-function triggerRefresh(claudeSessionId) {
-    if (lockIsFresh())
-        return; // a refresh is already running
+function takeLock(file) {
+    if (lockIsFresh(file))
+        return false; // another refresh owns the window
+    try {
+        fs.writeFileSync(file, String(process.pid));
+    }
+    catch {
+        /* ignore */
+    }
+    return true;
+}
+function dropLock(file) {
+    try {
+        fs.unlinkSync(file);
+    }
+    catch { }
+}
+function triggerRefresh(claudeSessionId, transcriptPath) {
     try {
         const entry = process.argv[1]; // the CLI entry script
         // The detached refresh has no Claude env of its own — forward the session
-        // id (from stdin) so its resolveHubConfig/lens picks the right workspace.
-        const env = claudeSessionId
-            ? { ...process.env, SYNAP_LENS_SESSION: claudeSessionId }
-            : process.env;
+        // id (from stdin) so its resolveHubConfig/lens picks the right workspace,
+        // and the transcript path so it can catch the index up.
+        const env = { ...process.env };
+        if (claudeSessionId)
+            env.SYNAP_LENS_SESSION = claudeSessionId;
+        if (transcriptPath)
+            env.SYNAP_STATUSLINE_TRANSCRIPT = transcriptPath;
         const child = spawn(process.execPath, [entry, "statusline", "--refresh"], {
             detached: true,
             stdio: "ignore",
@@ -128,45 +174,89 @@ function triggerRefresh(claudeSessionId) {
     }
 }
 // ── REFRESH mode: fetch pod, write cache (lock-guarded) ────────────────
-async function refresh() {
-    if (lockIsFresh())
-        return; // another refresh owns the window
+/** The conversation this process serves: forwarded by render as SYNAP_LENS_SESSION. */
+function refreshSessionId() {
+    return process.env.SYNAP_LENS_SESSION || process.env.CLAUDE_CODE_SESSION_ID || undefined;
+}
+/**
+ * Catch the transcript index up (local files only), streaming: render reads at
+ * most RENDER_TRANSCRIPT_BYTES, so the first scan of a big transcript happens
+ * here. Also prunes this conversation's finished `synap wait` files.
+ */
+function catchUpTranscript(claudeSessionId) {
+    const transcriptPath = process.env.SYNAP_STATUSLINE_TRANSCRIPT;
+    if (!claudeSessionId)
+        return;
     try {
-        fs.writeFileSync(LOCK_FILE, String(process.pid));
+        pruneWaits(claudeSessionId);
+    }
+    catch { }
+    if (!transcriptPath)
+        return;
+    const lock = indexLockPath(claudeSessionId);
+    try {
+        fs.mkdirSync(path.dirname(lock), { recursive: true });
+    }
+    catch { }
+    if (!takeLock(lock))
+        return;
+    try {
+        const { index, changed } = updateIndex(loadIndex(claudeSessionId), transcriptPath, { maxBytes: Infinity });
+        if (changed)
+            saveIndex(claudeSessionId, index);
     }
     catch {
-        /* ignore */
+        /* the index is a display aid: the next render retries */
+    }
+    finally {
+        dropLock(lock);
+    }
+}
+async function refresh() {
+    const claudeSessionId = refreshSessionId();
+    catchUpTranscript(claudeSessionId);
+    const convFile = convCacheFile(claudeSessionId);
+    const convLock = convLockFile(claudeSessionId);
+    const prevShared = readJson(CACHE_FILE);
+    const prevConv = readJson(convFile);
+    // Each cache is fetched only when IT is due and nobody else is fetching it:
+    // N conversations share one pod-wide burst per TTL, plus their own 1–2 GETs.
+    const doShared = isDue(prevShared) && takeLock(LOCK_FILE);
+    const doConv = isDue(prevConv) && takeLock(convLock);
+    if (!doShared && !doConv)
+        return;
+    try {
+        const cfg = await resolveHubConfig({}).catch(() => null);
+        await Promise.all([
+            doShared ? refreshShared(cfg, prevShared) : null,
+            doConv ? refreshConv(cfg, prevConv, convFile) : null,
+        ]);
+    }
+    finally {
+        if (doShared)
+            dropLock(LOCK_FILE);
+        if (doConv)
+            dropLock(convLock);
     }
-    const prev = readCache();
+}
+/**
+ * The needs-you number out of a `GET /needs-you` body: `count.needsYou` is THE
+ * rule's headline. Anything else (no `count`, a non-number) is null = not
+ * measured, never 0.
+ */
+export function parseNeedsYouCount(body) {
+    const c = body?.count;
+    if (typeof c?.needsYou !== "number" || !Number.isFinite(c.needsYou))
+        return null;
+    return { count: c.needsYou, truncated: c.truncated === true };
+}
+/** The pod-wide burst: workspaces (doubling as liveness), skills, identity, proposals. */
+async function refreshShared(cfg, prev) {
     try {
-        const cfg = await resolveHubConfig({});
         // Thrown, not returned: the catch below stamps the attempt, so an
         // unconfigured CLI also backs off instead of respawning every render.
-        if (!cfg.podUrl || !cfg.apiKey)
+        if (!cfg?.podUrl || !cfg.apiKey)
             throw new Error("statusline: no pod config");
-        // This connection's per-Claude-session lens (forwarded as SYNAP_LENS_SESSION
-        // by the render process). Drives WHICH project/session we show — the bound
-        // ones, not a global guess.
-        const lens = resolveActiveLens();
-        // Minimal burst (the pod's edge limiter is shared with agent traffic).
-        // `/workspaces` succeeding doubles as the liveness signal — no separate
-        // `/health`. The bound focus-session and project are fetched by id only
-        // when the lens has them (0–2 extra calls).
-        const sessionReq = lens?.focusSessionId
-            ? hubGet(`/focus-sessions/${lens.focusSessionId}`, cfg.workspaceId ? { workspaceId: cfg.workspaceId } : {}, cfg)
-            : hubGet("/focus-sessions?status=active&limit=1", {}, cfg);
-        // Use the FULLY-RESOLVED project id (cfg.projectId = session-lens ?? env ??
-        // durable activeProjectId), NOT just the session lens — so a durable
-        // `synap project use` shows even in a fresh session with no lens file yet.
-        // Mirrors how activeWorkspaceId already uses cfg.workspaceId below.
-        const resolvedProjectId = cfg.projectId;
-        // Resolve the NAME via the single-project route. `GET /projects` returns a
-        // bare array and ignores `?ids=` (only status/limit) — the old call read a
-        // nonexistent `.projects` field, so the name never resolved and the line
-        // showed the raw UUID. `/projects/:id` returns the row directly ({id,name}).
-        const projectReq = resolvedProjectId
-            ? hubGet(`/projects/${encodeURIComponent(resolvedProjectId)}`, {}, cfg)
-            : Promise.resolve(null);
         // Identity safety: compare the AMBIENT SYNAP_HUB_API_KEY against the
         // claude-code surface key pinned to this pod. A cheap string compare
         // covers the common case (no pod call). Only when they diverge do we pay
@@ -182,19 +272,19 @@ async function refresh() {
         const identityReq = needsIdentityCheck
             ? hubGet("/users/me", {}, { podUrl: cfg.podUrl, apiKey: ambientKey, userId: "cli" })
             : Promise.resolve(null);
-        // Pending proposals — the one actionable ambient signal. No dedicated
-        // count endpoint exists yet (verified: `/proposals` returns `{ proposals: [] }`,
-        // no `total`); a high `limit` on the pending-only list is the cheapest
-        // accurate count within the burst budget (a personal pod won't realistically
-        // clear 1000 pending proposals before this undercounts).
-        const proposalsReq = hubGet("/proposals", { status: "pending", limit: 1000 }, cfg);
-        const [ws, skills, session, project, identity, proposals] = await Promise.allSettled([
+        // Needs you — the one actionable ambient signal, counted by the pod's own
+        // rule (`GET /needs-you`, `signals.needsYou`; decision E): the same number
+        // the badge shows, never re-derived from the pending-proposal list. `limit=1`
+        // trims the rows (we read only `count`).
+        const needsYouReq = hubGet("/needs-you", { limit: 1 }, cfg);
+        // Minimal burst (the pod's edge limiter is shared with agent traffic).
+        // `/workspaces` succeeding doubles as the liveness signal — no separate
+        // `/health`.
+        const [ws, skills, identity, needsYou] = await Promise.allSettled([
             hubGet("/workspaces", {}, cfg),
             hubGet("/agent-skills?limit=1", {}, cfg),
-            sessionReq,
-            projectReq,
             identityReq,
-            proposalsReq,
+            needsYouReq,
         ]);
         // Reached the pod iff /workspaces returned a well-formed payload.
         const ok = ws.status === "fulfilled" && Array.isArray(ws.value?.workspaces);
@@ -208,26 +298,6 @@ async function refresh() {
             totalEntities += w.entityCount ?? 0;
         }
         const skillCount = skills.status === "fulfilled" ? (skills.value?.total ?? 0) : prev?.skillCount ?? 0;
-        // Bound session — either the by-id fetch (object) or the active-list fallback.
-        let sessionGoal = prev?.sessionGoal ?? "";
-        let sessionId = prev?.sessionId ?? "";
-        if (session.status === "fulfilled" && session.value) {
-            const v = session.value;
-            const s = v.sessions ? v.sessions[0] : v; // list-shape vs object-shape
-            sessionGoal = s?.goal?.slice(0, 60) ?? "";
-            sessionId = s?.id ?? "";
-        }
-        else if (lens?.focusSessionId) {
-            sessionGoal = "";
-            sessionId = "";
-        }
-        // Bound project (from the fully-resolved id — durable or session).
-        let projectName = resolvedProjectId ? prev?.projectName ?? "" : "";
-        let projectId = resolvedProjectId ?? "";
-        if (project.status === "fulfilled" && project.value) {
-            const p = project.value?.projects?.find((x) => x.id === resolvedProjectId);
-            projectName = p?.name?.slice(0, 30) ?? "";
-        }
         // Acting identity: clean unless we detected a real divergence.
         let actingAgentLabel = "";
         let identityMismatch = false;
@@ -238,29 +308,25 @@ async function refresh() {
                 actingAgentLabel = (ambientKey && findSurfaceLabelForKey(ambientKey)) || actingId.slice(0, 8);
             }
         }
-        // Only a well-shaped array counts as "fetched" — a malformed 200 must not
-        // masquerade as "0 pending"; it falls back to the last-good count instead.
-        const proposalsRaw = proposals.status === "fulfilled"
-            ? proposals.value?.proposals
-            : undefined;
-        const proposalsFetched = Array.isArray(proposalsRaw);
-        const proposalCount = Array.isArray(proposalsRaw)
-            ? proposalsRaw.length
-            : prev?.proposalCount ?? 0;
+        // A failed or malformed read keeps the last-good count AND its time, and
+        // says it failed (`needsYouOk: false`): render then shows it as old, never
+        // as fresh. Only a well-shaped `count` is a measurement.
+        const read = needsYou.status === "fulfilled" ? parseNeedsYouCount(needsYou.value) : null;
+        const needsYouCount = read ? read.count : prev?.needsYouCount ?? 0;
+        const needsYouTruncated = read ? read.truncated : prev?.needsYouTruncated ?? false;
+        const needsYouAt = read ? Date.now() : prev?.needsYouAt ?? 0;
         const out = {
             ts: Date.now(),
             attemptedTs: Date.now(),
             ok: true,
             podUrl: cfg.podUrl,
-            activeWorkspaceId: cfg.workspaceId ?? "", // the lens THIS connection resolves to
             workspaces,
-            projectName,
-            projectId,
             skillCount,
-            proposalCount,
-            proposalsFetched: proposalsFetched || (prev?.proposalsFetched ?? false),
-            sessionGoal,
-            sessionId,
+            needsYouCount,
+            needsYouTruncated,
+            needsYouFetched: read !== null || (prev?.needsYouFetched ?? false),
+            needsYouAt,
+            needsYouOk: read !== null,
             totalEntities,
             actingAgentLabel,
             identityMismatch,
@@ -279,14 +345,114 @@ async function refresh() {
         }
         catch { }
     }
-    finally {
+}
+/** This conversation's own fields: its lens workspace, bound session and project (0–2 GETs). */
+async function refreshConv(cfg, prev, file) {
+    try {
+        if (!cfg?.podUrl || !cfg.apiKey)
+            throw new Error("statusline: no pod config");
+        // This connection's per-Claude-session lens (forwarded as SYNAP_LENS_SESSION
+        // by the render process). Drives WHICH project/session we show — the bound
+        // ones, not a global guess.
+        const lens = resolveActiveLens();
+        // The bound focus-session and project are fetched by id only when the
+        // lens has them.
+        const sessionReq = lens?.focusSessionId
+            ? hubGet(`/focus-sessions/${lens.focusSessionId}`, cfg.workspaceId ? { workspaceId: cfg.workspaceId } : {}, cfg)
+            : hubGet("/focus-sessions?status=active&limit=1", {}, cfg);
+        // Use the FULLY-RESOLVED project id (cfg.projectId = session-lens ?? env ??
+        // durable activeProjectId), NOT just the session lens — so a durable
+        // `synap project use` shows even in a fresh session with no lens file yet.
+        // Mirrors how activeWorkspaceId already uses cfg.workspaceId below.
+        const resolvedProjectId = cfg.projectId;
+        // Resolve the NAME via the single-project route. `GET /projects` returns a
+        // bare array and ignores `?ids=` (only status/limit) — the old call read a
+        // nonexistent `.projects` field, so the name never resolved and the line
+        // showed the raw UUID. `/projects/:id` returns the row directly ({id,name}).
+        const projectReq = resolvedProjectId
+            ? hubGet(`/projects/${encodeURIComponent(resolvedProjectId)}`, {}, cfg)
+            : Promise.resolve(null);
+        const [session, project] = await Promise.allSettled([sessionReq, projectReq]);
+        // The session read is this cache's liveness signal (as `/workspaces` is the
+        // shared one's): a 429 or a 5xx keeps the last good values (the catch
+        // stamps the attempt). Only a 404 on the bound session means it is gone.
+        const sessionGone = session.status === "rejected" && session.reason?.status === 404;
+        if (session.status === "rejected" && !sessionGone)
+            throw session.reason;
+        // Bound session — either the by-id fetch (object) or the active-list fallback.
+        let sessionGoal = prev?.sessionGoal ?? "";
+        let sessionId = prev?.sessionId ?? "";
+        if (session.status === "fulfilled" && session.value) {
+            const v = session.value;
+            const s = v.sessions ? v.sessions[0] : v; // list-shape vs object-shape
+            sessionGoal = s?.goal?.slice(0, 60) ?? "";
+            sessionId = s?.id ?? "";
+        }
+        else if (lens?.focusSessionId) {
+            sessionGoal = "";
+            sessionId = "";
+        }
+        // Bound project (from the fully-resolved id — durable or session).
+        let projectName = resolvedProjectId ? prev?.projectName ?? "" : "";
+        const projectId = resolvedProjectId ?? "";
+        if (project.status === "fulfilled" && project.value) {
+            // The single-row route answers the row itself ({ id, name, … }).
+            const name = project.value.name;
+            projectName = typeof name === "string" ? name.slice(0, 30) : "";
+        }
+        const out = {
+            ts: Date.now(),
+            attemptedTs: Date.now(),
+            ok: true,
+            podUrl: cfg.podUrl,
+            activeWorkspaceId: cfg.workspaceId ?? "", // the lens THIS connection resolves to
+            projectName,
+            projectId,
+            sessionGoal,
+            sessionId,
+        };
+        fs.writeFileSync(file, JSON.stringify(out));
+    }
+    catch {
+        // Same backoff as the shared cache: keep the last good values, stamp the attempt.
         try {
-            fs.unlinkSync(LOCK_FILE);
+            fs.writeFileSync(file, JSON.stringify({ ...(prev ?? emptyConv()), ok: false, attemptedTs: Date.now() }));
         }
         catch { }
     }
 }
-// ── RENDER mode: stdin + cache → 3 lines (no network) ──────────────────
+// ── RENDER mode: stdin + caches + local state → 4 lines (no network) ───
+/**
+ * This conversation's transcript index, brought up to date with what was
+ * appended since the last render — at most RENDER_TRANSCRIPT_BYTES: a bigger
+ * backlog (the first look at a long conversation) is left to the detached
+ * refresh, and this render shows the index as it is. Returns whether that
+ * backlog is waiting.
+ */
+function currentIndex(claudeSessionId, transcriptPath) {
+    try {
+        const { index, changed, behind } = updateIndex(loadIndex(claudeSessionId), transcriptPath, { maxBytes: RENDER_TRANSCRIPT_BYTES });
+        if (changed) {
+            try {
+                saveIndex(claudeSessionId, index);
+            }
+            catch { }
+        }
+        return { index, behind: behind > 0 };
+    }
+    catch {
+        return { index: null, behind: false };
+    }
+}
+/** Terminal width when Claude Code (or the shell) says it; the now line caps itself to it. */
+function widthOf(cc) {
+    for (const v of [cc.terminal_width, cc.columns, cc.terminal?.columns, process.env.COLUMNS]) {
+        const n = Number(v);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return undefined;
+}
 function render() {
     let cc = {};
     try {
@@ -298,12 +464,38 @@ function render() {
     // The Claude session id — forwarded to the detached refresh so it resolves
     // THIS session's lens (workspace/project/session), not a global guess.
     const claudeSessionId = cc.session_id || process.env.CLAUDE_CODE_SESSION_ID;
-    const cache = readCache();
-    // Trigger a background refresh if cache is missing or stale.
-    // The backoff clock is the last ATTEMPT, not the last success (see PodCache).
-    if (!cache || Date.now() - (cache.attemptedTs ?? cache.ts) > REFRESH_TTL_MS)
-        triggerRefresh(claudeSessionId);
-    const pod = cache ?? emptyCache();
+    const cwd = (cc.cwd ?? "");
+    const transcriptPath = (typeof cc.transcript_path === "string" && cc.transcript_path) ||
+        (cwd && claudeSessionId ? defaultTranscriptPath(cwd, claudeSessionId) : "");
+    const shared = readJson(CACHE_FILE);
+    const conv = readJson(convCacheFile(claudeSessionId));
+    const { index, behind } = claudeSessionId && transcriptPath ? currentIndex(claudeSessionId, transcriptPath) : { index: null, behind: false };
+    // Trigger a background refresh if a cache is missing or stale, or the
+    // transcript backlog is too big for a render — unless that refresh is
+    // already running.
+    if ((isDue(shared) && !lockIsFresh(LOCK_FILE)) ||
+        (isDue(conv) && !lockIsFresh(convLockFile(claudeSessionId))) ||
+        (behind && claudeSessionId && !lockIsFresh(indexLockPath(claudeSessionId))))
+        triggerRefresh(claudeSessionId, transcriptPath);
+    // Pod-wide fields from the shared cache; the conversation's own ONLY from its
+    // file — a shared cache written by an older CLI carries another
+    // conversation's session and project, which must not show here.
+    const c = conv ?? emptyConv();
+    const base = { ...emptyCache(), ...(shared ?? {}) };
+    // Every pod string is scrubbed of control characters here, before any of it
+    // reaches the terminal (lib/term.ts): a name holding ESC or OSC 8 would
+    // otherwise recolour the line or plant a link of its own.
+    const pod = {
+        ...base,
+        workspaces: (Array.isArray(base.workspaces) ? base.workspaces : []).map((w) => ({ ...w, name: safeText(String(w.name ?? "")) })),
+        actingAgentLabel: safeText(String(base.actingAgentLabel ?? "")),
+        activeWorkspaceId: safeText(String(c.activeWorkspaceId ?? "")),
+        projectName: safeText(String(c.projectName ?? "")),
+        projectId: safeText(String(c.projectId ?? "")),
+        sessionGoal: safeText(String(c.sessionGoal ?? "")),
+        sessionId: safeText(String(c.sessionId ?? "")),
+        podUrl: safeText(String(shared?.podUrl || c.podUrl || "")),
+    };
     // ── Claude Code fields ───────────────────────────────────────────────
     const modelName = (cc.model?.display_name ?? "").replace(/\s*\((?:1M|200K) context\)/, "").trim();
     const ctxPct = cc.context_window?.used_percentage;
@@ -315,14 +507,7 @@ function render() {
     const sdPct = rl?.seven_day?.used_percentage;
     const fhReset = rl?.five_hour?.resets_at;
     const vimMode = cc.vim?.mode;
-    const cwd = (cc.cwd ?? "");
-    let branch = "";
-    if (cwd) {
-        try {
-            branch = execSync(`git -C ${JSON.stringify(cwd)} --no-optional-locks symbolic-ref --short HEAD`, { encoding: "utf-8", timeout: 1000, stdio: ["ignore", "pipe", "ignore"] }).trim();
-        }
-        catch { /* not a git repo */ }
-    }
+    const branch = cwd ? gitBranchOf(cwd) : "";
     // ── Session stats (local file) ───────────────────────────────────────
     let callCount = 0;
     let sessionCount = 0;
@@ -401,22 +586,7 @@ function render() {
         const sg = pod.sessionId ? osc8(`synap://open/session/${pod.sessionId}`, pod.sessionGoal) : pod.sessionGoal;
         l2.push(`${D}▸${X} ${Y}${sg}${X}`);
     }
-    if (pod.proposalCount > 0) {
-        // cmd/ctrl-click opens the Proposals review app via the /open bounce
-        // (bare `proposals` keyword → synap://open/proposals → browser opens the app).
-        const proposalsLink = pod.podUrl ? `${pod.podUrl}/open/proposals` : "";
-        const label = `${pod.proposalCount} proposals`;
-        l2.push(`${D}↳${X} ${Y}${proposalsLink ? osc8(proposalsLink, label) : label}${X}`);
-    }
-    else if (pod.proposalsFetched) {
-        // Genuinely fetched and empty — distinct from "never fetched" so the line
-        // never silently omits a signal a user might mistake for "not checked yet".
-        l2.push(`${D}↳ 0 proposals${X}`);
-    }
-    else {
-        // No successful refresh has completed yet (fresh cache / all refreshes failed).
-        l2.push(`${D}↳ proposals —${X}`);
-    }
+    l2.push(needsYouSegment(pod, Date.now()));
     console.log(l2.join(" · "));
     // ─═─ LINE 3 — cost · rate limits · session stats ─═─────────────────────
     const l3 = [];
@@ -444,8 +614,82 @@ function render() {
     }
     if (l3.length)
         console.log(l3.join("  "));
+    // ─═─ LINE 4 — now: working / needs you / waiting on … / stopped ─═──────
+    // The bridge's status file first (what the POD says this conversation waits
+    // on); the transcript index when the file is absent, unbound, stale or
+    // unreadable — and an unreadable one is marked, never passed off as absent.
+    const now = Date.now();
+    const registry = claudeSessionId ? readRegistry(claudeSessionId) : null;
+    const bridge = claudeSessionId ? readBridgeStatus(claudeSessionId, { now, startedAt: registry?.startedAt }) : null;
+    if (bridge?.status === "fresh") {
+        console.log(buildBridgeLine({ now, file: bridge.file, writtenAt: bridge.writtenAt, registry, width: widthOf(cc) }));
+        return;
+    }
+    const line = buildNowLine({
+        now,
+        registry,
+        open: index ? Object.values(index.open) : [],
+        waits: claudeSessionId ? readWaits(claudeSessionId) : [],
+        width: widthOf(cc),
+        lastActivityAt: index?.lastEventAt || undefined,
+        alive: pidAlive,
+    });
+    console.log(bridge?.status === "failed" ? `${line} ${D}· ⚑ bridge status ${bridge.why}${X}` : line);
+}
+// ── Needs you (line 2) ─────────────────────────────────────────────────
+/**
+ * Where "N need you" opens: the desktop's Inbox, the whole pod — the page
+ * the browser opens for needs-you (its Home door, and the landing of every
+ * older needs-you link: browser `navigation/resolveDeepLink.test.ts`), whose
+ * rows are the same rule the count is (`GET /needs-you`). Named directly:
+ * the pod's `/open/proposals` bounce reached it only through two retired
+ * aliases (proposals → governance → inbox), and its "View in browser"
+ * fallback is pod admin's review queue, a subset of the count.
+ */
+export const NEEDS_YOU_LINK = "synap://open/app/inbox?scope=pod";
+/**
+ * Line 2's needs-you segment. A count is drawn as fresh only when the latest
+ * attempt read it and it is younger than the pod dot's own staleness bound;
+ * otherwise it is dimmed and says how old it is (`⚑ 12m old`), or that its
+ * age is unknown (`⚑ not read`). Never measured is `need you —`, never 0.
+ */
+export function needsYouSegment(pod, now) {
+    if (!pod.needsYouFetched)
+        return `${D}↳ need you —${X}`; // no read has ever succeeded
+    const label = `${pod.needsYouCount}${pod.needsYouTruncated ? "+" : ""} need you`;
+    // A cache from an older CLI has no measurement time: its `ts` is the claim it made.
+    const at = pod.needsYouAt ?? pod.ts;
+    const fresh = pod.ok && pod.needsYouOk !== false && at > 0 && now - at <= REFRESH_TTL_MS * 3;
+    if (!fresh) {
+        const old = at > 0 ? `⚑ ${age(now - at)} old` : "⚑ not read";
+        return `${D}↳ ${pod.needsYouCount > 0 ? osc8(NEEDS_YOU_LINK, label) : label} · ${old}${X}`;
+    }
+    // Genuinely fetched and empty — distinct from "never fetched".
+    if (pod.needsYouCount === 0)
+        return `${D}↳ 0 need you${X}`;
+    return `${D}↳${X} ${Y}${osc8(NEEDS_YOU_LINK, label)}${X}`;
 }
 // ── Entry ──────────────────────────────────────────────────────────────
+/**
+ * The checked-out branch of `cwd`, or "" when it is not a git repo.
+ *
+ * `cwd` comes from Claude Code's statusline JSON: any directory the person
+ * opened, cloned repos included. It goes to git as ONE argv word, no shell:
+ * a `JSON.stringify`-quoted path in a shell string still ran `$(…)` and
+ * backticks in a directory name, on every statusline refresh.
+ */
+export function gitBranchOf(cwd) {
+    try {
+        return execFileSync("git", ["-C", cwd, "--no-optional-locks", "symbolic-ref", "--short", "HEAD"], {
+            encoding: "utf-8",
+            timeout: 1000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return ""; // not a git repo (or git missing): the segment is left out
+    }
+}
 export async function statusline(opts) {
     if (opts?.refresh) {
         await refresh();