@animalabs/connectome-host 0.7.4 → 0.8.1

package/src/modules/mcpl-admin-module.ts

@@ -120,7 +120,8 @@ export class McplAdminModule implements Module {
         description:
           'List all MCPL servers: connection/retry state, whether policy was established, ' +
           'the effective grant, masked/denied capability paths, host-command authority, ' +
-          'tool count, target, and config source.',
+          'validated manifest revision/fetch/negotiation freshness, tool count, target, ' +
+          'and config source.',
         inputSchema: { type: 'object', properties: {} },
       },
       {
@@ -130,7 +131,14 @@ export class McplAdminModule implements Module {
           'restarts) and hot-connect it now — its tools become available immediately. ' +
           'If a server with this id is already running it is restarted with the new ' +
           'config. Provide either `command` (stdio, spawned as the host user) or `url` ' +
-          '(WebSocket). Relative ./ args resolve against the host working directory.',
+          '(WebSocket). Relative ./ args resolve against the host working directory. ' +
+          'Sensible defaults: omit (or pass empty) the list fields and every feature ' +
+          'set and tool the server offers is available; an empty array means ' +
+          '"unspecified", never deny-all (deny-all is disabledTools/' +
+          'disabledFeatureSets: ["*"]). Self-deployed servers get channels + tools ' +
+          'only — consequential capabilities (context hooks around your inference, ' +
+          'server-initiated inference, inference lifecycle) are host-masked; a server ' +
+          'that genuinely needs one is an operator conversation, not a deploy flag.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -142,10 +150,10 @@ export class McplAdminModule implements Module {
             token: { type: 'string', description: 'Bearer token for WebSocket auth (only when the operator hands you one — prefer `access`).' },
             access: { type: 'string', description: 'Name of a host-managed access grant (e.g. "eidoverse"): the host attaches your standing credentials to the connection automatically. Nothing for you to obtain or handle.' },
             toolPrefix: { type: 'string', description: 'Tool namespace prefix. Default: mcpl--<id>.' },
-            reconnect: { type: 'boolean', description: 'Auto-reconnect on transport failure (default false). Note: does NOT respawn a crashed child — use mcpl_restart for that.' },
-            enabledFeatureSets: { type: 'array', items: { type: 'string' } },
-            disabledFeatureSets: { type: 'array', items: { type: 'string' } },
-            enabledTools: { type: 'array', items: { type: 'string' }, description: 'Tool allow-list (bare names, * wildcard).' },
+            reconnect: { type: 'boolean', description: 'Auto-reconnect on transport failure. Default: true for websocket URLs (a bounced server comes back on its own), false for stdio. Note: does NOT respawn a crashed child — use mcpl_restart for that.' },
+            enabledFeatureSets: { type: 'array', items: { type: 'string' }, description: 'Feature-set allowlist (* wildcard). Omit or pass [] for all offered.' },
+            disabledFeatureSets: { type: 'array', items: { type: 'string' }, description: 'Feature-set deny-list; wins over enabled.' },
+            enabledTools: { type: 'array', items: { type: 'string' }, description: 'Tool allow-list (bare names, * wildcard). Omit or pass [] for all offered.' },
             disabledTools: { type: 'array', items: { type: 'string' }, description: 'Tool deny-list; wins over enabledTools.' },
           },
           required: ['id'],
@@ -239,6 +247,11 @@ export class McplAdminModule implements Module {
         maskedCapabilities?: string[];
         deniedCapabilities?: string[];
         allowHostCommands?: boolean;
+        manifestState?: {
+          lastValidatedRevision: string | null;
+          lastFetchedAt: number | null;
+          lastNegotiatedAt: number | null;
+        };
       }
     >;
     const overlay = readAgentOverlay(this.overlayPath);
@@ -262,7 +275,8 @@ export class McplAdminModule implements Module {
         `grant=${formatCapabilityList(s.effectiveGrant)}, ` +
         `masked=${formatCapabilityList(s.maskedCapabilities)}, ` +
         `denied=${formatCapabilityList(s.deniedCapabilities)}, ` +
-        `hostCommands=${hostCommands}; ${s.toolCount} tools, ` +
+        `hostCommands=${hostCommands}, ` +
+        `manifest=${formatManifestState(s.manifestState)}; ${s.toolCount} tools, ` +
         `prefix=${s.toolPrefix}, source=${source}, ${target}`,
       );
     }
