fuli-context 0.9.0 → 0.11.0

package/src/agent-roundtable/service.js

@@ -0,0 +1,218 @@
+import { randomUUID } from 'node:crypto';
+
+import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
+import { WAKE_CLIENTS, resolveClientCommand, sessionWorkingDirectory, wakeAgent } from './wake.js';
+
+const CLIENT_LABELS = { claude_code: 'Claude Code', codex: 'Codex', cursor: 'Cursor', claude: 'Claude', other: 'Agent' };
+const THREAD_MESSAGE_LIMIT = 24;
+const NESTED_ASK_LIMIT = 3;
+
+// Agents talk to each other directly: an ask wakes the recipient in its own
+// client and returns its answer, or waits in its inbox for its next task.
+export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFactory = randomUUID,
+  locateCwd = sessionWorkingDirectory, clientAvailable = (client) => Boolean(resolveClientCommand(client)) }) {
+  const spaceId = () => app.config.personal.spaceId;
+  // Opened on first use: most MCP processes never touch the roundtable.
+  let opened = null;
+  const store = new Proxy({}, { get: (_target, property) => (opened ??= openStore())[property] });
+
+  async function sender({ taskContextToken, sourceApplication }) {
+    if (!taskContextToken) return { agent: null, client: sourceApplication ?? 'other', session: null, projectId: null };
+    const task = await app.taskContextRegistry.context(taskContextToken, sourceApplication);
+    return { agent: task.projectAgentId ? await agentById(task.projectAgentId) : null,
+      client: task.sourceApplication ?? sourceApplication, session: task.sessionId, projectId: task.personalProjectId };
+  }
+
+  async function agents() {
+    return (await app.listProjectAgents({ personalSpaceId: spaceId() }))
+      .filter((agent) => agent.profile.status === 'active');
+  }
+  async function agentById(agentId) {
+    return (await agents()).find((agent) => agent.agentId === agentId) ?? null;
+  }
+  async function recipient(to) {
+    const needle = String(to ?? '').trim().replace(/^@\{?|\}$/g, '');
+    const all = await agents();
+    const exact = all.find((agent) => agent.agentId === needle || agent.agentId === decodeURIComponent(needle));
+    if (exact) return exact;
+    const named = all.filter((agent) => [agent.profile.displayName, agent.profile.name]
+      .some((name) => name?.toLowerCase() === needle.toLowerCase()));
+    if (named.length === 1) return named[0];
+    throw validation(named.length
+      ? `More than one Agent is named "${needle}"; use its agentId: ${named.map((agent) => agent.agentId).join(', ')}`
+      : `No active Agent matches "${needle}". Call find_agents first.`);
+  }
+
+  async function conversations(agent, projectId) {
+    const sessions = await app.personal.recentAgentSessions({ personalSpaceId: spaceId(), agentId: agent.agentId,
+      personalProjectId: projectId ?? null, limit: 5 }).catch(() => []);
+    return sessions.filter((session) => WAKE_CLIENTS.includes(session.source_application))
+      .map((session) => ({ client: session.source_application, sessionId: session.session_id,
+        projectId: session.personal_project_id, lastActive: session.last_active }));
+  }
+
+  async function findAgents({ query = null, personalProjectId = null } = {}) {
+    const needle = query?.trim().toLowerCase();
+    const matches = (await agents()).filter((agent) => !needle || [agent.agentId, agent.profile.displayName,
+      agent.profile.name, agent.profile.responsibility, ...(agent.profile.capabilities ?? [])]
+      .some((value) => value?.toLowerCase().includes(needle)));
+    return { agents: await Promise.all(matches.slice(0, 20).map(async (agent) => ({
+      agentId: agent.agentId, name: label(agent), responsibility: agent.profile.responsibility,
+      clients: (agent.profile.allowedClients ?? []).filter((client) => WAKE_CLIENTS.includes(client)),
+      recentConversations: await conversations(agent, personalProjectId)
+    }))),
+    guidance: 'message_agent sends to an Agent (optionally one of its recentConversations) and returns its answer.' };
+  }
+
+  // Ordered attempts: the chosen conversation (or the Agent's latest one), then a
+  // fresh session with the Agent's memory in that client and in its other clients.
+  async function deliveryTargets(agent, conversation, projectId, projectPath) {
+    const allowed = (agent.profile.allowedClients ?? []).filter((client) => WAKE_CLIENTS.includes(client) && clientAvailable(client));
+    const explicit = Boolean(conversation) && !['auto', 'new'].includes(conversation);
+    let resumable = null;
+    if (conversation !== 'new') {
+      const known = await conversations(agent, null);
+      const candidates = explicit
+        ? known.filter((session) => session.sessionId === conversation)
+        : known.filter((session) => !projectId || session.projectId === projectId);
+      for (const session of candidates) {
+        if (!allowed.includes(session.client)) continue;
+        const cwd = locateCwd(session.client, session.sessionId);
+        if (cwd) { resumable = { client: session.client, sessionId: session.sessionId, cwd }; break; }
+      }
+      if (explicit && !resumable) throw validation('That conversation cannot be resumed on this machine');
+    }
+    const freshClients = resumable
+      ? [resumable.client, ...(explicit ? [] : allowed.filter((client) => client !== resumable.client))]
+      : WAKE_CLIENTS.filter((client) => allowed.includes(client));
+    const fresh = freshClients.map((client) => ({ client, sessionId: null,
+      cwd: client === resumable?.client ? resumable.cwd : projectPath ?? resumable?.cwd ?? process.cwd() }));
+    return resumable ? [resumable, ...fresh] : fresh;
+  }
+
+  async function messageAgent({ taskContextToken = null, sourceApplication, to, body, threadId = null,
+    conversation = 'auto', wait = true, timeoutSeconds = 300, projectPath = null } = {}) {
+    const from = await sender({ taskContextToken, sourceApplication });
+    const target = await recipient(to);
+    if (from.agent?.agentId === target.agentId && !threadId) throw validation('An Agent cannot open a thread with itself');
+    let thread = threadId ? store.getThread(threadId) : null;
+    if (threadId && (!thread || thread.space_id !== spaceId())) throw validation('Thread not found');
+    const history = thread ? store.messages(thread.id) : [];
+    if (history.length >= THREAD_MESSAGE_LIMIT) throw validation('This thread reached its message limit; start a new one');
+    thread ??= store.createThread({ id: idFactory(), spaceId: spaceId(), projectId: from.projectId,
+      subject: body.trim().split(/\r?\n/)[0].slice(0, 80) });
+    const ask = store.appendMessage(thread.id, { id: idFactory(), kind: 'ask', body, status: 'queued',
+      from: { agentId: from.agent?.agentId, name: from.agent ? label(from.agent) : CLIENT_LABELS[from.client] ?? from.client,
+        client: from.client, session: from.session },
+      to: { agentId: target.agentId, name: label(target) } });
+    const nested = history.filter((message) => message.kind === 'ask' && message.status === 'delivering').length;
+    if (!wait || nested >= NESTED_ASK_LIMIT) return queued(thread, ask, target, nested ? 'nested_limit' : 'not_waiting');
+    const attempts = await deliveryTargets(target, conversation, from.projectId, projectPath);
+    if (!attempts.length) return queued(thread, ask, target, 'no_client');
+    const prompt = wakePrompt({ thread, ask, target, senderName: ask.from_name, senderClient: from.client });
+    const timeoutMs = Math.min(Math.max(timeoutSeconds, 30), 900) * 1000;
+    const unusable = new Set();
+    let failure = 'wake_failed';
+    for (const delivery of attempts) {
+      if (unusable.has(delivery.client)) continue;
+      store.updateMessage(ask.id, { status: 'delivering', toClient: delivery.client, toSession: delivery.sessionId });
+      let answer;
+      try {
+        answer = await wake({ client: delivery.client, sessionId: delivery.sessionId, cwd: delivery.cwd, timeoutMs, prompt });
+      } catch (error) {
+        failure = error.code ?? 'wake_failed';
+        // A missing or logged-out client cannot answer from any session. A conversation
+        // open in its app, or a sub-agent thread, still allows a new session.
+        if (['client_login_required', 'client_unavailable'].includes(failure)) unusable.add(delivery.client);
+        // A timeout already used the caller's wait.
+        if (failure === 'wake_timeout') break;
+        continue;
+      }
+      const via = `${delivery.client}:${delivery.sessionId ? 'resume' : 'new'}`;
+      store.updateMessage(ask.id, { status: 'answered', via });
+      const reply = store.appendMessage(thread.id, { id: idFactory(), kind: 'reply', body: answer.body, status: 'sent',
+        inReplyTo: ask.id, via, from: { agentId: target.agentId, name: label(target), client: delivery.client,
+          session: answer.sessionId }, to: { agentId: from.agent?.agentId, name: ask.from_name, client: from.client, session: from.session } });
+      return { status: 'answered', threadId: thread.id, messageId: ask.id, recipient: { agentId: target.agentId, name: label(target) },
+        via, reply: reply.body };
+    }
+    store.updateMessage(ask.id, { status: 'queued', error: failure });
+    return queued(thread, ask, target, failure);
+  }
+
+  async function readMessages({ taskContextToken, sourceApplication }) {
+    const me = await sender({ taskContextToken, sourceApplication });
+    if (!me.agent) return { messages: [] };
+    return { messages: store.pendingFor(spaceId(), me.agent.agentId).map(inboxItem),
+      guidance: 'Answer each with reply_agent_message.' };
+  }
+
+  async function replyMessage({ taskContextToken, sourceApplication, messageId, body }) {
+    const me = await sender({ taskContextToken, sourceApplication });
+    const ask = store.getMessage(messageId);
+    if (!ask || ask.kind !== 'ask' || !me.agent || ask.to_agent !== me.agent.agentId) throw validation('No such message for this Agent');
+    if (ask.status === 'answered') throw validation('This message was already answered');
+    store.updateMessage(ask.id, { status: 'answered', via: `${me.client}:inbox` });
+    store.appendMessage(ask.thread_id, { id: idFactory(), kind: 'reply', body, status: 'sent', inReplyTo: ask.id,
+      via: `${me.client}:inbox`, from: { agentId: me.agent.agentId, name: label(me.agent), client: me.client, session: me.session },
+      to: { agentId: ask.from_agent, name: ask.from_name, client: ask.from_client, session: ask.from_session } });
+    return { status: 'sent', threadId: ask.thread_id };
+  }
+
+  function threads({ limit = 50 } = {}) {
+    return { threads: store.listThreads(spaceId(), { limit }).map((thread) => {
+      const messages = store.messages(thread.id);
+      const people = new Map();
+      for (const message of messages) {
+        for (const [agentId, name, client] of [[message.from_agent, message.from_name, message.from_client], [message.to_agent, message.to_name, message.to_client]]) {
+          const key = agentId ?? name;
+          if (key && !people.has(key)) people.set(key, { agentId, name, client });
+        }
+      }
+      const last = messages.at(-1);
+      return { id: thread.id, subject: thread.subject, projectId: thread.project_id, updatedAt: thread.updated_at,
+        messageCount: messages.length, participants: [...people.values()],
+        waiting: messages.some((message) => message.kind === 'ask' && message.status !== 'answered'),
+        last: last ? { from: last.from_name, body: last.body.slice(0, 160) } : null };
+    }) };
+  }
+
+  function thread({ threadId }) {
+    const record = store.getThread(threadId);
+    if (!record || record.space_id !== spaceId()) throw validation('Thread not found');
+    return { id: record.id, subject: record.subject, projectId: record.project_id, createdAt: record.created_at,
+      messages: store.messages(record.id).map((message) => ({ id: message.id, kind: message.kind, status: message.status,
+        body: message.body, inReplyTo: message.in_reply_to, via: message.via, error: message.error, createdAt: message.created_at,
+        from: { agentId: message.from_agent, name: message.from_name, client: message.from_client },
+        to: { agentId: message.to_agent, name: message.to_name, client: message.to_client } })) };
+  }
+
+  return { findAgents, messageAgent, readMessages, replyMessage, threads, thread,
+    pending: (agentId) => store.pendingFor(spaceId(), agentId).map(inboxItem),
+    close: () => opened?.close() };
+}
+
+function queued(thread, ask, target, reason) {
+  return { status: 'queued', threadId: thread.id, messageId: ask.id, reason,
+    recipient: { agentId: target.agentId, name: label(target) },
+    guidance: `${label(target)} will see this message when it next starts a task and answer with reply_agent_message.` };
+}
+
+function inboxItem(message) {
+  return { messageId: message.id, threadId: message.thread_id, from: message.from_name,
+    fromClient: message.from_client, body: message.body, createdAt: message.created_at };
+}
+
+function wakePrompt({ thread, target, senderName, senderClient, ask }) {
+  return `@{${encodeURIComponent(target.agentId)}} [FULI 圆桌 · ${thread.id}]\n`
+    + `${senderName}（${CLIENT_LABELS[senderClient] ?? senderClient}）发来消息：\n\n${ask.body}\n\n`
+    + `请直接回答对方，你的最终回复会原样转达。需要再问其他 Agent 时，调用 message_agent 并带上 threadId="${thread.id}"。`;
+}
+
+function label(agent) {
+  return agent.profile.displayName || agent.profile.name || agent.agentId;
+}
+
+function validation(message) {
+  return new ApplicationError(ApplicationErrorCode.VALIDATION, message);
+}

