fuli-context 0.10.0 → 0.11.1

package/src/roundtables/application.js

@@ -1,69 +0,0 @@
-import { join } from 'node:path';
-import { mkdirSync } from 'node:fs';
-import { createRoundtableService } from './service.js';
-
-// Application boundary: validate identity/scope against Fuli, not the local log.
-export function createFuliRoundtableService({ app, dataDir }) {
-  let core;
-  const getCore = () => {
-    if (core) return core;
-    mkdirSync(dataDir, { recursive: true });
-    return core = createRoundtableService({ databasePath: join(dataDir, 'roundtables.sqlite'),
-    contextProvider: async ({ binding, seat, actor }) => {
-      if (!binding || !seat.agentId || !seat.shareAgentContext) return null;
-      const agent = await app.getProjectAgent({ ...binding, agentId: seat.agentId });
-      if (!(agent.profile.allowedClients ?? []).includes(actor.sourceApplication)) {
-        return { status: 'client_not_allowed', guidance: 'Private Agent context requires an explicitly allowed authenticated client; shared room messages remain available.' };
-      }
-      return app.getProjectAgentContext({ personalProjectId: binding.personalProjectId,
-        agentId: seat.agentId, queries: [], sourceApplication: actor.sourceApplication });
-    },
-    verifyCompletion: async ({ binding }) => {
-      if (!binding?.taskId || !binding.artifactRevision) return { verified: false, taskStatus: 'unverified', evidence: [] };
-      const task = await app.viewProjectAgentTask({ ...binding, includeEvents: false });
-      const gate = await app.agentVerification('query', { ...binding });
-      return { verified: gate.status === 'passed' && task.status === 'completed',
-        taskStatus: task.status, evidence: [{ source: 'fuli_quality_gate', artifactRevision: binding.artifactRevision, status: gate.status }] };
-    }
-    });
-  };
-  return new Proxy({}, {
-    get(_target, property) {
-      if (property === 'bindingAuthority') return 'fuli_application';
-      if (property === 'then') return undefined;
-      if (property === 'close') return () => core?.close();
-      if (property !== 'create') return (...args) => getCore()[property](...args);
-      return async (input, actor) => {
-        let binding = input.binding ?? null;
-        let projectId = input.personalProjectId ?? binding?.personalProjectId;
-        if (input.projectPath && !projectId) {
-          const resolution = await app.listCurrentProjectAgents({ projectPath: input.projectPath });
-          projectId = resolution.personal_project_id;
-          if (!projectId) throw new TypeError('Register or select the exact Fuli project; no ambiguous project is inferred');
-        }
-        if (projectId) {
-          const spaceId = app.config.personal.spaceId;
-          if (binding?.personalSpaceId && binding.personalSpaceId !== spaceId) throw new TypeError('Roundtable must use the active personal space');
-          const projects = await app.listPersonalProjects({ personalSpaceId: spaceId });
-          if (!projects.some((project) => project.project_id === projectId)) throw new TypeError('Fuli project not found');
-          binding = { personalSpaceId: spaceId, personalProjectId: projectId,
-            taskId: binding?.taskId ?? null, artifactRevision: binding?.artifactRevision ?? null };
-          if (binding.taskId) {
-            if (!binding.artifactRevision) throw new TypeError('Fuli task binding requires its current artifact revision');
-            await app.viewProjectAgentTask({ ...binding, includeEvents: false });
-          }
-          for (const seat of input.seats ?? []) {
-            if (seat.agentId) {
-              const agent = await app.getProjectAgent({ ...binding, agentId: seat.agentId });
-              if (agent.profile.status !== 'active') throw new TypeError('Roundtable requires an active Fuli Agent');
-            }
-          }
-        } else {
-          if ((input.seats ?? []).some((seat) => seat.agentId || seat.shareAgentContext)) throw new TypeError('Fuli Agent binding requires an exact project');
-          binding = null;
-        }
-        return getCore().create({ ...input, binding }, actor);
-      };
-    }
-  });
-}

package/src/roundtables/domain.js

