@monster-orange/den 0.4.27 → 0.4.28

package/src/shared/agents/helpers.ts

@@ -0,0 +1,175 @@
+/**
+ * D32: the helpers an agent starts inside its own session (Claude Code's
+ * Agent and Workflow subagents). They belong to the agent's session, not
+ * to Den: Den shows them, read-only, and never stops or steers them.
+ *
+ * Runtime-neutral shapes; a runtime that can read its helpers implements
+ * Runtime.helpers / Runtime.helperTranscript (den-claude: claude-helpers.ts).
+ */
+
+/** running: working now. idle: no activity for a while, not known done. */
+export type HelperStatus = "running" | "idle" | "done" | "failed" | "stopped";
+
+export interface Helper {
+  /** The runtime's id for it (Claude Code: agent-<id>'s <id>). */
+  id: string;
+  /** What the agent asked it to do, in a few words. Missing: show the id. */
+  description?: string;
+  /** Its kind (general-purpose, Explore, a plugin's agent, …). */
+  type?: string;
+  model?: string;
+  /** The worktree it works in, when it has its own. */
+  branch?: string;
+  worktree?: string;
+  /** Started in the background (the agent kept going meanwhile). */
+  background?: boolean;
+  /** 1: started by the agent; 2+: started by another helper (parentId). */
+  depth: number;
+  parentId?: string;
+  /** When it ran inside a workflow. */
+  workflow?: { runId: string; name?: string; phase?: string; label?: string };
+  /** It ran in one of the agent's earlier conversations (before a relaunch). */
+  earlier?: true;
+  status: HelperStatus;
+  /** How the status was told, for "why does it say that". */
+  statusFrom: string;
+  /** Epoch ms. */
+  startedAt?: number;
+  lastActivityAt?: number;
+  durationMs?: number;
+  /** The tool it used last, when known. */
+  lastTool?: string;
+}
+
+/** One line of a helper's transcript, tool calls summarized. */
+export interface HelperTranscriptItem {
+  at?: number;
+  kind: "prompt" | "text" | "tool" | "result" | "note";
+  /** For a tool call: its name. */
+  tool?: string;
+  text: string;
+  error?: boolean;
+}
+
+export interface HelperTranscript {
+  helper: Helper;
+  items: HelperTranscriptItem[];
+  /** Earlier lines left out (only the last ones are shown). */
+  omitted: number;
+}
+
+/** Read-only, and why: shown wherever helpers are. */
+export const HELPERS_READ_ONLY_NOTE =
+  "Helpers run inside this agent's own session, so Den shows them but can't stop or steer them. To change what they do, tell the agent.";
+
+/** D32 settings (agents.helpers.*), permissive defaults. */
+export interface HelperSettings {
+  /** No activity for this long and not known done: idle, not running. */
+  activeMinutes: number;
+  /** Done, failed and stopped helpers fold away after this long. */
+  collapseDoneMinutes: number;
+}
+
+export const HELPER_DEFAULTS: HelperSettings = {
+  activeMinutes: 10,
+  collapseDoneMinutes: 30,
+};
+
+/** What a runtime's helpers hooks are given. */
+export interface HelperReadOptions {
+  env?: NodeJS.ProcessEnv;
+  now?: number;
+  settings?: Partial<HelperSettings>;
+  /** Whether the agent itself is running now. */
+  agentLive?: boolean;
+  /** A transcript's last lines (default 500). */
+  limit?: number;
+}
+
+/**
+ * Running helpers first, then the newest; a helper's own helpers right
+ * under it, in the same order (a tree, depth first). One whose parent
+ * isn't in the list sits at the top level.
+ */
+export function sortHelpers(hs: Helper[]): Helper[] {
+  const ids = new Set(hs.map((h) => h.id));
+  const kids = new Map<string, Helper[]>();
+  const roots: Helper[] = [];
+  for (const h of hs)
+    if (h.parentId && h.parentId !== h.id && ids.has(h.parentId))
+      kids.set(h.parentId, [...(kids.get(h.parentId) ?? []), h]);
+    else roots.push(h);
+  // Running counts for the whole branch: a done helper with a running
+  // helper under it sorts with the running ones (0.4.28-dev.1's gate).
+  const busy = new Map<string, boolean>();
+  const runs = (h: Helper, path = new Set<string>()): boolean => {
+    const known = busy.get(h.id);
+    if (known !== undefined) return known;
+    if (path.has(h.id)) return h.status === "running";
+    path.add(h.id);
+    const r =
+      h.status === "running" ||
+      (kids.get(h.id) ?? []).some((k) => runs(k, path));
+    path.delete(h.id);
+    busy.set(h.id, r);
+    return r;
+  };
+  const live = (h: Helper) => (runs(h) ? 0 : 1);
+  const order = (a: Helper, b: Helper) =>
+    live(a) - live(b) ||
+    (b.startedAt ?? b.lastActivityAt ?? 0) -
+      (a.startedAt ?? a.lastActivityAt ?? 0) ||
+    a.id.localeCompare(b.id);
+  const out: Helper[] = [];
+  const seen = new Set<string>();
+  const walk = (h: Helper) => {
+    if (seen.has(h.id)) return;
+    seen.add(h.id);
+    out.push(h);
+    for (const k of (kids.get(h.id) ?? []).sort(order)) walk(k);
+  };
+  for (const r of roots.sort(order)) walk(r);
+  // A loop of parents (never from Claude Code): still listed, flat.
+  for (const h of [...hs].sort(order)) if (!seen.has(h.id)) out.push(h);
+  return out;
+}
+
+/**
+ * At most `n` of `list`, in its order: the running ones first to stay,
+ * then the rest (a running helper is never cut for a done one).
+ */
+export function capHelpers(list: readonly Helper[], n: number): Helper[] {
+  const kept = new Set(
+    [
+      ...list.filter((h) => h.status === "running"),
+      ...list.filter((h) => h.status !== "running"),
+    ].slice(0, Math.max(0, n)),
+  );
+  return list.filter((h) => kept.has(h));
+}
+
+/**
+ * How far each helper of `list` (in sortHelpers' order) is indented: one
+ * step under a parent shown above it, none when its parent isn't in the
+ * list. The page's twin is agent-helpers.js shownDepths.
+ */
+export function shownDepths(list: readonly Helper[]): Map<string, number> {
+  const at = new Map<string, number>();
+  for (const h of list)
+    at.set(
+      h.id,
+      h.parentId && at.has(h.parentId) ? at.get(h.parentId)! + 1 : 0,
+    );
+  return at;
+}
+
+/** {running, total}: what a badge shows. */
+export function helperCounts(hs: readonly Helper[]): {
+  running: number;
+  total: number;
+} {
+  return {
+    running: hs.filter((h) => h.status === "running").length,
+    total: hs.length,
+  };
+}