package/src/agent-roundtable/store.js

@@ -0,0 +1,86 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// Every Agent-to-Agent exchange is kept as a thread of messages so people can
+// see who talked to whom, through which client, and what was said. The file
+// is shared by the console and every client's MCP process.
+export function createRoundtableStore(path = ':memory:') {
+  if (path !== ':memory:') mkdirSync(dirname(path), { recursive: true });
+  const database = new DatabaseSync(path);
+  database.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA busy_timeout = 5000;
+    CREATE TABLE IF NOT EXISTS threads (
+      id TEXT PRIMARY KEY, space_id TEXT NOT NULL, project_id TEXT, subject TEXT NOT NULL,
+      created_at TEXT NOT NULL, updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY, thread_id TEXT NOT NULL REFERENCES threads(id), seq INTEGER NOT NULL,
+      kind TEXT NOT NULL, body TEXT NOT NULL, status TEXT NOT NULL, in_reply_to TEXT,
+      from_agent TEXT, from_name TEXT, from_client TEXT, from_session TEXT,
+      to_agent TEXT, to_name TEXT, to_client TEXT, to_session TEXT,
+      via TEXT, error TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+      UNIQUE(thread_id, seq)
+    );
+    CREATE INDEX IF NOT EXISTS messages_inbox ON messages(to_agent, status);
+    CREATE INDEX IF NOT EXISTS threads_recent ON threads(space_id, updated_at);
+  `);
+  const now = () => new Date().toISOString();
+  const transaction = (work) => {
+    database.exec('BEGIN IMMEDIATE');
+    try { const result = work(); database.exec('COMMIT'); return result; }
+    catch (error) { database.exec('ROLLBACK'); throw error; }
+  };
+
+  return {
+    createThread({ id, spaceId, projectId = null, subject }) {
+      const at = now();
+      database.prepare('INSERT INTO threads(id, space_id, project_id, subject, created_at, updated_at) VALUES(?,?,?,?,?,?)')
+        .run(id, spaceId, projectId, subject, at, at);
+      return this.getThread(id);
+    },
+    getThread(id) {
+      return database.prepare('SELECT * FROM threads WHERE id = ?').get(id) ?? null;
+    },
+    listThreads(spaceId, { projectId = null, limit = 50 } = {}) {
+      return database.prepare(`SELECT t.*, (SELECT count(*) FROM messages m WHERE m.thread_id = t.id) AS message_count
+        FROM threads t WHERE t.space_id = ? AND (? IS NULL OR t.project_id = ?)
+        ORDER BY t.updated_at DESC LIMIT ?`).all(spaceId, projectId, projectId, limit);
+    },
+    appendMessage(threadId, message) {
+      return transaction(() => {
+        const at = now();
+        const seq = (database.prepare('SELECT coalesce(max(seq), 0) AS seq FROM messages WHERE thread_id = ?').get(threadId).seq) + 1;
+        database.prepare(`INSERT INTO messages(id, thread_id, seq, kind, body, status, in_reply_to,
+          from_agent, from_name, from_client, from_session, to_agent, to_name, to_client, to_session,
+          via, error, created_at, updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
+          message.id, threadId, seq, message.kind, message.body, message.status, message.inReplyTo ?? null,
+          message.from?.agentId ?? null, message.from?.name ?? null, message.from?.client ?? null, message.from?.session ?? null,
+          message.to?.agentId ?? null, message.to?.name ?? null, message.to?.client ?? null, message.to?.session ?? null,
+          message.via ?? null, null, at, at);
+        database.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(at, threadId);
+        return this.getMessage(message.id);
+      });
+    },
+    updateMessage(id, { status, via, error, toClient, toSession }) {
+      database.prepare(`UPDATE messages SET status = coalesce(?, status), via = coalesce(?, via), error = ?,
+        to_client = coalesce(?, to_client), to_session = coalesce(?, to_session), updated_at = ? WHERE id = ?`)
+        .run(status ?? null, via ?? null, error ?? null, toClient ?? null, toSession ?? null, now(), id);
+      return this.getMessage(id);
+    },
+    getMessage(id) {
+      return database.prepare('SELECT * FROM messages WHERE id = ?').get(id) ?? null;
+    },
+    messages(threadId) {
+      return database.prepare('SELECT * FROM messages WHERE thread_id = ? ORDER BY seq').all(threadId);
+    },
+    // Questions waiting for this Agent that no delivery is currently answering.
+    pendingFor(spaceId, agentId, limit = 5) {
+      return database.prepare(`SELECT m.* FROM messages m JOIN threads t ON t.id = m.thread_id
+        WHERE t.space_id = ? AND m.to_agent = ? AND m.kind = 'ask' AND m.status = 'queued'
+        ORDER BY m.created_at LIMIT ?`).all(spaceId, agentId, limit);
+    },
+    close() { database.close(); }
+  };
+}

