@opengeni/react 5.1.0-canary.0 → 5.2.0-canary.1

package/src/timeline/genie-loading.tsx

@@ -12,7 +12,15 @@ export type GenieLoadingOptions = {
   /** Replace the visual while preserving SDK loading visibility and transitions. */
   render?: (props: GenieLoadingRenderProps) => ReactNode;
   phrases?: readonly string[];
-  /** Public options stay independent of the renderer's declaration layout. */
+  /** Native copy overrides. Omitted messages retain the default English copy. */
+  messages?: {
+    status?: string;
+    slowStatus?: string;
+    slowText?: string;
+    showDetails?: string;
+    hideDetails?: string;
+  };
+  /** Public adapter options; the renderer dependency's declarations stay private. */
   orb?: {
     state?:
       | "working"
@@ -90,10 +98,14 @@ export function GenieLoading({
       </div>
       <div className="og-genie-copy">
         <span className="sr-only" role="status">
-          {slow ? "Preparing your task. Taking longer than usual." : "Preparing your task."}
+          {slow
+            ? (options?.messages?.slowStatus ?? "Preparing your task. Taking longer than usual.")
+            : (options?.messages?.status ?? "Preparing your task.")}
         </span>
         <span key={slow ? "slow" : phrase} className="og-genie-phrase" aria-hidden="true">
-          {slow ? "A little longer than usual…" : phrases[phrase % phrases.length]}
+          {slow
+            ? (options?.messages?.slowText ?? "A little longer than usual…")
+            : phrases[phrase % phrases.length]}
         </span>
         {showDetails || detailsOpen ? (
           <button
@@ -102,7 +114,9 @@ export function GenieLoading({
             aria-expanded={detailsOpen}
             onClick={onShowDetails}
           >
-            {detailsOpen ? "Hide details" : "Behind the magic"}
+            {detailsOpen
+              ? (options?.messages?.hideDetails ?? "Hide details")
+              : (options?.messages?.showDetails ?? "Behind the magic")}
             <span aria-hidden="true"> ↗</span>
           </button>
         ) : null}

package/src/timeline/index.ts

@@ -41,6 +41,7 @@ export type {
   MachineInputBatchItem,
   MachineInputMember,
   MemoryItem,
+  KnowledgeItem,
   NoticeItem,
   ReasoningItem,
   SandboxItem,
@@ -139,3 +140,6 @@ export {
   v4aToGitFileDiff,
 } from "./parsers";
 export type { ApplyPatchOperation } from "./parsers";
+
+export { KnowledgeActivityProvider } from "./knowledge-receipt";
+export type { KnowledgeActivityActions } from "./knowledge-receipt";

package/src/timeline/knowledge-receipt.tsx

@@ -0,0 +1,100 @@
+import { createContext, useContext, useState, type ReactNode } from "react";
+import { BrainCircuitIcon } from "lucide-react";
+import { ActivityDisclosure, BodyNote } from "./shared";
+
+export type KnowledgeActivityActions = {
+  onInspect?: ((entryId: string) => void) | undefined;
+  onRetryFile?: ((fileId: string) => Promise<boolean | void>) | undefined;
+  retryDisabled?: boolean | undefined;
+};
+const KnowledgeActions = createContext<KnowledgeActivityActions>({});
+export function KnowledgeActivityProvider({
+  children,
+  ...actions
+}: KnowledgeActivityActions & { children: ReactNode }) {
+  return <KnowledgeActions.Provider value={actions}>{children}</KnowledgeActions.Provider>;
+}
+
+/** A saved/pending result never opens or blocks the human-input surface. */
+export function KnowledgeReceiptRow(props: {
+  outcome: "published" | "pending" | "rejected" | "archived" | "failed";
+  entryId?: string | undefined;
+  fileId?: string | undefined;
+  title?: string | undefined;
+  source?: boolean | undefined;
+}) {
+  const actions = useContext(KnowledgeActions);
+  const [retrying, setRetrying] = useState(false);
+  const [retrySent, setRetrySent] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const label =
+    props.outcome === "pending"
+      ? "Knowledge saved for review"
+      : props.outcome === "failed"
+        ? "Source preparation failed"
+        : props.outcome === "rejected"
+          ? "Source remains rejected"
+          : props.outcome === "archived"
+            ? "Knowledge archived"
+            : props.source
+              ? "Source saved to Knowledge"
+              : "Saved to Knowledge";
+  const actionClass =
+    "rounded-og-sm px-1 py-0.5 text-og-sm text-og-fg-muted hover:text-og-fg focus-visible:outline-2 focus-visible:outline-og-accent disabled:opacity-50";
+  return (
+    <ActivityDisclosure
+      icon={<BrainCircuitIcon className="size-3.5" />}
+      iconTone="muted"
+      title={label}
+      preview={props.title}
+    >
+      {props.outcome === "pending" ? (
+        <BodyNote>
+          Saved in Needs review. This task continues; future tasks can use it after approval.
+        </BodyNote>
+      ) : null}
+      {props.outcome === "failed" ? (
+        <BodyNote>
+          The original file remains attached. Searchable text has not been retained.
+        </BodyNote>
+      ) : null}
+      {props.outcome === "rejected" ? (
+        <BodyNote>Processing the file again leaves the review decision unchanged.</BodyNote>
+      ) : null}
+      {props.entryId && actions.onInspect ? (
+        <button
+          className={actionClass}
+          type="button"
+          onClick={() => actions.onInspect?.(props.entryId!)}
+        >
+          {props.outcome === "pending" ? "Review in Knowledge" : "View in Knowledge"}
+        </button>
+      ) : null}
+      {props.outcome === "failed" && props.fileId && actions.onRetryFile ? (
+        <button
+          className={actionClass}
+          type="button"
+          disabled={retrying || retrySent || actions.retryDisabled}
+          onClick={() => {
+            setRetrying(true);
+            setError(null);
+            void actions.onRetryFile!(props.fileId!)
+              .then((sent) => {
+                if (sent !== false) setRetrySent(true);
+                else setError("Could not start the retry. Try again when the chat is ready.");
+              })
+              .catch(() => setError("Could not start the retry. Please try again."))
+              .finally(() => setRetrying(false));
+          }}
+        >
+          {retrying ? "Starting retry…" : retrySent ? "Retry requested" : "Retry preparation"}
+        </button>
+      ) : null}
+      {error ? (
+        <p role="alert" className="text-og-sm">
+          {error}
+        </p>
+      ) : null}
+    </ActivityDisclosure>
+  );
+}

package/src/timeline/platform-activity-row.tsx

@@ -10,7 +10,6 @@ export default function PlatformActivityRow({
   t: displayName,
   b: BotIcon,
   m: Markdown,
-  r: truncate,
   j,
   s,
 }: {
@@ -20,7 +19,6 @@ export default function PlatformActivityRow({
   t: (name: string) => string;
   b: typeof import("lucide-react").BotIcon;
   m: typeof import("../components/markdown").Markdown;
-  r: typeof import("../lib/format").truncate;
   j: RowJsx;
   s: RowJsxs;
 }) {
@@ -35,7 +33,11 @@ export default function PlatformActivityRow({
             children: "Thought",
           }),
       running: item.streaming,
-      preview: truncate(item.text, 110),
+      compactPreview: item.text.replace(/\*\*|__|`/g, "").replace(/\s+/g, " "),
+      preview: j("span", {
+        className: "og-reasoning-preview",
+        children: j(Markdown, { streaming: item.streaming, children: item.text }),
+      }),
       children: j("div", {
         className: "text-og-base leading-6 text-og-fg-muted [&_strong]:text-og-fg-muted",
         children: j(Markdown, { streaming: item.streaming, children: item.text }),

package/src/timeline/projection.ts

@@ -1175,6 +1175,45 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "instruction.confirmation.recovered": {
+        const receipt = asRecord(payload.receipt);
+        if (receipt.outcome !== "published") break;
+        closeStreamingTail();
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "input",
+          text: "Your previously approved workspace instruction was saved.",
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+      case "knowledge.confirmation.recovered":
+      case "knowledge.source.prepared":
+      case "knowledge.source.failed": {
+        const receipt = asRecord(payload.receipt);
+        const outcome = event.type === "knowledge.source.failed" ? "failed" : receipt.outcome;
+        if (
+          (event.type !== "knowledge.confirmation.recovered" &&
+            typeof payload.fileId !== "string") ||
+          !["published", "pending", "rejected", "archived", "failed"].includes(String(outcome))
+        )
+          break;
+        closeStreamingTail();
+        items.push({
+          kind: "knowledge",
+          id: event.id,
+          turnId,
+          fileId: typeof payload.fileId === "string" ? payload.fileId : undefined,
+          filename: typeof payload.filename === "string" ? payload.filename : undefined,
+          entryId: typeof receipt.entryId === "string" ? receipt.entryId : undefined,
+          status: outcome === "failed" ? "failed" : "complete",
+          outcome: outcome as "published" | "pending" | "rejected" | "archived" | "failed",
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+
       case "memory.saved":
       case "memory.corrected": {
         // A first-party memory write is a discrete step, not streamed text, so it
@@ -1517,6 +1556,7 @@ function isActivityItem(item: TimelineItem): item is ActivityItem {
     case "sandbox":
     case "startup-phase":
     case "memory":
+    case "knowledge":
     case "fleet-decision":
       return true;
     default:

package/src/timeline/retained-image.ts

@@ -0,0 +1,91 @@
+import { useEffect, useRef, useState } from "react";
+import type { RetainedArtifactReference } from "@opengeni/sdk";
+import type { ToolRendererProps } from "./registry";
+type RetainedImageState =
+  | { kind: "loading" }
+  | { kind: "ready"; url: string }
+  | { kind: "unavailable"; label: string }
+  | { kind: "error"; message: string };
+
+export function useRetainedImageObjectUrl(
+  artifact: RetainedArtifactReference,
+  load: ToolRendererProps["loadRetainedArtifact"],
+): RetainedImageState {
+  const [state, setState] = useState<RetainedImageState>({ kind: "loading" });
+  // Function outputs are commonly serialized JSON. Parsing them creates a new
+  // object on every render, so depend on the immutable wire value rather than
+  // object identity; otherwise the loader can refetch after its own setState.
+  const artifactValue = retainedArtifactValue(artifact);
+  const stableArtifactRef = useRef({ value: artifactValue, artifact });
+  if (stableArtifactRef.current.value !== artifactValue) {
+    stableArtifactRef.current = { value: artifactValue, artifact };
+  }
+  const stableArtifact = stableArtifactRef.current.artifact;
+  useEffect(() => {
+    if (!load) {
+      setState({ kind: "unavailable", label: "retrieval is not configured" });
+      return;
+    }
+    const controller = new AbortController();
+    let objectUrl: string | null = null;
+    setState({ kind: "loading" });
+    void load(stableArtifact, controller.signal)
+      .then((source) => {
+        if (controller.signal.aborted) return;
+        if (!source) {
+          setState({ kind: "unavailable", label: "bytes are unavailable" });
+          return;
+        }
+        if (!(source instanceof Uint8Array)) {
+          if (!source.url.trim()) {
+            setState({ kind: "unavailable", label: "URL is unavailable" });
+            return;
+          }
+          setState({ kind: "ready", url: source.url });
+          return;
+        }
+        objectUrl = URL.createObjectURL(
+          new Blob([source as unknown as BlobPart], { type: stableArtifact.contentType }),
+        );
+        setState({ kind: "ready", url: objectUrl });
+      })
+      .catch((error: unknown) => {
+        if (controller.signal.aborted) return;
+        const status =
+          error && typeof error === "object" && "status" in error
+            ? Number((error as { status?: unknown }).status)
+            : null;
+        setState(
+          status === 404
+            ? { kind: "unavailable", label: "deleted" }
+            : status === 410
+              ? { kind: "unavailable", label: "expired or unavailable" }
+              : { kind: "error", message: "retrieval failed" },
+        );
+      });
+    return () => {
+      controller.abort();
+      if (objectUrl) URL.revokeObjectURL(objectUrl);
+    };
+  }, [stableArtifact, load]);
+  return state;
+}
+
+function retainedArtifactValue(artifact: RetainedArtifactReference): string {
+  return [
+    artifact.artifactId,
+    artifact.kind,
+    artifact.contentType,
+    artifact.originalBytes,
+    artifact.sha256,
+    artifact.retainedAt,
+    artifact.dimensions?.width ?? "",
+    artifact.dimensions?.height ?? "",
+    artifact.retention.policy,
+    artifact.retention.expiresAt ?? "",
+    artifact.retrieval.method,
+    artifact.retrieval.path,
+    artifact.retrieval.acceptRanges,
+    artifact.retrieval.maxRangeBytes,
+  ].join("\0");
+}

package/src/timeline/rolling-activity.tsx

@@ -0,0 +1,83 @@
+import { renderActivity } from "./activity-rail";
+import { AnimatePresence, motion, useReducedMotion } from "motion/react";
+import { WrenchIcon } from "lucide-react";
+import { Suspense, useEffect, useState } from "react";
+import { CompactActivityContext } from "./shared";
+import { defaultToolRegistry } from "./tool-renderers";
+import type { ToolRegistry } from "./registry";
+import { toolDisplayName } from "./tool-display-name";
+import type { ActivityItem } from "./types";
+
+/** One stable viewport; updates replace its content without moving the conversation. */
+export function RollingActivity({
+  items,
+  toolRegistry = defaultToolRegistry,
+  previousItem,
+}: {
+  items: ActivityItem[];
+  /** The standalone item visible immediately before this reel mounted. */
+  previousItem?: ActivityItem | undefined;
+  toolRegistry?: ToolRegistry;
+}) {
+  const reduced = useReducedMotion();
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+  const work = items.filter((item) => item.kind !== "startup-phase");
+  const active = work.filter((item) =>
+    item.kind === "reasoning" ? item.streaming : "status" in item && item.status === "running",
+  );
+  // Advance with the event order; finishing a parallel tool must not replay an older one.
+  const item = !mounted && previousItem ? previousItem : work.at(-1);
+  if (!item) return null;
+  const earlierCount = Math.max(
+    0,
+    work.findIndex((entry) => entry.id === item.id),
+  );
+  const fallback = (
+    <span className="og-rolling-label">
+      <WrenchIcon className="size-3.5" />
+      <span>{item.kind === "tool-call" ? toolDisplayName(item.name) : "Working"}</span>
+    </span>
+  );
+  return (
+    <span
+      className="og-rolling-status"
+      data-running={active.some((entry) => entry.id === item.id) ? "true" : undefined}
+    >
+      <span className="sr-only">
+        {item.kind === "tool-call"
+          ? toolDisplayName(item.name)
+          : item.kind === "reasoning"
+            ? "Thinking"
+            : "Working"}
+      </span>
+      <span className="og-rolling-window" aria-hidden="true">
+        <AnimatePresence initial={false} mode="sync">
+          <motion.span
+            key={item.id}
+            className="og-rolling-face"
+            initial={{
+              opacity: 0,
+              y: reduced ? 0 : 24,
+            }}
+            animate={{ opacity: 1, y: 0 }}
+            exit={{
+              opacity: 0,
+              y: reduced ? 0 : -24,
+            }}
+            transition={{ duration: reduced ? 0 : 0.4, ease: [0.22, 1, 0.36, 1] }}
+          >
+            <CompactActivityContext.Provider value={true}>
+              <Suspense fallback={fallback}>
+                {renderActivity(item, toolRegistry, undefined, undefined, undefined, undefined)}
+              </Suspense>
+            </CompactActivityContext.Provider>
+          </motion.span>
+        </AnimatePresence>
+      </span>
+      {earlierCount > 0 ? (
+        <span className="og-rolling-count">{`+${earlierCount} earlier`}</span>
+      ) : null}
+    </span>
+  );
+}

package/src/timeline/shared.tsx

@@ -55,6 +55,8 @@ export function ToolCallTruncationProvider({
 }
 
 export type ActivityDisclosureProps = {
+  /** Override the rolling preview; null keeps rapidly streaming details out of the header. */
+  compactPreview?: ReactNode;
   icon: ReactNode;
   /** Icon tint. Defaults to the muted foreground; renderers pass accent/failed. */
   iconTone?: "accent" | "failed" | "running" | "muted" | undefined;
@@ -116,6 +118,8 @@ const ICON_TONE: Record<NonNullable<ActivityDisclosureProps["iconTone"]>, string
  * inline media, and at most one right-gutter settle chip. Compact by default;
  * the body mounts only when expanded.
  */
+export const CompactActivityContext = createContext(false);
+
 export function ActivityDisclosure({
   icon,
   iconTone: iconToneProp = "muted",
@@ -123,6 +127,7 @@ export function ActivityDisclosure({
   titleMono,
   running,
   preview,
+  compactPreview,
   media,
   chip: chipProp,
   failed,
@@ -150,6 +155,21 @@ export function ActivityDisclosure({
   const forcedDefaultOpen = useForcedDefaultOpen();
   const [open, setOpen] = useState(defaultOpen ?? forcedDefaultOpen ?? false);
   const truncation = useContext(ToolCallTruncationContext);
+  const compact = useContext(CompactActivityContext);
+  if (compact)
+    return (
+      <span className="og-rolling-label">
+        <span className={cn("shrink-0", ICON_TONE[iconTone])}>{icon}</span>
+        <span className="og-command-reel">
+          <span className="og-reel-title">{title}</span>
+          {(compactPreview === undefined ? preview : compactPreview) ? (
+            <span className="og-reel-preview text-og-fg-subtle">
+              {compactPreview === undefined ? preview : compactPreview}
+            </span>
+          ) : null}
+        </span>
+      </span>
+    );
   const hasBody = expandable && (children != null || truncation != null);
 
   // The preview is detail-on-demand: it is suppressed once the row is open so a
@@ -189,20 +209,21 @@ export function ActivityDisclosure({
         <span className="size-3.5 shrink-0" />
       )}
       <span className={cn("shrink-0", ICON_TONE[iconTone])}>{icon}</span>
-      <span
-        className={cn(
-          "min-w-0 shrink truncate text-og-base font-medium",
-          titleMono && "font-og-mono text-og-sm font-normal",
-          running && "og-shimmer-text",
+      <span className={cn("og-command-reel", running && "og-command-reel-running")}>
+        <span
+          className={cn(
+            "min-w-0 shrink truncate text-og-base font-medium",
+            titleMono && "font-og-mono text-og-sm font-normal",
+          )}
+        >
+          {title}
+        </span>
+        {previewVisible && !media ? (
+          <span className="min-w-0 flex-1 truncate text-og-sm text-og-fg-subtle">{preview}</span>
+        ) : (
+          <span className="flex-1" />
         )}
-      >
-        {title}
       </span>
-      {previewVisible && !media ? (
-        <span className="min-w-0 flex-1 truncate text-og-sm text-og-fg-subtle">{preview}</span>
-      ) : (
-        <span className="flex-1" />
-      )}
       {/* The right gutter carries at most ONE signal: the media thumbnail, else a
           terse settle chip (hidden once expanded — the body owns the detail). */}
       {media && !open ? (

package/src/timeline/tool-renderers.tsx

@@ -1,3 +1,5 @@
+import { KnowledgeReceiptRow } from "./knowledge-receipt";
+import { useRetainedImageObjectUrl } from "./retained-image";
 import {
   parseSandboxFileArtifactReceipt,
   type GitFileDiff,
@@ -34,7 +36,7 @@ import {
   VideoIcon,
   WrenchIcon,
 } from "lucide-react";
-import { useEffect, useRef, useState, type ReactNode } from "react";
+import { useContext, useState, type ReactNode } from "react";
 import { formatBytes, stringifyPayload, tryParseJson } from "../lib/format";
 import { useTimelineComputeLabel } from "./compute-label";
 import {
@@ -71,6 +73,7 @@ import {
   TermBlock,
   Thumbnail,
   ActivityDisclosure,
+  CompactActivityContext,
   type DisclosureChip,
 } from "./shared";
 import { RawPatch, ToolDiff } from "./tool-diff";
@@ -96,9 +99,12 @@ const ICON_SIZE = "size-3.5";
  * left-to-right.
  */
 function RunningPreview({ children }: { children: ReactNode }) {
+  const compact = useContext(CompactActivityContext);
   return (
     <span className="inline-flex items-center gap-1.5">
-      <span className="size-1.5 shrink-0 animate-og-pulse rounded-full bg-og-status-running" />
+      {!compact && (
+        <span className="size-1.5 shrink-0 animate-og-pulse rounded-full bg-og-status-running" />
+      )}
       <span className="min-w-0 truncate">{children}</span>
     </span>
   );
@@ -766,95 +772,6 @@ function ComputerCallRenderer({ item, loadRetainedScreenshot }: ToolRendererProp
   );
 }
 
-type RetainedImageState =
-  | { kind: "loading" }
-  | { kind: "ready"; url: string }
-  | { kind: "unavailable"; label: string }
-  | { kind: "error"; message: string };
-
-function useRetainedImageObjectUrl(
-  artifact: RetainedArtifactReference,
-  load: ToolRendererProps["loadRetainedArtifact"],
-): RetainedImageState {
-  const [state, setState] = useState<RetainedImageState>({ kind: "loading" });
-  // Function outputs are commonly serialized JSON. Parsing them creates a new
-  // object on every render, so depend on the immutable wire value rather than
-  // object identity; otherwise the loader can refetch after its own setState.
-  const artifactValue = retainedArtifactValue(artifact);
-  const stableArtifactRef = useRef({ value: artifactValue, artifact });
-  if (stableArtifactRef.current.value !== artifactValue) {
-    stableArtifactRef.current = { value: artifactValue, artifact };
-  }
-  const stableArtifact = stableArtifactRef.current.artifact;
-  useEffect(() => {
-    if (!load) {
-      setState({ kind: "unavailable", label: "retrieval is not configured" });
-      return;
-    }
-    const controller = new AbortController();
-    let objectUrl: string | null = null;
-    setState({ kind: "loading" });
-    void load(stableArtifact, controller.signal)
-      .then((source) => {
-        if (controller.signal.aborted) return;
-        if (!source) {
-          setState({ kind: "unavailable", label: "bytes are unavailable" });
-          return;
-        }
-        if (!(source instanceof Uint8Array)) {
-          if (!source.url.trim()) {
-            setState({ kind: "unavailable", label: "URL is unavailable" });
-            return;
-          }
-          setState({ kind: "ready", url: source.url });
-          return;
-        }
-        objectUrl = URL.createObjectURL(
-          new Blob([source as unknown as BlobPart], { type: stableArtifact.contentType }),
-        );
-        setState({ kind: "ready", url: objectUrl });
-      })
-      .catch((error: unknown) => {
-        if (controller.signal.aborted) return;
-        const status =
-          error && typeof error === "object" && "status" in error
-            ? Number((error as { status?: unknown }).status)
-            : null;
-        setState(
-          status === 404
-            ? { kind: "unavailable", label: "deleted" }
-            : status === 410
-              ? { kind: "unavailable", label: "expired or unavailable" }
-              : { kind: "error", message: "retrieval failed" },
-        );
-      });
-    return () => {
-      controller.abort();
-      if (objectUrl) URL.revokeObjectURL(objectUrl);
-    };
-  }, [stableArtifact, load]);
-  return state;
-}
-
-function retainedArtifactValue(artifact: RetainedArtifactReference): string {
-  return [
-    artifact.artifactId,
-    artifact.kind,
-    artifact.contentType,
-    artifact.originalBytes,
-    artifact.sha256,
-    artifact.retainedAt,
-    artifact.dimensions?.width ?? "",
-    artifact.dimensions?.height ?? "",
-    artifact.retention.policy,
-    artifact.retention.expiresAt ?? "",
-    artifact.retrieval.method,
-    artifact.retrieval.path,
-    artifact.retrieval.acceptRanges,
-    artifact.retrieval.maxRangeBytes,
-  ].join("\0");
-}
-
 function RetainedSessionImageDisclosure({
   artifact,
   load,
@@ -2370,7 +2287,54 @@ function GenericToolIcon({ name }: { name: string }) {
 
 /* ---- the default registry -------------------------------------------------- */
 
+function KnowledgeSaveRenderer({ item }: ToolRendererProps) {
+  const output = unwrapMcpOutput(item.output);
+  const parsed = tryParseJson(output.text);
+  if (item.status === "running" || output.isError || !parsed || typeof parsed !== "object")
+    return <GenericRenderer item={item} />;
+  const value = parsed as Record<string, unknown>;
+  const receipt = (value.status === "retained" ? value.receipt : value) as
+    | Record<string, unknown>
+    | undefined;
+  if (
+    !receipt ||
+    typeof receipt.entryId !== "string" ||
+    !["published", "pending", "rejected", "archived"].includes(String(receipt.outcome))
+  )
+    return <GenericRenderer item={item} />;
+  const args = parseToolArgs(item.arguments);
+  const entry = args.entry as Record<string, unknown> | undefined;
+  return (
+    <KnowledgeReceiptRow
+      outcome={receipt.outcome as "published" | "pending" | "rejected" | "archived"}
+      entryId={receipt.entryId}
+      title={
+        typeof entry?.title === "string"
+          ? entry.title
+          : typeof value.filename === "string"
+            ? value.filename
+            : undefined
+      }
+      source={value.status === "retained" || value.retained === true}
+    />
+  );
+}
+
 const BASE_ENTRIES: ToolRegistryEntry[] = [
+  ...[
+    "knowledge_save",
+    "knowledge_archive",
+    "knowledge_retain_file",
+    "knowledge_retain_message",
+    "task_note_promote_knowledge",
+  ].flatMap((name) =>
+    [name, `opengeni__${name}`, `mcp__opengeni__${name}`].map((trustedName) => ({
+      match: "name" as const,
+      name: trustedName,
+      matchPrefixedLeaf: false,
+      render: KnowledgeSaveRenderer,
+    })),
+  ),
   // Provider-native items carry `raw.type` on the wire — this is their source of
   // truth and is consulted first by the registry.
   { match: "rawType", type: "apply_patch_call", render: ApplyPatchRenderer },