beforeInference names no server it skips, and leaves each call's 5 s timer armed after the call answers #736

// Probe (Barnaby-2576), F397 and F398: `HookOrchestrator.beforeInference`
// with three servers: `fast` answers at once, `fails` rejects (a transport
// error), and `slow` answers after 6 s, past the 5 s timeout. The probe
// prints what beforeInference returns and how long it took, every line it
// printed to stderr, and, once it returned, how many timers the process
// still holds (process.getActiveResourcesInfo) and how long until the
// process could exit, for the hook alone and for a hook that answered at once.
// Run with tsx from the agent-framework checkout's root.
import { HookOrchestrator } from '../src/mcpl/hook-orchestrator.js';
import { CapabilityGrant, ALL_CAPABILITY_PATHS } from '../src/mcpl/capability-grant.js';
import type { McplServerRegistry } from '../src/mcpl/server-registry.js';
import type { FeatureSetManager } from '../src/mcpl/feature-set-manager.js';

console.log(`node ${process.version}, ${process.platform}`);
const mode = process.argv[2] ?? 'mixed';
const grant = () => new CapabilityGrant(new Set(ALL_CAPABILITY_PATHS), []);
const answer = (text: string) => ({ featureSet: 'fs', contextInjections: [{ namespace: 'n', position: 'system', content: [{ type: 'text', text }] }] });
const servers = mode === 'mixed'
  ? [
      { id: 'fast', grant: grant(), sendBeforeInference: async () => answer('from fast') },
      { id: 'fails', grant: grant(), sendBeforeInference: async () => { throw new Error('transport closed'); } },
      { id: 'slow', grant: grant(), sendBeforeInference: () => new Promise((r) => setTimeout(() => r(answer('from slow')), 6000).unref()) },
    ]
  : [{ id: 'fast', grant: grant(), sendBeforeInference: async () => answer('from fast') }];
const orchestrator = new HookOrchestrator(
  { getAllServers: () => servers } as unknown as McplServerRegistry,
  { validateInbound() {} } as unknown as FeatureSetManager,
);
const lines: string[] = [];
const original = console.error;
console.error = (...args: unknown[]) => { lines.push(args.map(String).join(' ')); };
const t0 = Date.now();
const injections = await orchestrator.beforeInference({
  inferenceId: 'i', conversationId: 'c', turnIndex: 0, userMessage: null, model: { id: 'test' } as never,
} as never);
const took = Date.now() - t0;
console.error = original;
console.log(`\n== ${mode === 'mixed' ? 'servers fast, fails (rejects) and slow (answers after 6 s)' : 'one server, fast'}`);
console.log(`beforeInference returned after ${took} ms with ${injections.length} injection(s): ${JSON.stringify(injections.map((i) => (i.content as Array<{ text?: string }>)[0]?.text))}`);
console.log(`stderr lines during the hook: ${JSON.stringify(lines)}`);
const timers = () => process.getActiveResourcesInfo().filter((r) => r === 'Timeout').length;
console.log(`timers held right after it returned: ${timers()}`);
const exitStart = Date.now();
process.on('exit', () => {
  console.log(`process exited ${Date.now() - exitStart} ms after the hook returned, with nothing else to do`);
});