fuli-context 0.7.9 → 0.7.10-beta.7

package/src/agent-tools/graph-handlers.js

@@ -1,6 +1,37 @@
 import { ApplicationError } from '../app/application-error.js';
+import { agentInterfaceCatalog } from './interface-catalog.js';
 
 const HANDLERS = Object.freeze({
+  list_project_agent_tasks: (app, input) => app.listProjectAgentTasks(input),
+  request_agent_attention: (app, input) => app.requestAgentAttention(input),
+  list_agent_attention: (app, input) => app.listAgentAttention(input),
+  cancel_agent_attention: (app, input) => app.cancelAgentAttention(input),
+  list_preference_conflicts: (app, input) => app.listPreferenceConflicts(input),
+  list_agent_interfaces: () => agentInterfaceCatalog(),
+  get_capture_policy: (app) => app.getCapturePolicy(),
+  update_capture_policy: (app, input) => app.updateCapturePolicy(input),
+  list_external_knowledge_connectors: (app) => externalKnowledge(app).listConnectorTypes(),
+  discover_external_knowledge_sources: (app, input) => externalKnowledge(app).discover(input),
+  list_external_knowledge_bindings: (app) => externalKnowledge(app).listBindings(),
+  create_external_knowledge_binding: (app, input) => externalKnowledge(app).createBinding(input),
+  check_external_knowledge_binding: (app, input) => externalKnowledge(app).checkBinding(input.bindingId),
+  sync_external_knowledge_binding: (app, { bindingId, ...input }) =>
+    externalKnowledge(app).syncBinding(bindingId, input),
+  retrieve_external_knowledge_binding: (app, { bindingId, ...input }) =>
+    externalKnowledge(app).retrieveBinding(bindingId, input),
+  update_external_knowledge_binding_targets: (app, { bindingId, ...input }) =>
+    externalKnowledge(app).updateBindingTargets(bindingId, input),
+  delete_external_knowledge_binding: (app, input) =>
+    externalKnowledge(app).deleteBinding(input.bindingId),
+  get_external_knowledge_conflict_policy: (app, input) =>
+    connectedKnowledge(app).getConflictPolicy(input),
+  update_external_knowledge_conflict_policy: (app, input) =>
+    connectedKnowledge(app).updateConflictPolicy(input),
+  defer_preference_conflict: (app, input) => app.deferPreferenceConflict({
+    ...input,
+    operationActor: 'agent'
+  }),
+  delete_public_project: (app, input) => app.deletePublicProject(input),
   list_employee_templates: (app, input) => employeeService(app).list(input),
   recruit_employee: (app, input) => employeeService(app).recruit(input),
   list_employee_tools: (app, input) => employeeService(app).describeTools(input),
@@ -182,6 +213,16 @@ function employeeService(app) {
   return app.employees;
 }
 
+function externalKnowledge(app) {
+  if (!app.externalKnowledge) throw new Error('External knowledge runtime is unavailable');
+  return app.externalKnowledge;
+}
+
+function connectedKnowledge(app) {
+  if (!app.connectedKnowledge) throw new Error('Connected knowledge runtime is unavailable');
+  return app.connectedKnowledge;
+}
+
 export function dispatchGraphTool(app, name, input) {
   const handler = HANDLERS[name];
   if (!handler) throw new Error(`Unknown agent tool: ${name}`);

package/src/agent-tools/interface-catalog.js

@@ -0,0 +1,101 @@
+const UI_MUTATION_PARITY = Object.freeze([
+  agent('POST /api/agent-attention', 'request_agent_attention'),
+  agent('POST /api/agent-attention/cancel', 'cancel_agent_attention'),
+  local('POST /api/agent-attention/respond', 'Only a local person may respond to an Agent request. A response records a decision, but never executes permissions or task acceptance.'),
+  agent('POST /api/system/runtime/leases', 'acquire_runtime_lease'),
+  agent('PATCH /api/system/runtime/leases/:leaseId', 'refresh_runtime_lease'),
+  agent('DELETE /api/system/runtime/leases/:leaseId', 'release_runtime_lease'),
+  agent('PATCH /api/capture-policy', 'update_capture_policy'),
+  local('PATCH /api/agent-access-policy', 'The Agent access kill switch requires local user presence and cannot be changed by an Agent.'),
+  local('PUT /api/system/settings', 'Device-level runtime settings remain a local user operation.'),
+  agent('POST /api/capture', 'capture_session_knowledge'),
+  agent('POST /api/subscriptions', 'subscribe_public_project'),
+  agent('DELETE /api/subscriptions/:projectId', 'unsubscribe_public_project'),
+  agent('POST /api/external-knowledge/bindings', 'create_external_knowledge_binding'),
+  agent('POST /api/external-knowledge/bindings/:bindingId/check', 'check_external_knowledge_binding'),
+  agent('POST /api/external-knowledge/bindings/:bindingId/sync', 'sync_external_knowledge_binding'),
+  agent('PATCH /api/external-knowledge/bindings/:bindingId/targets', 'update_external_knowledge_binding_targets'),
+  agent('DELETE /api/external-knowledge/bindings/:bindingId', 'delete_external_knowledge_binding'),
+  agent('PATCH /api/external-knowledge/conflict-policy', 'update_external_knowledge_conflict_policy'),
+  agent('PUT /api/personal-projects', 'upsert_personal_project'),
+  agent('PUT /api/project-agents', 'upsert_project_agent'),
+  agent('DELETE /api/project-agents/:agentId', 'delete_project_agent'),
+  agent('POST /api/project-agent-assignments', 'create_project_agent_assignment'),
+  agent('POST /api/project-agent-assignments/:assignmentId/end', 'end_project_agent_assignment'),
+  agent('POST /api/project-agent-assignments/:assignmentId/replace', 'replace_project_agent_assignment'),
+  agent('POST /api/project-agent-tasks', 'submit_project_agent_task'),
+  agent('POST /api/project-agent-activity', 'record_project_agent_task_activity'),
+  agent('PUT /api/project-agent-coordination-policy', 'update_project_agent_coordination_policy'),
+  agent('PATCH /api/project-agent-coordination-policy', 'update_project_agent_coordination_policy'),
+  agent('PUT /api/project-agent-recruitment-policy', 'update_project_agent_recruitment_policy'),
+  agent('PATCH /api/project-agent-recruitment-policy', 'update_project_agent_recruitment_policy'),
+  agent('POST /api/project-agent-recruitments/decision', 'decide_project_agent_recruitment'),
+  agent('PUT /api/executors', 'upsert_executor'),
+  agent('DELETE /api/executors/:executorId', 'delete_executor'),
+  agent('POST /api/executors/preflight', 'preflight_executor'),
+  agent('POST /api/executors/authorization', 'authorize_executor'),
+  agent('POST /api/executors/health', 'report_executor_health'),
+  agent('PUT /api/executor-routing-rules', 'upsert_executor_routing_rule'),
+  agent('PATCH /api/executor-routing-rules/:ruleId', 'update_executor_routing_rule'),
+  agent('DELETE /api/executor-routing-rules/:ruleId', 'delete_executor_routing_rule'),
+  agent('PATCH /api/project-agent-learning/:evidenceId', 'ignore_project_agent_routing_learning', 'reset_project_agent_routing_learning'),
+  agent('POST /api/projects/publish', 'publish_personal_project'),
+  agent('DELETE /api/projects/:projectId', 'delete_public_project'),
+  agent('POST /api/project-relations', 'create_project_relation'),
+  agent('POST /api/project-relations/:relationId/decision', 'review_project_relation'),
+  agent('POST /api/personal-review/:draftId/decision', 'review_personal_draft'),
+  agent('POST /api/review/:proposalId/decision', 'review_project_proposal'),
+  agent('POST /api/preference-conflicts/defer', 'defer_preference_conflict'),
+  local('POST /api/preference-conflicts/:conflictId/complete', 'Completing a preference conflict records a human decision and requires local user presence.'),
+  agent('PATCH /api/knowledge/:itemKind/:itemId', 'revise_personal_knowledge'),
+  agent('POST /api/knowledge/:itemKind/:itemId/assignment', 'reassign_personal_knowledge'),
+  local('POST /api/knowledge/:itemKind/:itemId/preference-scope', 'Changing personal preference visibility requires local human review.'),
+  agent('POST /api/knowledge/entity/:itemId/project-action/preview', 'preview_personal_project_action'),
+  agent('POST /api/knowledge/entity/:itemId/project-action', 'apply_personal_project_action'),
+  local('POST /api/knowledge/batch-confirmation', 'Batch confirmation asserts human confirmation and requires local user presence.'),
+  agent('POST /api/employee-templates/:templateId/recruit', 'recruit_employee'),
+  agent('POST /api/employee-templates/:templateId/call', 'call_employee_tool'),
+  local('PATCH /employee-workspaces/:templateId/:projectId/api/work-items/:itemId/status', 'Completing a Jefa work item records explicit human acceptance in the native workbench.'),
+  local('PATCH /employee-workspaces/:templateId/:projectId/api/projects/:projectId/sharing', 'Changing public project visibility requires explicit local human approval; the read-only report never grants access to private tasks.'),
+]);
+
+export function agentInterfaceCatalog() {
+  const uiMutationParity = structuredClone(UI_MUTATION_PARITY);
+  const agentControlled = uiMutationParity.filter(({ access }) => access === 'agent').length;
+  return {
+    schemaVersion: 1,
+    contract: 'agent-interface-parity-v1',
+    guidance: [
+      'Use the named Agent tool instead of browser automation for FULI data reads and writes.',
+      'Read the tool schema and current record before writes; preserve versions, scopes, and idempotency keys.',
+      'local_user_only entries are deliberate trust boundaries, not missing interfaces.',
+    ],
+    coverage: {
+      total: uiMutationParity.length,
+      agentControlled,
+      localUserOnly: uiMutationParity.length - agentControlled,
+    },
+    uiMutationParity,
+    readWorkflows: [
+      { domain: 'human-attention', toolNames: ['list_agent_attention', 'request_agent_attention', 'cancel_agent_attention'], guidance: 'Raise a hand only for an explicit human action. Read resolved responses before continuing. Responses do not grant permissions or accept tasks.' },
+      { domain: 'projects', toolNames: ['list_knowledge_spaces', 'list_personal_projects', 'list_project_releases', 'list_project_relations'] },
+      { domain: 'knowledge', toolNames: ['search_knowledge_graph', 'get_knowledge_graph', 'get_user_taste_skill', 'list_preference_conflicts'] },
+      { domain: 'people-and-tasks', toolNames: ['list_project_agents', 'list_project_agent_assignments', 'list_project_agent_tasks', 'view_project_agent_task', 'view_project_agent_activity', 'list_project_agent_recruitments'] },
+      { domain: 'employees-and-boards', toolNames: ['list_employee_templates', 'list_employee_tools', 'call_employee_tool'], guidance: 'Discover the employee read_board and other read tools before invoking them with exact project scope.' },
+      { domain: 'external-knowledge', toolNames: ['list_external_knowledge_connectors', 'discover_external_knowledge_sources', 'list_external_knowledge_bindings', 'retrieve_external_knowledge_binding', 'get_external_knowledge_conflict_policy'], readRoutes: ['POST /api/external-knowledge/discover', 'POST /api/external-knowledge/bindings/:bindingId/retrieve'] },
+      { domain: 'executors', toolNames: ['list_executors', 'get_executor', 'list_executor_routing_rules', 'list_project_agent_routing_learning'] },
+      { domain: 'review', toolNames: ['list_personal_review_queue', 'list_project_review_queue', 'list_knowledge_review_candidates'] },
+      { domain: 'policy-and-health', toolNames: ['get_capture_policy', 'get_project_agent_coordination_policy', 'get_project_agent_recruitment_policy', 'get_graphiti_status'] },
+    ],
+  };
+}
+
+function agent(route, ...toolNames) {
+  return Object.freeze(toolNames.length === 1
+    ? { route, access: 'agent', toolName: toolNames[0] }
+    : { route, access: 'agent', toolNames: Object.freeze(toolNames) });
+}
+
+function local(route, reason) {
+  return Object.freeze({ route, access: 'local_user_only', reason });
+}

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

@@ -0,0 +1,184 @@
+import {
+  arraySchema,
+  enumSchema,
+  integerSchema,
+  nullableStringSchema,
+  objectSchema,
+  stringSchema,
+} from './schema.js';
+
+const id = { ...stringSchema(), minLength: 1, maxLength: 256 };
+const label = { ...stringSchema(), minLength: 1, maxLength: 512 };
+const url = { ...stringSchema(), minLength: 1, maxLength: 2048, pattern: '^https?://\\S+$' };
+const freeObject = { type: 'object', additionalProperties: true };
+const target = objectSchema({
+  personalSpaceId: id,
+  personalProjectId: id,
+  mode: enumSchema(['hybrid', 'live', 'mirror']),
+}, ['personalSpaceId', 'personalProjectId', 'mode']);
+
+export const AGENT_INTERFACE_DEFINITIONS = [
+  {
+    name: 'list_project_agent_tasks',
+    title: 'READ · List project Agent tasks',
+    description: 'Read task summaries for one personal space, optionally narrowed to one exact project, Agent or status. Use this to discover task IDs before viewing or updating a task. Results are bounded; do not claim omitted historical tasks do not exist.',
+    inputSchema: objectSchema({
+      personalSpaceId: id,
+      personalProjectId: nullableStringSchema(),
+      agentId: nullableStringSchema(),
+      status: enumSchema(['awaiting_recruitment', 'queued', 'running', 'paused', 'failed', 'awaiting_review', 'blocked', 'completed', 'cancelled']),
+      limit: integerSchema({ minimum: 1, maximum: 200 }),
+    }, ['personalSpaceId']),
+  },
+  {
+    name: 'list_preference_conflicts',
+    title: 'READ · List preference conflicts',
+    description: 'Read recorded preference conflicts in one personal space before deferring or resolving an exact conflict. This does not confirm either instruction or apply a decision.',
+    inputSchema: objectSchema({
+      personalSpaceId: id,
+      status: nullableStringSchema(),
+      limit: integerSchema({ minimum: 1, maximum: 1000 }),
+    }, ['personalSpaceId']),
+  },
+  {
+    name: 'list_agent_interfaces',
+    title: 'READ · List Agent interface parity',
+    description: 'List the durable Agent-control contract for FULI UI data mutations and read workflows. Each operation names the exact structured tool to call, or an explicit local-user-only trust boundary. Use this catalog instead of browser automation when choosing how to read or change FULI data.',
+    inputSchema: objectSchema({}),
+  },
+  {
+    name: 'get_capture_policy',
+    title: 'READ · Get automatic capture policy',
+    description: 'Read whether automatic personal knowledge capture is enabled. This does not change the independent Agent access kill switch.',
+    inputSchema: objectSchema({}),
+  },
+  {
+    name: 'update_capture_policy',
+    title: 'WRITE · Update automatic capture policy',
+    description: 'On an explicit user request enable or disable automatic personal knowledge capture. This never changes Agent access, deletes existing knowledge, or bypasses project scope.',
+    inputSchema: objectSchema({ enabled: { type: 'boolean' } }, ['enabled']),
+  },
+  {
+    name: 'list_external_knowledge_connectors',
+    title: 'READ · List external knowledge connectors',
+    description: 'List installed external-knowledge connector types and capabilities. Returned availability does not authorize a connection or disclose credentials.',
+    inputSchema: objectSchema({}),
+  },
+  {
+    name: 'discover_external_knowledge_sources',
+    title: 'READ · Discover external knowledge sources',
+    description: 'Use one configured connector to discover source identifiers before creating a binding. Pass environment-variable references rather than credential values.',
+    inputSchema: objectSchema({
+      connectorType: id,
+      connectorConfig: freeObject,
+      source: freeObject,
+      query: nullableStringSchema(),
+      cursor: nullableStringSchema(),
+      limit: integerSchema({ minimum: 1, maximum: 100 }),
+    }, ['connectorType']),
+  },
+  {
+    name: 'list_external_knowledge_bindings',
+    title: 'READ · List external knowledge bindings',
+    description: 'List configured external-knowledge bindings, project targets, modes, capabilities, and sync state without returning secret values.',
+    inputSchema: objectSchema({}),
+  },
+  {
+    name: 'create_external_knowledge_binding',
+    title: 'WRITE · Create external knowledge binding',
+    description: 'Create a scoped external-knowledge binding after an explicit user request. Connector configuration may contain environment-variable names but never credential values. Every target must name an existing personal project and an explicit live, mirror, or hybrid mode.',
+    inputSchema: objectSchema({
+      name: label,
+      connectorType: id,
+      connectorConfig: freeObject,
+      source: freeObject,
+      targets: arraySchema(target, { minItems: 1, maxItems: 32 }),
+    }, ['name', 'connectorType', 'connectorConfig', 'source', 'targets']),
+  },
+  {
+    name: 'check_external_knowledge_binding',
+    title: 'WRITE · Check external knowledge binding',
+    description: 'Check one existing binding and persist its current readiness and negotiated capabilities. This does not synchronize content.',
+    inputSchema: objectSchema({ bindingId: id }, ['bindingId']),
+  },
+  {
+    name: 'sync_external_knowledge_binding',
+    title: 'WRITE · Synchronize external knowledge binding',
+    description: 'Synchronize selected mirror or hybrid targets through the configured connector. Preserve the binding scope and never widen targets implicitly.',
+    inputSchema: objectSchema({
+      bindingId: id,
+      targetId: nullableStringSchema(),
+      personalProjectId: nullableStringSchema(),
+      maxPages: integerSchema({ minimum: 1, maximum: 100 }),
+      pageSize: integerSchema({ minimum: 1, maximum: 100 }),
+    }, ['bindingId']),
+  },
+  {
+    name: 'retrieve_external_knowledge_binding',
+    title: 'READ · Retrieve external knowledge binding',
+    description: 'Run a scoped live retrieval against one binding target. This read does not store returned content or change project scope.',
+    inputSchema: objectSchema({
+      bindingId: id,
+      query: { ...stringSchema(), minLength: 1, maxLength: 2000 },
+      targetId: nullableStringSchema(),
+      personalProjectId: nullableStringSchema(),
+      limit: integerSchema({ minimum: 1, maximum: 100 }),
+    }, ['bindingId', 'query']),
+  },
+  {
+    name: 'update_external_knowledge_binding_targets',
+    title: 'WRITE · Update external knowledge targets',
+    description: 'Replace the explicit project targets for one binding. Removed targets are invalidated without deleting unrelated project knowledge; never infer or widen project access.',
+    inputSchema: objectSchema({
+      bindingId: id,
+      expectedTargetsVersion: { ...stringSchema(), minLength: 64, maxLength: 64, pattern: '^[a-f0-9]{64}$' },
+      targets: arraySchema(target, { minItems: 1, maxItems: 32 }),
+    }, ['bindingId', 'expectedTargetsVersion', 'targets']),
+  },
+  {
+    name: 'delete_external_knowledge_binding',
+    title: 'WRITE · Delete external knowledge binding',
+    description: 'Delete one explicitly identified external-knowledge binding after a user request. Its projected target state is invalidated while unrelated FULI knowledge is preserved.',
+    inputSchema: objectSchema({ bindingId: id }, ['bindingId']),
+  },
+  {
+    name: 'get_external_knowledge_conflict_policy',
+    title: 'READ · Get external knowledge conflict policy',
+    description: 'Read the conflict policy for one exact personal project.',
+    inputSchema: objectSchema({ personalProjectId: id }, ['personalProjectId']),
+  },
+  {
+    name: 'update_external_knowledge_conflict_policy',
+    title: 'WRITE · Update external knowledge conflict policy',
+    description: 'Set whether one exact personal project asks the human or lets the current Agent decide only the current response when external and graph knowledge conflict. This never confirms or rewrites either source.',
+    inputSchema: objectSchema({
+      personalSpaceId: id,
+      personalProjectId: id,
+      mode: enumSchema(['ask_human', 'agent_decide']),
+    }, ['personalSpaceId', 'personalProjectId', 'mode']),
+  },
+  {
+    name: 'defer_preference_conflict',
+    title: 'WRITE · Defer preference conflict',
+    description: 'Defer one exact preference conflict without resolving either side. The conflict remains visible for later review.',
+    inputSchema: objectSchema({
+      personalSpaceId: id,
+      conflictId: { ...stringSchema(), minLength: 1, maxLength: 1024 },
+      preferenceKey: label,
+      preferenceScope: enumSchema(['global', 'project']),
+      preferenceProjectId: nullableStringSchema(),
+      leftItemId: id,
+      leftItemKind: enumSchema(['entity', 'relationship']),
+      rightItemId: id,
+      rightItemKind: enumSchema(['entity', 'relationship']),
+      reason: { ...stringSchema(), minLength: 1, maxLength: 2000 },
+    }, ['personalSpaceId', 'conflictId', 'preferenceKey', 'preferenceScope',
+      'leftItemId', 'leftItemKind', 'rightItemId', 'rightItemKind', 'reason']),
+  },
+  {
+    name: 'delete_public_project',
+    title: 'WRITE · Delete public project',
+    description: 'Delete one explicitly identified public project from its Provider after an explicit user request. This is not the same as unsubscribing and may require Provider ownership.',
+    inputSchema: objectSchema({ projectId: id, providerUrl: url }, ['projectId', 'providerUrl']),
+  },
+];

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

@@ -52,6 +52,7 @@ export const projectAgentModelStrategy = objectSchema({
 });
 export const projectAgentProfile = objectSchema({
   name: boundedString(160),
+  displayName: boundedString(160),
   responsibility: boundedString(4096),
   occupationEmoji: { ...nullableStringSchema(), minLength: 1, maxLength: 32 },
   agentType: enumSchema(['coordinator', 'durable', 'hr', 'temporary']),

package/src/cli/local-runtime-command.js

@@ -125,7 +125,8 @@ function checkAgentSetup({ paths, env, nodePath, discover, inspect }) {
       runtimeConfigPath: paths.graphRuntimeConfigPath,
       sessionSkillPath: paths.sessionSkillPath,
       projectSkillPath: paths.projectSkillPath,
-      reviewSkillPath: paths.reviewSkillPath
+      reviewSkillPath: paths.reviewSkillPath,
+      operationSkillPath: paths.operationSkillPath
     });
     return {
       status: 'checked',

package/src/employees/catalog/bole.json

@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "id": "bole",
+  "version": "1.0.0",
+  "name": "Bole",
+  "role": "HR",
+  "description": "查看 Agent 人员分布、当前工作和带时间与原因的招募记录。",
+  "occupationEmoji": "🔎",
+  "defaultProjectScope": "all",
+  "workbench": { "kind": "native", "view": "people" },
+  "capabilities": ["Agent 招募", "人员分布", "工作状态", "招募审计"],
+  "workKinds": ["agent-recruitment", "staffing-review"],
+  "initialPreferences": [
+    "每次招募保留任务、原因、触发来源与时间线。",
+    "只展示 Provider 已记录的人员状态，不推测未上报的工作。"
+  ],
+  "permissions": ["agents.read", "tasks.read", "recruitments.read"],
+  "runtime": null
+}

package/src/employees/install-package.js

@@ -13,6 +13,9 @@ export function installEmployeePackage({ sourceDirectory, runtimeConfigPath, rep
   const source = resolve(sourceDirectory);
   const digest = packageDigest(source);
   const manifest = parseEmployeeManifest(JSON.parse(readFileSync(join(source, 'employee.json'), 'utf8')));
+  if (manifest.id === 'bole' || manifest.workbench?.kind === 'native') {
+    throw new EmployeeError('A built-in native workbench cannot be installed or replaced by a package', 409, 'native_workbench_reserved');
+  }
   if (manifest.runtime) {
     confinedPath(source, manifest.runtime.entry);
     confinedPath(source, `${manifest.runtime.webRoot}/index.html`);

package/src/employees/manifest.js

@@ -27,6 +27,10 @@ export const employeeManifestSchema = z.object({
     boardTool: toolIdentifier,
     titleTool: toolIdentifier.optional(),
   }).strict().optional(),
+  workbench: z.object({
+    kind: z.literal('native'),
+    view: z.literal('people')
+  }).strict().optional(),
   runtime: z.object({
     apiVersion: z.literal(1),
     entry: relativeFile,

package/src/employees/package-registry.js

@@ -18,12 +18,14 @@ export function createEmployeePackageRegistry({ packageDirectory, dataDirectory,
     if (packageDirectory && existsSync(packageDirectory)) {
       for (const name of readdirSync(packageDirectory)) {
         if (!/^[a-z][a-z0-9-]{0,63}$/.test(name)) continue;
+        if (entries.get(name)?.manifest.workbench?.kind === 'native') continue;
         const root = join(packageDirectory, name);
         try {
           if (!statSync(root).isDirectory()) continue;
           confinedPath(packageDirectory, name);
           const manifest = readManifest(confinedPath(root, 'employee.json'));
           if (manifest.id !== name) continue;
+          if (manifest.workbench?.kind === 'native') continue;
           if (manifest.runtime) {
             confinedPath(root, manifest.runtime.entry);
             confinedPath(root, `${manifest.runtime.webRoot}/index.html`);

package/src/employees/recruitment.js

@@ -62,6 +62,9 @@ export function createEmployeeRecruitment({ app, registry, managementStore }) {
   async function recruit(input) {
     assertSpace(input);
     const { manifest } = registry.get(input.templateId);
+    if (manifest.workbench?.kind === 'native') {
+      throw new EmployeeError('This built-in role is provisioned by the Provider and does not require recruitment', 409, 'system_managed_employee');
+    }
     const selection = parseEmployeeProjectSelection(input);
     const agentId = employeeAgentId(manifest.id);
     const key = `${spaceId}:${agentId}`;

package/src/employees/service.js

@@ -51,6 +51,9 @@ export function createEmployeeService({ app, runtimeConfigPath, registry: config
     if (!tool || !manifest.permissions.includes(tool.permission)) {
       throw new EmployeeError('Employee tool is not available or permitted', 403, 'tool_not_permitted');
     }
+    if (context.templateId === 'jefa' && tool.permission === 'board.write' && requestsHumanAcceptance(input.arguments)) {
+      throw new EmployeeError('Jefa completion requires explicit human acceptance in the workbench', 403, 'human_acceptance_required');
+    }
     const session = input.sourceSessionId ? {
       sourceApplication: input.sourceApplication ?? 'other', id: input.sourceSessionId,
       verified: input.sourceSessionVerified === true,
@@ -81,3 +84,10 @@ export function createEmployeeService({ app, runtimeConfigPath, registry: config
     async close() { try { await registry.close(); } finally { managementStore.close(); } }
   };
 }
+
+function requestsHumanAcceptance(value, depth = 0) {
+  if (!value || typeof value !== 'object') return false;
+  if (depth > 32) throw new TypeError('Employee tool arguments are too deeply nested');
+  return Object.entries(value).some(([key, entry]) =>
+    (key === 'status' && entry === 'done') || requestsHumanAcceptance(entry, depth + 1));
+}

package/src/external-knowledge/registry.js

@@ -1,4 +1,8 @@
 import { readJsonFile, writeJsonFileAtomic } from '../storage/json-file.js';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { ApplicationError } from '../app/application-error.js';
 
 const CURRENT_VERSION = 2;
 const EMPTY_REGISTRY = Object.freeze({ version: CURRENT_VERSION, bindings: [] });
@@ -15,6 +19,26 @@ export class ExternalKnowledgeRegistry {
     return clone(this.#read().bindings);
   }
 
+  async withMutation(operation) {
+    // An OS-backed SQLite reservation coordinates separate console/MCP processes.
+    // No credentials or binding data is stored here; a crashed owner releases its lock.
+    mkdirSync(dirname(this.filePath), { recursive: true, mode: 0o700 });
+    const path = `${this.filePath}.mutation-lock.sqlite`;
+    const lock = new DatabaseSync(path);
+    try {
+      chmodSync(path, 0o600);
+      try { lock.exec('BEGIN IMMEDIATE'); }
+      catch (error) {
+        if (error.errcode === 5 || error.errcode === 6) {
+          throw new ApplicationError('external_knowledge_busy', 'Another external-knowledge mutation is in progress; re-read state before retrying');
+        }
+        throw error;
+      }
+      try { return await operation(); }
+      finally { lock.exec('ROLLBACK'); }
+    } finally { lock.close(); }
+  }
+
   get(id) {
     const binding = this.#read().bindings.find((item) => item.id === id);
     return binding ? clone(binding) : null;

package/src/external-knowledge/service.js

@@ -9,6 +9,7 @@ import {
   normalizeExternalDocument
 } from './document-mapping.js';
 import { safeExternalSourceDiagnostic } from './safe-diagnostic.js';
+import { ApplicationError } from '../app/application-error.js';
 
 const MODES = new Set(['hybrid', 'live', 'mirror']);
 const MAX_TARGETS = 32;
@@ -80,6 +81,10 @@ export class ExternalKnowledgeService {
   }
 
   async createBinding(input) {
+    return this.registry.withMutation(() => this.#createBinding(input));
+  }
+
+  async #createBinding(input) {
     const connectorType = requiredString(input?.connectorType, 'connectorType', 64);
     const connector = this.#connector(connectorType);
     const connectorConfig = safeConfiguration(input.connectorConfig ?? {});
@@ -117,7 +122,14 @@ export class ExternalKnowledgeService {
   }
 
   async updateBindingTargets(id, input) {
+    return this.registry.withMutation(() => this.#updateBindingTargets(id, input));
+  }
+
+  async #updateBindingTargets(id, input) {
     const binding = this.#binding(id);
+    if (input.expectedTargetsVersion !== undefined && input.expectedTargetsVersion !== targetsVersion(binding)) {
+      throw new ApplicationError('external_knowledge_conflict', 'Binding targets changed; re-read the complete targets array before retrying');
+    }
     const connector = this.#connector(binding.connectorType);
     const targets = bindingTargets(input, {
       bindingId: binding.id,
@@ -151,6 +163,10 @@ export class ExternalKnowledgeService {
   }
 
   async checkBinding(id) {
+    return this.registry.withMutation(() => this.#checkBinding(id));
+  }
+
+  async #checkBinding(id) {
     const binding = this.#binding(id);
     const connector = this.#connector(binding.connectorType);
     const result = typeof connector.check === 'function'
@@ -165,6 +181,10 @@ export class ExternalKnowledgeService {
   }
 
   async syncBinding(id, options = {}) {
+    return this.registry.withMutation(() => this.#syncBinding(id, options));
+  }
+
+  async #syncBinding(id, options) {
     if (!options || typeof options !== 'object' || Array.isArray(options)) {
       throw new TypeError('Synchronization options must be an object');
     }
@@ -227,6 +247,10 @@ export class ExternalKnowledgeService {
   }
 
   async deleteBinding(id) {
+    return this.registry.withMutation(() => this.#deleteBinding(id));
+  }
+
+  async #deleteBinding(id) {
     const binding = this.#binding(id);
     let invalidated = 0;
     for (const target of binding.targets) {
@@ -503,6 +527,7 @@ function publicBinding(binding) {
   const first = output.targets?.[0] ?? null;
   return {
     ...output,
+    targetsVersion: targetsVersion(binding),
     // Keep the v1 aliases while clients migrate to target-aware bindings.
     target: first ? {
       personalSpaceId: first.personalSpaceId,
@@ -513,6 +538,12 @@ function publicBinding(binding) {
   };
 }
 
+function targetsVersion(binding) {
+  return createHash('sha256').update(JSON.stringify(binding.targets.map((target) => [
+    target.id, target.personalSpaceId, target.personalProjectId, target.mode,
+  ]).sort((left, right) => String(left[0]).localeCompare(String(right[0]))))).digest('hex');
+}
+
 function bindingTargets(input, {
   bindingId,
   existingTargets = [],
@@ -631,13 +662,15 @@ function assertNegotiatedCapabilities(type, capabilities, targets) {
 }
 
 function selectedTargets(binding, input, { capability, requireOne = false }) {
+  const targetId = optionalString(input?.targetId, 'targetId', 256);
   const personalSpaceId = optionalString(input?.personalSpaceId, 'personalSpaceId', 256);
   const personalProjectId = optionalString(input?.personalProjectId, 'personalProjectId', 256);
   let targets = binding.targets.filter((target) =>
+    (!targetId || target.id === targetId) &&
     (!personalSpaceId || target.personalSpaceId === personalSpaceId) &&
     (!personalProjectId || target.personalProjectId === personalProjectId)
   );
-  if ((personalSpaceId || personalProjectId) && !targets.length) {
+  if ((targetId || personalSpaceId || personalProjectId) && !targets.length) {
     throw new TypeError('External knowledge binding is not assigned to this personal project');
   }
   targets = targets.filter(({ mode }) => capability === 'sync' ? mode !== 'live' : mode !== 'mirror');

package/src/graphiti/agent-attention.js

@@ -0,0 +1,26 @@
+const fields = {
+  personalSpaceId: 'personal_space_id', personalProjectId: 'personal_project_id',
+  agentId: 'agent_id', taskId: 'task_id', requestId: 'request_id',
+  idempotencyKey: 'idempotency_key', requestedAction: 'requested_action',
+  expectedRevision: 'expected_revision', respondedBy: 'responded_by',
+  createdAt: 'created_at', updatedAt: 'updated_at'
+};
+
+export function attentionInput(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined)
+    .map(([key, value]) => [fields[key] ?? key, value]));
+}
+
+export function attentionRecord(value) {
+  const names = Object.fromEntries(Object.entries(fields).map(([camel, snake]) => [snake, camel]));
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [names[key] ?? key, item]));
+}
+
+export async function listAgentAttention(application, input) {
+  const value = await application.personal.listAgentAttention(attentionInput(input));
+  return { ...value, items: value.items.map(attentionRecord) };
+}
+
+export async function changeAgentAttention(application, operation, input) {
+  return attentionRecord(await application.personal.changeAgentAttention(operation, attentionInput(input)));
+}

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

@@ -61,6 +61,7 @@ export async function beginTaskContext(application, {
     previous_checkpoint_missing: task.previousCheckpointMissing,
     ...preferences,
     task_guidance: {
+      human_attention: 'When the selected Project Agent needs a human answer, decision, review or permission, use request_agent_attention with the exact current space/project/Agent IDs, a stable idempotency key and a specific requestedAction. Never raise a hand for ordinary running, queueing or automatic retries. Read list_agent_attention with status=resolved for replies; cancel obsolete requests with cancel_agent_attention. A response does not grant permission or accept task completion.',
       retrieval: 'Inspect task_knowledge_recall before asking for a stable project fact or method again. On a miss, use search_current_project_knowledge with focused action, artifact, target-system, or identifier queries; never use the full conversational request as the only query.',
       checkpoint: 'Before finishing, call checkpoint_task_knowledge with capture_candidates or retain_nothing. When durable role context changed, include agentMemory with the loaded revision and a bounded merged summary, decisions, open threads and next actions. Do not overwrite from truncated context or store raw transcripts.'
     }