package/src/agent-roundtable/tools.js

@@ -0,0 +1,61 @@
+import { ApplicationError } from '../app/application-error.js';
+import { booleanSchema, integerSchema, objectSchema, stringSchema } from '../agent-tools/schema.js';
+
+const text = (maxLength) => ({ ...stringSchema(), minLength: 1, maxLength });
+
+export const ROUNDTABLE_TOOL_DEFINITIONS = [
+  {
+    name: 'find_agents',
+    title: 'ROUNDTABLE · Find Agents to talk to',
+    description: 'List active FULI Agents you can message directly, with their recent Claude Code / Codex conversations. Optional query matches name, responsibility or capability.',
+    inputSchema: objectSchema({ query: text(128), personalProjectId: text(128) })
+  },
+  {
+    name: 'message_agent',
+    title: 'ROUNDTABLE · Ask another Agent',
+    description: 'Send a message to another Agent, like asking a teammate or a sub-agent. By default Fuli wakes the recipient in its own client (resuming its latest conversation, or one from find_agents) read-only, and returns its answer in reply. If it cannot be woken the message waits in its inbox. Pass the current taskContextToken so the recipient knows who is asking, projectPath as the current working directory, and threadId to continue a thread. Every exchange is recorded for the user.',
+    inputSchema: objectSchema({
+      taskContextToken: text(160),
+      to: text(160),
+      body: text(16_000),
+      threadId: text(128),
+      conversation: text(128),
+      wait: booleanSchema(),
+      timeoutSeconds: integerSchema({ minimum: 30, maximum: 900 }),
+      projectPath: text(4096)
+    }, ['to', 'body'])
+  },
+  {
+    name: 'read_agent_messages',
+    title: 'ROUNDTABLE · Read messages for me',
+    description: 'Read messages other Agents sent to the current task\'s Agent that are still waiting for an answer.',
+    inputSchema: objectSchema({ taskContextToken: text(160) }, ['taskContextToken'])
+  },
+  {
+    name: 'reply_agent_message',
+    title: 'ROUNDTABLE · Reply to an Agent',
+    description: 'Answer a message from read_agent_messages or task-entry agent_messages. The reply is delivered to the asking Agent and recorded in the thread.',
+    inputSchema: objectSchema({ taskContextToken: text(160), messageId: text(128), body: text(16_000) },
+      ['taskContextToken', 'messageId', 'body'])
+  },
+  {
+    name: 'read_agent_thread',
+    title: 'ROUNDTABLE · Read a thread',
+    description: 'Read every message of one Agent conversation thread.',
+    inputSchema: objectSchema({ threadId: text(128) }, ['threadId'])
+  }
+];
+
+export const ROUNDTABLE_TOOL_NAMES = ROUNDTABLE_TOOL_DEFINITIONS.map(({ name }) => name);
+
+export function callRoundtableTool(roundtable, name, input) {
+  if (!roundtable) throw new ApplicationError('roundtable_unavailable', 'Agent roundtable needs a local Fuli installation');
+  switch (name) {
+    case 'find_agents': return roundtable.findAgents(input);
+    case 'message_agent': return roundtable.messageAgent(input);
+    case 'read_agent_messages': return roundtable.readMessages(input);
+    case 'reply_agent_message': return roundtable.replyMessage(input);
+    case 'read_agent_thread': return roundtable.thread(input);
+    default: throw new TypeError(`Unknown roundtable tool: ${name}`);
+  }
+}

