@animalabs/connectome-host 0.7.2 → 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/scripts/warmup-session.ts

@@ -42,7 +42,7 @@ import { resolve } from 'node:path';
 import { JsStore } from '@animalabs/chronicle';
 import { ContextManager } from '@animalabs/context-manager';
 import { AutobiographicalStrategy } from '@animalabs/agent-framework';
-import { Membrane, AnthropicAdapter, type NormalizedResponse } from '@animalabs/membrane';
+import { Membrane, AnthropicAdapter, BedrockAdapter, type NormalizedResponse } from '@animalabs/membrane';
 import { SessionManager } from '../src/session-manager.js';
 import { resolveAgentName } from '../src/agent-name.js';
 
@@ -181,7 +181,13 @@ function formatDuration(sec: number): string {
 
 async function main() {
   const opts = parseArgs(process.argv);
-  if (!process.env.ANTHROPIC_API_KEY) {
+  const bedrockModel = /^([a-z]{2,6}\.)?anthropic\./.test(opts.model);
+  if (bedrockModel) {
+    if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+      console.error('Bedrock model id — set AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (and AWS_REGION)');
+      process.exit(1);
+    }
+  } else if (!process.env.ANTHROPIC_API_KEY) {
     console.error('Set ANTHROPIC_API_KEY');
     process.exit(1);
   }
@@ -218,8 +224,16 @@ async function main() {
   // -- Membrane with token-spend hook --
   const price = priceOf(opts.model);
   const spend: Spend = { inputTokens: 0, outputTokens: 0, cost: 0 };
-  const adapter = new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY });
+  // Bedrock model ids (anthropic.* / <region>.anthropic.*) route through the
+  // BedrockAdapter with AWS_* env creds — legacy Claude models (revival
+  // sessions) exist nowhere else. Caching off: legacy models reject
+  // cache_control outright.
+  const isBedrock = /^([a-z]{2,6}\.)?anthropic\./.test(opts.model);
+  const adapter = isBedrock
+    ? new BedrockAdapter()
+    : new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY });
   const membrane = new Membrane(adapter, {
+    ...(isBedrock ? { defaultPromptCaching: false } : {}),
     // Imported sessions store assistant turns under participant `agentName`.
     // Membrane's default assistantParticipant is 'Claude'; if that disagrees
     // with the stored participant every assistant message maps to role

package/src/codex-subscription-adapter.ts

@@ -532,7 +532,19 @@ export class CodexSubscriptionAdapter implements ProviderAdapter {
         stopReason,
         stopSequence: undefined,
         usage: {
-          inputTokens: terminal.usage?.input_tokens ?? 0,
+          // OpenAI/Codex reports `input_tokens` INCLUSIVE of cached tokens,
+          // whereas the rest of the stack uses the additive Anthropic
+          // convention (inputTokens = fresh/uncached, cacheReadTokens added on
+          // top, so inputTokens + cacheReadTokens == total prompt). Report
+          // fresh-only here so that convention holds. Without this, every
+          // consumer that sums the buckets — the calibration realTotal
+          // (framework.ts), cost pricing, and gate metering — double-counts
+          // the cached prefix: on a heavily-cached turn real/est hit ~2.0,
+          // which the estimator rejected as out-of-band on full-cache compiles
+          // and (worse) ratcheted the multiplier upward on partial-cache ones,
+          // inflating estimates until the budget solver exhausted and the
+          // agent wedged (Sol, 2026-07-31).
+          inputTokens: Math.max(0, (terminal.usage?.input_tokens ?? 0) - cachedTokens),
           outputTokens: terminal.usage?.output_tokens ?? 0,
           cacheReadTokens: cachedTokens > 0 ? cachedTokens : undefined,
         },

package/src/framework-agent-config.ts

@@ -10,12 +10,60 @@ export type FrameworkAgentConfig = AgentConfig & {
   sameRoundThinkTextPolicy?: 'public' | 'private';
 };
 
+/**
+ * Prompt caching went GA on Bedrock in April 2025 for 3.5 Haiku, 3.7
+ * Sonnet, and Claude 4+ — but NOT for 3.5 Sonnet (either version). 1022
+ * ("3.6") was in the Dec 2024 preview and was dropped at GA — that
+ * account-level "your request did not allow prompt caching" is the error
+ * observed here 2026-07-21 (antra's diagnosis, confirmed against the AWS
+ * docs 2026-07-31; as of the same day's live probe every 3.5-era model
+ * is EOL on Bedrock anyway). So the gate denies the pre-GA FAMILIES —
+ * Claude v2/instant, Claude 3, 3.5 Sonnet — at the family boundary, so
+ * dated ids, bare aliases, -latest, and inference-profile forms
+ * (us.anthropic.claude-...) all resolve the same; 3.5 Haiku and 3.7
+ * Sonnet stay distinct and on. Non-Claude Bedrock ids (Nova etc.) are
+ * out of scope for this gate and conservatively off — membrane's
+ * BedrockAdapter only accepts Claude ids today. recipe.agent.
+ * promptCaching overrides in either direction for accounts/regions
+ * whose entitlements differ from the GA table. (Connectome issue #35.)
+ */
+export function bedrockModelSupportsPromptCaching(model: string): boolean {
+  const id = model.toLowerCase();
+  if (!id.includes('claude')) return false;
+  // (?![a-z0-9]) = family boundary: end of id, or a separator (-, ., :)
+  // before a date/qualifier — matches the whole family, not one spelling.
+  return !/claude-(v2|instant|3-(opus|sonnet|haiku)|3-5-sonnet)(?![a-z0-9])/.test(id);
+}
+
+export function resolvePromptCaching(recipe: Recipe, model: string): boolean | undefined {
+  if (recipe.agent.promptCaching !== undefined) return recipe.agent.promptCaching;
+  if (recipe.agent.provider === 'bedrock') return bedrockModelSupportsPromptCaching(model);
+  return undefined; // membrane default (on)
+}
+
+/**
+ * Membrane-level counterpart of resolvePromptCaching, spread into the
+ * Membrane constructor config. The per-agent flag only governs agent
+ * inference; internal callers (autobio compression, executeMerge) read
+ * Membrane's defaultPromptCaching — so an explicit recipe override must
+ * land at BOTH layers, on every provider, or `promptCaching: false` on
+ * an Anthropic recipe would silently keep caching on for internal calls.
+ */
+export function membraneCachingOverride(
+  recipe: Recipe,
+  model: string,
+): { defaultPromptCaching?: boolean } {
+  const promptCaching = resolvePromptCaching(recipe, model);
+  return promptCaching === undefined ? {} : { defaultPromptCaching: promptCaching };
+}
+
 export function buildFrameworkAgentConfig(
   recipe: Recipe,
   agentName: string,
   model: string,
   strategy: FrameworkAgentConfig['strategy'],
 ): FrameworkAgentConfig {
+  const promptCaching = resolvePromptCaching(recipe, model);
   return {
     name: agentName,
     model,
@@ -23,10 +71,17 @@ export function buildFrameworkAgentConfig(
     maxTokens: recipe.agent.maxTokens ?? 16384,
     maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
     contextBudgetTokens: recipe.agent.contextBudgetTokens,
-    ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
-    // Bedrock legacy Claude models reject cache_control outright
-    // ("your request did not allow prompt caching") — suppress markers.
-    ...(recipe.agent.provider === 'bedrock' && { promptCaching: false }),
+    // cacheTtl is withheld at the HOST layer on bedrock: the transport
+    // only has the default 5m cache, and older membrane releases forward
+    // the ttl field Bedrock rejects. Note this is not the whole story —
+    // Agent Framework still supplies its own default ('1h') downstream
+    // when the host omits the field, and membrane ≥0.5.77 strips it at
+    // the provider boundary before wire dispatch. Requests are safe, but
+    // pre-adapter config is NOT cache-TTL telemetry; the wire truth lives
+    // at the adapter.
+    ...(recipe.agent.cacheTtl && recipe.agent.provider !== 'bedrock'
+      && { cacheTtl: recipe.agent.cacheTtl }),
+    ...(promptCaching !== undefined && { promptCaching }),
     // Prefill scaffold (anthropic-xml formatter), e.g. chapterx CLI-sim's
     // '<cmd>cat untitled.txt</cmd>' — part of migrating prefill-era bots.
     ...(recipe.agent.prefillUserMessage && { prefillUserMessage: recipe.agent.prefillUserMessage }),

package/src/framework-strategy.ts

@@ -36,6 +36,7 @@ const PASSTHROUGH_KEYS: ReadonlyArray<keyof RecipeStrategy> = [
   'summaryContextLabel',
   'witnessedBeforeSequence',
   'witnessedInstruction',
+  'identityReminder',
 ];
 
 export function buildFrameworkStrategy(
@@ -82,12 +83,41 @@ 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;
   }
 
+  // Reasonable memory defaults for recipes that omit strategy tuning:
+  //
+  // - foldingStrategy 'kv-stable': the library's own fallback is
+  //   'flat-profile', which replans compile layouts without regard for
+  //   prompt-cache stability. Long-lived agents want cache-stable folds by
+  //   default; recipes can still pin 'flat-profile'/'oldest-first' explicitly.
+  //   (Only meaningful under adaptive resolution, so gate on it.)
+  // - summaryParticipant <agent name>: the library falls back to the literal
+  //   '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 === 'frontdesk') &&
+    autobiographicalOpts.adaptiveResolution !== false &&
+    autobiographicalOpts.foldingStrategy === undefined
+  ) {
+    autobiographicalOpts.foldingStrategy = 'kv-stable';
+  }
+  if (autobiographicalOpts.summaryParticipant === undefined && recipe.agent.name) {
+    autobiographicalOpts.summaryParticipant = recipe.agent.name;
+  }
+
   return strategyType === 'passthrough'
     ? new PassthroughStrategy()
     : strategyType === 'frontdesk'

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 }