@@ -1,181 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { posix, win32 } from 'node:path';
-
-export const DEFAULT_LIMITS = Object.freeze({ maxRounds: 3, maxMessages: 30, maxPeerMessages: 100, maxDurationMs: 1_800_000, turnTimeoutMs: 300_000 });
-export const TERMINAL_STATUSES = new Set(['concluded', 'failed', 'cancelled']);
-const ROLES = new Set(['moderator', 'specialist', 'implementer', 'reviewer']);
-const RUNTIMES = new Set(['mcp', 'codex', 'claude-code', 'pi', 'grok', 'a2a']);
-const PHASES = ['discussion', 'planning', 'implementation', 'review', 'synthesis'];
-
-export class RoundtableError extends Error {
-  constructor(code, message, statusCode = 400) {
-    super(message);
-    this.name = 'RoundtableError';
-    this.code = code;
-    this.statusCode = statusCode;
-    this.status = statusCode;
-  }
-}
-
-export function fail(code, message, status = 400) { throw new RoundtableError(code, message, status); }
-
-export function text(value, name, max = 16_384) {
-  if (typeof value !== 'string' || !value.trim() || Buffer.byteLength(value, 'utf8') > max) fail('invalid_input', `${name} must be nonempty and at most ${max} UTF-8 bytes`);
-  return value.trim();
-}
-
-export function normalizeLimits(input = {}) {
-  const limits = { ...DEFAULT_LIMITS };
-  for (const [key, maximum] of Object.entries(DEFAULT_LIMITS)) {
-    const value = input[key] ?? maximum;
-    if (!Number.isSafeInteger(value) || value < 1 || value > maximum) fail('invalid_limits', `${key} must be between 1 and ${maximum}`);
-    limits[key] = value;
-  }
-  limits.turnTimeoutMs = Math.min(limits.turnTimeoutMs, limits.maxDurationMs);
-  return limits;
-}
-
-export function newRoom(input, now) {
-  if (!['discussion', 'collaboration'].includes(input.mode ?? 'discussion')) fail('invalid_mode', 'Unknown roundtable mode');
-  if (!Array.isArray(input.seats) || input.seats.length < 2 || input.seats.length > 6) fail('invalid_seats', 'Choose between two and six seats');
-  const seats = input.seats.map(raw => {
-    const id = text(raw.id ?? randomUUID(), 'seat.id', 128);
-    if (!input.binding && (raw.agentId || raw.shareAgentContext === true)) fail('invalid_binding', 'Standalone seats cannot claim a Fuli Agent identity or private context');
-    if (!ROLES.has(raw.role)) fail('invalid_role', 'Unknown seat role');
-    if (!RUNTIMES.has(raw.runtime ?? 'mcp')) fail('invalid_runtime', 'Unknown participant runtime');
-    const execution = { permission: 'read-only', workspace: null };
-    if (raw.execution?.permission === 'workspace-write') {
-      if (raw.role !== 'implementer') fail('invalid_permission', 'Only implementer seats can receive workspace write permission');
-      execution.permission = 'workspace-write';
-      execution.workspace = text(raw.execution.workspace, 'execution.workspace', 4096);
-      if (!posix.isAbsolute(execution.workspace) && !win32.isAbsolute(execution.workspace)) fail('invalid_workspace', 'Write permission requires an explicit absolute workspace');
-    } else if (raw.execution?.permission && raw.execution.permission !== 'read-only') fail('invalid_permission', 'Unknown execution permission');
-    return { id, name: text(raw.name, 'seat.name', 256), role: raw.role, runtime: raw.runtime ?? 'mcp', agentId: raw.agentId ? text(raw.agentId, 'seat.agentId', 256) : null, shareAgentContext: raw.shareAgentContext === true, identityKind: input.binding && raw.agentId ? 'fuli' : 'standalone', execution, selfProfile: null, joinedAt: null, joinedInvitationId: null, sourceApplication: null, sourceSessionId: null };
-  });
-  if (new Set(seats.map(s => s.id)).size !== seats.length) fail('duplicate_seat', 'Seat IDs must be distinct');
-  if (seats.filter(s => s.role === 'moderator').length !== 1) fail('invalid_moderator', 'Exactly one moderator is required');
-  if (input.mode === 'collaboration' && (!seats.some(seat => seat.role === 'implementer') || !seats.some(seat => seat.role === 'reviewer'))) {
-    fail('missing_collaboration_role', 'Collaboration requires an implementer and an independent reviewer');
-  }
-  const id = randomUUID();
-  let binding = null;
-  if (input.binding) {
-    binding = { personalSpaceId: text(input.binding.personalSpaceId, 'binding.personalSpaceId', 256) };
-    const projectKey = input.binding.personalProjectId ? 'personalProjectId' : 'projectId';
-    binding[projectKey] = text(input.binding[projectKey], `binding.${projectKey}`, 256);
-    for (const key of ['taskId', 'coordinatedTaskId', 'artifactRevision']) if (input.binding[key] !== undefined && input.binding[key] !== null) binding[key] = text(input.binding[key], `binding.${key}`, 256);
-  }
-  const implementers = seats.filter(s => s.role === 'implementer');
-  const tasks = input.mode === 'collaboration' ? implementationTasks(input.tasks, implementers, id, input.goal) : [];
-  if (input.mode === 'collaboration') {
-    for (const seat of seats.filter(s => s.role === 'reviewer')) tasks.push({ id: `${id}:review:${seat.id}`, title: 'Review implementation / 审查实施', instructions: input.goal, seatId: seat.id, phase: 'review', status: 'pending', dependencies: tasks.filter(t => t.phase === 'implementation').map(t => t.id), permission: 'read-only', workspace: null, artifacts: [], verification: null });
-  }
-  return { id, goal: text(input.goal, 'goal'), mode: input.mode ?? 'discussion', binding, scope: binding ? { kind: 'fuli', ...binding } : { kind: 'temporary', id: `temporary:${id}`, label: 'Temporary collaboration / 临时协作', identityAuthority: 'standalone' }, seats, limits: normalizeLimits(input.limits), status: 'draft', phase: 'discussion', revision: 0, round: 1, phaseIndex: 0, agentMessageCount: 0, peerMessageCount: 0, nextSeq: 1, nextTurnNumber: 1, createdAt: now, updatedAt: now, startedAt: null, stopReason: null, currentTurn: null, turns: [], tasks, outcome: null, events: [] };
-}
-
-function implementationTasks(input, implementers, roomId, goal) {
-  if (input !== undefined && (!Array.isArray(input) || !input.length || input.length > 24)) fail('invalid_tasks', 'Provide between one and 24 tasks');
-  const supplied = input ?? implementers.map((seat, index) => ({ id: `${roomId}:implementation:${seat.id}`, title: `Implement: ${seat.name}`, seatId: seat.id, instructions: goal, dependsOn: index ? [`${roomId}:implementation:${implementers[index - 1].id}`] : [] }));
-  const tasks = supplied.map(raw => {
-    const seat = implementers.find(s => s.id === raw.seatId);
-    if (!seat) fail('invalid_task_seat', 'Tasks can only be assigned to this room\'s implementer seats');
-    const dependencies = raw.dependsOn ?? [];
-    if (!Array.isArray(dependencies) || dependencies.length > 24) fail('invalid_dependencies', 'Task dependencies must be a bounded list');
-    return { id: text(raw.id ?? randomUUID(), 'task.id', 256), title: text(raw.title, 'task.title', 512), instructions: text(raw.instructions ?? goal, 'task.instructions', 8192), seatId: seat.id, phase: 'implementation', status: 'pending', dependencies: dependencies.map(dep => text(dep, 'task dependency', 256)), permission: seat.execution.permission, workspace: seat.execution.workspace, artifacts: [], verification: null };
-  });
-  if (new Set(tasks.map(task => task.id)).size !== tasks.length) fail('duplicate_task', 'Task IDs must be distinct');
-  const byId = new Map(tasks.map(task => [task.id, task])), visiting = new Set(), visited = new Set();
-  const visit = id => {
-    if (visiting.has(id)) fail('task_cycle', 'Task dependencies must be acyclic');
-    if (visited.has(id)) return;
-    const task = byId.get(id); if (!task) fail('invalid_dependencies', 'Dependencies must refer to tasks in this room');
-    visiting.add(id); for (const dependency of task.dependencies) visit(dependency); visiting.delete(id); visited.add(id);
-  };
-  for (const task of tasks) visit(task.id);
-  if (input) for (const seat of implementers) if (!tasks.some(t => t.seatId === seat.id)) fail('unassigned_implementer', 'Every implementer needs an assigned task');
-  // A seat reports one bundle per turn; bundle dependencies must also be acyclic.
-  orderedImplementers(implementers, tasks);
-  return tasks;
-}
-
-function orderedImplementers(seats, tasks) {
-  const pending = [...seats], result = [], byId = new Map(tasks.map(t => [t.id, t]));
-  while (pending.length) {
-    const index = pending.findIndex(seat => tasks.filter(t => t.seatId === seat.id).every(task => task.dependencies.every(id => byId.get(id).seatId === seat.id || result.some(done => done.id === byId.get(id).seatId))));
-    if (index < 0) fail('task_bundle_cycle', 'Dependencies between seat task bundles must be acyclic');
-    result.push(pending.splice(index, 1)[0]);
-  }
-  return result;
-}
-
-export function assertMutable(room) {
-  if (TERMINAL_STATUSES.has(room.status)) fail('terminal_room', 'Terminal roundtables are immutable', 409);
-}
-
-export function event(room, kind, now, details = {}) {
-  room.events.push({ id: randomUUID(), kind, createdAt: now, ...details });
-  // Events are operational metadata; the immutable message and attempt history is retained.
-  if (room.events.length > 500) room.events.shift();
-}
-
-export function phaseSeats(room) {
-  if (room.phase === 'discussion') return room.seats;
-  if (room.phase === 'planning' || room.phase === 'synthesis') return room.seats.filter(s => s.role === 'moderator');
-  const seats = room.seats.filter(s => s.role === (room.phase === 'implementation' ? 'implementer' : 'reviewer'));
-  return room.phase === 'implementation' ? orderedImplementers(seats, room.tasks.filter(t => t.phase === 'implementation')) : seats;
-}
-
-export function scheduleTurn(room, now) {
-  if (room.status !== 'active' || room.currentTurn) return;
-  const seat = phaseSeats(room)[room.phaseIndex];
-  if (!seat) {
-    room.status = 'waiting_input';
-    room.stopReason = `missing_${room.phase}_seat`;
-    event(room, 'phase_blocked', now, { reason: room.stopReason });
-    return;
-  }
-  const tasks = room.tasks.filter(t => t.phase === room.phase && t.seatId === seat.id), task = tasks[0];
-  if (tasks.some(assigned => assigned.dependencies.some(id => { const dependency = room.tasks.find(t => t.id === id); return dependency?.seatId !== seat.id && dependency?.status !== 'reported_complete'; }))) {
-    room.status = 'waiting_input'; room.stopReason = 'task_dependencies_incomplete'; return;
-  }
-  room.currentTurn = { id: `${room.id}:turn:${room.nextTurnNumber++}`, seatId: seat.id, phase: room.phase, round: room.round, status: 'pending', fence: 0, attemptId: null, deadline: null, taskId: task?.id ?? null, taskIds: tasks.map(t => t.id), attempts: [] };
-}
-
-export function finishTurn(room, now) {
-  const turn = room.currentTurn;
-  room.turns.push(turn);
-  room.currentTurn = null;
-  room.phaseIndex += 1;
-  if (room.phaseIndex < phaseSeats(room).length) { scheduleTurn(room, now); return; }
-  room.phaseIndex = 0;
-  if (room.phase === 'discussion' && room.round < room.limits.maxRounds) { room.round += 1; scheduleTurn(room, now); return; }
-  if (room.phase === 'synthesis') {
-    room.status = room.mode === 'discussion' ? 'concluded' : 'waiting_input';
-    room.stopReason = room.mode === 'discussion' ? null : 'owner_completion_required';
-    if (room.outcome) room.outcome.acceptance = 'pending';
-    event(room, 'synthesis_complete', now, { status: room.status });
-    return;
-  }
-  room.phase = room.mode === 'discussion' ? 'synthesis' : PHASES[PHASES.indexOf(room.phase) + 1];
-  event(room, 'phase_changed', now, { phase: room.phase });
-  scheduleTurn(room, now);
-}
-
-export function budgetReason(room, now) {
-  if (room.startedAt !== null && now - room.startedAt >= room.limits.maxDurationMs) return 'duration_limit';
-  if (room.agentMessageCount >= room.limits.maxMessages) return 'message_limit';
-  return null;
-}
-
-export function publicRoom(room) {
-  const { nextSeq, nextTurnNumber, phaseIndex, currentTurn, turns, tasks, outcome, events, ...result } = room;
-  return structuredClone({ ...result, phaseIndex, seats: room.seats.map(publicSeat) });
-}
-
-export function publicSeat(seat) { const { joinedInvitationId, ...result } = seat; return structuredClone(result); }
-
-export function publicTurn(turn) {
-  if (!turn) return null;
-  const { attempts, ...result } = turn;
-  return structuredClone(result);
-}