package/src/agent-roundtable/wake.js

@@ -0,0 +1,99 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+import { WAKE_CLIENTS, wakeAdapter } from '../agents/wake-registry.js';
+
+// Wakes the recipient Agent in its own client, headlessly and read-only, and
+// returns its final answer with that conversation's full context. Each client's
+// command, arguments, session lookup and output format live in its adapter.
+export { WAKE_CLIENTS };
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9-]{7,127}$/;
+
+function adapterFor(client) {
+  const adapter = wakeAdapter(client);
+  if (!adapter) throw new TypeError(`Unsupported client: ${client}`);
+  return adapter;
+}
+
+export function resolveClientCommand(client, { env = process.env, platform = process.platform,
+  fileExists = existsSync, which = whichCommand } = {}) {
+  return wakeAdapter(client)?.resolveCommand({ env, platform, fileExists, which }) ?? null;
+}
+
+export function wakeArguments(client, { sessionId = null, cwd } = {}) {
+  if (sessionId !== null && !SESSION_ID.test(sessionId)) throw new TypeError('Invalid client session id');
+  return adapterFor(client).args({ sessionId, cwd });
+}
+
+// Clients only resume a conversation from the directory it started in.
+export function sessionWorkingDirectory(client, sessionId, { home = homedir(), env = process.env } = {}) {
+  if (!SESSION_ID.test(sessionId)) return null;
+  return wakeAdapter(client)?.sessionDirectory(sessionId, { home, env }) ?? null;
+}
+
+export async function wakeAgent({ client, sessionId = null, cwd, prompt, timeoutMs = 300_000,
+  env = process.env, run = runProcess } = {}) {
+  const command = resolveClientCommand(client, { env });
+  if (!command) throw Object.assign(new Error(`${client} is not installed on this machine`), { code: 'client_unavailable' });
+  const childEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith('FULI_ROUNDTABLE_')));
+  const result = await run(command, wakeArguments(client, { sessionId, cwd }), { cwd, env: childEnv, input: prompt, timeoutMs });
+  return parseFinalAnswer(client, result);
+}
+
+export function parseFinalAnswer(client, { code, stdout }) {
+  const adapter = adapterFor(client);
+  const state = adapter.initialState();
+  let sessionId = null;
+  for (const line of stdout.split(/\r?\n/)) {
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    sessionId ??= event.thread_id ?? event.session_id ?? null;
+    adapter.readEvent(event, state);
+    if (event.error === 'authentication_failed') {
+      throw Object.assign(new Error(`${client} is not logged in on this machine`), { code: 'client_login_required' });
+    }
+  }
+  if (code !== 0 || state.failed || !state.completed || !state.body.trim()) {
+    throw Object.assign(new Error(`${client} did not return an answer`), { code: 'wake_failed' });
+  }
+  return { body: state.body.trim(), sessionId };
+}
+
+// Owns exactly one child process tree and never touches unrelated clients.
+export function runProcess(command, args, { cwd, env, input, timeoutMs, maxOutputBytes = 4_000_000 }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, env, shell: false, windowsHide: true,
+      detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'ignore'] });
+    let output = '', bytes = 0, settled = false;
+    const kill = () => {
+      if (!child.pid) return;
+      if (process.platform === 'win32') spawn('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' }).unref();
+      else { try { process.kill(-child.pid, 'SIGKILL'); } catch { /* already exited */ } }
+    };
+    const finish = (error, code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) { kill(); reject(error); } else resolve({ code, stdout: output });
+    };
+    const timer = setTimeout(() => finish(Object.assign(new Error('The woken Agent did not answer in time'), { code: 'wake_timeout' })), timeoutMs);
+    child.stdout.on('data', (chunk) => {
+      bytes += chunk.length;
+      if (bytes > maxOutputBytes) finish(Object.assign(new Error('The woken Agent produced too much output'), { code: 'wake_failed' }));
+      else output += chunk.toString('utf8');
+    });
+    child.on('error', () => finish(Object.assign(new Error('The client could not be started'), { code: 'client_unavailable' })));
+    child.on('close', (code) => finish(null, code));
+    child.stdin.on('error', () => {});
+    child.stdin.end(input);
+  });
+}
+
+function whichCommand(name, platform) {
+  const result = spawnSync(platform === 'win32' ? 'where.exe' : 'which', [name], { encoding: 'utf8', windowsHide: true });
+  if (result.status !== 0) return null;
+  // On Windows only real executables can be spawned without a shell.
+  return result.stdout.split(/\r?\n/).map((line) => line.trim())
+    .find((line) => line && (platform !== 'win32' || /\.exe$/i.test(line))) ?? null;
+}

