@staix/agent-hub 0.12.32 → 0.12.34

package/src/hub/tasks.ts

@@ -18,12 +18,12 @@ import { CLASSES, OUTCOMES_KEPT_MS, ALL_PLAN_KEYS, TASK_MOVE_REASONS, taskHasSta
 import type { Bus } from "./bus.ts";
 import { HUB, newEnvelope, NOTE_KINDS, noteLine, sanitize, USER, type Envelope, type PeerId, type PeerState } from "./envelope.ts";
 import type { PiiVerdict, ScreenItem, ScreenRecord } from "./inference.ts";
-import { assign, detectSignals, LOCAL, peerEntry, PI, predictSplit, type Assignment, type PeerCapabilities, type Routing, type SplitObservation, type SplitPrediction } from "./routing.ts";
+import { assign, detectSignals, peerEntry, predictSplit, relayCandidates, type Assignment, type PeerCapabilities, type Routing, type SplitObservation, type SplitPrediction } from "./routing.ts";
 import { ExecutionBudget, type ExecutionBudgetConfig, type ExecutionBudgetDecision, type ExecutionBudgetStatus, type ExecutionUnit } from "./execution-budget.ts";
 import { Cohorts, MAX_REQUESTS, type Cohort, type Completion } from "./cohorts.ts";
 import { realPath } from "./project.ts";
 import { PreEffectToolRefusal } from "./tool-refusal.ts";
-import { SUPPORTED_PEERS } from "./peer-catalog.ts";
+import { ADAPTERS, definitionOf } from "../adapters/registry.ts";
 import { nextSweep, taskSweepConfig, type TaskSweepConfig, type SweepRecord } from "./task-sweep.ts";
 import { readSdlcPr, sdlcConfig, sdlcReceipt, sdlcStatus, stageDefinition, lifecycleStage, type SdlcConfig, sdlcGh, type SdlcGh, type SdlcStatus } from "./sdlc.ts";
 
@@ -125,9 +125,12 @@ export interface TasksDeps {
   sweep?: TaskSweepConfig;
   /** Shutdown or coordinator work holds task sweeps too. */
   sweepHeld?: () => boolean;
+  /** Consecutive changes_requested verdicts that move a task to another peer (`tasks.escalate_after`, #488). */
+  escalateAfter?: () => number;
 }
 
-const ESCALATE_AFTER = 2;
+/** The `tasks.escalate_after` default (#488): the third consecutive changes_requested escalates. */
+export const ESCALATE_AFTER = 3;
 // Demotion (issue #36): a failure counts half after a day. A peer is demoted for a class once its decayed failures
 // reach 1.5 (two within about half a day, three within two days) and outweigh its decayed successes there.
 // ponytail: fixed constants; make them config when someone needs to tune them.
@@ -509,7 +512,7 @@ export class Tasks {
   private health() {
     const failing = this.d.failing?.();
     const held = this.d.held?.();
-    return { ...(this.d.capabilities ? { capabilities: this.d.capabilities(), repository: this.d.repository } : {}), pullOnly: [...this.d.bus.peers.values()].filter(peer => peer.id === "kimi" && peer.pullOnly).map(peer => peer.id), offRoster: SUPPORTED_PEERS.filter(peer => !this.d.bus.isRostered(peer)), ...(failing ? { failing } : {}), ...(held ? { held } : {}), ...(this.d.roles ? { roles: this.d.roles } : {}) };
+    return { ...(this.d.capabilities ? { capabilities: this.d.capabilities(), repository: this.d.repository } : {}), pullOnly: [...this.d.bus.peers.values()].filter(peer => definitionOf(peer.id)?.attach?.pullOnlyForms?.length && peer.pullOnly).map(peer => peer.id), offRoster: ADAPTERS.map(adapter => adapter.kind).filter(peer => !this.d.bus.isRostered(peer)), ...(failing ? { failing } : {}), ...(held ? { held } : {}), ...(this.d.roles ? { roles: this.d.roles } : {}) };
   }
 
   /** Capability admission precedes explicit assignments/reservations, independent of readiness or transient peer health. */
@@ -799,7 +802,7 @@ export class Tasks {
       if (by !== USER && Object.hasOwn(patch, "reserved") && this.hasPersonReservation(task)) throw new PreEffectToolRefusal("a person's reservation is retained");
       if (Object.hasOwn(patch, "deps") || Object.hasOwn(patch, "reserved")) {
         if (task.state !== "backlog" || taskHasStarted(task) || task.owner) throw new PreEffectToolRefusal("dependency and reservation changes require unstarted backlog work");
-        if (patch.reserved && !(SUPPORTED_PEERS as readonly string[]).includes(patch.reserved) && !this.d.bus.knownPeers().includes(patch.reserved) && !this.d.routing().classes[task.class]?.peers.includes(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is not a supported or configured peer");
+        if (patch.reserved && !definitionOf(patch.reserved) && !this.d.bus.knownPeers().includes(patch.reserved) && !this.d.routing().classes[task.class]?.peers.includes(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is not a supported or configured peer");
         if (patch.reserved && !this.d.bus.isRostered(patch.reserved)) throw new PreEffectToolRefusal("reserved owner is off roster");
         if (patch.reserved) this.requireCapabilities(task, patch.reserved);
         const rows = new Map(this.d.board.list().map(row => [row.id, row]));
@@ -1596,7 +1599,7 @@ export class Tasks {
     const pii = this.isPii(task), delivery = { ...a, reviewer: task.reviewer ?? undefined };
     const rejected = task.history.filter((h) => h.event === "changes_requested").map((h) => `- ${h.by}: ${this.screen(task, h.note ?? "", "review note", delivery.owner, h.withheld)}`);
     const handoff = context && !pii ? this.screen(task, context, "handoff", delivery.owner, contextWithheld).slice(0, 3000) : "";
-    const facts = [`class ${profileTaskLabel(task)}`, delivery.owner === PI ? `backend pi/${delivery.piBackend ?? "dgx"}` : "", task.refs.paths?.length ? `paths ${task.refs.paths.join(", ")}` : "", task.refs.branch ? `branch ${task.refs.branch}` : "", delivery.reviewer ? `reviewer ${delivery.reviewer}` : task.class === "review" ? "no reviewer" : this.noReviewer(delivery)].filter(Boolean).join("; ");
+    const facts = [`class ${profileTaskLabel(task)}`, delivery.owner && definitionOf(delivery.owner)?.routing?.backendLabel ? `backend ${definitionOf(delivery.owner)!.routing!.backendLabel}/${delivery.piBackend ?? "dgx"}` : "", task.refs.paths?.length ? `paths ${task.refs.paths.join(", ")}` : "", task.refs.branch ? `branch ${task.refs.branch}` : "", delivery.reviewer ? `reviewer ${delivery.reviewer}` : task.class === "review" ? "no reviewer" : this.noReviewer(delivery)].filter(Boolean).join("; ");
     const plan = planText(task.plan);
     const body = [
       `Task #${task.id} [${profileTaskLabel(task)}] ${task.title}`,
@@ -2338,7 +2341,7 @@ export class Tasks {
     if (rejected.owner) this.d.board.recordOutcome(rejected.owner, rejected.class, false);
     this.contradict(rejected);
     this.note(rejected, by, "decision", `Task #${rejected.id} changes requested by ${by}: ${rejected.title}\n${note ?? ""}`, withheld);
-    if (rejected.rejections >= ESCALATE_AFTER) {
+    if (rejected.rejections >= (this.d.escalateAfter?.() ?? ESCALATE_AFTER)) {
       let moved: Task;
       try {
         moved = await this.escalate(HUB, rejected.id, `${rejected.rejections} consecutive changes_requested`, "rejections");
@@ -2415,7 +2418,7 @@ export class Tasks {
       const acceptance = previous.history.slice(assignment + 1).some(entry => entry.event === "accepted" && entry.by === peer);
       const boardEvidence = role === "owner" && acceptance;
       const mayHaveReceived = boardEvidence || this.d.bus.lastDeliveredTo(peer).some(matches) || this.d.bus.queueList(peer).some(row => ["dispatching", "accepted", "needs_review", "completed"].includes(row.state) && row.originals.some(matches));
-      for (const env of this.d.bus.snapshot(false).queues[peer] ?? []) if (matches(env)) this.d.bus.withdraw(env.id);
+      for (const env of this.d.bus.pendingEnvelopes(peer)) if (matches(env)) this.d.bus.withdraw(env.id);
       if (!mayHaveReceived) return;
       const body = role === "owner"
         ? `Task ${this.publicTitle(next)} is no longer assigned to you${next.owner ? `; its owner is now ${next.owner}` : "; it is unassigned"}. Do not accept or complete it; late calls under your former assignment are refused.`
@@ -2494,7 +2497,7 @@ export class Tasks {
       const owner = task.owner === peer;
       const weights = this.weights(task.class);
       const pii = this.isPii(task);
-      const candidates = owner ? [pii ? LOCAL : PI, pii ? undefined : LOCAL, ...(routing.classes[task.class]?.peers ?? []).filter(p => p !== LOCAL && p !== PI)].filter((p): p is PeerId => !!p) : [];
+      const candidates = owner ? relayCandidates(routing.classes[task.class]?.peers ?? [], pii) : [];
       const a = assign(task, this.states(), routing, { ...weights, offRoster: [...(weights.offRoster ?? []), peer], exclude: [peer], excludeOwners: owner && this.plannerPullRecord(task)?.pull ? this.plannerFull(task) : [], candidates, ...(owner ? { waitsFor: this.waitsFor(task) } : task.owner ? { notReviewer: task.owner } : {}) });
       return { id: task.id, title: this.publicTitle(task), role: owner ? "owner" : "reviewer", to: (owner ? a.owner : a.reviewer) ?? null };
     });
@@ -2515,7 +2518,7 @@ export class Tasks {
       if (urgentOnly && !task.signals.includes("urgent")) continue;
       if (task.owner === peer && (OPEN.includes(task.state) || roster && task.state === "in_review")) {
         const pii = this.isPii(task);
-        const candidates = [pii ? LOCAL : PI, pii ? undefined : LOCAL, ...(routing.classes[task.class]?.peers ?? []).filter((p) => p !== LOCAL && p !== PI)].filter((p): p is PeerId => !!p);
+        const candidates = relayCandidates(routing.classes[task.class]?.peers ?? [], pii);
         if (this.plannerPullRecord(task)?.pull && !assign(task, this.states(), routing, { candidates, exclude: [...this.excluded(task), peer], excludeOwners: this.plannerFull(task), waitsFor: this.waitsFor(task), ...this.weights(task.class) }).owner) continue;
         // Budget keeps its original release/unassign behaviour for ordinary work. Roster changes the state in
         // assignOwner's same owner write only after routing has found somebody to take it.
@@ -2735,4 +2738,4 @@ export class Tasks {
   }
 }
 
-export { LOCAL };
+export { LOCAL } from "./routing.ts";

package/src/hub/tooling.ts

@@ -1,7 +1,8 @@
+import { definitionOf } from "../adapters/registry.ts";
 import { spawn, type ChildProcess } from "node:child_process";
-import { accessSync, closeSync, constants, fstatSync, openSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { accessSync, constants, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, join, relative, resolve, isAbsolute } from "node:path";
+import { delimiter, relative, resolve, isAbsolute } from "node:path";
 import { realPath } from "./project.ts";
 
 /**
@@ -15,11 +16,6 @@ export const ADDONS = ["claude-mem", "ponytail", "ripwire", "open-code-review",
 export type AddonName = (typeof ADDONS)[number];
 export interface Addon { name: AddonName; version: string | null }
 
-/** Plugin names (before the `@marketplace`) that stand for an add-on. */
-// Maps, not objects: a plugin named `constructor` or `toString` must find nothing, not an inherited property.
-const PLUGINS = new Map<string, AddonName>([["claude-mem", "claude-mem"], ["ponytail", "ponytail"], ["open-code-review", "open-code-review"]]);
-/** Claude Code only: the Codex plugin is a Claude plugin named `codex` from the `openai-codex` marketplace. */
-const CLAUDE_ONLY = new Map<string, AddonName>([["codex@openai-codex", "codex-plugin"]]);
 /**
  * Executables any peer with a shell can run, and how each is told apart from another program of the same name: the
  * first one on PATH is asked for its version (bounded, no stdin), so Graphviz's `dot` is never resource admission.
@@ -32,60 +28,9 @@ const PROBE_MS = 2000, PROBE_BYTES = 4096;
 /** `env` supplies CLAUDE_CONFIG_DIR and CODEX_HOME, the runtimes' own config roots (the hub's environment by default). */
 export interface ToolingSources { home?: string; cwd?: string; path?: string; env?: Record<string, string | undefined> }
 
-/** A regular file of at most 1 MiB, opened without blocking: a FIFO or device under a project's `.claude/` reads as absent. */
-const text = (file: string): string | undefined => {
-  let fd: number | undefined;
-  try {
-    fd = openSync(file, constants.O_RDONLY | constants.O_NONBLOCK);
-    const st = fstatSync(fd);
-    if (!st.isFile() || st.size > 1024 * 1024) return undefined;
-    return readFileSync(fd, "utf8");
-  } catch { return undefined; } finally { if (fd !== undefined) closeSync(fd); }
-};
-const json = (file: string): Record<string, unknown> | undefined => {
-  try { const v = JSON.parse(text(file) ?? ""); return v && typeof v === "object" ? v as Record<string, unknown> : undefined; } catch { return undefined; }
-};
 /** A version string as data, never anything longer or stranger. */
 const version = (v: unknown): string | null => typeof v === "string" && /^[0-9A-Za-z.+_-]{1,40}$/.test(v) ? v : null;
 
-function claudePlugins(root: string, cwd: string | undefined): Addon[] {
-  const enabled = new Map<string, boolean>();
-  for (const file of [join(root, "settings.json"), ...(cwd ? [join(cwd, ".claude", "settings.json"), join(cwd, ".claude", "settings.local.json")] : [])]) {
-    const map = json(file)?.enabledPlugins;
-    if (map && typeof map === "object") for (const [key, on] of Object.entries(map)) enabled.set(key, on === true);
-  }
-  const installed = (json(join(root, "plugins", "installed_plugins.json"))?.plugins ?? {}) as Record<string, { scope?: string; projectPath?: string; version?: unknown }[]>;
-  const out: Addon[] = [];
-  for (const [key, on] of enabled) {
-    if (!on) continue;
-    const name = CLAUDE_ONLY.get(key) ?? PLUGINS.get(key.split("@")[0]!);
-    const entries = Array.isArray(installed[key]) ? installed[key]! : [];
-    // An install for another project is not this one's.
-    const entry = entries.find((e) => e?.scope === "user") ?? entries.find((e) => e?.projectPath === cwd);
-    if (name && entry) out.push({ name, version: version(entry.version) });
-  }
-  return out;
-}
-
-function codexPlugins(root: string): Addon[] {
-  const config = text(join(root, "config.toml"));
-  if (config === undefined) return [];
-  const found = new Map<string, string>(), disabled = new Set<string>(); // plugin name -> marketplace
-  // `[plugins."name@market"]` with no `enabled = false` below it, and plugins whose hooks Codex was told to trust
-  // unless their plugin entry disables them: a trust entry outlives the plugin's own switch.
-  for (const m of config.matchAll(/^\[plugins\."([^"@]+)@([^"]+)"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/gm)) if (!/^\s*enabled\s*=\s*false\b/m.test(m[3] ?? "")) found.set(m[1]!, m[2]!); else disabled.add(m[1]! + "@" + m[2]!);
-  for (const m of config.matchAll(/^\[hooks\.state\."([^"@]+)@([^":]+):/gm)) if (!disabled.has(m[1]! + "@" + m[2]!)) found.set(m[1]!, m[2]!);
-  const out: Addon[] = [];
-  for (const [plugin, market] of found) {
-    const name = PLUGINS.get(plugin);
-    if (!name) continue;
-    let versions: string[] = [];
-    try { versions = readdirSync(join(root, "plugins", "cache", market, plugin)); } catch { /* no cache: version unknown */ }
-    out.push({ name, version: versions.length === 1 ? version(versions[0]) : null });
-  }
-  return out;
-}
-
 /** Never throws: a path that cannot be resolved (a project directory that went away) is compared as given. */
 const real = (path: string): string => { try { return realPath(path); } catch { return resolve(path); } };
 const within = (file: string, dir: string): boolean => { const r = relative(dir, file); return r === "" || (!r.startsWith("..") && !isAbsolute(r)); };
@@ -145,8 +90,7 @@ export async function detectTooling(peer: string, src: ToolingSources = {}): Pro
   const found = new Map<AddonName, Addon>();
   const add = (a: Addon) => { if (!found.has(a.name) || (found.get(a.name)!.version === null && a.version !== null)) found.set(a.name, a); };
   const env = src.env ?? process.env;
-  if (peer === "claude") claudePlugins(env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude"), src.cwd).forEach(add);
-  if (peer === "codex") codexPlugins(env.CODEX_HOME?.trim() || join(home, ".codex")).forEach(add);
+  definitionOf(peer)?.hooks?.pluginInventory?.({ env, home, cwd: src.cwd }).forEach(add);
   const path = src.path ?? process.env.PATH ?? "";
   for (const [bin, spec] of Object.entries(BINARIES)) {
     const file = onPath(bin, path, src.cwd ?? process.cwd());

package/src/hub/ui.ts

@@ -5,6 +5,7 @@ import { PEER_PALETTE, peerPaletteCss } from "../ui/peer-palette.ts";
 import { PEER_START_RETRY_MS } from "./start-mode.ts";
 import { taskProgress } from "../ui/task-progress.ts";
 import { officeModel } from "../ui/office-model.ts";
+import { OFFICE_PEER_ORDER, ADAPTER_DISPLAY } from "../adapters/registry.ts";
 import { needs } from "../ui/needs.ts";
 import { createHash, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
@@ -35,10 +36,11 @@ export function startDashboard(options: DashboardOptions) {
   // Inject the same pure public-board model used by the console before computing CSP hashes.
   const html = readFileSync(new URL("../ui/index.html", import.meta.url), "utf8")
     .replace("/* BOARD_MODEL */", () => `const boardColumns = ${boardColumns.toString()}; const peerPalette = ${JSON.stringify(PEER_PALETTE)};`)
+    .replace("/* ADAPTER_DISPLAY */", () => `const adapterDisplay = ${JSON.stringify(ADAPTER_DISPLAY)};`)
     .replace("/* PEER_PALETTE_CSS */", () => peerPaletteCss())
     .replace("/* TASK_PROGRESS_MODEL */", () => `const taskProgress = ${taskProgress.toString()};`)
     .replace("/* PEER_START_RETRY_MS */", () => `const PEER_START_RETRY_MS = ${PEER_START_RETRY_MS};`)
-    .replace("/* OFFICE_MODEL */", () => `const officeModel = ${officeModel.toString()};`)
+    .replace("/* OFFICE_MODEL */", () => `const officeModel = ((OFFICE_PEER_ORDER) => ${officeModel.toString()})(${JSON.stringify(OFFICE_PEER_ORDER)});`)
     .replace("/* NEEDS_MODEL */", () => `const needs = ${needs.toString()};`);
   const hashes = (tag: string) => [...html.matchAll(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "g"))]
     .map((m) => `'sha256-${createHash("sha256").update(m[1]!).digest("base64")}'`).join(" ");

package/src/memory/recall.ts

@@ -1,10 +1,8 @@
+import { ADAPTERS, definitionOf } from "../adapters/registry.ts";
 import type { PeerId } from "../hub/envelope.ts";
 import type { MemoryClient } from "./client.ts";
 import type { View as MemoryView } from "@staix/agent-mem";
 
-const PLATFORMS = ["claude", "codex", "kimi", "agent-hub"];
-/** Peers whose own hooks already inject their own platform's context at session start. */
-const OWN_PLATFORM: Record<PeerId, string> = { claude: "claude", codex: "codex" };
 
 const HEADER =
   "Shared project memory (claude-mem): recent work by the agents in this project. Reference only, not a request. " +
@@ -26,11 +24,12 @@ const hasContext = (text: string | undefined): text is string => !!text && text.
 const entries = (text: string) => text.slice(Math.max(text.indexOf("\n### "), 0)).trim();
 
 export async function recallFor(peer: PeerId, client: MemoryClient, chain: string[], tokens: number): Promise<string | undefined> {
-  const own = OWN_PLATFORM[peer];
+  const hooks = definitionOf(peer)?.hooks;
+  const own = hooks?.recallInjected ? hooks.recallPlatform : undefined;
   // Everyone else gets all platforms in one call; claude and codex get the other platforms only.
   const blocks = own
     ? await Promise.all(
-        PLATFORMS.filter((p) => p !== own).map(async (p) => {
+        [...ADAPTERS.flatMap(adapter => adapter.hooks?.recallSource ? [adapter.hooks.recallSource] : []), "agent-hub"].filter((p) => p !== own).map(async (p) => {
           const text = await client.contextInject(chain, p);
           return hasContext(text) ? `## from ${p} sessions\n${entries(text)}` : undefined;
         }),

package/src/models/route/signals.ts

@@ -3,6 +3,7 @@
 // Ported to TypeScript from NVIDIA NeMo Switchyard crates/libsy/src/algorithms/util/tool_signals.rs at c8848511, modified.
 
 import type { Conversation, NormalizedToolCall } from './normalize.ts';
+import { definitionOf } from '../../adapters/registry.ts';
 
 export const DEFAULT_RECENT_WINDOW = 3;
 export const SOFT = 0.3;
@@ -133,7 +134,8 @@ function shellClassification(command: string): Semantic {
 function semantic(name: string, command?: string, source?: string): Semantic {
   if (source?.toLowerCase() === 'filechange') return 'edit';
   const lower = name.toLowerCase();
-  if (source === 'codex' && lower === 'filechange') return 'edit';
+  const native = source === undefined ? undefined : definitionOf(source)?.hooks?.classifyTool?.(name, command);
+  if (native !== undefined) return native;
   if (WRITE.has(lower)) return 'write';
   if (EDITOR.has(lower) && command === 'view') return 'read';
   if (EDIT.has(lower)) return 'edit';

package/src/pi/launch.ts

@@ -1,3 +1,4 @@
+import { ADAPTERS } from "../adapters/registry.ts";
 import { join } from "node:path";
 import { peerChildEnv } from "../hub/child-process.ts";
 import type { PiOptions, PiModelDescriptor, PiTuiLaunch } from "../adapters/pi.ts";
@@ -16,6 +17,6 @@ export function buildPiLaunch(opts: Pick<PiOptions, "stateDir" | "cmd" | "mode"
   const env: NodeJS.ProcessEnv = { ...peerChildEnv("pi", inherited), PI_CODING_AGENT_DIR: join(opts.stateDir, "pi"), AGENTHUB_PI_BRIDGE_URL: `http://127.0.0.1:${bridgePort}`, AGENTHUB_PI_BRIDGE_TOKEN: bridgeToken, AGENTHUB_PI_OWNER_TOKEN: bridgeToken, AGENTHUB_PI_RELAY_URL: opts.relay.url, AGENTHUB_PI_RELAY_TOKEN: opts.relay.token, AGENTHUB_PI_MODELS: JSON.stringify(opts.relay.models), AGENTHUB_PI_TOOLS: JSON.stringify(opts.tools), AGENTHUB_PI_MAX_STEPS: String(opts.maxSteps ?? 30) };
   const args = [ ...(opts.mode === "headless" ? ["--mode", "rpc"] : []), "--provider", "agent-hub-local", "--model", opts.model ?? modelFor(opts.backend, opts.relay.models), "--models", opts.relay.models.map((model) => `agent-hub-local/${model.id}`).join(","), "--no-builtin-tools", "--no-skills", "--no-prompt-templates", "--no-extensions", "--extension", extension, ...(opts.preamble ? ["--append-system-prompt", opts.preamble] : []), "--session-dir", join(opts.stateDir, "pi-sessions")];
   if (opts.sessionFile) args.push("--session", opts.sessionFile); else if (opts.sessionId) args.push("--session-id", opts.sessionId);
-  const command = opts.cmd ?? ["pi"];
+  const command = opts.cmd ?? [ADAPTERS.find(adapter => adapter.start.daemonPort === "pi-rpc")!.cli.command];
   return { cmd: command[0]!, args: [...command.slice(1), ...args], env };
 }

package/src/ui/index.html

@@ -72,6 +72,7 @@ const dashboardTheme = (() => {
 /* TASK_PROGRESS_MODEL */
 /* PEER_START_RETRY_MS */
 /* BOARD_MODEL */
+/* ADAPTER_DISPLAY */
 /* NEEDS_MODEL */
 /* OFFICE_MODEL */
 const officeView = (() => {
@@ -284,7 +285,7 @@ function renderTaskStage(stage) {
   row.append(el('span', ` / Stage ${stage.stage}/4: ${stage.label}`)); return row;
 }
 function renderApprovals(permissions) {
-  const terminalWaiting = permissions.filter((permission) => permission.peer === 'pi' || permission.peer === 'local').length;
+  const terminalWaiting = permissions.filter((permission) => adapterDisplay[permission.peer]?.terminalApproval).length;
   $('permission-count').textContent = permissions.length + ' waiting' + (terminalWaiting ? ', ' + terminalWaiting + ' Pi/local: answer in the console or ahub tail / ahub permit' : '');
   update('permissions', permissions, (target) => {
     if (!permissions.length) return empty(target, 'No approvals waiting.');
@@ -783,7 +784,7 @@ function render(snapshot) {
       if (peer.attached === false) row.append(el('p', 'Disconnected recipient; work is retained.', 'meta'));
       if (peer.toolsOnly) row.append(el('p', peer.toolsOnly, 'meta'));
       if (peer.permissionNote) row.append(el('p', peer.permissionNote, 'meta'));
-      if (peer.pullOnly && id === 'kimi') row.append(el('p', 'Last hub_inbox read: ' + (typeof peer.lastInboxAt === 'number' ? Math.max(0, Math.floor((Date.now() - peer.lastInboxAt) / 1000)) + 's ago' : 'never'), 'meta'));
+      if (peer.pullOnly && adapterDisplay[id]?.pullOnlyRead) row.append(el('p', 'Last hub_inbox read: ' + (typeof peer.lastInboxAt === 'number' ? Math.max(0, Math.floor((Date.now() - peer.lastInboxAt) / 1000)) + 's ago' : 'never'), 'meta'));
       if (peer.paused) row.append(el('p', peer.paused, 'meta'));
       if (peer.requestedModel) row.append(el('p', 'Requested: ' + peer.requestedModel, 'meta'));
       for (const backend of peer.backends || []) {

package/src/ui/office-model.ts

@@ -1,3 +1,5 @@
+import { OFFICE_PEER_ORDER } from "../adapters/registry.ts";
+
 /**
  * Pure office scene model for the dashboard (#264, phase 1: the static Flat view).
  * Self-contained so `src/hub/ui.ts` injects it into the page by toString(), exactly like
@@ -178,7 +180,7 @@ export interface OfficeScene {
 }
 
 export function officeModel(snapshot: OfficeSnapshotInput, previous: OfficeScene | null, options: { cols?: number; now?: number }): OfficeScene {
-  const FIXED = ["claude", "codex", "kimi", "pi", "local"];
+  const FIXED = OFFICE_PEER_ORDER;
   const KNOWN = ["proposed", "in_progress", "in_review", "changes_requested", "approved", "cancelled"];
   const GLYPHS: Record<string, string> = { idle: "○", busy: "●", offline: "×", paused: "‖", waiting: "⚑", unknown: "?" };
   const LABELS: Record<string, string> = { idle: "idle", busy: "busy", offline: "offline", paused: "paused", waiting: "waiting on approval" };

package/src/ui/peer-palette.ts

@@ -1,12 +1,22 @@
+import { definitionOf, OFFICE_PEER_ORDER } from "../adapters/registry.ts";
+import type { NATIVE_DISPLAYS } from "../adapters/definitions/native-display.ts";
+
+type NativePalette = { [Kind in keyof typeof NATIVE_DISPLAYS]: {
+  tone: (typeof NATIVE_DISPLAYS)[Kind]["palette"]["tone"];
+  ansi: (typeof NATIVE_DISPLAYS)[Kind]["palette"]["ansi"];
+  css: (typeof NATIVE_DISPLAYS)[Kind]["palette"]["fg"];
+} };
+const other = { tone: "muted", ansi: "\x1b[90m", css: "#8a8f99" } as const;
+const nativePalette = Object.fromEntries(OFFICE_PEER_ORDER.map(kind => {
+  const palette = definitionOf(kind)!.display.palette;
+  return [kind, { tone: palette.tone ?? other.tone, ansi: palette.ansi ?? other.ansi, css: palette.fg }];
+})) as NativePalette;
+
 /** Stable peer identity colors shared by terminal board/status and the dashboard (#263). */
 export const PEER_PALETTE = Object.freeze({
-  claude: { tone: "peerClaude", ansi: "\x1b[94m", css: "#6495ed" },
-  codex: { tone: "peerCodex", ansi: "\x1b[96m", css: "#22b8cf" },
-  kimi: { tone: "taskKeyword", ansi: "\x1b[35m", css: "#bc73ca" },
-  pi: { tone: "attention", ansi: "\x1b[33m", css: "#c79936" },
-  local: { tone: "success", ansi: "\x1b[32m", css: "#4caa77" },
+  ...nativePalette,
   hub: { tone: "info", ansi: "\x1b[36m", css: "#489da8" },
-  other: { tone: "muted", ansi: "\x1b[90m", css: "#8a8f99" },
+  other,
 } as const);
 export function peerStyle(peer: string): (typeof PEER_PALETTE)[keyof typeof PEER_PALETTE] {
   return PEER_PALETTE[Object.hasOwn(PEER_PALETTE, peer) ? peer as keyof typeof PEER_PALETTE : "other"];

package/templates/routing.toml

@@ -46,8 +46,8 @@ target = "dsv4f"
 # confirmations = 2
 
 # L1: task assignment. `peers` is the preference order among attached, unpaused peers (idle before busy).
-# `route` / `fixed_model` apply when the task lands on the local worker. Two changes_requested in a row move the
-# task to the next attached peer in `escalate_to`.
+# `route` / `fixed_model` apply when the task lands on the local worker. `tasks.escalate_after` consecutive
+# changes_requested (default 3, in .agenthub/config.json) move the task to the next attached peer in `escalate_to`.
 
 [signals]
 pii_patterns = ["\\b\\d{6}-\\d{7}\\b"]   # Korean resident registration numbers; add your own, e.g. "@your-org\\.example" for staff mail addresses