fuli-context 0.7.6 → 0.7.8

package/src/adaptive-runtime/lease-client.js

@@ -14,13 +14,15 @@ export function createRuntimeLeaseClient({
   clearHeartbeat = clearInterval
 }) {
   const leases = new Map();
+  const acquisitions = new Set();
+  let closed = false;
 
-  async function withGraphLease(owner, operation) {
-    return withLease({ kind: 'graph', owner }, operation);
+  async function withGraphLease(owner, operation, requestContext = null) {
+    return withLease({ kind: 'graph', owner }, operation, requestContext);
   }
 
-  async function withExecutorLease(executorId, owner, operation) {
-    return withLease({ kind: 'executor', executorId, owner }, operation);
+  async function withExecutorLease(executorId, owner, operation, requestContext = null) {
+    return withLease({ kind: 'executor', executorId, owner }, operation, requestContext);
   }
 
   async function acquireGraphLease(owner) {
@@ -31,7 +33,19 @@ export function createRuntimeLeaseClient({
     return acquireLease({ kind: 'executor', executorId, owner });
   }
 
-  async function acquireLease(input) {
+  async function acquireLease(input, signal = null) {
+    assertOpen();
+    signal?.throwIfAborted();
+    const acquisition = acquireOpenLease(input, signal);
+    acquisitions.add(acquisition);
+    try {
+      return await acquisition;
+    } finally {
+      acquisitions.delete(acquisition);
+    }
+  }
+
+  async function acquireOpenLease(input, signal = null) {
     const settings = readSettings(paths.adaptiveRuntimeSettingsPath);
     if (!settings.enabled) return disabledLease();
 
@@ -40,10 +54,24 @@ export function createRuntimeLeaseClient({
       method: 'POST',
       body: input,
       timeoutMs: 180_000,
-      fetchImpl
+      fetchImpl,
+      signal
     });
     const handle = publicLease(lease);
-    if (!handle.enabled) return handle;
+    if (!handle.enabled) {
+      const explicitlyDisabled = lease?.enabled === false && lease.leaseId === null;
+      if (!explicitlyDisabled) {
+        // Preserve a usable ID before rejecting a malformed success response.
+        // Without one, remote TTL is the only available cleanup mechanism.
+        if (typeof lease?.leaseId === 'string' && lease.leaseId.trim()) {
+          await releaseRemote({ consoleUrl, handle: { leaseId: lease.leaseId } }).catch(() => {});
+        }
+        throw new Error('Invalid runtime lease response');
+      }
+      assertOpen();
+      signal?.throwIfAborted();
+      return handle;
+    }
 
     const entry = {
       handle,
@@ -55,6 +83,8 @@ export function createRuntimeLeaseClient({
     };
     leases.set(handle.leaseId, entry);
     try {
+      assertOpen();
+      signal?.throwIfAborted();
       startHeartbeat(entry, settings);
       return { ...entry.handle };
     } catch (error) {
@@ -89,10 +119,13 @@ export function createRuntimeLeaseClient({
     }
   }
 
-  async function withLease(input, operation) {
+  async function withLease(input, operation, requestContext = null) {
     if (typeof operation !== 'function') throw new TypeError('Runtime operation is required');
-    const handle = await acquireLease(input);
+    const signal = agentRequestSignal(requestContext);
+    signal?.throwIfAborted();
+    const handle = await acquireLease(input, signal);
     try {
+      signal?.throwIfAborted();
       return await operation();
     } finally {
       await releaseLease(handle);
@@ -100,8 +133,16 @@ export function createRuntimeLeaseClient({
   }
 
   async function close() {
+    closed = true;
     const handles = [...leases.values()].map(({ handle }) => ({ ...handle }));
-    await Promise.allSettled(handles.map((handle) => releaseLease(handle)));
+    await Promise.allSettled([
+      ...acquisitions,
+      ...handles.map((handle) => releaseLease(handle))
+    ]);
+  }
+
+  function assertOpen() {
+    if (closed) throw new Error('Runtime lease client is closed');
   }
 
   function startHeartbeat(entry, settings) {
@@ -184,7 +225,8 @@ export function createRuntimeLeaseClient({
         }
         return { ...entry.handle, refreshed };
       } catch (error) {
-        stopHeartbeat(entry);
+        // A transient request failure must not abandon a still-running operation.
+        // The next heartbeat retries; release/close or refreshed:false stops it.
         throw error;
       }
     })();
@@ -269,7 +311,7 @@ function publicLease(value, fallback = null) {
     ...(fallback && typeof fallback === 'object' ? fallback : {}),
     ...(value && typeof value === 'object' ? value : {})
   };
-  if (source.enabled !== true || typeof source.leaseId !== 'string' || !source.leaseId) {
+  if (source.enabled !== true || typeof source.leaseId !== 'string' || !source.leaseId.trim()) {
     return disabledLease();
   }
   const handle = {
@@ -311,13 +353,15 @@ async function requestJson(url, {
   method,
   body,
   timeoutMs,
-  fetchImpl
+  fetchImpl,
+  signal = null
 }) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
   const response = await fetchImpl(url, {
     method,
     headers: body === undefined ? undefined : { 'content-type': 'application/json' },
     body: body === undefined ? undefined : JSON.stringify(body),
-    signal: AbortSignal.timeout(timeoutMs)
+    signal: signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal
   });
   if (!response.ok) {
     let detail = null;
@@ -333,3 +377,11 @@ async function requestJson(url, {
   }
   return response.json();
 }
+
+function agentRequestSignal(value) {
+  const signal = value?.signal;
+  return signal && typeof signal.addEventListener === 'function' &&
+    typeof signal.throwIfAborted === 'function'
+    ? signal
+    : null;
+}

package/src/adaptive-runtime/runtime-broker.js

@@ -9,6 +9,8 @@ import {
   writeAdaptiveRuntimeState
 } from './state.js';
 
+const IDLE_FAILURE_RETRY_MS = 30_000;
+
 export function createAdaptiveRuntimeBroker({
   paths,
   settings,
@@ -33,12 +35,14 @@ export function createAdaptiveRuntimeBroker({
   let databaseTimer = null;
   let transition = Promise.resolve();
   let closed = false;
+  let closePromise = null;
+  let idleRetryAt = 0;
 
   scheduleIdle();
 
   async function acquire(input = {}) {
     if (!configured.enabled) return disabledLease();
-    if (closed) throw new Error('Adaptive runtime coordinator is closed');
+    assertOpen();
     const kind = input.kind ?? 'graph';
     if (!['graph', 'executor'].includes(kind)) {
       throw new TypeError('Runtime lease kind must be graph or executor');
@@ -56,18 +60,22 @@ export function createAdaptiveRuntimeBroker({
     };
     leases.set(leaseId, lease);
     clearIdleTimers();
-    armExpiry(lease);
     try {
       await exclusive(async () => {
+        assertOpen();
         await ensureAwake();
         if (executorId) await executorPool.acquire(executorId, leaseId);
       });
+      assertOpen();
+      idleRetryAt = 0;
+      // The caller can only heartbeat after startup returns its lease handle.
+      armExpiry(lease);
       return publicLease(lease);
     } catch (error) {
       leases.delete(leaseId);
       if (lease.timer) clearTimer(lease.timer);
       if (executorId) executorPool.release(executorId, leaseId);
-      touch();
+      touch(errorMessage(error));
       scheduleIdle();
       throw error;
     }
@@ -126,14 +134,19 @@ export function createAdaptiveRuntimeBroker({
   }
 
   function close() {
-    if (closed) return;
+    if (closed) return closePromise;
     closed = true;
     clearIdleTimers();
     for (const lease of leases.values()) {
       if (lease.timer) clearTimer(lease.timer);
     }
     leases.clear();
-    executorPool.close();
+    closePromise = executorPool.close();
+    return closePromise;
+  }
+
+  function assertOpen() {
+    if (closed) throw new Error('Adaptive runtime coordinator is closed');
   }
 
   async function ensureAwake() {
@@ -175,9 +188,11 @@ export function createAdaptiveRuntimeBroker({
         await operation();
       }).catch((error) => {
         persist('degraded', errorMessage(error));
+        // A missed idle deadline must not become a zero-delay failure loop.
+        idleRetryAt = now() + IDLE_FAILURE_RETRY_MS;
         scheduleIdle();
       });
-    }, Math.max(0, timestamp - now()));
+    }, Math.max(0, timestamp - now(), idleRetryAt - now()));
     timer?.unref?.();
     return timer;
   }
@@ -241,8 +256,8 @@ export function createAdaptiveRuntimeBroker({
     return initial;
   }
 
-  function touch() {
-    state = persistValue({ ...state, lastActivityAt: isoNow(), lastError: null });
+  function touch(lastError = null) {
+    state = persistValue({ ...state, lastActivityAt: isoNow(), lastError });
   }
 
   function persist(stage, lastError = null) {
@@ -260,7 +275,7 @@ export function createAdaptiveRuntimeBroker({
 
   function nextSleepAt(lastActivityMs, idleSeconds, stages) {
     if (!configured.enabled || leases.size > 0 || !stages.includes(state.stage)) return null;
-    return new Date(lastActivityMs + idleSeconds * 1000).toISOString();
+    return new Date(Math.max(lastActivityMs + idleSeconds * 1000, idleRetryAt)).toISOString();
   }
 
   function clearIdleTimers() {

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

@@ -0,0 +1,43 @@
+import { booleanSchema, objectSchema, stringSchema } from './schema.js';
+
+const id = { ...stringSchema(), minLength: 1, maxLength: 256 };
+const projectPath = { ...stringSchema(), minLength: 1, maxLength: 4096 };
+const target = { projectPath, templateId: id };
+
+export const EMPLOYEE_TOOL_DEFINITIONS = [
+  {
+    name: 'list_employee_templates', title: 'READ · Employee catalog',
+    description: 'List reusable employee Agent templates, recruitment state, assignments and installed workbench availability. This does not recruit or start an executor.',
+    inputSchema: objectSchema({})
+  },
+  {
+    name: 'recruit_employee', title: 'WRITE · Recruit an employee',
+    description: 'On an explicit user request recruit an employee. New recruitment without a scope uses the template default (Jefa: all projects, including future projects). Existing identities retain their saved scope. Use management.mode=all plus excludedProjectIds for a persistent all-except rule, or mode=selected plus projectIds for a fixed selection. Never combine management with projectPath/personalProjectIds. Changing existing management requires replaceAssignments and expectedAssignmentsVersion from the catalog. Legacy projectPath or personalProjectIds remains a current-project selection. Exclusions take effect before assignment synchronization; data and history are preserved. Reload after conflicts or incomplete updates. No models or workers start. Reactivation must be explicitly requested.',
+    inputSchema: objectSchema({
+      ...target, reactivate: booleanSchema(),
+      personalProjectIds: { type: 'array', items: id, maxItems: 500 },
+      replaceAssignments: booleanSchema(),
+      expectedAssignmentsVersion: { ...stringSchema(), minLength: 1, maxLength: 128 },
+      management: objectSchema({
+        mode: { type: 'string', enum: ['all', 'selected'] },
+        projectIds: { type: 'array', items: id, maxItems: 500 },
+        excludedProjectIds: { type: 'array', items: id, maxItems: 500 },
+        titleMode: { type: 'string', enum: ['off', 'suggest', 'auto'] },
+        titleStyle: { type: 'string', enum: ['text', 'emoji'] },
+      }, ['mode']),
+    }, ['templateId'])
+  },
+  {
+    name: 'list_employee_tools', title: 'READ · Employee workbench tools',
+    description: 'Discover the exact input schemas and permissions for a recruited employee in the current project. Read these schemas before calling a tool; a workbench has to be installed first.',
+    inputSchema: objectSchema(target, ['projectPath', 'templateId'])
+  },
+  {
+    name: 'call_employee_tool', title: 'WRITE · Call an employee workbench tool',
+    description: 'Call a discovered employee tool inside the exact assigned project. May read or change data according to the tool schema. Preserve optimistic concurrency and idempotency keys. Does not grant cross-project access, execute an external model, or confirm task completion for the human.',
+    inputSchema: objectSchema({
+      ...target, tool: id,
+      arguments: { type: 'object', additionalProperties: true }
+    }, ['projectPath', 'templateId', 'tool', 'arguments'])
+  }
+];

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

@@ -31,6 +31,8 @@ import {
   recruitmentStatus,
   routingRuleScope
 } from './project-agent-definitions.js';
+import { PROJECT_AGENT_MEMORY_DEFINITIONS, workingMemorySchema } from './project-agent-memory-definitions.js';
+import { EMPLOYEE_TOOL_DEFINITIONS } from './employee-definitions.js';
 
 const id = boundedString(256);
 const label = boundedString(512);
@@ -98,7 +100,7 @@ const profileAspect = {
 };
 const sourceApplication = {
   type: ['string', 'null'],
-  enum: ['codex', 'claude_code', 'cursor', 'kiro', 'other', null]
+  enum: ['codex', 'claude', 'claude_code', 'cursor', 'kiro', 'other', null]
 };
 const epistemicFields = {
   originQuadrant: epistemicQuadrant,
@@ -276,13 +278,19 @@ const workflowObservedStep = objectSchema({
 }, ['actionId', 'name']);
 
 export const GRAPH_TOOL_DEFINITIONS = [
+  ...EMPLOYEE_TOOL_DEFINITIONS,
   {
     name: 'begin_task_context',
     title: 'LIFECYCLE · Begin a Fuli-aware task',
-    description: 'Lifecycle entry used by supported Agent hooks before the model processes a user prompt. It resolves the exact local project from projectPath, loads effective collaboration preferences, and uses taskPrompt transiently for bounded automatic recall when the request signals a stable prior fact, runbook, URL, decision, release, deployment, or authentication method. It never stores or returns projectPath or taskPrompt. Inspect task_knowledge_recall before asking the user to repeat stable context. Returns an opaque taskContextToken. Claude Code setup installs this as a deterministic UserPromptSubmit hook; manual Agent calls are a fallback.',
+    description: 'Lifecycle entry used by supported Agent hooks before the model processes a user prompt. It resolves the exact local project from projectPath, loads effective collaboration preferences, and uses taskPrompt transiently for bounded automatic recall when the request signals a stable prior fact, runbook, URL, decision, release, deployment, or authentication method. It never stores or returns projectPath or taskPrompt. Inspect task_knowledge_recall before asking the user to repeat stable context. Returns an opaque taskContextToken. Fuli setup generates Claude Code and Codex UserPromptSubmit hook configuration and a Cursor task-entry adapter. Configuration is not proof of host loading, trust, or execution. Use supplied hook context without repeating the preference fallback; Cursor retrieves context through the Agent when its hook cannot inject it.',
     inputSchema: objectSchema({
       sessionId: id,
+      turnId: id,
       projectPath: boundedString(4096),
+      personalProjectId: nullableStringSchema(),
+      projectAgentId: nullableStringSchema(),
+      workKind: boundedString(128),
+      requiredCapabilities: arraySchema(boundedString(512), { maxItems: 16 }),
       taskPrompt: boundedString(8192)
     }, ['sessionId', 'projectPath'])
   },
@@ -294,7 +302,11 @@ export const GRAPH_TOOL_DEFINITIONS = [
       taskContextToken: id,
       disposition: enumSchema(['capture_candidates', 'retain_nothing']),
       reason: boundedString(2000),
-      capture: objectSchema(captureEpisodeFields, captureEpisodeRequired)
+      capture: objectSchema(captureEpisodeFields, captureEpisodeRequired),
+      agentMemory: objectSchema({
+        expectedRevision: integerSchema({ minimum: 0 }),
+        memory: workingMemorySchema
+      }, ['expectedRevision', 'memory'])
     }, ['taskContextToken', 'disposition', 'reason'])
   },
   {
@@ -308,10 +320,13 @@ export const GRAPH_TOOL_DEFINITIONS = [
     title: 'READ FIRST · Load task collaboration preferences',
     description: 'Fallback for Agents or tasks without begin_task_context hook context. When no hook context was supplied, call this exact tool name at the start of every user task before any other tool or answer; never substitute a project action tool. Do not call it redundantly when the entry hook already supplied preferences. Pass projectPath as the current working directory and taskPrompt as the current user request. Fuli uses both transiently, never stores or returns them, resolves one exact registered local project, and performs bounded automatic recall only when the request signals stable prior context. Inspect task_knowledge_recall before asking the user to repeat a project fact or method. On a miss, search_current_project_knowledge with one to four focused action, artifact, target-system, or identifier queries; never use the full conversational request as the only query. Apply effective_preferences before answering or constructing tool arguments. Resolve only relevant deferred_conflicts first. For write tools, enforce preferences in the actual payload; the final answer is not compliance. Personal-global preferences always apply; conflicted, pending, invalid, ambiguous-project, and unrelated-project items never auto-apply. Automatic injection does not count as usage evidence. personalProjectId remains an explicit compatibility override.',
     inputSchema: objectSchema({
+      sessionId: id,
       projectPath: boundedString(4096),
       taskPrompt: boundedString(8192),
       personalProjectId: nullableStringSchema(),
       projectAgentId: nullableStringSchema(),
+      workKind: boundedString(128),
+      requiredCapabilities: arraySchema(boundedString(512), { maxItems: 16 }),
       limit: integerSchema({ minimum: 1, maximum: 200 })
     }, ['projectPath'])
   },
@@ -514,6 +529,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
     description: 'High-level project search for normal Agent work. Pass projectPath plus one or more focused queries; Fuli resolves the exact local project, searches its local knowledge first, then follows outgoing PART_OF or USES_KNOWLEDGE_FROM relations to authorized parent/source knowledge. An exact current-project item with the same stable key overrides an inherited item. The tool never guesses an ambiguous project and never traverses RELATED_TO. Instead it returns structured related_project_suggestions so the Agent can ask whether to add exactly one related project to this read-only search; explicit human confirmation is required before any expansion.',
     inputSchema: objectSchema({
       projectPath: boundedString(4096),
+      personalProjectId: nullableStringSchema(),
       queries: arraySchema(shortText, { minItems: 1, maxItems: 10 }),
       limitPerQuery: integerSchema({ minimum: 1, maximum: 50 }),
       includeHistorical: booleanSchema(),
@@ -671,6 +687,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
       agentId: id
     }, ['personalSpaceId', 'agentId'])
   },
+  ...PROJECT_AGENT_MEMORY_DEFINITIONS,
   {
     name: 'delete_project_agent',
     title: 'WRITE · Archive one Agent identity',
@@ -759,6 +776,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
     description: 'View one task with lead/collaborator assignments, routing decision, effective model strategy, source client/session, event history, actual executor/model, routing rule, and fallback audit. Missing connected state is not synthesized.',
     inputSchema: objectSchema({
       personalSpaceId: id,
+      personalProjectId: id,
       taskId: id,
       includeEvents: booleanSchema()
     }, ['personalSpaceId', 'taskId'])
@@ -766,7 +784,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'record_project_agent_task_activity',
     title: 'WRITE · Record task activity',
-    description: 'Record one explicit task event, including real terminal activity and actual executor/model/client attribution. Terminal activity is the only source for per-Agent activity summaries.',
+    description: 'Record one explicit task event, including real terminal activity, actual executor/model/client attribution, and an optional source-labelled cumulative token snapshot for the concrete worker. Never estimate missing usage. Terminal activity is the only source for per-Agent activity summaries.',
     inputSchema: projectAgentTaskActivityInput
   },
   {
@@ -775,6 +793,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
     description: 'Return actual per-Agent daily completed/failed/cancelled activity and verifiable summaries. No history is fabricated and configured Agent status is not treated as running state.',
     inputSchema: objectSchema({
       personalSpaceId: id,
+      personalProjectId: id,
       agentId: id,
       fromDate: nullableStringSchema(),
       toDate: nullableStringSchema()
@@ -806,13 +825,13 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'get_project_agent_recruitment_policy',
     title: 'READ · Get recruitment policy',
-    description: 'Read the persisted recruitment confirmation mode. The default is automatic; require_confirmation creates only a pending recruitment event.',
+    description: 'Deprecated: read the legacy stored space setting, which does not control recruitment. Use get_project_agent_coordination_policy for the effective exact-project switches.',
     inputSchema: objectSchema({ personalSpaceId: id }, ['personalSpaceId'])
   },
   {
     name: 'update_project_agent_recruitment_policy',
     title: 'WRITE · Set recruitment policy',
-    description: 'Persist automatic or require_confirmation recruitment authorization. This changes policy only; it does not create an Agent or recruitment record by itself.',
+    description: 'Deprecated compatibility storage only; this does not change recruitment authorization. Use update_project_agent_coordination_policy with the exact project and askBeforeRecruitment instead. The response warns that this legacy value is not effective.',
     inputSchema: objectSchema({
       personalSpaceId: id,
       confirmationMode: recruitmentConfirmationMode

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

@@ -1,6 +1,10 @@
 import { ApplicationError } from '../app/application-error.js';
 
 const HANDLERS = Object.freeze({
+  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),
+  call_employee_tool: (app, input) => employeeService(app).callTool(input),
   begin_task_context: (app, input) => app.beginTaskContext(input),
   checkpoint_task_knowledge: (app, input) =>
     app.checkpointTaskKnowledge(input),
@@ -82,6 +86,8 @@ const HANDLERS = Object.freeze({
   replace_project_agent_assignment: (app, input) =>
     app.replaceProjectAgentAssignment(input),
   get_project_agent_context: (app, input) => app.getProjectAgentContext(input),
+  get_project_agent_memory: (app, input) => app.getProjectAgentMemory(input),
+  checkpoint_project_agent_memory: (app, input) => app.checkpointProjectAgentMemory(input),
   coordinate_project_agent_task: (app, input) =>
     app.coordinateProjectAgentTask(input),
   acquire_runtime_lease: (app, input) => app.acquireRuntimeLease(input),
@@ -171,6 +177,11 @@ const HANDLERS = Object.freeze({
   get_graphiti_status: (app) => app.getGraphitiStatus()
 });
 
+function employeeService(app) {
+  if (!app.employees) throw new Error('Employee runtime is unavailable');
+  return app.employees;
+}
+
 export function dispatchGraphTool(app, name, input) {
   const handler = HANDLERS[name];
   if (!handler) throw new Error(`Unknown agent tool: ${name}`);

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

@@ -14,8 +14,26 @@ const idempotencyKey = { ...boundedString(256), minLength: 8 };
 const dateTime = { ...boundedString(64), format: 'date-time' };
 const sourceApplication = {
   type: ['string', 'null'],
-  enum: ['codex', 'claude_code', 'cursor', 'kiro', 'other', null]
+  enum: ['codex', 'claude', 'claude_code', 'cursor', 'kiro', 'other', null]
 };
+const nullableTokenCount = {
+  ...integerSchema({ minimum: 0 }),
+  type: ['integer', 'null']
+};
+export const projectAgentTokenUsage = objectSchema({
+  source: enumSchema(['executor', 'host', 'dingdong']),
+  totalTokens: integerSchema({ minimum: 0 }),
+  inputTokens: nullableTokenCount,
+  outputTokens: nullableTokenCount,
+  cachedInputTokens: nullableTokenCount,
+  cacheWriteInputTokens: nullableTokenCount,
+  reasoningOutputTokens: nullableTokenCount
+}, ['source', 'totalTokens']);
+export const projectAgentWorkerRuntime = objectSchema({
+  application: enumSchema(['codex', 'claude', 'claude_code', 'cursor', 'kiro', 'other']),
+  sessionId: { ...nullableStringSchema(), minLength: 1, maxLength: 256 },
+  sessionUrl: { ...nullableStringSchema(), maxLength: 2048 }
+}, ['application']);
 
 const projectAgentStatus = enumSchema(['active', 'inactive', 'archived']);
 export const nullableProjectAgentStatus = {
@@ -43,8 +61,8 @@ export const projectAgentProfile = objectSchema({
   defaultModelStrategy: projectAgentModelStrategy,
   executorPolicy: projectAgentExecutorPolicy,
   allowedClients: arraySchema(
-    enumSchema(['codex', 'claude_code', 'cursor', 'kiro', 'other']),
-    { maxItems: 5 }
+    enumSchema(['codex', 'claude', 'claude_code', 'cursor', 'kiro', 'other']),
+    { maxItems: 6 }
   ),
   testSource: nullableStringSchema(),
   cleanupEligible: booleanSchema(),
@@ -116,6 +134,7 @@ export const projectAgentTaskSubmitInput = objectSchema({
   objective: boundedString(4096),
   workKind: boundedString(128),
   requiredCapabilities: arraySchema(boundedString(512), { maxItems: 16 }),
+  executorCapabilityHints: arraySchema(boundedString(512), { maxItems: 16 }),
   duration: projectAgentTaskDuration,
   staffingIntent: projectAgentStaffingIntent,
   leadAgentId: nullableStringSchema(),
@@ -140,6 +159,7 @@ export const projectAgentTaskCoordinateInput = objectSchema({
   objective: boundedString(4096),
   workKind: boundedString(128),
   requiredCapabilities: arraySchema(boundedString(512), { maxItems: 16 }),
+  executorCapabilityHints: arraySchema(boundedString(512), { maxItems: 16 }),
   duration: projectAgentTaskDuration,
   staffingIntent: projectAgentStaffingIntent,
   leadAgentId: nullableStringSchema(),
@@ -170,6 +190,11 @@ export const projectAgentTaskActivityInput = objectSchema({
   actorKind: enumSchema(['agent', 'human']),
   sourceApplication,
   sourceSessionId: nullableStringSchema(),
+  sourceSessionUrl: { ...nullableStringSchema(), maxLength: 2048 },
+  toolsUsed: {
+    ...arraySchema(boundedString(512), { maxItems: 32 }),
+    type: ['array', 'null']
+  },
   actualExecutor: nullableStringSchema(),
   actualModelProvider: nullableStringSchema(),
   actualModel: nullableStringSchema(),
@@ -183,7 +208,13 @@ export const projectAgentTaskActivityInput = objectSchema({
   workerId: { ...nullableStringSchema(), minLength: 1, maxLength: 128 },
   workerLabel: { ...nullableStringSchema(), minLength: 1, maxLength: 160 },
   workerOccupationEmoji: { ...nullableStringSchema(), minLength: 1, maxLength: 32 },
-  workerStatus: { ...projectAgentTaskStatus, type: ['string', 'null'] }
+  workerStatus: { ...projectAgentTaskStatus, type: ['string', 'null'] },
+  tokenUsage: { ...projectAgentTokenUsage, type: ['object', 'null'] },
+  workerRuntime: {
+    ...projectAgentWorkerRuntime,
+    type: ['object', 'null'],
+    description: 'Observed worker application and session, separate from the reporting host sourceApplication/sourceSessionId. Requires workerId and a participating Agent; never infer a session URL or actual model. Token usage is the latest cumulative snapshot for this worker session, not a sum across retries.'
+  }
 }, [
   'personalSpaceId', 'personalProjectId', 'taskId', 'idempotencyKey', 'status', 'summary'
 ]);

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

@@ -0,0 +1,36 @@
+import {
+  arraySchema, integerSchema, nullableStringSchema, objectSchema, stringSchema
+} from './schema.js';
+
+const id = { ...stringSchema(), minLength: 1, maxLength: 128 };
+const note = { ...stringSchema(), minLength: 1, maxLength: 1024 };
+export const workingMemorySchema = objectSchema({
+  summary: { ...stringSchema(), minLength: 1, maxLength: 4000 },
+  decisions: arraySchema(note, { maxItems: 12 }),
+  openThreads: arraySchema(note, { maxItems: 12 }),
+  nextActions: arraySchema(note, { maxItems: 12 })
+}, ['summary']);
+
+export const PROJECT_AGENT_MEMORY_DEFINITIONS = [
+  {
+    name: 'get_project_agent_memory',
+    title: 'READ · Restore private Agent working memory',
+    description: 'Read the latest versioned working notes for exactly one assigned Agent and project from the shared local Provider. This works across hosts connected to that Provider. Working notes are not confirmed facts or user instructions; do not load another Agent’s private memory.',
+    inputSchema: objectSchema({
+      personalSpaceId: id, personalProjectId: id, agentId: id,
+      limit: integerSchema({ minimum: 1, maximum: 10 })
+    }, ['personalSpaceId', 'personalProjectId', 'agentId'])
+  },
+  {
+    name: 'checkpoint_project_agent_memory',
+    title: 'WRITE · Checkpoint private Agent working memory',
+    description: 'Save a bounded, distilled working-context snapshot after meaningful work: summary, decisions, unresolved threads and next actions. Read the current revision first, preserve still-relevant notes, and use expectedRevision for optimistic concurrency. On conflict reload and merge; never blindly retry an overwrite. Reuse one idempotency key for the same logical write. Never store raw chats, credentials, unsupported facts, or another Agent’s memory. Shared confirmed facts belong in capture_session_knowledge. Honors disabled capture.',
+    inputSchema: objectSchema({
+      personalSpaceId: id, personalProjectId: id, agentId: id,
+      expectedRevision: integerSchema({ minimum: 0 }),
+      idempotencyKey: { ...stringSchema(), minLength: 8, maxLength: 256 },
+      memory: workingMemorySchema,
+      taskId: { ...nullableStringSchema(), minLength: 1, maxLength: 128 }
+    }, ['personalSpaceId', 'personalProjectId', 'agentId', 'expectedRevision', 'idempotencyKey', 'memory'])
+  }
+];

package/src/agent-tools.js

@@ -1,5 +1,6 @@
 import { GRAPH_TOOL_DEFINITIONS } from './agent-tools/graph-definitions.js';
 import { dispatchGraphTool } from './agent-tools/graph-handlers.js';
+import { runWithAgentRequestContext } from './app/agent-request-context.js';
 
 const TOOL_DEFINITIONS = [...GRAPH_TOOL_DEFINITIONS];
 
@@ -7,8 +8,11 @@ export function listAgentTools() {
   return clone(TOOL_DEFINITIONS);
 }
 
-export function callAgentTool(app, name, input = {}) {
-  return dispatchGraphTool(app, name, input);
+export function callAgentTool(app, name, input = {}, requestContext = null) {
+  return runWithAgentRequestContext(
+    requestContext,
+    () => dispatchGraphTool(app, name, input)
+  );
 }
 
 function clone(value) {