package/src/roundtables/http-router.js

@@ -1,58 +0,0 @@
-import { readJson, sendJson } from '../http/response.js';
-
-const owner = Object.freeze({ kind: 'owner' });
-
-// The parent local-console request policy must authorize the owner before entry.
-export async function handleRoundtableApiRequest({ request, response, url, service }) {
-  if (!service || !url.pathname.startsWith('/api/roundtables')) return false;
-  if (url.pathname === '/api/roundtables') {
-    if (request.method === 'GET') sendJson(response, 200, await service.list({}, owner));
-    else if (request.method === 'POST') {
-      const input = await readJson(request);
-      if (service.bindingAuthority !== 'fuli_application' &&
-          (input.binding || input.projectPath || input.personalProjectId || (input.seats ?? []).some((seat) => seat.agentId || seat.shareAgentContext))) {
-        throw new TypeError('Standalone rooms cannot claim a Fuli project or Agent; connect the validated Fuli application');
-      }
-      sendJson(response, 201, await service.create(input, owner));
-    }
-    else sendJson(response, 405, { error: 'Method not allowed' });
-    return true;
-  }
-  const route = url.pathname.match(/^\/api\/roundtables\/([^/]+)(?:\/(control|messages|invites|revoke))?$/);
-  if (!route) { sendJson(response, 404, { error: 'Roundtable route not found' }); return true; }
-  const roomId = decodeURIComponent(route[1]);
-  if (!route[2] && request.method === 'GET') {
-    const after = Number(url.searchParams.get('after') ?? 0);
-    const limit = Number(url.searchParams.get('limit') ?? 100);
-    sendJson(response, 200, await service.read({ roomId, after, limit }, owner));
-  } else if (route[2] && request.method === 'POST') {
-    const methods = { control: 'control', messages: 'addHumanMessage', invites: 'invite', revoke: 'revoke' };
-    const body = await readJson(request);
-    const { actor: _actor, taskVerification: _fakeVerification, ...safe } = body;
-    sendJson(response, 200, await service[methods[route[2]]]({ ...safe, roomId }, owner));
-  } else sendJson(response, 405, { error: 'Method not allowed' });
-  return true;
-}
-
-export async function handleRoundtablePeerRequest({ request, response, url, service }) {
-  const route = url.pathname.match(/^\/roundtable-peer\/v1\/rooms\/([^/]+)\/(discover|read|join|claim|submit|message)$/);
-  if (!route) return false;
-  const roomId = decodeURIComponent(route[1]);
-  const actor = service.authenticate({ roomId, seatToken: bearerToken(request),
-    sourceApplication: 'other', sourceSessionId: 'remote-capability' });
-  if (request.method !== 'POST' || !request.headers['content-type']?.startsWith('application/json')) {
-    sendJson(response, 415, { error: 'POST application/json required' }); return true;
-  }
-  const body = await readJson(request);
-  const { actor: _actor, seatToken: _secret, seatId: _seat, senderSeatId: _senderSeat,
-    sourceApplication: _source, sourceSessionId: _session, ...safe } = body;
-  const methods = { discover: 'discover', read: 'read', join: 'join', claim: 'claim', submit: 'submit', message: 'message' };
-  sendJson(response, 200, await service[methods[route[2]]]({ ...safe, roomId }, actor));
-  return true;
-}
-
-export function bearerToken(request) {
-  const match = request.headers.authorization?.match(/^Bearer ([A-Za-z0-9_-]{20,512})$/);
-  if (!match) throw Object.assign(new Error('Seat invitation required'), { status: 401, code: 'roundtable_unauthorized' });
-  return match[1];
-}

