@zerwiz/ymir 0.1.16 → 0.1.18

package/.agents/config/app-repos.yaml

@@ -0,0 +1,38 @@
+# App repositories — PUBLIC map (the five surfaces)
+#
+# The fork path: a fresh clone has no private hoard (no
+# `$YMIR_HOME/hodd/identity/projects.yaml`), so bin/ymir-install.sh's `apps`
+# step falls back to THIS file to clone the five app repos. The hoard registry
+# stays authoritative when present; this file is the fork's road.
+#
+# Block shape must match the installer's awk (repo: apps/<path> + git: dict).
+
+- id: hlidskjalf
+  name: Hlidskjalf
+  repo: apps/hlidskjalf
+  posture: direct-PR
+  git: { host: github.com, owner: zerwiz, repo: hlidskjalf, remote: origin, default_branch: main, auth: gh }
+
+- id: hlidskjalf-mobile
+  name: Hlidskjalf Mobile
+  repo: apps/hlidskjalf-mobile
+  posture: direct-PR
+  git: { host: github.com, owner: zerwiz, repo: hlidskjalf-mobile, remote: origin, default_branch: main, auth: gh }
+
+- id: odrerir
+  name: Óðrerir
+  repo: apps/odrerir
+  posture: direct-PR
+  git: { host: github.com, owner: zerwiz, repo: odrerir, remote: origin, default_branch: main, auth: gh }
+
+- id: sessrumnir
+  name: Sessrúmnir
+  repo: apps/sessrumnir
+  posture: direct-PR
+  git: { host: github.com, owner: zerwiz, repo: sessrumnir, remote: origin, default_branch: main, auth: gh }
+
+- id: smidja
+  name: Smíðja factory
+  repo: apps/smidja-factory
+  posture: direct-PR
+  git: { host: github.com, owner: zerwiz, repo: smidja, remote: origin, default_branch: main, auth: gh }

package/.claude/settings.json

@@ -0,0 +1,31 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -z \"${GROK_AGENT:-}${GROK_HOOK_EVENT:-}\" ] || exit 0; exec \"$CLAUDE_PROJECT_DIR\"/bin/saga-sessionstart-run.sh",
+            "timeout": 180
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -z \"${GROK_AGENT:-}${GROK_HOOK_EVENT:-}\" ] || exit 0; exec \"$CLAUDE_PROJECT_DIR\"/bin/syn-turnend-guard.sh --claude"
+          },
+          {
+            "type": "command",
+            "command": "[ -z \"${GROK_AGENT:-}${GROK_HOOK_EVENT:-}\" ] || exit 0; out=$(exec \"$CLAUDE_PROJECT_DIR\"/bin/syn-watch-arm.sh --restart); rc=$?; case \"$out\" in *signal:*|*stale:*|*check:*|*heartbeat:*) printf '%s\n' \"$out\" >&2; exit 2;; esac; exit $rc",
+            "asyncRewake": true,
+            "timeout": 28800
+          }
+        ]
+      }
+    ]
+  }
+}

package/.codex/hooks.json

