fuli-context 0.10.0 → 0.11.1

package/src/agents/identity-receipt.js

@@ -12,20 +12,48 @@ 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 = [], assignmentStatus = null, assignmentReason = null }) {
+  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：未选定';
+    ? `FULI Agent：负责人 ${agentLink(application, agentId, name)}`
+      + (helpers.length ? ` · 协作 ${helpers.map(item => agentLink(application, item.agentId, item.name)).join('、')}` : '')
+    : unassignedReceipt(assignmentStatus, assignmentReason);
   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.' };
+}
+
+function unassignedReceipt(status, reason) {
+  if (!status) return 'FULI Agent：分配未完成（任务没有可用负责人）';
+  if (status === 'project_unresolved') {
+    return reason === 'ambiguous' ? 'FULI Agent：分配待确认（项目归属待确认）'
+      : reason === 'session_identity_required' ? 'FULI Agent：分配失败（缺少会话标识）'
+        : 'FULI Agent：分配失败（项目归属未能恢复）';
+  }
+  const labels = {
+    unavailable: '分配失败（服务或身份恢复不可用）',
+    agent_unavailable: '分配失败（指定 FLA 不可用）',
+    agent_not_found: '分配失败（指定 FLA 不存在）',
+    ambiguous_agent: '分配待确认（存在同名 FLA）',
+    agent_selection_conflict: '分配待确认（FLA 选择冲突）',
+    manual_selection: '分配待确认（需要选择负责人）'
+  };
+  return `FULI Agent：${labels[status] ?? '分配未完成（HR 尚未返回负责人）'}`;
 }
 
 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,8 @@ 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 { resolveTaskEntryProject } from './task-entry-project-scope.js';
 import { getWritingTasteProfile as getWritingTasteProfileWorkflow } from './writing-taste-profile-workflow.js';
 import {
   groupSubscriptions,
@@ -117,7 +120,8 @@ export function openFederatedGraphApplication({
       fetchImpl
     });
     app.employees = createEmployeeService({ app, runtimeConfigPath });
-    app.roundtables = createFuliRoundtableService({ app, dataDir: dirname(runtimeConfigPath) });
+    app.roundtable = createAgentRoundtable({ app, env,
+      openStore: () => createRoundtableStore(join(dirname(runtimeConfigPath), 'agent-roundtable.sqlite')) });
   }
   return app;
 }
@@ -258,7 +262,15 @@ 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);
+    }
+    projectResolution = await resolveTaskEntryProject(this, projectResolution, {
+      sessionId, sourceSessionId, sourceApplication, agentInvocation, agentToolName
+    });
     return taskEntryPreferences(this, projectResolution, {
       personalProjectId, projectAgentId, projectPath, taskPrompt, sourceApplication,
       sourceSessionId, sessionId, turnId, workKind, requiredCapabilities,
@@ -1152,7 +1164,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-mapping.js

@@ -71,6 +71,8 @@ export function projectAgentRecord(value) {
     Object.hasOwn(profile, 'display_name'));
   copyOptional(result, 'legacyAgentIds', value.legacy_agent_ids,
     Object.hasOwn(value, 'legacy_agent_ids'));
+  copyOptional(result, 'employeeNumber', value.employee_number,
+    Object.hasOwn(value, 'employee_number'));
   copyOptional(result.profile, 'workKinds', profile.work_kinds,
     Object.hasOwn(profile, 'work_kinds'));
   copyOptional(

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

@@ -8,26 +8,56 @@ const ENTRY_TOOLS = new Set(['begin_task_context', 'get_collaboration_preference
 
 export async function resolveTaskEntryAgent(application, resolution, input) {
   if (!input.agentInvocation || !ENTRY_TOOLS.has(input.agentToolName)) return null;
-  if (!resolution.personalProjectId) return { status: 'project_unresolved', worker_started: false };
+  if (!resolution.personalProjectId) return {
+    status: resolution.status === 'unavailable' ? 'unavailable' : 'project_unresolved',
+    reason: resolution.reason ?? resolution.status,
+    worker_started: false
+  };
   try {
     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'
+    };
+    const contextRequest = {
+      ...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 ?? []
+    };
+    const delegation = application.roundtable?.taskEntryDelegation?.({
+      sessionId: input.receivingSessionId ?? input.sessionId
     });
+    if (delegation) {
+      contextRequest.delegation_token = delegation.token;
+      contextRequest.delegation_session_id = delegation.sessionId;
+    }
+    let value = await application.personal.resolveProjectAgentContext(contextRequest);
+    if (value?.reason === 'project_lead_required') {
+      await application.personal.staffDefaultProjectLead(scope);
+      // Re-resolve after staffing so a requested specialist is not lost and a
+      // concurrent successful hire is handled without selecting another owner.
+      value = await application.personal.resolveProjectAgentContext(contextRequest);
+    }
     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 && value.reason !== 'project_lead_required' && (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-agent-team-context.js

@@ -15,7 +15,10 @@ export async function loadProjectTeamContext(application, personalSpaceId, proje
         && 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)),
     peer_roles: ['hr', 'project_manager'], worker_started: false,
-    guidance: 'The team lead is the user-facing owner. Split bounded work among team members 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. 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.' };
 }

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,23 @@ export class GraphitiProviderClient {
   resolveProjectAgentContext(input) {
     return this.#request('/v1/project-agent-context/resolve', { method: 'POST', body: input });
   }
+  issueAgentDelegation(input) {
+    return this.#request('/v1/project-agent-context/delegations', { method: 'POST', body: input });
+  }
+  verifyAgentDelegation(input) {
+    return this.#request('/v1/project-agent-context/delegations/verify', { method: 'POST', body: input });
+  }
+  revokeAgentDelegation(input) {
+    return this.#request('/v1/project-agent-context/delegations/revoke', { 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

@@ -7,12 +7,11 @@ export async function taskEntryPreferences(application, projectResolution, {
   sourceSessionId, sessionId, turnId, workKind, requiredCapabilities,
   limit, agentInvocation, agentToolName
 }, recordAgentViews) {
-  const selection = projectPath === null && !personalProjectId && !projectAgentId
-    ? null
-    : await resolveTaskEntryAgent(
+  const selection = await resolveTaskEntryAgent(
       application, projectResolution, { projectAgentId, taskPrompt, sourceApplication,
         sessionId: agentToolName === 'get_collaboration_preferences'
           ? sessionId ?? sourceSessionId : turnId ? sessionId : null,
+        receivingSessionId: sessionId ?? sourceSessionId,
         turnId: agentToolName === 'begin_task_context' ? turnId : null,
         workKind, requiredCapabilities, agentInvocation, agentToolName }
     );
@@ -41,9 +40,23 @@ export async function taskEntryPreferences(application, projectResolution, {
     sourceApplication, taskPrompt, selectionReason: selection.reason,
     matchBasis: selection.match_basis
   }) : 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.';
+  }
+  if (context && selection?.reporting_lead_agent_id) {
+    context.reporting_lead_agent_id = selection.reporting_lead_agent_id;
+    context.reporting_guidance = 'This is a delegated member turn. Keep this member identity and private memory isolated. Return results and blockers to the project lead; the lead integrates the final user report.';
+  }
+  // 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
+      name: context?.role?.name, sourceApplication,
+      assignmentStatus: selection?.status, assignmentReason: selection?.reason
     }) };
 }