fuli-context 0.12.0 → 0.12.2

package/src/agent-roundtable/service.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 
 import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
 import { WAKE_CLIENTS, resolveClientCommand, sessionWorkingDirectory, wakeAgent } from './wake.js';
@@ -6,6 +6,8 @@ import { WAKE_CLIENTS, resolveClientCommand, sessionWorkingDirectory, wakeAgent
 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;
+const REMOTE_PENDING = new Set(['sent', 'queued', 'claimed', 'running']);
+const REMOTE_FINAL = new Set(['answered', 'failed', 'cancelled', 'expired', 'unknown']);
 
 // 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.
@@ -14,6 +16,8 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
   const spaceId = () => app.config.personal.spaceId;
   // Opened on first use: most MCP processes never touch the roundtable.
   let opened = null;
+  const refreshes = new Map();
+  let refreshOffset = 0;
   const store = new Proxy({}, { get: (_target, property) => (opened ??= openStore())[property] });
 
   async function sender({ taskContextToken, sourceApplication }) {
@@ -60,18 +64,24 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
       agent.employeeNumber ? `FLA ${agent.employeeNumber}` : null, 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) => ({
+    const local = await Promise.all(matches.slice(0, 20).map(async (agent) => ({
       agentId: agent.agentId, employeeNumber: agent.employeeNumber, 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.' };
+    })));
+    const remote = app.peer ? await app.peer.remoteAgents({ query: needle }).catch(() => null) : null;
+    return { agents: local,
+      ...(remote ? { remoteAgents: remote.agents, ...(remote.unavailable ? { remoteUnavailable: remote.unavailable } : {}) } : {}),
+      guidance: remote
+        ? 'message_agent sends to an Agent (optionally one of its recentConversations) and returns its answer. remoteAgents run on other paired devices (LAN roundtable Beta): address them by their exact address, from an active project task. Only each shared project\'s lead can be asked. Use get_agent_message_status for a pending reply.'
+        : '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));
+  async function deliveryTargets(agent, conversation, projectId, projectPath, { clients = null, freshCwd = null, strictCwd = false } = {}) {
+    const allowed = (agent.profile.allowedClients ?? []).filter((client) => WAKE_CLIENTS.includes(client)
+      && (!clients || clients.includes(client)) && clientAvailable(client));
     const explicit = Boolean(conversation) && !['auto', 'new'].includes(conversation);
     let resumable = null;
     if (conversation !== 'new') {
@@ -89,49 +99,39 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
     const freshClients = resumable
       ? [resumable.client, ...(explicit ? [] : allowed.filter((client) => client !== resumable.client))]
       : WAKE_CLIENTS.filter((client) => allowed.includes(client));
+    // A strict delivery only starts new sessions in a folder known for this project.
+    const strictFolder = strictCwd ? freshCwd ?? resumable?.cwd ?? await projectFolder(agent, projectId) : null;
+    if (strictCwd && !strictFolder) return resumable ? [resumable] : [];
     const fresh = freshClients.map((client) => ({ client, sessionId: null,
-      cwd: client === resumable?.client ? resumable.cwd : projectPath ?? resumable?.cwd ?? process.cwd() }));
+      cwd: client === resumable?.client ? resumable.cwd
+        : strictCwd ? strictFolder : freshCwd ?? 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');
-    if (!taskContextToken || !from.projectId) return queued(thread, ask, target, 'task_context_required');
-    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;
+  async function projectFolder(agent, projectId) {
+    for (const session of await conversations(agent, projectId)) {
+      if (session.projectId !== projectId) continue;
+      const cwd = locateCwd(session.client, session.sessionId);
+      if (cwd) return cwd;
+    }
+    return null;
+  }
+
+  // Tries each target until one answers as the restored Agent. The grant is the
+  // only authority the woken session receives and is revoked after every attempt.
+  async function deliver({ ask, attempts, prompt, timeoutMs, issueGrant, signal, onSpawn, peerDepth }) {
     const unusable = new Set();
     let failure = 'wake_failed';
     for (const delivery of attempts) {
       if (unusable.has(delivery.client)) continue;
+      if (signal?.aborted) { failure = 'cancelled'; break; }
       store.updateMessage(ask.id, { status: 'delivering', toClient: delivery.client, toSession: delivery.sessionId });
       let answer;
       let grant;
       try {
-        grant = await app.personal.issueAgentDelegation({ personal_space_id: spaceId(),
-          task_context_token: taskContextToken, source_application: from.client, agent_id: target.agentId,
-          target_application: delivery.client,
-          // Claude resumes into a fork with a new ID. Only Codex resumes in place.
-          target_session_id: delivery.client === 'codex' ? delivery.sessionId : null,
-          lifetime_seconds: timeoutMs / 1000 });
+        grant = await issueGrant(delivery, timeoutMs / 1000);
         answer = await wake({ client: delivery.client, sessionId: delivery.sessionId, cwd: delivery.cwd,
-          timeoutMs, prompt, delegationToken: grant.token });
+          timeoutMs, prompt, delegationToken: grant.token, peerDepth, signal, onSpawn });
         const verified = answer.sessionId && await app.personal.verifyAgentDelegation({
           personal_space_id: spaceId(), token: grant.token, session_id: answer.sessionId });
         if (!verified?.redeemed) throw Object.assign(new Error('The receiving session did not restore the Agent'),
@@ -141,8 +141,8 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
         // 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;
+        // A timeout already used the caller's wait; a cancellation ends the delivery.
+        if (failure === 'wake_timeout' || failure === 'cancelled') break;
         continue;
       } finally {
         // Even failed or timed-out attempts lose their authority. Expiry remains
@@ -150,16 +150,209 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
         if (grant?.token) await app.personal.revokeAgentDelegation({
           personal_space_id: spaceId(), token: grant.token }).catch(() => {});
       }
-      const via = `${delivery.client}:${delivery.sessionId ? 'resume' : 'new'}`;
+      return { answer, delivery, via: `${delivery.client}:${delivery.sessionId ? 'resume' : 'new'}` };
+    }
+    throw Object.assign(new Error('No client answered'), { code: failure });
+  }
+
+  async function messageAgent({ taskContextToken = null, sourceApplication, to, body, threadId = null,
+    conversation = 'auto', wait = true, timeoutSeconds = 300, projectPath = null } = {}) {
+    if (app.peer?.isRemoteAddress(to)) {
+      return messageRemote({ taskContextToken, sourceApplication, to, body, threadId, conversation, wait, timeoutSeconds });
+    }
+    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');
+    const { thread, history } = openThread(threadId, from.projectId, body);
+    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');
+    if (!taskContextToken || !from.projectId) return queued(thread, ask, target, 'task_context_required');
+    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;
+    try {
+      const { answer, delivery, via } = await deliver({ ask, attempts, prompt, timeoutMs,
+        issueGrant: (delivery, lifetime) => app.personal.issueAgentDelegation({ personal_space_id: spaceId(),
+          task_context_token: taskContextToken, source_application: from.client, agent_id: target.agentId,
+          target_application: delivery.client,
+          // Claude resumes into a fork with a new ID. Only Codex resumes in place.
+          target_session_id: delivery.client === 'codex' ? delivery.sessionId : null,
+          lifetime_seconds: lifetime }) });
       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 };
+    } catch (error) {
+      store.updateMessage(ask.id, { status: 'queued', error: error.code ?? 'wake_failed' });
+      return queued(thread, ask, target, error.code ?? 'wake_failed');
+    }
+  }
+
+  function openThread(threadId, projectId, body) {
+    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,
+      subject: body.trim().split(/\r?\n/)[0].slice(0, 80) });
+    return { thread, history };
+  }
+
+  // A remote ask is signed by this device for one verified local task. The task
+  // token itself never leaves this computer.
+  async function messageRemote({ taskContextToken, sourceApplication, to, body, threadId, conversation, wait, timeoutSeconds }) {
+    if (!['auto', 'new'].includes(conversation ?? 'auto')) throw validation('Remote Agents accept conversation "auto" or "new"');
+    const from = await sender({ taskContextToken, sourceApplication });
+    if (!from.agent || !from.projectId) throw validation('A remote message must come from an active project task of a FULI Agent; pass taskContextToken');
+    const target = await app.peer.resolveRemote(to);
+    const { thread } = openThread(threadId, from.projectId, body);
+    if (thread.project_id !== from.projectId) throw validation('This thread belongs to another project');
+    const ask = store.appendMessage(thread.id, { id: idFactory(), kind: 'ask', body, status: 'sent', via: 'peer',
+      from: { agentId: from.agent.agentId, name: label(from.agent), client: from.client, session: from.session },
+      to: { agentId: target.address, name: `${target.name} · ${target.deviceName}` } });
+    let state;
+    try {
+      state = await app.peer.send({ messageId: ask.id, threadId: thread.id, target, body,
+        conversation: conversation ?? 'auto', depth: peerDepth(env) + 1, taskContextToken, sourceApplication: from.client,
+        from: { agentId: from.agent.agentId, name: label(from.agent), client: from.client } });
+    } catch (error) {
+      store.updateMessage(ask.id, { status: 'failed', error: error.code ?? 'peer_send_failed' });
+      throw error;
+    }
+    if (wait) state = await app.peer.waitFor(ask.id, Math.min(Math.max(timeoutSeconds, 30), 900) * 1000);
+    return remoteView(applyRemote(ask.id, state));
+  }
+
+  function applyRemote(messageId, state) {
+    const ask = store.getMessage(messageId);
+    if (!ask || !state || !REMOTE_PENDING.has(ask.status)) return ask;
+    const status = state.status === 'queued' ? 'sent' : state.status;
+    if (status === 'answered' && state.reply) {
+      store.updateMessage(ask.id, { status: 'answered', via: state.via ?? 'peer' });
+      store.appendMessage(ask.thread_id, { id: idFactory(), kind: 'reply', body: state.reply, status: 'sent', inReplyTo: ask.id,
+        via: state.via ?? 'peer', from: { agentId: ask.to_agent, name: ask.to_name, client: state.via?.split(':')[0] ?? null },
+        to: { agentId: ask.from_agent, name: ask.from_name, client: ask.from_client, session: ask.from_session } });
+    } else if (status !== ask.status) {
+      store.updateMessage(ask.id, { status, error: state.error ?? null });
     }
-    store.updateMessage(ask.id, { status: 'queued', error: failure });
-    return queued(thread, ask, target, failure);
+    return store.getMessage(ask.id);
+  }
+
+  function remoteView(ask) {
+    const reply = ask.status === 'answered'
+      ? store.messages(ask.thread_id).find((message) => message.in_reply_to === ask.id) : null;
+    return { status: ask.status === 'sent' ? 'queued' : ask.status, threadId: ask.thread_id, messageId: ask.id,
+      recipient: { agentId: ask.to_agent, name: ask.to_name }, remote: true,
+      ...(reply ? { reply: reply.body, via: reply.via } : {}), ...(ask.error ? { reason: ask.error } : {}),
+      ...(REMOTE_FINAL.has(ask.status) ? {} : { guidance: 'The remote device has not answered yet. Check later with get_agent_message_status; it does not mean the work ran.' }),
+      ...(ask.status === 'unknown' ? { guidance: 'The remote device lost track of this attempt; it may or may not have run. It is not retried automatically.' } : {}) };
+  }
+
+  // Runs on the receiving device for one claimed, locally authorized remote ask.
+  async function answerRemote({ claim, share, prompt: promptOverride = null, issueGrant, signal, onSpawn, timeoutMs }) {
+    const { assertion, sender: device } = claim;
+    if (share.spaceId !== spaceId()) throw Object.assign(new Error('The share belongs to another space'), { code: 'share_unavailable' });
+    const target = await agentById(share.agentId);
+    if (!target) throw Object.assign(new Error('The shared Agent is no longer active'), { code: 'agent_unavailable' });
+    // Remote IDs are only meaningful together with their device and this share,
+    // so they never address an existing local row.
+    const scope = [device.nodeId, share.spaceId, share.projectId, share.bindingId, share.agentId];
+    const threadId = remoteRowId('thread', [...scope, assertion.threadId]);
+    const askId = remoteRowId('ask', [...scope, assertion.messageId]);
+    if (store.getMessage(askId)) {
+      throw Object.assign(new Error('This remote message was already delivered here'), { code: 'already_delivered' });
+    }
+    const thread = store.getThread(threadId) ?? store.createThread({ id: threadId, spaceId: share.spaceId,
+      projectId: share.projectId, subject: assertion.body.trim().split(/\r?\n/)[0].slice(0, 80) });
+    const ask = store.appendMessage(thread.id, { id: askId, kind: 'ask',
+      body: assertion.body, status: 'delivering', via: 'peer',
+      from: { agentId: `peer:${device.nodeId.slice(0, 16)}:${assertion.from.agentId}`, name: `${assertion.from.name} · ${device.name}`,
+        client: assertion.from.client ?? 'other' },
+      to: { agentId: target.agentId, name: label(target) } });
+    const attempts = await deliveryTargets(target, assertion.conversation, share.projectId, null,
+      { clients: share.clients, freshCwd: share.workingDirectory ?? null, strictCwd: true });
+    if (!attempts.length) {
+      const code = share.clients.some((client) => clientAvailable(client)) ? 'no_working_directory' : 'no_client';
+      store.updateMessage(ask.id, { status: 'failed', error: code });
+      throw Object.assign(new Error(code === 'no_working_directory'
+        ? 'This shared project has no known folder on this device; the owner sets one in Settings'
+        : 'No shared client can run on this device'), { code });
+    }
+    const prompt = promptOverride ?? wakePrompt({ thread, ask, target, senderName: ask.from_name, senderClient: ask.from_client });
+    try {
+      const { answer, delivery, via } = await deliver({ ask, attempts, prompt, timeoutMs, issueGrant, signal, onSpawn,
+        peerDepth: assertion.depth });
+      store.updateMessage(ask.id, { status: 'answered', via });
+      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: ask.from_agent, name: ask.from_name, client: ask.from_client } });
+      return { body: answer.body, via, sessionId: answer.sessionId };
+    } catch (error) {
+      store.updateMessage(ask.id, { status: error.code === 'cancelled' ? 'cancelled' : 'failed', error: error.code ?? 'wake_failed' });
+      throw error;
+    }
+  }
+
+  async function messageStatus({ taskContextToken, sourceApplication, messageId }) {
+    const me = await sender({ taskContextToken, sourceApplication });
+    const ask = taskScopedAsk(me, messageId);
+    if (![ask.from_agent, ask.to_agent].includes(me.agent.agentId)) throw validation('No such message for this Agent');
+    return statusOf(ask);
+  }
+
+  async function statusOf(ask) {
+    if (REMOTE_PENDING.has(ask.status) && app.peer?.hasSent(ask.id)) {
+      const state = await app.peer.status(ask.id).catch(() => null);
+      return remoteView(applyRemote(ask.id, state) ?? ask);
+    }
+    if (ask.via === 'peer' || app.peer?.hasSent(ask.id)) return remoteView(ask);
+    const reply = store.messages(ask.thread_id).find((message) => message.in_reply_to === ask.id);
+    return { status: ask.status, threadId: ask.thread_id, messageId: ask.id,
+      recipient: { agentId: ask.to_agent, name: ask.to_name }, ...(reply ? { reply: reply.body, via: reply.via } : {}),
+      ...(ask.error ? { reason: ask.error } : {}) };
+  }
+
+  async function cancelMessage({ taskContextToken, sourceApplication, messageId }) {
+    const me = await sender({ taskContextToken, sourceApplication });
+    const ask = taskScopedAsk(me, messageId);
+    if (ask.from_agent !== me.agent.agentId) throw validation('No such message sent by this Agent');
+    return cancelAsk(ask);
+  }
+
+  // The same Agent ID can work in several projects; a task only reaches its own project's messages.
+  function taskScopedAsk(me, messageId) {
+    const ask = store.getMessage(messageId);
+    const thread = ask && store.getThread(ask.thread_id);
+    if (!ask || ask.kind !== 'ask' || !me.agent || !me.projectId || thread?.space_id !== spaceId()
+      || thread.project_id !== me.projectId) {
+      throw validation('No such message for this Agent in the current project');
+    }
+    return ask;
+  }
+
+  async function cancelAsk(ask) {
+    if (app.peer?.hasSent(ask.id)) {
+      if (!REMOTE_PENDING.has(ask.status)) return remoteView(ask);
+      return remoteView(applyRemote(ask.id, await app.peer.cancel(ask.id)));
+    }
+    if (ask.status === 'queued') store.updateMessage(ask.id, { status: 'cancelled', error: 'cancelled' });
+    else if (ask.status === 'delivering') throw validation('This message is being answered in another process; it ends at its timeout');
+    return statusOf(store.getMessage(ask.id));
+  }
+
+  // The local owner can inspect and cancel any message from the console.
+  function ownedAsk(messageId) {
+    const ask = store.getMessage(messageId);
+    const thread = ask && store.getThread(ask.thread_id);
+    if (!ask || ask.kind !== 'ask' || thread?.space_id !== spaceId()) throw validation('Message not found');
+    return ask;
   }
 
   async function readMessages({ taskContextToken, sourceApplication }) {
@@ -174,6 +367,7 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
     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');
+    if (ask.from_agent?.startsWith('peer:')) throw validation('A remote device message is answered by its delivery, not from the inbox');
     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 },
