@xenosystem/blocks 0.6.0 → 0.8.0

package/dist/agent/index.js

@@ -0,0 +1,1439 @@
+import "../chunk-2KG3PWR4.js";
+
+// src/agent/agent/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import {
+  bindConfig,
+  configBool,
+  configString,
+  isRecord
+} from "@xenosystem/block-sdk";
+
+// src/agent/agent/unified-diff.ts
+var HUNK_HEADER = /^@@+ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@+(.*)$/;
+var FILE_HEADER = /^(diff --git |index |--- |\+\+\+ |new file mode |deleted file mode |similarity index |rename (from|to) |old mode |new mode |Binary files )/;
+function hash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function parseUnifiedDiff(path, diff) {
+  const hunks = [];
+  const ids = /* @__PURE__ */ new Set();
+  let current = null;
+  let oldLine = 0;
+  let newLine = 0;
+  const close = () => {
+    if (!current) return;
+    const body = current.lines.map((l) => `${l.kind[0]}${l.text}`).join("\n");
+    let id = `${path}#${hash(`${current.header ?? ""}
+${body}`)}`;
+    if (ids.has(id)) {
+      id = `${id}-${ids.size}`;
+    }
+    ids.add(id);
+    current.id = id;
+    hunks.push(current);
+    current = null;
+  };
+  for (const raw of diff.split("\n")) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    const header = HUNK_HEADER.exec(line);
+    if (header) {
+      close();
+      oldLine = Number(header[1]);
+      newLine = Number(header[3]);
+      current = {
+        id: "",
+        oldStart: oldLine,
+        // ⚠️ An absent count means 1, per the format. Defaulting it to 0 would render a
+        // single-line hunk as an empty one — present in the list, empty on screen.
+        oldLines: header[2] === void 0 ? 1 : Number(header[2]),
+        newStart: newLine,
+        newLines: header[4] === void 0 ? 1 : Number(header[4]),
+        lines: [],
+        header: line
+      };
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("\\")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      current.lines.push({ kind: "added", newLineNumber: newLine, text: line.slice(1) });
+      newLine += 1;
+    } else if (line.startsWith("-")) {
+      current.lines.push({ kind: "removed", oldLineNumber: oldLine, text: line.slice(1) });
+      oldLine += 1;
+    } else if (line.startsWith(" ")) {
+      current.lines.push({
+        kind: "context",
+        oldLineNumber: oldLine,
+        newLineNumber: newLine,
+        text: line.slice(1)
+      });
+      oldLine += 1;
+      newLine += 1;
+    } else if (line === "") {
+      if (current.lines.filter((l) => l.kind !== "added").length >= current.oldLines) continue;
+      current.lines.push({ kind: "context", oldLineNumber: oldLine, newLineNumber: newLine, text: "" });
+      oldLine += 1;
+      newLine += 1;
+    } else if (FILE_HEADER.test(line)) {
+      close();
+    }
+  }
+  close();
+  return hunks;
+}
+function countChanges(hunks) {
+  let additions = 0;
+  let deletions = 0;
+  for (const hunk of hunks) {
+    for (const line of hunk.lines) {
+      if (line.kind === "added") additions += 1;
+      else if (line.kind === "removed") deletions += 1;
+    }
+  }
+  return { additions, deletions };
+}
+
+// src/agent/agent/projections.ts
+var AGENT_FANOUT_PORTS = [
+  "runs",
+  "records",
+  "elicitations",
+  "withdraw",
+  "diffModel",
+  "terminalData",
+  "terminalSession"
+];
+var RUN_STATUS = {
+  idle: "requested",
+  queued: "queued",
+  running: "running",
+  // The two that had no run-panel equivalent until the panel gained them, and the reason it did.
+  "waiting-for-user": "awaiting-decision",
+  "waiting-for-permission": "awaiting-permission",
+  succeeded: "succeeded",
+  failed: "failed",
+  cancelled: "cancelled"
+};
+function turnStatusToRunStatus(state) {
+  return RUN_STATUS[state];
+}
+function levelFor(role) {
+  return role === "error" ? "error" : "info";
+}
+var AgentProjector = class {
+  now;
+  /** turnId → sessionId. The address a run action comes back on. */
+  turnSession = /* @__PURE__ */ new Map();
+  /** callId → the step path inside its run, so a nested call can be patched in place. */
+  callPath = /* @__PURE__ */ new Map();
+  /** messageId → seen, so the second event for a message patches rather than re-appends. */
+  messages = /* @__PURE__ */ new Set();
+  /** askId → sessionId. */
+  askSession = /* @__PURE__ */ new Map();
+  /** terminalId → sessionId. */
+  terminalSession = /* @__PURE__ */ new Map();
+  /**
+   * File path → the change set it belongs to.
+   *
+   * ⚠️ **Replaced wholesale on every `patch` event, because the diff panel's model is too.** The
+   * map and the thing it describes move together, so a decision can never address a change set the
+   * user is no longer looking at.
+   */
+  patchPaths = /* @__PURE__ */ new Map();
+  /**
+   * Answers that addressed nothing known, since the last clear.
+   *
+   * Surfaced rather than swallowed, for the reason `xeno.core.console` surfaces its dropped
+   * patches: a mis-wired return path and a dead one look identical from the outside, and this is
+   * the one number that tells them apart.
+   */
+  dropped = 0;
+  constructor(options = {}) {
+    this.now = options.now ?? (() => Date.now());
+  }
+  /** How many answers were dropped for want of a correlation. */
+  get droppedAnswers() {
+    return this.dropped;
+  }
+  /** Forget everything. Used when the host replaces or clears the session index. */
+  reset() {
+    this.turnSession.clear();
+    this.callPath.clear();
+    this.messages.clear();
+    this.askSession.clear();
+    this.terminalSession.clear();
+    this.patchPaths = /* @__PURE__ */ new Map();
+    this.dropped = 0;
+  }
+  /** How many asks are still outstanding. */
+  get pendingAsks() {
+    return this.askSession.size;
+  }
+  /** Which session an ask belongs to, or `undefined`. */
+  sessionForAsk(askId) {
+    return this.askSession.get(askId);
+  }
+  /** Which session a turn belongs to, or `undefined`. */
+  sessionForTurn(turnId) {
+    return this.turnSession.get(turnId);
+  }
+  /** Which session a terminal belongs to, or `undefined`. */
+  sessionForTerminal(terminalId) {
+    return this.terminalSession.get(terminalId);
+  }
+  /** Which change set a reviewed file belongs to, or `undefined`. */
+  patchForPath(path) {
+    return this.patchPaths.get(path);
+  }
+  /** Record that an ask has been settled, so a second answer for it is dropped rather than resent. */
+  settleAsk(askId) {
+    this.askSession.delete(askId);
+  }
+  /** Count an answer that could not be correlated. */
+  dropAnswer() {
+    this.dropped += 1;
+  }
+  /**
+   * Project one event.
+   *
+   * @param event - The event.
+   * @returns Zero or more emissions, in the order they must be delivered. **Order matters**: a
+   *   console record must be appended before it is patched, and a step must be announced before it
+   *   is addressed — both panels drop an update for something they do not hold.
+   */
+  project(event) {
+    switch (event.type) {
+      case "session":
+        return [];
+      case "session-closed": {
+        return [];
+      }
+      case "turn": {
+        const fresh = !this.turnSession.has(event.turnId);
+        this.turnSession.set(event.turnId, event.sessionId);
+        const status = turnStatusToRunStatus(event.state);
+        if (fresh) {
+          return [
+            {
+              portId: "runs",
+              value: {
+                append: [
+                  {
+                    id: event.turnId,
+                    label: event.label ?? event.turnId,
+                    status,
+                    // The run panel sorts on this and requires it. A turn with no reported start
+                    // is stamped on arrival rather than defaulted to the epoch, which would file
+                    // it at the bottom of the list — exactly where nobody looks for the thing they
+                    // just asked for.
+                    startedAt: event.startedAt ?? this.now(),
+                    endedAt: event.endedAt,
+                    error: event.error,
+                    source: event.sessionId
+                  }
+                ]
+              }
+            }
+          ];
+        }
+        return [
+          {
+            portId: "runs",
+            value: {
+              patch: {
+                [event.turnId]: {
+                  status,
+                  ...event.label === void 0 ? {} : { label: event.label },
+                  ...event.endedAt === void 0 ? {} : { endedAt: event.endedAt },
+                  ...event.error === void 0 ? {} : { error: event.error }
+                }
+              }
+            }
+          }
+        ];
+      }
+      case "tool": {
+        this.turnSession.set(event.turnId, event.sessionId);
+        const known = this.callPath.get(event.callId);
+        const status = turnStatusToRunStatus(event.state);
+        if (!known) {
+          const parentPath = event.parentCallId ? this.callPath.get(event.parentCallId) : void 0;
+          const path = [...parentPath ?? [], event.callId];
+          this.callPath.set(event.callId, path);
+          return [
+            {
+              portId: "runs",
+              value: {
+                appendSteps: [
+                  {
+                    runId: event.turnId,
+                    path: parentPath,
+                    steps: [
+                      {
+                        id: event.callId,
+                        label: event.label ?? event.callId,
+                        status,
+                        startedAt: event.startedAt,
+                        endedAt: event.endedAt,
+                        progress: event.progress,
+                        detail: event.detail,
+                        error: event.error
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ];
+        }
+        return [
+          {
+            portId: "runs",
+            value: {
+              patchSteps: [
+                {
+                  runId: event.turnId,
+                  path: known,
+                  patch: {
+                    status,
+                    ...event.label === void 0 ? {} : { label: event.label },
+                    ...event.progress === void 0 ? {} : { progress: event.progress },
+                    ...event.detail === void 0 ? {} : { detail: event.detail },
+                    ...event.endedAt === void 0 ? {} : { endedAt: event.endedAt },
+                    ...event.error === void 0 ? {} : { error: event.error }
+                  }
+                }
+              ]
+            }
+          }
+        ];
+      }
+      case "message": {
+        const fresh = !this.messages.has(event.messageId);
+        const delta = {};
+        if (fresh) {
+          this.messages.add(event.messageId);
+          delta.append = [
+            {
+              id: event.messageId,
+              ts: event.ts ?? this.now(),
+              level: levelFor(event.role),
+              message: event.text ?? "",
+              source: event.sessionId,
+              scope: event.role
+            }
+          ];
+          if (event.append !== void 0) {
+            delta.patch = { [event.messageId]: { appendMessage: event.append } };
+          }
+          return [{ portId: "records", value: delta }];
+        }
+        const patch = {};
+        if (event.text !== void 0) patch.message = event.text;
+        if (event.append !== void 0) patch.appendMessage = event.append;
+        if (Object.keys(patch).length === 0) return [];
+        return [{ portId: "records", value: { patch: { [event.messageId]: patch } } }];
+      }
+      case "ask": {
+        this.askSession.set(event.ask.id, event.sessionId);
+        return [{ portId: "elicitations", value: event.ask }];
+      }
+      case "ask-withdraw": {
+        this.askSession.delete(event.askId);
+        return [{ portId: "withdraw", value: event.askId }];
+      }
+      case "patch": {
+        const paths = /* @__PURE__ */ new Map();
+        const files = event.files.map((file) => {
+          paths.set(file.path, { sessionId: event.sessionId, patchId: event.patchId });
+          return this.projectFile(file);
+        });
+        this.patchPaths = paths;
+        return [
+          {
+            portId: "diffModel",
+            value: {
+              files,
+              status: "ready",
+              oldLabel: event.oldLabel,
+              newLabel: event.newLabel
+            }
+          }
+        ];
+      }
+      case "terminal": {
+        this.terminalSession.set(event.terminalId, event.sessionId);
+        const out = [];
+        if (event.session !== void 0) {
+          out.push({ portId: "terminalSession", value: event.session });
+        }
+        if (event.data !== void 0) {
+          out.push({ portId: "terminalData", value: { id: event.terminalId, data: event.data } });
+        }
+        return out;
+      }
+      default: {
+        return [];
+      }
+    }
+  }
+  /** One file of a change set → the diff panel's file shape. */
+  projectFile(file) {
+    if (file.omitted !== void 0 || file.diff === void 0) {
+      return {
+        path: file.path,
+        oldPath: file.oldPath,
+        status: file.status,
+        language: file.language,
+        hunks: [],
+        omitted: file.omitted ?? "unreadable"
+      };
+    }
+    const hunks = parseUnifiedDiff(file.path, file.diff);
+    if (hunks.length === 0) {
+      return {
+        path: file.path,
+        oldPath: file.oldPath,
+        status: file.status,
+        language: file.language,
+        hunks: [],
+        omitted: "unreadable"
+      };
+    }
+    const { additions, deletions } = countChanges(hunks);
+    return {
+      path: file.path,
+      oldPath: file.oldPath,
+      status: file.status,
+      language: file.language,
+      hunks,
+      additions,
+      deletions
+    };
+  }
+};
+
+// src/agent/agent/types.ts
+function isBusy(turn) {
+  return turn === "queued" || turn === "running";
+}
+function isWaitingOnUser(turn) {
+  return turn === "waiting-for-user" || turn === "waiting-for-permission";
+}
+
+// src/agent/agent/controller.ts
+var AgentController = class {
+  host;
+  projector;
+  sessions = [];
+  activeSessionId = null;
+  connection = "idle";
+  connectionMessage = null;
+  catalog = { providers: [] };
+  draft = "";
+  /** Last delta revision applied. A delta whose rev has not advanced is dropped. */
+  rev = -1;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Memoized view state.
+   *
+   * `useSyncExternalStore` compares by identity and loops forever if `getState` returns a fresh
+   * object each call. Every mutation clears this; nothing else may.
+   */
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.projector = new AgentProjector({ now: options.now });
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const active = this.sessions.find((s) => s.id === this.activeSessionId) ?? null;
+      const turn = active?.turn ?? "idle";
+      const busy = isBusy(turn);
+      const activeProvider = this.catalog.providers.find((p) => p.id === (active?.providerId ?? this.catalog.activeProviderId)) ?? null;
+      this.snapshot = {
+        sessions: this.sessions,
+        active,
+        turn,
+        connection: this.connection,
+        // A turn's own failure sentence wins over the connection's: it is the more specific fact,
+        // and it is the one the user is looking at.
+        message: (turn === "failed" ? active?.message : null) ?? this.connectionMessage,
+        providers: this.catalog.providers,
+        activeProvider,
+        activeModelId: active?.modelId ?? this.catalog.activeModelId ?? null,
+        draft: this.draft,
+        canSubmit: this.canSubmit(),
+        busy,
+        pendingAsks: this.projector.pendingAsks
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  /* ── Fan-out ───────────────────────────────────────────────────────────── */
+  fanOut(emissions) {
+    for (const emission of emissions) this.host.emit(emission.portId, emission.value);
+  }
+  /** Emit the one thing the host acts on. */
+  intent(intent) {
+    this.host.emit("intent", intent);
+  }
+  /* ── Host-pushed state ─────────────────────────────────────────────────── */
+  /**
+   * Apply a session delta.
+   *
+   * The host is authoritative: sessions are upserted, never merged cleverly, and the panel keeps no
+   * "better" older value. A panel that second-guesses its host is a second source of truth.
+   *
+   * @param delta - The delta.
+   */
+  ingest(delta) {
+    if (typeof delta.rev === "number") {
+      if (delta.rev <= this.rev) return;
+      this.rev = delta.rev;
+    }
+    if (delta.clear) {
+      this.sessions = [];
+      this.activeSessionId = null;
+      this.projector.reset();
+      this.notify();
+      return;
+    }
+    if (delta.replace) {
+      this.sessions = [...delta.replace].sort(orderSessions);
+      this.projector.reset();
+      if (this.activeSessionId && !this.sessions.some((s) => s.id === this.activeSessionId)) {
+        this.activeSessionId = null;
+      }
+      this.notify();
+      return;
+    }
+    let touched = false;
+    for (const event of delta.events ?? []) {
+      if (event.type === "session") {
+        this.upsertSession(event.session);
+        touched = true;
+      } else if (event.type === "session-closed") {
+        this.sessions = this.sessions.filter((s) => s.id !== event.sessionId);
+        if (this.activeSessionId === event.sessionId) this.activeSessionId = null;
+        touched = true;
+      } else if (event.type === "turn") {
+        touched = this.setTurnState(event.sessionId, event.state) || touched;
+      } else if (event.type === "ask" || event.type === "ask-withdraw") {
+        touched = true;
+      }
+      this.fanOut(this.projector.project(event));
+    }
+    if (!this.activeSessionId && this.sessions.length > 0) {
+      this.activeSessionId = this.sessions[0].id;
+      touched = true;
+    }
+    if (touched) this.notify();
+  }
+  upsertSession(next) {
+    const at = this.sessions.findIndex((s) => s.id === next.id);
+    if (at < 0) {
+      this.sessions = [...this.sessions, next].sort(orderSessions);
+      return;
+    }
+    const defined = Object.fromEntries(Object.entries(next).filter(([, v]) => v !== void 0));
+    const merged = { ...this.sessions[at], ...defined };
+    const sessions = [...this.sessions];
+    sessions[at] = merged;
+    this.sessions = sessions.sort(orderSessions);
+  }
+  setTurnState(sessionId, turn) {
+    const at = this.sessions.findIndex((s) => s.id === sessionId);
+    if (at < 0) return false;
+    if (this.sessions[at].turn === turn) return false;
+    const sessions = [...this.sessions];
+    sessions[at] = { ...sessions[at], turn };
+    this.sessions = sessions;
+    return true;
+  }
+  /** Install the provider catalogue. The host decides what is selectable; the panel renders it. */
+  setCatalog(catalog) {
+    this.catalog = { ...catalog, providers: catalog.providers ?? [] };
+    this.notify();
+  }
+  /**
+   * Report the connection out of band.
+   *
+   * Separate from the session delta so a host never has to express "not connected" as an empty
+   * session list — the distinction `xeno.core.runs` and `xeno.core.diff` both draw, and for the
+   * same reason: zero sessions means "there are none" only when someone looked.
+   */
+  setStatus(status, message) {
+    this.connection = status;
+    this.connectionMessage = message ?? null;
+    this.notify();
+  }
+  /* ── The composer ──────────────────────────────────────────────────────── */
+  setDraft(text) {
+    this.draft = text;
+    this.notify();
+  }
+  /**
+   * Would {@link submit} do anything?
+   *
+   * 🔴 The view's `disabled` derives from THIS, so an enabled button cannot be a button that
+   * refuses. The affordance and the guard are one predicate.
+   *
+   * ⚠️ `connection === 'idle'` does NOT block. Idle means *the host has never reported a
+   * connection state*, and inventing a blocker out of silence would make the panel unusable in
+   * every host that does not wire the optional `status` port. Silence is not a refusal; the host
+   * refuses if it must.
+   */
+  canSubmit() {
+    if (!this.activeSessionId) return false;
+    if (this.draft.trim() === "") return false;
+    if (this.connection === "connecting" || this.connection === "failed") return false;
+    const active = this.sessions.find((s) => s.id === this.activeSessionId);
+    return !isBusy(active?.turn ?? "idle");
+  }
+  /**
+   * Ask the host to run the draft.
+   *
+   * 🔴 **The draft is NOT cleared here.** The panel does not know the turn started — the host may
+   * refuse, the provider may be unavailable, a permission check may reject it. Clearing on emit
+   * would show success before anything settled, which is a claim the panel cannot back; the draft
+   * clears when the host reports a `running` turn. (`panel-template`'s rule, applied to the one
+   * place in this catalog where a user would notice losing their text.)
+   *
+   * @returns Whether an intent was emitted.
+   */
+  submit() {
+    if (!this.canSubmit()) return false;
+    const active = this.sessions.find((s) => s.id === this.activeSessionId);
+    this.intent({
+      type: "prompt",
+      sessionId: active.id,
+      text: this.draft,
+      providerId: active.providerId ?? this.catalog.activeProviderId,
+      modelId: active.modelId ?? this.catalog.activeModelId
+    });
+    return true;
+  }
+  /**
+   * Ask the host to steer the running turn.
+   *
+   * ⚠️ **Steering lands at the agent's next decision point, not instantly.** That was measured
+   * against real Claude Code and recorded in the ADE spec, and it is why this is a separate verb
+   * from {@link submit} rather than "submit while busy": the two have different latencies and
+   * different failure modes, and a control that hid the difference would be lying about which one
+   * the user got.
+   *
+   * @returns Whether an intent was emitted.
+   */
+  steer() {
+    const active = this.sessions.find((s) => s.id === this.activeSessionId);
+    if (!active || this.draft.trim() === "") return false;
+    if (!isBusy(active.turn ?? "idle")) return false;
+    this.intent({ type: "steer", sessionId: active.id, text: this.draft });
+    return true;
+  }
+  /** Ask the host to stop the running turn. */
+  cancel() {
+    const active = this.sessions.find((s) => s.id === this.activeSessionId);
+    if (!active) return false;
+    this.intent({ type: "cancel", sessionId: active.id });
+    return true;
+  }
+  /** Show another session. Panel-local AND an intent — the host may need to attach to it. */
+  selectSession(sessionId) {
+    if (!this.sessions.some((s) => s.id === sessionId)) return false;
+    this.activeSessionId = sessionId;
+    this.notify();
+    this.intent({ type: "select-session", sessionId });
+    return true;
+  }
+  /** Ask the host to start a session. The panel does not create one — it has no way to. */
+  newSession(providerId, modelId) {
+    this.intent({
+      type: "new-session",
+      providerId: providerId ?? this.catalog.activeProviderId,
+      modelId: modelId ?? this.catalog.activeModelId
+    });
+  }
+  /**
+   * Ask the host to switch the active session's agent.
+   *
+   * Refused for a provider the host declared unavailable: the panel must not offer what the host
+   * will not honour, which is the rule `xeno.core.consent` applies to durations.
+   *
+   * @returns Whether an intent was emitted.
+   */
+  selectProvider(providerId, modelId) {
+    const provider = this.catalog.providers.find((p) => p.id === providerId);
+    if (!provider || provider.unavailable !== void 0) return false;
+    if (!this.activeSessionId) return false;
+    this.intent({ type: "select-provider", sessionId: this.activeSessionId, providerId, modelId });
+    return true;
+  }
+  /* ── Answers coming back from the canonical panels ─────────────────────── */
+  /**
+   * A consent decision or an elicitation result, from `xeno.core.consent`.
+   *
+   * 🔴 **Dropped when the id correlates to nothing.** A decision routed to a guessed session
+   * applies a human's approval to work they never saw. Both of consent's output ports arrive here
+   * because both are answers to an ask this panel minted, and the panel forwards each verbatim —
+   * it does not read `decision`, and must not: interpreting an allow/deny would make this a second
+   * place where a grant is decided.
+   *
+   * @param answer - The decision or result, verbatim.
+   * @returns Whether an intent was emitted.
+   */
+  answer(answer) {
+    if (!answer || typeof answer !== "object") return false;
+    const id = answer.id;
+    if (typeof id !== "string") return false;
+    const sessionId = this.projector.sessionForAsk(id);
+    if (!sessionId) {
+      this.projector.dropAnswer();
+      return false;
+    }
+    this.projector.settleAsk(id);
+    this.intent({ type: "answer", sessionId, askId: id, answer });
+    this.notify();
+    return true;
+  }
+  /**
+   * A hunk decision, from `xeno.core.diff`.
+   *
+   * @param decision - `{path, hunkId, action, comment?}`, verbatim.
+   * @returns Whether an intent was emitted.
+   */
+  patchDecision(decision) {
+    if (!decision || typeof decision !== "object") return false;
+    const path = decision.path;
+    if (typeof path !== "string") return false;
+    const owner = this.projector.patchForPath(path);
+    if (!owner) {
+      this.projector.dropAnswer();
+      return false;
+    }
+    this.intent({
+      type: "patch-decision",
+      sessionId: owner.sessionId,
+      patchId: owner.patchId,
+      decision
+    });
+    return true;
+  }
+  /**
+   * A run action, from `xeno.core.runs`.
+   *
+   * ⚠️ The targeted step is read from `stepPath`'s LAST element, falling back to `stepId`. Both are
+   * emitted together by that panel and mean the same thing at depth 1; only the path survives
+   * nesting, which is the case an agent's subagent calls produce.
+   *
+   * @param action - `{runId, action, stepId?, stepPath?}`, verbatim.
+   * @returns Whether an intent was emitted.
+   */
+  runAction(action) {
+    if (!action || typeof action !== "object") return false;
+    const record = action;
+    if (typeof record.runId !== "string") return false;
+    if (record.action !== "cancel" && record.action !== "retry") return false;
+    const sessionId = this.projector.sessionForTurn(record.runId);
+    if (!sessionId) {
+      this.projector.dropAnswer();
+      return false;
+    }
+    const path = Array.isArray(record.stepPath) ? record.stepPath : void 0;
+    const last = path && path.length > 0 ? path[path.length - 1] : void 0;
+    const callId = typeof last === "string" ? last : typeof record.stepId === "string" ? record.stepId : void 0;
+    this.intent({ type: "run-action", sessionId, turnId: record.runId, action: record.action, callId });
+    return true;
+  }
+  /**
+   * A terminal intent, from `xeno.core.terminal`.
+   *
+   * @param intent - The terminal panel's intent, verbatim.
+   * @returns Whether an intent was emitted.
+   */
+  terminalIntent(intent) {
+    if (!intent || typeof intent !== "object") return false;
+    const id = intent.id;
+    if (typeof id !== "string") return false;
+    const sessionId = this.projector.sessionForTerminal(id);
+    if (!sessionId) {
+      this.projector.dropAnswer();
+      return false;
+    }
+    this.intent({ type: "terminal", sessionId, terminal: intent });
+    return true;
+  }
+  /** Answers that could not be correlated, since the last reset. Surfaced, never swallowed. */
+  get droppedAnswers() {
+    return this.projector.droppedAnswers;
+  }
+  /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+  /**
+   * Serialize.
+   *
+   * 🔴 **Preferences plus the unsent draft, and nothing else.** No transcript, no run list, no
+   * session content — that is host state which has moved on, and `.xapp` is a plain JSON file that
+   * may contain nothing sensitive.
+   */
+  serialize() {
+    return { activeSessionId: this.activeSessionId, draft: this.draft };
+  }
+  /** Restore preferences. Sessions are NOT restored; the host re-pushes them. */
+  deserialize(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if (typeof s.activeSessionId === "string" || s.activeSessionId === null) {
+      this.activeSessionId = s.activeSessionId ?? null;
+    }
+    if (typeof s.draft === "string") this.draft = s.draft;
+    this.notify();
+  }
+  /** Release everything. */
+  dispose() {
+    this.listeners.clear();
+    this.sessions = [];
+    this.projector.reset();
+    this.snapshot = null;
+  }
+};
+function orderSessions(a, b) {
+  const at = a.createdAt;
+  const bt = b.createdAt;
+  if (at === void 0 && bt === void 0) return 0;
+  if (at === void 0) return 1;
+  if (bt === void 0) return -1;
+  return bt - at;
+}
+
+// src/agent/agent/manifest.ts
+import { WELL_KNOWN_PORT_SCHEMAS } from "@xenosystem/block-sdk";
+var AGENT_PANEL_ID = "xeno.core.agent";
+var AGENT_SESSION_SCHEMA = "xeno.agentsession@1";
+var AGENT_CATALOG_SCHEMA = "xeno.agentcatalog@1";
+var AGENT_INTENT_SCHEMA = "xeno.agentintent@1";
+var CONSENT_ELICITATION_SCHEMA = "xeno.elicitation@1";
+var CONSENT_ELICITATION_RESULT_SCHEMA = "xeno.elicitationresult@1";
+var agentManifest = {
+  id: AGENT_PANEL_ID,
+  version: "0.1.0",
+  title: "Agent",
+  icon: "bot",
+  description: "One agent surface for every XENO app: the composer, the lane and provider picker, and the session switcher \u2014 plus the translation from one session-event stream into the canonical panels that render the tool timeline, the log, the permission queue, the diff and the terminal. Holds no agent logic and runs nothing.",
+  defaultSlot: "right",
+  inputs: [
+    {
+      id: "session",
+      name: "Session Events",
+      type: "object",
+      schema: AGENT_SESSION_SCHEMA,
+      description: "A delta: {rev?, events?, replace?, clear?}. Events are session/turn/message/tool/ask/patch/terminal \u2014 see the package README for the shape and INTEGRATION.md for the host obligation. Fan-in: one wire per agent host.",
+      multiple: true
+    },
+    {
+      id: "catalog",
+      name: "Provider Catalog",
+      type: "object",
+      schema: AGENT_CATALOG_SCHEMA,
+      description: '{providers[], activeProviderId?, activeModelId?}. A provider carries a `lane` (cloud|local|acp) and an `unavailable` SENTENCE \u2014 never a boolean, because "why can I not pick this?" is the whole question a greyed-out row raises.',
+      multiple: false
+    },
+    {
+      id: "status",
+      name: "Connection",
+      type: "object",
+      description: '{status, message?} \u2014 idle | connecting | ready | failed, out of band, so a host never has to express "not connected" as an empty session list.',
+      multiple: false
+    },
+    {
+      id: "decision",
+      name: "Consent Decision",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.CONSENT_DECISION,
+      description: "The consent panel's `decision` output, routed back so it can be correlated to the session that asked. Forwarded VERBATIM \u2014 this panel never reads allow/deny, because interpreting it would make this a second place where a grant is decided.",
+      multiple: true
+    },
+    {
+      id: "result",
+      name: "Elicitation Result",
+      type: "object",
+      schema: CONSENT_ELICITATION_RESULT_SCHEMA,
+      description: "The consent panel's `result` output \u2014 a text/path/choice answer, or a cancellation carrying no value at all. Correlated and forwarded verbatim.",
+      multiple: true
+    },
+    {
+      id: "diffDecision",
+      name: "Hunk Decision",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.DIFF_DECISION_INTENT,
+      description: "The diff panel's `decision` output. \u{1F534} Dropped when its path belongs to no change set currently on screen \u2014 forwarding it would apply a review of one proposal to another.",
+      multiple: true
+    },
+    {
+      id: "runAction",
+      name: "Run Action",
+      type: "object",
+      description: "The runs panel's `action` output: {runId, action, stepId?, stepPath?}. The run id IS the turn id; the targeted tool call is `stepPath`'s last element.",
+      multiple: true
+    },
+    {
+      id: "terminalIntent",
+      name: "Terminal Intent",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.TERMINAL_INTENT,
+      description: "The terminal panel's `intent` output, correlated to the session that owns the instance and forwarded verbatim.",
+      multiple: true
+    }
+  ],
+  outputs: [
+    {
+      id: "intent",
+      name: "Intent",
+      type: "object",
+      schema: AGENT_INTENT_SCHEMA,
+      description: "The ONE thing the host acts on: prompt | cancel | steer | select-session | new-session | select-provider | answer | patch-decision | run-action | terminal. Every answer arriving from a canonical panel leaves here carrying the session id that panel could not know."
+    },
+    {
+      id: "runs",
+      name: "Runs Delta",
+      type: "object",
+      description: "For `xeno.core.runs` \u2192 `runs`. A turn is a RUN; a tool call is a STEP, nested by `parentCallId`, addressed by path. Progress travels as `patchSteps`, never as a re-push of the run."
+    },
+    {
+      id: "records",
+      name: "Log Delta",
+      type: "object",
+      description: "For `xeno.core.console` \u2192 `records`. A message opens with `append` and streams with `patch.appendMessage` \u2014 the update-by-id path a token-streamed reply has no other representation in."
+    },
+    {
+      id: "elicitations",
+      name: "Elicitations",
+      type: "object",
+      schema: CONSENT_ELICITATION_SCHEMA,
+      description: "For `xeno.core.consent` \u2192 `elicitations`. Forwarded verbatim; whether an ask can be rendered is that panel\u2019s decision, not this one\u2019s."
+    },
+    {
+      id: "withdraw",
+      name: "Withdraw",
+      type: "string",
+      description: "For `xeno.core.consent` \u2192 `withdraw`. An ask the agent no longer needs answered, so the queue is not left holding a question nobody is waiting on."
+    },
+    {
+      id: "diffModel",
+      name: "Diff Model",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.DIFF_MODEL,
+      description: 'For `xeno.core.diff` \u2192 `model`. Unified-diff text is parsed HERE (the panel ships no engine by charter). A file with no readable diff is reported `omitted: "unreadable"`, never as identical.'
+    },
+    {
+      id: "terminalData",
+      name: "Terminal Data",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.TERMINAL_DATA,
+      description: "For `xeno.core.terminal` \u2192 `data`. Raw bytes, escape sequences intact \u2014 never pre-parsed, because the emulator is the parser."
+    },
+    {
+      id: "terminalSession",
+      name: "Terminal Session",
+      type: "object",
+      description: "For `xeno.core.terminal` \u2192 `session`. Emitted BEFORE any data for that instance: a write into a terminal the panel has not been told about has nowhere to land."
+    }
+  ],
+  commands: [
+    {
+      id: "get_sessions",
+      title: "Get Sessions",
+      description: 'Return every session with its turn state, newest first, plus the connection status. The STATUS travels with the count so a caller cannot read 0 as "none" when the truth is "not connected".',
+      parameters: {}
+    },
+    {
+      id: "get_status",
+      title: "Get Status",
+      description: "Connection, active session, turn state, pending asks, and how many panel answers were dropped for want of a correlation.",
+      parameters: {}
+    },
+    {
+      id: "select_session",
+      title: "Select Session",
+      description: "Show another session. Returns the active session id, or null.",
+      parameters: { sessionId: { type: "string", description: "Session id", required: true } }
+    },
+    {
+      id: "cancel_turn",
+      title: "Cancel Turn",
+      description: "Ask the host to stop the active session\u2019s turn. Stopping only ever reduces what happens, which is why it is the one mutating verb here.",
+      parameters: {}
+    }
+    // 🔴 WHAT IS DELIBERATELY ABSENT, and why each one is a refusal rather than an omission:
+    //
+    // - **No `submit_prompt`.** An agent that can start turns can start them forever — an unbounded
+    //   self-driving loop with a billing meter attached and no human decision point anywhere in it.
+    //   Every other agent-facing verb in this catalog costs at most one wrong row; this one costs
+    //   credits until somebody notices.
+    // - **No `set_draft`.** Writing into the human's composer is putting words in their mouth: the
+    //   text sits where they expect their own to be, and the next keystroke sends it.
+    // - **No `answer_ask`.** An agent answering its own permission prompt is precisely what
+    //   `xeno.core.consent` exists to prevent, and routing around that panel would defeat it just
+    //   as thoroughly as editing it.
+    // - **No patch accept/reject.** Same reasoning as `xeno.core.diff`: the review step exists to
+    //   check the agent, so the agent must not be able to operate the thing that checks it.
+  ],
+  config: [
+    {
+      key: "submitOnEnter",
+      label: "Enter sends",
+      type: "boolean",
+      defaultValue: true,
+      description: "Enter submits and Shift+Enter inserts a newline. Off swaps the two."
+    },
+    {
+      key: "showLane",
+      label: "Show lane",
+      type: "boolean",
+      defaultValue: true,
+      description: "Show whether the turn runs in the cloud, locally, or through ACP. Where the code and the credits go is not a detail."
+    },
+    {
+      key: "showSessions",
+      label: "Show session switcher",
+      type: "boolean",
+      defaultValue: true,
+      description: "Hide it in a host that owns session selection in its own chrome."
+    },
+    {
+      key: "emptyHint",
+      label: "Empty hint",
+      type: "text",
+      description: "Say what would produce a session, not that there are none.",
+      placeholder: "Start a session to talk to an agent."
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/agent/agent/react/AgentPanelView.tsx
+import { useSyncExternalStore } from "react";
+import {
+  Badge,
+  EmptyState,
+  Row,
+  RowList,
+  ScrollArea,
+  StatusBadge,
+  StatusBar,
+  TextButton,
+  Toolbar,
+  ToolbarGroup
+} from "@xenosystem/workbench/primitives/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var LANE_LABEL = {
+  cloud: "Cloud",
+  local: "Local",
+  acp: "ACP"
+};
+var TURN = {
+  idle: { label: "Idle", tone: "neutral" },
+  queued: { label: "Queued", tone: "neutral" },
+  running: { label: "Working", tone: "info" },
+  "waiting-for-user": { label: "Needs an answer", tone: "warning" },
+  "waiting-for-permission": { label: "Needs permission", tone: "warning" },
+  succeeded: { label: "Done", tone: "success" },
+  failed: { label: "Failed", tone: "error" },
+  cancelled: { label: "Cancelled", tone: "neutral" }
+};
+var COLUMN = { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 };
+var COMPOSER = {
+  width: "100%",
+  minHeight: 64,
+  resize: "vertical",
+  background: "transparent",
+  color: "inherit",
+  border: "none",
+  outline: "none",
+  font: "inherit",
+  padding: "8px 10px"
+};
+function AgentPanelView({
+  controller,
+  submitOnEnter = true,
+  showLane = true,
+  showSessions = true,
+  emptyHint
+}) {
+  const state = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+  if (state.connection === "failed") {
+    return /* @__PURE__ */ jsx(ErrorPane, { message: state.message });
+  }
+  if (state.connection === "connecting") {
+    return /* @__PURE__ */ jsx(EmptyState, { title: "Connecting\u2026", hint: "Waiting for the agent host." });
+  }
+  if (state.sessions.length === 0) {
+    return /* @__PURE__ */ jsxs("div", { style: COLUMN, children: [
+      /* @__PURE__ */ jsx(EmptyState, { title: "No sessions", hint: emptyHint ?? "Start a session to talk to an agent." }),
+      /* @__PURE__ */ jsx(
+        Toolbar,
+        {
+          right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.newSession(), children: "New session" }) })
+        }
+      )
+    ] });
+  }
+  const turn = TURN[state.turn];
+  const lane = state.activeProvider?.lane;
+  return /* @__PURE__ */ jsxs("div", { style: COLUMN, children: [
+    /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsxs(ToolbarGroup, { children: [
+          /* @__PURE__ */ jsx(StatusBadge, { tone: turn.tone, children: turn.label }),
+          showLane && lane ? /* @__PURE__ */ jsx(Badge, { children: LANE_LABEL[lane] ?? lane }) : null,
+          state.pendingAsks > 0 ? /* @__PURE__ */ jsx(Badge, { children: `${state.pendingAsks} waiting` }) : null
+        ] }),
+        right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.newSession(), children: "New session" }) })
+      }
+    ),
+    showSessions ? /* @__PURE__ */ jsx(ScrollArea, { children: /* @__PURE__ */ jsx(RowList, { children: state.sessions.map((session) => /* @__PURE__ */ jsx(
+      Row,
+      {
+        noIcon: true,
+        label: session.title ?? session.id,
+        selected: session.id === state.active?.id,
+        onClick: () => controller.selectSession(session.id),
+        trailing: /* @__PURE__ */ jsx(Badge, { children: TURN[session.turn ?? "idle"].label })
+      },
+      session.id
+    )) }) }) : null,
+    state.providers.length > 1 ? /* @__PURE__ */ jsx(RowList, { children: state.providers.map((provider) => /* @__PURE__ */ jsx(
+      Row,
+      {
+        noIcon: true,
+        label: provider.label,
+        meta: provider.unavailable ?? (showLane ? LANE_LABEL[provider.lane] ?? provider.lane : void 0),
+        disabled: provider.unavailable !== void 0,
+        selected: provider.id === state.activeProvider?.id,
+        onClick: () => controller.selectProvider(provider.id)
+      },
+      provider.id
+    )) }) : null,
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        style: COMPOSER,
+        value: state.draft,
+        placeholder: state.busy ? "Steer the running turn\u2026" : "Ask the agent\u2026",
+        onChange: (event) => controller.setDraft(event.target.value),
+        onKeyDown: (event) => {
+          if (event.key !== "Enter") return;
+          const wantsSubmit = submitOnEnter ? !event.shiftKey : event.shiftKey;
+          if (!wantsSubmit) return;
+          event.preventDefault();
+          if (state.busy) controller.steer();
+          else controller.submit();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        left: state.message ?? state.active?.cwd ?? void 0,
+        right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: state.busy ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.steer(), children: "Steer" }),
+          /* @__PURE__ */ jsx(TextButton, { onClick: () => controller.cancel(), children: "Stop" })
+        ] }) : (
+          // `disabled` derives from the SAME predicate `submit()` enforces, so an enabled
+          // button can never be a button that refuses.
+          /* @__PURE__ */ jsx(TextButton, { disabled: !state.canSubmit, onClick: () => controller.submit(), children: "Send" })
+        ) })
+      }
+    )
+  ] });
+}
+function ErrorPane({ message }) {
+  return /* @__PURE__ */ jsx(EmptyState, { title: "Not connected", hint: message ?? "The agent host reported a failure." });
+}
+
+// src/agent/agent/panel.ts
+var CONNECTIONS = ["idle", "connecting", "ready", "failed"];
+function createAgentPanel(options = {}) {
+  return {
+    manifest: agentManifest,
+    activate(host) {
+      const initial = host.config ?? {};
+      const controller = new AgentController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        now: options.now
+      });
+      const resolve = (config) => ({
+        submitOnEnter: configBool(config, "submitOnEnter", true),
+        showLane: configBool(config, "showLane", true),
+        showSessions: configBool(config, "showSessions", true),
+        emptyHint: configString(config, "emptyHint", "Start a session to talk to an agent.")
+      });
+      let renderConfig = resolve(initial);
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot(el);
+        root.render(createElement(AgentPanelView, { controller, ...renderConfig }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig(host, (config) => {
+        renderConfig = resolve(config);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          switch (portId) {
+            case "session": {
+              if (!isRecord(value)) return;
+              if (value.events !== void 0 && !Array.isArray(value.events)) return;
+              if (value.replace !== void 0 && !Array.isArray(value.replace)) return;
+              controller.ingest(value);
+              return;
+            }
+            case "catalog": {
+              if (!isRecord(value) || !Array.isArray(value.providers)) return;
+              controller.setCatalog(value);
+              return;
+            }
+            case "status": {
+              if (!isRecord(value)) return;
+              const status = value.status;
+              if (typeof status !== "string" || !CONNECTIONS.includes(status)) return;
+              controller.setStatus(
+                status,
+                typeof value.message === "string" ? value.message : void 0
+              );
+              return;
+            }
+            // The four return paths. Each guards inside the controller and DROPS an answer it
+            // cannot correlate — a decision routed to a guessed session applies a human's approval
+            // to work they never saw.
+            case "decision":
+            case "result":
+              controller.answer(value);
+              return;
+            case "diffDecision":
+              controller.patchDecision(value);
+              return;
+            case "runAction":
+              controller.runAction(value);
+              return;
+            case "terminalIntent":
+              controller.terminalIntent(value);
+              return;
+            default:
+              return;
+          }
+        },
+        async onCommand(commandId, params) {
+          const state = controller.getState();
+          switch (commandId) {
+            case "get_sessions": {
+              return {
+                connection: state.connection,
+                count: state.sessions.length,
+                sessions: state.sessions.map((session) => ({
+                  id: session.id,
+                  title: session.title ?? null,
+                  providerId: session.providerId ?? null,
+                  lane: session.lane ?? null,
+                  turn: session.turn ?? "idle",
+                  active: session.id === state.active?.id
+                }))
+              };
+            }
+            case "get_status": {
+              return {
+                connection: state.connection,
+                message: state.message,
+                activeSessionId: state.active?.id ?? null,
+                turn: state.turn,
+                busy: state.busy,
+                pendingAsks: state.pendingAsks,
+                // Surfaced rather than swallowed: a mis-wired return path and a dead one look
+                // identical from the outside, and this is the one number that tells them apart.
+                droppedAnswers: controller.droppedAnswers
+              };
+            }
+            case "select_session": {
+              if (typeof params.sessionId !== "string") return null;
+              controller.selectSession(params.sessionId);
+              return controller.getState().active?.id ?? null;
+            }
+            case "cancel_turn": {
+              return controller.cancel();
+            }
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var agentPanel = createAgentPanel();
+
+// src/agent/agent/wiring.ts
+var AGENT_WIRING_TARGETS = {
+  RUNS: "xeno.core.runs",
+  CONSOLE: "xeno.core.console",
+  CONSENT: "xeno.core.consent",
+  DIFF: "xeno.core.diff",
+  TERMINAL: "xeno.core.terminal"
+};
+var AGENT = AGENT_PANEL_ID;
+var { RUNS, CONSOLE, CONSENT, DIFF, TERMINAL } = AGENT_WIRING_TARGETS;
+var AGENT_PANEL_WIRING = Object.freeze([
+  // ── The tool timeline ──────────────────────────────────────────────────
+  {
+    from: { panel: AGENT, port: "runs" },
+    to: { panel: RUNS, port: "runs" },
+    why: "Turns become runs and tool calls become nested steps. Without it there is no timeline at all \u2014 the panel that can render a subagent three levels down never receives one.",
+    optional: true
+  },
+  {
+    from: { panel: RUNS, port: "action" },
+    to: { panel: AGENT, port: "runAction" },
+    why: "Cancel and Retry on a run or one of its steps. Without it those buttons emit into nothing and read as a broken agent rather than a missing wire.",
+    optional: true
+  },
+  // ── The transcript ─────────────────────────────────────────────────────
+  {
+    from: { panel: AGENT, port: "records" },
+    to: { panel: CONSOLE, port: "records" },
+    why: "The conversation itself, streamed by update-by-id. Without it the agent replies into nothing visible.",
+    optional: true
+  },
+  // ── Permissions and questions ──────────────────────────────────────────
+  {
+    from: { panel: AGENT, port: "elicitations" },
+    to: { panel: CONSENT, port: "elicitations" },
+    why: "Every permission the agent needs, and every question it asks. Without it a turn that stops on a grant looks like a hung agent.",
+    optional: true
+  },
+  {
+    from: { panel: AGENT, port: "withdraw" },
+    to: { panel: CONSENT, port: "withdraw" },
+    why: "An ask the agent no longer needs. Without it the queue keeps a question nobody is waiting on, in front of the ones that matter.",
+    optional: true
+  },
+  {
+    from: { panel: CONSENT, port: "decision" },
+    to: { panel: AGENT, port: "decision" },
+    why: "Permission answers. \u{1F534} Without it the agent never learns it was allowed, and the user watches an Allow they already pressed change nothing.",
+    optional: true
+  },
+  {
+    from: { panel: CONSENT, port: "result" },
+    to: { panel: AGENT, port: "result" },
+    why: "Text, path and choice answers. A SECOND port because a permission and an answer partition \u2014 wiring only `decision` silently drops every question the agent asked.",
+    optional: true
+  },
+  // ── Review ─────────────────────────────────────────────────────────────
+  {
+    from: { panel: AGENT, port: "diffModel" },
+    to: { panel: DIFF, port: "model" },
+    why: "Proposed edits, parsed from unified diff here because the diff panel ships no engine by charter.",
+    optional: true
+  },
+  {
+    from: { panel: DIFF, port: "decision" },
+    to: { panel: AGENT, port: "diffDecision" },
+    why: "Accept and reject, correlated back to the change set that produced them. \u26A0\uFE0F Only meaningful with the diff panel\u2019s `review` config on; it is off by default.",
+    optional: true
+  },
+  // ── The terminal ───────────────────────────────────────────────────────
+  {
+    from: { panel: AGENT, port: "terminalSession" },
+    to: { panel: TERMINAL, port: "session" },
+    why: "Instance lifecycle. Must be wired for `terminalData` to land anywhere \u2014 the panel drops a write for an instance it has not been told about.",
+    optional: true
+  },
+  {
+    from: { panel: AGENT, port: "terminalData" },
+    to: { panel: TERMINAL, port: "data" },
+    why: "The agent\u2019s PTY output, escape sequences intact.",
+    optional: true
+  },
+  {
+    from: { panel: TERMINAL, port: "intent" },
+    to: { panel: AGENT, port: "terminalIntent" },
+    why: "What the HUMAN types, plus resize and stop. Without it the terminal renders and swallows every keystroke.",
+    optional: true
+  }
+]);
+function wiringFor(panelId) {
+  return AGENT_PANEL_WIRING.filter((w) => w.from.panel === panelId || w.to.panel === panelId);
+}
+export {
+  AGENT_CATALOG_SCHEMA,
+  AGENT_FANOUT_PORTS,
+  AGENT_INTENT_SCHEMA,
+  AGENT_PANEL_ID,
+  AGENT_PANEL_WIRING,
+  AGENT_SESSION_SCHEMA,
+  AGENT_WIRING_TARGETS,
+  AgentController,
+  AgentPanelView,
+  AgentProjector,
+  CONSENT_ELICITATION_RESULT_SCHEMA,
+  CONSENT_ELICITATION_SCHEMA,
+  agentManifest,
+  agentPanel,
+  countChanges,
+  createAgentPanel,
+  isBusy,
+  isWaitingOnUser,
+  parseUnifiedDiff,
+  turnStatusToRunStatus,
+  wiringFor
+};