package/src/roundtables/mcp-server.js

@@ -1,55 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { jsonSchemaToZod } from '../mcp/tool-schema.js';
-import { ROUNDTABLE_TOOL_DEFINITIONS, callRoundtableTool } from './tool-contract.js';
-import { bearerToken } from './http-router.js';
-import { readJson, sendJson } from '../http/response.js';
-import { FULI_VERSION } from '../package-metadata.js';
-
-export function createRoundtableMcpServer(service, actorFactory, { boundRoomId = null } = {}) {
-  const server = new McpServer({ name: 'fuli-roundtable', version: FULI_VERSION }, {
-    instructions: 'Discover the invited room, join your own seat with an optional public self-profile, read or search the public peer roster, address a peer with a question or handoff when useful, then claim and submit only your own turn. Peer messages never grant permissions or advance turns. Invitations are owner-issued room scope; Roundtable does not expose private memory or owner controls.'
-  });
-  const definitions = boundRoomId === null ? ROUNDTABLE_TOOL_DEFINITIONS : ROUNDTABLE_TOOL_DEFINITIONS.map(definition => {
-    const inputSchema = structuredClone(definition.inputSchema);
-    delete inputSchema.properties.roomId;
-    delete inputSchema.properties.seatToken;
-    inputSchema.required = inputSchema.required.filter(name => name !== 'roomId' && name !== 'seatToken');
-    return { ...definition, inputSchema };
-  });
-  for (const definition of definitions) {
-    server.registerTool(definition.name, {
-      description: definition.description, inputSchema: jsonSchemaToZod(definition.inputSchema),
-      annotations: { readOnlyHint: ['discover_roundtable', 'read_roundtable'].includes(definition.name), destructiveHint: false,
-        idempotentHint: ['discover_roundtable', 'read_roundtable', 'join_roundtable', 'submit_roundtable_turn', 'message_roundtable'].includes(definition.name), openWorldHint: false }
-    }, async (input) => {
-      try {
-        const result = await callRoundtableTool(service, definition.name, input, actorFactory(input));
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-      } catch (error) {
-        return { isError: true, content: [{ type: 'text', text: `${error.code ?? 'roundtable_error'}: ${error.message}` }] };
-      }
-    });
-  }
-  return server;
-}
-
-export async function handleRoundtableMcpRequest({ request, response, url, service }) {
-  const route = url.pathname.match(/^\/roundtable-peer\/v1\/rooms\/([^/]+)\/mcp$/);
-  if (!route) return false;
-  const roomId = decodeURIComponent(route[1]);
-  const secret = bearerToken(request);
-  const actorFactory = (input = {}) => {
-    if (input.roomId !== undefined && input.roomId !== roomId) throw Object.assign(new Error('Invitation is bound to another room'), { code: 'roundtable_forbidden' });
-    return service.authenticate({ roomId, seatToken: secret, sourceApplication: 'other', sourceSessionId: 'remote-mcp-capability' });
-  };
-  actorFactory({ roomId }); // Authenticate even initialize/list requests.
-  if (request.method !== 'POST') { sendJson(response, 405, { error: 'This MCP endpoint uses stateless POST responses' }); return true; }
-  const server = createRoundtableMcpServer(service, actorFactory, { boundRoomId: roomId });
-  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
-  try {
-    await server.connect(transport);
-    await transport.handleRequest(request, response, await readJson(request));
-  } finally { await server.close(); }
-  return true;
-}