package/src/agent-tools/agent-conversation-definitions.js

@@ -13,9 +13,9 @@ export const AGENT_CONVERSATION_DEFINITIONS = [
     description: 'Explicitly attach the current task session to an earlier conversation of the SAME Agent and project, returning bounded recovery context. Select the intended Agent at task entry first. Does not transfer files or native runtime state.',
     inputSchema: objectSchema({ taskContextToken: { ...id, maxLength: 160 }, conversationId: id }, ['taskContextToken', 'conversationId']) },
   { name: 'get_agent_conversation_policy', title: 'READ · Conversation policy',
-    description: 'Read idle archival days, recovery context budget and capture switch. Defaults: 7 inactive days and 2000 conservative UTF-8 byte units. Archival preserves originals.',
+    description: 'Read the compaction threshold, recovery context budget and capture switch. Defaults: fold older messages into a digest after 64 KB of unfolded text; recover 4000 conservative UTF-8 bytes. Raw messages are always retained.',
     inputSchema: objectSchema(scope, required) },
   { name: 'update_agent_conversation_policy', title: 'WRITE · Conversation policy',
-    description: 'Configure this Agent and project conversation capture and recovery. No LLM runs during capture or archival. Raw data is retained; inactivity affects default recovery only.',
-    inputSchema: objectSchema({ ...scope, idleDays: integerSchema({ minimum: 1, maximum: 365 }), contextBudget: integerSchema({ minimum: 512, maximum: 16000 }), enabled: booleanSchema() }, [...required, 'idleDays', 'contextBudget', 'enabled']) }
+    description: 'Configure this Agent and project conversation capture and recovery. No LLM runs during capture or compaction. Raw data is retained; compaction only shortens default recovery.',
+    inputSchema: objectSchema({ ...scope, compactAfterKb: integerSchema({ minimum: 8, maximum: 1024 }), contextBudget: integerSchema({ minimum: 512, maximum: 16000 }), enabled: booleanSchema() }, [...required, 'compactAfterKb', 'contextBudget', 'enabled']) }
 ];

