fuli-context 0.9.0-beta.2 → 0.10.0

package/src/agents/codex/token-usage.js

@@ -0,0 +1,235 @@
+import { constants } from 'node:fs';
+import { lstat, opendir, open } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+
+const MAX_HEADER_BYTES = 64 * 1024;
+const MAX_USAGE_TAIL_BYTES = 4 * 1024 * 1024;
+const MAX_CANDIDATE_FILES = 128;
+const MAX_DIRECTORY_ENTRIES = 2048;
+const MAX_DIRECTORY_DEPTH = 8;
+
+/**
+ * Codex's native JSONL session adapter. It returns only the latest cumulative
+ * token_count snapshot and never returns transcript records or text.
+ */
+export function createCodexTokenUsageResolver({
+  sessionsDirectory = undefined,
+  archivedSessionsDirectory = undefined,
+  codexSessionsDirectory = undefined,
+  codexArchivedSessionsDirectory = undefined,
+  codexHomeDirectory = undefined,
+  homeDirectory = undefined
+} = {}) {
+  const explicitSessionsDirectory = sessionsDirectory ?? codexSessionsDirectory;
+  const explicitArchivedSessionsDirectory =
+    archivedSessionsDirectory ?? codexArchivedSessionsDirectory;
+  const home = typeof homeDirectory === 'string' && homeDirectory
+    ? homeDirectory : defaultHomeDirectory();
+  const codexHome = typeof codexHomeDirectory === 'string' && codexHomeDirectory
+    ? codexHomeDirectory
+    : homeDirectory === undefined ? (defaultCodexHomeDirectory() ?? (home ? join(home, '.codex') : null))
+      : (home ? join(home, '.codex') : null);
+  const useDefaultRoots = explicitSessionsDirectory === undefined &&
+    explicitArchivedSessionsDirectory === undefined;
+  const roots = [
+    explicitSessionsDirectory ?? (useDefaultRoots && codexHome ? join(codexHome, 'sessions') : null),
+    explicitArchivedSessionsDirectory ??
+      (useDefaultRoots && codexHome ? join(codexHome, 'archived_sessions') : null)
+  ]
+    .filter((root, index, values) => typeof root === 'string' && root && values.indexOf(root) === index);
+  return {
+    resolve: (request) => resolveCodexTokenUsage(request, { roots })
+  };
+}
+
+export async function resolveCodexTokenUsage(request = {}, { roots } = {}) {
+  const sessionId = safeSessionId(request.sessionId ?? request.session_id);
+  if (!sessionId) return null;
+  const configuredRoots = Array.isArray(roots) ? roots : roots ? [roots] : null;
+  const directories = (configuredRoots ?? [
+    defaultCodexSessionsDirectory(),
+    defaultCodexArchivedSessionsDirectory()
+  ]).filter((root, index, values) => typeof root === 'string' && root && values.indexOf(root) === index);
+
+  let inspectedEntries = 0;
+  let candidates = 0;
+  for (const root of directories) {
+    const files = await matchingSessionFiles(root, sessionId, {
+      onEntry: () => { inspectedEntries += 1; },
+      get entriesInspected() { return inspectedEntries; },
+      get candidatesFound() { return candidates; },
+      addCandidate: () => { candidates += 1; }
+    });
+    for (const file of files) {
+      const usage = await readSessionUsage(file, sessionId);
+      if (usage) return usage;
+    }
+    if (inspectedEntries >= MAX_DIRECTORY_ENTRIES || candidates >= MAX_CANDIDATE_FILES) break;
+  }
+  return null;
+}
+
+async function matchingSessionFiles(root, sessionId, counters, depth = 0) {
+  if (depth > MAX_DIRECTORY_DEPTH || counters.entriesInspected >= MAX_DIRECTORY_ENTRIES ||
+      counters.candidatesFound >= MAX_CANDIDATE_FILES) return [];
+  let directory;
+  try {
+    const rootStat = await lstat(root);
+    if (!rootStat.isDirectory()) return [];
+    directory = await opendir(root);
+  } catch {
+    return [];
+  }
+
+  const files = [];
+  try {
+    for await (const entry of directory) {
+      counters.onEntry();
+      if (counters.entriesInspected > MAX_DIRECTORY_ENTRIES ||
+          counters.candidatesFound >= MAX_CANDIDATE_FILES) break;
+      const path = join(root, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await matchingSessionFiles(path, sessionId, counters, depth + 1));
+        continue;
+      }
+      if (!entry.isFile() || extname(entry.name) !== '.jsonl' ||
+          !basename(entry.name).includes(sessionId)) continue;
+      counters.addCandidate();
+      files.push(path);
+    }
+  } catch {
+    // A session directory can rotate while the host is running. An incomplete
+    // scan is an unavailable snapshot, never a reason to guess another file.
+  } finally {
+    await directory.close().catch(() => {});
+  }
+  return files;
+}
+
+async function readSessionUsage(filePath, sessionId) {
+  let file;
+  try {
+    file = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const stat = await file.stat();
+    if (!stat.isFile() || stat.size <= 0) return null;
+
+    const header = await readBytes(file, Math.min(MAX_HEADER_BYTES, stat.size), 0);
+    const firstLineEnd = header.indexOf(10);
+    if (firstLineEnd < 0 || !isSessionHeader(header.subarray(0, firstLineEnd), sessionId)) {
+      return null;
+    }
+
+    const start = Math.max(0, stat.size - MAX_USAGE_TAIL_BYTES);
+    const tail = await readBytes(file, stat.size - start, start);
+    let firstLine = 0;
+    if (start > 0) {
+      const previous = await readBytes(file, 1, start - 1);
+      if (previous[0] !== 10) {
+        firstLine = tail.indexOf(10) + 1;
+        if (firstLine <= 0) return null;
+      }
+    }
+    return latestTokenUsage(tail.subarray(firstLine));
+  } catch {
+    return null;
+  } finally {
+    await file?.close().catch(() => {});
+  }
+}
+
+async function readBytes(file, length, position) {
+  const buffer = Buffer.allocUnsafe(length);
+  let offset = 0;
+  while (offset < length) {
+    const result = await file.read(buffer, offset, length - offset, position + offset);
+    if (!result.bytesRead) break;
+    offset += result.bytesRead;
+  }
+  return offset === length ? buffer : buffer.subarray(0, offset);
+}
+
+function isSessionHeader(bytes, sessionId) {
+  try {
+    const record = JSON.parse(bytes.toString('utf8'));
+    return record?.type === 'session_meta' && record.payload?.id === sessionId;
+  } catch {
+    return false;
+  }
+}
+
+function latestTokenUsage(bytes) {
+  let latest = null;
+  const text = bytes.toString('utf8');
+  let offset = 0;
+  while (offset < text.length) {
+    const end = text.indexOf('\n', offset);
+    const line = text.slice(offset, end < 0 ? text.length : end).trim();
+    if (line.includes('"token_count"') && line.includes('"total_token_usage"')) {
+      try {
+        const record = JSON.parse(line);
+        const total = record?.payload?.info?.total_token_usage;
+        if (record?.type === 'event_msg' && record.payload?.type === 'token_count') {
+          const totalTokens = nonNegativeInteger(total?.total_tokens);
+          if (totalTokens !== null) {
+            latest = {
+              source: 'host',
+              totalTokens,
+              inputTokens: optionalNonNegativeInteger(total?.input_tokens),
+              outputTokens: optionalNonNegativeInteger(total?.output_tokens),
+              cachedInputTokens: optionalNonNegativeInteger(total?.cached_input_tokens),
+              cacheWriteInputTokens: optionalNonNegativeInteger(total?.cache_write_input_tokens),
+              reasoningOutputTokens: optionalNonNegativeInteger(total?.reasoning_output_tokens)
+            };
+          }
+        }
+      } catch {
+        // Ignore malformed native records and continue to later snapshots.
+      }
+    }
+    if (end < 0) break;
+    offset = end + 1;
+  }
+  return latest;
+}
+
+function optionalNonNegativeInteger(value) {
+  return value === null || value === undefined ? null : nonNegativeInteger(value);
+}
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function safeSessionId(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim();
+  if (!normalized || normalized.length > 256 || normalized.includes('..') ||
+      !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(normalized)) return null;
+  return normalized;
+}
+
+function defaultCodexSessionsDirectory() {
+  const codexHome = defaultCodexRootDirectory();
+  return codexHome ? join(codexHome, 'sessions') : null;
+}
+
+function defaultCodexArchivedSessionsDirectory() {
+  const codexHome = defaultCodexRootDirectory();
+  return codexHome ? join(codexHome, 'archived_sessions') : null;
+}
+
+function defaultCodexRootDirectory() {
+  const configured = defaultCodexHomeDirectory();
+  if (configured) return configured;
+  const home = defaultHomeDirectory();
+  return home ? join(home, '.codex') : null;
+}
+
+function defaultCodexHomeDirectory() {
+  const value = process.env.CODEX_HOME;
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function defaultHomeDirectory() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? null;
+}

