fuli-context 0.12.0 → 0.12.2

package/src/cli/connect-command.js

@@ -0,0 +1,31 @@
+import { resolveSetupPaths } from '../setup/paths.js';
+import { resolveGraphRuntimeOptions } from '../graphiti/runtime-config.js';
+import { clientConnectionConfig } from '../setup/client-connection.js';
+
+export function runConnectCommand(args, { env = process.env, write = console.log } = {}) {
+  if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
+    write('fuli connect [--format standard|vscode|server] [--profile full|chat] [--source-application codex|claude|claude_code|cursor|kiro|other] [--data-dir DIR | --runtime-config FILE]\nPrint local MCP configuration; merge the fuli entry into your client settings. No files are changed.\nUse --profile chat for chat apps that load every tool into each conversation. fuli setup configures Claude Desktop automatically.');
+    return;
+  }
+  const options = new Map();
+  for (let index = 0; index < args.length; index += 2) {
+    const flag = args[index];
+    if (!['--format', '--profile', '--source-application', '--data-dir', '--runtime-config'].includes(flag)) throw new TypeError(`Unknown connect option: ${flag}`);
+    if (options.has(flag)) throw new TypeError(`Duplicate ${flag}`);
+    const value = args[index + 1];
+    if (!value?.trim() || value.startsWith('--')) throw new TypeError(`Missing value for ${flag}`);
+    options.set(flag, value);
+  }
+  if (options.has('--data-dir') && options.has('--runtime-config')) {
+    throw new TypeError('Choose --data-dir or --runtime-config, not both');
+  }
+  const paths = resolveSetupPaths({ dataDir: options.get('--data-dir'), env });
+  const runtimeConfigPath = options.has('--data-dir') ? paths.graphRuntimeConfigPath
+    : resolveGraphRuntimeOptions(options.has('--runtime-config') ? ['--runtime-config', options.get('--runtime-config')] : [], env).runtimeConfigPath;
+  const config = clientConnectionConfig({ mcpServerPath: paths.mcpServerPath, runtimeConfigPath }, options.get('--format'), {
+    profile: options.get('--profile') ?? 'full',
+    sourceApplication: options.get('--source-application') ?? 'other'
+  });
+  write(JSON.stringify(config, null, 2));
+  return config;
+}

package/src/cli/mcp-command.js

@@ -0,0 +1,101 @@
+import { callAgentTool, listAgentTools } from '../agent-tools.js';
+import {
+  bindRuntimeLeaseAgentTools,
+  createRuntimeLeaseClient
+} from '../adaptive-runtime/lease-client.js';
+import { ApplicationError } from '../app/application-error.js';
+import { openFederatedGraphApplication } from '../graphiti/federated-application.js';
+import {
+  GraphRuntimeConfigurationError,
+  resolveGraphRuntimeOptions
+} from '../graphiti/runtime-config.js';
+import { runStdio } from '../mcp/runtime.js';
+import { prepareDirectAgentToolCall } from '../mcp/direct-call.js';
+import { normalizeMcpSourceApplication } from '../mcp/session-id.js';
+import { toolNamesForProfile } from '../mcp/tool-profiles.js';
+import { applicationErrorMessage } from '../mcp/tool-result.js';
+
+export async function runMcpCommand(args, { env = process.env } = {}) {
+  if (args.includes('--tools')) {
+    process.stdout.write(`${JSON.stringify(listAgentTools(), null, 2)}\n`);
+    return;
+  }
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write(helpText());
+    return;
+  }
+
+  const { runtimeConfigPath } = resolveGraphRuntimeOptions(args, env);
+  const configuredSourceApplication = args.includes('--source-application')
+    ? requiredOption(args, '--source-application')
+    : null;
+  if (args.includes('--call')) {
+    await runCall({
+      args,
+      runtimeConfigPath,
+      sourceApplication: configuredSourceApplication
+        ? normalizeMcpSourceApplication(configuredSourceApplication)
+        : 'other'
+    });
+    return;
+  }
+  await runStdio({
+    runtimeConfigPath,
+    sourceApplication: configuredSourceApplication
+      ? normalizeMcpSourceApplication(configuredSourceApplication)
+      : undefined,
+    toolNames: toolNamesForProfile(args.includes('--tool-profile') ? requiredOption(args, '--tool-profile') : 'full')
+  });
+}
+
+async function runCall({ args, runtimeConfigPath, sourceApplication }) {
+  const toolName = requiredOption(args, '--call');
+  const prepared = await prepareDirectAgentToolCall({
+    toolName,
+    input: parseInput(args),
+    sourceApplication
+  });
+  const app = openFederatedGraphApplication({ runtimeConfigPath });
+  const leaseClient = createRuntimeLeaseClient({ runtimeConfigPath });
+  bindRuntimeLeaseAgentTools(app, leaseClient);
+  try {
+    const result = await leaseClient.withGraphLease(
+      `cli-call:${toolName}`,
+      () => callAgentTool(app, toolName, prepared.input)
+    );
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } finally {
+    await leaseClient.close();
+    await app.close();
+  }
+}
+
+function option(args, flag) {
+  const index = args.indexOf(flag);
+  return index === -1 ? null : args[index + 1];
+}
+
+function requiredOption(args, flag) {
+  const value = option(args, flag);
+  if (!value) throw new TypeError(`Missing value for ${flag}`);
+  return value;
+}
+
+function parseInput(args) {
+  const raw = option(args, '--input');
+  return raw ? JSON.parse(raw) : {};
+}
+
+export function startupMessage(error) {
+  if (error instanceof ApplicationError) return applicationErrorMessage(error);
+  if (error instanceof GraphRuntimeConfigurationError) return error.message;
+  return 'MCP server failed to start';
+}
+
+function helpText() {
+  return 'Usage: fuli mcp [--runtime-config <graph-runtime.json>] ' +
+    '[--source-application <codex|claude|claude_code|cursor|kiro|other>] [--tool-profile <full|chat>]\n' +
+    '       fuli mcp --tools\n' +
+    '       fuli mcp --runtime-config <graph-runtime.json> ' +
+    '--call <tool> [--input <json>]\n';
+}

