@staix/agent-hub 0.12.33 → 0.12.35

package/src/hub/config-reload.ts

@@ -1,9 +1,11 @@
+import { ADAPTERS } from "../adapters/registry.ts";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { validateRawConfig, type ConfigLayer } from "./config-apply.ts";
 import { parseOverlay, parseRouting, type Routing } from "./routing.ts";
 import { CLASSES } from "./board.ts";
+import { validateInstances } from "./instances.ts";
 
 export const CONFIG_SOURCE_FILES = ["config.json", "config.local.json", "routing.toml", "routing.local.toml"] as const;
 export type ConfigSourceName = typeof CONFIG_SOURCE_FILES[number];
@@ -66,15 +68,19 @@ function validateRoutingRaw(value: unknown): void {
       const entry = table(item, `${key}.${name}`); text(entry[required], `${key}.${name}.${required}`); openValue(entry, `${key}.${name}`);
     }
   };
+  const nativeValidators = { bool, text, strings, argv: strings,
+    number: (min = 1, max = Number.MAX_SAFE_INTEGER, _integer = true) => (v: unknown, k: string) => numeric(v, k, min, max),
+    words: (values: readonly string[]) => (v: unknown, k: string) => choice(v, k, values),
+    block: (fields: Record<string, (v: unknown, k: string) => void>) => (v: unknown, k: string) => closed(v, k, fields),
+  };
   closed(value, "routing", {
-    local: (v, k) => closed(v, k, { route: text, fixed_model: text }),
+    ...Object.assign({}, ...ADAPTERS.map(adapter => adapter.configuration?.routingSchema?.(nativeValidators) ?? {})),
     targets: (v, k) => switchyard(v, k, "id"), routes: (v, k) => switchyard(v, k, "type"),
     // parseRouting delegates these tables to the existing parseHubRoutes validator.
     hub_routes: (v, k) => { table(v, k); },
     stay_switch: (v, k) => choice(v, k, ["off", "shadow", "enforce"]), max_switch_prefill_tokens: numeric,
     signals: (v, k) => closed(v, k, { pii_patterns: strings, long_context_tokens: numeric, pii_screen: (x, p) => choice(x, p, ["off", "local"]) }),
     constraints: (v, k) => closed(v, k, { pii: (x, p) => choice(x, p, ["local_only", "off"]), long_context: (x, p) => choice(x, p, ["skip_local", "off"]), budget_paused: (x, p) => choice(x, p, ["skip_peer", "off"]) }),
-    pi: (v, k) => closed(v, k, { dgx_max_context_tokens: numeric, mlx_max_context_tokens: numeric, efficient_wait_ms: (x, p) => numeric(x, p, 0, 119999) }),
     classes: (v, k) => { for (const [name, item] of Object.entries(table(v, k))) {
       if (!(CLASSES as readonly string[]).includes(name)) bad(`${k}.${name}`);
       closed(item, `${k}.${name}`, { peers, escalate_to: peers, route: text, fixed_model: text, local_allowed: bool, pi_backend: (x, p) => choice(x, p, ["dgx", "mlx"]) });
@@ -85,6 +91,15 @@ function validateRoutingRaw(value: unknown): void {
 /** Strict reloads never use routing's last-good fallback. Startup can retain its existing fallback explicitly. */
 export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: Routing): ConfigSources {
   const layers: ConfigLayer[] = [], trustLayers: ConfigSources["trustLayers"] = [];
+  let localRaw: Record<string, unknown> = {};
+  try { localRaw = JSON.parse(texts["config.local.json"] ?? "{}"); }
+  catch { if (!fallbackRouting) throw new Error(".agenthub/config.local.json: invalid JSON object"); }
+  let declared;
+  try { declared = validateInstances(localRaw?.instances); }
+  catch (error) {
+    if (!fallbackRouting) throw new Error(`.agenthub/config.local.json: ${(error as Error).message}`);
+    declared = validateInstances(undefined);
+  }
   for (const name of CONFIG_SOURCE_FILES) {
     const text = texts[name];
     if (text === null) continue;
@@ -99,7 +114,7 @@ export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: R
     }
     if (name === "config.json" || name === "config.local.json") {
       if (!fallbackRouting) {
-        try { validateRawConfig(raw); }
+        try { validateRawConfig(raw, declared); }
         catch (error) { throw new Error(`.agenthub/${name}: ${(error as Error).message}`); }
       }
       layers.push({ name, raw });

package/src/hub/config-trust.ts

@@ -29,7 +29,7 @@ export const MACHINE_LOCAL = [
   "terminal.open", // the command a hub-made TUI start runs to open a terminal (#269)
 ] as const;
 /** Legacy exported field list stays compatible; new policies use the complete list below. */
-export const ALL_MACHINE_LOCAL = [...MACHINE_LOCAL, "protect_instruction_files", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "text_projection"] as const;
+export const ALL_MACHINE_LOCAL = [...MACHINE_LOCAL, "protect_instruction_files", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "text_projection", "instances"] as const;
 
 /** A known repository, including an unreadable marker, must never be mistaken for a plain directory. */
 export function configRepositoryPresent(cwd: string): boolean {

package/src/hub/context-window.ts

@@ -1,3 +1,6 @@
+import { nonnegative, positive } from "../adapters/definitions/native-context.ts";
+export { claudeContext, codexContext, acpContext } from "../adapters/definitions/native-context.ts";
+
 /** Native active-context occupancy, separate from accumulated billable usage (#185). */
 export interface ContextReading {
   source: "claude_statusline" | "codex_token_usage" | "acp_usage_update";
@@ -17,33 +20,6 @@ export interface ContextView {
 }
 export interface ContextConfig { gate: number; stale_min: number }
 export const DEFAULT_CONTEXT: ContextConfig = { gate: 0, stale_min: 30 };
-const nonnegative = (n: unknown): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0;
-const positive = (n: unknown): n is number => nonnegative(n) && n > 0;
-const record = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === "object" && !Array.isArray(v);
-const object = (v: unknown): Record<string, unknown> => record(v) ? v : {};
-export function claudeContext(value: unknown, sessionId: string, measuredAt: number): ContextReading {
-  const c = object(value);
-  const current = object(c.current_usage);
-  const parts = [current.input_tokens, current.cache_creation_input_tokens, current.cache_read_input_tokens];
-  const window = positive(c.context_window_size) ? c.context_window_size : null;
-  const sum = c.current_usage != null && parts.every(nonnegative) ? parts.reduce<number>((sum, n) => sum + (n as number), 0) : null;
-  const tokens = nonnegative(sum) ? sum : null;
-  const used = record(c.current_usage) && tokens !== null && nonnegative(c.used_percentage) && c.used_percentage <= 100 && window !== null ? c.used_percentage / 100 : null;
-  return { source: "claude_statusline", sessionId, measuredAt, tokens, window, used };
-}
-export function codexContext(value: unknown, sessionId: string, measuredAt: number): ContextReading {
-  const c = object(value), last = object(c.last);
-  const window = positive(c.modelContextWindow) ? c.modelContextWindow : null;
-  const tokens = nonnegative(last.totalTokens) ? last.totalTokens : null;
-  return { source: "codex_token_usage", sessionId, measuredAt, tokens, window, used: tokens !== null && window !== null ? Math.min(1, tokens / window) : null };
-}
-/** An ACP `usage_update` of the `{ used, size }` shape (Kimi 2.x): context occupancy, not consumption (#167, #285). */
-export function acpContext(usage: { used: number; size: number }, sessionId: string, measuredAt: number): ContextReading {
-  const window = positive(usage.size) ? usage.size : null;
-  const tokens = nonnegative(usage.used) ? usage.used : null;
-  // If a report ever shows used > size, the fraction clamps so a bar renders; tokens keeps the reported number.
-  return { source: "acp_usage_update", sessionId, measuredAt, tokens, window, used: tokens !== null && window !== null ? Math.min(1, tokens / window) : null };
-}
 export const unknownContext = (): ContextView => ({ source: null, measuredAt: null, tokens: null, window: null, used: null, freshness: "unknown" });
 /** Invalid/stale readings hide the value but never rearm a threshold already crossed. */
 export class ContextWindows {

package/src/hub/control-client.ts

@@ -8,7 +8,7 @@ export function stateDirFor(cwd: string): string {
 
 /** Control WS wire version. 2 = `deliver` carries `envs` (digests); 3 = `tools` role and task messages; 4 = budget messages and `hub_checkpoint`; 5 = `ask`; 6 = console-only `ui` session bootstrap; 8 = controlled recovery; 9 = Pi bridge metadata; 10 = durable delivery receipts; 11 = queue hold diagnostics; 12 = generation-bound channel settlement and execution budgets; 13 = turn-free facts (`facts` with tool, session and transcript binding, `silenced`) and per-recipient send results (issue #108). 14 = native context-window status and session-bound context checkpoint request ids (issue #185). 15 = conductor tools and permission deadlines/closed events (issues #190, #194). 16 = a Claude session without channel evidence: hello `channel: false` and `inbox` (issue #205). The plugin is installed apart from the daemon, so they can drift. */
 export const PROTOCOL = 16;
-export const DAEMON_FEATURES = ["task_cancel", "recovery_deferred_hub"] as const;
+export const DAEMON_FEATURES = ["task_cancel", "recovery_deferred_hub", "peer_instances"] as const;
 /** Protocols a current coordinator may authenticate while upgrading a running source. */
 export const RECOVERY_SOURCE_PROTOCOLS = [9, 10, 11, 12, 13, 14, 15, PROTOCOL] as const;
 

package/src/hub/crash.ts

@@ -1,4 +1,4 @@
-import { definitionOf } from "../adapters/registry.ts";
+import { definitionOf, type KindMap } from "../adapters/registry.ts";
 import { chmodSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { JournalDelivery } from "./delivery-journal.ts";
@@ -56,50 +56,26 @@ const str = (v: unknown) => (typeof v === "string" && v ? v : undefined);
  * What can come back after a crash. `resume` holds the start arguments for peers the hub launches itself (Kimi through
  * ACP `session/load`, Pi through its session file, the local worker afresh); the others say what the user has to do.
  */
-export function crashPlan(records: SessionRecord[]): { peer: string; resume?: Record<string, string>; how: string; fresh?: Record<string, string>; tui?: true }[] {
+export function crashPlan(records: SessionRecord[], instances?: KindMap): { peer: string; resume?: Record<string, string>; how: string; fresh?: Record<string, string>; tui?: true }[] {
   return records.map(({ peer, meta }) => {
     const launch = (meta.launch && typeof meta.launch === "object" ? meta.launch : {}) as Record<string, unknown>;
     const model = str(launch.model);
-    const adapter = definitionOf(peer);
-    if (adapter?.transport === "acp" && adapter.start.create) {
+    const adapter = definitionOf(peer, instances);
+    const extra = adapter !== undefined && definitionOf(peer) === undefined;
+    const command = extra ? `ahub ${adapter.cli.command} --as ${peer}` : `ahub ${peer}`;
+    if (adapter?.session.resumeById) {
       const sessionId = adapter.session.crashIdentity?.(meta).sessionId;
-      if (!sessionId) return { peer, how: `${peer}: saved ACP session identity unavailable; start it deliberately with ahub ${peer}` };
+      if (!sessionId) return { peer, how: `${peer}: saved ACP session identity unavailable; start it deliberately with ${command}` };
       return { peer, resume: { sessionId, ...(model ? { model } : {}) }, how: `${peer}: the recorded conversation can be loaded again (ACP session/load)` };
     }
-    switch (peer) {
-      case "claude":
-        return { peer, how: "claude: the Claude Code plugin reconnects by itself while that session is still open" };
-      case "codex":
-        return { peer, how: `codex: its app-server died with the hub; run ahub codex again${str(meta.threadId) ? ` (its conversation was thread ${meta.threadId})` : ""}` };
-      case "jcode":
-        return { peer, how: "jcode: native 0.94.0 load does not prove the restored id; reopen the original conversation with its native client, no automatic fresh replacement" };
-      case "kimi": {
-        const sessionId = str(meta.sessionId);
-        if (!sessionId) return { peer, how: "kimi: no session id was recorded; start it again with ahub kimi" };
-        return { peer, resume: { sessionId, ...(model ? { model } : {}) }, how: `kimi: session ${sessionId} can be loaded again (ACP session/load)` };
-      }
-      case "pi": {
-        // `fresh`: what a new headless session keeps of the recorded one (pi.auto_start's fallback, #66).
-        const fresh: Record<string, string> = {};
-        for (const k of ["backend", "model"] as const) if (str(launch[k])) fresh[k] = str(launch[k])!;
-        const sessionFile = str(meta.sessionFile) ?? str(launch.sessionFile);
-        // #269: a terminal Pi stays marked as one without a session file too, so nothing headless is started in its place.
-        if (!sessionFile) return { peer, fresh, ...(str(launch.mode) === "tui" ? { tui: true } : {}), how: "pi: no session file was recorded; start it again with ahub pi" };
-        // A terminal Pi is run by the CLI that launched it, not by the hub: nothing here could start it again.
-        if (str(launch.mode) === "tui") return { peer, fresh, tui: true, how: `pi: it ran in a terminal; start it again with ahub pi --mode tui --session-file ${sessionFile}` };
-        const args: Record<string, string> = { sessionFile };
-        for (const k of ["mode", "backend", "model"] as const) if (str(launch[k])) args[k] = str(launch[k])!;
-        return { peer, fresh, resume: args, how: `pi: its session file can be resumed (${sessionFile})` };
-      }
-      case "local": {
-        // `model` is also recorded as the route's fallback, and a model given at start pins it: pass one or the other.
-        const route = str(launch.route);
-        const args: Record<string, string> = route ? { route } : model ? { model } : {};
-        return { peer, resume: args, how: "local: starts again without its history (the worker keeps none across a hub stop)" };
-      }
-      default:
-        return { peer, how: `${peer}: reconnects by itself if its client is still running` };
-    }
+    const native = adapter?.session.crashPlan?.(meta);
+    if (!native) return { peer, how: `${peer}: reconnects by itself if its client is still running` };
+    if (!extra) return { peer, ...native };
+    const prefix = `${adapter.kind}:`;
+    let how = native.how.startsWith(prefix) ? `${peer}:${native.how.slice(prefix.length)}` : `${peer}: ${native.how}`;
+    // Manual launch guidance selects this instance. Recorded headless resume prose can contain an opaque id, never a command.
+    if (!native.resume || native.tui) how = how.replace(`ahub ${adapter.cli.command}`, command);
+    return { peer, ...native, how };
   });
 }