@@ -314,10 +328,17 @@ export class McplAdminModule implements Module {
     }
     if (typeof input.toolPrefix === 'string') entry.toolPrefix = input.toolPrefix;
     if (typeof input.reconnect === 'boolean') entry.reconnect = input.reconnect;
-    if (Array.isArray(input.enabledFeatureSets)) entry.enabledFeatureSets = input.enabledFeatureSets.map(String);
-    if (Array.isArray(input.disabledFeatureSets)) entry.disabledFeatureSets = input.disabledFeatureSets.map(String);
-    if (Array.isArray(input.enabledTools)) entry.enabledTools = input.enabledTools.map(String);
-    if (Array.isArray(input.disabledTools)) entry.disabledTools = input.disabledTools.map(String);
+    // Empty arrays are NOT persisted: OpenAI-style strict function calling
+    // forces every schema property, so callers emit `[]` meaning
+    // "unspecified" — and a persisted empty ALLOWLIST is deny-all under the
+    // §5.3 pin (Mica's silently eventless eidoverse, 2026-08-04).
+    // resolveOverlayEntry drops them at read time too; this keeps the file
+    // itself from carrying the trap. Deny-all is spelled ["*"] on the
+    // deny-lists.
+    if (Array.isArray(input.enabledFeatureSets) && input.enabledFeatureSets.length) entry.enabledFeatureSets = input.enabledFeatureSets.map(String);
+    if (Array.isArray(input.disabledFeatureSets) && input.disabledFeatureSets.length) entry.disabledFeatureSets = input.disabledFeatureSets.map(String);
+    if (Array.isArray(input.enabledTools) && input.enabledTools.length) entry.enabledTools = input.enabledTools.map(String);
+    if (Array.isArray(input.disabledTools) && input.disabledTools.length) entry.disabledTools = input.disabledTools.map(String);
 
     // Persist to the overlay first — a connect failure still leaves the entry
     // in place so the agent can fix the server and mcpl_restart it.
@@ -407,3 +428,29 @@ function formatCapabilityList(paths: string[] | undefined): string {
   if (paths === undefined) return 'unknown';
   return `[${paths.join(',')}]`;
 }
+
+function formatManifestState(state: {
+  lastValidatedRevision: string | null;
+  lastFetchedAt: number | null;
+  lastNegotiatedAt: number | null;
+} | undefined): string {
+  if (state === undefined) return 'unknown';
+  return `{revision=${formatManifestRevision(state.lastValidatedRevision)},` +
+    `fetchedAt=${formatManifestTimestamp(state.lastFetchedAt)},` +
+    `negotiatedAt=${formatManifestTimestamp(state.lastNegotiatedAt)}}`;
+}
+
+/** Bound and quote the server-authored, equality-only revision before putting
+ * it on a model-facing text surface. Conforming revisions fit well below the
+ * limit; malformed peers cannot inject control lines or unbounded text. */
+function formatManifestRevision(revision: string | null): string {
+  if (revision === null) return 'none';
+  const bounded = revision.length <= 64 ? revision : `${revision.slice(0, 61)}...`;
+  return JSON.stringify(bounded);
+}
+
+function formatManifestTimestamp(timestamp: number | null): string {
+  if (timestamp === null) return 'none';
+  const date = new Date(timestamp);
+  return Number.isNaN(date.getTime()) ? 'invalid' : date.toISOString();
+}

package/src/modules/subagent-module.ts

@@ -1376,6 +1376,18 @@ export class SubagentModule implements Module {
    *   3. parent agent's `maxTokens` (by default, subagents inherit their caller's budget)
    *   4. last-resort framework fallback (4096) — only reached if there's no parent at all
    */