package/src/roundtables/participant-registry.js

@@ -1,12 +0,0 @@
-import { createCodexParticipant } from '../agents/codex/roundtable-participant.js';
-import { createClaudeCodeParticipant } from '../agents/claude-code/roundtable-participant.js';
-import { createGrokParticipant } from '../agents/grok/roundtable-participant.js';
-import { createA2AParticipant } from '../agents/a2a/roundtable-participant.js';
-import { createPiParticipant } from '../agents/pi/roundtable-participant.js';
-
-export function createRoundtableParticipant(runtime, options) {
-  const factories = { codex: createCodexParticipant, 'claude-code': createClaudeCodeParticipant,
-    grok: createGrokParticipant, a2a: createA2AParticipant, pi: createPiParticipant };
-  if (!factories[runtime]) throw new TypeError('Select codex, claude-code, pi, grok or a2a; MCP seats join through their client');
-  return factories[runtime](options);
-}

package/src/roundtables/process.js

@@ -1,70 +0,0 @@
-import { spawn } from 'node:child_process';
-
-// Own exactly one child/process group; never search for or kill unrelated clients.
-export function runParticipantProcess(command, args, { cwd, env = process.env, signal,
-  input, timeoutMs = 300_000, maxOutputBytes = 2_000_000 } = {}) {
-  signal?.throwIfAborted();
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, env, shell: false, windowsHide: true,
-      detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
-    let output = '', outputBytes = 0, failure, settled = false, hardTimer;
-    const kill = () => {
-      if (!child.pid) return;
-      if (process.platform === 'win32') {
-        const killer = spawn('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore', shell: false });
-        killer.on('error', () => child.kill()); killer.unref();
-      } else { try { process.kill(-child.pid, 'SIGKILL'); } catch {} }
-    };
-    const finish = (error, code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer); clearTimeout(hardTimer); signal?.removeEventListener('abort', abort);
-      kill(); child.stdin.destroy(); child.stdout.destroy(); child.stderr.destroy(); child.unref();
-      if (error || failure) reject(error ?? failure); else resolve({ code, stdout: output });
-    };
-    const stop = (code) => {
-      if (failure || settled) return;
-      failure = Object.assign(new Error(code), { code }); kill();
-      hardTimer = setTimeout(() => finish(failure), 2000);
-    };
-    const abort = () => stop('cancelled');
-    const timer = setTimeout(() => stop('turn_timeout'), timeoutMs);
-    signal?.addEventListener('abort', abort, { once: true });
-    child.stdout.on('data', (chunk) => {
-      outputBytes += chunk.length;
-      if (outputBytes > maxOutputBytes) { stop('output_too_large'); return; }
-      output += chunk.toString('utf8');
-    });
-    // Drain upstream stderr without echoing keys, prompts, settings or credentials.
-    child.stderr.on('data', () => {});
-    child.on('error', () => finish(Object.assign(new Error('Participant process unavailable'), { code: 'runtime_unavailable' })));
-    child.on('close', (code) => finish(null, code));
-    child.stdin.on('error', () => {});
-    child.stdin.end(input);
-  });
-}
-
-export function parseParticipantEvents(application, result) {
-  const events = result.stdout.split(/\r?\n/).flatMap((line) => { try { return [JSON.parse(line)]; } catch { return []; } });
-  let body = '', sessionId = null, usage = null, failed = result.code !== 0;
-  let codexCompleted = false, pendingCodexError = false;
-  for (const event of events) {
-    sessionId ??= event.thread_id ?? event.session_id ?? null;
-    if (application === 'codex') {
-      if (event.type === 'item.completed' && event.item?.type === 'agent_message') body = event.item.text ?? '';
-      if (event.type === 'turn.completed') {
-        usage = event.usage ?? null; codexCompleted = true; pendingCodexError = false;
-      }
-      if (event.type === 'error') pendingCodexError = true;
-      if (event.type === 'turn.failed') failed = true;
-    } else if (event.type === 'result') {
-      body = event.structured_output ? JSON.stringify(event.structured_output) : event.result ?? ''; usage = event.usage ?? null; failed ||= Boolean(event.is_error);
-    }
-  }
-  const actual = { sourceApplication: application, sessionId, model: null,
-    usage: usage ? { source: 'executor', ...usage } : null, evidenceLevel: 'real_cli' };
-  if (application === 'codex' && (!codexCompleted || pendingCodexError)) failed = true;
-  if (failed) throw Object.assign(new Error('Participant execution failed; inspect client authorization locally'), { code: 'runtime_failed', actual });
-  if (!body || Buffer.byteLength(body) > 16_384) throw Object.assign(new Error('Participant final response missing or too large'), { code: 'response_invalid', actual });
-  return { body, actual };
-}