@@ -181,6 +375,29 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
     return { status: 'sent', threadId: ask.thread_id };
   }
 
+  function refreshRemote({ threadId = null } = {}) {
+    if (!app.peer) return Promise.resolve();
+    const key = threadId ?? 'directory';
+    if (refreshes.has(key)) return refreshes.get(key);
+    const records = threadId ? [store.getThread(threadId)] : store.listThreads(spaceId(), { limit: 200 });
+    const pending = records.filter((record) => record?.space_id === spaceId()).flatMap((record) => store.messages(record.id))
+      .filter((message) => message.kind === 'ask' && REMOTE_PENDING.has(message.status) && app.peer.hasSent(message.id));
+    const start = pending.length && !threadId ? refreshOffset % pending.length : 0;
+    const batch = [...pending.slice(start), ...pending.slice(0, start)].slice(0, 20);
+    if (!threadId) refreshOffset += batch.length;
+    // A shared deadline bounds the whole console refresh even with many offline asks.
+    const signal = AbortSignal.timeout(2_000);
+    const work = Promise.all(Array.from({ length: Math.min(4, batch.length) }, async () => {
+      while (batch.length && !signal.aborted) {
+        const message = batch.shift();
+        try { applyRemote(message.id, await app.peer.status(message.id, { signal, timeoutMs: 2_000 })); }
+        catch { /* Keep the last known result when the other computer is unavailable. */ }
+      }
+    })).finally(() => refreshes.delete(key));
+    refreshes.set(key, work);
+    return work;
+  }
+
   function threads({ limit = 50 } = {}) {
     return { threads: store.listThreads(spaceId(), { limit }).map((thread) => {
       const messages = store.messages(thread.id);
@@ -194,7 +411,7 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
       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'),
+        waiting: messages.some((message) => message.kind === 'ask' && !['answered', 'cancelled', 'failed', 'expired', 'unknown'].includes(message.status)),
         last: last ? { from: last.from_name, body: last.body.slice(0, 160) } : null };
     }) };
   }
