@nanobpm/agentic 0.1.0

package/dist/vocab/resolver.js

@@ -0,0 +1,149 @@
+/**
+ * The vocab resolver — S3's REGISTER→SERVE core.
+ *
+ * The versioned vocab artifact (S0 {@link VocabDocument}) is the ONE
+ * capability→token map; no map is ever baked into a worker. This resolver reads
+ * it and, given a declared enrolment capability, produces the deterministic
+ * SERVE token set the worker is entitled to fill — the `serve` reply to a
+ * `register` handshake.
+ *
+ * Token derivation walks `networks → subnetworks → roles`, joining segments into
+ * a routing token `network[.subnetwork…].role` (never a seat, never a
+ * capability). One exception encodes a BARE (network-less) role such as
+ * `decide`: a top-level role whose name equals its containing network and that
+ * has no subnetworks collapses to the single-segment token `role` — the only way
+ * the S0 network→role schema can express the bare tokens the grammar allows. So
+ * `networks.decide.roles.decide` serves the token `decide`.
+ */
+import { formatToken, parseToken, validateVocabDocument } from "../protocol/index.js";
+import { parseRequiresList, RequiresParseError, satisfiesRequires } from "./requires.js";
+/** Raised when the document handed to the resolver is not a valid vocab artifact. */
+export class VocabDocumentError extends Error {
+    errors;
+    constructor(errors) {
+        super(`invalid vocab document: ${errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+        this.name = "VocabDocumentError";
+        this.errors = errors;
+    }
+}
+/**
+ * Parse a role's `requires` gate, tagging any failure with the routing token so a
+ * malformed predicate names the role that carries it (e.g. when merging author
+ * extensions) instead of surfacing a bare, context-free {@link RequiresParseError}.
+ */
+function parseRequires(token, requires) {
+    try {
+        return parseRequiresList(requires);
+    }
+    catch (error) {
+        if (error instanceof RequiresParseError) {
+            throw new VocabDocumentError([{ path: token, message: error.message }]);
+        }
+        throw error;
+    }
+}
+function deriveToken(network, subnetworks, role) {
+    // A self-named top-level role denotes a rootless (network-less) role: the only
+    // way the network→role schema can express a single-segment token like `decide`.
+    if (subnetworks.length === 0 && network === role) {
+        return formatToken({ subnetworks: [], role });
+    }
+    return formatToken({ network, subnetworks: [...subnetworks], role });
+}
+function normaliseSeats(seats) {
+    if (seats === undefined)
+        return 1;
+    if (typeof seats === "number")
+        return seats;
+    return [...seats];
+}
+export class VocabResolver {
+    #roles;
+    #byToken;
+    #version;
+    /**
+     * Build a resolver over a vocab document. The document is re-validated against
+     * the S0 schema and every role's `requires` gate is parsed up front, so a
+     * malformed gate fails loudly at construction rather than silently at match.
+     */
+    constructor(doc) {
+        const validation = validateVocabDocument(doc);
+        if (!validation.ok) {
+            throw new VocabDocumentError(validation.errors.map((e) => ({ path: e.path, message: e.message })));
+        }
+        const document = validation.value;
+        this.#version = document.version;
+        const roles = [];
+        const collect = (network, subnetworks, node) => {
+            if (node.roles !== undefined) {
+                for (const [roleName, role] of Object.entries(node.roles)) {
+                    const token = deriveToken(network, subnetworks, roleName);
+                    roles.push({
+                        token,
+                        ...(subnetworks.length === 0 && network === roleName ? {} : { network }),
+                        subnetworks: [...subnetworks],
+                        role: roleName,
+                        ...(role.weight === undefined ? {} : { weight: role.weight }),
+                        seats: normaliseSeats(role.seats),
+                        seatsDistinctFamily: role.seatsDistinctFamily === true,
+                        requires: parseRequires(token, role.requires),
+                    });
+                }
+            }
+            if (node.subnetworks !== undefined) {
+                for (const [subName, sub] of Object.entries(node.subnetworks)) {
+                    collect(network, [...subnetworks, subName], sub);
+                }
+            }
+        };
+        for (const [networkName, network] of Object.entries(document.networks)) {
+            collect(networkName, [], network);
+        }
+        // Deterministic order + a token→role index; a duplicate token is a modelling
+        // error (two roles cannot claim one routing token).
+        roles.sort((a, b) => (a.token < b.token ? -1 : a.token > b.token ? 1 : 0));
+        const byToken = new Map();
+        for (const role of roles) {
+            if (byToken.has(role.token)) {
+                throw new VocabDocumentError([{ path: role.token, message: `duplicate routing token: ${role.token}` }]);
+            }
+            byToken.set(role.token, role);
+        }
+        this.#roles = roles;
+        this.#byToken = byToken;
+    }
+    /** The vocab artifact version this resolver was built from. */
+    get version() {
+        return this.#version;
+    }
+    /** Every role in the vocab, sorted by token. */
+    roles() {
+        return this.#roles;
+    }
+    /** Every leaf token in the vocab, sorted. */
+    tokens() {
+        return this.#roles.map((role) => role.token);
+    }
+    /** Look up a role by its routing token. */
+    roleForToken(token) {
+        // Normalise through the grammar so `planning.planner` and any equivalent
+        // spelling resolve identically.
+        let key;
+        try {
+            key = formatToken(parseToken(token));
+        }
+        catch {
+            return undefined;
+        }
+        return this.#byToken.get(key);
+    }
+    /**
+     * Resolve a declared enrolment capability to its SERVE token set: every role
+     * whose `requires` gate the capability satisfies. The token list is sorted and
+     * de-duplicated, so the same capability always yields the same SERVE.
+     */
+    resolve(capability) {
+        const matched = this.#roles.filter((role) => satisfiesRequires(role.requires, capability));
+        return { tokens: matched.map((role) => role.token), roles: matched };
+    }
+}

package/dist/vocab/serve.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The REGISTER→SERVE handshake mechanics.
+ *
+ * S2 owns the `register` family on the hub (one family, one owning module — this
+ * slice does NOT claim it). S3 supplies the other half of the handshake: given a
+ * declared enrolment capability, resolve it (via {@link VocabResolver}) to its
+ * SERVE token set and emit a `serve` frame back to the worker.
+ *
+ * The `serve` reply rides the CONTROL lane — it is a control/facts message, so a
+ * bulk relay storm can never delay a worker learning which tokens it may serve
+ * (S0 invariant 5). The composition root wires this after presence register
+ * (e.g. from S2's register path or an app-level adapter); keeping it a pure,
+ * connection-agnostic helper is what lets it compose without editing S2.
+ */
+import type { Capability, Frame, ServePayload } from "../protocol/index.ts";
+import type { Resolution, VocabResolver } from "./resolver.ts";
+/** The minimal per-connection sink a serve reply needs — S1's `HubConnection.send`. */
+export interface ServeSink {
+    send(frame: Frame): void;
+}
+/** Build the `serve` payload for an instance and its resolved token set. */
+export declare function buildServePayload(instance: string, tokens: readonly string[]): ServePayload;
+/**
+ * Build the `serve` frame carrying an instance's SERVE token set. Rides the
+ * control lane; `seq` defaults to 0 (the caller owns per-connection sequencing).
+ * The built payload is validated against the S0 `serve` contract, so a
+ * malformed token set fails loudly here rather than on the wire. `seq` is
+ * likewise checked against the wire's uint32 bound (the same {@link MAX_SEQ}
+ * `encodeFrame` enforces) so a bad sequence number fails here — at construction
+ * — rather than later during encoding.
+ */
+export declare function buildServeFrame(instance: string, tokens: readonly string[], seq?: number): Frame;
+/**
+ * Resolve `capability` and send the resulting `serve` frame to `sink`. Returns
+ * the {@link Resolution} so the caller can also record the assigned tokens (e.g.
+ * for demand×supply or diversity correlation). This is the server side of
+ * `REGISTER {capability}` → `SERVE [leaf tokens]`.
+ */
+export declare function serveCapability(resolver: VocabResolver, sink: ServeSink, instance: string, capability: Capability, seq?: number): Resolution;

package/dist/vocab/serve.js

@@ -0,0 +1,36 @@
+import { MAX_SEQ, validatePayload } from "../protocol/index.js";
+/** Build the `serve` payload for an instance and its resolved token set. */
+export function buildServePayload(instance, tokens) {
+    return { instance, tokens: [...tokens] };
+}
+/**
+ * Build the `serve` frame carrying an instance's SERVE token set. Rides the
+ * control lane; `seq` defaults to 0 (the caller owns per-connection sequencing).
+ * The built payload is validated against the S0 `serve` contract, so a
+ * malformed token set fails loudly here rather than on the wire. `seq` is
+ * likewise checked against the wire's uint32 bound (the same {@link MAX_SEQ}
+ * `encodeFrame` enforces) so a bad sequence number fails here — at construction
+ * — rather than later during encoding.
+ */
+export function buildServeFrame(instance, tokens, seq = 0) {
+    if (!Number.isInteger(seq) || seq < 0 || seq > MAX_SEQ) {
+        throw new Error(`refusing to build serve frame with invalid seq (must be a uint32): ${String(seq)}`);
+    }
+    const payload = buildServePayload(instance, tokens);
+    const check = validatePayload("serve", payload);
+    if (!check.ok) {
+        throw new Error(`refusing to build invalid serve frame: ${check.errors.map((e) => e.message).join("; ")}`);
+    }
+    return { lane: "control", family: "serve", seq, payload };
+}
+/**
+ * Resolve `capability` and send the resulting `serve` frame to `sink`. Returns
+ * the {@link Resolution} so the caller can also record the assigned tokens (e.g.
+ * for demand×supply or diversity correlation). This is the server side of
+ * `REGISTER {capability}` → `SERVE [leaf tokens]`.
+ */
+export function serveCapability(resolver, sink, instance, capability, seq = 0) {
+    const resolution = resolver.resolve(capability);
+    sink.send(buildServeFrame(instance, resolution.tokens, seq));
+    return resolution;
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@nanobpm/agentic",
+  "version": "0.1.0",
+  "description": "The Nano agentic protocol (ADR 0056): one app-tier channel carrying agent presence/registry, demand×supply, a shared blackboard and live terminal relay — with the wire contract, channel/hub, family modules and the operator cockpit, as subpath exports.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "keywords": [
+    "nanobpm",
+    "agentic",
+    "protocol",
+    "channel",
+    "presence",
+    "demand",
+    "relay",
+    "transcript",
+    "blackboard",
+    "cockpit",
+    "conformance"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nanobpm/nano-ide.git",
+    "directory": "packages/agentic"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./source": "./src/index.ts",
+    "./protocol": {
+      "types": "./dist/protocol/index.d.ts",
+      "default": "./dist/protocol/index.js"
+    },
+    "./source/protocol": "./src/protocol/index.ts",
+    "./channel": {
+      "types": "./dist/channel/index.d.ts",
+      "default": "./dist/channel/index.js"
+    },
+    "./source/channel": "./src/channel/index.ts",
+    "./presence": {
+      "types": "./dist/presence/index.d.ts",
+      "default": "./dist/presence/index.js"
+    },
+    "./source/presence": "./src/presence/index.ts",
+    "./vocab": {
+      "types": "./dist/vocab/index.d.ts",
+      "default": "./dist/vocab/index.js"
+    },
+    "./source/vocab": "./src/vocab/index.ts",
+    "./demand": {
+      "types": "./dist/demand/index.d.ts",
+      "default": "./dist/demand/index.js"
+    },
+    "./source/demand": "./src/demand/index.ts",
+    "./relay": {
+      "types": "./dist/relay/index.d.ts",
+      "default": "./dist/relay/index.js"
+    },
+    "./source/relay": "./src/relay/index.ts",
+    "./transcript": {
+      "types": "./dist/transcript/index.d.ts",
+      "default": "./dist/transcript/index.js"
+    },
+    "./source/transcript": "./src/transcript/index.ts",
+    "./blackboard": {
+      "types": "./dist/blackboard/index.d.ts",
+      "default": "./dist/blackboard/index.js"
+    },
+    "./source/blackboard": "./src/blackboard/index.ts",
+    "./cockpit": {
+      "types": "./dist/cockpit/index.d.ts",
+      "default": "./dist/cockpit/index.js"
+    },
+    "./source/cockpit": "./src/cockpit/index.ts",
+    "./protocol/conformance": {
+      "types": "./dist/protocol/conformance/index.d.ts",
+      "default": "./dist/protocol/conformance/index.js"
+    },
+    "./source/protocol/conformance": "./src/protocol/conformance/index.ts"
+  },
+  "files": [
+    "dist",
+    "src",
+    "page",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
+    "test:conformance": "node --test --experimental-strip-types \"src/protocol/conformance/corpus.test.ts\""
+  },
+  "dependencies": {
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.9.3"
+  }
+}

package/page/cockpit.css

@@ -0,0 +1,114 @@
+/* The cockpit stylesheet — a compact, phone-friendly dark cockpit shared by the
+   standalone shell and the console App-View embed, so the two render identically.
+   The three-state SLO lights key off `data-status` (green | amber | red). */
+
+:root {
+  --cockpit-bg: #0b0f14;
+  --cockpit-panel: #131a22;
+  --cockpit-edge: #223041;
+  --cockpit-text: #e6edf3;
+  --cockpit-muted: #8b98a5;
+  --cockpit-green: #2ea043;
+  --cockpit-amber: #d29922;
+  --cockpit-red: #f85149;
+}
+
+.cockpit-shell {
+  color: var(--cockpit-text);
+  background: var(--cockpit-bg);
+  font: 14px/1.4 ui-sans-serif, system-ui, sans-serif;
+  display: grid;
+  gap: 12px;
+  padding: 12px;
+  min-height: 100%;
+}
+
+.cockpit-header {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+}
+
+.cockpit-title {
+  font-size: 16px;
+  margin: 0;
+}
+
+.cockpit-status {
+  padding: 2px 8px;
+  border-radius: 999px;
+  border: 1px solid var(--cockpit-edge);
+  font-variant: small-caps;
+}
+
+.cockpit-dot {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  margin-right: 6px;
+  background: var(--cockpit-muted);
+  vertical-align: middle;
+}
+
+[data-status="green"] > .cockpit-dot,
+.cockpit-dot[data-status="green"] { background: var(--cockpit-green); }
+[data-status="amber"] > .cockpit-dot,
+.cockpit-dot[data-status="amber"] { background: var(--cockpit-amber); }
+[data-status="red"] > .cockpit-dot,
+.cockpit-dot[data-status="red"] { background: var(--cockpit-red); }
+
+.cockpit-status[data-status="green"] { color: var(--cockpit-green); }
+.cockpit-status[data-status="amber"] { color: var(--cockpit-amber); }
+.cockpit-status[data-status="red"] { color: var(--cockpit-red); }
+
+.cockpit-missing {
+  background: var(--cockpit-panel);
+  border: 1px solid var(--cockpit-edge);
+  border-radius: 8px;
+  padding: 10px;
+}
+.cockpit-missing[data-empty="true"] { opacity: 0.7; }
+.cockpit-panel-title { font-size: 13px; margin: 0 0 8px; color: var(--cockpit-muted); }
+.cockpit-light { display: flex; align-items: center; gap: 6px; padding: 2px 0; }
+.cockpit-light-detail { color: var(--cockpit-muted); font-size: 12px; }
+
+.cockpit-matrix { display: grid; gap: 10px; }
+.cockpit-network {
+  background: var(--cockpit-panel);
+  border: 1px solid var(--cockpit-edge);
+  border-left: 3px solid var(--cockpit-muted);
+  border-radius: 8px;
+  padding: 10px;
+}
+.cockpit-network[data-status="green"] { border-left-color: var(--cockpit-green); }
+.cockpit-network[data-status="red"] { border-left-color: var(--cockpit-red); }
+.cockpit-network-head { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
+.cockpit-network-name { font-weight: 600; }
+.cockpit-network-missing { color: var(--cockpit-red); font-size: 12px; }
+
+.cockpit-tokens { width: 100%; border-collapse: collapse; }
+.cockpit-th { text-align: left; color: var(--cockpit-muted); font-weight: 500; font-size: 12px; padding: 2px 6px; }
+.cockpit-td { padding: 3px 6px; border-top: 1px solid var(--cockpit-edge); vertical-align: top; }
+.cockpit-token[data-status="red"] .cockpit-token-name { color: var(--cockpit-red); }
+.cockpit-workers { display: flex; flex-wrap: wrap; gap: 4px; }
+.cockpit-worker {
+  background: #1c2733;
+  color: var(--cockpit-text);
+  border: 1px solid var(--cockpit-edge);
+  border-radius: 6px;
+  padding: 1px 8px;
+  cursor: pointer;
+  font: inherit;
+}
+.cockpit-worker:hover { border-color: var(--cockpit-green); }
+
+.cockpit-terminal {
+  background: #000;
+  border: 1px solid var(--cockpit-edge);
+  border-radius: 8px;
+  padding: 8px;
+}
+.cockpit-terminal-host { min-height: 220px; }
+.cockpit-nonagentic { color: var(--cockpit-muted); font-size: 12px; }

package/page/cockpit.page.json

@@ -0,0 +1,33 @@
+{
+	"schemaVersion": "1.0",
+	"title": "Cockpit",
+	"nodes": [
+		{
+			"type": "nav",
+			"id": "nav",
+			"props": {
+				"variant": "bar",
+				"title": "Agent cockpit",
+				"items": [{ "label": "Cockpit", "page": "cockpit" }]
+			}
+		},
+		{
+			"type": "text",
+			"id": "intro",
+			"props": {
+				"text": "Live demand×supply across the agent networks, missing-agent lights, the diversity SLO, and a drill-into-a-worker live terminal over the relay. The same view renders embedded in the console (App View) and standalone on a phone.",
+				"variant": "sub"
+			}
+		},
+		{
+			"type": "appView",
+			"id": "cockpit",
+			"props": {
+				"title": "Agent networks",
+				"embed": "./embed.html",
+				"standalone": "./standalone.html",
+				"fill": true
+			}
+		}
+	]
+}

package/page/embed.html

@@ -0,0 +1,40 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Cockpit — App View embed</title>
+    <link rel="stylesheet" href="./cockpit.css" />
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xterm/xterm@5/css/xterm.min.css" />
+    <style>
+      html, body { margin: 0; height: 100%; background: #0b0f14; }
+    </style>
+    <script type="importmap">
+      {
+        "imports": {
+          "@nanobpm/agentic/cockpit": "../dist/cockpit/index.js",
+          "@xterm/xterm": "https://cdn.jsdelivr.net/npm/@xterm/xterm@5/+esm"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <!--
+      Console App-View embed. The console loads this document into its App-View
+      surface (ADR 0057) and hands it a host element; we mount the SAME cockpit
+      via the SAME page/mount.js as the standalone shell — only the host and the
+      injected endpoints differ, so the page renders identically. When the console
+      injects endpoint config via `window.__NANO_APP_VIEW__`, it is honoured.
+    -->
+    <main id="cockpit-root"></main>
+    <script type="module">
+      import { mountCockpit } from "./mount.js";
+
+      const cfg = window.__NANO_APP_VIEW__ ?? {};
+      mountCockpit(cfg.host ?? document.getElementById("cockpit-root"), {
+        reportUrl: cfg.reportUrl,
+        relayUrl: cfg.relayUrl,
+      });
+    </script>
+  </body>
+</html>

package/page/mount.js

@@ -0,0 +1,78 @@
+// Browser adapter for @nanobpm/agentic/cockpit (S8).
+//
+// This is the ONE wiring both the standalone shell and the console App-View embed
+// call — they differ only in the host element they pass, so the cockpit renders
+// identically embedded and standalone. It supplies the browser capabilities the
+// injection-based core (`bootCockpit`) needs: the real `document`, a `fetch`-based
+// S4 demand report source, a `WebSocket` relay socket factory, and an xterm.js
+// terminal sink. It is plain browser ESM — not part of the typechecked/linted src.
+//
+// Resolve `@nanobpm/agentic/cockpit` and `@xterm/xterm` via the host page's import
+// map (see standalone.html / embed.html).
+import { bootCockpit } from "@nanobpm/agentic/cockpit";
+import { Terminal } from "@xterm/xterm";
+
+/** An xterm.js-backed terminal sink mounted into `host`. */
+function xtermSink(host) {
+  const term = new Terminal({ convertEol: true, fontFamily: "ui-monospace, monospace", fontSize: 13 });
+  term.open(host);
+  return { write: (chunk) => term.write(chunk), dispose: () => term.dispose() };
+}
+
+/** A WebSocket relay socket factory for the agentic channel at `url`. */
+function relaySocketFactory(url) {
+  return () => {
+    const ws = new WebSocket(url);
+    ws.binaryType = "arraybuffer";
+    return {
+      send: (bytes) => ws.send(bytes),
+      close: () => ws.close(),
+      onMessage: (cb) => ws.addEventListener("message", (event) => cb(new Uint8Array(event.data))),
+      onOpen: (cb) => ws.addEventListener("open", () => cb()),
+      onClose: (cb) => ws.addEventListener("close", () => cb()),
+    };
+  };
+}
+
+/**
+ * Mount the cockpit into `host` and start polling.
+ *
+ * @param {Element} host — where the cockpit renders (standalone: document.body; embedded: the App-View host).
+ * @param {object} [opts]
+ * @param {string} [opts.reportUrl] — the S4 demand×supply JSON endpoint the app serves.
+ * @param {string} [opts.relayUrl]  — the agentic channel WebSocket URL (with auth token + capability query).
+ * @param {number} [opts.refreshMs] — poll interval (default 2000).
+ * @returns the CockpitHandle (call `.dispose()` to tear down).
+ */
+export function mountCockpit(host, opts = {}) {
+  if (host == null || typeof host.replaceChildren !== "function") {
+    throw new Error(
+      "mountCockpit(host): host must be a mounted DOM element (got " +
+        (host === null ? "null" : typeof host) +
+        "). Check that the cockpit root element exists before mounting.",
+    );
+  }
+  const reportUrl = opts.reportUrl ?? "/app/api/agentic/demand";
+  const relayUrl = opts.relayUrl ?? defaultRelayUrl();
+  const cockpit = bootCockpit({
+    host,
+    doc: document,
+    fetchReport: async () => {
+      const res = await fetch(reportUrl, { headers: { accept: "application/json" } });
+      if (!res.ok) throw new Error(`demand fetch failed: ${res.status}`);
+      return res.json();
+    },
+    connectRelay: relaySocketFactory(relayUrl),
+    createTerminal: xtermSink,
+    refreshMs: opts.refreshMs ?? 2000,
+    onError: (err) => console.error("[cockpit]", err),
+  });
+  cockpit.start();
+  return cockpit;
+}
+
+/** Derive the channel WebSocket URL from the current origin (path `/agentic`). */
+function defaultRelayUrl() {
+  const proto = location.protocol === "https:" ? "wss:" : "ws:";
+  return `${proto}//${location.host}/agentic`;
+}

package/page/standalone.html

@@ -0,0 +1,43 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+    <title>Agent networks — the cockpit</title>
+    <link rel="stylesheet" href="./cockpit.css" />
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xterm/xterm@5/css/xterm.min.css" />
+    <style>
+      html, body { margin: 0; height: 100%; background: #0b0f14; }
+    </style>
+    <!--
+      Resolve the cockpit ESM + xterm.js. The cockpit is mapped RELATIVE to this
+      page (../dist/index.js) — exactly like ./mount.js and ./cockpit.css above —
+      so it resolves against whatever origin/version served the page (a CDN pin,
+      the Urban runtime, or a local checkout) with no hard-coded version to drift
+      out of sync with package.json. xterm.js stays a pinned third-party CDN dep.
+      The SAME page/mount.js the console App-View embed uses is loaded here.
+    -->
+    <script type="importmap">
+      {
+        "imports": {
+          "@nanobpm/agentic/cockpit": "../dist/cockpit/index.js",
+          "@xterm/xterm": "https://cdn.jsdelivr.net/npm/@xterm/xterm@5/+esm"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <main id="cockpit-root"></main>
+    <script type="module">
+      import { mountCockpit } from "./mount.js";
+
+      // Standalone: mount into the page body. Endpoints default to the current
+      // origin; override via ?report= and ?relay= for a remote app.
+      const params = new URLSearchParams(location.search);
+      mountCockpit(document.getElementById("cockpit-root"), {
+        reportUrl: params.get("report") ?? undefined,
+        relayUrl: params.get("relay") ?? undefined,
+      });
+    </script>
+  </body>
+</html>