@@ -0,0 +1,43 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash -lc 'payload=$(cat 2>/dev/null || true); [ -n \"$payload\" ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; root=$(pwd -P) || exit 0; [ -x \"$root/bin/saga-sessionstart-run.sh\" ] || exit 0; [ -f \"$root/AGENTS.md\" ] || exit 0; [ -f \"$root/.codex/hooks.json\" ] || exit 0; jq -e \"any(.hooks.SessionStart[]?.hooks[]?.command?; type == \\\"string\\\" and contains(\\\"saga-sessionstart-run.sh\\\"))\" \"$root/.codex/hooks.json\" >/dev/null 2>&1 || exit 0; printf \"%s\" \"$payload\" | \"$root/bin/saga-sessionstart-run.sh\"'",
+            "timeout": 180
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash -lc 'payload=$(cat 2>/dev/null || true); [ -n \"$payload\" ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; root=$(pwd -P) || exit 0; [ -x \"$root/bin/syn-arm-pretool-check.sh\" ] || exit 0; [ -f \"$root/AGENTS.md\" ] || exit 0; [ -f \"$root/.codex/hooks.json\" ] || exit 0; jq -e \"any(.hooks.PreToolUse[]?.hooks[]?.command?; type == \\\"string\\\" and contains(\\\"syn-arm-pretool-check.sh\\\"))\" \"$root/.codex/hooks.json\" >/dev/null 2>&1 || exit 0; printf \"%s\" \"$payload\" | \"$root/bin/syn-arm-pretool-check.sh\"'",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "bash -lc 'payload=$(cat 2>/dev/null || true); [ -n \"$payload\" ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; root=$(pwd -P) || exit 0; [ -x \"$root/bin/syn-cd-pretool-check.sh\" ] || exit 0; [ -f \"$root/AGENTS.md\" ] || exit 0; [ -f \"$root/.codex/hooks.json\" ] || exit 0; jq -e \"any(.hooks.PreToolUse[]?.hooks[]?.command?; type == \\\"string\\\" and contains(\\\"syn-cd-pretool-check.sh\\\"))\" \"$root/.codex/hooks.json\" >/dev/null 2>&1 || exit 0; printf \"%s\" \"$payload\" | \"$root/bin/syn-cd-pretool-check.sh\"'",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash -lc 'payload=$(cat 2>/dev/null || true); [ -n \"$payload\" ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; root=$(pwd -P) || exit 0; [ -x \"$root/bin/syn-turnend-guard.sh\" ] || exit 0; [ -f \"$root/AGENTS.md\" ] || exit 0; [ -f \"$root/.codex/hooks.json\" ] || exit 0; jq -e \"any(.hooks.Stop[]?.hooks[]?.command?; type == \\\"string\\\" and contains(\\\"syn-turnend-guard.sh\\\"))\" \"$root/.codex/hooks.json\" >/dev/null 2>&1 || exit 0; printf \"%s\" \"$payload\" | \"$root/bin/syn-turnend-guard.sh\"'",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}

package/.cursor/hooks.json

@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "command": "digest=$(\"$CURSOR_PROJECT_DIR\"/bin/saga-sessionstart-run.sh --source startup </dev/null 2>/dev/null); [ -n \"$digest\" ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; jq -n --arg c \"$digest\" '{additional_context:$c}' 2>/dev/null || true",
+        "timeout": 180
+      }
+    ],
+    "stop": [
+      {
+        "type": "command",
+        "command": "guard=$(\"$CURSOR_PROJECT_DIR\"/bin/syn-turnend-guard.sh 2>&1 </dev/null); rc=$?; [ \"$rc\" -eq 2 ] || exit 0; command -v jq >/dev/null 2>&1 || exit 0; jq -n --arg m \"$guard\" '{followup_message:$m}' 2>/dev/null || true",
+        "timeout": 30
+      }
+    ],
+    "preToolUse": [
+      {
+        "matcher": "Shell",
+        "type": "command",
+        "command": "\"$CURSOR_PROJECT_DIR\"/bin/syn-arm-pretool-check.sh --cursor",
+        "timeout": 10
+      },
+      {
+        "matcher": "Shell",
+        "type": "command",
+        "command": "\"$CURSOR_PROJECT_DIR\"/bin/syn-cd-pretool-check.sh --cursor",
+        "timeout": 10
+      }
+    ]
+  }
+}

package/.pi/extensions/README.md

