A channel a server opens in another's place isn't closed again when the host has no decision recorded for it #730

// Probe (Barnaby-2576), F284: a channel a server opens in another channel's
// place (a substituted channels/open answer) is closed again only when the
// host's decision for it is 'closed'. Here the substitute was registered from
// a push (ensureChannelRegistered), so no decision is on record.
// Control: the same substitute registered by channels/changed with
// initiallyOpen false (a recorded 'closed' decision), as
// test/channel-open-substitution.test.ts has it.
// After the open, a message on the substitute arrives by channels/incoming,
// and the probe prints what reached the agent (pushEventFn).
// Run with tsx from the agent-framework checkout's root.
import { ChannelRegistry } from '../src/mcpl/channel-registry.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';
import type { ChannelDescriptor, ChannelsOpenResult } from '../src/mcpl/types.js';

console.log(`node ${process.version}, ${process.platform}`);
const tick = () => new Promise<void>((resolve) => setImmediate(resolve));

function descriptor(id: string, initiallyOpen = false): ChannelDescriptor {
  return { id, type: 'test', label: id, direction: 'bidirectional', initiallyOpen, address: { value: id } };
}

async function run(variant: 'pushed' | 'registered-closed'): Promise<void> {
  const calls: string[] = [];
  const events: Array<{ type: string; [k: string]: unknown }> = [];
  const traces: string[] = [];
  const server = {
    grant: new CapabilityGrant(new Set(ALL_CAPABILITY_PATHS), []),
    sendChannelsOpen: async (params: { channelId?: string }): Promise<ChannelsOpenResult> => {
      calls.push(`open ${params.channelId}`);
      return { channel: descriptor('y') };
    },
    sendChannelsClose: async (params: { channelId: string }) => { calls.push(`close ${params.channelId}`); return { closed: true }; },
    sendChannelsPublish: async () => ({ delivered: true }),
  };
  const registry = new ChannelRegistry(
    { getServer: () => server } as unknown as McplServerRegistry,
    {} as FeatureSetManager,
    (event) => events.push(event as unknown as { type: string }),
    (event) => traces.push(event.type),
  );
  const errors: string[] = [];
  const original = console.error;
  console.error = (...args: unknown[]) => { errors.push(args.map(String).join(' ')); };
  try {
    await registry.handleChanged('test', { added: [descriptor('x')] });
    if (variant === 'pushed') registry.ensureChannelRegistered('test', 'y', 'y');
    else await registry.handleChanged('test', { added: [descriptor('y')] });
    const before = registry.getDesiredState('test', 'y');
    calls.length = 0;
    const result = await registry.handleChannelToolCall('channel_open', { serverId: 'test', channelId: 'x' });
    for (let i = 0; i < 5; i++) await tick();
    const after = registry.getDesiredState('test', 'y');
    const callsAfterOpen = [...calls];
    events.length = 0;
    await registry.handleIncoming('test', {
      messages: [{
        channelId: 'y', messageId: 'y-2', author: { id: 'u1', name: 'someone' },
        timestamp: '2026-10-23T05:00:00Z', content: [{ type: 'text', text: 'hello from y' }],
      }],
    } as never);
    for (let i = 0; i < 5; i++) await tick();
    console.error = original;
    console.log(`\n== y ${variant === 'pushed' ? 'registered from a push (no decision recorded)' : 'registered by channels/changed, initiallyOpen false'}`);
    console.log(`decision for y before the open: ${JSON.stringify(before)}`);
    console.log(`channel_open x answered: success=${result.success}`);
    console.log(`substitution traced: ${traces.includes('mcpl:channel-open-substituted')}`);
    console.log(`server calls after channel_open x: ${JSON.stringify(callsAfterOpen)}`);
    console.log(`decision for y after: ${JSON.stringify(after)}; y open in the registry: ${registry.getOpenChannels().some((e) => e.descriptor.id === 'y')}`);
    console.log(`events reaching the agent from y's message: ${JSON.stringify(events.map((e) => ({ type: e.type, channelId: (e as { channelId?: unknown }).channelId ?? (e as { metadata?: { channelId?: unknown } }).metadata?.channelId })))}`);
  } finally {
    console.error = original;
  }
}

await run('registered-closed');
await run('pushed');