@staix/agent-hub 0.12.43 → 0.12.45

package/src/hub/config-reload.ts

@@ -1,10 +1,12 @@
-import { ADAPTERS } from "../adapters/registry.ts";
+import { ADAPTERS, createProjectAdapterCatalog } from "../adapters/registry.ts";
+import { externalMetadataDefinitions, type ExternalAdapterMetadata } from "../adapters/external-metadata.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 { validateRawConfig, type ConfigLayer, type ConfigIdentitySnapshot } from "./config-apply.ts";
 import { parseOverlay, parseRouting, type Routing } from "./routing.ts";
 import { CLASSES } from "./board.ts";
+import { readInstanceConfig } from "./instance-config.ts";
 import { validateInstances } from "./instances.ts";
 
 export const CONFIG_SOURCE_FILES = ["config.json", "config.local.json", "routing.toml", "routing.local.toml"] as const;
@@ -16,6 +18,8 @@ export interface ConfigSources {
   trustLayers: { name: ConfigSourceName; raw: Record<string, unknown> }[];
   routing: Routing;
   fingerprint: string;
+  /** Captured trusted declarations, never a peer-name prefix or a request value. */
+  identity: ConfigIdentitySnapshot;
 }
 const MAX_CONFIG_BYTES = 1024 * 1024;
 
@@ -83,16 +87,38 @@ 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 {
+export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: Routing, cwd?: string, externalAdapters?: readonly ExternalAdapterMetadata[]): 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"); }
+  const jsonLayers: ConfigLayer[] = [];
+  for (const name of ["config.json", "config.local.json"] as const) {
+    const text = texts[name];
+    if (text === null) continue;
+    try {
+      const value: unknown = JSON.parse(text);
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+      jsonLayers.push({ name, raw: value as Record<string, unknown> });
+    } catch {
+      if (!fallbackRouting) throw new Error(`.agenthub/${name}: invalid JSON object`);
+    }
+  }
+  const localRaw = jsonLayers.find(layer => layer.name === "config.local.json")?.raw ?? {};
   let declared;