package/src/agents/cursor/lifecycle-hook.js

@@ -6,7 +6,6 @@ import { callAgentTool } from '../../agent-tools.js';
 import { createRuntimeLeaseClient } from '../../adaptive-runtime/lease-client.js';
 import { openFederatedGraphApplication } from '../../graphiti/federated-application.js';
 import { resolveGraphRuntimeOptions } from '../../graphiti/runtime-config.js';
-import { boundedHookMessage } from '../lifecycle-message.js';
 
 const EVENTS = new Set(['sessionStart', 'beforeSubmitPrompt', 'stop']);
 
@@ -18,14 +17,9 @@ export async function cursorLifecycleOutput(event, input, invoke) {
   }
   const source = { sourceApplication: 'cursor', sourceSessionId: sessionId };
   if (event === 'stop') {
-    // One host-counted continuation at most; never restart cancelled/error turns.
-    if (input.status !== 'completed' || (input.loop_count ?? 0) >= 1) return {};
-    const check = await invoke('verify_task_checkpoint', { sessionId, ...source });
-    const notice = '\nIf this mode is read-only or checkpoint writes are denied, state that the checkpoint was not saved and do not retry. This is the only checkpoint continuation.';
-    const reason = boundedHookMessage(check.reason, { maxBytes: 8_000 - Buffer.byteLength(notice, 'utf8') });
-    return check.status === 'checkpoint_required' && reason.trim()
-      ? { followup_message: reason + notice }
-      : {};
+    // Cursor has no advisory Stop output. A followup_message would start
+    // another model turn, so pending checkpoints remain available through MCP.
+    return {};
   }
   const roots = input.workspace_roots;
   if (!Array.isArray(roots) || roots.length !== 1 || typeof roots[0] !== 'string') {
@@ -50,6 +44,7 @@ export async function cursorLifecycleOutput(event, input, invoke) {
       + `get_collaboration_preferences with sessionId=${JSON.stringify(sessionId)}, `
       + 'projectPath=current working directory and taskPrompt=current request '
       + 'to restore the role selected for that exact prompt and its latest project memory. '
+      + 'Every final reply MUST include this task’s agent_receipt.markdown unchanged exactly once, including greetings and capture-disabled tasks. '
       + 'Before finishing, call '
       + `verify_task_checkpoint with sessionId=${JSON.stringify(sessionId)}; use its task_context_token `
       + 'to checkpoint_task_knowledge, including agentMemory if the role context changed. '

package/src/agents/identity-receipt.js

@@ -14,11 +14,18 @@ export function agentContinuation(projectId, agentId, conversationId = null) {
 
 export function taskAgentReceipt(application, { projectId, agentId, name = null,
   sourceApplication = null, workStatus = null, conversationId = null, persistence = null }) {
-  return { owner: { agent_id: agentId, name,
-    profile_url: agentProfileUrl(application, agentId), source_application: sourceApplication },
+  const owner = agentId ? { agent_id: agentId, name,
+    profile_url: agentProfileUrl(application, agentId), source_application: sourceApplication } : null;
+  const label = String(name?.trim() || agentId).replace(/[\r\n\t]+/g, ' ')
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+    .replace(/[\\`*_{}\[\]()!|]/g, '\\$&');
+  const markdown = owner
+    ? `FULI Agent：[${label}](<${owner.profile_url.replace(/[<>\s]/g, encodeURIComponent)}>)`
+    : 'FULI Agent：未选定';
+  return { required: true, markdown, owner,
     personal_project_id: projectId, work_status: workStatus, persistence,
-    continuation: agentContinuation(projectId, agentId, conversationId),
-    guidance: 'Finish with the named owner and profile link, truthful work/memory status and continuation. Add only actually used collaboration_receipt participants (for example Jefa); tools and configured peers are not independent model workers.' };
+    continuation: owner ? agentContinuation(projectId, agentId, conversationId) : null,
+    guidance: 'MUST include agent_receipt.markdown unchanged exactly once in every final user-visible reply, including greetings, status and errors, even when capture is disabled or nothing is retained. Use this task’s receipt; never invent an owner. Report only truthful work/memory status and actually used collaboration_receipt participants; tools and configured peers are not independent model workers.' };
 }
 
 export function employeeCollaborationReceipt(application, context, { tool, permission, sourceApplication }) {

package/src/agents/token-usage-resolver.js

@@ -0,0 +1,147 @@
+import { createCodexTokenUsageResolver } from './codex/token-usage.js';
+
+const TOKEN_USAGE_SOURCES = new Set(['executor', 'host', 'dingdong']);
+const DEFAULT_RESOLVER = createAgentTokenUsageResolver();
+
+/**
+ * Resolve one exact worker/session identity through the runtime adapter port.
+ *
+ * A worker runtime is authoritative when present. Its session is never
+ * replaced with the reporting host session. A reporting host session is used
+ * only when no worker runtime was supplied, which covers direct host activity.
+ */
+export function resolveAgentSession(input = {}) {
+  const workerRuntime = input.workerRuntime ?? input.worker_runtime;
+  if (workerRuntime !== undefined && workerRuntime !== null) {
+    if (!workerRuntime || typeof workerRuntime !== 'object' || Array.isArray(workerRuntime)) {
+      return null;
+    }
+    const application = workerRuntime.application;
+    const sessionId = safeSessionId(workerRuntime.sessionId ?? workerRuntime.session_id);
+    if (!validApplication(application) || !sessionId) return null;
+    return {
+      application,
+      sessionId,
+      sourceApplication: input.sourceApplication ?? input.source_application ?? null,
+      sourceSessionId: input.sourceSessionId ?? input.source_session_id ?? null,
+      scope: 'worker'
+    };
+  }
+
+  if (hasWorkerMetadata(input)) return null;
+  const application = input.sourceApplication ?? input.source_application;
+  const sessionId = safeSessionId(input.sourceSessionId ?? input.source_session_id);
+  if (!validApplication(application) || !sessionId) return null;
+  return {
+    application,
+    sessionId,
+    sourceApplication: application,
+    sourceSessionId: sessionId,
+    scope: 'host'
+  };
+}
+
+/**
+ * Shared adapter port for exact session token usage.
+ *
+ * Adapters receive only the selected session identity and return a cumulative
+ * snapshot or null. They must not return transcript content.
+ */
+export function createAgentTokenUsageResolver({ adapters } = {}) {
+  const registry = adapters instanceof Map
+    ? adapters
+    : new Map(Object.entries(adapters ?? {
+      codex: createCodexTokenUsageResolver()
+    }));
+  return {
+    async resolve(input = {}) {
+      const session = resolveAgentSession(input);
+      if (!session) return null;
+      const adapter = registry.get(session.application);
+      const resolve = typeof adapter === 'function' ? adapter : adapter?.resolve;
+      if (typeof resolve !== 'function') return null;
+      try {
+        return normalizeTokenUsage(await resolve.call(adapter, session));
+      } catch {
+        // Usage collection is best-effort. It must not prevent the host from
+        // recording otherwise valid worker activity.
+        return null;
+      }
+    }
+  };
+}
+
+export async function enrichProjectAgentTaskActivity(input = {}, resolver = DEFAULT_RESOLVER) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return input;
+  const actorKind = input.actorKind ?? input.actor_kind;
+  if (actorKind === 'human') return input;
+  // Null is an explicit report (including an explicit zero inside the object),
+  // so only an omitted value is eligible for automatic collection.
+  const explicitTokenUsage = (Object.hasOwn(input, 'tokenUsage') && input.tokenUsage !== undefined) ||
+    (Object.hasOwn(input, 'token_usage') && input.token_usage !== undefined);
+  if (explicitTokenUsage) return input;
+
+  const resolve = typeof resolver === 'function' ? resolver : resolver?.resolve;
+  if (typeof resolve !== 'function') return input;
+  try {
+    const tokenUsage = normalizeTokenUsage(await resolve.call(resolver, input));
+    return tokenUsage ? { ...input, tokenUsage } : input;
+  } catch {
+    return input;
+  }
+}
+
+export async function resolveProjectAgentTaskActivityTokenUsage(input, resolver = DEFAULT_RESOLVER) {
+  const enriched = await enrichProjectAgentTaskActivity(input, resolver);
+  if (!enriched || typeof enriched !== 'object') return null;
+  return enriched.tokenUsage !== undefined ? enriched.tokenUsage : enriched.token_usage ?? null;
+}
+
+function normalizeTokenUsage(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const source = value.source;
+  const totalTokens = nonNegativeInteger(value.totalTokens ?? value.total_tokens);
+  if (!TOKEN_USAGE_SOURCES.has(source) || totalTokens === null) return null;
+  return {
+    source,
+    totalTokens,
+    inputTokens: optionalNonNegativeInteger(value.inputTokens ?? value.input_tokens),
+    outputTokens: optionalNonNegativeInteger(value.outputTokens ?? value.output_tokens),
+    cachedInputTokens: optionalNonNegativeInteger(value.cachedInputTokens ?? value.cached_input_tokens),
+    cacheWriteInputTokens: optionalNonNegativeInteger(
+      value.cacheWriteInputTokens ?? value.cache_write_input_tokens
+    ),
+    reasoningOutputTokens: optionalNonNegativeInteger(
+      value.reasoningOutputTokens ?? value.reasoning_output_tokens
+    )
+  };
+}
+
+function optionalNonNegativeInteger(value) {
+  return value === null || value === undefined ? null : nonNegativeInteger(value);
+}
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function validApplication(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 64;
+}
+
+function hasWorkerMetadata(input) {
+  return [
+    input.workerId ?? input.worker_id,
+    input.workerLabel ?? input.worker_label,
+    input.workerStatus ?? input.worker_status,
+    input.workerOccupationEmoji ?? input.worker_occupation_emoji
+  ].some((value) => value !== undefined && value !== null && value !== '');
+}
+
+function safeSessionId(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim();
+  if (!normalized || normalized.length > 256 || normalized.includes('..') ||
+      !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(normalized)) return null;
+  return normalized;
+}

package/src/conversations/current-task-lookup.js

@@ -0,0 +1,40 @@
+import { ProviderRequestError } from '../graphiti/provider-client.js';
+
+// Only this first, read-only lookup can be deferred before a scope is known.
+// Each real HTTP attempt is bounded; writes and later handoff operations are
+// never retried here or mistaken for a compatibility failure.
+export async function lookupTranscriptTask(application, input, sourceApplication) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const task = await application.personal.currentTaskContext({
+        personal_space_id: application.config.personal.spaceId,
+        session_id: input.session_id, source_application: sourceApplication
+      }, { timeoutMs: 1500 });
+      if (task !== null && (!task || typeof task !== 'object' || Array.isArray(task)
+        || typeof task.token !== 'string' || !task.token
+        || !Object.hasOwn(task, 'project_agent_id')
+        || (task.project_agent_id !== null && (typeof task.project_agent_id !== 'string'
+          || !task.project_agent_id || typeof task.personal_project_id !== 'string' || !task.personal_project_id))
+        || (task.session_id !== undefined && task.session_id !== input.session_id)
+        || (task.source_application !== undefined && task.source_application !== sourceApplication)
+        || (task.personal_space_id !== undefined && task.personal_space_id !== application.config.personal.spaceId))) {
+        throw new ProviderRequestError('Current task response does not match its requested scope', { code: 'provider_invalid_response' });
+      }
+      return { task };
+    } catch (error) {
+      if (!(error instanceof ProviderRequestError)) throw error;
+      if (error.status === 404 && error.code === 'provider_error'
+        && error.diagnostic?.status === 404 && error.diagnostic.detail === 'Not Found') {
+        return { failure: { status: 'unsupported', entryBlocked: true,
+          code: 'current_task_endpoint_unavailable',
+          reason: 'Visible transcript synchronization is not available on this Fuli provider version' } };
+      }
+      const transient = ['provider_unavailable', 'provider_timeout'].includes(error.code)
+        || (error.code === 'provider_http_5xx' && [502, 503, 504].includes(error.status));
+      if (!transient) throw error;
+      if (attempt === 1) return { failure: { status: 'unsaved', entryBlocked: true,
+        code: 'current_task_lookup_unavailable',
+        reason: 'Visible transcript synchronization is temporarily unavailable after bounded retries; native history remains available for a later verified task entry' } };
+    }
+  }
+}

package/src/conversations/sync-transcript.js

@@ -1,5 +1,6 @@
 import { initialTranscriptBoundary, readTranscriptBatch } from './transcript-reader.js';
 import { transcriptDigest } from './transcript-guard.js';
+import { lookupTranscriptTask } from './current-task-lookup.js';
 
 const pending = reason => ({ status: 'partial', entryBlocked: true, reason });
 const retryReason = 'Transcript handoff is pending. Retry task entry to continue its saved progress; no new Agent context was supplied';
@@ -9,8 +10,9 @@ export async function syncConversationTranscript(application, input, sourceAppli
   if (!input?.transcript_path) return { status: 'partial', reason: 'Host did not supply a visible transcript' };
   let committedPages = 0;
   try {
-    const task = await application.personal.currentTaskContext({ personal_space_id: application.config.personal.spaceId,
-      session_id: input.session_id, source_application: sourceApplication });
+    const lookup = await lookupTranscriptTask(application, input, sourceApplication);
+    if (lookup.failure) return lookup.failure;
+    const task = lookup.task;
     if (!task?.project_agent_id) return guard?.value ? pending(retryReason) : { status: 'unassigned' };
     const scope = { personal_space_id: application.config.personal.spaceId, personal_project_id: task.personal_project_id,
       agent_id: task.project_agent_id, source_application: sourceApplication };

package/src/graphiti/federated-application.js

@@ -92,6 +92,7 @@ export function openFederatedGraphApplication({
   config,
   capturePolicyStore,
   agentAccessPolicyStore,
+  tokenUsageResolver,
   fetchImpl = globalThis.fetch,
   env = process.env
 }) {
@@ -105,6 +106,7 @@ export function openFederatedGraphApplication({
     agentAccessPolicyStore: agentAccessPolicyStore ?? new AgentAccessPolicyStore(
       agentAccessPolicyPathForRuntime(runtimeConfigPath)
     ),
+    tokenUsageResolver,
     consoleUrl: sourceConsoleUrl(runtimeConfigPath),
     providerRequestTimeoutMs: providerRequestTimeoutFromEnv(env)
   });
@@ -140,7 +142,8 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     consoleUrl = sourceConsoleUrl(null),
     projectPathResolver = resolvePersonalProjectPath,
     taskContextRegistry = null,
-    providerRequestTimeoutMs = undefined
+    providerRequestTimeoutMs = undefined,
+    tokenUsageResolver = undefined
   } = {}) {
     super();
     this.graphiti = true;
@@ -149,6 +152,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     this.agentAccessPolicyStore = agentAccessPolicyStore;
     this.consoleUrl = consoleUrl;
     this.projectPathResolver = projectPathResolver;
+    this.tokenUsageResolver = tokenUsageResolver;
     this.personal = new GraphitiProviderClient({
       baseUrl: config.personal.providerUrl,
       accessToken: config.personal.accessToken,
@@ -285,6 +289,7 @@ export class FederatedGraphApplication extends ProjectAgentControlPlaneApplicati
     return {
       status: 'generated',
       ...skill,
+      agent_receipt: context.agent_receipt,
       ...(context.task_knowledge_recall
         ? { task_knowledge_recall: context.task_knowledge_recall }
         : {}),

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

@@ -380,7 +380,7 @@ export function providerProjectAgentTaskActivity(input) {
   }
   if (hasAny(input, ['tokenUsage', 'token_usage'])) {
     result.token_usage = providerProjectAgentTokenUsage(
-      input.tokenUsage ?? input.token_usage
+      input.tokenUsage !== undefined ? input.tokenUsage : input.token_usage
     );
   }
   if (hasAny(input, ['workerRuntime', 'worker_runtime'])) {

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

@@ -1,5 +1,6 @@
 import { loadProjectAgentContinuity } from './project-agent-task-entry.js';
 import { resolveCoordinationScope, scopedTaskIdempotencyKey } from './temporary-project-scope.js';
+import { enrichProjectAgentTaskActivity } from '../agents/token-usage-resolver.js';
 import {
   executorActualReportRecord,
   executorRecord,
@@ -306,8 +307,12 @@ export async function viewProjectAgentTask(application, input) {
 }
 
 export async function recordProjectAgentTaskActivity(application, input) {
+  const activity = await enrichProjectAgentTaskActivity(
+    input,
+    application.tokenUsageResolver
+  );
   const value = await application.personal.recordProjectAgentTaskActivity(
-    providerProjectAgentTaskActivity(input)
+    providerProjectAgentTaskActivity(activity)
   );
   return value?.task ? projectAgentTaskRecord(value.task) : projectAgentTaskRecord(value);
 }

package/src/graphiti/provider-client.js

@@ -72,8 +72,10 @@ export class GraphitiProviderClient {
       method: operation === 'policy' ? 'PUT' : 'POST', body: input
     });
   }
-  currentTaskContext(input) {
-    return this.#request(`/v1/task-context-sessions/current?${new URLSearchParams(input)}`);
+  currentTaskContext(input, { timeoutMs = this.requestTimeoutMs } = {}) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new TypeError('Current task timeout must be a positive safe integer');
+    return this.#request(`/v1/task-context-sessions/current?${new URLSearchParams(input)}`,
+      { timeoutMs: Math.min(timeoutMs, this.requestTimeoutMs) });
   }
   health() { return this.#request('/health', { authenticated: false }); }
   listSpaces() { return this.#request('/v1/spaces'); }
@@ -695,7 +697,8 @@ export class GraphitiProviderClient {
     method = 'GET',
     body,
     authenticated = true,
-    workflowObservation = false
+    workflowObservation = false,
+    timeoutMs = this.requestTimeoutMs
   } = {}) {
     const headers = { accept: 'application/json' };
     if (authenticated) headers.authorization = `Bearer ${this.accessToken}`;
@@ -708,7 +711,7 @@ export class GraphitiProviderClient {
     const timeout = setTimeout(() => {
       timedOut = true;
       controller.abort(new Error('Graphiti provider request timed out'));
-    }, this.requestTimeoutMs);
+    }, timeoutMs);
     const callerSignal = activeAgentRequestSignal();
     const signal = callerSignal
       ? AbortSignal.any([controller.signal, callerSignal])

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

@@ -36,15 +36,14 @@ export async function taskEntryPreferences(application, projectResolution, {
       sourceApplication, sourceSessionId, sessionId })
     : null;
   const managedPreferences = management ? { ...preferences, project_management_context: management } : preferences;
-  if (!selection) return managedPreferences;
-  const context = selection.agent ? await loadProjectAgentContinuity(application, {
+  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
-    }) } : {}) };
+  return { ...managedPreferences, ...(context ? { project_agent_context: context } : {}),
+    agent_receipt: taskAgentReceipt(application, {
+      projectId: projectResolution.personalProjectId, agentId: selection?.agent?.agentId ?? null,
+      name: context?.role?.name, sourceApplication
+    }) };
 }

package/src/http/static-handler.js

@@ -78,5 +78,7 @@ function faviconFilePath() {
 }
 
 function shouldServeApplication(pathname) {
-  return extname(pathname) === '' && !pathname.startsWith('/api/');
+  // Agent identities (for example employee.jefa) are route parameters, not assets.
+  const agentProfile = /^\/agents\/[^/]+\/[^/]+\/?$/.test(pathname);
+  return !pathname.startsWith('/api/') && (agentProfile || extname(pathname) === '');
 }