@@ -216,11 +433,23 @@ export function createAgentRoundtable({ app, openStore, wake = wakeAgent, idFact
       ? { token: env.FULI_ROUNDTABLE_DELEGATION, sessionId: sessionId ?? null } : null;
   }
 
-  return { findAgents, messageAgent, readMessages, replyMessage, threads, thread, taskEntryDelegation,
+  return { findAgents, messageAgent, readMessages, replyMessage, threads, thread, refreshRemote, taskEntryDelegation,
+    messageStatus, cancelMessage, answerRemote,
+    ownerMessageStatus: ({ messageId }) => statusOf(ownedAsk(messageId)),
+    ownerCancelMessage: ({ messageId }) => cancelAsk(ownedAsk(messageId)),
     pending: (agentId) => store.pendingFor(spaceId(), agentId).map(inboxItem),
     close: () => opened?.close() };
 }
 
+function remoteRowId(kind, parts) {
+  return `peer-${kind}-${createHash('sha256').update(JSON.stringify(parts)).digest('hex').slice(0, 40)}`;
+}
+
+function peerDepth(env) {
+  const depth = Number(env.FULI_ROUNDTABLE_PEER_DEPTH);
+  return Number.isSafeInteger(depth) && depth > 0 ? depth : 0;
+}
+
 function queued(thread, ask, target, reason) {
   return { status: 'queued', threadId: thread.id, messageId: ask.id, reason,
     recipient: { agentId: target.agentId, name: label(target) },

package/src/agent-roundtable/tools.js

@@ -13,7 +13,7 @@ export const ROUNDTABLE_TOOL_DEFINITIONS = [
   {
     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.',
+    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. A peer:<device>:<binding> address from find_agents asks the shared project lead on another paired device (LAN roundtable Beta, project leads only). Every exchange is recorded for the user.',
     inputSchema: objectSchema({
       taskContextToken: text(160),
       to: text(160),
@@ -43,6 +43,18 @@ export const ROUNDTABLE_TOOL_DEFINITIONS = [
     title: 'ROUNDTABLE · Read a thread',
     description: 'Read every message of one Agent conversation thread.',
     inputSchema: objectSchema({ threadId: text(128) }, ['threadId'])
+  },
+  {
+    name: 'get_agent_message_status',
+    title: 'ROUNDTABLE · Check a message',
+    description: 'Check whether a message you sent or received in the current task\'s project was answered, including asks to a shared project lead on another paired device (LAN roundtable Beta). "unknown" means the receiving device lost track of the attempt; it may or may not have run and is not retried.',
+    inputSchema: objectSchema({ taskContextToken: text(160), messageId: text(128) }, ['taskContextToken', 'messageId'])
+  },
+  {
+    name: 'cancel_agent_message',
+    title: 'ROUNDTABLE · Cancel a message',
+    description: 'Cancel a message the current task\'s Agent sent in this project. A waiting message is withdrawn; one already running on another device is asked to stop.',
+    inputSchema: objectSchema({ taskContextToken: text(160), messageId: text(128) }, ['taskContextToken', 'messageId'])
   }
 ];
 
@@ -56,6 +68,8 @@ export function callRoundtableTool(roundtable, name, 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);
+    case 'get_agent_message_status': return roundtable.messageStatus(input);
+    case 'cancel_agent_message': return roundtable.cancelMessage(input);
     default: throw new TypeError(`Unknown roundtable tool: ${name}`);
   }
 }

package/src/agent-roundtable/wake.js

@@ -33,12 +33,14 @@ export function sessionWorkingDirectory(client, sessionId, { home = homedir(), e
 }
 
 export async function wakeAgent({ client, sessionId = null, cwd, prompt, timeoutMs = 300_000,
-  delegationToken = null, env = process.env, run = runProcess } = {}) {
+  delegationToken = null, peerDepth = null, env = process.env, run = runProcess, signal, onSpawn } = {}) {
   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_')));
   if (delegationToken) childEnv.FULI_ROUNDTABLE_DELEGATION = delegationToken;
-  const result = await run(command, wakeArguments(client, { sessionId, cwd }), { cwd, env: childEnv, input: prompt, timeoutMs });
+  if (peerDepth) childEnv.FULI_ROUNDTABLE_PEER_DEPTH = String(peerDepth);
+  const result = await run(command, wakeArguments(client, { sessionId, cwd }),
+    { cwd, env: childEnv, input: prompt, timeoutMs, signal, onSpawn });
   return parseFinalAnswer(client, result);
 }
 
@@ -62,10 +64,17 @@ export function parseFinalAnswer(client, { code, stdout }) {
 }
 
 // Owns exactly one child process tree and never touches unrelated clients.
-export function runProcess(command, args, { cwd, env, input, timeoutMs, maxOutputBytes = 4_000_000 }) {
+export function runProcess(command, args, { cwd, env, input, timeoutMs, maxOutputBytes = 4_000_000, signal, onSpawn }) {
   return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(Object.assign(new Error('The delivery was cancelled before it started'), { code: 'cancelled', started: false }));
+      return;
+    }
     const child = spawn(command, args, { cwd, env, shell: false, windowsHide: true,
       detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'ignore'] });
+    child.once('spawn', () => onSpawn?.());
+    signal?.addEventListener('abort', () => finish(Object.assign(new Error('The delivery was cancelled'),
+      { code: 'cancelled', reason: String(signal.reason ?? 'cancelled') })), { once: true });
     let output = '', bytes = 0, settled = false;
     const kill = () => {
       if (!child.pid) return;

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

@@ -764,7 +764,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'coordinate_project_agent_task',
     title: 'WRITE · Prepare a host-executed Agent team',
-    description: 'Resolve the exact local project, or create an isolated temporary task scope when no project matches, then let the Provider coordinator route one durable task and assemble an isolated context bundle for every selected lead/collaborator. Ambiguous matches require exact selection. Pass the current taskContextToken so temporary scope and a newly recruited lead bind to the owned lifecycle; otherwise provide a stable sourceSessionId and idempotencyKey for retries. Temporary projects retain audit history, never become implicit directory bindings, and default to audited task-only recruitment under the existing HR policy; explicit durable recruitment requests remain explicit. When recruiting, HR should set recruitmentProfile.character from the role responsibilities and preserve user expectations; configured traits must never be presented as proven growth. Fuli persists identity, staffing, and memory scope; the host must start real workers, report their concrete evidence, and finish their lifecycle. A routing recommendation never proves that a worker started.',
+    description: 'Resolve the exact local project, or create an isolated temporary task scope when no project matches, then let the Provider coordinator route one durable task and assemble an isolated context bundle for every selected lead/collaborator. Ambiguous matches require exact selection. Pass the current taskContextToken so temporary scope and a newly recruited lead bind to the owned lifecycle; otherwise provide a stable sourceSessionId and idempotencyKey for retries. Temporary projects retain audit history, never become implicit directory bindings, and default to audited task-only recruitment under the existing AR policy; explicit durable recruitment requests remain explicit. When recruiting, AR should set recruitmentProfile.character from the role responsibilities and preserve user expectations; configured traits must never be presented as proven growth. Fuli persists identity, staffing, and memory scope; the host must start real workers, report their concrete evidence, and finish their lifecycle. A routing recommendation never proves that a worker started.',
     inputSchema: projectAgentTaskCoordinateInput
   },
   {
@@ -792,7 +792,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'submit_project_agent_task',
     title: 'WRITE · Submit a routed Agent task',
-    description: 'Submit one durable task to the FULI control plane. Every new task requires a passed quality gate for its exact artifact revision before completion; use record_agent_verification with actual run evidence. Existing matching durable Agents are preferred; no anonymous temporary Agent is created. The Agent locked executor policy outranks task, assignment, project, and space rules; explicit user priority is never lowered for token savings. The space coordinator, complexity, model strategy, routing decision, boundaries, actual executor/model/rule/fallback audit fields, and any HR disclosure are persisted by the Provider. HR should fill recruitmentProfile.character from role responsibilities, preserve user expectations, and distinguish configured traits from demonstrated growth; never invent past achievements.',
+    description: 'Submit one durable task to the FULI control plane. Every new task requires a passed quality gate for its exact artifact revision before completion; use record_agent_verification with actual run evidence. Existing matching durable Agents are preferred; no anonymous temporary Agent is created. The Agent locked executor policy outranks task, assignment, project, and space rules; explicit user priority is never lowered for token savings. The space coordinator, complexity, model strategy, routing decision, boundaries, actual executor/model/rule/fallback audit fields, and any AR disclosure are persisted by the Provider. AR should fill recruitmentProfile.character from role responsibilities, preserve user expectations, and distinguish configured traits from demonstrated growth; never invent past achievements.',
     inputSchema: projectAgentTaskSubmitInput
   },
   {
@@ -833,10 +833,19 @@ export const GRAPH_TOOL_DEFINITIONS = [
       personalProjectId: id
     }, ['personalSpaceId', 'personalProjectId'])
   },
+  {
+    name: 'get_project_team',
+    title: 'READ · Get project team',
+    description: 'Read the exact project people view: the one accountable lead, explicit team members reporting to that lead, other Agents with an active assignment as collaborators, and assigned peer roles such as AR or project managers. Ended and archived assignments are excluded; status no_lead or lead_unavailable is reported truthfully. Never includes private memory and never resolves a parent or child project.',
+    inputSchema: objectSchema({
+      personalSpaceId: id,
+      personalProjectId: id
+    }, ['personalSpaceId', 'personalProjectId'])
+  },
   {
     name: 'update_project_agent_coordination_policy',
     title: 'WRITE · Set project Agent continuity policy',
-    description: 'Persist project collaboration switches and an optional stable team lead with members. HR and employee project managers remain peer roles and cannot be team members. Omitted team fields preserve the current team. Read policy first and send expectedUpdatedAt to prevent overwriting concurrent edits. This changes policy only and never starts a worker.',
+    description: 'Persist project collaboration switches and an optional stable team lead with members. AR and employee project managers remain peer roles and cannot be team members. Omitted team fields preserve the current team. Read policy first and send expectedUpdatedAt to prevent overwriting concurrent edits. This changes policy only and never starts a worker.',
     inputSchema: objectSchema({
       personalSpaceId: id,
       personalProjectId: id,
@@ -869,7 +878,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'list_project_agent_recruitments',
     title: 'READ · List recruitment records',
-    description: 'List auditable HR recruitment records with trigger client/session, role, capabilities, position kind, reason, status, and created/recruited Agent.',
+    description: 'List auditable AR recruitment records with trigger client/session, role, capabilities, position kind, reason, status, and created/recruited Agent.',
     inputSchema: objectSchema({
       personalSpaceId: id,
       personalProjectId: nullableStringSchema(),
@@ -880,7 +889,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'decide_project_agent_recruitment',
     title: 'WRITE · Approve or cancel recruitment',
-    description: 'Approve or cancel one pending HR recruitment event with an expected revision. Approval creates only the declared durable or bounded temporary role through the Provider.',
+    description: 'Approve or cancel one pending AR recruitment event with an expected revision. Approval creates only the declared durable or bounded temporary role through the Provider.',
     inputSchema: objectSchema({
       personalSpaceId: id,
       personalProjectId: id,

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

@@ -154,6 +154,7 @@ const HANDLERS = Object.freeze({
   view_project_agent_activity: (app, input) => app.viewProjectAgentActivity(input),
   get_project_agent_coordination_policy: (app, input) =>
     app.getProjectAgentCoordinationPolicy(input),
+  get_project_team: (app, input) => app.getProjectTeam(input),
   update_project_agent_coordination_policy: (app, input) =>
     app.updateProjectAgentCoordinationPolicy(input),
   get_project_agent_recruitment_policy: (app, input) =>

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

@@ -1,5 +1,13 @@
 const UI_MUTATION_PARITY = Object.freeze([
   agent('PUT /api/agent-pins', 'pin_agent'),
+  agent('POST /api/roundtable/messages/:messageId/cancel', 'cancel_agent_message'),
+  local('POST /api/peer/coordinator', 'Opening a LAN listener on this device is a local device decision of its owner.'),
+  local('POST /api/peer/invitations', 'Pairing invitations admit another device and are created by the local owner.'),
+  local('POST /api/peer/invitations/preview', 'The local owner inspects a private device invitation before deciding to pair.'),
+  local('POST /api/peer/join', 'Pairing this device with a coordinator is a local owner decision.'),
+  local('PUT /api/peer/shares', 'Which project leads, clients and folders other devices may use is chosen by the local owner.'),
+  local('POST /api/peer/devices/:nodeId/revoke', 'Revoking a paired device is a local owner decision.'),
+  local('POST /api/peer/disable', 'Leaving the LAN roundtable is a local owner decision.'),
   local('PUT /api/judgment/policy', 'Autonomy grants delegated authority and requires the local user.'),
   local('POST /api/judgment/feedback', 'Votes and reasons are human feedback, never model-generated approval.'),
   agent('POST /api/judgment/review', 'review_with_tonborg'),
@@ -88,7 +96,8 @@ export function agentInterfaceCatalog() {
       { domain: 'human-attention', toolNames: ['list_agent_attention', 'request_agent_attention', 'cancel_agent_attention'], guidance: 'Raise a hand only for an explicit human action. Read resolved responses before continuing. Responses do not grant permissions or accept tasks.' },
       { domain: 'projects', toolNames: ['list_knowledge_spaces', 'list_personal_projects', 'list_project_releases', 'list_project_relations'] },
       { domain: 'knowledge', toolNames: ['search_knowledge_graph', 'get_knowledge_graph', 'get_user_taste_skill', 'list_preference_conflicts'] },
-      { domain: 'people-and-tasks', toolNames: ['list_project_agents', 'list_project_agent_assignments', 'list_project_agent_tasks', 'view_project_agent_task', 'view_project_agent_activity', 'list_project_agent_recruitments'] },
+      { domain: 'people-and-tasks', toolNames: ['get_project_team', 'list_project_agents', 'list_project_agent_assignments', 'list_project_agent_tasks', 'view_project_agent_task', 'view_project_agent_activity', 'list_project_agent_recruitments'] },
+      { domain: 'roundtable', toolNames: ['find_agents', 'read_agent_messages', 'read_agent_thread', 'get_agent_message_status'], readRoutes: ['GET /api/roundtable/threads', 'GET /api/roundtable/threads/:threadId', 'GET /api/roundtable/messages/:messageId'], guidance: 'message_agent and reply_agent_message write recorded thread messages as the current task Agent. A queued message is not a reply, and a reply is not evidence that work ran. Remote asks reach only a shared project lead on a paired device; unknown means it may or may not have run. Pairing and sharing devices stay with the local owner. When task entry returns requested_agent_id, this session is still the selected Agent; follow requested_agent_guidance instead of acting as the requested Agent.' },
       { domain: 'employees-and-boards', toolNames: ['list_employee_templates', 'list_employee_tools', 'call_employee_tool'], guidance: 'Discover the employee read_board and other read tools before invoking them with exact project scope.' },
       { domain: 'external-knowledge', toolNames: ['list_external_knowledge_connectors', 'discover_external_knowledge_sources', 'list_external_knowledge_bindings', 'retrieve_external_knowledge_binding', 'get_external_knowledge_conflict_policy'], readRoutes: ['POST /api/external-knowledge/discover', 'POST /api/external-knowledge/bindings/:bindingId/retrieve'] },
       { domain: 'executors', toolNames: ['list_executors', 'get_executor', 'list_executor_routing_rules', 'list_project_agent_routing_learning'] },

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

@@ -61,7 +61,7 @@ export const projectAgentProfile = objectSchema({
       taste: { type: 'string', maxLength: 2048, default: '' },
       personality: { type: 'string', maxLength: 2048, default: '' }
     }),
-    description: 'HR-configured judgment, taste and personality based on role responsibilities. These are intended working traits, not evidence of observed growth or performance.'
+    description: 'AR-configured judgment, taste and personality based on role responsibilities. These are intended working traits, not evidence of observed growth or performance.'
   },
   expectations: {
     type: 'string', maxLength: 4096, default: '',

package/src/agents/identity-receipt.js

@@ -53,7 +53,7 @@ function unassignedReceipt(status, reason) {
     agent_selection_conflict: '分配待确认（FLA 选择冲突）',
     manual_selection: '分配待确认（需要选择负责人）'
   };
-  return `FULI Agent：${labels[status] ?? '分配未完成（HR 尚未返回负责人）'}`;
+  return `FULI Agent：${labels[status] ?? '分配未完成（AR 尚未返回负责人）'}`;
 }
 
 export function employeeCollaborationReceipt(application, context, { tool, permission, sourceApplication }) {

package/src/cli/command-registry.js

@@ -19,8 +19,11 @@ Local service:
   open [--data-dir DIR]
 
 Install and Agent connection:
+  connect [--format standard|vscode|server] [--data-dir DIR | --runtime-config FILE]  (print generic MCP configuration)
+  mcp [--runtime-config FILE] [--source-application codex|claude|claude_code|cursor|kiro|other]  (stdio server)
   setup [--yes] [--codex-only] [--data-dir DIR] [--personal-space NAME] [--port PORT] [--runtime-mode container|native] [--memory-profile low|balanced] [--adaptive-memory|--no-adaptive-memory] [--skip-agents] [--no-start] [--personal-only|--with-dev-public]
   connect-workspace --url URL --token-file FILE [--data-dir DIR]
+  peer status|host|invite|join|share|revoke|off [--data-dir DIR]  (LAN roundtable Beta: pair devices and share project leads)
   remote-mcp --personal-project-id ID --bearer-token-file FILE [--port PORT] [--data-dir DIR] [--source-application claude|cursor|other] [--allowed-origin HTTPS_ORIGIN] [--allowed-host HOST] [--max-sessions N] [--session-idle-ttl-seconds N]
   employee install BUILT_PACKAGE_DIRECTORY [--replace] [--runtime-config FILE]
   update [setup options]