@@ -0,0 +1,39 @@
+# Pi extensions — Brokk distro runtime
+
+These extensions make a Pi session open as **Brokk** the way Ymir intends: the
+primary takes the high seat automatically, the Sága session-start context is
+injected before the first turn, and supervision stays alive across the session.
+Ported from the validated upstream agent-distro reference for
+[plan 29](../../docs/plans/29-brokk-distro-runtime.md).
+
+| File | Norse role | Purpose |
+|---|---|---|
+| `syn-turnend-guard.ts` | **Sýn** (watchful sight) | inject the Sága digest at session start, re-emit on compaction, refuse a blind turn end, PreToolUse seatbelts |
+| `gna-pi-watch.ts` | **Gná** (Frigg's messenger) | watcher continuity: arm, re-arm, deliver actionable wakes; emits the Skuld dispatch offer |
+| `ro.ts` | **Ró** (calm/peace) | calm presentation: hides transcript chrome, replaces the working row with a longship, `/ro` toggle |
+| `skuld-branch-supervision.ts` | **Skuld** (the Norn of what shall be) | supervision branch: handles routine wakes with a cheaper model; `/skuld-model` |
+| `lib/vordr-sessionstart-supervisor.mjs` | **Vörðr** (warden) | supervise the digest child process |
+| `lib/rodd-operational-input.ts` | **Rödd** (voice) | structured operational-message wire bridge |
+| `lib/ro-*.ts` | **Ró** helpers | visibility, assistant/user layout adapters, working longship |
+| `lib/skuld-branch-*.ts` | **Skuld** helpers | dispatch handshake + model picker |
+
+## Wiring
+
+- **Sága** digest: `bin/saga-session-start.sh`, routed by `bin/saga-sessionstart-run.sh`.
+- **Gná** watcher: `bin/syn-watch-arm.sh`; turn-end check: `bin/syn-turnend-guard.sh`.
+- **Gleipnir** lock: `bin/gleipnir-lock-lib.sh` (writes `state/.lock`).
+- **Rödd** wire: `bin/rodd-operational-input.sh`.
+
+The harness passes `BROKK_SESSION_PID` so the session lock is bound to the live
+Pi process, not the short-lived digest helper.
+
+## Other harnesses
+
+OpenCode, Claude Code, Codex, and Cursor adapters are wired too; see
+`docs/plans/29-brokk-distro-runtime.md` §7 and
+`.agents/skills/galdr-ymirsystem/assets/harness-integration/`. Grok is not yet implemented.
+
+## Agents
+
+Agents live in `.agents/agents/` and are bound per tool by `bin/valknut-load.sh`
+(OpenCode reads `.opencode/agents/`; Pi links resolve under `.pi/agents/`).

package/.pi/extensions/gna-pi-watch.ts

@@ -0,0 +1,15 @@
+/**
+ * A no-op extension, kept only so nothing loads TWICE.
+ *
+ * An extension that registers the same tools as one already loaded from the global
+ * home makes pi refuse the duplicate — `Tool "gna_watch_arm" conflicts with …`. But a
+ * file that exports no factory at all is its own error:
+ *   "Extension does not export a valid factory function".
+ * So this exports a valid factory that registers nothing.
+ *
+ * The real extension is `gna-pi-watch`, in the shared source
+ * (`.pi/shared/extensions/`), deployed to the one global home.
+ */
+export default function well(): void {
+  // deliberately empty: this seat is not the extension's home.
+}

package/.pi/extensions/lib/ro-assistant-layout.ts

@@ -0,0 +1,96 @@
+// Verified against Pi 0.81.1 and 0.82.0, which export AssistantMessageComponent with an
+// updateContent method. installRoAssistantLayout() probes that exact method and throws
+// if it is missing; ro.ts catches that and skips only this adapter with a diagnostic
+// instead of blocking Ró or Pi.
+// This layout removes collapsed thinking and the mid-turn assistant text blocks
+// classified as "assistant-working-note" from a shallow presentation copy. The message
+// itself, model context, session storage, and export rendering are never touched.
+// ./ro-visibility.ts owns which classes Ró hides.
+import type { AssistantMessageComponent as PiAssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
+import { roPresentationHides } from "./ro-visibility.ts";
+
+type AssistantMessage = Parameters<PiAssistantMessageComponent["updateContent"]>[0];
+
+type AssistantMessagePresentationState = {
+  hiddenThinkingLabel: string;
+  hideThinkingBlock: boolean;
+  lastMessage?: AssistantMessage;
+};
+
+type CalmAssistantLayoutPatch = {
+  hidesThinking: () => boolean;
+  hidesWorkingNote: () => boolean;
+};
+
+// A mid-turn assistant message is one the model did not end its response with: Pi's
+// agent loop runs its tool calls and then issues another assistant message. stopReason
+// is intrinsic to each message and is already set while the message streams, so this
+// layout never has to ask whether the turn ended. It stays "pending" until the tool
+// call materializes, which is why a working note is briefly visible before it
+// collapses; suppressing pending text would also stop a genuine reply from streaming.
+function isMidTurnAssistantMessage(message: AssistantMessage): boolean {
+  if (message.stopReason === "toolUse") return true;
+  return (
+    message.stopReason === "length" &&
+    message.content.some((block) => block.type === "toolCall")
+  );
+}
+
+// Keep the introduction-version symbol stable so a compatible upgrade cannot
+// double-patch a live process.
+const CALM_ASSISTANT_LAYOUT_PATCH = Symbol.for(
+  "brokk:ro-assistant-layout:pi-0.81.1",
+);
+
+export function installRoAssistantLayout(): void {
+  const registry = globalThis as typeof globalThis & {
+    [key: symbol]: CalmAssistantLayoutPatch | undefined;
+  };
+  const hidesThinking = (): boolean => roPresentationHides("assistant-thinking");
+  const hidesWorkingNote = (): boolean => roPresentationHides("assistant-working-note");
+  const installed = registry[CALM_ASSISTANT_LAYOUT_PATCH];
+  if (installed) {
+    installed.hidesThinking = hidesThinking;
+    installed.hidesWorkingNote = hidesWorkingNote;
+    return;
+  }
+
+  const patch: CalmAssistantLayoutPatch = { hidesThinking, hidesWorkingNote };
+  const AssistantMessageComponent = PiCodingAgent.AssistantMessageComponent;
+  if (typeof AssistantMessageComponent !== "function") {
+    throw new Error("Brokk Ró requires Pi AssistantMessageComponent");
+  }
+  const originalUpdateContent = AssistantMessageComponent.prototype.updateContent;
+  if (typeof originalUpdateContent !== "function") {
+    throw new Error("Brokk Ró requires Pi AssistantMessageComponent.updateContent");
+  }
+
+  AssistantMessageComponent.prototype.updateContent = function (
+    message: AssistantMessage,
+  ): void {
+    const state = this as unknown as AssistantMessagePresentationState;
+    const hideThinking =
+      state.hiddenThinkingLabel === "" &&
+      state.hideThinkingBlock &&
+      patch.hidesThinking();
+    const hideWorkingNote =
+      patch.hidesWorkingNote() && isMidTurnAssistantMessage(message);
+    const presentationMessage =
+      hideThinking || hideWorkingNote
+        ? {
+            ...message,
+            content: message.content.filter(
+              (block) =>
+                !(hideThinking && block.type === "thinking") &&
+                !(hideWorkingNote && block.type === "text"),
+            ),
+          }
+        : message;
+
+    originalUpdateContent.call(this, presentationMessage);
+    if (presentationMessage !== message) state.lastMessage = message;
+  };
+
+  registry[CALM_ASSISTANT_LAYOUT_PATCH] = patch;
+}

package/.pi/extensions/lib/ro-operational-user-layout.ts

@@ -0,0 +1,145 @@
+// Verified against Pi 0.81.1 and 0.82.0, which add the ordinary-user spacer and row
+// together via InteractiveMode.addMessageToChat. This adapter probes that exact method
+// and throws if it is missing; ro.ts catches that and skips only this adapter with a
+// diagnostic instead of blocking Ró or Pi. It changes only that presentation and never
+// message delivery.
+import type { UserMessageComponent as PiUserMessageComponent } from "@earendil-works/pi-coding-agent";
+import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
+import { roPresentationHides } from "./ro-visibility.ts";
+import { classifyRoddCurrentOperationalText } from "./rodd-operational-input.ts";
+
+type UserMessageConstructorArgs = ConstructorParameters<typeof PiUserMessageComponent>;
+type UserMessageLike = {
+  role: string;
+  content: unknown;
+};
+type AddMessageOptions = {
+  populateHistory?: boolean;
+};
+type InteractiveModePresentation = {
+  chatContainer: {
+    children: unknown[];
+    addChild(component: PiUserMessageComponent): void;
+  };
+  editor: {
+    addToHistory?(text: string): void;
+  };
+  getMarkdownThemeWithSettings(): UserMessageConstructorArgs[1];
+  getUserMessageText(message: UserMessageLike): string;
+  outputPad: number;
+};
+type InteractiveModePrototype = {
+  addMessageToChat(
+    this: InteractiveModePresentation,
+    message: UserMessageLike,
+    options?: AddMessageOptions,
+  ): void;
+};
+type CalmOperationalUserLayoutPatch = {
+  hidesOperationalInput: () => boolean;
+  isOperationalInput: (text: string) => boolean;
+};
+
+// Keep the introduction-version symbol stable so a compatible upgrade cannot
+// double-patch a live process.
+const CALM_OPERATIONAL_USER_LAYOUT_PATCH = Symbol.for(
+  "brokk:ro-operational-user-layout:pi-0.81.1",
+);
+const LEGACY_CALM_OPERATIONAL_PREFIX = "\u2063Supervisor escalate (";
+
+function contentIsTextOnly(content: unknown): boolean {
+  if (typeof content === "string") return true;
+  if (!Array.isArray(content) || content.length === 0) return false;
+  return content.every(
+    (block) =>
+      typeof block === "object" &&
+      block !== null &&
+      (block as { type?: unknown }).type === "text" &&
+      typeof (block as { text?: unknown }).text === "string",
+  );
+}
+
+export function installRoOperationalUserLayout(): void {
+  const registry = globalThis as typeof globalThis & {
+    [key: symbol]: CalmOperationalUserLayoutPatch | undefined;
+  };
+  const hidesOperationalInput = (): boolean => roPresentationHides("synthetic-user");
+  const isOperationalInput = (text: string): boolean => {
+    if (!text.includes("\u2063")) return false;
+    return (
+      classifyRoddCurrentOperationalText(text) !== undefined ||
+      text.startsWith(LEGACY_CALM_OPERATIONAL_PREFIX)
+    );
+  };
+  const installed = registry[CALM_OPERATIONAL_USER_LAYOUT_PATCH];
+  if (installed) {
+    installed.hidesOperationalInput = hidesOperationalInput;
+    installed.isOperationalInput = isOperationalInput;
+    return;
+  }
+
+  const patch: CalmOperationalUserLayoutPatch = {
+    hidesOperationalInput,
+    isOperationalInput,
+  };
+  const InteractiveMode = PiCodingAgent.InteractiveMode;
+  if (typeof InteractiveMode !== "function") {
+    throw new Error("Brokk Ró requires Pi InteractiveMode");
+  }
+  const prototype = InteractiveMode.prototype as unknown as InteractiveModePrototype;
+  const originalAddMessageToChat = prototype.addMessageToChat;
+  if (typeof originalAddMessageToChat !== "function") {
+    throw new Error("Brokk Ró requires Pi InteractiveMode.addMessageToChat");
+  }
+
+  const UserMessageComponent = PiCodingAgent.UserMessageComponent;
+  if (typeof UserMessageComponent !== "function") {
+    throw new Error("Brokk Ró requires Pi UserMessageComponent");
+  }
+  class CalmOperationalUserMessageComponent extends UserMessageComponent {
+    private readonly hasLeadingSpacer: boolean;
+
+    constructor(
+      text: UserMessageConstructorArgs[0],
+      markdownTheme: UserMessageConstructorArgs[1],
+      outputPad: number,
+      hasLeadingSpacer: boolean,
+    ) {
+      super(text, markdownTheme, outputPad);
+      this.hasLeadingSpacer = hasLeadingSpacer;
+    }
+
+    override render(width: number): string[] {
+      if (patch.hidesOperationalInput()) return [];
+      const lines = super.render(width);
+      return this.hasLeadingSpacer ? ["", ...lines] : lines;
+    }
+  }
+
+  prototype.addMessageToChat = function (
+    message: UserMessageLike,
+    options?: AddMessageOptions,
+  ): void {
+    if (message.role !== "user" || !contentIsTextOnly(message.content)) {
+      originalAddMessageToChat.call(this, message, options);
+      return;
+    }
+
+    const text = this.getUserMessageText(message);
+    if (!text || !patch.isOperationalInput(text)) {
+      originalAddMessageToChat.call(this, message, options);
+      return;
+    }
+
+    const component = new CalmOperationalUserMessageComponent(
+      text,
+      this.getMarkdownThemeWithSettings(),
+      this.outputPad,
+      this.chatContainer.children.length > 0,
+    );
+    this.chatContainer.addChild(component);
+    if (options?.populateHistory) this.editor.addToHistory?.(text);
+  };
+
+  registry[CALM_OPERATIONAL_USER_LAYOUT_PATCH] = patch;
+}

package/.pi/extensions/lib/ro-visibility.ts

@@ -0,0 +1,99 @@
+import {
+  getMarkdownTheme,
+  type ExtensionAPI,
+  UserMessageComponent,
+} from "@earendil-works/pi-coding-agent";
+export const RO_TRANSCRIPT_CLASSES = [
+  "genuine-user-prompt",
+  "genuine-agent-response",
+  "assistant-working-note",
+  "assistant-thinking",
+  "assistant-tool-call",
+  "tool-result",
+  "tool-image",
+  "user-bash",
+  "skill-invocation",
+  "custom-message",
+  "custom-entry",
+  "compaction-summary",
+  "branch-summary",
+  "working-status",
+  "command-status",
+  "system-notice",
+  "cache-notice",
+  "project-trust-warning",
+  "synthetic-user",
+  "synthetic-assistant",
+  "unknown",
+] as const;
+
+export type CalmTranscriptClass = (typeof RO_TRANSCRIPT_CLASSES)[number];
+
+// Ró is on or off. "assistant-working-note" is deliberately absent from the allowlist:
+// Ró hides mid-turn assistant working notes, keeping the genuine final reply.
+const CALM_VISIBLE_CLASSES = new Set<CalmTranscriptClass>([
+  "genuine-user-prompt",
+  "genuine-agent-response",
+  "working-status",
+]);
+
+// Legacy session entries from Ró versions before 2026-07-23 retain this
+// presentation type. New operational input stays user-role and is never rerouted.
+export const RO_SYNTHETIC_PRESENTATION_TYPE = "brokk-synthetic-input-presentation";
+export const RO_PRESENTATION_EVENT = "brokk:ro-presentation";
+
+export type RoPresentationState = {
+  active: boolean;
+  stockExportRendering: boolean;
+};
+
+export const RO_SYNTHETIC_KINDS = [
+  "session-start",
+  "watcher",
+  "turn-end-guard",
+  "away-supervisor",
+  "from-brokk",
+  "launch-brief",
+  "legacy-operational",
+] as const;
+
+export type BrokkSyntheticKind = (typeof RO_SYNTHETIC_KINDS)[number];
+type BrokkSyntheticPresentation = {
+  content: string;
+  kind: BrokkSyntheticKind;
+};
+
+let ro = false;
+let stockExportRendering = false;
+
+export function roTranscriptClassIsVisible(itemClass: CalmTranscriptClass): boolean {
+  return CALM_VISIBLE_CLASSES.has(itemClass);
+}
+
+export function setCalmPresentation(active: boolean): void {
+  ro = active;
+}
+
+export function setCalmStockExportRendering(active: boolean): void {
+  stockExportRendering = active;
+}
+
+export function calmPresentationIsActive(): boolean {
+  return ro;
+}
+
+export function roPresentationHides(itemClass: CalmTranscriptClass): boolean {
+  return ro && !stockExportRendering && !roTranscriptClassIsVisible(itemClass);
+}
+
+export function registerBrokkSyntheticPresentation(pi: ExtensionAPI): void {
+  pi.registerEntryRenderer<BrokkSyntheticPresentation>(
+    RO_SYNTHETIC_PRESENTATION_TYPE,
+    (entry) => {
+      if (roPresentationHides("synthetic-user")) return undefined;
+      const data = entry.data;
+      if (!data || typeof data.content !== "string") return undefined;
+      return new UserMessageComponent(data.content, getMarkdownTheme());
+    },
+  );
+}