npm - @plasm_lang/vercel-agent - Versions diffs - 0.3.63 - Mend

@plasm_lang/vercel-agent 0.3.63

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (121) hide show

package/README.md +235 -0
package/agent/.plasm/archives/runs/runs/pr2d5c4a99707b4c19b650553d50229a1d600d28e3d98a9c58f18e5026cecc86ca.json +64 -0
package/agent/.plasm/archives/runs/runs/pr2e0c0d8ad443c63c82da7435ee1a002b0e0fa718b640263c0a9d3e6e5944812f.json +64 -0
package/agent/.plasm/archives/runs/runs/pr2faedb8354f40ee6d828e3af07b421fda9ccda973a4f7347fce3639f03a0a869.json +64 -0
package/agent/.plasm/archives/runs/runs/pr586b47c55547b0702c572bce4255558b22dbe5e682d6359169577e0ea75fe98f.json +64 -0
package/agent/.plasm/archives/runs/runs/pr76212356445e3b00fcf256835aaec18bac68576324b90d0be92d47f0b4a862a7.json +56 -0
package/agent/.plasm/archives/runs/runs/pr9ec805d689e00db9270a9539858f2fb7216c24acbfea943d450e37b641149da1.json +64 -0
package/agent/.plasm/archives/runs/runs/prc3c0c4ba2e28fc94ed6d37b6796e277a7997d9cb3184640d14c35c98bc6d136f.json +64 -0
package/agent/.plasm/archives/runs/runs/prf04de32522f2fdcb17818907d91bccce7dcaecbd1259041cc448d447b6993244.json +64 -0
package/agent/.plasm/archives/traces/traces/local/00000000000000000000000000000000/records.ndjson +1 -0
package/agent/.plasm/archives/traces/traces/local/00000000000000000000000000000000/summary.json +13 -0
package/agent/.plasm/discovery/manifest.json +126 -0
package/agent/.plasm/sessions/TGlzdCBwcm9kdWN0cyBmcm9tIHRoZSBleGVjdXRlX3RpbnkgY2F0YWxvZw.json +44 -0
package/agent/.plasm/sessions/TGlzdCBwcm9kdWN0cyBmcm9tIHRoZSBleGVjdXRlX3RpbnkgY2F0YWxvZw.teaching.tsv +23 -0
package/agent/.plasm/sessions/bGlzdCBleGVjdXRlX3RpbnkgcHJvZHVjdHM.json +151 -0
package/agent/.plasm/sessions/bGlzdCBleGVjdXRlX3RpbnkgcHJvZHVjdHM.teaching.tsv +131 -0
package/agent/.plasm/sessions/bGlzdCBleGVjdXRlX3RpbnkgcHJvZHVjdHMgYXN5bmMgdHJhbnNwb3J0.json +44 -0
package/agent/.plasm/sessions/bGlzdCBleGVjdXRlX3RpbnkgcHJvZHVjdHMgYXN5bmMgdHJhbnNwb3J0.teaching.tsv +23 -0
package/agent/.plasm/stubs/.gitkeep +0 -0
package/agent/.plasm/stubs/execute_tiny.ts +107 -0
package/agent/agent.ts +52 -0
package/agent/catalogs/README.md +15 -0
package/agent/channels/.gitkeep +0 -0
package/agent/channels/execute-tiny-webhook.ts +59 -0
package/agent/channels/health.ts +16 -0
package/agent/hooks/.gitkeep +0 -0
package/agent/hooks/trace-log.ts +10 -0
package/agent/instructions.md +25 -0
package/agent/schedules/.gitkeep +0 -0
package/agent/schedules/ping.ts +13 -0
package/agent/skills/.gitkeep +0 -0
package/agent/skills/plasm-authoring.md +8 -0
package/agent/subagents/.gitkeep +0 -0
package/agent/subagents/tiny/agent.ts +28 -0
package/bin/plasm-agent.mjs +18 -0
package/package.json +77 -0
package/scripts/plasm-node.mjs +19 -0
package/scripts/resolve-ts-extension.mjs +18 -0
package/src/archive/adapters.ts +27 -0
package/src/archive/index.ts +99 -0
package/src/archive/local-run-archive.ts +90 -0
package/src/archive/local-trace-archive.ts +91 -0
package/src/archive/paths.ts +15 -0
package/src/archive/postgres-kv-adapter.ts +72 -0
package/src/archive/prod-archive-store.ts +143 -0
package/src/archive/resolve-backend.ts +60 -0
package/src/archive/run-id.ts +23 -0
package/src/archive/types.ts +75 -0
package/src/archive/vercel-blob-adapter.ts +21 -0
package/src/archive/vercel-kv-adapter.ts +24 -0
package/src/authoring/channel-dispatch.ts +44 -0
package/src/authoring/context.ts +34 -0
package/src/authoring/define-channel.ts +83 -0
package/src/authoring/define-hook.ts +51 -0
package/src/authoring/define-schedule.ts +64 -0
package/src/authoring/define-skill.ts +38 -0
package/src/authoring/hook-runner.ts +18 -0
package/src/authoring/schedule-manager.ts +118 -0
package/src/authoring/slot-loader.ts +253 -0
package/src/authoring/subagent-loader.ts +121 -0
package/src/catalog/loader.ts +71 -0
package/src/cli/build.ts +54 -0
package/src/cli/dev.ts +60 -0
package/src/cli/info.ts +12 -0
package/src/cli/init.ts +372 -0
package/src/cli/link.ts +68 -0
package/src/cli/project-root.ts +57 -0
package/src/define-agent.ts +150 -0
package/src/dev/client/ansi.ts +36 -0
package/src/dev/client/http-session.ts +180 -0
package/src/dev/client/repl.ts +92 -0
package/src/dev/client/slash.ts +119 -0
package/src/dev/dev-session.ts +153 -0
package/src/dev/http.ts +29 -0
package/src/dev/server.ts +147 -0
package/src/dev/session-routes.ts +185 -0
package/src/discovery/project-walker.ts +272 -0
package/src/engine/connect-auth.ts +135 -0
package/src/engine/create-host-transport.ts +7 -0
package/src/engine/fixture-mock-transport.ts +54 -0
package/src/engine/host-transport-bridge.ts +32 -0
package/src/engine/host-transport.ts +84 -0
package/src/engine/napi-binding.ts +265 -0
package/src/evals/define-eval.ts +56 -0
package/src/evals/run-eval.ts +136 -0
package/src/gateway-model.ts +43 -0
package/src/index.ts +296 -0
package/src/instrumentation.ts +56 -0
package/src/load-env.ts +63 -0
package/src/operator/routes.ts +287 -0
package/src/operator/types.ts +63 -0
package/src/operator/ui-shell.ts +134 -0
package/src/project-info.ts +229 -0
package/src/runtime/agent-runtime.ts +469 -0
package/src/runtime/compaction.ts +81 -0
package/src/runtime/logical-session.ts +72 -0
package/src/runtime/plasm-agent.ts +199 -0
package/src/server/plasm-handler.ts +331 -0
package/src/session-state.ts +135 -0
package/src/state/define-state.ts +57 -0
package/src/state/fs-state-adapter.ts +72 -0
package/src/state/kv-state-adapter.ts +62 -0
package/src/state/postgres-state-adapter.ts +116 -0
package/src/stubs/capability-invoke-shape.ts +135 -0
package/src/stubs/catalog-client.ts +170 -0
package/src/stubs/catalog-hash.ts +11 -0
package/src/stubs/catalog-introspection.ts +121 -0
package/src/stubs/cgs-ts-types.ts +164 -0
package/src/stubs/domain-parser.ts +203 -0
package/src/stubs/generator.ts +390 -0
package/src/stubs/input-type-to-ts.ts +233 -0
package/src/stubs/plasm-value-emitter.ts +162 -0
package/src/stubs/program-builder.ts +82 -0
package/src/stubs/stub-symbols.ts +89 -0
package/src/symbol-registry.ts +74 -0
package/src/telemetry/plasm-spans.ts +83 -0
package/src/tools/descriptions.ts +94 -0
package/src/tools/format.ts +29 -0
package/src/tools/harness-tools.ts +65 -0
package/src/tools/plasm-tools.ts +104 -0
package/src/workflow/world-bootstrap.ts +52 -0

