fuli-context 0.8.2 → 0.9.0-beta.1

package/src/cli/roundtable-command.js

@@ -0,0 +1,59 @@
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { openFederatedGraphApplication } from '../graphiti/federated-application.js';
+import { resolveSetupPaths } from '../setup/paths.js';
+import { createRoundtableServer } from '../roundtables/server.js';
+import { runRoundtableWorker } from '../roundtables/worker.js';
+
+export async function runRoundtableCommand(args, { env = process.env } = {}) {
+  const [action, ...options] = args;
+  if (!action || ['--help', '-h'].includes(action)) {
+    console.log('fl roundtable serve [--data-dir DIR] [--port 3738] [--host 127.0.0.1] [--public-url HTTPS_URL]\nfl roundtable worker --url URL --room ID --runtime codex|claude-code|pi|grok|a2a [--workspace DIR] [--allow-write] [--model MODEL] [--a2a-url HTTPS_URL]\nSeat secret: FULI_ROUNDTABLE_TOKEN environment variable. Pi uses local Ollama; select an installed model with --model. Owner console remains local; expose only /roundtable-peer/ through your HTTPS proxy.'); return;
+  }
+  const allowed = new Set(['--data-dir', '--port', '--host', '--public-url', '--url', '--room', '--runtime', '--workspace', '--model', '--a2a-url', '--allow-write', '--once', '--allow-http']);
+  const flags = new Set(['--allow-write', '--once', '--allow-http']);
+  const values = {};
+  for (let index = 0; index < options.length; index++) {
+    const name = options[index];
+    if (!allowed.has(name) || Object.hasOwn(values, name)) throw new TypeError(`Unknown or duplicate Roundtable option ${name}`);
+    if (flags.has(name)) values[name] = true;
+    else { const value = options[++index]; if (!value || value.startsWith('--')) throw new TypeError(`Missing ${name}`); values[name] = value; }
+  }
+  if (action === 'serve') {
+    const port = Number(values['--port'] ?? 3738);
+    if (!Number.isSafeInteger(port) || port < 0 || port > 65535) throw new TypeError('Invalid Roundtable port');
+    const allowedHosts = [];
+    if (values['--public-url']) {
+      const publicUrl = new URL(values['--public-url']);
+      if (publicUrl.protocol !== 'https:' || publicUrl.username || publicUrl.password) throw new TypeError('Public URL must use HTTPS');
+      allowedHosts.push(publicUrl.host);
+    }
+    const paths = resolveSetupPaths({ env, dataDir: values['--data-dir'] ? resolve(values['--data-dir']) : undefined });
+    const app = existsSync(paths.graphRuntimeConfigPath)
+      ? openFederatedGraphApplication({ runtimeConfigPath: paths.graphRuntimeConfigPath, env }) : null;
+    let host;
+    try { host = await createRoundtableServer({ dataDir: paths.dataDir, service: app?.roundtables, port, host: values['--host'] ?? '127.0.0.1', allowedHosts }); }
+    catch (error) { await app?.close(); throw error; }
+    const closeServer = host.close;
+    let closing;
+    host.close = () => closing ??= closeServer().finally(() => app?.close());
+    const stop = () => { void host.close().catch(() => { process.exitCode = 1; }); };
+    process.once('SIGINT', stop); process.once('SIGTERM', stop);
+    host.server.once('close', () => { process.off('SIGINT', stop); process.off('SIGTERM', stop); });
+    console.log(`Agent 圆桌 / Agent Roundtable: ${host.url}/roundtables`);
+    return host;
+  }
+  if (action === 'worker') {
+    if (!values['--url'] || !values['--room'] || !values['--runtime']) throw new TypeError('Worker requires --url --room --runtime');
+    const controller = new AbortController();
+    const stop = () => controller.abort(); process.once('SIGINT', stop); process.once('SIGTERM', stop);
+    try {
+      return await runRoundtableWorker({ url: values['--url'], roomId: values['--room'], runtime: values['--runtime'],
+        workspace: resolve(values['--workspace'] ?? process.cwd()), allowWrite: Boolean(values['--allow-write']),
+        model: values['--model'], a2aUrl: values['--a2a-url'], once: Boolean(values['--once']),
+        allowHttp: Boolean(values['--allow-http']), env, signal: controller.signal,
+        onEvent: (event) => console.log(JSON.stringify(event)) });
+    } finally { process.off('SIGINT', stop); process.off('SIGTERM', stop); }
+  }
+  throw new TypeError('Roundtable action must be serve or worker');
+}

