tuiboard 0.12.0 → 0.13.1

package/src/input/open-session.ts

@@ -179,6 +179,8 @@ export interface LaunchStep {
    * replaced with it.
    */
   captureId?: (stdout: string) => string | undefined;
+  /** Best-effort rollback (with `{id}`) if a later step fails, e.g. close the tab this step opened. */
+  undo?: LaunchStep;
 }
 
 export interface LaunchTarget {
@@ -365,39 +367,86 @@ export function describePlan(steps: LaunchStep[]): string {
 
 /**
  * Run a plan. Throws with a readable message on the first failing step.
- * Short IPC steps run synchronously (their output feeds the next step);
- * GUI launches are detached so tuiboard doesn't wait on the new window.
+ * Short IPC steps are awaited (their output feeds the next step) without
+ * blocking the UI; GUI launches are detached so tuiboard doesn't wait on the
+ * new window.
  */
 export async function runLaunchPlan(steps: LaunchStep[]): Promise<void> {
-  const { spawn, spawnSync } = await import("node:child_process");
+  const undos: LaunchStep[] = [];
   let id: string | undefined;
-  for (const step of steps) {
-    const args = step.args.map((a) => (id !== undefined ? a.replaceAll("{id}", id) : a));
-    const exe = Bun.which(step.cmd) ?? step.cmd;
-    if (step.detached) {
-      await new Promise<void>((resolve, reject) => {
-        const child = spawn(exe, args, { detached: true, stdio: "ignore", windowsHide: true });
-        child.once("error", (e) => reject(new Error(`${step.cmd}: ${e.message}`)));
-        child.once("spawn", () => {
-          child.unref();
-          resolve();
-        });
-      });
-      continue;
-    }
-    const res = spawnSync(exe, args, {
-      input: step.input,
-      encoding: "utf8",
-      windowsHide: true,
-      timeout: step.timeoutMs ?? 10_000,
-    });
-    if (res.error) throw new Error(`${step.cmd}: ${res.error.message}`);
-    if (res.status !== 0) {
-      throw new Error(`${step.cmd}: ${(res.stderr || "").trim() || `exit ${res.status}`}`);
+  try {
+    for (const step of steps) {
+      id = await runStep(step, id);
+      if (step.undo) undos.unshift(step.undo);
     }
-    if (step.captureId) {
-      id = step.captureId(res.stdout ?? "");
-      if (!id) throw new Error(`${step.cmd}: unexpected output`);
+  } catch (e) {
+    for (const undo of undos) {
+      await runStep(undo, id).catch(() => undefined);
     }
+    throw e;
+  }
+}
+
+/** CLI error text, unwrapping JSON errors like herdr's `{"error":{"message":…}}`. */
+function errorText(out: string): string {
+  const text = out.trim();
+  try {
+    const msg = JSON.parse(text)?.error?.message;
+    if (typeof msg === "string") return msg;
+  } catch {
+    // not JSON
+  }
+  return text;
+}
+
+async function runStep(step: LaunchStep, id: string | undefined): Promise<string | undefined> {
+  const { spawn } = await import("node:child_process");
+  const args = step.args.map((a) => (id !== undefined ? a.replaceAll("{id}", id) : a));
+  const exe = Bun.which(step.cmd) ?? step.cmd;
+  if (step.detached) {
+    await new Promise<void>((resolve, reject) => {
+      const child = spawn(exe, args, { detached: true, stdio: "ignore", windowsHide: true });
+      child.once("error", (e) => reject(new Error(`${step.cmd}: ${e.message}`)));
+      child.once("spawn", () => {
+        child.unref();
+        resolve();
+      });
+    });
+    return id;
+  }
+  const { status, stdout, stderr } = await new Promise<{
+    status: number | null;
+    stdout: string;
+    stderr: string;
+  }>((resolve, reject) => {
+    const child = spawn(exe, args, { windowsHide: true });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => (out += d));
+    child.stderr?.on("data", (d) => (err += d));
+    const timeoutMs = step.timeoutMs ?? 10_000;
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`${step.cmd}: timed out after ${Math.round(timeoutMs / 1000)}s`));
+    }, timeoutMs);
+    child.once("error", (e) => {
+      clearTimeout(timer);
+      reject(new Error(`${step.cmd}: ${e.message}`));
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      resolve({ status: code, stdout: out, stderr: err });
+    });
+    if (step.input !== undefined) child.stdin?.end(step.input);
+    else child.stdin?.end();
+  });
+  if (status !== 0) {
+    throw new Error(`${step.cmd}: ${errorText(stderr) || errorText(stdout) || `exit ${status}`}`);
+  }
+  if (step.captureId) {
+    const captured = step.captureId(stdout);
+    if (!captured) throw new Error(`${step.cmd}: unexpected output`);
+    return captured;
   }
+  return id;
 }