package/src/operator/types.ts ADDED Viewed

@@ -0,0 +1,63 @@
+export interface OperatorStubFreshness {
+  stubPath: string;
+  liveCatalogCgsHash: string;
+  generatedCatalogCgsHash: string | null;
+  fresh: boolean;
+  lastBuiltAt: string | null;
+  validationErrors: string[];
+}
+export interface OperatorCatalogEntry {
+  entryId: string;
+  label: string;
+  rootDir: string;
+  catalogCgsHash: string;
+  authScheme?: string;
+  entityCount: number;
+  capabilityCount: number;
+  stub: OperatorStubFreshness;
+}
+export interface OperatorCatalogsResponse {
+  catalogs: OperatorCatalogEntry[];
+  generatedAt: string;
+}
+export interface OperatorSessionEntry {
+  intent: string;
+  logicalSessionRef: string;
+  logicalSessionId: string;
+  waveCount: number;
+  seedCount: number;
+  planCommitCount: number;
+  updatedAt: string;
+}
+export interface OperatorSessionsResponse {
+  sessions: OperatorSessionEntry[];
+}
+export interface OperatorPlanCommit {
+  intent: string;
+  logicalSessionRef: string;
+  ref: string;
+  program: string;
+  at: string;
+}
+export interface OperatorPlansResponse {
+  plans: OperatorPlanCommit[];
+}
+export interface OperatorOpsResponse {
+  nativeEngineAvailable: boolean;
+  engineMode: "napi" | "stub";
+  agentRoot: string;
+  catalogCount: number;
+  sessionCount: number;
+  planCommitCount: number;
+}
+export interface OperatorHealthResponse {
+  status: string;
+}

