fuli-context 0.10.0 → 0.11.0

package/src/agents/identity-receipt.js

@@ -12,20 +12,30 @@ export function agentContinuation(projectId, agentId, conversationId = null) {
     guidance: 'Use a connected client and the same authorized project/Agent. Obtain a fresh task context; never reuse the previous client’s token. This is a FULI prompt, not a native client @ picker registration.' };
 }
 
-export function taskAgentReceipt(application, { projectId, agentId, name = null,
-  sourceApplication = null, workStatus = null, conversationId = null, persistence = null }) {
-  const owner = agentId ? { agent_id: agentId, name,
-    profile_url: agentProfileUrl(application, agentId), source_application: sourceApplication } : null;
+function agentLink(application, agentId, name) {
   const label = String(name?.trim() || agentId).replace(/[\r\n\t]+/g, ' ')
     .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
     .replace(/[\\`*_{}\[\]()!|]/g, '\\$&');
+  return `[${label}](<${agentProfileUrl(application, agentId).replace(/[<>\s]/g, encodeURIComponent)}>)`;
+}
+
+// The reply's attribution line: who led the task and who actually helped.
+export function taskAgentReceipt(application, { projectId, agentId, name = null,
+  sourceApplication = null, workStatus = null, conversationId = null, persistence = null,
+  collaborators = [] }) {
+  const owner = agentId ? { agent_id: agentId, name,
+    profile_url: agentProfileUrl(application, agentId), source_application: sourceApplication } : null;
+  const helpers = owner ? collaborators.filter(item => item.agentId !== agentId) : [];
   const markdown = owner
-    ? `FULI Agent：[${label}](<${owner.profile_url.replace(/[<>\s]/g, encodeURIComponent)}>)`
+    ? `FULI Agent：负责人 ${agentLink(application, agentId, name)}`
+      + (helpers.length ? ` · 协作 ${helpers.map(item => agentLink(application, item.agentId, item.name)).join('、')}` : '')
     : 'FULI Agent：未选定';
   return { required: true, markdown, owner,
+    collaborators: helpers.map(item => ({ agent_id: item.agentId, name: item.name,
+      profile_url: agentProfileUrl(application, item.agentId) })),
     personal_project_id: projectId, work_status: workStatus, persistence,
     continuation: owner ? agentContinuation(projectId, agentId, conversationId) : null,
-    guidance: 'MUST include agent_receipt.markdown unchanged exactly once in every final user-visible reply, including greetings, status and errors, even when capture is disabled or nothing is retained. Use this task’s receipt; never invent an owner. Report only truthful work/memory status and actually used collaboration_receipt participants; tools and configured peers are not independent model workers.' };
+    guidance: 'MUST end every final user-visible reply with agent_receipt.markdown unchanged, exactly once, including greetings, status and errors, even when capture is disabled or nothing is retained. The receipt returned by checkpoint_task_knowledge supersedes the entry receipt because it names actual collaborators. Never invent an owner or a collaborator.' };
 }
 
 export function employeeCollaborationReceipt(application, context, { tool, permission, sourceApplication }) {

package/src/agents/session-log.js

@@ -0,0 +1,34 @@
+import { closeSync, openSync, readSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Read-only helpers for locating a client's JSONL session log on disk.
+
+export function listDirectory(directory) {
+  try { return readdirSync(directory); } catch { return []; }
+}
+
+// Newest-first search for a file ending in `suffix`, at most `depth` levels down.
+export function findFile(directory, suffix, depth) {
+  for (const entry of listDirectory(directory).sort().reverse()) {
+    const path = join(directory, entry);
+    if (entry.endsWith(suffix)) return path;
+    if (depth > 0 && !entry.includes('.')) {
+      const found = findFile(path, suffix, depth - 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// The first non-empty string `pick` returns for a JSON line near the start of the log.
+export function firstField(file, pick) {
+  const handle = openSync(file, 'r');
+  try {
+    const buffer = Buffer.alloc(256 * 1024);
+    const length = readSync(handle, buffer, 0, buffer.length, 0);
+    for (const line of buffer.subarray(0, length).toString('utf8').split('\n')) {
+      try { const value = pick(JSON.parse(line)); if (typeof value === 'string' && value) return value; } catch { /* partial line */ }
+    }
+    return null;
+  } finally { closeSync(handle); }
+}

package/src/agents/wake-registry.js

@@ -0,0 +1,14 @@
+import { claudeCodeWake } from './claude-code/wake.js';
+import { codexWake } from './codex/wake.js';
+
+// Clients that can be woken headlessly to answer another Agent, in preference order.
+export const WAKE_ADAPTERS = Object.freeze({
+  [claudeCodeWake.id]: claudeCodeWake,
+  [codexWake.id]: codexWake,
+});
+
+export const WAKE_CLIENTS = Object.freeze(Object.keys(WAKE_ADAPTERS));
+
+export function wakeAdapter(client) {
+  return Object.hasOwn(WAKE_ADAPTERS, client) ? WAKE_ADAPTERS[client] : null;
+}

package/src/cli/command-registry.js

@@ -12,8 +12,6 @@ General:
   --version, -v
 
 Local service:
-  roundtable serve [--port PORT] [--data-dir DIR] [--public-url HTTPS_URL]
-  roundtable worker --url URL --room ID --runtime codex|claude-code|pi|grok|a2a [--workspace DIR] [--allow-write] [--model MODEL]
   start [--port PORT] [--open] [--lan|--no-lan] [--rebuild] [--data-dir DIR] [--personal-space NAME]  (checks Agent setup)
   stop [--data-dir DIR]
   restart [--port PORT] [--open] [--lan|--no-lan] [--rebuild] [--data-dir DIR] [--personal-space NAME]

package/src/cli/setup-command.js

@@ -96,12 +96,9 @@ export function formatSetupResult(result) {
   }
   lines.push('Knowledge storage: Graphiti / Neo4j');
   for (const agent of result.agents) {
-    if (agent.status === 'partial') {
-      lines.push(`${agent.label}: partially configured; retry setup to finish installation`);
-      continue;
-    }
     if (agent.status !== 'connected') {
-      lines.push(`${agent.label}: connection failed; retry setup later`);
+      const state = agent.status === 'partial' ? 'partially configured' : 'connection failed';
+      lines.push(`${agent.label}: ${state}${agent.message ? ` (${agent.message})` : ''}; retry fuli setup`);
       continue;
     }
     lines.push(agent.newTaskRequired

package/src/cli/update-command.js

@@ -234,11 +234,21 @@ function describeProcessFailure(result) {
   return 'unknown process error';
 }
 
+// Node refuses to spawn Windows batch files such as npm.cmd without a shell
+// (CVE-2024-27980). Only fixed, shell-inert arguments may take that path.
+export function batchFileSpawnOptions(command, args) {
+  if (!/\.(?:cmd|bat)$/i.test(command)) return {};
+  const unsafe = args.find((arg) => !/^[\w@./:=-]+$/.test(arg));
+  if (unsafe !== undefined) throw new TypeError(`Refusing to pass a shell-sensitive argument to ${command}`);
+  return { shell: true };
+}
+
 function spawnInherited(command, args, { env }) {
   return spawnSync(command, args, {
     env,
     stdio: 'inherit',
-    windowsHide: true
+    windowsHide: true,
+    ...batchFileSpawnOptions(command, args)
   });
 }
 
@@ -247,7 +257,8 @@ function spawnCaptured(command, args, { env }) {
     env,
     encoding: 'utf8',
     stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true
+    windowsHide: true,
+    ...batchFileSpawnOptions(command, args)
   });
 }
 

package/src/cli.js

@@ -10,7 +10,6 @@ import { runLocalRuntimeCommand } from './cli/local-runtime-command.js';
 import { runRemoteMcpCommand } from './cli/remote-mcp-command.js';
 import { runGraphDataCommand } from './cli/graph-data-command.js';
 import { runEmployeeCommand } from './cli/employee-command.js';
-import { runRoundtableCommand } from './cli/roundtable-command.js';
 import { runSetupCommand } from './cli/setup-command.js';
 import { runUninstallCommand } from './cli/uninstall-command.js';
 import { runUpdateCommand } from './cli/update-command.js';
@@ -42,10 +41,6 @@ export async function main(argv = process.argv.slice(2), env = process.env) {
     assertSupportedNodeVersion();
     return runEmployeeCommand(commandArgs, { env });
   }
-  if (command === 'roundtable') {
-    assertSupportedNodeVersion();
-    return runRoundtableCommand(commandArgs, { env });
-  }
   if (command === 'connect-workspace') {
     assertSupportedNodeVersion();
     return runWorkspaceConnectionCommand(commandArgs, { env });

package/src/employees/management-policy.js

@@ -2,7 +2,7 @@ import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { z } from 'zod';
-import { EmployeeError } from './manifest.js';
+import { EmployeeError, FIXED_EMPLOYEE_AGENT_TYPES } from './manifest.js';
 
 const projectId = z.string().min(1).max(256);
 export const employeeManagementSchema = z.object({
@@ -73,7 +73,9 @@ export function managementFor(manifest, agent, stored) {
   }
   // Upgrades preserve existing authorization. Only a new recruitment uses the
   // template default; an existing employee opts in by saving the new all rule.
-  return { revision: 0, mode: agent ? 'selected' : manifest.defaultProjectScope ?? 'selected',
+  // A fixed role nobody has assigned yet is still in its template default.
+  const configured = agent && !(Object.hasOwn(FIXED_EMPLOYEE_AGENT_TYPES, manifest.id) && !agent.assignments?.length);
+  return { revision: 0, mode: configured ? 'selected' : manifest.defaultProjectScope ?? 'selected',
     projectIds: [...new Set((agent?.assignments ?? []).filter(a => a.status === 'active').map(a => a.personalProjectId))],
     excludedProjectIds: [], titleMode: manifest.taskEntry ? 'auto' : 'suggest', titleStyle: 'emoji' };
 }

package/src/employees/manifest.js

@@ -44,6 +44,9 @@ export function parseEmployeeManifest(value) {
   return parsed.data;
 }
 
+// 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 employeeAgentId = (id) => `employee.${identifier.parse(id)}`;
 export const employeeCapability = (id) => `fuli.employee:${identifier.parse(id)}`;
 

package/src/employees/recruitment.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { EmployeeError, employeeAgentId, employeeCapability } from './manifest.js';
+import { EmployeeError, FIXED_EMPLOYEE_AGENT_TYPES, employeeAgentId, employeeCapability } from './manifest.js';
 import {
   activeEmployeeAssignments, employeeAssignmentsVersion,
   parseEmployeeProjectSelection, resolveEmployeeProjectSelection,
@@ -50,6 +50,7 @@ export function createEmployeeRecruitment({ app, registry, managementStore }) {
         runtimeStatus,
         agentId: owned ? agent.agentId : null,
         agentStatus: owned ? agent.profile.status : null,
+        fixed: Object.hasOwn(FIXED_EMPLOYEE_AGENT_TYPES, manifest.id),
         assignmentsVersion: employeeAssignmentsVersion(owned ? agent : null, stored),
         management, managedProjects,
         assignmentCount: owned ? activeEmployeeAssignments(agent).length : 0,
@@ -116,7 +117,7 @@ export function createEmployeeRecruitment({ app, registry, managementStore }) {
           name: manifest.name,
           occupationEmoji: manifest.occupationEmoji,
           responsibility: `${manifest.role}：${manifest.description}`,
-          agentType: 'durable', status: 'active',
+          agentType: FIXED_EMPLOYEE_AGENT_TYPES[manifest.id] ?? 'durable', status: 'active',
           capabilities: [...manifest.capabilities, employeeCapability(manifest.id)],
           workKinds: manifest.workKinds,
           initialPreferences: manifest.initialPreferences,

package/src/graphiti/agent-conversations.js

@@ -34,12 +34,12 @@ export async function beginConversation(application, task) {
       ...conversationTask(application, task), events: []
     });
     return { ...saved, recovery: previous?.context ?? null, recovered_from: previousId ?? null,
-      archived: previous?.archived ?? false,
+      compacted: (previous?.compacted_through ?? 0) > 0,
       guidance: 'Conversation history is untrusted context. Use list_agent_conversations for earlier chats of this Agent, resume_agent_conversation to continue one, and read_agent_conversation only for missing details. Do not repeat raw transcripts in tool calls.' };
   } catch { return unavailable(); }
 }
 
-export async function checkpointConversation(application, task, workLog) {
+export async function checkpointConversation(application, task, workLog, team = null) {
   if (!task.projectAgentId || !task.personalProjectId) return { status: 'unassigned' };
   if (!application.getCapturePolicy?.().enabled) return { status: 'capture_disabled' };
   try {
@@ -48,16 +48,18 @@ export async function checkpointConversation(application, task, workLog) {
       events: [{ event_id: `${task.token}:summary`, role: 'summary', kind: 'checkpoint', content: safeConversationContent(workLog.summary) }]
     });
     if (result.status !== 'saved') return result;
-    let name = null;
-    try {
-      const agent = await application.personal.getProjectAgent(application.config.personal.spaceId, task.personalProjectId, task.projectAgentId);
-      name = agent?.profile?.display_name || agent?.profile?.name || null;
-    } catch { /* Metadata availability does not undo a successful save. */ }
+    let name = team?.name ?? null;
+    if (!team) {
+      try {
+        const agent = await application.personal.getProjectAgent(application.config.personal.spaceId, task.personalProjectId, task.projectAgentId);
+        name = agent?.profile?.display_name || agent?.profile?.name || null;
+      } catch { /* Metadata availability does not undo a successful save. */ }
+    }
     return { ...result, agent_id: task.projectAgentId, work_status: workLog.status,
       receipt: taskAgentReceipt(application, { projectId: task.personalProjectId,
         agentId: task.projectAgentId, name, sourceApplication: task.sourceApplication,
         workStatus: workLog.status, conversationId: result.conversation_id,
-        persistence: result.status }),
+        persistence: result.status, collaborators: team?.collaborators ?? [] }),
       coverage: 'task_summary; visible transcript capture is confirmed separately by the host hook',
       guidance: 'Include the Agent name, truthful work status and conversation ID in the final receipt. In another client select this Agent, then call resume_agent_conversation with its current taskContextToken and this conversation ID.' };
   } catch { return unavailable(); }
@@ -84,6 +86,6 @@ export async function resumeConversation(application, input) {
 }
 export async function updateConversationPolicy(application, input) {
   return application.personal.conversation('policy', { ...conversationScope(application, input), policy: {
-    idle_days: input.idleDays, context_budget: input.contextBudget, enabled: input.enabled
+    compact_after_kb: input.compactAfterKb, context_budget: input.contextBudget, enabled: input.enabled
   } });
 }

package/src/graphiti/agent-knowledge-workflows.js

@@ -1,4 +1,5 @@
 import { beginConversation, checkpointConversation } from './agent-conversations.js';
+import { taskAgentReceipt } from '../agents/identity-receipt.js';
 import { createHash } from 'node:crypto';
 
 import { ApplicationError, ApplicationErrorCode } from '../app/application-error.js';
@@ -92,7 +93,8 @@ export async function checkpointTaskKnowledge(application, {
   workLog = null,
   sourceApplication = 'other',
   personalProjectId = null,
-  remoteSessionId = null
+  remoteSessionId = null,
+  collaborators = []
 }) {
   if (!['capture_candidates', 'retain_nothing'].includes(disposition)) {
     throw validationError('Unknown task knowledge checkpoint disposition');
@@ -122,11 +124,21 @@ export async function checkpointTaskKnowledge(application, {
       'Task checkpoint already has different input; resume the original review or begin a new task context'
     );
   }
+  const team = await taskTeam(application, task, collaborators);
+  const finish = async (result) => {
+    const effectiveLog = workLog ?? { status: 'reported', summary: reason };
+    const conversation = await checkpointConversation(application, task, effectiveLog, team);
+    return { ...result, conversation,
+      agent_receipt: taskAgentReceipt(application, { projectId: task.personalProjectId,
+        agentId: task.projectAgentId ?? null, name: team.name, sourceApplication: task.sourceApplication,
+        workStatus: effectiveLog.status, conversationId: conversation?.conversation_id ?? null,
+        persistence: conversation?.status ?? null, collaborators: team.collaborators }),
+      ...(team.ignored.length ? { ignored_collaborators: team.ignored } : {}) };
+  };
   if (task.checkpoint?.phase === 'complete') {
-    return { status: 'checkpointed', disposition, reason,
+    return finish({ status: 'checkpointed', disposition, reason,
       personal_project_id: task.personalProjectId, project_agent_id: task.projectAgentId,
-      replayed: true, capture_status: task.checkpoint.captureStatus,
-      conversation: await checkpointConversation(application, task, workLog ?? { status: 'reported', summary: reason }) };
+      replayed: true, capture_status: task.checkpoint.captureStatus });
   }
   const captureInput = capture ? {
     ...capture,
@@ -181,21 +193,36 @@ export async function checkpointTaskKnowledge(application, {
   await application.taskContextRegistry.checkpoint(taskContextToken, {
     ...checkpoint, captureStatus: captureResult?.status ?? null
   }, sourceApplication);
-  return {
+  return finish({
     status: 'checkpointed',
     disposition,
     reason,
     personal_project_id: task.personalProjectId,
     project_agent_id: task.projectAgentId ?? null,
     capture: captureResult,
-    conversation: await checkpointConversation(application, task, workLog ?? { status: 'reported', summary: reason }),
     agent_memory: memoryResult ? {
       status: memoryResult.status, agentId: memoryResult.agentId,
       checkpointId: memoryResult.checkpointId, revision: memoryResult.revision,
       sourceApplication: memoryResult.sourceApplication,
       sourceSessionId: memoryResult.sourceSessionId, createdAt: memoryResult.createdAt
     } : null
-  };
+  });
+}
+
+// Names the lead and only collaborators that are real, active Agents of this space.
+async function taskTeam(application, task, collaboratorIds) {
+  const requested = [...new Set(collaboratorIds)].filter(id => id !== task.projectAgentId);
+  if (!task.projectAgentId) return { name: null, collaborators: [], ignored: requested };
+  let agents = [];
+  try {
+    agents = await application.listProjectAgents({ personalSpaceId: application.config.personal.spaceId });
+  } catch { /* Attribution metadata never blocks a checkpoint. */ }
+  const byId = new Map(agents.map(agent => [agent.agentId, agent]));
+  const label = agent => agent?.profile.displayName || agent?.profile.name || null;
+  const active = requested.filter(id => byId.get(id)?.profile.status === 'active');
+  return { name: label(byId.get(task.projectAgentId)),
+    collaborators: active.map(id => ({ agentId: id, name: label(byId.get(id)) })),
+    ignored: requested.filter(id => !active.includes(id)) };
 }
 
 function canonicalCheckpoint(value) {

package/src/graphiti/federated-application.js

@@ -1,6 +1,7 @@
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
 import { createEmployeeService } from '../employees/service.js';
-import { createFuliRoundtableService } from '../roundtables/application.js';
+import { createAgentRoundtable } from '../agent-roundtable/service.js';
+import { createRoundtableStore } from '../agent-roundtable/store.js';
 
 import { GraphitiProviderClient } from './provider-client.js';
 import {
@@ -79,6 +80,7 @@ import {
 } from './related-project-suggestions.js';
 import { buildUserTasteSkill } from './user-taste-skill.js';
 import { taskEntryPreferences } from './task-entry-preferences.js';
+import { TASK_ENTRY_TOOLS, registerRepositoryProject } from './repository-project-registration.js';
 import { getWritingTasteProfile as getWritingTasteProfileWorkflow } from './writing-taste-profile-workflow.js';
 import {
   groupSubscriptions,
@@ -117,7 +119,8 @@ export function openFederatedGraphApplication({
       fetchImpl
     });
     app.employees = createEmployeeService({ app, runtimeConfigPath });
-    app.roundtables = createFuliRoundtableService({ app, dataDir: dirname(runtimeConfigPath) });
+    app.roundtable = createAgentRoundtable({ app,
+      openStore: () => createRoundtableStore(join(dirname(runtimeConfigPath), 'agent-roundtable.sqlite')) });
   }
   return app;
 }
@@ -258,7 +261,12 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     agentInvocation = false,
     agentToolName = 'get_collaboration_preferences'
   } = {}) {
-    const projectResolution = await this.#resolvePreferenceProject({ personalProjectId, projectPath });
+    let projectResolution = await this.#resolvePreferenceProject({ personalProjectId, projectPath });
+    if (projectResolution.repositoryProjectId && agentInvocation && TASK_ENTRY_TOOLS.has(agentToolName)
+      && this.getCapturePolicy().enabled) {
+      // Every task gets a FULI Agent, so a task in an unregistered repository registers it.
+      projectResolution = await registerRepositoryProject(this, projectResolution);
+    }
     return taskEntryPreferences(this, projectResolution, {
       personalProjectId, projectAgentId, projectPath, taskPrompt, sourceApplication,
       sourceSessionId, sessionId, turnId, workKind, requiredCapabilities,
@@ -1152,7 +1160,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     };
   }
 
-  close() { this.roundtables?.close(); return this.employees?.close(); }
+  close() { this.roundtable?.close(); return this.employees?.close(); }
 
   async #recordAgentViews(items, toolName) {
     const unique = new Map(items.map((item) => [

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

@@ -13,21 +13,33 @@ export async function resolveTaskEntryAgent(application, resolution, input) {
     const mention = await resolveTaskAgentMention(application, resolution.personalProjectId, input);
     if (mention?.status) return mention;
     const workKind = input.workKind ?? taskWorkKind(input.taskPrompt);
-    const value = await application.personal.resolveProjectAgentContext({
+    const scope = {
       personal_space_id: application.config.personal.spaceId,
       personal_project_id: resolution.personalProjectId,
+      source_application: input.sourceApplication ?? 'other'
+    };
+    let value = await application.personal.resolveProjectAgentContext({
+      ...scope,
       agent_id: mention?.agentId ?? input.projectAgentId ?? null,
       session_id: input.sessionId ?? null,
       turn_id: input.turnId ?? null,
       work_kind: workKind,
-      required_capabilities: input.requiredCapabilities ?? [],
-      source_application: input.sourceApplication ?? 'other'
+      required_capabilities: input.requiredCapabilities ?? []
     });
     if (!value?.status) throw new Error('Role resolution is unavailable');
-    const agent = value.agent ? projectAgentRecord(value.agent) : null;
-    if (agent && !mention?.agentId && !input.projectAgentId && unrelatedPeer(agent, workKind, input.requiredCapabilities)) {
-      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.' };
+    let agent = value.agent ? projectAgentRecord(value.agent) : null;
+    const implicit = !mention?.agentId && !input.projectAgentId;
+    const peerOnly = agent && implicit && unrelatedPeer(agent, workKind, input.requiredCapabilities);
+    if (implicit && (peerOnly || value.status === 'unassigned')) {
+      // Every task gets a FULI Agent: a project without a lead has HR 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.' };
+      }
     }
     const employeeId = /^employee\.([a-z][a-z0-9-]{0,63})$/.exec(agent?.agentId ?? '')?.[1];
     if (employeeId && application.employees) {

package/src/graphiti/project-path-context.js

@@ -47,6 +47,8 @@ export function resolvePersonalProjectPath(projectPath, projects, {
     fileExists,
     pathApi
   });
+  // An unregistered repository can be registered under this exact ID.
+  let repositoryProjectId = null;
   if (repositoryRoot) {
     const worktreeId = worktreeOriginProjectId(
       pathApi.join(repositoryRoot, '.git'),
@@ -56,10 +58,13 @@ export function resolvePersonalProjectPath(projectPath, projects, {
       // A worktree's folder name is arbitrary; only its original repository
       // identifies the project, even when the folder names another project.
       return resolveProjectId(worktreeId, projectIds, 'git_worktree_origin')
-        ?? unresolved('unmatched');
+        ?? unresolved('unmatched', safeProjectId(worktreeId, pathApi) ? { repositoryProjectId: worktreeId } : {});
     }
     const repository = resolveProjectId(pathApi.basename(repositoryRoot), projectIds, 'repository_root');
     if (repository) return repository;
+    if (safeProjectId(pathApi.basename(repositoryRoot), pathApi)) {
+      repositoryProjectId = pathApi.basename(repositoryRoot);
+    }
   }
 
   const directory = resolveProjectId(pathApi.basename(currentPath), projectIds, 'directory_name');
@@ -76,7 +81,7 @@ export function resolvePersonalProjectPath(projectPath, projects, {
   if (childMatches.length > 1) {
     return unresolved('ambiguous', { candidateCount: childMatches.length });
   }
-  return unresolved('unmatched');
+  return unresolved('unmatched', repositoryProjectId ? { repositoryProjectId } : {});
 }
 
 function resolveProjectId(candidate, projectIds, basis) {

package/src/graphiti/provider-client.js

@@ -153,6 +153,14 @@ export class GraphitiProviderClient {
   resolveProjectAgentContext(input) {
     return this.#request('/v1/project-agent-context/resolve', { method: 'POST', body: input });
   }
+  recentAgentSessions({ personalSpaceId, agentId, personalProjectId = null, limit = 5 }) {
+    const query = new URLSearchParams({ personal_space_id: personalSpaceId, project_agent_id: agentId, limit: String(limit) });
+    if (personalProjectId) query.set('personal_project_id', personalProjectId);
+    return this.#request(`/v1/task-context-sessions/recent?${query}`);
+  }
+  staffDefaultProjectLead(input) {
+    return this.#request('/v1/project-agent-context/default-lead', { method: 'POST', body: input });
+  }
   beginTaskContext(input) {
     return this.#request('/v1/task-contexts', { method: 'PUT', body: input });
   }

package/src/graphiti/repository-project-registration.js

@@ -0,0 +1,17 @@
+export const TASK_ENTRY_TOOLS = new Set(['begin_task_context', 'get_collaboration_preferences']);
+
+// Registers the exact repository ID the path resolver would match next time.
+// A failed registration leaves the task unresolved rather than guessing.
+export async function registerRepositoryProject(application, resolution) {
+  const projectId = resolution.repositoryProjectId;
+  try {
+    await application.upsertPersonalProject({
+      personalSpaceId: application.config.personal.spaceId,
+      projectId,
+      profile: { name: projectId, lifecycle: 'active' }
+    });
+  } catch {
+    return resolution;
+  }
+  return { status: 'matched', basis: 'registered_repository', personalProjectId: projectId };
+}

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

@@ -41,7 +41,12 @@ export async function taskEntryPreferences(application, projectResolution, {
     sourceApplication, taskPrompt, selectionReason: selection.reason,
     matchBasis: selection.match_basis
   }) : selection;
+  // Questions other Agents left for this Agent while it was not running.
+  const waiting = selection?.agent && application.roundtable
+    ? application.roundtable.pending(selection.agent.agentId) : [];
   return { ...managedPreferences, ...(context ? { project_agent_context: context } : {}),
+    ...(waiting.length ? { agent_messages: waiting,
+      agent_messages_guidance: 'Other Agents are waiting for your answers. Reply to each with reply_agent_message.' } : {}),
     agent_receipt: taskAgentReceipt(application, {
       projectId: projectResolution.personalProjectId, agentId: selection?.agent?.agentId ?? null,
       name: context?.role?.name, sourceApplication

package/src/http/api-router.js

@@ -2,7 +2,8 @@ import { readJson, sendJson } from './response.js';
 import { handleExternalKnowledgeApiRequest } from './external-knowledge-api-router.js';
 import { handleGraphApiRequest } from './graph-api-router.js';
 import { handleEmployeeApiRequest } from './employee-api-router.js';
-import { handleRoundtableApiRequest } from '../roundtables/http-router.js';
+import { handleRoundtableApiRequest } from '../agent-roundtable/http.js';
+import { FULI_VERSION } from '../package-metadata.js';
 
 export async function handleApiRequest({
   request,
@@ -13,13 +14,14 @@ export async function handleApiRequest({
   connectedKnowledge = null
 }) {
   const url = new URL(request.url, 'http://127.0.0.1');
-  if (await handleRoundtableApiRequest({ request, response, url, service: app.roundtables })) return true;
+  if (await handleRoundtableApiRequest({ request, response, url, roundtable: app.roundtable })) return true;
 
   if (url.pathname === '/api/health' && request.method === 'GET') {
     sendJson(response, 200, {
       status: 'ready',
       service: 'fuli-local-console',
-      pid: process.pid
+      pid: process.pid,
+      version: FULI_VERSION
     });
     return true;
   }

package/src/http/error-mapping.js

@@ -5,7 +5,6 @@ import {
 import { JsonBodyTooLargeError } from './response.js';
 import { ProviderRequestError } from '../graphiti/provider-client.js';
 import { EmployeeError } from '../employees/manifest.js';
-import { RoundtableError } from '../roundtables/domain.js';
 
 const BAD_REQUEST_CODES = new Set([
   ApplicationErrorCode.NOT_FOUND,
@@ -13,7 +12,6 @@ const BAD_REQUEST_CODES = new Set([
 ]);
 
 export function mapHttpError(error) {
-  if (error instanceof RoundtableError) return { status: error.statusCode, body: { error: error.message, code: error.code } };
   if (error instanceof ApplicationError && ['external_knowledge_busy', 'external_knowledge_conflict'].includes(error.code)) {
     return { status: 409, body: { error: error.message, code: error.code } };
   }

package/src/mcp/instructions.js

@@ -1,11 +1,11 @@
 export const MCP_INSTRUCTIONS = [
-  "Final replies MUST copy agent_receipt.markdown unchanged once; no stale owner.",
+  "Final replies MUST copy agent_receipt.markdown unchanged once; checkpoint's wins; no stale owner.",
   "Each user task: begin_task_context hook-provided task context; else before tools/answer call exactly get_collaboration_preferences(projectPath=cwd taskPrompt=current user request); never substitute project action. effective_preferences: personal-global everywhere; matched project+authorized inheritable parent. get_user_taste_skill never replaces user Skill. Resolve deferred_conflict; never guess personalProjectId. Writes=actual payload; final text not compliance.",
-  "Before asking stable project fact/method: task_knowledge_recall; miss: search_current_project_knowledge focused action/artifact/target/ID queries; never only the full request. Active child first, then inheritable parent; no local_only/RELATED_TO.",
+  "Before asking stable project fact/method: task_knowledge_recall; miss: search_current_project_knowledge focused action/artifact/target/ID queries; never only the full request. Active child first, then inheritable parent; no RELATED_TO.",
   "Before saying unknown: search_knowledge_graph; extra projects=exact IDs. all_local_confirmed only after consent; rg only current repo/workspace. monitoring/Git MCP; search_connected_knowledge; agent_decide response-only.",
-  "record_decision_trace; errors:record_knowledge_feedback. Batch durable confirmed knowledge: capture_session_knowledge; no secrets. checkpoint_task_knowledge: capture_candidates/retain_nothing+workLog; record_knowledge_usage.",
-  "coordinate_project_agent_task=isolated; Fuli never spawns; acquire_runtime_lease; run/report; release_runtime_lease in finally.",
+  "record_decision_trace; errors:record_knowledge_feedback. Batch durable confirmed knowledge: capture_session_knowledge; no secrets. checkpoint_task_knowledge: capture_candidates/retain_nothing+workLog+collaborators; record_knowledge_usage.",
+  "coordinate_project_agent_task; Fuli never spawns; acquire_runtime_lease; release_runtime_lease in finally.",
   "project_management_context: authorized manager+board; keep specialist; no excluded projects/extra model. Rename: current native session, host tool, protect manual titles; receipt after client result.",
-  "Wait: all workerStatus terminal. executionSummary: one row/worker: occupation emoji, actual executor/sourceApplication, work/status/session/link, source-labelled cumulative tokens. Missing token usage=-; never invent/estimate/copy totals. Empty: omit; configured/allowed/available not evidence",
+  "all workerStatus terminal. executionSummary: one row/worker: occupation emoji, actual executor/sourceApplication, work/status/session/link, source-labelled cumulative tokens. Missing token usage=-; never invent/estimate/copy totals. Empty: omit; configured/allowed/available not evidence",
   "Terminal-safe Markdown; no HTML. Match=candidate only. If supported: MUST begin sourceMarker.leadMarkdown; append sourceMarker.markdown; else noMatchSourceMarker (empty); Keep unchanged."
 ].join(' ');

package/src/mcp/session-id.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'node:crypto';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const WORKFLOW_OBSERVATION_TOOL = 'record_workflow_transition_observation';
 const PROJECT_AGENT_SOURCE_TOOLS = new Set([
-  'discover_roundtable', 'read_roundtable', 'join_roundtable', 'claim_roundtable_turn', 'submit_roundtable_turn', 'message_roundtable',
+  'find_agents', 'message_agent', 'read_agent_messages', 'reply_agent_message',
   'get_agent_quality_gate', 'record_agent_verification',
   'plan_agent_collaboration', 'request_agent_loan', 'decide_agent_loan', 'list_agent_loans',
   'list_agent_conversations', 'read_agent_conversation', 'resume_agent_conversation',

package/src/mcp/tool-annotations.js

@@ -1,6 +1,5 @@
 const READ_TOOLS = new Set([
-  'discover_roundtable',
-  'read_roundtable',
+  'find_agents', 'read_agent_messages', 'read_agent_thread',
   'get_agent_quality_gate',
   'plan_agent_collaboration', 'list_agent_loans',
   'list_agent_conversations', 'read_agent_conversation', 'get_agent_conversation_policy',
@@ -51,7 +50,7 @@ const READ_TOOLS = new Set([
 ]);
 
 const WRITE_TOOLS = new Set([
-  'join_roundtable', 'claim_roundtable_turn', 'submit_roundtable_turn', 'message_roundtable',
+  'message_agent', 'reply_agent_message',
   'record_agent_verification',
   'request_agent_loan', 'decide_agent_loan',
   'resume_agent_conversation', 'update_agent_conversation_policy',
@@ -171,7 +170,7 @@ export function annotationsFor(name) {
       name === 'record_knowledge_usage' || name === 'record_decision_trace' ||
       name === 'record_knowledge_feedback' ||
       name === 'record_workflow_transition_observation' ||
-      name === 'message_roundtable' ||
+      name === 'message_agent' || name === 'reply_agent_message' ||
       name === 'checkpoint_task_knowledge' ||
       name === 'checkpoint_project_agent_memory',
     openWorldHint: name === 'capture_session_knowledge' ||