@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/client-web/src/docker-sandbox-view.ts

@@ -0,0 +1,177 @@
+export interface DockerSandboxRunView {
+  readonly image: string;
+  readonly command: readonly string[];
+  readonly commandCount: number;
+  readonly write: boolean;
+  readonly exitCode: number;
+  readonly status: "completed" | "failed" | "timed_out";
+  readonly output: string;
+  readonly truncated: boolean;
+}
+
+export interface DockerSandboxDefaultsView {
+  readonly image: string;
+  readonly pull: string;
+  readonly network: string;
+  readonly rootFilesystem: string;
+  readonly workspace: string;
+  readonly memory: string;
+  readonly cpus: number;
+  readonly pids: number;
+  readonly timeoutMs: number;
+}
+
+export interface DockerSandboxPanelView {
+  readonly latest: DockerSandboxRunView | null;
+  readonly defaults: DockerSandboxDefaultsView;
+  readonly malformed: boolean;
+}
+
+const defaultSettings = {
+  image: "alpine:3.20",
+  pull: "never",
+  network: "none",
+  rootFilesystem: "read-only",
+  workspace: "read-only",
+  memory: "512m",
+  cpus: 1,
+  pids: 256,
+  timeoutMs: 120_000,
+} as const;
+const rootKeys = new Set(["latest", "defaults"]);
+const latestKeys = new Set(["image", "command", "write", "exitCode", "status", "output"]);
+const defaultsKeys = new Set(Object.keys(defaultSettings));
+const maxArguments = 128;
+const maxImageInputLength = 4_096;
+const maxArgumentInputLength = 16_384;
+const maxOutputInputLength = 12_000;
+const maxVisibleArguments = 16;
+const maxVisibleArgumentLength = 256;
+const maxVisibleOutputLength = 4_000;
+const unsafeUnicode = /[\p{Cc}\p{Cf}\p{Cs}\u2028\u2029]/u;
+
+function ownDataRecord(value: unknown, allowed: ReadonlySet<string>): Record<string, unknown> | undefined {
+  try {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string" || !allowed.has(key))) return undefined;
+    const output = Object.create(null) as Record<string, unknown>;
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!("value" in descriptor)) return undefined;
+      output[key] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasExactly(source: Record<string, unknown>, keys: ReadonlySet<string>): boolean {
+  const own = Object.keys(source);
+  return own.length === keys.size && own.every((key) => keys.has(key));
+}
+
+function ownDataArray(value: unknown, maximum: number): unknown[] | undefined {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value) as unknown as PropertyDescriptorMap;
+    const lengthDescriptor = descriptors.length;
+    const length: unknown = lengthDescriptor !== undefined && "value" in lengthDescriptor ? lengthDescriptor.value : undefined;
+    if (!Number.isSafeInteger(length) || (length as number) < 0 || (length as number) > maximum) return undefined;
+    if (
+      Reflect.ownKeys(descriptors).some(
+        (key) => key !== "length" && (typeof key !== "string" || !/^\d+$/u.test(key) || Number(key) >= (length as number) || String(Number(key)) !== key),
+      ) ||
+      Object.values(descriptors).some((descriptor) => !("value" in descriptor))
+    )
+      return undefined;
+    const output: unknown[] = [];
+    for (let index = 0; index < (length as number); index += 1) {
+      const descriptor = descriptors[String(index)];
+      if (descriptor === undefined || !("value" in descriptor)) return undefined;
+      output.push(descriptor.value);
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function safeText(value: unknown, maximum: number, allowEmpty = false, allowLineBreaks = false): string | undefined {
+  if (typeof value !== "string" || (!allowEmpty && value.length === 0)) return undefined;
+  for (const character of value) {
+    if (unsafeUnicode.test(character) && !(allowLineBreaks && (character === "\t" || character === "\n" || character === "\r"))) return undefined;
+  }
+  if ([...value].length > maximum || new TextEncoder().encode(value).byteLength > maximum) return undefined;
+  return value;
+}
+
+function safeInteger(value: unknown, minimum: number, maximum: number): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum ? value : undefined;
+}
+
+function displayText(value: string, maximum: number): string {
+  return [...value].slice(0, maximum).join("");
+}
+
+function runView(value: unknown): DockerSandboxRunView | undefined {
+  const source = ownDataRecord(value, latestKeys);
+  if (source === undefined || !hasExactly(source, latestKeys)) return undefined;
+  const image = safeText(source.image, maxImageInputLength);
+  const commandRaw = ownDataArray(source.command, maxArguments);
+  const output = safeText(source.output, maxOutputInputLength, true, true);
+  const exitCode = safeInteger(source.exitCode, -2_147_483_648, 2_147_483_647);
+  if (
+    image === undefined ||
+    commandRaw === undefined ||
+    commandRaw.length === 0 ||
+    output === undefined ||
+    exitCode === undefined ||
+    typeof source.write !== "boolean" ||
+    (source.status !== "completed" && source.status !== "failed" && source.status !== "timed_out")
+  )
+    return undefined;
+  const command: string[] = [];
+  for (const argument of commandRaw) {
+    const text = safeText(argument, maxArgumentInputLength);
+    if (text === undefined || text.length === 0) return undefined;
+    command.push(text);
+  }
+  return {
+    image: displayText(image, 512),
+    command: command.slice(0, maxVisibleArguments).map((argument) => displayText(argument, maxVisibleArgumentLength)),
+    commandCount: command.length,
+    write: source.write,
+    exitCode,
+    status: source.status,
+    output: displayText(output, maxVisibleOutputLength),
+    truncated:
+      image.length > 512 ||
+      command.length > maxVisibleArguments ||
+      command.some((argument) => argument.length > maxVisibleArgumentLength) ||
+      output.length > maxVisibleOutputLength,
+  };
+}
+
+function defaultsView(value: unknown): DockerSandboxDefaultsView | undefined {
+  const source = ownDataRecord(value, defaultsKeys);
+  if (source === undefined || !hasExactly(source, defaultsKeys)) return undefined;
+  for (const [key, expected] of Object.entries(defaultSettings)) if (source[key] !== expected) return undefined;
+  return { ...defaultSettings };
+}
+
+function malformedView(): DockerSandboxPanelView {
+  return { latest: null, defaults: { ...defaultSettings }, malformed: true };
+}
+
+export function dockerSandboxPanelView(data: unknown): DockerSandboxPanelView {
+  const source = ownDataRecord(data, rootKeys);
+  if (source === undefined || !hasExactly(source, rootKeys)) return malformedView();
+  const defaults = defaultsView(source.defaults);
+  if (defaults === undefined) return malformedView();
+  if (source.latest === null) return { latest: null, defaults, malformed: false };
+  const latest = runView(source.latest);
+  return latest === undefined ? malformedView() : { latest, defaults, malformed: false };
+}

package/packages/client-web/src/fail-logger-view.ts

@@ -0,0 +1,112 @@
+export interface FailureView {
+  readonly time: string | null;
+  readonly source: string;
+  readonly message: string;
+  readonly occurrences: number;
+}
+
+export interface FailLoggerPanelView {
+  readonly total: number;
+  readonly observed: number;
+  readonly dropped: number;
+  readonly capacity: number;
+  readonly failures: readonly FailureView[];
+  readonly truncated: boolean;
+}
+
+const failureLimit = 50;
+const sourceLimit = 64;
+const messageLimit = 2_048;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") return false;
+  try {
+    return !Array.isArray(value);
+  } catch {
+    return false;
+  }
+}
+
+function ownDataProperty(value: unknown, key: string): unknown {
+  if (value === null || typeof value !== "object") return undefined;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function dataProperty(value: unknown, key: string): unknown {
+  return isRecord(value) ? ownDataProperty(value, key) : undefined;
+}
+
+function arrayLength(value: unknown): number | undefined {
+  try {
+    if (!Array.isArray(value)) return undefined;
+  } catch {
+    return undefined;
+  }
+  const length = ownDataProperty(value, "length");
+  return typeof length === "number" && Number.isSafeInteger(length) && length >= 0 ? length : undefined;
+}
+
+function count(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+
+function positiveCount(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+function capacity(value: unknown): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= failureLimit ? value : failureLimit;
+}
+
+function failure(value: unknown): { readonly value: FailureView; readonly truncated: boolean } | undefined {
+  if (!isRecord(value)) return undefined;
+  const rawSource = dataProperty(value, "source");
+  const rawMessage = dataProperty(value, "message");
+  if (typeof rawSource !== "string" || typeof rawMessage !== "string") return undefined;
+  const rawTime = dataProperty(value, "time");
+  const time = typeof rawTime === "string" && rawTime.length <= 64 && Number.isFinite(Date.parse(rawTime)) ? new Date(rawTime).toISOString() : null;
+  const normalizedSource = (rawSource.trim() || "runtime").replaceAll("\0", "�");
+  const normalizedMessage = (rawMessage.trim() || "未知错误").replaceAll("\0", "�");
+  return {
+    value: {
+      time,
+      source: normalizedSource.slice(0, sourceLimit),
+      message: normalizedMessage.slice(0, messageLimit),
+      occurrences: positiveCount(dataProperty(value, "occurrences"), 1),
+    },
+    truncated: normalizedSource.length > sourceLimit || normalizedMessage.length > messageLimit || rawSource.includes("\0") || rawMessage.includes("\0"),
+  };
+}
+
+export function failLoggerPanelView(data: unknown): FailLoggerPanelView {
+  const source = isRecord(data) ? data : {};
+  const sourceFailures = dataProperty(source, "failures");
+  const rawLength = arrayLength(sourceFailures) ?? 0;
+  const inspectedLength = Math.min(rawLength, failureLimit);
+  const failures: FailureView[] = [];
+  let truncated = rawLength > failureLimit;
+  for (let index = 0; index < inspectedLength; index += 1) {
+    const item = failure(ownDataProperty(sourceFailures, String(index)));
+    if (item === undefined) {
+      truncated = true;
+      continue;
+    }
+    failures.push(item.value);
+    if (item.truncated) truncated = true;
+  }
+  const total = count(dataProperty(source, "total"), failures.length);
+  const observed = Math.max(total, count(dataProperty(source, "observed"), total));
+  return {
+    total,
+    observed,
+    dropped: count(dataProperty(source, "dropped"), 0),
+    capacity: capacity(dataProperty(source, "capacity")),
+    failures,
+    truncated,
+  };
+}

package/packages/client-web/src/genui-view.ts

@@ -0,0 +1,88 @@
+type BlockType = "text" | "badge" | "progress";
+type Tone = "neutral" | "info" | "success" | "warning" | "danger";
+
+export interface GenUiBlockView {
+  readonly type: BlockType;
+  readonly label: string;
+  readonly value: string | number;
+  readonly tone: Tone;
+}
+
+export interface GenUiCardView {
+  readonly title: string;
+  readonly renderedAt: string | null;
+  readonly blocks: readonly GenUiBlockView[];
+  readonly truncated: boolean;
+}
+
+export interface GenUiPanelView {
+  readonly rendered: number;
+  readonly latest: GenUiCardView | null;
+  readonly limits: { readonly blocks: number; readonly title: number; readonly label: number; readonly value: number; readonly totalText: number };
+}
+
+const defaultLimits = { blocks: 12, title: 256, label: 256, value: 4_000, totalText: 16_384 } as const;
+const visibleValueLimit = 2_000;
+const blockTypes = new Set<BlockType>(["text", "badge", "progress"]);
+const tones = new Set<Tone>(["neutral", "info", "success", "warning", "danger"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function count(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+
+function block(value: unknown): GenUiBlockView | undefined {
+  if (!isRecord(value) || typeof value.type !== "string" || !blockTypes.has(value.type as BlockType)) return undefined;
+  if (typeof value.label !== "string" || value.label.trim() === "" || typeof value.tone !== "string" || !tones.has(value.tone as Tone)) return undefined;
+  const type = value.type as BlockType;
+  const tone = value.tone as Tone;
+  if (type === "progress") {
+    if (typeof value.value !== "number" || !Number.isFinite(value.value) || value.value < 0 || value.value > 100) return undefined;
+    return { type, label: value.label.slice(0, defaultLimits.label), value: value.value, tone };
+  }
+  if (typeof value.value !== "string") return undefined;
+  return { type, label: value.label.slice(0, defaultLimits.label), value: value.value.slice(0, visibleValueLimit), tone };
+}
+
+function card(value: unknown): GenUiCardView | null {
+  if (!isRecord(value) || typeof value.title !== "string" || value.title.trim() === "" || !Array.isArray(value.blocks)) return null;
+  const blocks = value.blocks
+    .slice(0, defaultLimits.blocks)
+    .map(block)
+    .filter((item): item is GenUiBlockView => item !== undefined);
+  const renderedAt = typeof value.renderedAt === "string" && Number.isFinite(Date.parse(value.renderedAt)) ? new Date(value.renderedAt).toISOString() : null;
+  return {
+    title: value.title.slice(0, defaultLimits.title),
+    renderedAt,
+    blocks,
+    truncated:
+      value.title.length > defaultLimits.title ||
+      value.blocks.length > defaultLimits.blocks ||
+      blocks.length !== Math.min(value.blocks.length, defaultLimits.blocks) ||
+      value.blocks.some(
+        (item) =>
+          isRecord(item) &&
+          ((typeof item.label === "string" && item.label.length > defaultLimits.label) ||
+            (typeof item.value === "string" && item.value.length > visibleValueLimit)),
+      ),
+  };
+}
+
+export function genUiPanelView(data: unknown): GenUiPanelView {
+  const source = isRecord(data) ? data : {};
+  const limits = isRecord(source.limits) ? source.limits : {};
+  return {
+    rendered: count(source.rendered, 0),
+    latest: card(source.latest),
+    limits: {
+      blocks: count(limits.blocks, defaultLimits.blocks) || defaultLimits.blocks,
+      title: count(limits.title, defaultLimits.title) || defaultLimits.title,
+      label: count(limits.label, defaultLimits.label) || defaultLimits.label,
+      value: count(limits.value, defaultLimits.value) || defaultLimits.value,
+      totalText: count(limits.totalText, defaultLimits.totalText) || defaultLimits.totalText,
+    },
+  };
+}

package/packages/client-web/src/git-time-capsule-view.ts

@@ -0,0 +1,215 @@
+export interface GitTimeCapsuleActivityView {
+  readonly action: "capture" | "restore";
+  readonly status: "completed" | "failed" | "cancelled";
+  readonly at: string;
+  readonly name: string | null;
+  readonly bytes: number;
+  readonly files: number;
+  readonly error: string | null;
+}
+
+export interface GitTimeCapsulePanelView {
+  readonly latest: GitTimeCapsuleActivityView | null;
+  readonly capsules: readonly { readonly name: string; readonly bytes: number }[];
+  readonly inventory: { readonly total: number; readonly shown: number; readonly truncated: boolean; readonly displayLimit: number };
+  readonly timeoutMs: number;
+  readonly limits: { readonly capsuleBytes: number; readonly inventory: number; readonly directoryEntries: number };
+  readonly truncated: boolean;
+}
+
+const defaults = {
+  timeoutMs: 15_000,
+  capsuleBytes: 8 * 1024 * 1024,
+  inventory: 256,
+  directoryEntries: 4_096,
+  displayLimit: 20,
+};
+const maxErrorLength = 2_000;
+
+function ownDataRecord(value: unknown): Record<string, unknown> | undefined {
+  try {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string")) return undefined;
+    const output = Object.create(null) as Record<string, unknown>;
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!("value" in descriptor)) return undefined;
+      output[key] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownDataArray(value: unknown, maximum: number): { values: unknown[]; altered: boolean } | undefined {
+  try {
+    if (!Array.isArray(value)) return undefined;
+    const length = Object.getOwnPropertyDescriptor(value, "length");
+    if (length === undefined || !("value" in length) || !Number.isSafeInteger(length.value) || length.value < 0) return undefined;
+    const count = Math.min(length.value as number, maximum);
+    const values: unknown[] = [];
+    for (let index = 0; index < count; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (descriptor === undefined || !("value" in descriptor)) return undefined;
+      values.push(descriptor.value);
+    }
+    return { values, altered: length.value > maximum };
+  } catch {
+    return undefined;
+  }
+}
+
+function count(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+
+function boundedCount(value: unknown, maximum: number): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum ? value : undefined;
+}
+
+function expectedKeys(source: Record<string, unknown>, keys: readonly string[]): boolean {
+  const expected = new Set(keys);
+  return Object.keys(source).every((key) => expected.has(key));
+}
+
+function capsuleName(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  if (
+    value.length === 0 ||
+    value.length > 255 ||
+    value !== value.trim() ||
+    new TextEncoder().encode(value).byteLength > 255 ||
+    !value.endsWith(".patch") ||
+    /[/\\\p{Cc}\p{Cf}\p{Cs}]/u.test(value)
+  )
+    return undefined;
+  return value;
+}
+
+function cleanedError(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const error = value
+    .replaceAll(/[\p{Cc}\p{Cf}]+/gu, " ")
+    .trim()
+    .slice(0, maxErrorLength);
+  return error === "" ? null : error;
+}
+
+function canonicalTimestamp(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  try {
+    return new Date(value).toISOString() === value ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function activity(value: unknown): GitTimeCapsuleActivityView | null {
+  const source = ownDataRecord(value);
+  if (source === undefined || (source.action !== "capture" && source.action !== "restore")) return null;
+  if (source.status !== "completed" && source.status !== "failed" && source.status !== "cancelled") return null;
+  const at = canonicalTimestamp(source.at);
+  if (at === undefined) return null;
+  const name = source.name === undefined ? null : capsuleName(source.name);
+  if (source.name !== undefined && name === undefined) return null;
+  if (source.status === "completed" && name === null) return null;
+  const error = cleanedError(source.error);
+  const bytes = boundedCount(source.bytes, defaults.capsuleBytes);
+  const files = boundedCount(source.files, defaults.capsuleBytes);
+  if (source.status === "completed" && (bytes === undefined || bytes === 0 || files === undefined || files === 0)) return null;
+  if (source.action === "restore" && source.status === "completed" && source.restored !== true) return null;
+  if ((source.status === "failed" || source.status === "cancelled") && error === null) return null;
+  if (source.status === "completed" && error !== null) return null;
+  return {
+    action: source.action,
+    status: source.status,
+    at,
+    name: name ?? null,
+    bytes: bytes ?? 0,
+    files: files ?? 0,
+    error,
+  };
+}
+
+function activityContractValid(source: Record<string, unknown>): boolean {
+  if (source.status === "completed")
+    return expectedKeys(source, ["action", "status", "at", "name", "bytes", "files", ...(source.action === "restore" ? ["restored"] : [])]);
+  return expectedKeys(source, ["action", "status", "at", "error"]);
+}
+
+function capsule(value: unknown): { name: string; bytes: number } | undefined {
+  const source = ownDataRecord(value);
+  if (source === undefined) return undefined;
+  const name = capsuleName(source.name);
+  const bytes = boundedCount(source.bytes, defaults.capsuleBytes);
+  if (name === undefined || bytes === undefined || bytes === 0) return undefined;
+  return { name, bytes };
+}
+
+export function gitTimeCapsulePanelView(data: unknown): GitTimeCapsulePanelView {
+  const parsedSource = ownDataRecord(data);
+  const source = parsedSource ?? {};
+  const rawCapsules = ownDataArray(source.capsules, defaults.displayLimit);
+  const visible = rawCapsules?.values ?? [];
+  const parsedCapsules = visible.map((value) => {
+    const record = ownDataRecord(value);
+    return { value: capsule(value), contractValid: record !== undefined && expectedKeys(record, ["name", "bytes"]) };
+  });
+  const capsules = parsedCapsules.map((item) => item.value).filter((item): item is { name: string; bytes: number } => item !== undefined);
+  const rawInventory = ownDataRecord(source.inventory) ?? {};
+  const rawLimits = ownDataRecord(source.limits) ?? {};
+  const rawLatest = ownDataRecord(source.latest);
+  const latest = activity(source.latest);
+  const total = count(rawInventory.total, capsules.length);
+  const shown = count(rawInventory.shown, capsules.length);
+  const inventoryValid =
+    total >= capsules.length &&
+    total <= defaults.inventory &&
+    shown === capsules.length &&
+    rawInventory.truncated !== undefined &&
+    typeof rawInventory.truncated === "boolean" &&
+    rawInventory.displayLimit === defaults.displayLimit &&
+    expectedKeys(rawInventory, ["total", "shown", "truncated", "displayLimit"]);
+  const limitsValid =
+    rawLimits.capsuleBytes === defaults.capsuleBytes &&
+    rawLimits.inventory === defaults.inventory &&
+    rawLimits.directoryEntries === defaults.directoryEntries &&
+    expectedKeys(rawLimits, ["capsuleBytes", "inventory", "directoryEntries"]);
+  const parsedTimeout =
+    typeof source.timeoutMs === "number" && Number.isSafeInteger(source.timeoutMs) && source.timeoutMs >= 100 && source.timeoutMs <= 60_000
+      ? source.timeoutMs
+      : undefined;
+  const timeoutValid = parsedTimeout !== undefined;
+  const dataWasTruncated =
+    parsedSource === undefined ||
+    rawCapsules === undefined ||
+    rawCapsules.altered ||
+    parsedCapsules.some((item) => !item.contractValid) ||
+    capsules.length !== visible.length ||
+    (source.latest !== null && (rawLatest === undefined || latest === null || !activityContractValid(rawLatest))) ||
+    (typeof rawLatest?.error === "string" ? rawLatest.error !== latest?.error : false) ||
+    !inventoryValid ||
+    !limitsValid ||
+    !timeoutValid ||
+    !expectedKeys(source, ["latest", "capsules", "inventory", "timeoutMs", "limits"]);
+  return {
+    latest,
+    capsules,
+    inventory: {
+      total: inventoryValid ? total : Math.max(capsules.length, Math.min(defaults.inventory, total)),
+      shown: capsules.length,
+      truncated: rawInventory.truncated === true || dataWasTruncated,
+      displayLimit: defaults.displayLimit,
+    },
+    timeoutMs: parsedTimeout ?? defaults.timeoutMs,
+    limits: {
+      capsuleBytes: defaults.capsuleBytes,
+      inventory: defaults.inventory,
+      directoryEntries: defaults.directoryEntries,
+    },
+    truncated: dataWasTruncated,
+  };
+}

package/packages/client-web/src/graph-memory-view.ts

@@ -0,0 +1,91 @@
+type RelationKind = "USED_SKILL" | "SOLVED_BY" | "REQUIRES" | "PATCHES" | "CONFLICTS_WITH" | "RELATED_TO";
+
+const relationKinds = new Set<RelationKind>(["USED_SKILL", "SOLVED_BY", "REQUIRES", "PATCHES", "CONFLICTS_WITH", "RELATED_TO"]);
+const defaults = { nodes: 2_000, relations: 5_000, fileBytes: 4_194_304, searchResults: 50 };
+const recentLimit = 8;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function count(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+
+function positive(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+function text(value: unknown, maximum: number): string | undefined {
+  return typeof value === "string" && value.trim() !== "" ? value.trim().slice(0, maximum) : undefined;
+}
+
+function time(value: unknown): string | null {
+  return typeof value === "string" && Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : null;
+}
+
+function node(value: unknown) {
+  if (!isRecord(value) || typeof value.id !== "string" || (value.kind !== "task" && value.kind !== "skill" && value.kind !== "event")) return undefined;
+  const label = text(value.label, 160);
+  const summary = text(value.summary, 2_000);
+  if (label === undefined || summary === undefined) return undefined;
+  return {
+    id: value.id.slice(0, 160),
+    kind: value.kind,
+    label,
+    summary,
+    source: text(value.source, 512) ?? null,
+    updatedAt: time(value.updatedAt),
+  };
+}
+
+function relation(value: unknown) {
+  if (!isRecord(value) || typeof value.relation !== "string" || !relationKinds.has(value.relation as RelationKind)) return undefined;
+  const kind = value.relation as RelationKind;
+  const fromLabel = text(value.fromLabel ?? value.from, 160);
+  const toLabel = text(value.toLabel ?? value.to, 160);
+  if (fromLabel === undefined || toLabel === undefined) return undefined;
+  return { id: text(value.id, 160) ?? "relation", relation: kind, fromLabel, toLabel, createdAt: time(value.createdAt) };
+}
+
+export function graphMemoryPanelView(data: unknown) {
+  const source = isRecord(data) ? data : {};
+  const rawRecent = Array.isArray(source.recent) ? source.recent : [];
+  const visibleRecent = rawRecent.slice(0, recentLimit);
+  const recent = visibleRecent.map(node).filter((item): item is NonNullable<ReturnType<typeof node>> => item !== undefined);
+  const rawRelations = Array.isArray(source.recentRelations) ? source.recentRelations : [];
+  const visibleRelations = rawRelations.slice(0, recentLimit);
+  const recentRelations = visibleRelations.map(relation).filter((item): item is NonNullable<ReturnType<typeof relation>> => item !== undefined);
+  const rawKinds = isRecord(source.kinds) ? source.kinds : {};
+  const rawLimits = isRecord(source.limits) ? source.limits : {};
+  const rawSearch = isRecord(source.lastSearch) ? source.lastSearch : undefined;
+  const searchNodes = rawSearch !== undefined && Array.isArray(rawSearch.nodes) ? Math.min(rawSearch.nodes.length, defaults.searchResults) : 0;
+  const query = rawSearch === undefined ? undefined : text(rawSearch.query, 160);
+  const stringTruncated = visibleRecent.some(
+    (item) =>
+      isRecord(item) && [item.label, item.summary, item.source].some((value, index) => typeof value === "string" && value.length > [160, 2_000, 512][index]),
+  );
+  const truncated =
+    rawRecent.length > recentLimit ||
+    recent.length !== visibleRecent.length ||
+    rawRelations.length > recentLimit ||
+    recentRelations.length !== visibleRelations.length ||
+    stringTruncated ||
+    (rawSearch !== undefined && typeof rawSearch.query === "string" && rawSearch.query.length > 160) ||
+    (rawSearch !== undefined && Array.isArray(rawSearch.nodes) && rawSearch.nodes.length > defaults.searchResults);
+  return {
+    nodes: count(source.nodes, recent.length),
+    relations: count(source.relations, recentRelations.length),
+    kinds: { task: count(rawKinds.task, 0), skill: count(rawKinds.skill, 0), event: count(rawKinds.event, 0) },
+    recent,
+    recentRelations,
+    lastSearch: rawSearch === undefined || query === undefined ? null : { query, total: count(rawSearch.total, searchNodes), shown: searchNodes },
+    limits: {
+      nodes: positive(rawLimits.nodes, defaults.nodes),
+      relations: positive(rawLimits.relations, defaults.relations),
+      fileBytes: positive(rawLimits.fileBytes, defaults.fileBytes),
+      searchResults: positive(rawLimits.searchResults, defaults.searchResults),
+    },
+    truncated,
+  };
+}