-  try { declared = validateInstances(localRaw?.instances); }
-  catch (error) {
+  let identityAdapters: ConfigIdentitySnapshot["adapters"];
+  let inertModuleRoster = false;
+  let catalog = createProjectAdapterCatalog();
+  try {
+    if (cwd) {
+      const accepted = readInstanceConfig(cwd, jsonLayers, externalAdapters === undefined ? undefined : externalMetadataDefinitions(externalAdapters));
+      catalog = accepted.catalog; declared = accepted.instances; identityAdapters = accepted.adapters;
+      inertModuleRoster = !!accepted.adapter_modules?.length;
+    } else {
+      catalog = createProjectAdapterCatalog(localRaw?.adapters, externalMetadataDefinitions(externalAdapters));
+      identityAdapters = localRaw?.adapters as ConfigIdentitySnapshot["adapters"];
+      declared = validateInstances(localRaw?.instances, catalog);
+    }
+  } catch (error) {
     if (!fallbackRouting) throw new Error(`.agenthub/config.local.json: ${(error as Error).message}`);
-    declared = validateInstances(undefined);
+    declared = validateInstances(undefined, catalog);
   }
   for (const name of CONFIG_SOURCE_FILES) {
     const text = texts[name];
@@ -108,7 +134,12 @@ export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: R
     }
     if (name === "config.json" || name === "config.local.json") {
       if (!fallbackRouting) {
-        try { validateRawConfig(raw, declared); }
+        try {
+          const structural = { ...raw };
+          // Declaration provenance was checked before compilation; ignored source data is never re-admitted.
+          delete structural.adapters; delete structural.instances;
+          validateRawConfig(structural, declared, catalog, inertModuleRoster);
+        }
         catch (error) { throw new Error(`.agenthub/${name}: ${(error as Error).message}`); }
       }
       layers.push({ name, raw });
@@ -125,5 +156,5 @@ export function parseConfigSources(texts: ConfigSourceTexts, fallbackRouting?: R
     try { routing = parseRouting(base, overlay); }
     catch { throw new Error(".agenthub/routing.toml / routing.local.toml: invalid effective routing"); }
   }
-  return { texts, layers, trustLayers, routing, fingerprint: configFingerprint(texts) };
+  return { texts, layers, trustLayers, routing, fingerprint: configFingerprint(texts), identity: { ...(identityAdapters ? { adapters: structuredClone(identityAdapters) } : {}), instances: declared ?? validateInstances(undefined, catalog), ...(catalog.externalDefinitions.length ? { externalAdapters: catalog.externalDefinitions.map(({ kind, displayName }) => ({ kind, displayName })) } : {}) } };
 }

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", "instances"] as const;
+export const ALL_MACHINE_LOCAL = [...MACHINE_LOCAL, "protect_instruction_files", "qwen_cmd", "jcode_cmd", "jcode_home", "jcode_provider_profile", "adapters", "adapter_modules", "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,6 +1,12 @@
 import { nonnegative, positive } from "../adapters/definitions/native-context.ts";
+import type { AdapterDefinition } from "../adapters/registry-types.ts";
 export { claudeContext, codexContext, acpContext } from "../adapters/definitions/native-context.ts";
 
+/** The host retains session/time/privacy fences; the declared reader owns normalization. */
+export function readNativeContext(definition: AdapterDefinition | undefined, value: unknown, sessionId: string, measuredAt: number): ContextReading | undefined {
+  return definition?.budget?.context?.read(value, sessionId, measuredAt);
+}
+
 /** Native active-context occupancy, separate from accumulated billable usage (#185). */
 export interface ContextReading {
   source: "claude_statusline" | "codex_token_usage" | "acp_usage_update";

package/src/hub/control-client.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { projectContext } from "./project.ts";
+import { externalAdapterMetadata, type ExternalAdapterMetadata } from "../adapters/external-metadata.ts";
 
 export function stateDirFor(cwd: string): string {
   return projectContext(cwd).stateDir;
@@ -8,7 +9,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 = ["native_hook_launch", "task_cancel", "recovery_deferred_hub", "peer_instances", "release_trains", "reviewer_pool", "native_tui_launch", "terminal_owner", "cli_audit_delegated"] as const;
+export const DAEMON_FEATURES = ["external_adapter_modules", "configured_acp", "native_hook_launch", "task_cancel", "recovery_deferred_hub", "peer_instances", "release_trains", "reviewer_pool", "native_tui_launch", "terminal_owner", "cli_audit_delegated"] 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;
 
@@ -38,6 +39,7 @@ export interface ControlDescriptor {
   features?: readonly string[];
   /** The daemon's accepted native start modes, used by launchers when the file value is retained. */
   startModes?: Readonly<Record<string, "tui" | "headless">>;
+  externalAdapters?: readonly ExternalAdapterMetadata[];
   /** #226: the daemon's processSignature, written into status.json only (not the status reply); absent before 0.12.21. */
   pidSignature?: string;
 }
@@ -54,6 +56,7 @@ export function readControl(stateDir: string): ControlDescriptor | undefined {
     return { url: `ws://127.0.0.1:${status.controlPort}`, token, projectId: status.projectId,
       instanceId: status.instanceId, cwd: status.cwd, protocol: status.protocol, pid: status.pid, features: Array.isArray(status.features) ? status.features.filter((feature: unknown): feature is string => typeof feature === "string") : [],
       ...(startModes ? { startModes } : {}),
+      ...(status.externalAdapters !== undefined ? { externalAdapters: externalAdapterMetadata(status.externalAdapters) } : {}),
       ...(typeof status.pidSignature === "string" && status.pidSignature ? { pidSignature: status.pidSignature } : {}) };
   } catch {
     return undefined;

package/src/hub/crash.ts

@@ -1,4 +1,4 @@
-import { definitionOf, type KindMap } from "../adapters/registry.ts";
+import { definitionOf, type ProjectAdapterCatalog, 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,17 +56,19 @@ 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[], instances?: KindMap): { peer: string; resume?: Record<string, string>; how: string; fresh?: Record<string, string>; tui?: true }[] {
+export function crashPlan(records: SessionRecord[], instances?: KindMap, catalog?: ProjectAdapterCatalog): { 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, instances);
-    const extra = adapter !== undefined && definitionOf(peer) === undefined;
+    const adapter = (catalog?.definitionOf ?? definitionOf)(peer, instances);
+    const extra = adapter !== undefined && adapter.kind !== peer;
     const command = extra ? `ahub ${adapter.cli.command} --as ${peer}` : `ahub ${peer}`;
     if (adapter?.session.resumeById) {
-      const sessionId = adapter.session.crashIdentity?.(meta).sessionId;
+      const rawId = meta[adapter.session.idField];
+      const sessionId = adapter.session.crashIdentity ? adapter.session.crashIdentity(meta).sessionId
+        : adapter.transport === "acp" && typeof rawId === "string" && rawId.length > 0 && Buffer.byteLength(rawId) <= 4096 && !/[\p{Cc}\p{Cf}]/u.test(rawId) ? rawId : undefined;
       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)` };
+      return { peer, resume: { sessionId, ...(model && definitionOf(adapter.kind) ? { model } : {}) }, how: `${peer}: the recorded conversation can be loaded again (ACP session/load)` };
     }
     const native = adapter?.session.crashPlan?.(meta);
     if (!native) return { peer, how: `${peer}: reconnects by itself if its client is still running` };