fuli-context 0.11.1 → 0.12.1

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

@@ -0,0 +1,12 @@
+import { objectSchema, stringSchema, integerSchema, booleanSchema } from './schema.js';
+const id = { ...stringSchema(), minLength: 1, maxLength: 256 };
+const scope = { personalSpaceId: id, personalProjectId: { ...id, type: ['string', 'null'] } };
+export const JUDGMENT_TOOL_DEFINITIONS = [
+  { name: 'get_judgment_policy', title: 'READ · Tonborg autonomy', description: 'Read effective autonomy and quality preferences, including project inheritance. Only the user changes autonomy in Settings. Never infer permission from a recommendation.', inputSchema: objectSchema(scope, ['personalSpaceId']) },
+  { name: 'list_judgments', title: 'READ · Tonborg decisions', description: 'Read scoped decisions, execution receipts and human feedback. A recommendation is not evidence of execution. Feedback is scoped evidence, not a new global instruction.', inputSchema: objectSchema({ ...scope, limit: integerSchema({ minimum: 1, maximum: 100 }) }, ['personalSpaceId']) },
+  { name: 'review_with_tonborg', title: 'WRITE · Tonborg review', description: 'Run a bounded real-model review under the saved autonomy policy. Manual mode only analyzes. AI-reviewed never asserts human confirmation. Reuse requestId on retries; failures and stale evidence remain visible. May invoke the locally configured judgment client.', inputSchema: objectSchema({ ...scope, requestId: id, limit: integerSchema({ minimum: 1, maximum: 10 }) }, ['personalSpaceId', 'requestId']) },
+  { name: 'assess_agent_action', title: 'READ · Tonborg executor judgment', description: 'Before a new subagent, session or client choice, ask Tonborg whether to continue, delegate, reuse a verified conversation or open a new session, and select from authorized, preflighted executors and their available models using scoped preferences and feedback. Respect locked Agent policies and user rules. The host still validates and starts workers. Report actual runtime separately; this does not grant permission or claim execution.', inputSchema: objectSchema({ ...scope, requestId: id, objective: { ...stringSchema(), minLength: 1, maxLength: 8000 }, agentId: id, workKind: id, taskId: id, requiredCapabilities: { type: 'array', items: id, maxItems: 32 }, action: { type: 'string', enum: ['subagent', 'session', 'client'] } }, ['personalSpaceId', 'personalProjectId', 'requestId', 'objective', 'agentId', 'workKind']) },
+  { name: 'assess_task_completion', title: 'WRITE · Tonborg task acceptance', description: 'The accountable lead asks Tonborg to assess an awaiting-review FULI task at its exact revision. Saved autonomy may complete it only with a passed real verification by another Agent. Preserves Jefa human acceptance and never approves publication or new permissions. Reuse requestId on retries; inspect the actual execution receipt.', inputSchema: objectSchema({ ...scope, requestId: id, taskContextToken: id, taskId: id, artifactRevision: { ...id, maxLength: 160 }, expectedRevision: integerSchema({ minimum: 0 }) }, ['personalSpaceId', 'personalProjectId', 'requestId', 'taskContextToken', 'taskId', 'artifactRevision', 'expectedRevision']) },
+  { name: 'get_agent_pins', title: 'READ · Pinned Agents', description: 'Read the user’s pinned Agent IDs and revision. An explicit empty list remains empty.', inputSchema: objectSchema({ personalSpaceId: id }, ['personalSpaceId']) },
+  { name: 'pin_agent', title: 'WRITE · Pin an Agent', description: 'On the user’s request pin or unpin an existing Agent in navigation. Preserve the current revision and reload after conflicts.', inputSchema: objectSchema({ personalSpaceId: id, agentId: id, pinned: booleanSchema(), expectedRevision: integerSchema({ minimum: 0 }) }, ['personalSpaceId', 'agentId', 'pinned', 'expectedRevision']) },
+];

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/claude-code/wake.js