package/src/store/agent-adapters/claude-code.ts

@@ -333,6 +333,7 @@ function buildSession(
     gitBranch: parsed.gitBranch,
     model: parsed.model,
     resumeCommand: `claude --resume ${jsonl.sessionId}`,
+    resumeArgv: ["claude", "--resume", jsonl.sessionId],
   };
 }
 

package/src/store/agent-adapters/codex.ts

@@ -389,6 +389,7 @@ export function createCodexAdapter(codexHome = defaultCodexHome()): AgentAdapter
         gitBranch: parsed.gitBranch ?? row?.git_branch ?? undefined,
         model: parsed.model ?? row?.model ?? undefined,
         resumeCommand: `codex resume ${f.threadId}`,
+        resumeArgv: ["codex", "resume", f.threadId],
       });
     }
     // Drop cache entries for files that disappeared (archived / deleted).

package/src/store/agent-adapters/opencode.ts

@@ -178,6 +178,7 @@ export function readOpenCodeSessions(dbPath: string, now: number): AgentSession[
         // Assistant messages carry `modelID`; user messages `model.modelID`.
         model: lastData?.modelID ?? lastData?.model?.modelID,
         resumeCommand: `opencode --session ${s.id}`,
+        resumeArgv: ["opencode", "--session", s.id],
       } satisfies AgentSession;
     });
   } finally {

package/src/store/agent-adapters/pi.ts

@@ -238,6 +238,7 @@ export function createPiAdapter(sessionsDir = defaultPiSessionsDir()): AgentAdap
         lastAssistant: p.lastAssistant,
         model: p.model,
         resumeCommand: `pi --session ${sessionId}`,
+        resumeArgv: ["pi", "--session", sessionId],
       };
     });
     const live = new Set(files.map((f) => f.path));

package/src/store/agents.ts

@@ -13,6 +13,13 @@ import { resolve, sep } from "node:path";
 import chokidar from "chokidar";
 import { createSignal } from "solid-js";
 
+import {
+  linkHerdrSessions,
+  type HerdrLink,
+  type HerdrSnapshot,
+  type HerdrSource,
+} from "~/store/herdr";
+
 /** Threshold: session untouched longer than this is "archived" (won't show in compact list). */
 export const DORMANT_AFTER_MS = 7 * 86_400 * 1000;
 