package/src/roundtables/profiles.js

@@ -1,84 +0,0 @@
-import { fail, text } from './domain.js';
-
-export const ROUNDTABLE_PROTOCOL = Object.freeze({
-  name: 'fuli-roundtable',
-  version: '1'
-});
-
-const MAX_PROFILE_CAPABILITIES = 32;
-const MAX_CAPABILITY_BYTES = 128;
-const MAX_QUERY_BYTES = 128;
-
-/**
- * Self profiles are public declarations. They never change the coordinator's
- * seat role, runtime, execution permission or private Agent context.
- */
-export function normalizeSelfProfile(value) {
-  if (value === undefined || value === null) return null;
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    fail('invalid_self_profile', 'selfProfile must be an object');
-  }
-  const result = {};
-  if (value.responsibility !== undefined) result.responsibility = text(value.responsibility, 'selfProfile.responsibility', 2048);
-  if (value.introduction !== undefined) result.introduction = text(value.introduction, 'selfProfile.introduction', 2048);
-  if (value.capabilities !== undefined) {
-    if (!Array.isArray(value.capabilities) || value.capabilities.length > MAX_PROFILE_CAPABILITIES) {
-      fail('invalid_self_profile', `selfProfile.capabilities must contain at most ${MAX_PROFILE_CAPABILITIES} entries`);
-    }
-    const capabilities = value.capabilities.map((capability) => text(capability, 'selfProfile.capability', MAX_CAPABILITY_BYTES));
-    if (new Set(capabilities.map(capability => capability.toLocaleLowerCase())).size !== capabilities.length) {
-      fail('invalid_self_profile', 'selfProfile.capabilities must be unique');
-    }
-    result.capabilities = capabilities;
-  }
-  if (!Object.keys(result).length) fail('invalid_self_profile', 'selfProfile must declare responsibility, capabilities or introduction');
-  return result;
-}
-
-export function normalizeCapabilityQuery(value) {
-  if (value === undefined || value === null || value === '') return null;
-  return text(value, 'capabilityQuery', MAX_QUERY_BYTES).toLocaleLowerCase();
-}
-
-export function matchesCapabilityQuery(seat, query) {
-  if (!query) return true;
-  const profile = seat.selfProfile;
-  return Array.isArray(profile?.capabilities) && profile.capabilities.some(capability => capability.toLocaleLowerCase().includes(query));
-}
-
-export function publicRoster(seats, query = null) {
-  return seats.filter(seat => matchesCapabilityQuery(seat, query));
-}
-
-export function nextRoundtableAction(room, seat) {
-  if (!seat.joinedAt) return { action: 'join', required: true, seatId: seat.id, reason: 'seat_not_joined' };
-  if (room.status === 'concluded' || room.status === 'cancelled' || room.status === 'failed') {
-    return { action: 'done', required: false, reason: room.status };
-  }
-  const turn = room.currentTurn;
-  if (turn) {
-    const ownTurn = turn.seatId === seat.id;
-    if (room.status !== 'active') {
-      return { action: 'wait', required: ownTurn, reason: room.stopReason ?? room.status, turnId: turn.id, seatId: turn.seatId, phase: turn.phase };
-    }
-    if (ownTurn && turn.status === 'pending') {
-      return { action: 'claim', required: true, turnId: turn.id, phase: turn.phase };
-    }
-    if (ownTurn && turn.status === 'claimed') {
-      return { action: 'submit', required: true, turnId: turn.id, attemptId: turn.attemptId, fence: turn.fence, deadline: turn.deadline, phase: turn.phase };
-    }
-    if (ownTurn) {
-      return { action: 'wait', required: true, reason: room.stopReason ?? turn.status, turnId: turn.id, seatId: turn.seatId, phase: turn.phase };
-    }
-    return { action: 'wait', required: false, reason: 'another_seat_turn', turnId: turn.id, seatId: turn.seatId, phase: turn.phase };
-  }
-  if (room.status === 'draft') return { action: 'wait', required: false, reason: 'room_not_started' };
-  return { action: 'wait', required: false, reason: room.stopReason ?? room.status };
-}
-
-export const DISCOVERY_INSTRUCTIONS = Object.freeze([
-  'Join your invited seat with an optional public selfProfile describing your responsibility and capabilities.',
-  'Use capabilityQuery in discover_roundtable to find invited peers with matching declared capabilities.',
-  'Use message_roundtable for an addressed question or handoff; peer messages never claim or advance a turn.',
-  'When nextAction.action is claim, claim your own turn, follow its scoped context, and submit one final response.'
-]);