package/src/operator/ui-shell.ts ADDED Viewed

@@ -0,0 +1,134 @@
+/** Read-only operator shell — fetches `/operator/*` BFF JSON. */
+export function renderOperatorShell(basePath = "/operator"): string {
+  const base = basePath.replace(/\/$/, "");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Plasm Operator</title>
+  <style>
+    :root { color-scheme: dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+    body { margin: 0; background: #0b0d10; color: #e8eaed; }
+    header { padding: 1rem 1.25rem; border-bottom: 1px solid #22262d; display: flex; gap: 1rem; align-items: center; }
+    header h1 { font-size: 1rem; font-weight: 600; margin: 0; letter-spacing: 0.02em; }
+    nav { display: flex; gap: 0.5rem; flex-wrap: wrap; }
+    nav button { background: #151922; border: 1px solid #2a3140; color: #c9d1d9; padding: 0.35rem 0.7rem; border-radius: 6px; cursor: pointer; }
+    nav button.active { background: #1f6feb33; border-color: #388bfd; color: #fff; }
+    main { padding: 1rem 1.25rem 2rem; }
+    .meta { color: #8b949e; font-size: 0.85rem; margin-bottom: 1rem; }
+    table { width: 100%; border-collapse: collapse; font-size: 0.9rem; }
+    th, td { text-align: left; padding: 0.5rem 0.65rem; border-bottom: 1px solid #22262d; vertical-align: top; }
+    th { color: #8b949e; font-weight: 500; }
+    code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.82rem; }
+    .badge { display: inline-block; padding: 0.1rem 0.45rem; border-radius: 999px; font-size: 0.75rem; }
+    .ok { background: #23863633; color: #3fb950; }
+    .warn { background: #9e6a0333; color: #d29922; }
+    pre { background: #11151c; border: 1px solid #22262d; padding: 0.75rem; border-radius: 8px; overflow: auto; font-size: 0.8rem; }
+    .error { color: #f85149; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Plasm Operator</h1>
+    <nav id="nav"></nav>
+  </header>
+  <main>
+    <div class="meta" id="meta"></div>
+    <div id="content"></div>
+  </main>
+  <script>
+    const BASE = ${JSON.stringify(base)};
+    const PANES = [
+      { id: "ops", label: "Ops", path: "/ops" },
+      { id: "catalogs", label: "Catalogs", path: "/catalogs" },
+      { id: "sessions", label: "Sessions", path: "/sessions" },
+      { id: "plans", label: "Plans", path: "/plans" },
+      { id: "runs", label: "Runs", path: "/runs" },
+      { id: "traces", label: "Traces", path: "/traces" },
+      { id: "archives", label: "Archives", path: "/archives" },
+    ];
+    let active = "catalogs";
+    const nav = document.getElementById("nav");
+    const meta = document.getElementById("meta");
+    const content = document.getElementById("content");
+    function setActive(id) {
+      active = id;
+      for (const btn of nav.querySelectorAll("button")) {
+        btn.classList.toggle("active", btn.dataset.id === id);
+      }
+      void loadPane(id);
+    }
+    for (const pane of PANES) {
+      const btn = document.createElement("button");
+      btn.textContent = pane.label;
+      btn.dataset.id = pane.id;
+      btn.onclick = () => setActive(pane.id);
+      nav.appendChild(btn);
+    }
+    async function fetchJson(path) {
+      const res = await fetch(BASE + path);
+      if (!res.ok) throw new Error(res.status + " " + path);
+      return res.json();
+    }
+    function esc(s) {
+      return String(s).replace(/[&<>"]/g, (c) => ({ "&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;" }[c]));
+    }
+    function renderTable(rows, columns) {
+      if (!rows.length) return "<p>No rows.</p>";
+      const head = columns.map((c) => "<th>" + esc(c.label) + "</th>").join("");
+      const body = rows.map((row) =>
+        "<tr>" + columns.map((c) => "<td>" + esc(c.render(row)) + "</td>").join("") + "</tr>"
+      ).join("");
+      return "<table><thead><tr>" + head + "</tr></thead><tbody>" + body + "</tbody></table>";
+    }
+    async function loadPane(id) {
+      meta.textContent = "Loading…";
+      content.innerHTML = "";
+      try {
+        const pane = PANES.find((p) => p.id === id);
+        const data = await fetchJson(pane.path);
+        meta.textContent = "Updated " + new Date().toLocaleString();
+        if (id === "ops") {
+          content.innerHTML = "<pre>" + esc(JSON.stringify(data, null, 2)) + "</pre>";
+          return;
+        }
+        if (id === "catalogs") {
+          content.innerHTML = renderTable(data.catalogs || [], [
+            { label: "entry", render: (r) => r.entryId },
+            { label: "hash", render: (r) => (r.catalogCgsHash || "").slice(0, 12) + "…" },
+            { label: "stub", render: (r) => r.stub?.fresh ? "fresh" : "stale" },
+            { label: "caps", render: (r) => String(r.capabilityCount ?? "") },
+          ]);
+          return;
+        }
+        if (id === "sessions") {
+          content.innerHTML = renderTable(data.sessions || [], [
+            { label: "intent", render: (r) => r.intent },
+            { label: "ref", render: (r) => r.logicalSessionRef },
+            { label: "plans", render: (r) => String(r.planCommitCount ?? 0) },
+          ]);
+          return;
+        }
+        if (id === "plans") {
+          content.innerHTML = renderTable(data.plans || [], [
+            { label: "pc", render: (r) => r.ref },
+            { label: "intent", render: (r) => r.intent },
+            { label: "program", render: (r) => (r.program || "").slice(0, 48) },
+          ]);
+          return;
+        }
+        if (id === "runs" || id === "traces" || id === "archives") {
+          content.innerHTML = "<pre>" + esc(JSON.stringify(data, null, 2)) + "</pre>";
+          return;
+        }
+        content.innerHTML = "<pre>" + esc(JSON.stringify(data, null, 2)) + "</pre>";
+      } catch (err) {
+        meta.innerHTML = '<span class="error">' + esc(String(err)) + "</span>";
+      }
+    }
+    setActive("catalogs");
+  </script>
+</body>
+</html>`;
+}

package/src/project-info.ts ADDED Viewed

@@ -0,0 +1,229 @@
+import path from "node:path";
+import { listChannelRoutes } from "./authoring/channel-dispatch.js";
+import { loadAuthoredSlots, summarizeLoadedSlots } from "./authoring/slot-loader.js";
+import { loadSubagents, summarizeSubagents } from "./authoring/subagent-loader.js";
+import type { AgentDefinition } from "./define-agent.js";
+import type { ProjectDiscovery } from "./discovery/project-walker.js";
+import { walkAgentProject } from "./discovery/project-walker.js";
+import { isNativeEngineAvailable } from "./engine/napi-binding.js";
+import { exportScheduleCronManifest } from "./authoring/schedule-manager.js";
+import { isGatewayConfigured } from "./gateway-model.js";
+import type { LoadedProjectSlots } from "./authoring/slot-loader.js";
+import { resolveCatalogLiveHash } from "./stubs/catalog-hash.js";
+import { stubFreshness } from "./stubs/generator.js";
+export const PLASM_LANGUAGE_TOOLS = [
+  "discover_capabilities",
+  "plasm_context",
+  "plasm",
+  "plasm_run",
+] as const;
+export const FRAMEWORK_NAME = "@plasm_lang/vercel-agent";
+export const FRAMEWORK_VERSION = "0.0.1";
+export interface CatalogInfoEntry {
+  name: string;
+  entryId?: string;
+  stubPath: string;
+  stubFresh?: Awaited<ReturnType<typeof stubFreshness>>;
+}
+export interface ProjectInfoRoutes {
+  health: string;
+  info: string;
+  session: string;
+  sessionContinue: string;
+  sessionStream: string;
+  channels: Array<{ method: string; path: string }>;
+  scheduleCrons: string[];
+  operator: string;
+}
+export interface ProjectInfoPayload {
+  status: "ok" | "degraded";
+  framework: string;
+  version: string;
+  projectRoot: string;
+  agentRoot: string;
+  packageName?: string;
+  engine: {
+    native: boolean;
+    mode: "napi" | "stub";
+  };
+  gateway: {
+    configured: boolean;
+  };
+  discovery: ProjectDiscovery;
+  loadedSlots: ReturnType<typeof summarizeLoadedSlots> & {
+    subagents: ReturnType<typeof summarizeSubagents>;
+  };
+  catalogs: CatalogInfoEntry[];
+  diagnostics: Array<{
+    level: string;
+    slot: string;
+    path: string;
+    message: string;
+  }>;
+  languageTools: readonly string[];
+  /** Present on dev-server `/plasm/v1/info` only. */
+  dev?: {
+    model: AgentDefinition["model"];
+    compaction: AgentDefinition["compaction"] | null;
+    modelOptions: AgentDefinition["modelOptions"] | null;
+    build: AgentDefinition["build"] | null;
+    experimental: AgentDefinition["experimental"] | null;
+    scheduleCrons: ReturnType<typeof exportScheduleCronManifest> | null;
+    sessions: { active: number };
+    routes: ProjectInfoRoutes;
+  };
+}
+export interface CollectProjectInfoOptions {
+  projectRoot: string;
+  agentRoot: string;
+  packageName?: string;
+  cached?: {
+    discovery: ProjectDiscovery;
+    loadedSlots: LoadedProjectSlots;
+    subagents: ReturnType<typeof summarizeSubagents>;
+  };
+  dev?: {
+    definition: AgentDefinition;
+    sessionCount: number;
+  };
+}
+async function catalogEntries(
+  project: { projectRoot: string; agentRoot: string },
+  discovery: ProjectDiscovery,
+): Promise<CatalogInfoEntry[]> {
+  const catalogs: CatalogInfoEntry[] = [];
+  for (const catalog of discovery.catalogs) {
+    const entryId = catalog.entryId ?? catalog.name;
+    const stubPath = path.join(project.agentRoot, ".plasm", "stubs", `${entryId}.ts`);
+    let stubFresh: Awaited<ReturnType<typeof stubFreshness>> | undefined;
+    try {
+      const liveHash = await resolveCatalogLiveHash(catalog.path);
+      stubFresh = await stubFreshness(liveHash, stubPath);
+    } catch {
+      stubFresh = undefined;
+    }
+    catalogs.push({
+      name: catalog.name,
+      entryId: catalog.entryId,
+      stubPath: path.relative(project.projectRoot, stubPath),
+      stubFresh,
+    });
+  }
+  return catalogs;
+}
+export async function collectProjectInfo(
+  options: CollectProjectInfoOptions,
+): Promise<ProjectInfoPayload> {
+  const { projectRoot, agentRoot, packageName, cached, dev } = options;
+  let discovery: ProjectDiscovery;
+  let loadedSlots: LoadedProjectSlots;
+  let subagentSummary: ReturnType<typeof summarizeSubagents>;
+  let subDiagnostics: Array<{ level: string; slot: string; path: string; message: string }>;
+  if (cached) {
+    discovery = cached.discovery;
+    loadedSlots = cached.loadedSlots;
+    subagentSummary = cached.subagents;
+    subDiagnostics = [];
+  } else {
+    discovery = await walkAgentProject(agentRoot);
+    loadedSlots = await loadAuthoredSlots({ discovery });
+    const loaded = await loadSubagents({ discovery, parentSlots: loadedSlots });
+    subagentSummary = summarizeSubagents(loaded.subagents, agentRoot);
+    subDiagnostics = loaded.diagnostics;
+  }
+  const diagnostics = [
+    ...loadedSlots.diagnostics,
+    ...subDiagnostics,
+    ...discovery.diagnostics,
+  ];
+  const catalogs = await catalogEntries({ projectRoot, agentRoot }, discovery);
+  const hasErrors = diagnostics.some((d) => d.level === "error");
+  const native = isNativeEngineAvailable();
+  const payload: ProjectInfoPayload = {
+    status: hasErrors ? "degraded" : "ok",
+    framework: FRAMEWORK_NAME,
+    version: FRAMEWORK_VERSION,
+    projectRoot,
+    agentRoot,
+    packageName,
+    engine: {
+      native,
+      mode: native ? "napi" : "stub",
+    },
+    gateway: { configured: isGatewayConfigured() },
+    discovery,
+    loadedSlots: {
+      ...summarizeLoadedSlots(loadedSlots, agentRoot),
+      subagents: subagentSummary,
+    },
+    catalogs,
+    diagnostics,
+    languageTools: PLASM_LANGUAGE_TOOLS,
+  };
+  if (dev) {
+    const scheduleCrons = exportScheduleCronManifest(loadedSlots.schedules);
+    payload.dev = {
+      model: dev.definition.model,
+      compaction: dev.definition.compaction ?? null,
+      modelOptions: dev.definition.modelOptions ?? null,
+      build: dev.definition.build ?? null,
+      experimental: dev.definition.experimental ?? null,
+      scheduleCrons,
+      sessions: { active: dev.sessionCount },
+      routes: {
+        health: "GET /plasm/v1/health",
+        info: "GET /plasm/v1/info",
+        session: "POST /plasm/v1/session",
+        sessionContinue: "POST /plasm/v1/session/:sessionId",
+        sessionStream: "GET /plasm/v1/session/:id/stream",
+        channels: listChannelRoutes(loadedSlots.channels),
+        scheduleCrons: scheduleCrons.crons.map((c) => `GET ${c.path}`),
+        operator: "GET /operator",
+      },
+    };
+  }
+  return payload;
+}
+export function formatPlasmInfoHuman(info: ProjectInfoPayload): string {
+  const lines: string[] = [];
+  lines.push(`${info.framework}  status=${info.status}`);
+  lines.push(`project: ${info.projectRoot}`);
+  lines.push(`agent:   ${info.agentRoot}`);
+  lines.push(`engine:  ${info.engine.mode}${info.engine.native ? " (native)" : " (fallback)"}`);
+  lines.push(
+    `gateway: ${info.gateway.configured ? "configured" : "missing — set AI_GATEWAY_API_KEY or run plasm-agent link"}`,
+  );
+  lines.push("");
+  lines.push(`catalogs (${info.discovery.catalogs.length})`);
+  for (const c of info.catalogs) {
+    const fresh = c.stubFresh?.fresh ? "fresh" : c.stubFresh ? "stale" : "missing";
+    lines.push(`  - ${c.name} entry_id=${c.entryId ?? "?"} stub=${fresh}`);
+  }
+  lines.push(`channels: ${info.discovery.channels.length}  schedules: ${info.discovery.schedules.length}`);
+  lines.push(`skills: ${info.discovery.skills.length}  hooks: ${info.discovery.hooks.length}`);
+  lines.push(`subagents: ${info.loadedSlots.subagents.length}`);
+  if (info.diagnostics.length) {
+    lines.push("");
+    lines.push("diagnostics:");
+    for (const d of info.diagnostics) {
+      lines.push(`  [${d.level}] ${d.slot}: ${d.message} (${d.path})`);
+    }
+  }
+  return lines.join("\n");
+}