@animalabs/connectome-host 0.7.3 → 0.7.4

package/scripts/audit-module-optins.ts

@@ -0,0 +1,288 @@
+/**
+ * Report-only audit of subagents/lessons/retrieval opt-ins across recipes.
+ *
+ * Background: published v0.7.2 and earlier treated these three modules as
+ * opt-OUT (an omitted `modules` key meant enabled), and DEFAULT_RECIPE
+ * enabled all three explicitly. Current main treats them as opt-IN
+ * (a4bd9fd). That flip is the right default, but it leaves existing
+ * deployments with two things only a human can settle:
+ *
+ *   1. A source recipe that explicitly says `lessons: true` stays enabled
+ *      after upgrade — intentionally. Whether that `true` was a real choice
+ *      or boilerplate copied from the old onboarding guide is not something
+ *      a defaults change (or this script) can infer. It gets reported;
+ *      the operator decides.
+ *   2. A persisted `data/.recipe.json` is a resolved snapshot of whatever
+ *      was in effect at launch — under the old defaults that includes
+ *      `subagents/lessons/retrieval: true` the operator never wrote. It is
+ *      not necessarily the authoritative source recipe, so it's reported
+ *      separately, as a pointer back to the source, never as a finding in
+ *      itself.
+ *
+ * This script reads and reports. It never modifies a file, and it has no
+ * flag that would make it modify a file.
+ *
+ * Usage:
+ *   bun scripts/audit-module-optins.ts <recipe.json | directory> [...more]
+ *
+ * Directories are scanned recursively for *.json (including .recipe.json
+ * snapshots; node_modules/.git skipped). Fleet children referenced by
+ * local path are followed automatically.
+ *
+ * Exit codes: 0 = nothing needs an operator decision; 2 = explicit enables
+ * (or inert-retrieval combinations) found — review the report; 1 = a path
+ * argument could not be read.
+ */
+
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+
+export const AUDITED_MODULES = ['subagents', 'lessons', 'retrieval'] as const;
+export type AuditedModule = (typeof AUDITED_MODULES)[number];
+
+export type ModuleState = 'explicit-enable' | 'explicit-disable' | 'omitted';
+
+export interface RecipeAudit {
+  /** Path as reported (relative to cwd where possible). */
+  path: string;
+  recipeName: string;
+  /** basename === '.recipe.json': a resolved launch snapshot, not a source. */
+  isSnapshot: boolean;
+  states: Record<AuditedModule, ModuleState>;
+  /** Snapshot has all three explicitly true — the old DEFAULT_RECIPE shape.
+   *  Almost certainly captured pre-flip defaults, not an operator choice. */
+  matchesOldDefaultBoilerplate: boolean;
+  /** retrieval explicitly enabled while lessons is omitted: worked under the
+   *  old defaults (omitted lessons = on), silently inert after upgrade. */
+  inertRetrieval: boolean;
+  /** Local fleet-children recipe paths referenced by this recipe. */
+  childRecipePaths: string[];
+}
+
+interface RawRecipeShape {
+  name?: unknown;
+  agent?: unknown;
+  modules?: Record<string, unknown>;
+}
+
+/** A JSON document we treat as a recipe: object with a name and an agent
+ *  block. Anything else in a scanned directory is silently skipped. */
+export function looksLikeRecipe(raw: unknown): raw is RawRecipeShape {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return false;
+  const o = raw as RawRecipeShape;
+  return typeof o.name === 'string' && !!o.agent && typeof o.agent === 'object';
+}
+
+export function classifyModule(value: unknown): ModuleState {
+  if (value === undefined || value === null) return 'omitted';
+  if (value === false) return 'explicit-disable';
+  // true or a config object both enable (matches createFramework wiring).
+  return 'explicit-enable';
+}
+
+export function auditRecipe(raw: RawRecipeShape, path: string): RecipeAudit {
+  const modules = (raw.modules && typeof raw.modules === 'object' ? raw.modules : {}) as Record<string, unknown>;
+  const states = Object.fromEntries(
+    AUDITED_MODULES.map((m) => [m, classifyModule(modules[m])]),
+  ) as Record<AuditedModule, ModuleState>;
+
+  const isSnapshot = basename(path) === '.recipe.json';
+
+  const childRecipePaths: string[] = [];
+  const fleet = modules.fleet;
+  if (fleet && typeof fleet === 'object') {
+    const children = (fleet as { children?: unknown }).children;
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        const ref = (child as { recipe?: unknown })?.recipe;
+        if (typeof ref !== 'string' || !ref) continue;
+        if (ref.startsWith('http://') || ref.startsWith('https://')) continue;
+        childRecipePaths.push(isAbsolute(ref) ? ref : resolve(dirname(resolve(path)), ref));
+      }
+    }
+  }
+
+  return {
+    path,
+    recipeName: String(raw.name),
+    isSnapshot,
+    states,
+    matchesOldDefaultBoilerplate:
+      isSnapshot &&
+      modules.subagents === true && modules.lessons === true && modules.retrieval === true,
+    inertRetrieval: states.retrieval === 'explicit-enable' && states.lessons === 'omitted',
+    childRecipePaths,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Filesystem walk (main-path only; the logic above is what the tests pin)
+// ---------------------------------------------------------------------------
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'web']);
+
+function collectJsonFiles(root: string, out: string[]): void {
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const full = join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name)) collectJsonFiles(full, out);
+    } else if (entry.name.endsWith('.json')) {
+      out.push(full);
+    }
+  }
+}
+
+export function auditPaths(paths: string[]): { audits: RecipeAudit[]; unreadable: string[] } {
+  const files: string[] = [];
+  const unreadable: string[] = [];
+  for (const p of paths) {
+    if (!existsSync(p)) {
+      unreadable.push(p);
+      continue;
+    }
+    if (statSync(p).isDirectory()) collectJsonFiles(p, files);
+    else files.push(p);
+  }
+
+  const audits: RecipeAudit[] = [];
+  const seen = new Set<string>();
+  const queue = [...files];
+  while (queue.length > 0) {
+    const file = queue.shift()!;
+    const key = resolve(file);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    let raw: unknown;
+    try {
+      raw = JSON.parse(readFileSync(file, 'utf-8'));
+    } catch {
+      continue; // not JSON we can read — not our business to complain about
+    }
+    if (!looksLikeRecipe(raw)) continue;
+    const audit = auditRecipe(raw, file);
+    audits.push(audit);
+    // Follow local fleet children so a parent path argument covers the tree.
+    for (const child of audit.childRecipePaths) {
+      if (existsSync(child)) queue.push(child);
+    }
+  }
+  return { audits, unreadable };
+}
+
+// ---------------------------------------------------------------------------
+// Report
+// ---------------------------------------------------------------------------
+
+const STATE_LINES: Record<AuditedModule, Record<ModuleState, string>> = {
+  subagents: {
+    'explicit-enable':
+      'explicitly enabled — stays on after upgrade. Keep if this agent really forks workers.',
+    'explicit-disable': 'explicitly disabled — no change on upgrade (belt-and-braces for old checkouts).',
+    omitted:
+      'omitted — ON under published ≤0.7.2, OFF after upgrade. Declare `true` only if this agent relied on forking.',
+  },
+  lessons: {
+    'explicit-enable':
+      'explicitly enabled — stays on after upgrade. Keep if this agent curates a lesson library.',
+    'explicit-disable': 'explicitly disabled — no change on upgrade (belt-and-braces for old checkouts).',
+    omitted:
+      'omitted — ON under published ≤0.7.2, OFF after upgrade. Declare `true` only if this agent relied on lessons.',
+  },
+  retrieval: {
+    'explicit-enable':
+      'explicitly enabled — stays on after upgrade: per-compile injection plus two Haiku calls per turn. Keep only as a real choice.',
+    'explicit-disable': 'explicitly disabled — no change on upgrade (belt-and-braces for old checkouts).',
+    omitted: 'omitted — ON under published ≤0.7.2 (when lessons ran), OFF after upgrade.',
+  },
+};
+
+export function renderReport(audits: RecipeAudit[]): { text: string; needsDecision: number } {
+  const lines: string[] = [];
+  let needsDecision = 0;
+
+  const sources = audits.filter((a) => !a.isSnapshot);
+  const snapshots = audits.filter((a) => a.isSnapshot);
+
+  for (const a of sources) {
+    lines.push(`${a.path}  (recipe "${a.recipeName}")`);
+    for (const m of AUDITED_MODULES) {
+      const state = a.states[m];
+      if (state === 'explicit-enable') needsDecision++;
+      lines.push(`  ${m}: ${STATE_LINES[m][state]}`);
+    }
+    if (a.inertRetrieval) {
+      needsDecision++;
+      lines.push(
+        '  ⚠ retrieval is enabled but lessons is omitted. Under the old defaults omitted lessons still ran,',
+        '    so retrieval worked; after upgrade lessons is off and retrieval is silently inert.',
+        '    Either add `lessons: true` (if retrieval is a real choice) or drop `retrieval`.',
+      );
+    }
+    lines.push('');
+  }
+
+  if (snapshots.length > 0) {
+    lines.push('Resolved snapshots (data/.recipe.json) — informational only:');
+    lines.push(
+      '  These are launch-time captures, not authoritative sources. Under the old defaults they',
+      '  include enables the operator never wrote. Audit the source recipe each run was launched',
+      '  from; the snapshot refreshes on the next launch from source.',
+    );
+    for (const a of snapshots) {
+      const enabled = AUDITED_MODULES.filter((m) => a.states[m] === 'explicit-enable');
+      const note = a.matchesOldDefaultBoilerplate
+        ? 'all three enabled — matches the old DEFAULT_RECIPE shape, almost certainly pre-flip defaults, not a choice'
+        : enabled.length > 0
+          ? `explicitly enabled here: ${enabled.join(', ')}`
+          : 'no audited modules enabled';
+      lines.push(`  ${a.path}  (recipe "${a.recipeName}"): ${note}`);
+    }
+    lines.push('');
+  }
+
+  return { text: lines.join('\n'), needsDecision };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main(): void {
+  const args = process.argv.slice(2).filter((a) => !a.startsWith('--'));
+  if (args.length === 0) {
+    console.error('Usage: bun scripts/audit-module-optins.ts <recipe.json | directory> [...more]');
+    console.error('Report-only: reads recipes, changes nothing.');
+    process.exit(1);
+  }
+
+  const { audits, unreadable } = auditPaths(args);
+  for (const p of unreadable) console.error(`cannot read: ${p}`);
+
+  console.log('connectome-host module opt-in audit — report only, nothing is modified\n');
+  console.log(
+    'Published ≤0.7.2 treated subagents/lessons/retrieval as opt-OUT (omitted = enabled).\n' +
+      'Current main treats them as opt-IN (omitted = disabled). Explicit enables survive the\n' +
+      'upgrade by design — this report shows where each recipe stands so you can decide which\n' +
+      'of those are real choices and which are old boilerplate.\n',
+  );
+
+  let needsDecision = 0;
+  if (audits.length === 0) {
+    console.log('No recipe-shaped JSON found under the given paths.');
+  } else {
+    const report = renderReport(audits);
+    needsDecision = report.needsDecision;
+    console.log(report.text);
+    const sources = audits.filter((a) => !a.isSnapshot).length;
+    console.log(
+      `Summary: ${audits.length} recipe(s) audited (${sources} source, ${audits.length - sources} snapshot), ` +
+        `${needsDecision} item(s) need an operator decision.`,
+    );
+  }
+
+  // Unreadable path arguments outrank findings in the exit code.
+  if (unreadable.length > 0) process.exit(1);
+  if (needsDecision > 0) process.exit(2);
+}
+
+if (import.meta.main) main();

package/src/framework-strategy.ts

@@ -36,6 +36,7 @@ const PASSTHROUGH_KEYS: ReadonlyArray<keyof RecipeStrategy> = [
   'summaryContextLabel',
   'witnessedBeforeSequence',
   'witnessedInstruction',
+  'identityReminder',
 ];
 
 export function buildFrameworkStrategy(
@@ -82,9 +83,17 @@ export function buildFrameworkStrategy(
     if (value !== undefined) autobiographicalOpts[key] = value;
   }
 
-  // Autobiographical agents default to adaptive resolution unless a recipe
-  // opts out; frontdesk keeps its historical hierarchical renderer default.
-  if (strategyType === 'autobiographical' && autobiographicalOpts.adaptiveResolution === undefined) {
+  // Autobiographical AND frontdesk agents default to adaptive resolution
+  // unless a recipe opts out. Frontdesk historically kept the hierarchical
+  // renderer; that geometry has no tail reservation and no way to shed
+  // summary mass, so a long-lived agent saturates a fixed budget into a
+  // terminal context refusal (2026-08-03 boter clerk outage). The adaptive
+  // picker solves a frontier to fit — recipes can still pin
+  // `adaptiveResolution: false` as a rollback lever.
+  if (
+    (strategyType === 'autobiographical' || strategyType === 'frontdesk') &&
+    autobiographicalOpts.adaptiveResolution === undefined
+  ) {
     autobiographicalOpts.adaptiveResolution = true;
   }
 
@@ -99,7 +108,7 @@ export function buildFrameworkStrategy(
   //   'Claude', which voices self-recollections as a stranger for any agent
   //   not named Claude. Summaries should speak as the agent itself.
   if (
-    strategyType === 'autobiographical' &&
+    (strategyType === 'autobiographical' || strategyType === 'frontdesk') &&
     autobiographicalOpts.adaptiveResolution !== false &&
     autobiographicalOpts.foldingStrategy === undefined
   ) {

package/src/headless.ts

@@ -136,6 +136,8 @@ export async function runHeadless(app: AppContext, argv: string[] = []): Promise
     'workspace-mounts-snapshot',
     'workspace-tree-snapshot',
     'workspace-file-snapshot',
+    'cancel-subagent-result',
+    'panel-response',
   ]);
 
   function emit(event: Record<string, unknown>): void {
@@ -329,6 +331,18 @@ export async function runHeadless(app: AppContext, argv: string[] = []): Promise
         }
         return;
       }
+      case 'panel-request': {
+        // Operator-panel query/mutation, shared verb. The SAME handler the
+        // WebUI host runs locally answers here, so parent and child views of
+        // any panel op can never drift. runPanelOp never throws — failures
+        // come back as {ok:false} and still produce a panel-response, which
+        // the parent's promise API requires to settle.
+        const op = typeof cmd.op === 'string' ? cmd.op : '';
+        const { runPanelOp } = await import('./web/panel-data.js');
+        const result = await runPanelOp(app, op, cmd.params ?? {});
+        emit({ type: 'panel-response', corrId: cmd.corrId, op, ...result });
+        return;
+      }
       case 'cancel-subagent': {
         const mod = app.framework.getAllModules().find((m) => m.name === 'subagent') as
           | { cancelSubagent(name: string): boolean }

package/src/index.ts

@@ -37,6 +37,7 @@ import { readFileSync, existsSync } from 'node:fs';
 import { SubagentModule } from './modules/subagent-module.js';
 import { LessonsModule } from './modules/lessons-module.js';
 import { RetrievalModule } from './modules/retrieval-module.js';
+import { buildRetrievalModuleConfig } from './retrieval-config.js';
 import type { RecipeWorkspaceMount } from './recipe.js';
 import { TuiModule } from './modules/tui-module.js';
 import { TimeModule } from './modules/time-module.js';
@@ -103,6 +104,10 @@ interface AppContext {
   branchState: BranchState;
   userMessageCount: number;
   codexAdapter?: CodexSubscriptionAdapter;
+  /** Content-free recent provider-call ledger. Consumed by the panel-data
+   *  layer (health snapshots) in BOTH runtimes — WebUI host and headless
+   *  fleet child. Null when the provider adapter exposes no ledger. */
+  callLedger: CallLedger | null;
 
   /** Stop current framework, switch to a different session, start new framework. */
   switchSession(id: string): Promise<void>;
@@ -227,16 +232,13 @@ async function createFramework(
   }
 
   // Retrieval (requires lessons). OPT-IN — not part of the standard recipe:
-  // it injects context-dependent content into every compile (plus two Haiku
-  // calls per turn), which adds per-turn context churn. Enable explicitly via
-  // modules.retrieval only when an agent actually curates a lesson library.
+  // it injects context-dependent content into every compile (plus up to two
+  // configured retrieval-model calls), which adds per-turn context churn.
+  // Enable explicitly only when an agent actually curates a lesson library.
   if (modules.retrieval && lessonsModule) {
-    const retrievalConfig = typeof modules.retrieval === 'object' ? modules.retrieval : {};
-    moduleInstances.push(new RetrievalModule({
-      membrane,
-      retrievalModel: retrievalConfig.model,
-      maxInjectedLessons: retrievalConfig.maxInjected,
-    }));
+    moduleInstances.push(new RetrievalModule(
+      buildRetrievalModuleConfig(membrane, modules.retrieval, recipe.agent.provider),
+    ));
   }
 
   // Gate config — core AF EventGate feature.
@@ -996,6 +998,7 @@ async function main() {
     branchState: createBranchState(),
     userMessageCount: 0,
     codexAdapter,
+    callLedger,
 
     async switchSession(id: string) {
       handleExport(this);

package/src/modules/fleet-module.ts

@@ -34,7 +34,7 @@ import { spawn as spawnProcess, type ChildProcess } from 'node:child_process';
 import { connect as netConnect, type Socket } from 'node:net';
 import { existsSync, mkdirSync, unlinkSync, openSync, closeSync, appendFileSync, realpathSync } from 'node:fs';
 import { join, resolve, isAbsolute } from 'node:path';
-import { type IncomingCommand, type WireEvent, matchesSubscription } from './fleet-types.js';
+import { type IncomingCommand, type WireEvent, type PanelResponseEvent, matchesSubscription } from './fleet-types.js';
 import { loadRecipe } from '../recipe.js';
 import { REDUCER_REQUIRED_EVENTS } from '../state/agent-tree-reducer.js';
 
@@ -1621,6 +1621,65 @@ export class FleetModule implements Module {
     catch { return false; }
   }
 
+  /** Monotonic corrId source for requestPanel. */
+  private panelSeq = 0;
+
+  /**
+   * Run one operator-panel op (see src/web/panel-data.ts) in a fleet child
+   * and await its `panel-response`. Promise-based counterpart to the
+   * fire-and-forget request* verbs above: HTTP proxy routes need to await a
+   * body, and the WS handlers are simpler for it too.
+   *
+   * Never rejects — a dead child, send failure, or timeout resolves as
+   * `{ok:false, error, status}` (502 unreachable, 504 timeout), so callers
+   * translate straight into a response without try/catch.
+   */
+  requestPanel(
+    childName: string,
+    op: string,
+    params?: Record<string, unknown>,
+    timeoutMs = 30_000,
+  ): Promise<{ ok: boolean; data?: unknown; error?: string; status?: number }> {
+    const child = this.children.get(childName);
+    if (!child || !child.socket) {
+      return Promise.resolve({
+        ok: false,
+        error: child ? `child '${childName}' is ${child.status}, not running` : `unknown child: ${childName}`,
+        status: child ? 502 : 404,
+      });
+    }
+    const corrId = `panel-${op}-${++this.panelSeq}-${Date.now().toString(36)}`;
+    return new Promise((resolvePanel) => {
+      let settled = false;
+      const finish = (result: { ok: boolean; data?: unknown; error?: string; status?: number }): void => {
+        if (settled) return;
+        settled = true;
+        unsub();
+        clearTimeout(timer);
+        resolvePanel(result);
+      };
+      const unsub = this.onChildEvent(childName, (_name, evt) => {
+        if (evt.type !== 'panel-response') return;
+        const e = evt as unknown as PanelResponseEvent;
+        if (e.corrId !== corrId) return;
+        finish({
+          ok: e.ok === true,
+          ...(e.data !== undefined ? { data: e.data } : {}),
+          ...(typeof e.error === 'string' ? { error: e.error } : {}),
+          ...(typeof e.status === 'number' ? { status: e.status } : {}),
+        });
+      });
+      const timer = setTimeout(() => {
+        finish({ ok: false, error: `panel op '${op}' timed out after ${timeoutMs}ms (child '${childName}' unresponsive)`, status: 504 });
+      }, timeoutMs);
+      try {
+        this.sendToChild(child, { type: 'panel-request', op, ...(params ? { params } : {}), corrId });
+      } catch (err) {
+        finish({ ok: false, error: `send to child failed: ${err instanceof Error ? err.message : String(err)}`, status: 502 });
+      }
+    });
+  }
+
   private async killChild(child: FleetChild): Promise<void> {
     if (child.status === 'exited' || child.status === 'crashed') return;
     const proc = child.process;

package/src/modules/fleet-types.ts

@@ -38,7 +38,18 @@ export type IncomingCommand =
    *  `cancel-subagent-result`. The child looks the agent up in its own
    *  SubagentModule, so this is the only way to stop a subagent that lives
    *  in a fleet child rather than the conductor. */
-  | { type: 'cancel-subagent'; name: string; corrId?: string };
+  | { type: 'cancel-subagent'; name: string; corrId?: string }
+  /**
+   * Run one operator-panel operation in the child (see PANEL_OPS in
+   * src/web/panel-data.ts: mcpl / settings(-update|-reset|-cancel-transition)
+   * / pins / pin-add / pin-remove / health / context-makeup /
+   * context-coverage / context-curve / context-preview / debug-context).
+   * Response is a single `panel-response` with the same corrId. One generic
+   * verb rather than a verb per panel: both ends dispatch through the SAME
+   * shared handler (`runPanelOp`), so a new panel surface needs no protocol
+   * change to work across the fleet.
+   */
+  | { type: 'panel-request'; op: string; params?: Record<string, unknown>; corrId?: string };
 
 // ---------------------------------------------------------------------------
 // Child → Parent: events
@@ -134,6 +145,23 @@ export interface CancelSubagentResultEvent {
   ts?: number;
 }
 
+/** Response to a {type:'panel-request'} request. `data` is the same
+ *  wire-shaped JSON the WebUI host serves locally for the given op;
+ *  `ok:false` carries the error plus an HTTP-ish `status` so the parent's
+ *  proxy routes can answer faithfully (404 unknown agent, 429 preview
+ *  cooldown, 501 unsupported build). */
+export interface PanelResponseEvent {
+  type: 'panel-response';
+  corrId?: string;
+  /** Echo of the requested op. */
+  op: string;
+  ok: boolean;
+  data?: unknown;
+  error?: string;
+  status?: number;
+  ts?: number;
+}
+
 /** Response to a {type:'request-workspace-file'} request. */
 export interface WorkspaceFileSnapshotEvent {
   type: 'workspace-file-snapshot';
@@ -163,6 +191,7 @@ export type WireEvent =
   | WorkspaceTreeSnapshotEvent
   | WorkspaceFileSnapshotEvent
   | CancelSubagentResultEvent
+  | PanelResponseEvent
   // Arbitrary framework TraceEvent passthrough. The child stamps every emitted
   // event with `ts: Date.now()` in `emit()` (see headless.ts), so ts is always
   // present on the wire even when the underlying TraceEvent doesn't declare it.

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

@@ -118,8 +118,9 @@ export class McplAdminModule implements Module {
       {
         name: 'mcpl_list',
         description:
-          'List all MCPL servers: id, live connection status, tool count, command/url, ' +
-          'and where each is defined (recipe/file vs your own agent overlay).',
+          '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.',
         inputSchema: { type: 'object', properties: {} },
       },
       {
@@ -227,7 +228,19 @@ export class McplAdminModule implements Module {
 
   private handleList(): ToolResult {
     const framework = this.requireFramework();
-    const live = framework.listMcplServers();
+    // These fields land in agent-framework 0.8's MCPL grant work. Keep them
+    // optional here so connectome-host remains truthful ("unknown") if it is
+    // temporarily run against an older framework package during rollout.
+    const live = framework.listMcplServers() as Array<
+      ReturnType<AgentFramework['listMcplServers']>[number] & {
+        retrying?: boolean;
+        policyEstablished?: boolean;
+        effectiveGrant?: string[];
+        maskedCapabilities?: string[];
+        deniedCapabilities?: string[];
+        allowHostCommands?: boolean;
+      }
+    >;
     const overlay = readAgentOverlay(this.overlayPath);
     const fileServers = readMcplServersFile(this.configPath);
 
@@ -237,8 +250,19 @@ export class McplAdminModule implements Module {
         ? 'agent-overlay'
         : s.id in fileServers ? 'file/recipe' : 'recipe';
       const target = s.command ?? s.url ?? '?';
+      const connectionState = s.connected ? 'CONNECTED' : s.retrying ? 'RETRYING' : 'DISCONNECTED';
+      const policyState = s.policyEstablished === undefined
+        ? 'unknown'
+        : s.policyEstablished ? 'established' : 'not-established';
+      const hostCommands = s.allowHostCommands === undefined
+        ? 'unknown'
+        : s.allowHostCommands ? 'allow' : 'deny';
       lines.push(
-        `${s.id}: ${s.connected ? 'CONNECTED' : 'DISCONNECTED'} — ${s.toolCount} tools, ` +
+        `${s.id}: ${connectionState} — policy=${policyState}, ` +
+        `grant=${formatCapabilityList(s.effectiveGrant)}, ` +
+        `masked=${formatCapabilityList(s.maskedCapabilities)}, ` +
+        `denied=${formatCapabilityList(s.deniedCapabilities)}, ` +
+        `hostCommands=${hostCommands}; ${s.toolCount} tools, ` +
         `prefix=${s.toolPrefix}, source=${source}, ${target}`,
       );
     }
@@ -378,3 +402,8 @@ export class McplAdminModule implements Module {
     return ok(`Unloaded server "${id}" — its tools are gone from your toolset. ${persistNote}`);
   }
 }
+
+function formatCapabilityList(paths: string[] | undefined): string {
+  if (paths === undefined) return 'unknown';
+  return `[${paths.join(',')}]`;
+}