@mnemom/mnemom 0.17.20-next.0 → 0.17.21

package/plugins/mnemom/hooks/register.tsx

@@ -0,0 +1,1476 @@
+/**
+ * Mnemom for Claude Code — the hooks module.
+ *
+ * `mnemom agent` launches stock Claude Code with its model traffic routed through the Mnemom
+ * gateway (ANTHROPIC_BASE_URL → <gateway>/anthropic, the Mnemom key and the governed identity in
+ * ANTHROPIC_CUSTOM_HEADERS; under Remote Control a local proxy does the same). This mod is what
+ * the person SEES of that: the Mnemom band above the prompt, `/mnemom` commands, the Mnemom sign on
+ * the spinner and the turn line, Mnemom trailers in commit attribution, a governance section in
+ * the system prompt — and a guard that keeps the session routed.
+ *
+ * The launcher tells the mod about the launch through NON-SECRET env vars (`MNEMOM_CC_*`, set by
+ * cli/src/lib/claude-plugin.ts). No key, no header value ever reaches this module: a mod reads
+ * `$.env.get` by literal name and `claude plugin validate` lists every name it reads.
+ *
+ * Mnemom is the trust plane for the agentic internet: https://www.mnemom.ai
+ */
+
+import { atom, read, update, type Register, type StateDollar } from "claude-code";
+
+import type {
+  MnemomCeilings,
+  MnemomContract,
+  MnemomGoal,
+  MnemomLaunch,
+  MnemomReputation,
+  MnemomVerdict,
+} from "../types";
+
+const PLUGIN = "mnemom";
+const SIGN = "◆";
+/** The status pane's id (`$.ui.open`, the `Pane` render hook, `/mnemom panel`). */
+const PANE = "mnemom-status";
+
+/**
+ * The intro: on session start the band reveals the header left to right, holds it with a slow
+ * pulse of the name, then drops to the one-row band. 15 reveal frames + 24 hold frames at
+ * 60 ms ≈ 2.3 s.
+ */
+const INTRO_FRAME_MS = 60;
+const INTRO_REVEAL_FRAMES = 15;
+const INTRO_HOLD_FRAMES = 24;
+const INTRO_FRAMES = INTRO_REVEAL_FRAMES + INTRO_HOLD_FRAMES;
+
+// Brand: the name in the site's teal (mnemom-website/client/global.css); the mark is the
+// logo's glyph, traced once from the logo PNG into cells in its own gold (MARK_MU below).
+// Terminal colours are hex where the surface supports truecolor and the nearest ANSI colour
+// elsewhere.
+const TEAL = "#14b8a6";
+const TEAL_BRIGHT = "#2dd4bf";
+const WARN = "#f59e0b";
+const BAD = "#ef4444";
+/** The gold of the logo's glyph: the ◆ sign on the one-row band. */
+const GOLD = "#e0a040";
+
+// ── the logo's glyph, traced once from the brand PNG (the tracer is not in the tree; the
+// rows below are the result and are edited by hand if the mark ever changes) ──
+/** The glyph's gold as the trace found it in the logo. */
+const MARK_GOLD = "#d89838";
+/** The logo's glyph at 4 rows × 11 cells, a quadrant block per cell (its four dots), `.` where all four are off. */
+// prettier-ignore
+const MARK_MU: readonly string[] = [
+  "▗█▀▀█▙..██.",
+  "██..██..██.",
+  "██..██..██.",
+  "██..▜█▄▄▜█▄",
+];
+// ── end of the traced glyph ──
+
+/** One run of same-coloured cells in a row of the artwork; `dim`/`bold` mark text, not painted cells. */
+type Seg = { t: string; fg: string; bg?: string; dim?: boolean; bold?: boolean; inverse?: boolean };
+
+/** The quadrant block for each dot pattern; bits top-left 1, top-right 2, bottom-left 4, bottom-right 8. */
+const QUADRANTS = " ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█";
+
+/**
+ * The traced mark's rows → runs of terminal cells. A row is one character per cell: a quadrant
+ * block (the cell's four square dots, lit where the glyph is) in the glyph's gold, the way Claude
+ * Code draws its own mascot; `.` a cell with no dot lit. Only the Block Elements glyphs (█ ▀ ▄ ▌ ▐
+ * and the quarters), which every monospace font carries; the finer sextant and octant blocks are
+ * drawn from a fallback font and leave seams. A FULL cell (█) is PAINTED, not drawn: a space on
+ * the gold as its background. A glyph is drawn inside the glyph box, which is smaller than the
+ * cell wherever the terminal has line spacing or letter spacing, so a mark drawn in glyphs alone
+ * tiles with a grid of gaps (the nu showed one); a background fills the whole cell, spacing and
+ * all, so the stems and the body run unbroken, and only the partial cells at the crown, the floor,
+ * the corners and the tail are glyphs, meeting the painted cells where the glyph box ends. Where
+ * the glyph box sits is the terminal's: in one that draws the blocks from the font (cmux does)
+ * it starts about a fifth of the way down the cell and ends near its bottom, inset a little at
+ * the sides, so a glyph lit across its TOP (▀ ▜ ▛) drawn plainly hangs a fifth of a cell below
+ * the painted cells beside it — the crown sank below the stems' tops, and ▜ at a stem's foot left
+ * a dark slot across the stem — and drawn inverse (gold behind, the complement cut out) it shows
+ * the cell's margin as a gold rim around the cut-out, in a duller reverse-video gold. So the
+ * forms are these. A cell lit in its top half alone (▀, the crown) is PAINTED WHOLE: the logo's
+ * stroke is one width throughout and the stems are two dots wide, so the crown is that stroke,
+ * which the dot grid happened to split across a row boundary. A cell lit across its top and in
+ * ONE bottom dot (▛ ▜: a stem's foot, its outer corner rounded by the one dot that is off) is
+ * drawn INVERSE, its gold as the background and the missing dot cut out of it in the terminal's
+ * own background colour: the rounding is the point of the cell, a
+ * plain glyph there leaves a slot across the stem, and the rim is the price of the curve. A cell
+ * lit only below, or in one top corner (▄ ▗ ▙ ▟), stays a plain glyph: it rests on the cell's
+ * bottom, and it is what rounds the shoulders and flicks the tail. Where a terminal draws the
+ * blocks to the whole cell this changes nothing but the crown's weight, which is the logo's.
+ */
+function markRows(mark: readonly string[]): Seg[][] {
+  return mark.map((line) => {
+    const row: Seg[] = [];
+    for (const ch of Array.from(line)) {
+      const bits = QUADRANTS.indexOf(ch === "." ? " " : ch);
+      const seg: Seg =
+        bits === 15 || bits === 3
+          ? { t: " ", fg: MARK_GOLD, bg: MARK_GOLD }
+          : bits === 7 || bits === 11
+            ? { t: QUADRANTS[15 - bits] ?? " ", fg: MARK_GOLD, inverse: true }
+            : { t: bits > 0 ? ch : " ", fg: MARK_GOLD };
+      const last = row[row.length - 1];
+      if (last !== undefined && last.bg === seg.bg && last.inverse === seg.inverse) last.t += seg.t;
+      else row.push(seg);
+    }
+    return row;
+  });
+}
+
+/**
+ * The header, the shape of Claude Code's own (its mark beside "Claude Code v…", a line of text
+ * under that): the logo's glyph alone — the gold "nu" at its centre, traced from the logo PNG
+ * into quadrant blocks, four square dots to a cell, full cells painted; the whole logo is a colour
+ * blob at this size — beside `Mnemom` in bold teal with the launching CLI's version after it, and
+ * the tagline beneath, the two lines centred on the mark's rows. The glyph is four rows (eight
+ * dots) tall, a row over Claude Code's own header. The band's intro shows it, the status pane
+ * heads with it.
+ */
+const MARK_HEADER = markRows(MARK_MU);
+const WORD = "Mnemom";
+const TAGLINE = "the trust plane for the agentic internet";
+
+function cellsOf(row: readonly Seg[]): number {
+  return row.reduce((n, s) => n + s.t.length, 0);
+}
+function markColumns(mark: readonly (readonly Seg[])[]): number {
+  return Math.max(0, ...mark.map(cellsOf));
+}
+
+/** The text lines sit two cells right of the mark, centred on its rows. */
+const HEADER_INDENT = markColumns(MARK_HEADER) + 2;
+const HEADER_ROWS = Math.max(MARK_HEADER.length, 2);
+const HEADER_TEXT_ROW = Math.floor((HEADER_ROWS - 2) / 2);
+function headerColumns(version: string): number {
+  return HEADER_INDENT + Math.max(WORD.length + (version ? version.length + 2 : 0), TAGLINE.length);
+}
+/** The header in the given word colour (the glyph keeps the logo's gold); `version` may be empty. */
+function header(wordColor: string, version: string): Seg[][] {
+  const lines: Seg[][] = [
+    version
+      ? [
+          { t: WORD, fg: wordColor, bold: true },
+          { t: ` v${version}`, fg: wordColor, dim: true },
+        ]
+      : [{ t: WORD, fg: wordColor, bold: true }],
+    [{ t: TAGLINE, fg: wordColor, dim: true }],
+  ];
+  const rows = Array.from({ length: HEADER_ROWS }, (_, i) => [...(MARK_HEADER[i] ?? [])]);
+  return rows.map((row, i) => {
+    const line = lines[i - HEADER_TEXT_ROW];
+    if (line === undefined) return row;
+    return [...row, { t: " ".repeat(HEADER_INDENT - cellsOf(row)), fg: wordColor }, ...line];
+  });
+}
+
+/** The first `n` cells of a row of segments (the intro reveals the artwork left to right). */
+function cut(row: readonly Seg[], n: number): Seg[] {
+  const out: Seg[] = [];
+  let left = n;
+  for (const s of row) {
+    if (left <= 0) break;
+    out.push(left >= s.t.length ? s : { ...s, t: s.t.slice(0, left) });
+    left -= s.t.length;
+  }
+  return out;
+}
+
+const launch = atom({ plugin: "mnemom", key: "launch" } as const, null);
+const reputation = atom({ plugin: "mnemom", key: "reputation" } as const, null);
+const isHidden = atom({ plugin: "mnemom", key: "isHidden" } as const, false);
+const turns = atom({ plugin: "mnemom", key: "turns" } as const, 0);
+/** The intro's frame while it plays; -1 once it is over (the band is then one row). */
+const introFrame = atom({ plugin: "mnemom", key: "introFrame" } as const, -1);
+/** The live goal state (verdict, inferred goal, guardrail usage); null when not governed. */
+const goal = atom({ plugin: "mnemom", key: "goal" } as const, null);
+
+/** Refresh the Trust Rating every this many completed turns. */
+const REPUTATION_REFRESH_TURNS = 10;
+/**
+ * How long after a turn completes the live goal state is re-read: the gateway stores the turn's
+ * verdict (and, implicit, any goal revision) as the response closes, a moment before the turn ends
+ * here; the short wait lets that write land before `mnemom agent show` reads it.
+ */
+const GOAL_REFRESH_DELAY_MS = 1500;
+/** How long one `mnemom agent … --json` may take before it reads as unavailable. */
+const GOAL_READ_TIMEOUT_MS = 8000;
+
+/**
+ * The Trust Rating lookup in flight, if any. Started beside the session start (never in its way),
+ * awaited by `/mnemom status` and `/mnemom doctor` so they report a settled rating, and swallowed
+ * when it fails: the atom already carries the error state for the band to show.
+ */
+let reputationInFlight: Promise<unknown> | undefined;
+/** The live goal read in flight, if any; `/mnemom goal` and `/mnemom status` await it. */
+let goalInFlight: Promise<unknown> | undefined;
+
+/** A Bash command that would point the session away from the gateway, or drop its identity. */
+const REROUTE_RE =
+  /(^|[\s;&|(`])(unset\s+ANTHROPIC_(BASE_URL|CUSTOM_HEADERS|AUTH_TOKEN)\b|(export\s+)?ANTHROPIC_(BASE_URL|CUSTOM_HEADERS|AUTH_TOKEN)=)/;
+
+type Options = {
+  showBand: boolean;
+  requireGovernance: boolean;
+  guardReroute: boolean;
+  commitTrailer: boolean;
+  spinnerMark: boolean;
+};
+
+function readOptions(raw: Readonly<Record<string, unknown>>): Options {
+  const flag = (name: keyof Options, fallback: boolean): boolean =>
+    typeof raw[name] === "boolean" ? (raw[name] as boolean) : fallback;
+  return {
+    showBand: flag("showBand", true),
+    requireGovernance: flag("requireGovernance", false),
+    guardReroute: flag("guardReroute", true),
+    commitTrailer: flag("commitTrailer", true),
+    spinnerMark: flag("spinnerMark", true),
+  };
+}
+
+/** The launch facts, when `mnemom agent` exported them; null for a session it did not launch. */
+async function readLaunch($: {
+  env: { get: (name: string) => Promise<string | undefined> };
+}): Promise<MnemomLaunch | null> {
+  // Literal names only: `$.env.get` is pinned to the names the module spells out.
+  const gatewayHost = ((await $.env.get("MNEMOM_CC_GATEWAY_HOST")) ?? "").trim();
+  const agent = ((await $.env.get("MNEMOM_CC_AGENT")) ?? "").trim();
+  if (!gatewayHost || !agent) return null;
+  const mode = ((await $.env.get("MNEMOM_CC_GOAL_MODE")) ?? "off").trim();
+  const goalMode = mode === "sealed" || mode === "implicit" ? mode : "off";
+  const sealed =
+    goalMode === "sealed" ? parseContract((await $.env.get("MNEMOM_CC_CONTRACT")) ?? "") : null;
+  const ceilings =
+    sealed !== null
+      ? sealed.ceilings
+      : goalMode === "implicit"
+        ? parseGuardrails((await $.env.get("MNEMOM_CC_GUARDRAILS")) ?? "")
+        : NO_CEILINGS;
+  return {
+    gatewayHost: gatewayHost.replace(/\/+$/, ""),
+    apiUrl: (((await $.env.get("MNEMOM_CC_API_URL")) ?? "") || "https://api.mnemom.ai")
+      .trim()
+      .replace(/\/+$/, ""),
+    agent,
+    conversationId: ((await $.env.get("MNEMOM_CC_CONVERSATION_ID")) ?? "").trim(),
+    cell: ((await $.env.get("MNEMOM_CC_CELL")) ?? "").trim() || gatewayHost,
+    shape: ((await $.env.get("MNEMOM_CC_SHAPE")) ?? "terminal").trim(),
+    goalMode,
+    contractSha: ((await $.env.get("MNEMOM_CC_CONTRACT_SHA")) ?? "").trim(),
+    contract: sealed?.contract ?? null,
+    ceilings,
+    launcherExec: parseExec((await $.env.get("MNEMOM_CC_LAUNCHER_EXEC")) ?? ""),
+    session: ((await $.env.get("MNEMOM_CC_SESSION")) ?? "").trim(),
+    launcherVersion: ((await $.env.get("MNEMOM_CC_LAUNCHER_VERSION")) ?? "").trim(),
+  };
+}
+
+function reputationUrl(l: MnemomLaunch): string {
+  return `${l.apiUrl}/v1/reputation/${encodeURIComponent(l.agent)}`;
+}
+
+function asRecord(text: string): Record<string, unknown> | null {
+  try {
+    const v: unknown = JSON.parse(text);
+    return v !== null && typeof v === "object" && !Array.isArray(v)
+      ? (v as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function num(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+
+function str(v: unknown): string | null {
+  return typeof v === "string" && v.trim() ? v.trim() : null;
+}
+
+function strList(v: unknown): string[] {
+  return Array.isArray(v) ? v.map(str).filter((x): x is string => x !== null) : [];
+}
+
+function rec(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+/** One line of it: whitespace runs (and the newlines a statement may carry) become one space. */
+function oneLine(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+const NO_CEILINGS: MnemomCeilings = { maxTurns: null, budgetUsd: null, stallTurns: null };
+
+/** A positive finite number, else null (the gateway's `null = inactive` reads the same way). */
+function ceiling(v: unknown): number | null {
+  const n = num(v);
+  return n !== null && n > 0 ? n : null;
+}
+
+/** The sealed contract's canonical JSON (MNEMOM_CC_CONTRACT), as the launcher sealed it. */
+function parseContract(
+  text: string,
+): { contract: MnemomContract; ceilings: MnemomCeilings } | null {
+  const body = asRecord(text);
+  if (!body) return null;
+  const statement = str(body.statement);
+  if (statement === null) return null;
+  return {
+    contract: {
+      goalId: str(body.goal_id),
+      statement,
+      requirements: strList(body.requirements),
+      allowedPaths: strList(body.allowed_paths),
+      forbiddenPaths: strList(body.forbidden_paths),
+    },
+    ceilings: {
+      maxTurns: ceiling(body.max_turns),
+      budgetUsd: ceiling(body.budget_usd),
+      stallTurns: ceiling(body.stall_turns),
+    },
+  };
+}
+
+/** `max_turns=40; budget_usd=5; stall_turns=6` (MNEMOM_CC_GUARDRAILS) → ceilings. */
+function parseGuardrails(text: string): MnemomCeilings {
+  const out: MnemomCeilings = { ...NO_CEILINGS };
+  for (const part of text.split(";")) {
+    const [k, v] = part.split("=").map((x) => x.trim());
+    if (!k || v === undefined) continue;
+    const n = ceiling(Number(v));
+    if (k === "max_turns") out.maxTurns = n;
+    else if (k === "budget_usd") out.budgetUsd = n;
+    else if (k === "stall_turns") out.stallTurns = n;
+  }
+  return out;
+}
+
+/** MNEMOM_CC_LAUNCHER_EXEC: a JSON argv, every element a non-empty string; else empty. */
+function parseExec(text: string): string[] {
+  try {
+    const v: unknown = JSON.parse(text);
+    return Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === "string" && x.trim())
+      ? (v as string[])
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+/** GET /v1/reputation/{agent}: the public Trust Rating. Never throws. */
+async function fetchReputation(
+  $: { http: { fetch: (url: string) => Promise<{ ok: boolean; status: number; text: string }> } },
+  l: MnemomLaunch,
+  now: number,
+): Promise<MnemomReputation> {
+  try {
+    const res = await $.http.fetch(reputationUrl(l));
+    if (res.status === 404) return { state: "unrated", checkpointCount: null, fetchedAt: now };
+    if (!res.ok) return { state: "error", reason: `HTTP ${res.status}`, fetchedAt: now };
+    const body = asRecord(res.text);
+    if (!body) return { state: "error", reason: "unreadable body", fetchedAt: now };
+    const grade = str(body.grade);
+    const score = num(body.score);
+    const checkpointCount = num(body.checkpoint_count);
+    const eligible = body.is_eligible;
+    if (!grade || grade === "NR" || score === null || eligible === false) {
+      return { state: "unrated", checkpointCount, fetchedAt: now };
+    }
+    return {
+      state: "rated",
+      grade,
+      score,
+      tier: str(body.tier),
+      checkpointCount,
+      fetchedAt: now,
+    };
+  } catch (err) {
+    return {
+      state: "error",
+      reason: err instanceof Error ? err.message : String(err),
+      fetchedAt: now,
+    };
+  }
+}
+
+type RunDollar = {
+  process: {
+    run: (
+      argv: readonly string[],
+      init?: { timeoutMs?: number },
+    ) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
+  };
+};
+
+/**
+ * `mnemom agent <args> --json` through the launcher's own argv: the CLI authenticates with the
+ * launch key from its ledger, so the key never passes through here. Resolves the parsed object or
+ * throws with the CLI's first stderr line.
+ */
+async function runCli(
+  $: RunDollar,
+  l: MnemomLaunch,
+  args: readonly string[],
+): Promise<Record<string, unknown>> {
+  const what = `mnemom ${args.filter((a) => a !== "--json").join(" ")}`;
+  const res = await $.process.run([...l.launcherExec, ...args], {
+    timeoutMs: GOAL_READ_TIMEOUT_MS,
+  });
+  if (res.exitCode !== 0) {
+    const why = oneLine(res.stderr.split("\n").find((x) => x.trim()) ?? "");
+    throw new Error(`${what} exited ${res.exitCode}${why ? `: ${why}` : ""}`);
+  }
+  // The JSON is the whole of stdout; a notice printed before it is skipped.
+  const at = res.stdout.indexOf("{");
+  const body = at >= 0 ? asRecord(res.stdout.slice(at)) : null;
+  if (!body) throw new Error(`${what}: unreadable output`);
+  return body;
+}
+
+function parseVerdict(v: unknown): MnemomVerdict | null {
+  const r = rec(v);
+  const word = r ? str(r.verdict) : null;
+  if (!r || word === null) return null;
+  return { verdict: word, turn: num(r.turn), reason: str(r.reason), at: str(r.at) };
+}
+
+/**
+ * The live goal state. Sealed: `mnemom agent show` (the gateway's hash, the verdict, guardrail
+ * usage). Implicit: that plus `mnemom agent goal show` (the inferred goal, its revision and pin).
+ * Never throws: a failed read is the `unavailable` state with its reason.
+ */
+async function fetchGoal($: RunDollar, l: MnemomLaunch, now: number): Promise<MnemomGoal> {
+  const unavailable = (reason: string): MnemomGoal => ({
+    state: "unavailable",
+    reason,
+    fetchedAt: now,
+  });
+  // Every caller already skips `off`; this line is what narrows `l.goalMode` to the two live modes
+  // for `live.mode` below, so the plugin type-checks (tsc -p cli/plugins/mnemom).
+  if (l.goalMode === "off") return unavailable("goal alignment is off for this launch");
+  if (l.launcherExec.length === 0) return unavailable("the launcher did not say how to run mnemom");
+  if (!l.conversationId) return unavailable("the launcher did not say the conversation id");
+
+  const live: Extract<MnemomGoal, { state: "live" }> = {
+    state: "live",
+    fetchedAt: now,
+    mode: l.goalMode,
+    hash: null,
+    revision: null,
+    pinned: null,
+    pendingCount: null,
+    statement: l.contract?.statement ?? null,
+    requirements: l.contract?.requirements ?? [],
+    allowedPaths: l.contract?.allowedPaths ?? [],
+    forbiddenPaths: l.contract?.forbiddenPaths ?? [],
+    ceilings: { ...l.ceilings },
+    usage: null,
+    verdict: null,
+    turn: null,
+  };
+  const reasons: string[] = [];
+  let answered = false;
+
+  try {
+    const show = await runCli($, l, ["agent", "show", l.conversationId, "--json"]);
+    const view = rec(show.live);
+    if (view && view.available === true) {
+      answered = true;
+      const sealed = rec(view.sealed);
+      const contract = sealed ? rec(sealed.contract) : null;
+      if (sealed) live.hash = str(sealed.hash);
+      if (contract) {
+        live.statement = str(contract.statement) ?? live.statement;
+        live.requirements = strList(contract.requirements);
+        live.allowedPaths = strList(contract.allowed_paths);
+        live.forbiddenPaths = strList(contract.forbidden_paths);
+      }
+      const guardrails = rec(view.guardrails);
+      const ceilings = guardrails ? rec(guardrails.ceilings) : null;
+      if (ceilings) {
+        live.ceilings = {
+          maxTurns: ceiling(ceilings.max_turns) ?? live.ceilings.maxTurns,
+          budgetUsd: ceiling(ceilings.budget_usd) ?? live.ceilings.budgetUsd,
+          stallTurns: ceiling(ceilings.stall_turns) ?? live.ceilings.stallTurns,
+        };
+      }
+      const usage = guardrails ? rec(guardrails.state) : null;
+      if (usage) {
+        const fired = rec(usage.fired) ?? {};
+        live.usage = {
+          turns: num(usage.turns) ?? 0,
+          spendUsd: num(usage.spend_usd) ?? 0,
+          stallRun: num(usage.stall_run) ?? 0,
+          fired: Object.keys(fired).filter((k) => fired[k] === true),
+        };
+      }
+      live.verdict = parseVerdict(view.verdict);
+      live.turn = num(view.turn);
+    } else {
+      reasons.push(str(view?.reason) ?? "the gateway did not answer `mnemom agent show`");
+    }
+  } catch (err) {
+    reasons.push(err instanceof Error ? err.message : String(err));
+  }
+
+  if (l.goalMode === "implicit") {
+    try {
+      const g = await runCli($, l, ["agent", "goal", "show", l.conversationId, "--json"]);
+      // `mnemom agent goal show --json` → `{ gateway: {…}, ledger: {…} }`, the gateway part the live one.
+      const gw = rec(g.gateway) ?? g;
+      const intent = rec(gw.intent);
+      answered = true;
+      if (intent) {
+        live.hash = str(intent.contract_hash) ?? live.hash;
+        live.revision = num(intent.revision);
+        live.pinned = rec(intent.pinned) !== null;
+        live.pendingCount = num(intent.pending_count);
+        live.statement = str(intent.statement);
+        live.requirements = strList(intent.requirements);
+        live.allowedPaths = strList(intent.allowed_paths);
+        live.forbiddenPaths = strList(intent.forbidden_paths);
+      } else {
+        live.revision = num(gw.last_revision) ?? 0;
+        live.pinned = false;
+      }
+      live.verdict ??= parseVerdict(gw.verdict);
+    } catch (err) {
+      reasons.push(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  // Every path that leaves `answered` false pushed a reason first, so the join is never empty.
+  return answered ? live : unavailable(reasons.join("; "));
+}
+
+function gradeColor(grade: string): string {
+  if (/^A/.test(grade)) return TEAL_BRIGHT;
+  if (/^B/.test(grade)) return TEAL;
+  if (/^C/.test(grade)) return WARN;
+  return BAD;
+}
+
+function trustWord(r: MnemomReputation | null): string {
+  if (r === null || r.state === "loading") return "trust …";
+  if (r.state === "rated") return `trust ${r.grade} ${r.score}`;
+  if (r.state === "unrated") {
+    return r.checkpointCount !== null ? `trust NR (building ${r.checkpointCount}/50)` : "trust NR";
+  }
+  return "trust ?";
+}
+
+/** How long ago, for the pane: `just now`, `42s ago`, `3m ago`, `2h ago`. */
+function ago(now: number, then: number): string {
+  const s = Math.max(0, Math.round((now - then) / 1000));
+  if (s < 5) return "just now";
+  if (s < 90) return `${s}s ago`;
+  const m = Math.round(s / 60);
+  if (m < 90) return `${m}m ago`;
+  return `${Math.round(m / 60)}h ago`;
+}
+
+/** The Trust Rating spelled out for the pane. */
+function trustDetail(r: MnemomReputation | null, now: number): string {
+  if (r === null || r.state === "loading") return "fetching …";
+  if (r.state === "rated") {
+    const parts = [`${r.grade} ${r.score}`];
+    if (r.tier) parts.push(`tier ${r.tier}`);
+    if (r.checkpointCount !== null) parts.push(`${r.checkpointCount} checkpoints`);
+    parts.push(`refreshed ${ago(now, r.fetchedAt)}`);
+    return parts.join(" · ");
+  }
+  if (r.state === "unrated") {
+    return r.checkpointCount !== null
+      ? `not rated yet · building ${r.checkpointCount}/50 checkpoints · checked ${ago(now, r.fetchedAt)}`
+      : `not rated yet · checked ${ago(now, r.fetchedAt)}`;
+  }
+  return `unavailable · ${r.reason} · tried ${ago(now, r.fetchedAt)}`;
+}
+
+type LiveGoal = Extract<MnemomGoal, { state: "live" }>;
+
+function liveGoal(g: MnemomGoal | null): LiveGoal | null {
+  return g !== null && g.state === "live" ? g : null;
+}
+
+function verdictColor(v: MnemomVerdict | null): string | undefined {
+  if (v === null) return undefined;
+  if (v.verdict === "aligned") return TEAL;
+  if (v.verdict === "drifting") return WARN;
+  if (v.verdict === "violation") return BAD;
+  return undefined;
+}
+
+/** The goal's mode, hash/revision and pin for the pane's `goal` row. */
+function goalDetail(l: MnemomLaunch, g: MnemomGoal | null): string {
+  const live = liveGoal(g);
+  if (l.goalMode === "sealed") {
+    const parts = ["sealed contract"];
+    if (l.contractSha) parts.push(l.contractSha);
+    if (live?.hash && !l.contractSha.startsWith(live.hash) && !live.hash.startsWith(l.contractSha))
+      parts.push(`gateway hash ${live.hash}`);
+    if (l.contract?.goalId) parts.push(`goal id ${l.contract.goalId}`);
+    return parts.join(" · ");
+  }
+  if (l.goalMode === "implicit") {
+    const parts = ["implicit · inferred from your messages"];
+    if (live) {
+      parts.push(
+        live.revision === null || live.revision === 0
+          ? "no revision yet"
+          : `revision ${live.revision}`,
+      );
+      if (live.pinned) parts.push("pinned");
+      if (live.pendingCount) parts.push(`${live.pendingCount} pending`);
+    }
+    return parts.join(" · ");
+  }
+  return 'off · launch with --goal "…" (sealed) or --implicit';
+}
+
+/** The goal statement as best known: the gateway's (live) over the launch's (sealed contract). */
+function goalStatement(l: MnemomLaunch, g: MnemomGoal | null): string | null {
+  return liveGoal(g)?.statement ?? l.contract?.statement ?? null;
+}
+
+function goalRequirements(l: MnemomLaunch, g: MnemomGoal | null): string[] {
+  const live = liveGoal(g);
+  return live !== null ? live.requirements : (l.contract?.requirements ?? []);
+}
+
+function goalPaths(
+  l: MnemomLaunch,
+  g: MnemomGoal | null,
+): { allowed: string[]; forbidden: string[] } {
+  const live = liveGoal(g);
+  return {
+    allowed: live?.allowedPaths ?? l.contract?.allowedPaths ?? [],
+    forbidden: live?.forbiddenPaths ?? l.contract?.forbiddenPaths ?? [],
+  };
+}
+
+function goalCeilings(l: MnemomLaunch, g: MnemomGoal | null): MnemomCeilings {
+  return liveGoal(g)?.ceilings ?? l.ceilings;
+}
+
+function usd(n: number): string {
+  return `$${n.toFixed(n < 10 ? 2 : 0)}`;
+}
+
+/** The pane's `paths` row: `allowed: a, b · forbidden: c`, or `no path fences`. */
+function pathsDetail(paths: { allowed: string[]; forbidden: string[] }): string {
+  const parts: string[] = [];
+  if (paths.allowed.length > 0) parts.push(`allowed: ${paths.allowed.join(", ")}`);
+  if (paths.forbidden.length > 0) parts.push(`forbidden: ${paths.forbidden.join(", ")}`);
+  return parts.length > 0 ? parts.join(" · ") : "no path fences";
+}
+
+/**
+ * The guardrails row: each ceiling with its usage, `max turns 40 (12 used)`, `budget $5.00
+ * ($1.23 spent)`, `stall 6 (run 2)`; `FIRED` on one that tripped; `none set` when there are none.
+ */
+function guardrailDetail(
+  l: MnemomLaunch,
+  g: MnemomGoal | null,
+): { text: string; color: string | undefined } {
+  const c = goalCeilings(l, g);
+  const u = liveGoal(g)?.usage ?? null;
+  const parts: string[] = [];
+  let color: string | undefined;
+  const warnAt = (used: number, cap: number) => {
+    if (used / cap >= 0.8 && color !== BAD) color = WARN;
+  };
+  if (c.maxTurns !== null) {
+    let t = `max turns ${c.maxTurns}`;
+    if (u) {
+      t += ` (${u.turns} used)`;
+      warnAt(u.turns, c.maxTurns);
+    }
+    if (u?.fired.includes("turns")) t += " FIRED";
+    parts.push(t);
+  }
+  if (c.budgetUsd !== null) {
+    let t = `budget ${usd(c.budgetUsd)}`;
+    if (u) {
+      t += ` (${usd(u.spendUsd)} spent)`;
+      warnAt(u.spendUsd, c.budgetUsd);
+    }
+    if (u?.fired.includes("budget")) t += " FIRED";
+    parts.push(t);
+  }
+  if (c.stallTurns !== null) {
+    let t = `stall ${c.stallTurns} turns`;
+    if (u) {
+      t += ` (run ${u.stallRun})`;
+      warnAt(u.stallRun, c.stallTurns);
+    }
+    if (u?.fired.includes("stall")) t += " FIRED";
+    parts.push(t);
+  }
+  if (u && u.fired.length > 0) color = BAD;
+  return { text: parts.length > 0 ? parts.join(" · ") : "none set", color };
+}
+
+/** The verdict row: `aligned · turn 3 · <reason> · 12s ago`, or why there is none. */
+function verdictDetail(g: MnemomGoal | null, now: number): string {
+  if (g === null || g.state === "loading") return "reading …";
+  if (g.state === "unavailable")
+    return `unavailable · ${g.reason} · tried ${ago(now, g.fetchedAt)}`;
+  if (g.verdict === null) return `no verdict yet · read ${ago(now, g.fetchedAt)}`;
+  const parts = [g.verdict.verdict];
+  if (g.verdict.turn !== null) parts.push(`turn ${g.verdict.turn}`);
+  if (g.verdict.reason) parts.push(oneLine(g.verdict.reason));
+  parts.push(`read ${ago(now, g.fetchedAt)}`);
+  return parts.join(" · ");
+}
+
+/**
+ * The goal rows of the pane and `/mnemom status`: goal, statement, requirements, paths, guardrails,
+ * verdict. Only the `goal` row when goal alignment is off.
+ */
+function goalRows(
+  l: MnemomLaunch,
+  g: MnemomGoal | null,
+  now: number,
+): Array<[string, string, string | undefined]> {
+  const rows: Array<[string, string, string | undefined]> = [["goal", goalDetail(l, g), undefined]];
+  if (l.goalMode === "off") return rows;
+  const statement = goalStatement(l, g);
+  rows.push([
+    "statement",
+    statement !== null
+      ? oneLine(statement)
+      : l.goalMode === "implicit"
+        ? "(not inferred yet)"
+        : "(none)",
+    statement !== null ? TEAL : undefined,
+  ]);
+  const reqs = goalRequirements(l, g);
+  rows.push([
+    "requirements",
+    reqs.length > 0 ? `${reqs.length} · ${reqs.map(oneLine).join(" · ")}` : "none",
+    undefined,
+  ]);
+  rows.push(["paths", pathsDetail(goalPaths(l, g)), undefined]);
+  const guard = guardrailDetail(l, g);
+  rows.push(["guardrails", guard.text, guard.color]);
+  rows.push(["verdict", verdictDetail(g, now), verdictColor(liveGoal(g)?.verdict ?? null)]);
+  return rows;
+}
+
+/** `/mnemom goal`: the whole of it, every requirement and path on its own line. */
+function goalText(l: MnemomLaunch, g: MnemomGoal | null, now: number): string {
+  const lines = [`${SIGN} Mnemom goal — ${goalDetail(l, g)}`, ""];
+  if (l.goalMode === "off") {
+    lines.push(
+      '  Goal alignment is off for this session. Launch with --goal "…" (plus --requirement, --allow,',
+      "  --forbid, --max-turns, --budget, --stall) to seal a contract the gateway judges every turn",
+      "  against, or with --implicit to have the gateway infer the goal from your messages.",
+    );
+    return lines.join("\n");
+  }
+  const statement = goalStatement(l, g);
+  lines.push(
+    `  statement:     ${statement !== null ? oneLine(statement) : l.goalMode === "implicit" ? "(not inferred yet — it forms from your first messages)" : "(none)"}`,
+  );
+  const reqs = goalRequirements(l, g);
+  if (reqs.length === 0) lines.push("  requirements:  none");
+  else
+    reqs.forEach((r, i) =>
+      lines.push(`  ${i === 0 ? "requirements:" : "             "}  ${i + 1}. ${oneLine(r)}`),
+    );
+  const paths = goalPaths(l, g);
+  lines.push(`  allowed paths: ${paths.allowed.length > 0 ? paths.allowed.join(", ") : "any"}`);
+  lines.push(
+    `  forbidden:     ${paths.forbidden.length > 0 ? paths.forbidden.join(", ") : "none"}`,
+  );
+  lines.push(`  guardrails:    ${guardrailDetail(l, g).text}`);
+  lines.push(`  verdict:       ${verdictDetail(g, now)}`);
+  const live = liveGoal(g);
+  if (live?.hash) lines.push(`  gateway hash:  ${live.hash}`);
+  if (live?.turn !== null && live?.turn !== undefined) lines.push(`  gateway turn:  ${live.turn}`);
+  lines.push("");
+  if (l.goalMode === "sealed") {
+    lines.push(
+      "  The contract is sealed: the gateway judges every turn against these words and never revises them.",
+      `  manage:        mnemom agent show ${l.conversationId || "<conversation>"}`,
+    );
+  } else {
+    lines.push(
+      "  The goal is implicit: the gateway infers it from your messages and revises it as you steer.",
+      `  manage:        mnemom agent goal show|pin|reset ${l.conversationId || "<conversation>"}`,
+    );
+  }
+  return lines.join("\n");
+}
+
+type PaneDollar = {
+  ui: {
+    open: (pane: {
+      id: string;
+      title?: string;
+      rows?: number;
+      closeOnEscape?: true;
+    }) => Promise<unknown>;
+    close: (pane: { id: string }) => Promise<void>;
+  };
+};
+
+/** Open (or raise) the Mnemom status pane; taller when it has a goal to show. */
+function openStatusPane($: PaneDollar, l: MnemomLaunch | null): Promise<unknown> {
+  const rows = l !== null && l.goalMode !== "off" ? 22 : 16;
+  return $.ui.open({ id: PANE, title: "Mnemom", rows, closeOnEscape: true });
+}
+
+function closeStatusPane($: PaneDollar): Promise<void> {
+  return $.ui.close({ id: PANE });
+}
+
+/** The band's goal word: `goal sealed 01234567 · aligned`, `goal implicit rev 2 · drifting`. */
+function goalWord(l: MnemomLaunch, g: MnemomGoal | null = null): string {
+  const live = liveGoal(g);
+  let word: string;
+  if (l.goalMode === "sealed") {
+    word = `goal sealed${l.contractSha ? ` ${l.contractSha.slice(0, 8)}` : ""}`;
+  } else if (l.goalMode === "implicit") {
+    word = "goal implicit";
+    if (live?.revision) word += ` rev ${live.revision}`;
+    if (live?.pinned) word += " pinned";
+  } else {
+    return "goal off";
+  }
+  if (live?.verdict) word += ` · ${live.verdict.verdict}`;
+  return word;
+}
+
+function statusText(
+  l: MnemomLaunch | null,
+  r: MnemomReputation | null,
+  g: MnemomGoal | null,
+  turnCount: number,
+  now: number,
+): string {
+  if (l === null) {
+    return [
+      `${SIGN} Mnemom for Claude Code — NOT governed`,
+      "",
+      "This session was not launched by `mnemom agent`, so its model traffic is not routed",
+      "through the Mnemom gateway: no governed identity, no integrity record, no Trust Rating.",
+      "",
+      "Launch a governed session:   mnemom agent <session-name>",
+      "Learn more:                  https://docs.mnemom.ai",
+    ].join("\n");
+  }
+  const lines = [
+    `${SIGN} Mnemom for Claude Code — governed`,
+    "",
+    `  agent:         ${l.agent}`,
+    `  conversation:  ${l.conversationId || "(unknown)"}`,
+    `  cell:          ${l.cell}`,
+    `  gateway:       ${l.gatewayHost}`,
+    `  shape:         ${l.shape}`,
+    `  ${goalWord(l, g).replace(/^goal /, "goal:          ")}`,
+  ];
+  for (const [label, value] of goalRows(l, g, now).slice(1)) {
+    lines.push(`  ${`${label}:`.padEnd(15)}${value}`);
+  }
+  lines.push(
+    `  ${trustWord(r).replace(/^trust /, "trust rating:  ")}`,
+    `  turns:         ${turnCount}`,
+  );
+  if (l.session) lines.push(`  session:       ${l.session}`);
+  if (l.launcherVersion) lines.push(`  launcher:      mnemom ${l.launcherVersion}`);
+  lines.push(
+    "",
+    `  public page:   https://www.mnemom.ai/agents/${encodeURIComponent(l.agent)}/reputation`,
+  );
+  lines.push(
+    "  commands:      /mnemom goal · /mnemom panel · /mnemom doctor · /mnemom verify · /mnemom hide|show",
+  );
+  return lines.join("\n");
+}
+
+const HELP = [
+  `${SIGN} /mnemom — Mnemom for Claude Code`,
+  "",
+  "  /mnemom            this session's governance status (same as `status`)",
+  "  /mnemom goal       the goal in full: statement, requirements, path fences, guardrails, verdict",
+  "  /mnemom panel      open the Mnemom status pane (the ▸ status mark on the band does the same)",
+  "  /mnemom close      close it",
+  "  /mnemom doctor     reach the gateway (/health) and the Trust Rating API, report both",
+  "  /mnemom verify     fetch the agent's reputation attestation (hash chain, Merkle root)",
+  "  /mnemom hide       hide the band above the prompt for this session",
+  "  /mnemom show       show it again",
+  "",
+  "  Mnemom is the trust plane for the agentic internet — https://www.mnemom.ai",
+].join("\n");
+
+async function refreshReputation(
+  $: StateDollar & {
+    http: { fetch: (url: string) => Promise<{ ok: boolean; status: number; text: string }> };
+    clock: { now: () => Promise<number> };
+    ui: { status: (text: string | undefined) => void };
+  },
+  l: MnemomLaunch,
+): Promise<MnemomReputation> {
+  const r = await fetchReputation($, l, await $.clock.now());
+  // `update` resolves once the band has been redrawn with the new value.
+  await update($, reputation, () => r);
+  return r;
+}
+
+/** Re-read the live goal state and land it on the atom (the band and the pane redraw). */
+async function refreshGoal(
+  $: StateDollar & RunDollar & { clock: { now: () => Promise<number> } },
+  l: MnemomLaunch,
+): Promise<MnemomGoal> {
+  const g = await fetchGoal($, l, await $.clock.now());
+  await update($, goal, () => g);
+  return g;
+}
+
+export const register: Register = (on, rawOptions) => {
+  const options = readOptions(rawOptions);
+  let composeCache: { key: string; text: string } | null = null;
+
+  // ── session.start: read the launch facts, register /mnemom, start the intro ──
+  on("session.start", async ($, e, next) => {
+    const l = await readLaunch($);
+    await update($, launch, () => l);
+    await update($, reputation, () => (l ? { state: "loading" } : null));
+    await update($, goal, () => (l && l.goalMode !== "off" ? { state: "loading" } : null));
+
+    await $.command.register({
+      name: "mnemom",
+      description:
+        "Mnemom governance: status, the goal, status pane, doctor, verify, hide/show the band",
+      argumentHint: "[status|goal|panel|close|doctor|verify|hide|show|help]",
+      immediate: true,
+    });
+
+    // The intro: the header reveals itself on the band, holds, and the band drops to one row.
+    if (e.isInteractive && options.showBand) {
+      await update($, introFrame, () => 0);
+      const tick = $.clock.every(INTRO_FRAME_MS, () => {
+        update($, introFrame, (f) => (f < 0 ? f : f + 1))
+          .then((f) => {
+            if (f < 0 || f >= INTRO_FRAMES) {
+              tick.cancel();
+              return f < 0 ? undefined : update($, introFrame, () => -1).then(() => undefined);
+            }
+            return undefined;
+          })
+          .catch(() => tick.cancel());
+      });
+    }
+
+    if (l === null) {
+      if (e.isInteractive) {
+        $.ui.toast(
+          options.requireGovernance
+            ? `${SIGN} Mnemom: this session is not governed — tool calls are refused until it is launched with \`mnemom agent\`.`
+            : `${SIGN} Mnemom: this session is not routed through the Mnemom gateway. Launch with \`mnemom agent\` for a governed session.`,
+          { timeoutMs: 8000 },
+        );
+      }
+      return next(e);
+    }
+
+    // The Trust Rating lookup and the goal read run beside the session start, never in its way.
+    reputationInFlight = refreshReputation($, l).catch(() => undefined);
+    if (l.goalMode !== "off") goalInFlight = refreshGoal($, l).catch(() => undefined);
+    return next(e);
+  });
+
+  // ── /mnemom ──
+  on("command.run", { command: "mnemom" }, async ($, e) => {
+    // Before the first state read: a hook's reads are consistent from its first access on, so the
+    // rating the lookup lands must be in place before the launch is read.
+    await reputationInFlight;
+    await goalInFlight;
+    const l = await read($, launch);
+    const verb = (e.args ?? "").trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+
+    if (verb === "help" || verb === "-h" || verb === "--help") return { text: HELP };
+
+    if (verb === "goal" || verb === "contract") {
+      if (l === null) return { text: statusText(null, null, null, await read($, turns), 0) };
+      // A fresh read, so the verdict and the inferred goal are this moment's.
+      const g = l.goalMode === "off" ? null : await refreshGoal($, l);
+      return { text: goalText(l, g, await $.clock.now()) };
+    }
+
+    if (verb === "panel" || verb === "pane" || verb === "open") {
+      await openStatusPane($, l);
+      return {
+        text: `${SIGN} Mnemom status pane opened (Escape or its ✕ closes it; /mnemom close too).`,
+      };
+    }
+    if (verb === "close") {
+      await closeStatusPane($);
+      return { text: `${SIGN} Mnemom status pane closed.` };
+    }
+
+    if (verb === "hide" || verb === "show") {
+      const hide = verb === "hide";
+      await update($, isHidden, () => hide);
+      return {
+        text: hide
+          ? `${SIGN} Mnemom band hidden for this session (/mnemom show brings it back).`
+          : `${SIGN} Mnemom band shown.`,
+      };
+    }
+
+    if (verb === "doctor") {
+      if (l === null) return { text: statusText(null, null, null, await read($, turns), 0) };
+      const out = [`${SIGN} Mnemom doctor — ${l.cell}`, ""];
+      try {
+        const health = await $.http.fetch(`${l.gatewayHost}/health`);
+        out.push(
+          `  gateway ${l.gatewayHost}/health → ${health.ok ? "ok" : "FAIL"} (HTTP ${health.status})`,
+        );
+      } catch (err) {
+        out.push(
+          `  gateway ${l.gatewayHost}/health → unreachable (${err instanceof Error ? err.message : String(err)})`,
+        );
+      }
+      const r = await refreshReputation($, l);
+      out.push(`  trust rating ${reputationUrl(l)} → ${trustWord(r).replace(/^trust /, "")}`);
+      if (r.state === "error") out.push(`    (${r.reason})`);
+      const g = l.goalMode === "off" ? null : await refreshGoal($, l);
+      if (g !== null)
+        out.push(
+          `  live goal (mnemom agent show --json) → ${verdictDetail(g, await $.clock.now())}`,
+        );
+      out.push(
+        "",
+        `  identity: agent ${l.agent}, conversation ${l.conversationId || "(unknown)"}, ${goalWord(l, g)}`,
+        `  shape: ${l.shape}${l.launcherVersion ? ` · launcher mnemom ${l.launcherVersion}` : ""}`,
+      );
+      return { text: out.join("\n") };
+    }
+
+    if (verb === "verify") {
+      if (l === null) return { text: statusText(null, null, null, await read($, turns), 0) };
+      const url = `${reputationUrl(l)}/verify`;
+      try {
+        const res = await $.http.fetch(url);
+        if (res.status === 404) {
+          return {
+            text: `${SIGN} Mnemom verify — ${l.agent} has no published Trust Rating yet (HTTP 404 from ${url}); nothing to verify until the score publishes.`,
+          };
+        }
+        if (!res.ok) return { text: `${SIGN} Mnemom verify — HTTP ${res.status} from ${url}` };
+        const body = asRecord(res.text) ?? {};
+        const lines = [`${SIGN} Mnemom verify — ${l.agent}`, "", `  ${url}`, ""];
+        const chain = body.hash_chain_valid;
+        if (typeof chain === "boolean") {
+          lines.push(
+            `  hash chain:    ${chain ? "VALID — unbroken append-only checkpoint chain" : "INVALID"}`,
+          );
+        }
+        for (const [label, key] of [
+          ["merkle root:  ", "merkle_root"],
+          ["checkpoints:  ", "checkpoint_count"],
+          ["certificate:  ", "certificate_url"],
+          ["verified at:  ", "verified_at"],
+        ] as const) {
+          const v = body[key];
+          if (typeof v === "string" || typeof v === "number") lines.push(`  ${label} ${v}`);
+        }
+        if (lines.length === 4) lines.push(res.text.slice(0, 1200));
+        lines.push(
+          "",
+          "  This is a chain-integrity attestation (the rating derives from an unbroken checkpoint",
+          "  chain), not an in-band signature check. Public keys: https://api.mnemom.ai/.well-known/jwks.json",
+        );
+        return { text: lines.join("\n") };
+      } catch (err) {
+        return {
+          text: `${SIGN} Mnemom verify — ${url} unreachable (${err instanceof Error ? err.message : String(err)})`,
+        };
+      }
+    }
+
+    // `status` and the bare command.
+    const text = statusText(
+      l,
+      await read($, reputation),
+      await read($, goal),
+      await read($, turns),
+      await $.clock.now(),
+    );
+    // Report what is known now, and refresh behind the reply for the next look.
+    if (l !== null && verb === "status") {
+      reputationInFlight = refreshReputation($, l).catch(() => undefined);
+      if (l.goalMode !== "off") goalInFlight = refreshGoal($, l).catch(() => undefined);
+    }
+    return { text };
+  });
+
+  // ── the band above the prompt ──
+  // While the intro plays: the header revealing itself. After it: one row —
+  // the sign, the identity, the Trust Rating and a `▸ status` mark that opens the status pane.
+  // ctrl+x ctrl+a collapses the band; `/mnemom hide` hides it for the session.
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    const l = await read($, launch);
+    if (e.props.hasSurvey || !options.showBand || (await read($, isHidden))) return next(e);
+    const { Box, Button, Text } = $.ui.resolve(e);
+    const brand = l === null ? WARN : TEAL_BRIGHT;
+
+    const frame = await read($, introFrame);
+    // The intro: the header — the glyph beside `Mnemom` and the CLI's version, the tagline
+    // beneath — revealed left to right, held with a slow teal pulse, then the band drops to one
+    // row. A band too short or too narrow for the header skips the intro.
+    const version = l?.launcherVersion ?? "";
+    const columns = headerColumns(version);
+    if (frame >= 0 && e.props.maxRows >= HEADER_ROWS && e.props.bodyColumns >= columns) {
+      const pulse = frame >= INTRO_REVEAL_FRAMES && (frame - INTRO_REVEAL_FRAMES) % 8 >= 4;
+      const shown = Math.min(columns, Math.ceil(((frame + 1) * columns) / INTRO_REVEAL_FRAMES));
+      return (
+        <Box flexDirection="column">
+          {header(pulse ? TEAL : brand, version).map((row, i) => (
+            <Box flexDirection="row" key={`header-${i}`}>
+              {cut(row, shown).map((s) => (
+                <Text
+                  color={s.fg}
+                  backgroundColor={s.bg}
+                  dimColor={s.dim}
+                  bold={s.bold}
+                  inverse={s.inverse}
+                >
+                  {s.t}
+                </Text>
+              ))}
+            </Box>
+          ))}
+        </Box>
+      );
+    }
+
+    const open = (
+      <Button
+        key="status"
+        label="▸ status"
+        plain
+        dimColor
+        hotkey="s"
+        onPress={() => openStatusPane($, l)}
+      />
+    );
+
+    if (l === null) {
+      return (
+        <Box flexDirection="row" gap={1}>
+          <Text color={GOLD} bold>
+            {SIGN}
+          </Text>
+          <Text color={TEAL_BRIGHT} bold>
+            Mnemom
+          </Text>
+          <Text color={WARN} wrap="truncate-end">
+            · not governed — launch with: mnemom agent &lt;session&gt;
+          </Text>
+          <Text dimColor>·</Text>
+          {open}
+        </Box>
+      );
+    }
+
+    const r = await read($, reputation);
+    const g = await read($, goal);
+    const narrow = e.props.bodyColumns < 100;
+    const live = liveGoal(g);
+    return (
+      <Box flexDirection="row" gap={1}>
+        <Text color={GOLD} bold>
+          {SIGN}
+        </Text>
+        <Text color={TEAL_BRIGHT} bold>
+          Mnemom
+        </Text>
+        <Text dimColor>· governed · {l.cell} ·</Text>
+        <Text color={TEAL} wrap="truncate-end">
+          {l.agent}
+        </Text>
+        {!narrow && (
+          <Text
+            dimColor={live?.verdict === null || live === null}
+            color={verdictColor(live?.verdict ?? null)}
+          >
+            · {goalWord(l, g)}
+          </Text>
+        )}
+        <Text dimColor>·</Text>
+        <Text
+          color={r !== null && r.state === "rated" ? gradeColor(r.grade) : undefined}
+          dimColor={r === null || r.state !== "rated"}
+        >
+          {trustWord(r)}
+        </Text>
+        {!narrow && e.props.isWorking && <Text dimColor>· working</Text>}
+        <Text dimColor>·</Text>
+        {open}
+      </Box>
+    );
+  });
+
+  // ── the status pane ──
+  // Opened by the band's `▸ status` mark or `/mnemom panel`: the header and everything Mnemom
+  // knows about this session. Redraws as the rating and the turn count change.
+  on("ui.render", { component: "Pane", requestId: PANE }, async ($, e) => {
+    const { Box, Button, Text } = $.ui.resolve(e);
+    const l = await read($, launch);
+    const r = l === null ? null : await read($, reputation);
+    const g = l === null ? null : await read($, goal);
+    const turnCount = await read($, turns);
+    const now = await $.clock.now();
+    const brand = l === null ? WARN : TEAL_BRIGHT;
+    // The head is the intro's header; a pane too narrow for it shows the glyph alone.
+    const version = l?.launcherVersion ?? "";
+    // One column of margin inside the pane (the root's paddingLeft) comes off the width.
+    const art =
+      e.props.bodyColumns - 1 >= headerColumns(version) ? header(brand, version) : MARK_HEADER;
+
+    const rows: Array<[string, string, string | undefined]> =
+      l === null
+        ? [
+            [
+              "status",
+              "NOT governed — this session's model traffic is not routed through Mnemom",
+              WARN,
+            ],
+            ["why", "it was launched with plain `claude`, not `mnemom agent`", undefined],
+            ["launch", 'mnemom agent <session> [--goal "…"]', TEAL],
+            ["docs", "https://docs.mnemom.ai", undefined],
+          ]
+        : [
+            ["status", `governed · ${l.cell}`, TEAL],
+            ["gateway", l.gatewayHost, undefined],
+            ["agent", l.agent, TEAL],
+            ["conversation", l.conversationId || "(unknown)", undefined],
+            ...goalRows(l, g, now),
+            [
+              "trust rating",
+              trustDetail(r, now),
+              r !== null && r.state === "rated" ? gradeColor(r.grade) : undefined,
+            ],
+            ["turns", String(turnCount), undefined],
+            [
+              "session",
+              `${l.session || "(unnamed)"} · ${l.shape}${l.launcherVersion ? ` · mnemom ${l.launcherVersion}` : ""}`,
+              undefined,
+            ],
+            [
+              "public page",
+              `https://www.mnemom.ai/agents/${encodeURIComponent(l.agent)}/reputation`,
+              undefined,
+            ],
+          ];
+
+    return (
+      <Box flexDirection="column" paddingTop={1} paddingLeft={1}>
+        {art.map((row, i) => (
+          <Box flexDirection="row" key={`header-${i}`}>
+            {row.map((s) => (
+              <Text
+                color={s.fg}
+                backgroundColor={s.bg}
+                dimColor={s.dim}
+                bold={s.bold}
+                inverse={s.inverse}
+              >
+                {s.t}
+              </Text>
+            ))}
+          </Box>
+        ))}
+        <Text> </Text>
+        {rows.map(([label, value, color]) => (
+          <Box flexDirection="row">
+            <Text dimColor>{label.padEnd(14)}</Text>
+            <Text color={color} wrap="truncate-end">
+              {value}
+            </Text>
+          </Box>
+        ))}
+        <Text> </Text>
+        <Box flexDirection="row" gap={3}>
+          {l !== null && (
+            <Button
+              key="refresh"
+              label="↻ refresh"
+              plain
+              dimColor
+              hotkey="r"
+              onPress={() => {
+                reputationInFlight = refreshReputation($, l).catch(() => undefined);
+                if (l.goalMode !== "off") goalInFlight = refreshGoal($, l).catch(() => undefined);
+              }}
+            />
+          )}
+          <Text dimColor>/mnemom goal · /mnemom doctor · /mnemom verify</Text>
+          <Button
+            key="close"
+            label="✕ close"
+            plain
+            dimColor
+            hotkey="q"
+            role="dismiss"
+            onPress={() => closeStatusPane($)}
+          />
+        </Box>
+      </Box>
+    );
+  });
+
+  // ── the Mnemom sign on the spinner and the turn line (governed sessions only) ──
+  on("ui.render", { component: "Spinner" }, async ($, e, next) => {
+    if (!options.spinnerMark || (await read($, launch)) === null) return next(e);
+    return next({ ...e, props: { ...e.props, suffix: `${e.props.suffix} ${SIGN}` } });
+  });
+
+  on("ui.render", { component: "TurnDuration" }, async ($, e, next) => {
+    const own = await next(e);
+    if (!options.spinnerMark || (await read($, launch)) === null) return own;
+    const { Box, Text } = $.ui.resolve(e);
+    return (
+      <Box flexDirection="row">
+        {own}
+        <Text dimColor> · governed by Mnemom</Text>
+      </Box>
+    );
+  });
+
+  // ── tell the model what it is running as ──
+  // Two carriers for one text. `prompt.context` adds a block to the conversation's first user
+  // message, which a user-installed plugin may do. `prompt.compose` appends a system-prompt section,
+  // which the built-in security plugin bypasses for the user tier: it takes effect only where an
+  // administrator installs this plugin as a managed one.
+  /** The goal as the launch stated it (static: the live verdict is the person's to read, not the model's). */
+  const goalNote = (l: MnemomLaunch): string[] => {
+    if (l.goalMode === "sealed" && l.contract !== null) {
+      const c = l.contract;
+      const out = [
+        `- sealed goal (the gateway judges every turn against it): ${oneLine(c.statement)}`,
+      ];
+      if (c.requirements.length > 0)
+        out.push(`  requirements: ${c.requirements.map(oneLine).join("; ")}`);
+      if (c.allowedPaths.length > 0) out.push(`  allowed paths: ${c.allowedPaths.join(", ")}`);
+      if (c.forbiddenPaths.length > 0)
+        out.push(`  forbidden paths: ${c.forbiddenPaths.join(", ")}`);
+      const guard = guardrailDetail(l, null).text;
+      if (guard !== "none set") out.push(`  guardrails: ${guard}`);
+      return out;
+    }
+    if (l.goalMode === "implicit") {
+      const guard = guardrailDetail(l, null).text;
+      return [
+        "- implicit goal: the gateway infers the goal from the person's messages and judges each turn",
+        `  against it; /mnemom goal shows the current inference.${guard !== "none set" ? ` guardrails: ${guard}.` : ""}`,
+      ];
+    }
+    return [];
+  };
+
+  const governanceText = (l: MnemomLaunch): string => {
+    const key = `${l.agent}|${l.conversationId}|${l.cell}|${l.goalMode}|${l.contractSha}`;
+    if (composeCache === null || composeCache.key !== key) {
+      composeCache = {
+        key,
+        text: [
+          "This Claude Code session runs as a Mnemom-governed agent. Mnemom (https://www.mnemom.ai) is the",
+          "trust plane for the agentic internet: every model call in this session is routed through the",
+          `Mnemom gateway (${l.cell}), recorded as integrity checkpoints and reflected in the agent's public`,
+          "Trust Rating.",
+          "",
+          `- governed identity: ${l.agent}; conversation: ${l.conversationId || "(unknown)"}; ${goalWord(l)}.`,
+          ...goalNote(l),
+          "- The person can run /mnemom (status), /mnemom doctor and /mnemom verify at any time; the",
+          "  `about-mnemom` skill explains Mnemom, Trust Ratings and the gateway when they ask.",
+          "- Never change or unset ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN or ANTHROPIC_CUSTOM_HEADERS in",
+          "  this session: that drops governance for the session, and the Mnemom plugin denies it.",
+        ].join("\n"),
+      };
+    }
+    return composeCache.text;
+  };
+
+  on("prompt.context", async ($, e, next) => {
+    const composed = await next(e);
+    const l = await read($, launch);
+    if (l === null) return composed;
+    return {
+      ...composed,
+      blocks: [...composed.blocks, { name: "mnemomGovernance", text: governanceText(l) }],
+    };
+  });
+
+  on("prompt.compose", async ($, e, next) => {
+    const composed = await next(e);
+    const l = await read($, launch);
+    if (l === null) return composed;
+    return {
+      sections: [
+        ...composed.sections,
+        {
+          id: `${PLUGIN}:governance`,
+          text: `# Mnemom governance\n\n${governanceText(l)}`,
+          scope: "session",
+        },
+      ],
+    };
+  });
+
+  // ── commit attribution: who governed the work ──
+  on("attribution.text", { kind: "commit" }, async ($, e, next) => {
+    const composed = await next(e);
+    const l = await read($, launch);
+    if (!options.commitTrailer || l === null) return composed;
+    const trailers = [`Mnemom-Agent: ${l.agent}`];
+    if (l.conversationId) trailers.push(`Mnemom-Conversation: ${l.conversationId}`);
+    const base = composed.text.trimEnd();
+    return { text: base ? `${base}\n${trailers.join("\n")}` : trailers.join("\n") };
+  });
+
+  // ── the guard ──
+  on("tool.call", async ($, e, next) => {
+    const l = await read($, launch);
+    if (l === null) {
+      if (options.requireGovernance) {
+        return {
+          deny: `${$.plugin.name}: this session is not routed through the Mnemom gateway (requireGovernance is on). Launch it with \`mnemom agent <session>\`, or turn the option off in /config.`,
+        };
+      }
+      return next(e);
+    }
+    if (options.guardReroute && e.tool === "Bash" && REROUTE_RE.test(e.command)) {
+      return {
+        deny: `${$.plugin.name}: that command would change or unset the Mnemom gateway routing (ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN / ANTHROPIC_CUSTOM_HEADERS) for this governed session. Leave the routing in place; run an un-governed command in another terminal if you must.`,
+      };
+    }
+    return next(e);
+  });
+
+  // ── turns: count them, refresh the Trust Rating now and then ──
+  on("turn.complete", async ($, e, next) => {
+    const count = await update($, turns, (n) => n + 1);
+    const l = await read($, launch);
+    if (l !== null && count % REPUTATION_REFRESH_TURNS === 0)
+      reputationInFlight = refreshReputation($, l).catch(() => undefined);
+    // The turn's verdict (and, implicit, any goal revision) lands at the gateway as the response
+    // closes; read it a moment later, beside the next prompt, never in its way.
+    if (l !== null && l.goalMode !== "off") {
+      $.clock.after(GOAL_REFRESH_DELAY_MS, () => {
+        goalInFlight = refreshGoal($, l).catch(() => undefined);
+      });
+    }
+    return next(e);
+  });
+};