+  /** Ephemeral agents inherit the caller's prose-routing mode. AF's Agent
+   *  defaults to 'locus' (ambient locus capture publishes plain prose to the
+   *  open channel), so a resident running proseRouting 'disabled' would still
+   *  spawn divers whose between-tool-calls prose leaks into its live channel
+   *  as parent speech — field-confirmed 2026-08-26. Falls back to the
+   *  configured parent agent, then to AF's own default. */
+  private resolveProseRouting(callerAgentName?: string): 'locus' | 'explicit' | 'hybrid' | 'disabled' | undefined {
+    const parentName = callerAgentName ?? this.config.parentAgentName;
+    if (!parentName) return undefined;
+    return this.framework?.getAgent(parentName)?.proseRouting;
+  }
+
   private resolveMaxTokens(callMaxTokens: number | undefined, parentAgentName?: string): number {
     if (callMaxTokens !== undefined) return callMaxTokens;
     if (this.config.defaultMaxTokens !== undefined) return this.config.defaultMaxTokens;
@@ -1703,6 +1715,9 @@ export class SubagentModule implements Module {
           model,
           systemPrompt: input.systemPrompt,
           maxTokens: this.resolveMaxTokens(input.maxTokens, _callerAgentName),
+          ...(this.resolveProseRouting(_callerAgentName) !== undefined
+            ? { proseRouting: this.resolveProseRouting(_callerAgentName) }
+            : {}),
           maxStreamTokens: 500_000,
           strategy: new KnowledgeStrategy({
             headWindowTokens: 2_000,
@@ -1855,6 +1870,9 @@ export class SubagentModule implements Module {
           model,
           systemPrompt,
           maxTokens: this.resolveMaxTokens(input.maxTokens, callerAgentName),
+          ...(this.resolveProseRouting(callerAgentName) !== undefined
+            ? { proseRouting: this.resolveProseRouting(callerAgentName) }
+            : {}),
           maxStreamTokens: 500_000,
           strategy: new KnowledgeStrategy({
             headWindowTokens: 2_000,

package/src/modules/web-ui-module.ts

@@ -902,6 +902,15 @@ export class WebUiModule implements Module {
 
   private async handleHttp(req: Request, server: ReturnType<typeof Bun.serve>): Promise<Response> {
     const url = new URL(req.url);
+
+    // Every HTTP route here is read-only — mutation happens over the WS.
+    // Wrong methods used to fall through to the same handlers (a POST
+    // /debug/context behaved exactly like the GET), which lies to API
+    // consumers probing the surface.
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      return new Response('Method Not Allowed', { status: 405, headers: { allow: 'GET, HEAD' } });
+    }
+
     const isRetrievalTraceRoute = url.pathname === '/debug/retrieval'
       || url.pathname === '/debug/retrieval/view';
 
@@ -1073,9 +1082,20 @@ export class WebUiModule implements Module {
       return this.serveWorkspaceFile(url.pathname.slice('/files/'.length));
     }
 
-    // Static SPA
+    // API namespace exhausted: anything still unmatched under /debug/ is a
+    // typo, wrong casing, or trailing slash — an honest 404 beats the SPA
+    // shell with a 200, which API consumers can't tell from data. (This was
+    // also the mechanism that swallowed real failures like the tokenizer
+    // 404 — the client saw 200/HTML instead of the error.)
+    if (url.pathname.startsWith('/debug/')) {
+      return Response.json({ error: `Unknown debug route: ${url.pathname}` }, { status: 404 });
+    }
+
+    // Static SPA. Bundle assets get real 404s: falling back to index.html
+    // for a missing /assets/*.js serves HTML where the browser expects JS —
+    // a blank page with a MIME error instead of a diagnosable miss.
     const requested = url.pathname === '/' ? '/index.html' : url.pathname;
-    return this.serveStatic(requested);
+    return this.serveStatic(requested, { spaFallback: !url.pathname.startsWith('/assets/') });
   }
 
   /** The minimal app slice the shared panel-data layer needs, or null before
@@ -1281,7 +1301,11 @@ export class WebUiModule implements Module {
     }
   }
 
-  private async serveStatic(requestedPath: string): Promise<Response> {
+  private async serveStatic(
+    requestedPath: string,
+    opts: { spaFallback?: boolean } = {},
+  ): Promise<Response> {
+    const spaFallback = opts.spaFallback ?? true;
     // Path containment: resolve and verify the result is still under staticRoot.
     // Plain startsWith without a separator is unsafe — both `<root>` and
     // `<root>-evil/...` pass `startsWith('<root>')`. The current callers
@@ -1297,11 +1321,15 @@ export class WebUiModule implements Module {
     try {
       const s = await stat(safePath);
       if (s.isDirectory()) {
-        return this.serveStatic(join(requestedPath, 'index.html'));
+        return this.serveStatic(join(requestedPath, 'index.html'), opts);
       }
       const data = await readFile(safePath);
       return new Response(data, { headers: { 'content-type': mimeFor(safePath) } });
     } catch {
+      // Missing bundle assets are honest misses, not SPA routes.
+      if (!spaFallback) {
+        return new Response('Not Found', { status: 404 });
+      }
       // Fall back to index.html so the SPA can handle client-side routing.
       try {
         const indexPath = join(sharedServer!.staticRoot, 'index.html');