@@ -8,6 +8,13 @@ import { firstField, listDirectory } from '../session-log.js';
 export const claudeCodeWake = Object.freeze({
   id: 'claude_code',
 
+  judgmentArgs({ quality }) {
+    return ['-p', '--output-format', 'stream-json', '--verbose', '--safe-mode',
+      '--tools', '', '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}',
+      '--setting-sources', '', '--no-session-persistence', '--permission-mode', 'dontAsk',
+      '--effort', quality === 'economy' ? 'low' : quality === 'balanced' ? 'medium' : 'high'];
+  },
+
   resolveCommand({ env, which, platform }) {
     return env.FULI_CLAUDE_BIN || which('claude', platform);
   },

package/src/agents/codex/wake.js

@@ -9,6 +9,13 @@ import { findFile, firstField, listDirectory } from '../session-log.js';
 export const codexWake = Object.freeze({
   id: 'codex',
 
+  judgmentArgs({ cwd, quality }) {
+    return ['exec', '--json', '--ephemeral', '--ignore-user-config', '--ignore-rules',
+      '--skip-git-repo-check', '--sandbox', 'read-only', '-C', cwd,
+      '-c', 'project_doc_max_bytes=0', '-c', 'features.shell_tool=false',
+      '-c', `model_reasoning_effort="${quality === 'economy' ? 'low' : quality === 'balanced' ? 'medium' : 'high'}"`, '-'];
+  },
+
   resolveCommand({ env, which, platform, fileExists = existsSync }) {
     if (env.FULI_CODEX_BIN) return env.FULI_CODEX_BIN;
     const found = which('codex', platform);

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]

package/src/cli/connect-command.js

@@ -0,0 +1,28 @@
+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] [--data-dir DIR | --runtime-config FILE]\nPrint local MCP configuration; merge the fuli entry into your client settings. No files are changed.');
+    return;
+  }
+  const options = new Map();
+  for (let index = 0; index < args.length; index += 2) {
+    const flag = args[index];
+    if (!['--format', '--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'));
+  write(JSON.stringify(config, null, 2));
+  return config;
+}

package/src/cli/mcp-command.js

@@ -0,0 +1,99 @@
+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 { 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
+  });
+}
+
+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>]\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.'];
@@ -106,6 +107,10 @@ export function formatSetupResult(result) {
       : `${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/employees/catalog/tonborg.json

@@ -0,0 +1,20 @@
+{
+  "schemaVersion": 1,
+  "id": "tonborg",
+  "version": "1.0.0",
+  "name": "Tonborg",
+  "role": "判断官",
+  "description": "根据你的偏好与判断记录处理日常审核，为任务建议客户端和模型。",
+  "occupationEmoji": "⚖️",
+  "defaultProjectScope": "all",
+  "workbench": { "kind": "native", "view": "judgment" },
+  "capabilities": ["判断审核", "执行器选择", "判断反馈", "fuli.employee:tonborg"],
+  "workKinds": ["judgment", "knowledge-review", "executor-selection"],
+  "initialPreferences": [
+    "优先考虑用户明确偏好和当前任务证据；反馈只用于适用的范围。",
+    "记录判断依据与执行结果，权限不足或证据不足时交给用户。",
+    "保持项目负责人的汇报关系，不越过项目管理。"
+  ],
+  "permissions": ["judgment.read", "judgment.review"],
+  "runtime": null
+}

package/src/employees/manifest.js

@@ -29,7 +29,7 @@ export const employeeManifestSchema = z.object({
   }).strict().optional(),
   workbench: z.object({
     kind: z.literal('native'),
-    view: z.literal('people')
+    view: z.enum(['people', 'judgment'])
   }).strict().optional(),
   runtime: z.object({
     apiVersion: z.literal(1),
@@ -45,7 +45,7 @@ export function parseEmployeeManifest(value) {
 }
 
 // Built-in roles every personal space has; the Provider provisions their identities.
-export const FIXED_EMPLOYEE_AGENT_TYPES = Object.freeze({ jefa: 'coordinator', bole: 'hr' });
+export const FIXED_EMPLOYEE_AGENT_TYPES = Object.freeze({ jefa: 'coordinator', bole: 'hr', tonborg: 'durable' });
 
 export const employeeAgentId = (id) => `employee.${identifier.parse(id)}`;
 export const employeeCapability = (id) => `fuli.employee:${identifier.parse(id)}`;

package/src/employees/recruitment.js

@@ -186,7 +186,8 @@ export function createEmployeeRecruitment({ app, registry, managementStore }) {
     // All-project policy also covers projects without a materialized assignment.
     const agents = await app.listProjectAgents({ personalSpaceId: spaceId });
     const agent = agents.find((entry) => entry.agentId === employeeAgentId(manifest.id));
-    const management = managementFor(manifest, agent, managementStore.read(spaceId, manifest.id));
+    const stored = managementStore.read(spaceId, manifest.id);
+    const management = managementFor(manifest, agent, stored);
     if (input.sourceApplication && Array.isArray(agent?.profile.allowedClients) && !agent.profile.allowedClients.includes(input.sourceApplication)) {
       throw new EmployeeError('This employee is not enabled for the current Agent client', 403, 'assignment_required');
     }
@@ -196,6 +197,24 @@ export function createEmployeeRecruitment({ app, registry, managementStore }) {
       (management.mode !== 'all' && !(agent.assignments ?? []).some((entry) => entry.personalProjectId === selectedProject.id && entry.status === 'active'))) {
       throw new EmployeeError('Recruit this employee into the selected project first', 403, 'assignment_required');
     }
+    if (manifest.id === 'tonborg' && input.ensureAssignment === true &&
+      !activeEmployeeAssignments(agent).some(entry => entry.personalProjectId === selectedProject.id)) {
+      // Provider memory is project-scoped. Preserve the already authorized all
+      // rule before its first concrete assignment, without launching a worker.
+      if (!stored) managementStore.write(spaceId, manifest.id, managementWithoutRevision(management), 0);
+      const history = (agent.assignments ?? []).filter(entry => entry.personalProjectId === selectedProject.id);
+      const generation = history.map(entry => `${entry.assignmentId}:${entry.revision ?? 0}`).sort();
+      const key = createHash('sha256').update(JSON.stringify([manifest.id, selectedProject.id, generation])).digest('hex');
+      await app.createProjectAgentAssignment({
+        personalSpaceId: spaceId, personalProjectId: selectedProject.id, agentId: agent.agentId,
+        idempotencyKey: `employee-assignment:${key}`, responsibility: agent.profile.responsibility,
+        workKinds: agent.profile.workKinds ?? manifest.workKinds, capabilities: agent.profile.capabilities,
+        reason: 'Initialize authorized Tonborg project memory',
+      });
+      // Assignment storage is asynchronous; a concurrent scope/client change
+      // must be observed before any judgment evidence is read.
+      return authorize({ ...input, ensureAssignment: false });
+    }
     return { personalSpaceId: spaceId, project: selectedProject, agentId: agent.agentId, management };
   }
 

package/src/graphiti/agent-collaboration.js

@@ -30,11 +30,17 @@ export async function planAgentCollaboration(application, input) {
   }
   candidates.sort((a, b) => Number(a.requiresLoan) - Number(b.requiresLoan) || Number(b.workMatch) - Number(a.workMatch)
     || a.activeTasks - b.activeTasks || a.agentId.localeCompare(b.agentId));
+  const preferencePrompt = verificationPreference({ executors, rules, projectId: task.personalProjectId,
+    lockedExecutorIds: currentAgent.profile?.executorPolicy?.mode === 'locked' ? currentAgent.profile.executorPolicy.lockedExecutorIds : null });
+  const judgmentPolicy = await application.judgment?.policy({ personalSpaceId: spaceId, personalProjectId: task.personalProjectId });
+  if (judgmentPolicy && judgmentPolicy.mode !== 'manual' && preferencePrompt.choiceSource !== 'user_rule') {
+    Object.assign(preferencePrompt, { shouldAsk: false, recommendedExecutorId: null, choiceSource: 'tonborg',
+      guidance: 'The user delegated routine executor choices to Tonborg. Call assess_agent_action for the selected specialist before dispatch; ask only when its outcome requires user input. Recheck runtime availability and preserve the real execution receipt.' });
+  }
   return { teamLeadId: policy.team_lead_agent_id, currentAgentId: task.projectAgentId,
     candidates: candidates.slice(0, 8), pendingLoans: loans.loans?.filter(loan => loan.status === 'requested') ?? [],
     executionStarted: false,
-    preferencePrompt: verificationPreference({ executors, rules, projectId: task.personalProjectId,
-      lockedExecutorIds: currentAgent.profile?.executorPolicy?.mode === 'locked' ? currentAgent.profile.executorPolicy.lockedExecutorIds : null }),
+    preferencePrompt,
     guidance: 'Keep the project lead as owner. Choose a qualified specialist. For another project, the destination lead calls request_agent_loan; the source lead approves with decide_agent_loan in its own scoped task. Then coordinate_project_agent_task with the borrowed Agent. Share only the bounded task brief and authorized artifacts. Record actual workers. Verify each artifact; use record_agent_verification. Two failed attempts at one capability tier require escalation, not another identical retry. A selected model is not proof of execution or success.' };
 }
 

package/src/graphiti/federated-application.js

@@ -2,6 +2,10 @@ 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';
 
 import { GraphitiProviderClient } from './provider-client.js';
 import {
@@ -120,6 +124,10 @@ export function openFederatedGraphApplication({
       fetchImpl
     });
     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')) });
   }
@@ -1164,7 +1172,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     };
   }
 
-  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/knowledge-review.js

@@ -3,7 +3,8 @@ export function startKnowledgeReview(app, input) {
   return app.personal.startKnowledgeReview({
     personal_space_id: input.personalSpaceId,
     scope: input.scope,
-    personal_project_id: input.personalProjectId ?? null
+    personal_project_id: input.personalProjectId ?? null,
+    ...(input.reviewer ? { reviewer: input.reviewer } : {})
   });
 }
 
@@ -12,7 +13,8 @@ export function listKnowledgeReviewCandidates(app, input) {
   return app.personal.listKnowledgeReviewCandidates({
     personal_space_id: input.personalSpaceId,
     review_id: input.reviewId,
-    limit: input.limit
+    limit: input.limit,
+    ...(input.offset !== undefined ? { offset: input.offset } : {})
   });
 }
 
@@ -23,7 +25,9 @@ export function recordKnowledgeReviewProgress(app, input) {
     review_id: input.reviewId,
     candidate_key: input.candidateKey,
     outcome: input.outcome,
-    note: input.note ?? null
+    note: input.note ?? null,
+    ...(input.aiReviewEvidenceToken ? { ai_review_evidence_token: input.aiReviewEvidenceToken } : {}),
+    ...(input.aiAssessment ? { ai_assessment: input.aiAssessment } : {})
   });
 }
 

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-mapping.js

@@ -343,6 +343,8 @@ export function projectAgentTokenUsage(value) {
 export function providerProjectAgentTaskActivity(input) {
   const result = withoutUndefined({
     artifact_revision: input.artifactRevision ?? input.artifact_revision,
+    expected_verification_attempt_id: input.expectedVerificationAttemptId,
+    judgment_task_context_token: input.judgmentTaskContextToken,
     personal_space_id: input.personalSpaceId ?? input.personal_space_id,
     personal_project_id: input.personalProjectId ?? input.personal_project_id,
     task_id: input.taskId ?? input.task_id,

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', 'fuli-project-hr'].includes(agent.agentId)
-    || profile.agentType === 'hr' || capabilities.some(value => ['fuli.employee:jefa', 'fuli.employee:bole'].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())));
 }