package/src/cli.js

@@ -10,6 +10,7 @@ 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';
@@ -41,6 +42,10 @@ 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/conversations/task-context-view.js

@@ -5,7 +5,9 @@ export function compactTaskContext(value) {
   const result = { ...value };
   if (Array.isArray(value.effective_preferences)) result.effective_preferences = value.effective_preferences.map(item => ({
     instruction: item.instruction, preference_key: item.preference_key,
-    preference_scope: item.preference_scope, confirmation_status: item.confirmation_status
+    preference_scope: item.preference_scope, confirmation_status: item.confirmation_status,
+    profile_aspect: item.profile_aspect,
+    ...(item.attributes?.tasteDomain ? { attributes: { tasteDomain: item.attributes.tasteDomain } } : {})
   }));
   const continuity = value.project_agent_context;
   if (continuity?.memory) {

package/src/employees/service.js

@@ -4,6 +4,7 @@ import { createEmployeeRecruitment } from './recruitment.js';
 import { join } from 'node:path';
 import { EmployeeManagementStore } from './management-policy.js';
 import { employeeTaskEntry } from './task-entry.js';
+import { employeeCollaborationReceipt } from '../agents/identity-receipt.js';
 
 export function createEmployeeService({ app, runtimeConfigPath, registry: configuredRegistry, managementStore: configuredManagementStore }) {
   const registry = configuredRegistry ?? createEmployeePackageRegistry(employeeDirectories(runtimeConfigPath));
@@ -65,7 +66,13 @@ export function createEmployeeService({ app, runtimeConfigPath, registry: config
       sourceApplication: input.sourceApplication ?? 'other', id: input.sourceSessionId,
       verified: input.sourceSessionVerified === true,
     } : null;
-    try { return await runtime.callTool(input.tool, input.arguments ?? {}, { ...context, session }); }
+    try {
+      const result = await runtime.callTool(input.tool, input.arguments ?? {}, { ...context, session });
+      if (!result || typeof result !== 'object' || Array.isArray(result)) return result;
+      return { ...result, collaboration_receipt: employeeCollaborationReceipt(app, context, {
+        tool: input.tool, permission: tool.permission, sourceApplication: input.sourceApplication
+      }) };
+    }
     catch (error) {
       if (Number.isInteger(error?.status) && error.status >= 400 && error.status < 500) {
         throw new EmployeeError(error.message, error.status, error.code ?? 'tool_error');
@@ -79,7 +86,7 @@ export function createEmployeeService({ app, runtimeConfigPath, registry: config
     recruit: async (input) => recruitment.recruit(await resolveInput(input)),
     workspace, describeTools, callTool,
     authorize: recruitment.authorize,
-    taskEntry: (input) => employeeTaskEntry({ registry, recruitment, workspace }, input)
+    taskEntry: (input) => employeeTaskEntry({ app, registry, recruitment, workspace }, input)
       .catch(() => ({ status: 'unavailable', managers: [], worker_started: false })),
     async handleHttp(request, response, input) {
       const context = await workspace(input);

package/src/employees/task-entry.js

@@ -1,6 +1,7 @@
 // Management is a task-entry capability, not a replacement for the specialist
 // role/executor chosen by FULI. Never persist the user's prompt or start a model.
-export async function employeeTaskEntry({ registry, recruitment, workspace }, input) {
+import { employeeCollaborationReceipt } from '../agents/identity-receipt.js';
+export async function employeeTaskEntry({ app, registry, recruitment, workspace }, input) {
   if (!input.personalProjectId) return { status: 'project_unresolved', managers: [], worker_started: false };
   const managers = [];
   let unavailable = false;
@@ -18,6 +19,9 @@ export async function employeeTaskEntry({ registry, recruitment, workspace }, in
       const board = await runtime.callTool(manifest.taskEntry.boardTool, { limit: 8 }, resolved);
       managers.push({
         template_id: manifest.id, agent_id: context.agentId, name: manifest.name,
+        collaboration_receipt: employeeCollaborationReceipt(app, resolved, {
+          tool: manifest.taskEntry.boardTool, permission: 'board.read', sourceApplication: input.sourceApplication
+        }),
         personal_project_id: context.project.id, scope_mode: context.management.mode,
         title_mode: context.management.titleMode, title_style: context.management.titleStyle,
         board: { version: board.version, total: board.total, truncated: board.truncated,

package/src/graphiti/agent-conversations.js

@@ -1,4 +1,5 @@
 import { detectSensitiveContent } from '../security/sensitive-content.js';
+import { agentContinuation, taskAgentReceipt } from '../agents/identity-receipt.js';
 
 export function conversationScope(application, input) {
   return { personal_space_id: application.config.personal.spaceId,
@@ -46,16 +47,29 @@ export async function checkpointConversation(application, task, workLog) {
       ...conversationTask(application, task), summary: safeConversationContent(workLog.summary), status: workLog.status,
       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. */ }
     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 }),
       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(); }
 }
 
 export async function queryConversations(application, input) {
-  return application.personal.conversation('query', { ...conversationScope(application, input),
+  const result = await application.personal.conversation('query', { ...conversationScope(application, input),
     mode: input.mode ?? 'list', ...(input.conversationId ? { conversation_id: input.conversationId } : {}),
     after: input.after ?? 0, limit: input.limit ?? (input.mode === 'events' ? 3 : 10) });
+  if (!Array.isArray(result.conversations)) return result;
+  return { ...result, conversations: result.conversations.map(conversation => ({ ...conversation,
+    continuation_prompt: agentContinuation(input.personalProjectId, input.agentId, conversation.id).prompt })) };
 }
 export async function resumeConversation(application, input) {
   const task = await application.taskContextRegistry.context(input.taskContextToken, input.sourceApplication);

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

@@ -23,18 +23,26 @@ export async function beginTaskContext(application, {
   requiredCapabilities = []
 }) {
   const continuationToken = /^FULI_CHECKPOINT_REQUIRED: (fuli-task-[a-zA-Z0-9-]{8,128})\b/.exec(taskPrompt ?? '')?.[1];
+  const current = !continuationToken && turnId && application.taskContextRegistry.current
+    ? await application.taskContextRegistry.current(sessionId, sourceApplication) : null;
   const resumed = continuationToken
     ? await application.taskContextRegistry.context(continuationToken, sourceApplication) : null;
+  const scopeRetry = current?.turnId === turnId && current?.projectScope?.type === 'temporary'
+    ? current : null;
   if (resumed && resumed.sessionId !== sessionId) {
     throw validationError('Checkpoint continuation belongs to another host session');
   }
+  const existingTask = resumed ?? scopeRetry;
+  if (existingTask && personalProjectId && existingTask.personalProjectId !== personalProjectId) {
+    throw validationError('Task context belongs to another project');
+  }
   const preferences = await application.getCollaborationPreferences({
-    personalProjectId,
+    personalProjectId: resumed?.personalProjectId ?? scopeRetry?.personalProjectId ?? personalProjectId,
     projectPath,
     sessionId,
-    turnId,
+    turnId: existingTask?.turnId ?? turnId,
     taskPrompt,
-    projectAgentId: resumed?.projectAgentId ?? projectAgentId,
+    projectAgentId: resumed?.projectAgentId ?? scopeRetry?.projectAgentId ?? projectAgentId,
     sourceApplication,
     sourceSessionId,
     workKind,
@@ -45,7 +53,7 @@ export async function beginTaskContext(application, {
   if (resumed && resumed.personalProjectId !== preferences.context.personal_project_id) {
     throw validationError('Checkpoint continuation belongs to another project');
   }
-  const task = resumed ?? await application.taskContextRegistry.begin({
+  const task = resumed ?? scopeRetry ?? await application.taskContextRegistry.begin({
     sessionId,
     turnId,
     personalProjectId: preferences.context.personal_project_id,
@@ -64,6 +72,7 @@ export async function beginTaskContext(application, {
     resumed_checkpoint: Boolean(resumed),
     previous_checkpoint_missing: task.previousCheckpointMissing,
     ...preferences,
+    ...(task.projectScope ? { project_scope: task.projectScope } : {}),
     task_guidance: {
       collaboration: 'Before implementation assess work complexity and required capabilities using plan_agent_collaboration. The stable project lead coordinates qualified specialists and source-lead-approved loans. Use only available authorized clients/models. Ask optional verification-client preference once; after 15 seconds use the recommended authorized task-local default. Persist project/global preferences only after explicit choice. Verify artifacts, record_agent_verification with evidence; after two failures escalate capability. Never claim a model change or worker run from a routing recommendation alone.',
       profile_capture: 'Evaluate durable artifact taste (including writing voice, wording, structure and formatting), stable collaboration personality, and decision preferences separately. Do not default every preference to judgment_preference. Use tasteDomain: writing for writing evidence; retain exact session/turn/time provenance. Agent-inferred personality remains pending. Report actual missing evidence rather than promising automatic progress from use alone.',
@@ -124,7 +133,7 @@ export async function checkpointTaskKnowledge(application, {
     targetKind: 'personal',
     spaceId: application.config.personal.spaceId,
     personalProjectId: task.personalProjectId,
-    projectAgentId: task.projectAgentId ?? null,
+    projectAgentId: task.agentMemoryScope === 'task_only' ? null : task.projectAgentId ?? null,
     sessionId: task.sessionId,
     sourceApplication,
     idempotencyKey: `${task.token}:knowledge`

package/src/graphiti/federated-application.js

@@ -1,5 +1,6 @@
 import { dirname } from 'node:path';
 import { createEmployeeService } from '../employees/service.js';
+import { createFuliRoundtableService } from '../roundtables/application.js';
 
 import { GraphitiProviderClient } from './provider-client.js';
 import {
@@ -76,11 +77,8 @@ import {
 import {
   relatedProjectGuidance
 } from './related-project-suggestions.js';
-import {
-  getCollaborationPreferences as getCollaborationPreferencesWorkflow
-} from './collaboration-preference-workflow.js';
 import { buildUserTasteSkill } from './user-taste-skill.js';
-import { resolveTaskEntryAgent, loadProjectAgentContinuity } from './project-agent-task-entry.js';
+import { taskEntryPreferences } from './task-entry-preferences.js';
 import { getWritingTasteProfile as getWritingTasteProfileWorkflow } from './writing-taste-profile-workflow.js';
 import {
   groupSubscriptions,
@@ -117,6 +115,7 @@ export function openFederatedGraphApplication({
       fetchImpl
     });
     app.employees = createEmployeeService({ app, runtimeConfigPath });
+    app.roundtables = createFuliRoundtableService({ app, dataDir: dirname(runtimeConfigPath) });
   }
   return app;
 }
@@ -256,42 +255,11 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     agentToolName = 'get_collaboration_preferences'
   } = {}) {
     const projectResolution = await this.#resolvePreferenceProject({ personalProjectId, projectPath });
-    const selection = projectPath === null && !personalProjectId && !projectAgentId
-      ? null
-      : await resolveTaskEntryAgent(
-      this, projectResolution, { projectAgentId, taskPrompt, sourceApplication,
-        sessionId: agentToolName === 'get_collaboration_preferences'
-          ? sessionId ?? sourceSessionId : turnId ? sessionId : null,
-        turnId: agentToolName === 'begin_task_context' ? turnId : null,
-        workKind, requiredCapabilities, agentInvocation, agentToolName }
-    );
-    // A rejected explicit role must not leak its private preferences via fallback.
-    const selectedAgentId = selection ? selection.agent?.agentId ?? null : projectAgentId;
-    const preferences = await getCollaborationPreferencesWorkflow(
-      this,
-      projectResolution,
-      {
-        projectAgentId: selectedAgentId,
-        taskPrompt,
-        limit,
-        agentInvocation,
-        agentToolName
-      },
-      (items, toolName) => this.#recordAgentViews(items, toolName)
-    );
-    const management = this.employees && agentInvocation &&
-      ['begin_task_context', 'get_collaboration_preferences'].includes(agentToolName)
-      ? await this.employees.taskEntry({ personalProjectId: projectResolution.personalProjectId,
-        sourceApplication, sourceSessionId, sessionId })
-      : null;
-    const managedPreferences = management ? { ...preferences, project_management_context: management } : preferences;
-    if (!selection) return managedPreferences;
-    const context = selection.agent ? await loadProjectAgentContinuity(this, {
-      projectId: projectResolution.personalProjectId, agent: selection.agent,
-      sourceApplication, taskPrompt, selectionReason: selection.reason,
-      matchBasis: selection.match_basis
-    }) : selection;
-    return { ...managedPreferences, project_agent_context: context };
+    return taskEntryPreferences(this, projectResolution, {
+      personalProjectId, projectAgentId, projectPath, taskPrompt, sourceApplication,
+      sourceSessionId, sessionId, turnId, workKind, requiredCapabilities,
+      limit, agentInvocation, agentToolName
+    }, (items, toolName) => this.#recordAgentViews(items, toolName));
   }
 
   async getUserTasteSkill({
@@ -1179,7 +1147,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     };
   }
 
-  close() { return this.employees?.close(); }
+  close() { this.roundtables?.close(); return this.employees?.close(); }
 
   async #recordAgentViews(items, toolName) {
     const unique = new Map(items.map((item) => [

package/src/graphiti/project-agent-mapping.js

@@ -411,6 +411,7 @@ export function projectAgentTaskRecord(value = {}) {
     taskId: value.task_id,
     personalSpaceId: value.personal_space_id,
     personalProjectId: value.personal_project_id,
+    ...(value.project_scope ? { projectScope: value.project_scope } : {}),
     title: value.title,
     objective: value.objective,
     workKind: value.work_kind,

package/src/graphiti/project-agent-mention.js

@@ -0,0 +1,35 @@
+// Only an explicit leading mention selects a role. Matching uses this project's
+// directory, never fuzzy search or another Agent's memory. Provider authorization
+// still runs after matching, including for inactive or client-restricted names.
+export async function resolveTaskAgentMention(application, projectId, input) {
+  const prompt = String(input.taskPrompt ?? '').trimStart();
+  if (!prompt.startsWith('@')) return null;
+  const directory = await application.personal.listProjectAgents(
+    application.config.personal.spaceId, projectId);
+  const agents = Array.isArray(directory) ? directory : directory.agents ?? directory.items ?? [];
+  const raw = prompt.slice(1, 2049);
+  const text = normalize(raw);
+  const stable = /^\{([^{}\s]+)\}(?=$|[\s,，:：])/u.exec(raw);
+  let stableId;
+  try { stableId = stable ? decodeURIComponent(stable[1]) : null; }
+  catch { stableId = null; }
+  const matches = agents.flatMap(agent => {
+    const aliases = stable ? [agent.agent_id] : [agent.profile?.display_name, agent.profile?.name, agent.agent_id];
+    const lengths = aliases.filter(Boolean).map(name => stable ? name : normalize(name)).filter(name => stable
+      ? name === stableId : text.startsWith(name) && /^(?:$|[\s,，:：!?！？])/u.test(text.slice(name.length))).map(name => name.length);
+    return lengths.length ? [{ agent, length: Math.max(...lengths) }] : [];
+  });
+  const longest = Math.max(0, ...matches.map(match => match.length));
+  const exact = matches.filter(match => match.length === longest);
+  const failure = status => ({ status, worker_started: false,
+    required_action: 'Select an exact current-project Agent with @{agentId}; use list_project_agents to resolve names. Do not load a different Agent as fallback.' });
+  if (!exact.length) return failure('agent_not_found');
+  if (exact.length > 1) return { ...failure('ambiguous_agent'),
+    candidates: exact.slice(0, 8).map(({ agent }) => ({ agent_id: agent.agent_id,
+      name: agent.profile?.display_name || agent.profile?.name })) };
+  const agentId = exact[0].agent.agent_id;
+  if (input.projectAgentId && input.projectAgentId !== agentId) return failure('agent_selection_conflict');
+  return { agentId };
+}
+
+function normalize(value) { return String(value).normalize('NFKC').toLowerCase(); }

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 { resolveTaskAgentMention } from './project-agent-mention.js';
 
 const ENTRY_TOOLS = new Set(['begin_task_context', 'get_collaboration_preferences']);
 
@@ -9,18 +10,25 @@ 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 };
   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({
       personal_space_id: application.config.personal.spaceId,
       personal_project_id: resolution.personalProjectId,
-      agent_id: input.projectAgentId ?? null,
+      agent_id: mention?.agentId ?? input.projectAgentId ?? null,
       session_id: input.sessionId ?? null,
       turn_id: input.turnId ?? null,
-      work_kind: input.workKind ?? taskWorkKind(input.taskPrompt),
+      work_kind: workKind,
       required_capabilities: input.requiredCapabilities ?? [],
       source_application: input.sourceApplication ?? 'other'
     });
     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.' };
+    }
     const employeeId = /^employee\.([a-z][a-z0-9-]{0,63})$/.exec(agent?.agentId ?? '')?.[1];
     if (employeeId && application.employees) {
       try { await application.employees.authorize({ templateId: employeeId, personalProjectId: resolution.personalProjectId }); }
@@ -118,6 +126,15 @@ function boundedRoleText(value, limit) {
   return typeof value === 'string' ? value.slice(0, 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));
+  return peer && !(profile.workKinds ?? []).some(kind => kind.toLowerCase() === workKind.toLowerCase())
+    && !(required.length && required.every(value => capabilities.includes(value.toLowerCase())));
+}
+
 function scopedItems(items, agentId) {
   return (items ?? []).filter(item => !item.project_agent_id || item.project_agent_id === agentId)
     .slice(0, 4).map(item => ({
@@ -133,7 +150,9 @@ function scopedItems(items, agentId) {
 function taskWorkKind(prompt) {
   const text = typeof prompt === 'string' ? prompt.slice(0, 8192) : '';
   if (/代码审查|代码评审|code review|review code/iu.test(text)) return 'code_review';
-  if (/修复|实现|开发|编写代码|\b(?:implement|fix|bug|coding)\b/iu.test(text)) return 'implementation';
+  if (/架构|\barchitecture\b/iu.test(text)) return 'architecture';
+  if (/修复|实现|开发|编写代码|优化|改为|接入|\b(?:implement|fix|bug|coding)\b/iu.test(text)) return 'implementation';
   if (/测试|验证|\b(?:test|verify|validation)\b/iu.test(text)) return 'test_validation';
+  if (/看板|排期|规划|\bplanning\b/iu.test(text)) return 'project_management';
   return 'project_context';
 }

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

@@ -1,4 +1,5 @@
 import { loadProjectAgentContinuity } from './project-agent-task-entry.js';
+import { resolveCoordinationScope, scopedTaskIdempotencyKey } from './temporary-project-scope.js';
 import {
   executorActualReportRecord,
   executorRecord,
@@ -152,6 +153,9 @@ export async function coordinateProjectAgentTask(
   projectResolution,
   input
 ) {
+  let entryTask = input.taskContextToken
+    ? await application.taskContextRegistry.context(input.taskContextToken, input.sourceApplication) : null;
+  projectResolution = await resolveCoordinationScope(application, projectResolution, input, entryTask);
   const projectId = projectResolution.personalProjectId ??
     projectResolution.personal_project_id ?? null;
   if (!projectId) {
@@ -168,23 +172,28 @@ export async function coordinateProjectAgentTask(
     };
   }
 
-  const entryTask = input.taskContextToken
-    ? await application.taskContextRegistry.context(input.taskContextToken, input.sourceApplication) : null;
+  if (entryTask && projectResolution.scope?.type === 'temporary') {
+    entryTask = await application.taskContextRegistry.context(input.taskContextToken, input.sourceApplication);
+  }
   if (entryTask && entryTask.personalProjectId !== projectId) {
     throw new TypeError('Coordination task context belongs to another project');
   }
   const route = await submitProjectAgentTask(application, {
     personalSpaceId: application.config.personal.spaceId,
     personalProjectId: projectId,
-    idempotencyKey: input.idempotencyKey,
+    idempotencyKey: projectResolution.scope?.type === 'temporary'
+      ? scopedTaskIdempotencyKey(projectId, input) : input.idempotencyKey,
     title: input.title,
     verificationRequired: true,
     objective: input.objective,
     workKind: input.workKind,
     requiredCapabilities: input.requiredCapabilities,
     executorCapabilityHints: input.executorCapabilityHints,
-    duration: input.duration,
-    staffingIntent: input.staffingIntent,
+    duration: projectResolution.scope?.type === 'temporary' ? 'one_off' : input.duration,
+    staffingIntent: projectResolution.scope?.type === 'temporary'
+      && !input.leadAgentId
+      && (!input.staffingIntent || input.staffingIntent === 'reuse_preferred')
+      ? 'temporary' : input.staffingIntent,
     leadAgentId: input.leadAgentId,
     collaboratorAgentIds: input.collaboratorAgentIds,
     coordinatorAgentId: input.coordinatorAgentId,
@@ -193,7 +202,8 @@ export async function coordinateProjectAgentTask(
     modelStrategyOverride: input.modelStrategyOverride,
     executorPolicyOverride: input.executorPolicyOverride,
     sourceApplication: input.sourceApplication,
-    sourceSessionId: input.sourceSessionId,
+    sourceSessionId: projectResolution.scope?.type === 'temporary' && entryTask
+      ? entryTask.sessionId : input.sourceSessionId,
     routingReason: input.routingReason,
     recruitmentProfile: input.recruitmentProfile
   });
@@ -227,10 +237,11 @@ export async function coordinateProjectAgentTask(
   const hostExecutionRequired = route.task.status === 'queued' &&
     workerPlan.length > 0 && contextsReady;
   let adoptedTask = null;
+  const leadMemoryScope = workerPlan.find(worker => worker.agent_id === route.task.leadAgentId)
+    ?.context?.agent?.memoryScope;
   if (entryTask && !entryTask.projectAgentId && contextsReady
       && ['queued', 'running', 'paused', 'blocked', 'awaiting_recruitment'].includes(route.task.status)
-      && workerPlan.find(worker => worker.agent_id === route.task.leadAgentId)
-        ?.context?.agent?.memoryScope === 'reviewed_agent') {
+      && ['reviewed_agent', 'task_only'].includes(leadMemoryScope)) {
     adoptedTask = await application.taskContextRegistry.adoptAgent(input.taskContextToken, {
       personalProjectId: projectId, taskId: route.task.taskId, agentId: route.task.leadAgentId
     }, input.sourceApplication);
@@ -245,10 +256,16 @@ export async function coordinateProjectAgentTask(
     personal_space_id: application.config.personal.spaceId,
     personal_project_id: projectId,
     project_resolution: projectResolution,
+    ...(projectResolution.scope ? { project_scope: projectResolution.scope } : {}),
+    ...(route.task.status === 'awaiting_recruitment' ? {
+      required_action: 'Review the returned recruitment proposal and use decide_project_agent_recruitment with its current revision before starting a worker.'
+    } : {}),
     route,
-    ...(adoptedTask ? { task_context: {
-      task_context_token: adoptedTask.token, project_agent_id: adoptedTask.projectAgentId,
-      memory_revision: adoptedTask.memoryRevision, work_log_required: adoptedTask.workLogRequired
+    ...(adoptedTask || (entryTask && projectResolution.scope) ? { task_context: {
+      task_context_token: (adoptedTask ?? entryTask).token,
+      personal_project_id: projectId, project_agent_id: (adoptedTask ?? entryTask).projectAgentId,
+      memory_revision: (adoptedTask ?? entryTask).memoryRevision,
+      work_log_required: (adoptedTask ?? entryTask).workLogRequired
     } } : {}),
     host_execution_required: hostExecutionRequired,
     host_execution_policy: {
@@ -581,7 +598,9 @@ export async function getProjectAgentContext(
     executionSummary: agent.executionSummary ?? [],
     role_instructions: {
       responsibility: agent.profile.responsibility,
-      initial_preferences: agent.profile.initialPreferences
+      initial_preferences: agent.profile.initialPreferences,
+      character: continuity.role.character,
+      expectations: continuity.role.expectations
     },
     effective_preferences: preferences.effective_preferences,
     deferred_conflicts: preferences.deferred_conflicts,

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

@@ -39,6 +39,7 @@ export function resolvePersonalProjectPath(projectPath, projects, {
 
   const projectIds = new Set(
     projects
+      .filter(project => project.scope_type !== 'temporary' && project.scopeType !== 'temporary')
       .map(({ project_id: projectId }) => projectId)
       .filter((projectId) => safeProjectId(projectId, pathApi))
   );

package/src/graphiti/provider-client.js

@@ -87,6 +87,9 @@ export class GraphitiProviderClient {
   upsertPersonalProject(input) {
     return this.#request('/v1/personal-projects', { method: 'PUT', body: input });
   }
+  ensureTemporaryProject(input) {
+    return this.#request('/v1/temporary-projects/ensure', { method: 'POST', body: input });
+  }
   listPersonalProjects(personalSpaceId) {
     const query = new URLSearchParams({ personal_space_id: personalSpaceId });
     return this.#request(`/v1/personal-projects?${query}`);

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

@@ -0,0 +1,50 @@
+import { taskAgentReceipt } from '../agents/identity-receipt.js';
+import { getCollaborationPreferences as getCollaborationPreferencesWorkflow } from './collaboration-preference-workflow.js';
+import { resolveTaskEntryAgent, loadProjectAgentContinuity } from './project-agent-task-entry.js';
+
+export async function taskEntryPreferences(application, projectResolution, {
+  personalProjectId, projectAgentId, projectPath, taskPrompt, sourceApplication,
+  sourceSessionId, sessionId, turnId, workKind, requiredCapabilities,
+  limit, agentInvocation, agentToolName
+}, recordAgentViews) {
+  const selection = projectPath === null && !personalProjectId && !projectAgentId
+    ? null
+    : await resolveTaskEntryAgent(
+      application, projectResolution, { projectAgentId, taskPrompt, sourceApplication,
+        sessionId: agentToolName === 'get_collaboration_preferences'
+          ? sessionId ?? sourceSessionId : turnId ? sessionId : null,
+        turnId: agentToolName === 'begin_task_context' ? turnId : null,
+        workKind, requiredCapabilities, agentInvocation, agentToolName }
+    );
+  // A rejected explicit role must not leak its private preferences via fallback.
+  const selectedAgentId = selection ? selection.agent?.agentId ?? null : projectAgentId;
+  const preferences = await getCollaborationPreferencesWorkflow(
+    application,
+    projectResolution,
+    {
+      projectAgentId: selectedAgentId,
+      taskPrompt,
+      limit,
+      agentInvocation,
+      agentToolName
+    },
+    (items, toolName) => recordAgentViews(items, toolName)
+  );
+  const management = application.employees && agentInvocation &&
+    ['begin_task_context', 'get_collaboration_preferences'].includes(agentToolName)
+    ? await application.employees.taskEntry({ personalProjectId: projectResolution.personalProjectId,
+      sourceApplication, sourceSessionId, sessionId })
+    : null;
+  const managedPreferences = management ? { ...preferences, project_management_context: management } : preferences;
+  if (!selection) return managedPreferences;
+  const context = selection.agent ? await loadProjectAgentContinuity(application, {
+    projectId: projectResolution.personalProjectId, agent: selection.agent,
+    sourceApplication, taskPrompt, selectionReason: selection.reason,
+    matchBasis: selection.match_basis
+  }) : selection;
+  return { ...managedPreferences, project_agent_context: context,
+    ...(selection.agent ? { agent_receipt: taskAgentReceipt(application, {
+      projectId: projectResolution.personalProjectId, agentId: selection.agent.agentId,
+      name: context.role?.name, sourceApplication
+    }) } : {}) };
+}