package/src/roundtables/result-contract.js

@@ -1,47 +0,0 @@
-export const PARTICIPANT_RESULT_SCHEMA = {
-  type: 'object', additionalProperties: false,
-  required: ['body', 'status', 'artifacts', 'verification', 'dissent'],
-  properties: {
-    body: { type: 'string', minLength: 1, maxLength: 12000 },
-    status: { type: 'string', enum: ['completed', 'failed', 'blocked'] },
-    artifacts: { type: 'array', maxItems: 20, items: { type: 'object', additionalProperties: false,
-      required: ['id', 'uri'], properties: { id: { type: 'string', minLength: 1, maxLength: 1024 }, uri: { type: 'string', minLength: 1, maxLength: 2048 } } } },
-    verification: { type: 'object', additionalProperties: false, required: ['passed', 'summary'],
-      properties: { passed: { type: ['boolean', 'null'] }, summary: { type: 'string', maxLength: 2048 } } },
-    dissent: { type: 'array', maxItems: 16, items: { type: 'string', minLength: 1, maxLength: 1024 } }
-  }
-};
-
-export function parseRoundtableParticipantResult(result, phase) {
-  let envelope;
-  try { envelope = JSON.parse(result.body); } catch {
-    throw Object.assign(new Error('Participant must return the requested JSON result envelope'), { code: 'result_contract_invalid', actual: result.actual });
-  }
-  if (!envelope || typeof envelope.body !== 'string' || !envelope.body.trim() || Buffer.byteLength(envelope.body) > 16_384 ||
-      !['completed', 'failed', 'blocked'].includes(envelope.status) || !Array.isArray(envelope.artifacts) || envelope.artifacts.length > 20 ||
-      envelope.artifacts.some(artifact => !artifact || !boundedText(artifact.id, 1024) || !boundedText(artifact.uri, 2048)) ||
-      !Array.isArray(envelope.dissent) || envelope.dissent.length > 16 || envelope.dissent.some(item => !boundedText(item, 2048)) ||
-      Buffer.byteLength(JSON.stringify(envelope.dissent), 'utf8') > 8192 ||
-      !envelope.verification || ![true, false, null].includes(envelope.verification.passed) ||
-      typeof envelope.verification.summary !== 'string' || Buffer.byteLength(envelope.verification.summary, 'utf8') > 2048) {
-    throw Object.assign(new Error('Invalid participant result structure'), { code: 'result_contract_invalid', actual: result.actual });
-  }
-  if (envelope.status === 'completed' && phase === 'review' && typeof envelope.verification.passed !== 'boolean') {
-    throw Object.assign(new Error('Review requires an explicit verification verdict'), { code: 'review_verdict_required', actual: result.actual });
-  }
-  if (envelope.status === 'completed' && phase === 'implementation' && envelope.artifacts.length === 0) {
-    throw Object.assign(new Error('Implementation requires actual artifact references'), { code: 'artifact_required', actual: result.actual });
-  }
-  const artifacts = [...envelope.artifacts, ...(Array.isArray(result.artifacts) ? result.artifacts : [])];
-  if (artifacts.length > 20 || artifacts.some(artifact => typeof artifact === 'string' ? !boundedText(artifact, 1024) :
-    !artifact || !boundedText(artifact.id ?? artifact.artifactId, 1024) ||
-    ['name', 'uri', 'mimeType', 'kind'].some(key => artifact[key] !== undefined && !boundedText(artifact[key], 2048)))) {
-    throw Object.assign(new Error('Invalid or excessive adapter artifact references'), { code: 'result_contract_invalid', actual: result.actual });
-  }
-  return { ...result, body: envelope.body, status: envelope.status,
-    artifacts, verification: envelope.verification, dissent: envelope.dissent };
-}
-
-function boundedText(value, bytes) {
-  return typeof value === 'string' && Boolean(value.trim()) && Buffer.byteLength(value, 'utf8') <= bytes;
-}

