@animalabs/connectome-host 0.7.4 → 0.8.0

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,