@@ -30,7 +37,11 @@ export const HARNESS: Record<AgentProvider, { code: string; name: string }> = {
 export type AgentsFilter = "all" | AgentProvider;
 
 export type AgentStatus =
+  /** Waiting for you (permission/question) — known only via herdr. */
+  | "live-blocked"
   | "live-busy"
+  /** Finished its turn, not looked at yet — known only via herdr. */
+  | "live-done"
   | "live-idle"
   /** Looks busy, but stopped updating — the process likely crashed. */
   | "stale"
@@ -58,6 +69,10 @@ export interface AgentSession {
   model?: string;
   /** Shell command that resumes this session when run from `cwd`. */
   resumeCommand: string;
+  /** Same, as argv (`[binary, ...args]`) — for launchers that start the agent directly. */
+  resumeArgv: string[];
+  /** Set when the session is open in a herdr pane. */
+  herdr?: HerdrLink;
 }
 
 /** One agent CLI's session source. */
@@ -109,18 +124,32 @@ export function formatAge(ts: number, now: number): string {
 }
 
 const STATUS_RANK: Record<AgentStatus, number> = {
-  "live-busy": 0,
-  "live-idle": 1,
-  "stale": 2,
-  "dormant": 3,
-  "archived": 4,
+  "live-blocked": 0,
+  "live-busy": 1,
+  "live-done": 2,
+  "live-idle": 3,
+  "stale": 4,
+  "dormant": 5,
+  "archived": 6,
 };
 
+/** Is the agent process running (as far as we can tell)? */
+export function isLive(status: AgentStatus): boolean {
+  return status.startsWith("live-");
+}
+
+/**
+ * Most recently active first; status only breaks ties. Archived sessions
+ * always go last — the dashboard strip hides them and relies on that to keep
+ * cursor indices aligned with the full list.
+ */
 export function sortSessions(arr: AgentSession[]): AgentSession[] {
   return arr.slice().sort((a, b) => {
-    const r = STATUS_RANK[a.status] - STATUS_RANK[b.status];
-    if (r !== 0) return r;
-    return b.lastActivityMs - a.lastActivityMs;
+    const archived = Number(a.status === "archived") - Number(b.status === "archived");
+    if (archived !== 0) return archived;
+    const recency = b.lastActivityMs - a.lastActivityMs;
+    if (recency !== 0) return recency;
+    return STATUS_RANK[a.status] - STATUS_RANK[b.status];
   });
 }
 
@@ -128,6 +157,8 @@ export function sortSessions(arr: AgentSession[]): AgentSession[] {
 
 export interface AgentsStore {
   sessions: () => AgentSession[];
+  /** Latest herdr snapshot (undefined without herdr). */
+  herdr: () => HerdrSnapshot | undefined;
   refresh: () => void;
   dispose: () => Promise<void>;
 }
@@ -148,7 +179,10 @@ const MISSING_PATH_POLL_MS = 5000;
  */
 export function createAgentsStore(
   adapters: AgentAdapter[],
-  { missingPathPollMs = MISSING_PATH_POLL_MS } = {},
+  {
+    missingPathPollMs = MISSING_PATH_POLL_MS,
+    herdr,
+  }: { missingPathPollMs?: number; herdr?: HerdrSource } = {},
 ): AgentsStore {
   const [sessions, setSessions] = createSignal<AgentSession[]>([]);
   const byAdapter = new Map<AgentAdapter, AgentSession[]>();
@@ -162,8 +196,10 @@ export function createAgentsStore(
   }
 
   function publish(): void {
-    setSessions(sortSessions([...byAdapter.values()].flat()));
+    const all = [...byAdapter.values()].flat();
+    setSessions(sortSessions(linkHerdrSessions(all, herdr?.snapshot())));
   }
+  herdr?.onChange(publish);
 
   function refresh(): void {
     const now = Date.now();
@@ -231,8 +267,9 @@ export function createAgentsStore(
   async function dispose() {
     if (debounceTimer) clearTimeout(debounceTimer);
     clearInterval(missingPoll);
+    herdr?.dispose();
     await watcher.close();
   }
 
-  return { sessions, refresh, dispose };
+  return { sessions, herdr: () => herdr?.snapshot(), refresh, dispose };
 }

package/src/store/herdr.ts

@@ -0,0 +1,272 @@
+/**
+ * herdr (terminal workspace manager for coding agents) link.
+ *
+ * `herdr api snapshot` lists every pane with the agent running in it, that
+ * agent's state and — when herdr's integration for that agent is installed —
+ * the agent session it's on (`{kind: "id"}` for Claude/OpenCode, `{kind:
+ * "path"}` for Pi). tuiboard polls it and links panes to its own sessions, so
+ * a session open in herdr shows herdr's live state (including "idle" and
+ * "waiting for you", which the on-disk formats can't tell) and where it lives.
+ *
+ * Optional by design: no `herdr` on PATH, no server, or an unexpected answer
+ * all just mean "no links".
+ */
+
+import type { AgentProvider, AgentSession, AgentStatus } from "~/store/agents";
+
+export type HerdrAgentStatus = "idle" | "working" | "blocked" | "done" | "unknown";
+
+export interface HerdrPane {
+  paneId: string;
+  tabId: string;
+  workspaceId: string;
+  agent?: string;
+  status: HerdrAgentStatus;
+  cwd: string;
+  session?: { kind: "id" | "path"; value: string };
+}
+
+export interface HerdrSnapshot {
+  panes: HerdrPane[];
+  focusedWorkspaceId?: string;
+  tabs: Map<string, { label: string; number: number }>;
+  workspaces: Map<string, { label: string; number: number }>;
+}
+
+/** The `herdr` binary to drive: the one herdr itself advertises, else PATH. */
+export function herdrBin(env: Record<string, string | undefined> = process.env): string | undefined {
+  return env.HERDR_BIN_PATH || Bun.which("herdr") || undefined;
+}
+
+/** Where a session is open in herdr. */
+export interface HerdrLink {
+  paneId: string;
+  tabId: string;
+  workspaceId: string;
+  workspaceLabel: string;
+  tabLabel: string;
+  tabNumber: number;
+  status: HerdrAgentStatus;
+  /** How the pane was matched; `cwd` = no session identity from herdr. */
+  matchedBy: "id" | "path" | "cwd";
+  /** herdr's name for the agent (for `herdr integration install <name>`). */
+  agent: string;
+}
+
+/** `herdr blits · tab 3` */
+export function herdrPlace(l: HerdrLink): string {
+  return `herdr ${l.workspaceLabel || l.workspaceId} · tab ${l.tabNumber || l.tabId}`;
+}
+
+/** herdr agent name ↔ tuiboard provider. */
+export const HERDR_AGENT: Record<AgentProvider, string> = {
+  "claude-code": "claude",
+  codex: "codex",
+  opencode: "opencode",
+  pi: "pi",
+};
+const PROVIDER_OF: Record<string, AgentProvider> = Object.fromEntries(
+  Object.entries(HERDR_AGENT).map(([p, a]) => [a, p as AgentProvider]),
+);
+
+const STATUSES = new Set<HerdrAgentStatus>(["idle", "working", "blocked", "done", "unknown"]);
+
+/** Parse `herdr api snapshot` output. Returns undefined if it isn't one. */
+export function parseHerdrSnapshot(raw: string): HerdrSnapshot | undefined {
+  let data: any;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+  const snap = data?.result?.snapshot ?? data?.snapshot;
+  if (!snap || !Array.isArray(snap.panes)) return undefined;
+  const panes: HerdrPane[] = [];
+  for (const p of snap.panes) {
+    if (typeof p?.pane_id !== "string") continue;
+    const s = p.agent_session;
+    panes.push({
+      paneId: p.pane_id,
+      tabId: String(p.tab_id ?? ""),
+      workspaceId: String(p.workspace_id ?? ""),
+      agent: typeof p.agent === "string" ? p.agent : undefined,
+      status: STATUSES.has(p.agent_status) ? p.agent_status : "unknown",
+      cwd: String(p.cwd ?? ""),
+      session:
+        s && (s.kind === "id" || s.kind === "path") && typeof s.value === "string"
+          ? { kind: s.kind, value: s.value }
+          : undefined,
+    });
+  }
+  const byId = (list: unknown, key: string) =>
+    new Map<string, { label: string; number: number }>(
+      (Array.isArray(list) ? list : [])
+        .filter((x: any) => typeof x?.[key] === "string")
+        .map((x: any) => [x[key], { label: String(x.label ?? ""), number: Number(x.number ?? 0) }]),
+    );
+  return {
+    panes,
+    focusedWorkspaceId: typeof snap.focused_workspace_id === "string" ? snap.focused_workspace_id : undefined,
+    tabs: byId(snap.tabs, "tab_id"),
+    workspaces: byId(snap.workspaces, "workspace_id"),
+  };
+}
+
+/** Compare paths across the formats agents store (`C:/x`, `C:\x`, lossy case). */
+export function samePath(a: string, b: string): boolean {
+  const norm = (p: string) => {
+    let s = p.replaceAll("\\", "/").replace(/\/+$/, "");
+    if (/^[A-Za-z]:/.test(s)) s = s.toLowerCase();
+    return s;
+  };
+  if (!a || !b) return false;
+  const x = norm(a);
+  const y = norm(b);
+  return x === y || x.toLowerCase() === y.toLowerCase();
+}
+
+const STATUS_FROM_HERDR: Partial<Record<HerdrAgentStatus, AgentStatus>> = {
+  working: "live-busy",
+  blocked: "live-blocked",
+  done: "live-done",
+  idle: "live-idle",
+};
+
+/**
+ * Attach herdr links to sessions and let herdr's state win where it knows
+ * it. Panes reporting a session id/path are matched first; panes without one
+ * fall back to "most recent session of that agent in that directory".
+ */
+export function linkHerdrSessions(
+  sessions: AgentSession[],
+  snap: HerdrSnapshot | undefined,
+): AgentSession[] {
+  if (!snap || snap.panes.length === 0) return sessions;
+  const links = new Map<AgentSession, HerdrLink>();
+  const link = (s: AgentSession, p: HerdrPane, matchedBy: HerdrLink["matchedBy"]) => {
+    const tab = snap.tabs.get(p.tabId);
+    links.set(s, {
+      paneId: p.paneId,
+      tabId: p.tabId,
+      workspaceId: p.workspaceId,
+      workspaceLabel: snap.workspaces.get(p.workspaceId)?.label ?? "",
+      tabLabel: tab?.label ?? "",
+      tabNumber: tab?.number ?? 0,
+      status: p.status,
+      matchedBy,
+      agent: p.agent ?? "",
+    });
+  };
+  const agentPanes = snap.panes.filter((p) => p.agent && PROVIDER_OF[p.agent]);
+
+  for (const p of agentPanes) {
+    if (!p.session) continue;
+    const provider = PROVIDER_OF[p.agent!];
+    const { kind, value } = p.session;
+    const s = sessions.find(
+      (x) =>
+        x.provider === provider &&
+        !links.has(x) &&
+        (kind === "id"
+          ? x.sessionId === value
+          : samePath(x.sourcePath, value) || value.includes(x.sessionId)),
+    );
+    if (s) link(s, p, kind);
+  }
+  for (const p of agentPanes) {
+    if (p.session) continue;
+    const provider = PROVIDER_OF[p.agent!];
+    const s = sessions
+      .filter((x) => x.provider === provider && !links.has(x) && samePath(x.cwd, p.cwd))
+      .sort((a, b) => b.lastActivityMs - a.lastActivityMs)[0];
+    if (s) link(s, p, "cwd");
+  }
+
+  if (links.size === 0) return sessions;
+  return sessions.map((s) => {
+    const l = links.get(s);
+    if (!l) return s;
+    return { ...s, herdr: l, status: STATUS_FROM_HERDR[l.status] ?? s.status };
+  });
+}
+
+/** Agent status glyph style — the same two herdr offers. */
+export type IndicatorStyle = "dots" | "symbols";
+
+/** One synchronous snapshot, for CLI/dev scripts. */
+export function readHerdrSnapshotOnce(bin = Bun.which("herdr") ?? undefined): HerdrSnapshot | undefined {
+  if (!bin) return undefined;
+  try {
+    const res = Bun.spawnSync([bin, "api", "snapshot"], { stdout: "pipe", stderr: "ignore", timeout: 5000 });
+    return res.exitCode === 0 ? parseHerdrSnapshot(res.stdout.toString()) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ─── Polling source ─────────────────────────────────────────────────────────
+
+export interface HerdrSource {
+  snapshot: () => HerdrSnapshot | undefined;
+  onChange: (cb: () => void) => void;
+  dispose: () => void;
+}
+
+export const HERDR_POLL_MS = 2000;
+
+/**
+ * Poll `herdr api snapshot` in the background. Inert when herdr isn't on
+ * PATH (or `bin: null`). A failing call clears the snapshot (server gone)
+ * without noise.
+ */
+export function createHerdrSource(
+  { pollMs = HERDR_POLL_MS, bin = Bun.which("herdr") }: { pollMs?: number; bin?: string | null } = {},
+): HerdrSource {
+  let current: HerdrSnapshot | undefined;
+  let lastRaw = "";
+  const listeners: (() => void)[] = [];
+  if (!bin) return { snapshot: () => undefined, onChange: () => {}, dispose: () => {} };
+
+  let inFlight = false;
+  let disposed = false;
+  const poll = async () => {
+    if (inFlight || disposed) return;
+    inFlight = true;
+    try {
+      const proc = Bun.spawn([bin, "api", "snapshot"], {
+        stdout: "pipe",
+        stderr: "ignore",
+        windowsHide: true,
+      });
+      const timer = setTimeout(() => proc.kill(), 5000);
+      const out = await new Response(proc.stdout).text();
+      clearTimeout(timer);
+      const code = await proc.exited;
+      const snap = code === 0 ? parseHerdrSnapshot(out) : undefined;
+      // Only the parts we use decide whether anything changed.
+      const key = snap
+        ? JSON.stringify([snap.panes, [...snap.tabs], [...snap.workspaces]])
+        : "";
+      if (key !== lastRaw && !disposed) {
+        lastRaw = key;
+        current = snap;
+        for (const cb of listeners) cb();
+      }
+    } catch {
+      // herdr vanished mid-call — try again next tick
+    } finally {
+      inFlight = false;
+    }
+  };
+  void poll();
+  const timer = setInterval(poll, pollMs);
+  timer.unref?.();
+  return {
+    snapshot: () => current,
+    onChange: (cb) => listeners.push(cb),
+    dispose: () => {
+      disposed = true;
+      clearInterval(timer);
+    },
+  };
+}

package/src/store/index.ts

@@ -38,6 +38,7 @@ import {
   type AgentsStore,
 } from "./agents";
 import { AGENT_ADAPTERS } from "./agent-adapters";
+import { createHerdrSource } from "./herdr";
 import {
   createCalendarStore,
   createGoogleEvent,
@@ -380,7 +381,7 @@ export function createTuiStore({ config }: CreateStoreOptions) {
   // the agents zone is disabled we skip the watcher entirely (no session reads
   // at all) and hand back an inert stub.
   const agentsStore: AgentsStore = enabledZones.agents
-    ? createAgentsStore(AGENT_ADAPTERS)
+    ? createAgentsStore(AGENT_ADAPTERS, { herdr: createHerdrSource() })
     : noopAgentsStore();
   // Calendar feeds (read-only) merged into the Agenda zone. Skipped entirely
   // (no network) when the agenda zone is disabled.
@@ -1732,6 +1733,7 @@ export function createTuiStore({ config }: CreateStoreOptions) {
     activeBoard,
     agents: agentsStore,
     agentSessions,
+    agentIndicators: config.statusIndicators,
     cycleAgentsFilter,
     setLastLaunch,
     calendar: calendarStore,
@@ -1819,7 +1821,7 @@ export type TuiStore = ReturnType<typeof createTuiStore>;
 /** Inert agents store for when the agents zone is disabled — no chokidar
  *  watcher, no `~/.claude` reads at all. */
 function noopAgentsStore(): AgentsStore {
-  return { sessions: () => [], refresh: () => {}, dispose: async () => {} };
+  return { sessions: () => [], herdr: () => undefined, refresh: () => {}, dispose: async () => {} };
 }
 
 /** Inert calendar store for when the agenda zone is disabled — no fetching. */

package/src/ui/AgentRow.tsx

@@ -16,6 +16,7 @@ import { homedir } from "node:os";
 
 import { layoutCardDetails, layoutCardName, layoutLine } from "~/ui/agent-line";
 import { T } from "~/ui/glyphs";
+import { herdrPlace, type IndicatorStyle } from "~/store/herdr";
 import {
   HARNESS,
   cwdShort,
@@ -27,21 +28,42 @@ import {
 } from "~/store/agents";
 
 const STATUS_COLOR: Record<AgentStatus, string> = {
-  "live-busy": T.today,     // bright accent for actively-running
-  "live-idle": T.scheduled, // warm but quieter
-  "stale":     T.bannerWarn,
-  "dormant":   T.textDim,
-  "archived":  T.textDone,
+  "live-blocked": T.overdue,  // needs you
+  "live-busy":    T.today,    // bright accent for actively-running
+  "live-done":    T.done,     // finished, not looked at yet
+  "live-idle":    T.scheduled, // warm but quieter
+  "stale":        T.bannerWarn,
+  "dormant":      T.textDim,
+  "archived":     T.textDone,
 };
 
-const STATUS_GLYPH: Record<AgentStatus, string> = {
-  "live-busy": "●",
-  "live-idle": "○",
-  "stale":     "△",
-  "dormant":   "·",
-  "archived":  "·",
+/**
+ * herdr's two `status_indicators` styles, copied as-is so the same state reads
+ * the same in both tools. `stale` is tuiboard's own (no herdr equivalent).
+ */
+const STATUS_GLYPH: Record<IndicatorStyle, Record<AgentStatus, string>> = {
+  dots: {
+    "live-blocked": "●",
+    "live-busy":    "●",
+    "live-done":    "●",
+    "live-idle":    "○",
+    "stale":        "△",
+    "dormant":      "·",
+    "archived":     "·",
+  },
+  symbols: {
+    "live-blocked": "×",
+    "live-busy":    "◐",
+    "live-done":    "✓",
+    "live-idle":    "○",
+    "stale":        "△",
+    "dormant":      "·",
+    "archived":     "·",
+  },
 };
 
+
+
 /** One hue per harness so the badge reads before the letters do. */
 export const HARNESS_COLOR: Record<AgentProvider, string> = {
   "claude-code": T.warm,    // orange
@@ -66,6 +88,8 @@ interface AgentRowProps {
   nameMaxChars?: number;
   /** `line` (default) for the dashboard strip, `card` for the fullscreen view. */
   variant?: "line" | "card";
+  /** Status glyph style (default symbols, as in herdr). */
+  indicators?: IndicatorStyle;
   onClick?: () => void;
 }
 
@@ -106,7 +130,15 @@ export function AgentRow(props: AgentRowProps) {
   );
   const cardName = createMemo(() => layoutCardName(displayName(), width()));
   const details = createMemo(() =>
-    layoutCardDetails([model(), props.session.gitBranch, cardCwd(props.session.cwd)], width()),
+    layoutCardDetails(
+      [
+        model(),
+        props.session.herdr && herdrPlace(props.session.herdr),
+        props.session.gitBranch,
+        cardCwd(props.session.cwd),
+      ],
+      width(),
+    ),
   );
 
   // cursor · status glyph · harness badge — shared by both variants.
@@ -115,7 +147,7 @@ export function AgentRow(props: AgentRowProps) {
       {props.cursor ? "▶ " : "  "}
     </span>,
     <span style={{ fg: STATUS_COLOR[props.session.status] }}>
-      {STATUS_GLYPH[props.session.status]}{" "}
+      {STATUS_GLYPH[props.indicators ?? "symbols"][props.session.status]}{" "}
     </span>,
     <span style={{ fg: HARNESS_COLOR[props.session.provider] }}>
       {HARNESS[props.session.provider].code}{" "}