package/src/agent-tools/graph-definitions.js

@@ -305,7 +305,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'checkpoint_task_knowledge',
     title: 'LIFECYCLE · Finish knowledge review',
-    description: 'Complete exactly one end-of-task knowledge review. An assigned employee must include workLog with a concise result summary and truthful status even with retain_nothing. Include agentMemory with the loaded revision and merged notes when durable role memory changed. Use capture_candidates only for a small durable batch supported by the task; captured Agent proposals remain pending unless the payload contains valid human or authoritative-source confirmation. Use retain_nothing when the turn produced no reusable knowledge. Never store raw transcripts, guesses, temporary logs, credentials, or disposable output.',
+    description: 'Complete exactly one end-of-task knowledge review. An assigned employee must include workLog with a concise result summary and truthful status even with retain_nothing. Include agentMemory with the loaded revision and merged notes when durable role memory changed. Use capture_candidates only for a small durable batch supported by the task; captured Agent proposals remain pending unless the payload contains valid human or authoritative-source confirmation. Use retain_nothing when the turn produced no reusable knowledge. Never store raw transcripts, guesses, temporary logs, credentials, or disposable output. List in collaborators the Agent IDs that actually contributed (employee tools called, coordinated workers, Roundtable participants); unknown or inactive IDs are ignored. End the final reply with the returned agent_receipt.markdown, which names the lead and those collaborators.',
     inputSchema: objectSchema({
       taskContextToken: id,
       disposition: enumSchema(['capture_candidates', 'retain_nothing']),
@@ -318,7 +318,8 @@ export const GRAPH_TOOL_DEFINITIONS = [
       agentMemory: objectSchema({
         expectedRevision: integerSchema({ minimum: 0 }),
         memory: workingMemorySchema
-      }, ['expectedRevision', 'memory'])
+      }, ['expectedRevision', 'memory']),
+      collaborators: arraySchema(boundedString(128), { maxItems: 16 })
     }, ['taskContextToken', 'disposition', 'reason'])
   },
   {

package/src/agent-tools/interface-catalog.js

@@ -1,9 +1,4 @@
 const UI_MUTATION_PARITY = Object.freeze([
-  local('POST /api/roundtables', 'Creating rooms, granting private identity context and selecting execution permissions requires the local user.'),
-  local('POST /api/roundtables/:roomId/invites', 'Seat invitations are local-user issued scoped capabilities.'),
-  local('POST /api/roundtables/:roomId/revoke', 'Revoking participation requires the room owner.'),
-  local('POST /api/roundtables/:roomId/control', 'Starting, changing limits, stopping or human acceptance requires the room owner.'),
-  local('POST /api/roundtables/:roomId/messages', 'Human input must not be impersonated by an Agent.'),
   agent('POST /api/agent-conversations/query', 'list_agent_conversations', 'read_agent_conversation', 'get_agent_conversation_policy'),
   agent('PUT /api/agent-conversations/policy', 'update_agent_conversation_policy'),
   agent('POST /api/agent-attention', 'request_agent_attention'),

package/src/agent-tools.js

@@ -1,7 +1,7 @@
 import { GRAPH_TOOL_DEFINITIONS } from './agent-tools/graph-definitions.js';
 import { dispatchGraphTool } from './agent-tools/graph-handlers.js';
 import { runWithAgentRequestContext } from './app/agent-request-context.js';
-import { ROUNDTABLE_TOOL_DEFINITIONS, ROUNDTABLE_TOOL_NAMES, callRoundtableTool } from './roundtables/tool-contract.js';
+import { ROUNDTABLE_TOOL_DEFINITIONS, ROUNDTABLE_TOOL_NAMES, callRoundtableTool } from './agent-roundtable/tools.js';
 import { ApplicationError } from './app/application-error.js';
 
 const TOOL_DEFINITIONS = [...GRAPH_TOOL_DEFINITIONS, ...ROUNDTABLE_TOOL_DEFINITIONS];
@@ -17,7 +17,7 @@ export function callAgentTool(app, name, input = {}, requestContext = null) {
   return runWithAgentRequestContext(
     requestContext,
     () => ROUNDTABLE_TOOL_NAMES.includes(name)
-      ? callRoundtableTool(app.roundtables, name, input)
+      ? callRoundtableTool(app.roundtable, name, input)
       : dispatchGraphTool(app, name, input)
   );
 }

package/src/agents/claude-code/lifecycle-hook.js

@@ -37,19 +37,7 @@ export async function claudeLifecycleOutput(event, input, invoke) {
   const check = await invoke('verify_task_checkpoint', { sessionId, ...source });
   const reason = boundedHookMessage(check?.reason);
   if (check?.decision !== 'block' || !reason.trim()) return {};
-  if (input.stop_hook_active === true) {
-    if (typeof check.task_context_token === 'string' && check.task_context_token.trim()) {
-      await invoke('checkpoint_task_knowledge', {
-        taskContextToken: check.task_context_token,
-        disposition: 'retain_nothing',
-        reason: 'Claude Code Stop hook fallback after one checkpoint continuation.',
-        workLog: { status: 'incomplete', summary: 'The host stopped before the employee submitted a work summary. Review the prior task before resuming.' },
-        ...source
-      });
-    }
-    return {};
-  }
-  return { decision: 'block', reason };
+  return { systemMessage: reason };
 }
 
 export function claudeLifecycleUnavailable(event) {
@@ -80,7 +68,7 @@ export async function runClaudeLifecycleHook(args, dependencies = {}) {
           let sync = await syncConversationTranscript(app, input, 'claude_code', {
             normalize: normalizeClaudeRecord, verify: verifyClaudeTranscript
           }, guard);
-          if (event === 'UserPromptSubmit' && sync.entryBlocked) return { decision: 'block', reason: sync.reason };
+          if (event === 'UserPromptSubmit' && sync.entryBlocked) return { systemMessage: boundedHookMessage(sync.reason) };
           const entryGuard = sync.status === 'capture_disabled' ? null : guard;
           if (event === 'UserPromptSubmit' && entryGuard?.value) await entryGuard.write({ ...entryGuard.value, phase: 'beginning' });
           const output = await claudeLifecycleOutput(event, input, async (name, parameters) => {
@@ -91,12 +79,12 @@ export async function runClaudeLifecycleHook(args, dependencies = {}) {
           if (event === 'UserPromptSubmit') sync = await claimTranscriptBoundary(app, input, 'claude_code', sync, {
             normalize: normalizeClaudeRecord, verify: verifyClaudeTranscript
           }, entryGuard);
-          if (event === 'UserPromptSubmit' && sync.entryBlocked) return { decision: 'block', reason: sync.reason };
+          if (event === 'UserPromptSubmit' && sync.entryBlocked) return { systemMessage: boundedHookMessage(sync.reason) };
           return withTranscriptNotice(output, sync);
         });
       } catch (error) {
         if (event !== 'UserPromptSubmit' || !app.getCapturePolicy?.().enabled || !input.transcript_path) throw error;
-        return { decision: 'block', reason: error.code === 'EADDRINUSE'
+        return { systemMessage: error.code === 'EADDRINUSE'
           ? 'The session handoff lock is occupied. Retry after the current hook finishes; if it persists, start a new host session and resume the intended Agent.'
           : 'Fuli transcript handoff could not be completed safely. Retry task entry; no previous Agent context was supplied.' };
       }
@@ -127,7 +115,6 @@ async function main() {
     ? configured : 28000;
   const controller = new AbortController();
   let emitted = false;
-  let guarded = false;
   const emit = (output, callback) => {
     if (emitted) return;
     emitted = true;
@@ -137,11 +124,11 @@ async function main() {
   // No prompt, transcript, path or raw exception is written to diagnostics.
   const deadline = setTimeout(() => {
     controller.abort();
-    emit(guarded && event === 'UserPromptSubmit' ? { decision: 'block', reason: 'Fuli transcript handoff timed out. Retry task entry; the previous Agent context was not supplied.' } : claudeLifecycleUnavailable(event), () => process.exit(0));
+    emit(claudeLifecycleUnavailable(event), () => process.exit(0));
   }, timeoutMs);
   const abort = setTimeout(() => controller.abort(), Math.max(1, timeoutMs - 1500));
   try {
-    const output = await runClaudeLifecycleHook(args, { signal: controller.signal, onTranscriptGuard: () => { guarded = true; } });
+    const output = await runClaudeLifecycleHook(args, { signal: controller.signal });
     emit(output);
   } catch {
     emit(claudeLifecycleUnavailable(event));

package/src/agents/claude-code/wake.js

@@ -0,0 +1,37 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { firstField, listDirectory } from '../session-log.js';
+
+// Wakes Claude Code headlessly. Resuming forks the session, so an open window is
+// never written concurrently while the answer still has that conversation's context.
+export const claudeCodeWake = Object.freeze({
+  id: 'claude_code',
+
+  resolveCommand({ env, which, platform }) {
+    return env.FULI_CLAUDE_BIN || which('claude', platform);
+  },
+
+  args({ sessionId }) {
+    return ['-p', '--output-format', 'stream-json', '--verbose', '--permission-mode', 'dontAsk',
+      ...(sessionId ? ['--resume', sessionId, '--fork-session'] : [])];
+  },
+
+  // A session resumes only from the directory it started in.
+  sessionDirectory(sessionId, { home }) {
+    const root = join(home, '.claude', 'projects');
+    for (const project of listDirectory(root)) {
+      const file = join(root, project, `${sessionId}.jsonl`);
+      if (existsSync(file)) return firstField(file, (line) => line.cwd);
+    }
+    return null;
+  },
+
+  // stream-json ends with one `result` event carrying the final answer.
+  initialState: () => ({ body: '', completed: true, failed: false }),
+  readEvent(event, state) {
+    if (event.type !== 'result') return;
+    state.body = event.result ?? '';
+    state.failed ||= Boolean(event.is_error);
+  },
+});