package/src/shared/agents/runtime.ts

@@ -7,6 +7,7 @@
  * Built-ins register here exactly as a runtime plugin would (AG-8a):
  * den-claude and generic.
  */
+import type { Helper, HelperReadOptions, HelperTranscript } from "./helpers.js";
 import * as fs from "fs";
 import * as path from "path";
 import {
@@ -252,6 +253,18 @@ export interface Runtime {
    * throw; its catalog entry's `sessionName` says how stable its source is.
    */
   sessionName?(rec: AgentRecord, env?: NodeJS.ProcessEnv): string | null;
+  /**
+   * D32: the helpers the agent started inside its own session (Claude
+   * Code's Agent and Workflow subagents), in every conversation it has had,
+   * running first. Read-only. None: the runtime can't tell. Never throws.
+   */
+  helpers?(rec: AgentRecord, opts?: HelperReadOptions): Helper[];
+  /** D32: one helper's transcript, tool calls summarized; null if none. Never throws. */
+  helperTranscript?(
+    rec: AgentRecord,
+    id: string,
+    opts?: HelperReadOptions,
+  ): HelperTranscript | null;
   /** Where permission prompts surface (Q-AG-2). */
   approvals?: "terminal" | "hook";
   /**

package/src/shared/den-config.ts

@@ -8,6 +8,7 @@
  * The user file can toggle local_dev on/off without touching the shared config.
  */
 
+import { HELPER_DEFAULTS, type HelperSettings } from "./agents/helpers.js";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
@@ -916,6 +917,13 @@ export interface AgentsConfig {
    * false` keeps standing personas from rotating (default true).
    */
   rotate?: { after_compactions?: unknown; standing?: unknown };
+  /**
+   * D32, the helpers an agent starts in its own session:
+   * `{ active_minutes, collapse_done_minutes }`. A helper with no activity
+   * for `active_minutes` (default 10) and not known done shows idle; done
+   * ones fold away after `collapse_done_minutes` (default 30).
+   */
+  helpers?: { active_minutes?: unknown; collapse_done_minutes?: unknown };
   /**
    * Any other key is an agent id: `agents.<id>.grants` widens that agent's
    * MCP scope to other workspaces (AG spec §5b). Config only: an agent
@@ -940,6 +948,8 @@ export const AGENTS_RESERVED_KEYS = [
   "runtime_catalog",
   "default_pack",
   "rotate",
+  // D32: how helpers show.
+  "helpers",
   // AG-10.5, AG-11.1: the distribution's persona categories and roles.
   "categories",
   "roles",
@@ -968,12 +978,42 @@ export interface ResolvedAgentsConfig {
   rotate?: RotateSettings;
   /** D28: agents.rotate as written, the org scope. */
   rotateOrg?: OrgRotate;
+  /** agents.helpers (D32) with its defaults. */
+  helpers?: HelperSettings;
   /** agents.categories (AG-10.5): the distribution's, after Den's. */
   categories?: Category[];
   /** agents.roles (AG-11.1): new roles and Den roles' preset extensions. */
   roles?: RolesConfig;
 }
 
+/** `agents.helpers` (D32) checked; a bad key or value throws naming it. */
+export function helpersBlock(v: unknown): HelperSettings {
+  const out = { ...HELPER_DEFAULTS };
+  if (v === undefined || v === null) return out;
+  if (!isMapping(v))
+    throw new Error(
+      `agents.helpers: must be a mapping of active_minutes, collapse_done_minutes (got ${JSON.stringify(v)})`,
+    );
+  for (const [k, x] of Object.entries(v)) {
+    const key =
+      k === "active_minutes"
+        ? "activeMinutes"
+        : k === "collapse_done_minutes"
+          ? "collapseDoneMinutes"
+          : null;
+    if (!key)
+      throw new Error(
+        `agents.helpers.${k}: unknown key (agents.helpers takes active_minutes, collapse_done_minutes)`,
+      );
+    if (typeof x !== "number" || !Number.isFinite(x) || x <= 0 || x > 100_000)
+      throw new Error(
+        `agents.helpers.${k}: must be a number of minutes, above 0 and at most 100000 (got ${JSON.stringify(x)})`,
+      );
+    out[key] = x;
+  }
+  return out;
+}
+
 /** `agents.rotate` checked; any other key, or a bad value, throws naming it. */
 /**
  * `agents.rotate` checked, both ways: den#4's settings (afterCompactions 0
@@ -1077,6 +1117,7 @@ export function readAgentsConfig(
       return { rotate: r.settings, rotateOrg: r.org };
     })(),
   };
+  out.helpers = helpersBlock(raw.helpers);
   out.categories = checkCategoriesConfig(raw.categories);
   out.roles = checkRolesConfig(raw.roles, [
     ...DEN_CATEGORIES.map((c) => c.id),
@@ -1114,7 +1155,7 @@ export function readAgentsConfig(
     const where = `agents.${id}`;
     if (!AGENT_KEY_RE.test(id) || !isMapping(block))
       throw new Error(
-        `${where}: unknown key (agents: takes max_concurrent, persona_packs, runtime_catalog, default_pack, rotate, categories, roles, ` +
+        `${where}: unknown key (agents: takes max_concurrent, persona_packs, runtime_catalog, default_pack, rotate, helpers, categories, roles, ` +
           `or an agent id mapping to { grants: [...] })`,
       );
     for (const k of Object.keys(block))

package/src/shared/hub.ts

@@ -243,6 +243,8 @@ export interface HubWhoami {
   company?: { slug?: string; name?: string; url?: string };
   /** Hub's MCP endpoint; opaque. */
   mcpUrl?: string;
+  /** Threads on Hub waiting on the person (the rail's badge). */
+  unread?: number;
 }
 
 /**
@@ -287,6 +289,8 @@ export type HubStatus =
       label?: string;
       role?: string;
       login?: string;
+      /** Hub threads waiting on the person (whoami's unread). */
+      unread?: number;
       /** Why it isn't connected, in words (never the token). */
       problem?: string;
     };
@@ -379,6 +383,11 @@ export async function hubWhoami(
     ...(str(b.login) ? { login: str(b.login)! } : {}),
     ...(Object.keys(company).length ? { company } : {}),
     ...(str(b.mcp_url) ? { mcpUrl: str(b.mcp_url)! } : {}),
+    ...(typeof b.unread === "number" &&
+    Number.isInteger(b.unread) &&
+    b.unread >= 0
+      ? { unread: Math.min(b.unread, 1_000_000) }
+      : {}),
   };
 }
 
@@ -542,6 +551,7 @@ export async function hubStatus(
       ...(who.install ? { label: who.install } : {}),
       ...(who.role ? { role: who.role } : {}),
       ...(who.login ? { login: who.login } : {}),
+      ...(who.unread !== undefined ? { unread: who.unread } : {}),
     };
   } catch (e) {
     const kind = e instanceof HubCallError ? e.kind : "unreachable";

package/src/ui/cli/agent-ops.ts

@@ -50,6 +50,15 @@
  * Nothing here takes a grant: grants come from the org config only. The
  * host enforces agents.max_concurrent on every start, counting agents only.
  */
+import {
+  capHelpers,
+  HELPER_DEFAULTS,
+  HELPERS_READ_ONLY_NOTE,
+  helperCounts,
+  type Helper,
+  type HelperSettings,
+  type HelperTranscript,
+} from "../../shared/agents/helpers.js";
 import * as fs from "fs";
 import * as path from "path";
 import {
@@ -638,6 +647,12 @@ export interface AgentRow {
   /** D28: the last one (when, why, the old conversation, by itself or not). */
   lastRotation?: RotationEntry;
   session?: SessionInfo;
+  /**
+   * D32: the helpers it started in its own session: how many, how many
+   * run now, and the ones worth showing under it (running, or ended
+   * within agents.helpers.collapse_done_minutes; at most 8).
+   */
+  helpers?: { running: number; total: number; recent: Helper[] };
 }
 
 /** Its state as a row shows it (AG-14.1: stopped, exited or interrupted). */
@@ -831,9 +846,138 @@ export async function listAgents(
   const records = listRecords(d.stateDir()).filter((r) => r.workspace === ws);
   noteEnded(d.stateDir(), sessions, records);
   const rows = agentRows(sessions, records, d.stateDir(), policyResolver(d));
+  addHelperCounts(d, rows, records);
   return opts.stopped ? rows.filter((r) => isStoppedState(r.state)) : rows;
 }
 
+/** At most this many helpers ride along on an agent's row. */
+const ROW_HELPERS = 8;
+
+/** D32: agents.helpers, or its defaults when the config can't be read. */
+function helperSettings(d: AgentsResolved): HelperSettings {
+  try {
+    return d.agentsConfig().helpers ?? HELPER_DEFAULTS;
+  } catch {
+    return HELPER_DEFAULTS;
+  }
+}
+
+/** D32: each row's helper counts and recent helpers (never fails a list). */
+function addHelperCounts(
+  d: AgentsResolved,
+  rows: AgentRow[],
+  records: AgentRecord[],
+): void {
+  const settings = helperSettings(d);
+  const byId = new Map(records.map((r) => [r.id, r]));
+  for (const row of rows) {
+    const rec = byId.get(row.agent);
+    if (!rec) continue;
+    const h = rowHelpers(rec, !isStoppedState(row.state), settings, d.env);
+    if (h) row.helpers = h;
+  }
+}
+
+/**
+ * D32: what an agent's row shows of its helpers: counts, and the ones
+ * worth showing (running, or this conversation's ended within
+ * collapse_done_minutes; at most 8). Undefined: none, or its runtime
+ * can't tell. Never throws.
+ */
+export function rowHelpers(
+  rec: AgentRecord,
+  live: boolean,
+  settings: HelperSettings = HELPER_DEFAULTS,
+  env: NodeJS.ProcessEnv = process.env,
+  now = Date.now(),
+): AgentRow["helpers"] {
+  const rt = getRuntime(rec.runtime);
+  if (!rt?.helpers) return undefined;
+  let hs: Helper[] = [];
+  try {
+    hs = rt.helpers(rec, { env, now, settings, agentLive: live });
+  } catch {
+    return undefined;
+  }
+  if (!hs.length) return undefined;
+  const keep = settings.collapseDoneMinutes * 60_000;
+  const shown = hs.filter(
+    (h) =>
+      h.status === "running" ||
+      (!h.earlier && now - (h.lastActivityAt ?? h.startedAt ?? 0) <= keep),
+  );
+  return { ...helperCounts(hs), recent: capHelpers(shown, ROW_HELPERS) };
+}
+
+/** D32: an agent's helpers, read-only, and whether its runtime can tell. */
+export async function agentHelpers(
+  d: AgentsResolved,
+  id: string,
+  ws?: string,
+): Promise<{
+  rec: AgentRecord;
+  supported: boolean;
+  live: boolean;
+  helpers: Helper[];
+  note: string;
+}> {
+  const rec = agentRecord(d, id, ws);
+  const rt = getRuntime(rec.runtime);
+  const live = await agentLive(d, rec);
+  const helpers =
+    rt?.helpers?.(rec, {
+      env: d.env,
+      settings: helperSettings(d),
+      agentLive: live,
+    }) ?? [];
+  return {
+    rec,
+    supported: !!rt?.helpers,
+    live,
+    helpers,
+    note: HELPERS_READ_ONLY_NOTE,
+  };
+}
+
+/** D32: one of agent `id`'s helpers' transcript; a 404 when there's none. */
+export async function agentHelperTranscript(
+  d: AgentsResolved,
+  id: string,
+  helperId: string,
+  ws?: string,
+  limit?: number,
+): Promise<HelperTranscript & { note: string }> {
+  const rec = agentRecord(d, id, ws);
+  const rt = getRuntime(rec.runtime);
+  const t = rt?.helperTranscript?.(rec, helperId, {
+    env: d.env,
+    settings: helperSettings(d),
+    agentLive: await agentLive(d, rec),
+    ...(limit ? { limit } : {}),
+  });
+  if (!t) throw refused(`agent ${id} has no helper "${helperId}"`, [], 404);
+  return { ...t, note: HELPERS_READ_ONLY_NOTE };
+}
+
+/** Whether agent `rec`'s session runs now (an unreachable host: no). */
+async function agentLive(
+  d: AgentsResolved,
+  rec: AgentRecord,
+): Promise<boolean> {
+  try {
+    const c = await d.connectExisting();
+    if (!c) return false;
+    try {
+      const s = sessionOf(await c.list(), rec);
+      return Boolean(s && !s.exited);
+    } finally {
+      c.close();
+    }
+  } catch {
+    return false;
+  }
+}
+
 // ── personas, runtimes ──────────────────────────────────────────────────────
 
 /** The agents config; an invalid one is a refusal naming the key. */

package/src/ui/cli/agents-command.ts

@@ -70,6 +70,7 @@ import { HostError } from "../../shared/sessions/client.js";
 import { checkHandback } from "../../shared/agents/handback.js";
 import { checkHandoff } from "../../shared/agents/handoff.js";
 import { handoffFile, reasonText } from "../../shared/agents/rotation.js";
+import { shownDepths } from "../../shared/agents/helpers.js";
 import {
   parseRotateValue,
   type OverrideScope,
@@ -84,6 +85,8 @@ import {
   importAgent,
   changePersona,
   listAgents,
+  agentHelpers,
+  agentHelperTranscript,
   listConversations,
   listPersonas as personaList,
   listRuntimes,
@@ -129,7 +132,7 @@ export {
 
 export const AGENTS_HELP = {
   usage:
-    "agents <list|start|stop|resume|relaunch|rotate|keep|handoff|import|persona|rename|rm|personas|doctor|handback-check|handoff-check> ...",
+    "agents <list|start|stop|resume|relaunch|rotate|keep|handoff|import|persona|helpers|rename|rm|personas|doctor|handback-check|handoff-check> ...",
   lines: [
     "Agents: a persona and a workspace, run by a runtime in a session that",
     "outlives the web server (see `{cli} sessions`).",
@@ -167,6 +170,13 @@ export const AGENTS_HELP = {
     "    agent never rotates. A person's only",
     "{cli} agents handoff <id> [-w <ws>]",
     "    ask a running agent, at idle, to write its handoff",
+    "{cli} agents helpers <id> [-w <ws>] [--all] [--json]",
+    "    the helpers it started in its own session (Claude Code's Agent and",
+    "    Workflow subagents): what each does, its type, model, branch, state and",
+    "    times; running first. --all: its earlier conversations' too. Read-only:",
+    "    they belong to the agent's session, so Den can't stop or steer them",
+    "{cli} agents helpers <id> <helper> [-w <ws>] [--limit <n>] [--json]",
+    "    one helper's transcript, tool calls summarized (the last 500 lines)",
     "{cli} agents import -w <ws> [--runtime <r>] [--json]",
     "{cli} agents import -w <ws> --session <id> --persona <p> [--runtime <r>] [--id <id>] [--model <m>]",
     "    bring in a conversation started outside Den: the first lists the runtime's",
@@ -456,6 +466,120 @@ async function persona(args: string[], d: AgentsResolved): Promise<number> {
 }
 
 /** `<id> [-w <ws>]`. */
+/** D32: `agents helpers <id> [<helper>]`, read-only. */
+async function helpers(args: string[], d: AgentsResolved): Promise<number> {
+  const where = "agents helpers";
+  const p = parseArgs(where, args, {
+    "--workspace": true,
+    "--json": false,
+    "--all": false,
+    "--limit": true,
+  });
+  noExtra(where, p, 2);
+  const [id, helperId] = p.positional;
+  if (!id) throw new UsageError(`${where} needs <id>`);
+  const ws = workspaceFlag(where, p);
+  const ago = (ms?: number) =>
+    ms === undefined ? "-" : `${duration(Date.now() - ms)} ago`;
+  if (helperId) {
+    const raw = p.flags["--limit"];
+    const limit = raw === undefined ? undefined : Number(raw);
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 1))
+      throw new UsageError(
+        `${where}: --limit must be a whole number of at least 1`,
+      );
+    const t = await agentHelperTranscript(d, id, helperId, ws, limit);
+    if (p.flags["--json"]) {
+      d.out(JSON.stringify(t, null, 2));
+      return 0;
+    }
+    d.out(
+      `${t.helper.description ?? t.helper.id} (${t.helper.status}, ${t.helper.type ?? "helper"})`,
+    );
+    if (t.omitted) d.out(`… ${t.omitted} earlier lines`);
+    for (const i of t.items) {
+      const lead =
+        i.kind === "tool"
+          ? `→ ${i.tool}: `
+          : i.kind === "result"
+            ? i.error
+              ? "  ✗ "
+              : "  ← "
+            : i.kind === "prompt"
+              ? "asked: "
+              : i.kind === "note"
+                ? "… "
+                : "";
+      d.out(`${lead}${i.text}`);
+    }
+    d.out("");
+    d.out(t.note);
+    return 0;
+  }
+  const r = await agentHelpers(d, id, ws);
+  const shown = p.flags["--all"]
+    ? r.helpers
+    : r.helpers.filter((h) => !h.earlier);
+  if (p.flags["--json"]) {
+    d.out(
+      JSON.stringify(
+        {
+          agent: r.rec.id,
+          supported: r.supported,
+          live: r.live,
+          helpers: shown,
+          note: r.note,
+        },
+        null,
+        2,
+      ),
+    );
+    return 0;
+  }
+  if (!r.supported) {
+    d.out(`${r.rec.runtime} can't tell which helpers ${r.rec.id} started`);
+    return 0;
+  }
+  const earlier = r.helpers.length - r.helpers.filter((h) => !h.earlier).length;
+  if (!shown.length) {
+    d.out(
+      `${r.rec.id} has started no helpers${earlier && !p.flags["--all"] ? ` in this conversation (${earlier} earlier: --all)` : ""}`,
+    );
+    return 0;
+  }
+  const depth = shownDepths(shown);
+  for (const l of columns([
+    ["HELPER", "WHAT", "TYPE", "MODEL", "STATE", "STARTED", "FOR", "BRANCH"],
+    ...shown.map((h) => [
+      `${"  ".repeat(depth.get(h.id) ?? 0)}${h.id}`,
+      (h.description ?? "-").slice(0, 48),
+      h.workflow
+        ? `${h.type ?? "-"} (${h.workflow.name ?? "workflow"})`
+        : (h.type ?? "-"),
+      h.model ?? "-",
+      `${h.status}${h.earlier ? " (earlier)" : ""}`,
+      ago(h.startedAt),
+      h.durationMs === undefined ? "-" : duration(h.durationMs),
+      h.branch ?? "-",
+    ]),
+  ]))
+    d.out(l);
+  if (earlier && !p.flags["--all"])
+    d.out(`${earlier} more from earlier conversations: --all`);
+  d.out("");
+  d.out(r.note);
+  return 0;
+}
+
+/** 65 s → "1m 5s"; 2 h → "2h 0m". */
+function duration(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+
 function idAndWorkspace(
   where: string,
   args: string[],
@@ -962,6 +1086,8 @@ export async function cmdAgents(
         case "persona":
           await loadAgentWorkspaces(deps);
           return await persona(rest, d);
+        case "helpers":
+          return await helpers(rest, d);
         case "rename":
           return rename(rest, d);
         case "rm":

package/src/ui/mcp/api.ts

@@ -147,8 +147,9 @@ const ACTION_ROUTES: Record<string, string> = {
 };
 
 /**
- * Action routes with a parameter: an agent's resume (MCP agent_resume),
- * and Bring in's list and import (MCP agent_import, AG-17.1).
+ * Routes with a parameter: an agent's resume (MCP agent_resume), Bring
+ * in's list and import (MCP agent_import, AG-17.1), and an agent's helpers
+ * (MCP agent_helpers, D32, GET only).
  */
 const ACTION_ROUTE_PATTERNS: { re: RegExp; method: string }[] = [
   // One held request's state (its own, the server checks). Never /decide.
@@ -161,6 +162,11 @@ const ACTION_ROUTE_PATTERNS: { re: RegExp; method: string }[] = [
     re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/conversations$/,
     method: "GET",
   },
+  // D32 (MCP agent_helpers): an agent's helpers, or one's transcript. Reads.
+  {
+    re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/agents\/[A-Za-z0-9._-]{1,64}\/helpers(?:\/[A-Za-z0-9_-]{1,128})?$/,
+    method: "GET",
+  },
   {
     re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/conversations\/[A-Za-z0-9][A-Za-z0-9_-]{0,127}\/import$/,
     method: "POST",