package/src/roundtables/server.js

@@ -1,52 +0,0 @@
-import { createServer } from 'node:http';
-import { mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { createRoundtableService } from './service.js';
-import { handleRoundtableApiRequest, handleRoundtablePeerRequest } from './http-router.js';
-import { handleRoundtableMcpRequest } from './mcp-server.js';
-import { serveStatic } from '../http/static-handler.js';
-import { sendJson } from '../http/response.js';
-import { localServerAuthority, rejectRequestOutsidePolicy } from '../http/request-policy.js';
-import { mapHttpError } from '../http/error-mapping.js';
-
-export async function createRoundtableServer({ dataDir, service: configuredService,
-  port = 3738, host = '127.0.0.1', allowedHosts = [] } = {}) {
-  if (!configuredService && !dataDir) throw new TypeError('Roundtable data directory required');
-  if (dataDir) mkdirSync(dataDir, { recursive: true });
-  const service = configuredService ?? createRoundtableService({ databasePath: join(dataDir, 'roundtables.sqlite') });
-  let authority;
-  const server = createServer((request, response) => {
-    void (async () => {
-      const url = new URL(request.url, 'http://127.0.0.1');
-      if (url.pathname.startsWith('/roundtable-peer/')) {
-        // A public reverse proxy must preserve an explicitly allowed Host.
-        if (![authority, ...allowedHosts].includes(request.headers.host) || request.headers.origin) {
-          sendJson(response, 403, { error: 'Peer authority forbidden' }); return;
-        }
-        if (await handleRoundtableMcpRequest({ request, response, url, service }) ||
-            await handleRoundtablePeerRequest({ request, response, url, service })) return;
-        sendJson(response, 404, { error: 'Peer route not found' }); return;
-      }
-      const local = ['127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(request.socket.remoteAddress);
-      if (!local || rejectRequestOutsidePolicy({ request, response, authority })) {
-        if (!response.writableEnded) sendJson(response, 403, { error: 'Owner console is local only' }); return;
-      }
-      if (url.pathname === '/api/health') { sendJson(response, 200, { status: 'ready', service: 'fuli-roundtable' }); return; }
-      if (await handleRoundtableApiRequest({ request, response, url, service })) return;
-      if (url.pathname.startsWith('/api/')) { sendJson(response, 404, { error: 'Only Roundtable APIs are available on this coordinator' }); return; }
-      serveStatic(url.pathname, response);
-    })().catch((error) => {
-      if (response.headersSent || response.destroyed) return;
-      const mapped = error.status ? { status: error.status, body: { error: error.message, code: error.code } } : mapHttpError(error);
-      sendJson(response, mapped.status, mapped.body);
-    });
-  });
-  try {
-    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, host, resolve); });
-    authority = localServerAuthority(server.address());
-  } catch (error) { if (!configuredService) service.close(); throw error; }
-  let closing;
-  return { server, service, url: `http://${authority}`,
-    close: () => closing ??= new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()))
-      .finally(() => { if (!configuredService) service.close(); }) };
-}