package/src/cli/peer-command.js

@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs';
+
+import { resolveSetupPaths } from '../setup/paths.js';
+import { DEFAULT_RUNTIME_SETTINGS, readRuntimeSettings } from '../system/runtime-settings.js';
+import { shortFingerprint } from '../agent-peer/protocol.js';
+
+const USAGE = `fuli peer <action>  (LAN roundtable Beta; the local console must be running)
+  status
+  host --address IP [--port PORT] [--name NAME]   turn this computer into the coordinator
+  invite                                          print a one-use pairing invitation (10 minutes)
+  join (--invitation TEXT | --invitation-file FILE) [--name NAME]
+  share --project ID --clients codex[,claude_code] [--folder DIR]   (repeat --project for more; replaces the list)
+  revoke --device FINGERPRINT                     coordinator only
+  off                                             leave: stop listening, sharing and trusting devices`;
+
+// The owner's LAN roundtable controls through the local console, so the CLI
+// and Settings share one runtime and one set of local-only checks.
+export async function runPeerCommand(args, { env = process.env, fetchImpl = fetch, write = console.log } = {}) {
+  const [action, ...rest] = args;
+  if (!action || action === '--help' || action === '-h') { write(USAGE); return; }
+  const paths = resolveSetupPaths({ dataDir: option(rest, '--data-dir'), env });
+  const settings = paths.runtimeSettingsPath ? readRuntimeSettings(paths.runtimeSettingsPath) : DEFAULT_RUNTIME_SETTINGS;
+  const base = `http://127.0.0.1:${settings.ports.console}`;
+  const call = async (method, path, body) => {
+    let response;
+    try {
+      response = await fetchImpl(`${base}${path}`, { method, headers: { 'content-type': 'application/json' },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+    } catch {
+      throw new Error('The local FULI console is not running; start it with `fuli start`.');
+    }
+    const value = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(value.message ?? `Request failed (${response.status})`);
+    return value;
+  };
+  switch (action) {
+    case 'status': return printStatus(await call('GET', '/api/peer'), write);
+    case 'host': {
+      const address = option(rest, '--address');
+      if (!address) throw new Error('Pass --address with one of this computer\'s LAN addresses (see `fuli peer status`).');
+      return printStatus(await call('POST', '/api/peer/coordinator', { host: address,
+        port: Number(option(rest, '--port') ?? 0), name: option(rest, '--name') }), write);
+    }
+    case 'invite': {
+      const result = await call('POST', '/api/peer/invitations', {});
+      write(`Coordinator fingerprint: ${shortFingerprint(result.fingerprint)}`);
+      write(`Invitation (one use, until ${result.expiresAt}):\n${result.invitation}`);
+      write('Compare this fingerprint with the one shown on the joining device before you share it.');
+      return;
+    }
+    case 'join': {
+      const file = option(rest, '--invitation-file');
+      const invitation = option(rest, '--invitation') ?? (file ? readFileSync(file, 'utf8').trim() : null);
+      if (!invitation) throw new Error('Pass --invitation or --invitation-file.');
+      return printStatus(await call('POST', '/api/peer/join', { invitation, name: option(rest, '--name') }), write);
+    }
+    case 'share': {
+      const projects = options(rest, '--project');
+      const clients = (option(rest, '--clients') ?? '').split(',').map((client) => client.trim()).filter(Boolean);
+      const folder = option(rest, '--folder');
+      if (projects.length > 1 && folder) throw new Error('--folder applies to a single --project.');
+      return printStatus(await call('PUT', '/api/peer/shares', { shares: projects.map((projectId) => ({ projectId, clients,
+        ...(folder ? { workingDirectory: folder } : {}) })) }), write);
+    }
+    case 'revoke': {
+      const device = option(rest, '--device');
+      if (!/^[0-9a-f]{64}$/.test(device ?? '')) throw new Error('Pass --device with the full fingerprint from `fuli peer status`.');
+      return printStatus(await call('POST', `/api/peer/devices/${device}/revoke`, {}), write);
+    }
+    case 'off': return printStatus(await call('POST', '/api/peer/disable', {}), write);
+    default: throw new Error(`Unknown peer action: ${action}\n${USAGE}`);
+  }
+}
+
+function printStatus(status, write) {
+  if (!status.role) {
+    write('LAN roundtable (Beta): off.');
+    if (status.remoteRemovalPending) write('This device has stopped sharing. Pairing removal will retry when the coordinator is available.');
+    if (status.addresses.length) write(`LAN addresses: ${status.addresses.join(', ')}`);
+    return;
+  }
+  write(`LAN roundtable (Beta): ${status.role === 'coordinator' ? 'coordinator' : 'paired device'}`);
+  write(`This device: ${status.device.shortFingerprint}`);
+  write(`Coordinator: ${status.coordinator.name} ${status.coordinator.url} (${status.coordinator.shortFingerprint})`);
+  for (const device of status.devices.filter((entry) => !entry.self)) {
+    write(`  device ${device.name} ${device.shortFingerprint} ${device.status}${device.online ? ' online' : ''} ${device.nodeId}`);
+  }
+  for (const share of status.shares) {
+    write(`  shared project lead: ${share.projectName} · ${share.clients.join(', ')} · ${share.state}${share.workingDirectory ? '' : ' · folder from recent sessions'}`);
+  }
+}
+
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : undefined;
+}
+
+function options(args, name) {
+  return args.flatMap((value, index) => (value === name && index + 1 < args.length ? [args[index + 1]] : []));
+}

package/src/cli/setup-agent-selection.js

@@ -86,7 +86,7 @@ export function selectedAgentIds(agents, state) {
 
 export function formatAgentCheckboxSelection(agents, state) {
   return [
-    'Multiple supported Agents were detected:',
+    'Clients available for automatic setup:',
     ...agents.map((agent, index) => {
       const pointer = index === state.activeIndex ? '❯' : ' ';
       const checkbox = state.selected[index] ? '[x]' : '[ ]';
@@ -161,7 +161,7 @@ async function promptCheckboxAgentSelection(agents, { input, output }) {
 
 async function promptTextAgentSelection(agents, { input, output }) {
   const terminal = createInterface({ input, output });
-  output.write('Multiple supported Agents were detected:\n');
+  output.write('Clients available for automatic setup:\n');
   for (const [index, agent] of agents.entries()) {
     output.write(`  ${index + 1}. ${agent.label}\n`);
   }

package/src/cli/setup-command.js

@@ -67,7 +67,8 @@ export function formatSetupPreview(plan, options) {
     `Management UI: ${options.noStart
       ? 'will not start'
       : `http://127.0.0.1:${runtimeSettings.ports.console}`}`,
-    `Agents: ${agentSummary}`
+    `Automatic client setup: ${agentSummary}`,
+    'Other MCP clients: connect after setup with fuli connect (no model required)'
   ];
   if (
     runtimeMode !== 'native' &&
@@ -80,7 +81,7 @@ export function formatSetupPreview(plan, options) {
   return lines.join('\n');
 }
 
-export function formatSetupResult(result) {
+export function formatSetupResult(result, plan) {
   const lines = [result.status === 'ready'
     ? 'Fuli is ready.'
     : 'Fuli started, but one or more Agents are not connected.'];
@@ -101,11 +102,17 @@ export function formatSetupResult(result) {
       lines.push(`${agent.label}: ${state}${agent.message ? ` (${agent.message})` : ''}; retry fuli setup`);
       continue;
     }
-    lines.push(agent.newTaskRequired
-      ? `${agent.label}: connected; create or reopen a task to load the new configuration`
-      : `${agent.label}: connected`);
+    lines.push(agent.restartRequired
+      ? `${agent.label}: connected; quit and reopen the app to load Fuli`
+      : agent.newTaskRequired
+        ? `${agent.label}: connected; create or reopen a task to load the new configuration`
+        : `${agent.label}: connected`);
     for (const step of agent.nextSteps ?? []) lines.push(`${agent.label}: ${step}`);
   }
+  const dataDir = plan?.paths?.dataDir;
+  lines.push('Other MCP clients: run fuli connect and merge the fuli entry into your MCP settings.');
+  if (dataDir) lines.push(`For this installation, use --data-dir ${JSON.stringify(dataDir)}.`);
+  lines.push('MCP provides tools and memory. Automatic conversation capture and wake/resume require a client adapter.');
   return lines.join('\n');
 }
 

package/src/cli.js

@@ -11,6 +11,9 @@ import { runRemoteMcpCommand } from './cli/remote-mcp-command.js';
 import { runGraphDataCommand } from './cli/graph-data-command.js';
 import { runEmployeeCommand } from './cli/employee-command.js';
 import { runSetupCommand } from './cli/setup-command.js';
+import { runConnectCommand } from './cli/connect-command.js';
+import { runPeerCommand } from './cli/peer-command.js';
+import { runMcpCommand, startupMessage } from './cli/mcp-command.js';
 import { runUninstallCommand } from './cli/uninstall-command.js';
 import { runUpdateCommand } from './cli/update-command.js';
 import { runWorkspaceConnectionCommand } from './cli/workspace-connection-command.js';
@@ -32,6 +35,19 @@ export async function main(argv = process.argv.slice(2), env = process.env) {
     await runSetupCommand(commandArgs, { env });
     return;
   }
+  if (command === 'connect') {
+    assertSupportedNodeVersion();
+    return runConnectCommand(commandArgs, { env });
+  }
+  if (command === 'peer') {
+    assertSupportedNodeVersion();
+    return runPeerCommand(commandArgs, { env });
+  }
+  if (command === 'mcp') {
+    assertSupportedNodeVersion();
+    try { return await runMcpCommand(commandArgs, { env }); }
+    catch (error) { throw new Error(startupMessage(error)); }
+  }
   if (command === 'graph') {
     assertSupportedNodeVersion();
     const [action, ...graphArgs] = commandArgs;

package/src/employees/catalog/bole.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
   "id": "bole",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "name": "Bole",
-  "role": "HR",
+  "role": "AR",
   "description": "查看 Agent 人员分布、当前工作和带时间与原因的招募记录。",
   "occupationEmoji": "🔎",
   "defaultProjectScope": "all",

package/src/graphiti/federated-application.js

@@ -2,6 +2,7 @@ import { dirname, join } from 'node:path';
 import { createEmployeeService } from '../employees/service.js';
 import { createAgentRoundtable } from '../agent-roundtable/service.js';
 import { createRoundtableStore } from '../agent-roundtable/store.js';
+import { createPeerPort } from '../agent-peer/peer-port.js';
 import { createJudgmentService } from '../judgment/service.js';
 import { JudgmentStore } from '../judgment/store.js';
 import { createJudgmentEngine } from '../judgment/engine.js';
@@ -125,6 +126,8 @@ export function openFederatedGraphApplication({
     app.employees = createEmployeeService({ app, runtimeConfigPath });
     app.judgment = createJudgmentService({ app, engine: createJudgmentEngine({ app }),
       openStore: () => new JudgmentStore(join(dirname(runtimeConfigPath), 'judgment.sqlite')) });
+    app.peer = createPeerPort({ dataDir: dirname(runtimeConfigPath), provider: app.personal,
+      spaceId: () => app.config.personal.spaceId });
     app.roundtable = createAgentRoundtable({ app, env,
       openStore: () => createRoundtableStore(join(dirname(runtimeConfigPath), 'agent-roundtable.sqlite')) });
   }
@@ -1169,7 +1172,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     };
   }
 
-  close() { this.judgment?.close(); this.roundtable?.close(); return this.employees?.close(); }
+  close() { this.judgment?.close(); this.roundtable?.close(); this.peer?.close(); return this.employees?.close(); }
 
   async #recordAgentViews(items, toolName) {
     const unique = new Map(items.map((item) => [

package/src/graphiti/project-agent-control-plane.js

@@ -2,6 +2,7 @@ import { planAgentCollaboration, agentLoan, agentVerification } from './agent-co
 import { queryConversations, resumeConversation, updateConversationPolicy } from './agent-conversations.js';
 import { agentProjectResolution } from './agent-knowledge-workflows.js';
 import { listAgentAttention, changeAgentAttention } from './agent-attention.js';
+import { loadProjectTeam } from './project-team-view.js';
 import {
   getProjectAgentMemory,
   agentMemoryView,
@@ -205,6 +206,12 @@ export class ProjectAgentControlPlaneApplication {
     return getProjectAgentCoordinationPolicyWorkflow(this, input);
   }
 
+  async getProjectTeam(input) {
+    this.#assertSpace(input.personalSpaceId);
+    if (!input.personalProjectId) throw new TypeError('personalProjectId is required');
+    return loadProjectTeam(this, input.personalSpaceId, input.personalProjectId);
+  }
+
   async updateProjectAgentCoordinationPolicy(input) {
     this.#assertSpace(input.personalSpaceId);
     return updateProjectAgentCoordinationPolicyWorkflow(this, input);

package/src/graphiti/project-agent-task-entry.js

@@ -2,6 +2,7 @@ import { projectAgentRecord } from './project-agent-mapping.js';
 import { agentMemoryView } from './project-agent-memory.js';
 import { planTaskKnowledgeRecall } from './task-knowledge-recall.js';
 import { loadProjectTeamContext } from './project-agent-team-context.js';
+import { isPeerRoleAgent } from './project-team-view.js';
 import { resolveTaskAgentMention } from './project-agent-mention.js';
 
 const ENTRY_TOOLS = new Set(['begin_task_context', 'get_collaboration_preferences']);
@@ -49,14 +50,14 @@ export async function resolveTaskEntryAgent(application, resolution, input) {
     const implicit = !mention?.agentId && !input.projectAgentId;
     const peerOnly = agent && implicit && unrelatedPeer(agent, workKind, input.requiredCapabilities);
     if (implicit && value.reason !== 'project_lead_required' && (peerOnly || value.status === 'unassigned')) {
-      // Every task gets a FULI Agent: a project without a lead has HR hire one.
+      // Every task gets a FULI Agent: a project without a lead has AR hire one.
       const staffed = await application.personal.staffDefaultProjectLead(scope).catch(() => null);
       if (staffed?.agent) {
         value = staffed;
         agent = projectAgentRecord(staffed.agent);
       } else if (peerOnly) {
         return { status: 'unassigned', reason: 'specialist_required', worker_started: false,
-          required_action: 'Use coordinate_project_agent_task to select or recruit a qualified durable owner before implementation. HR and project managers collaborate in their own roles; do not attribute development to them by fallback.' };
+          required_action: 'Use coordinate_project_agent_task to select or recruit a qualified durable owner before implementation. AR and project managers collaborate in their own roles; do not attribute development to them by fallback.' };
       }
     }
     const employeeId = /^employee\.([a-z][a-z0-9-]{0,63})$/.exec(agent?.agentId ?? '')?.[1];
@@ -159,8 +160,7 @@ function boundedRoleText(value, limit) {
 function unrelatedPeer(agent, workKind, required = []) {
   const profile = agent.profile;
   const capabilities = (profile.capabilities ?? []).map(value => value.toLowerCase());
-  const peer = ['employee.jefa', 'employee.bole', 'employee.tonborg', 'fuli-project-hr'].includes(agent.agentId)
-    || profile.agentType === 'hr' || capabilities.some(value => ['fuli.employee:jefa', 'fuli.employee:bole', 'fuli.employee:tonborg'].includes(value));
+  const peer = isPeerRoleAgent({ agentId: agent.agentId, agentType: profile.agentType, capabilities });
   return peer && !(profile.workKinds ?? []).some(kind => kind.toLowerCase() === workKind.toLowerCase())
     && !(required.length && required.every(value => capabilities.includes(value.toLowerCase())));
 }

package/src/graphiti/project-agent-team-context.js

@@ -1,24 +1,22 @@
+import { loadProjectTeam } from './project-team-view.js';
+
 // Only public role/assignment data crosses the team boundary. Member memory
 // is restored separately inside each authorized worker's isolated context.
 export async function loadProjectTeamContext(application, personalSpaceId, projectId) {
   if (typeof application.personal.getProjectAgentCoordinationPolicy !== 'function') return null;
-  const policy = await application.personal.getProjectAgentCoordinationPolicy(personalSpaceId, projectId);
-  if (!policy?.team_lead_agent_id) return null;
-  const agents = await application.personal.listProjectAgents(personalSpaceId, projectId, { status: 'active' });
-  const ids = [policy.team_lead_agent_id, ...(policy.team_member_agent_ids ?? [])];
-  const roster = (Array.isArray(agents) ? agents : []).filter(agent => ids.includes(agent.agent_id)
-    && agent.assignments?.some(assignment => assignment.personal_project_id === projectId
-      && assignment.status === 'active'))
-    .map(agent => ({ agent_id: agent.agent_id,
-      name: agent.profile?.display_name || agent.profile?.name,
-      responsibility: agent.assignments?.find(assignment => assignment.personal_project_id === projectId
-        && assignment.status === 'active')?.responsibility || agent.profile?.responsibility,
-      role: agent.agent_id === policy.team_lead_agent_id ? 'lead' : 'member' }));
-  return { lead_agent_id: policy.team_lead_agent_id, roster,
-    user_facing_agent_id: policy.team_lead_agent_id,
-    reporting_lines: roster.filter(agent => agent.role === 'member')
-      .map(agent => ({ agent_id: agent.agent_id, reports_to_agent_id: policy.team_lead_agent_id })),
-    unavailable_agent_ids: ids.filter(id => !roster.some(agent => agent.agent_id === id)),
+  const team = await loadProjectTeam(application, personalSpaceId, projectId);
+  if (team.status === 'no_lead') return null;
+  const leadId = team.lead?.agentId ?? team.unavailableLead.agentId;
+  const entry = (person, role) => ({ agent_id: person.agentId, name: person.name,
+    responsibility: person.responsibility, role });
+  const roster = [...(team.lead ? [entry(team.lead, 'lead')] : []),
+    ...team.members.map(member => entry(member, 'member'))];
+  return { lead_agent_id: leadId, roster,
+    user_facing_agent_id: leadId,
+    reporting_lines: team.members.map(member => ({ agent_id: member.agentId, reports_to_agent_id: leadId })),
+    unavailable_agent_ids: [...(team.lead ? [] : [leadId]), ...team.unavailableMemberIds],
+    assigned_collaborators: team.collaborators.map(person => entry(person, 'collaborator')),
+    assigned_peers: team.peers.map(person => entry(person, 'peer')),
     peer_roles: ['hr', 'project_manager'], worker_started: false,
-    guidance: 'The project lead is the sole user-facing owner. Members report results and blockers to this lead; do not skip reporting levels or replace the lead when a member is named. The lead integrates and verifies member reports before reporting to the user. Split bounded work through an authorized coordination plan; report real worker evidence. HR and project managers remain peers. Team membership grants no new tool, data, executor, or publication permissions.' };
+    guidance: 'The project lead is the sole user-facing owner. Members report results and blockers to this lead; do not skip reporting levels or replace the lead when a member is named. Assigned collaborators outside the explicit team work through the lead and are not direct reports unless the policy names them. The lead integrates and verifies member reports before reporting to the user. Split bounded work through an authorized coordination plan; report real worker evidence. AR and project managers remain peers. Team membership grants no new tool, data, executor, or publication permissions.' };
 }

package/src/graphiti/project-team-view.js

@@ -0,0 +1,82 @@
+// One authoritative reading of a project's people. The coordination policy
+// owns the explicit hierarchy; active assignments decide who currently works
+// on the exact project. Assigned Agents outside the explicit team are shown as
+// collaborators and peer roles stay peers, never converted into direct reports.
+const PEER_AGENT_IDS = new Set(['employee.jefa', 'employee.bole', 'employee.tonborg', 'fuli-project-hr']);
+const PEER_CAPABILITIES = new Set(['fuli.employee:jefa', 'fuli.employee:bole', 'fuli.employee:tonborg']);
+
+export function isPeerRoleAgent({ agentId, agentType, capabilities = [] }) {
+  return PEER_AGENT_IDS.has(agentId) || agentType === 'hr'
+    || capabilities.some(value => PEER_CAPABILITIES.has(String(value).toLowerCase()));
+}
+
+export function buildProjectTeam({ policy, agents, projectId }) {
+  const leadId = policy?.team_lead_agent_id ?? null;
+  const memberIds = [...new Set(policy?.team_member_agent_ids ?? [])].filter(id => id !== leadId);
+  const all = Array.isArray(agents) ? agents : [];
+  const assigned = new Map();
+  for (const agent of all) {
+    const assignment = activeAssignment(agent, projectId);
+    if (assignment && isActive(agent)) assigned.set(agent.agent_id, person(agent, assignment));
+  }
+  const lead = leadId ? assigned.get(leadId) ?? null : null;
+  // Legacy or reclassified policies may still name a peer role as a member;
+  // it stays a peer and never gains a reporting line.
+  const members = memberIds.filter(id => assigned.has(id) && !assigned.get(id).peerRole)
+    .map(id => ({ ...assigned.get(id), reportsToAgentId: lead ? leadId : null }));
+  const reporting = new Set([leadId, ...members.map(member => member.agentId)]);
+  const collaborators = [];
+  const peers = [];
+  for (const [id, entry] of assigned) {
+    if (reporting.has(id)) continue;
+    (entry.peerRole ? peers : collaborators).push(entry);
+  }
+  const byName = (left, right) => left.name.localeCompare(right.name);
+  const former = leadId && !lead ? all.find(agent => agent.agent_id === leadId) : null;
+  return {
+    personalProjectId: projectId,
+    status: !leadId ? 'no_lead' : lead ? 'ready' : 'lead_unavailable',
+    lead,
+    unavailableLead: leadId && !lead ? { agentId: leadId, name: former ? displayName(former) : null } : null,
+    members,
+    collaborators: collaborators.sort(byName),
+    peers: peers.sort(byName),
+    unavailableMemberIds: memberIds.filter(id => !assigned.has(id))
+  };
+}
+
+function activeAssignment(agent, projectId) {
+  return (agent.assignments ?? []).find(assignment => assignment.personal_project_id === projectId
+    && assignment.status === 'active') ?? null;
+}
+
+function isActive(agent) {
+  const status = agent.profile?.status;
+  return status === undefined || status === null || status === 'active';
+}
+
+function displayName(agent) {
+  return agent.profile?.display_name || agent.profile?.name || agent.agent_id;
+}
+
+function person(agent, assignment) {
+  const profile = agent.profile ?? {};
+  return {
+    agentId: agent.agent_id,
+    name: displayName(agent),
+    employeeNumber: agent.employee_number ?? null,
+    occupationEmoji: profile.occupation_emoji ?? profile.occupationEmoji ?? null,
+    responsibility: assignment.responsibility || profile.responsibility || '',
+    peerRole: isPeerRoleAgent({ agentId: agent.agent_id, agentType: profile.agent_type,
+      capabilities: profile.capabilities ?? [] })
+  };
+}
+
+export async function loadProjectTeam(application, personalSpaceId, projectId) {
+  const [policy, agents] = await Promise.all([
+    application.personal.getProjectAgentCoordinationPolicy(personalSpaceId, projectId),
+    application.personal.listProjectAgents(personalSpaceId, projectId, { status: 'active' })
+  ]);
+  const list = Array.isArray(agents) ? agents : agents?.agents ?? agents?.items ?? [];
+  return buildProjectTeam({ policy, agents: list, projectId });
+}

package/src/graphiti/provider-client.js

@@ -156,6 +156,15 @@ export class GraphitiProviderClient {
   issueAgentDelegation(input) {
     return this.#request('/v1/project-agent-context/delegations', { method: 'POST', body: input });
   }
+  issueRemoteAgentDelegation(input) {
+    return this.#request('/v1/project-agent-context/remote-delegations', { method: 'POST', body: input });
+  }
+  issueRemoteAgentOrigin(input) {
+    return this.#request('/v1/project-agent-context/remote-origins', { method: 'POST', body: input });
+  }
+  getRemoteOriginAuthority(personalSpaceId) {
+    return this.#request(`/v1/project-agent-context/remote-origin-authority?${new URLSearchParams({ personal_space_id: personalSpaceId })}`);
+  }
   verifyAgentDelegation(input) {
     return this.#request('/v1/project-agent-context/delegations/verify', { method: 'POST', body: input });
   }

package/src/graphiti/task-entry-preferences.js

@@ -42,7 +42,7 @@ export async function taskEntryPreferences(application, projectResolution, {
   }) : selection;
   if (context && selection?.requested_agent_id) {
     context.requested_agent_id = selection.requested_agent_id;
-    context.requested_agent_guidance = 'The user requested this project specialist. Keep the project lead as accountable owner; coordinate a scoped workstream for the specialist and receive its report before replying. This request is not evidence that a worker ran. Do not load the specialist’s private memory into the lead context.';
+    context.requested_agent_guidance = 'The user requested this project specialist, but this session runs as the selected project lead. Keep the lead as accountable owner; coordinate a scoped workstream for the specialist and receive its report before replying. This request is not evidence that a worker ran. Do not load the specialist’s private memory, write memory or checkpoints as the specialist, or reuse another session’s task context. If this session was opened to act as the specialist, tell the user it is running as the lead.';
   }
   if (context && selection?.reporting_lead_agent_id) {
     context.reporting_lead_agent_id = selection.reporting_lead_agent_id;

package/src/http/api-router.js

@@ -3,6 +3,7 @@ import { handleExternalKnowledgeApiRequest } from './external-knowledge-api-rout
 import { handleGraphApiRequest } from './graph-api-router.js';
 import { handleEmployeeApiRequest } from './employee-api-router.js';
 import { handleRoundtableApiRequest } from '../agent-roundtable/http.js';
+import { handlePeerApiRequest } from '../agent-peer/http.js';
 import { handleJudgmentApiRequest } from '../judgment/http.js';
 import { FULI_VERSION } from '../package-metadata.js';
 
@@ -12,9 +13,11 @@ export async function handleApiRequest({
   app,
   system = null,
   externalKnowledge = null,
-  connectedKnowledge = null
+  connectedKnowledge = null,
+  peer = null
 }) {
   const url = new URL(request.url, 'http://127.0.0.1');
+  if (await handlePeerApiRequest({ request, response, url, peer })) return true;
   if (await handleRoundtableApiRequest({ request, response, url, roundtable: app.roundtable })) return true;
 
   if (url.pathname === '/api/health' && request.method === 'GET') {
@@ -32,6 +35,12 @@ export async function handleApiRequest({
     return true;
   }
 
+  if (system && url.pathname === '/api/system/client-connection' && request.method === 'GET') {
+    response.setHeader('Cache-Control', 'no-store');
+    sendJson(response, 200, system.clientConnection());
+    return true;
+  }
+
   if (system && url.pathname === '/api/system/settings' && request.method === 'PUT') {
     sendJson(response, 200, system.updateSettings(await readJson(request)));
     return true;

package/src/http/graph-api-router.js

@@ -320,6 +320,13 @@ export async function handleGraphApiRequest({
     }));
     return true;
   }
+  if (url.pathname === '/api/project-team' && request.method === 'GET') {
+    sendJson(response, 200, await app.getProjectTeam({
+      personalSpaceId: url.searchParams.get('personalSpaceId'),
+      personalProjectId: url.searchParams.get('personalProjectId')
+    }));
+    return true;
+  }
   if (url.pathname === '/api/project-agent-coordination-policy' &&
       (request.method === 'PUT' || request.method === 'PATCH')) {
     sendJson(response, 200, await app.updateProjectAgentCoordinationPolicy(await readJson(request)));

package/src/mcp/runtime.js

@@ -7,12 +7,13 @@ import {
 import { openFederatedGraphApplication } from '../graphiti/federated-application.js';
 import { createMcpServer } from './create-mcp-server.js';
 
-export async function runStdio({ runtimeConfigPath, sourceApplication }) {
+export async function runStdio({ runtimeConfigPath, sourceApplication, toolNames = null }) {
   const app = openFederatedGraphApplication({ runtimeConfigPath });
   const leaseClient = createRuntimeLeaseClient({ runtimeConfigPath });
   bindRuntimeLeaseAgentTools(app, leaseClient);
   const server = createServerOrClose(app, createMcpServer, {
     sourceApplication,
+    toolNames,
     withRuntimeLease: leaseClient.withGraphLease
   });
   const transport = new StdioServerTransport();