@hybridaione/hybridclaw 0.1.21 → 0.1.24

package/src/gateway-service.ts

@@ -50,16 +50,19 @@ import {
 } from './gateway-types.js';
 import type {
   ArtifactMetadata,
+  ChatMessage,
   DelegationSideEffect,
   DelegationTaskSpec,
   ScheduledTask,
   StoredMessage,
+  TokenUsageStats,
   ToolProgressEvent,
 } from './types.js';
 import { ensureBootstrapFiles } from './workspace.js';
 import { buildConversationContext } from './conversation.js';
 import { runIsolatedScheduledTask } from './scheduled-task-runner.js';
 import { delegationQueueStatus, enqueueDelegation } from './delegation-manager.js';
+import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
 
 const BOT_CACHE_TTL = 300_000; // 5 minutes
 const MAX_HISTORY_MESSAGES = 40;
@@ -166,6 +169,7 @@ export interface GatewayChatRequest {
   chatbotId?: GatewayChatRequestBody['chatbotId'];
   model?: GatewayChatRequestBody['model'];
   enableRag?: GatewayChatRequestBody['enableRag'];
+  onTextDelta?: (delta: string) => void;
   onToolProgress?: (event: ToolProgressEvent) => void;
   onProactiveMessage?: (message: ProactiveMessagePayload) => void | Promise<void>;
   abortSignal?: AbortSignal;
@@ -210,6 +214,49 @@ function plainCommand(text: string): GatewayCommandResult {
   return { kind: 'plain', text };
 }
 
+function buildTokenUsageAuditPayload(
+  messages: ChatMessage[],
+  resultText: string | null | undefined,
+  tokenUsage?: TokenUsageStats,
+): Record<string, number | boolean> {
+  const promptChars = messages.reduce((total, message) => {
+    const content = typeof message.content === 'string' ? message.content : '';
+    return total + content.length;
+  }, 0);
+  const completionChars = (resultText || '').length;
+
+  const fallbackEstimatedPromptTokens = estimateTokenCountFromMessages(messages);
+  const fallbackEstimatedCompletionTokens = estimateTokenCountFromText(resultText || '');
+  const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || fallbackEstimatedPromptTokens;
+  const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || fallbackEstimatedCompletionTokens;
+  const estimatedTotalTokens =
+    tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+
+  const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
+  const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
+  const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
+  const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
+  const promptTokens = apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens;
+  const completionTokens = apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens;
+  const totalTokens = apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens;
+
+  return {
+    modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
+    promptChars,
+    completionChars,
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    estimatedPromptTokens,
+    estimatedCompletionTokens,
+    estimatedTotalTokens,
+    apiUsageAvailable,
+    apiPromptTokens,
+    apiCompletionTokens,
+    apiTotalTokens,
+  };
+}
+
 export function getGatewayStatus(): GatewayStatus {
   return {
     status: 'ok',
@@ -811,11 +858,31 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
   ensureBootstrapFiles(agentId);
 
   const history = getConversationHistory(req.sessionId, MAX_HISTORY_MESSAGES);
-  const { messages, skills } = buildConversationContext({
+  const { messages, skills, historyStats } = buildConversationContext({
     agentId,
     sessionSummary: session.session_summary,
     history,
   });
+  const historyStart = messages.length > 0 && messages[0].role === 'system' ? 1 : 0;
+  recordAuditEvent({
+    sessionId: req.sessionId,
+    runId,
+    event: {
+      type: 'context.optimization',
+      historyMessagesOriginal: historyStats.originalCount,
+      historyMessagesIncluded: historyStats.includedCount,
+      historyMessagesDropped: historyStats.droppedCount,
+      historyCharsOriginal: historyStats.originalChars,
+      historyCharsPreBudget: historyStats.preBudgetChars,
+      historyCharsIncluded: historyStats.includedChars,
+      historyCharsDropped: historyStats.droppedChars,
+      historyMaxChars: historyStats.maxTotalChars,
+      historyMaxMessageChars: historyStats.maxMessageChars,
+      perMessageTruncatedCount: historyStats.perMessageTruncatedCount,
+      middleCompressionApplied: historyStats.middleCompressionApplied,
+      historyEstimatedTokens: estimateTokenCountFromMessages(messages.slice(historyStart)),
+    },
+  });
   messages.push({
     role: 'user',
     content: expandSkillInvocation(req.content, skills),
@@ -833,6 +900,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
       req.channelId,
       scheduledTasks,
       undefined,
+      req.onTextDelta,
       req.onToolProgress,
       req.abortSignal,
     );
@@ -851,6 +919,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
         model,
         durationMs: Date.now() - startedAt,
         toolCallCount: toolExecutions.length,
+        ...buildTokenUsageAuditPayload(messages, output.result, output.tokenUsage),
       },
     });
 
@@ -944,6 +1013,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
         toolsUsed: output.toolsUsed || [],
         artifacts: output.artifacts,
         toolExecutions,
+        tokenUsage: output.tokenUsage,
         error: errorMessage,
       };
     }
@@ -1009,6 +1079,7 @@ export async function handleGatewayMessage(req: GatewayChatRequest): Promise<Gat
       toolsUsed: output.toolsUsed || [],
       artifacts: output.artifacts,
       toolExecutions,
+      tokenUsage: output.tokenUsage,
     };
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);

package/src/gateway-types.ts

@@ -1,3 +1,5 @@
+import type { TokenUsageStats } from './types.js';
+
 export interface GatewayCommandResult {
   kind: 'plain' | 'info' | 'error';
   title?: string;
@@ -19,6 +21,7 @@ export interface GatewayChatResult {
     result: string;
     durationMs: number;
   }>;
+  tokenUsage?: TokenUsageStats;
   error?: string;
 }
 
@@ -30,12 +33,20 @@ export interface GatewayChatToolProgressEvent {
   durationMs?: number;
 }
 
+export interface GatewayChatTextDeltaEvent {
+  type: 'text';
+  delta: string;
+}
+
 export interface GatewayChatStreamResultEvent {
   type: 'result';
   result: GatewayChatResult;
 }
 
-export type GatewayChatStreamEvent = GatewayChatToolProgressEvent | GatewayChatStreamResultEvent;
+export type GatewayChatStreamEvent =
+  | GatewayChatToolProgressEvent
+  | GatewayChatTextDeltaEvent
+  | GatewayChatStreamResultEvent;
 
 export interface GatewayChatRequestBody {
   sessionId: string;

package/src/gateway.ts

@@ -66,6 +66,53 @@ function buildArtifactAttachments(
   return attachments;
 }
 
+function normalizePathForMatch(value: string): string {
+  return value.replace(/\\/g, '/').toLowerCase();
+}
+
+function simplifyImageAttachmentNarration(
+  text: string,
+  artifacts?: ArtifactMetadata[],
+): string {
+  if (!text.trim() || !artifacts || artifacts.length === 0) return text;
+
+  const imageArtifacts = artifacts.filter((artifact) => artifact.mimeType.startsWith('image/'));
+  if (imageArtifacts.length === 0) return text;
+
+  const pathHints = new Set<string>();
+  for (const artifact of imageArtifacts) {
+    const normalizedPath = normalizePathForMatch(artifact.path);
+    const filename = normalizePathForMatch(artifact.filename);
+    if (normalizedPath) pathHints.add(normalizedPath);
+    if (filename) pathHints.add(filename);
+    if (filename) pathHints.add(`/workspace/.browser-artifacts/${filename}`);
+    if (filename) pathHints.add(`.browser-artifacts/${filename}`);
+  }
+
+  const pathishLine = /(^`?\s*(\.\/|\/|~\/|[a-zA-Z]:\\|\.browser-artifacts\/))|([\\/][^\\/\s]+\.[a-zA-Z0-9]{1,8})/;
+  const locationNarration = /(workspace|saved to|find it at|located at|liegt unter|pfad|path)/i;
+
+  let removedPathNarration = false;
+  const keptLines: string[] = [];
+  for (const line of text.split('\n')) {
+    const normalizedLine = normalizePathForMatch(line);
+    const mentionsArtifact = Array.from(pathHints).some((hint) => normalizedLine.includes(hint));
+    const isPathLine = pathishLine.test(line.trim());
+    const isLocationNarration = locationNarration.test(line);
+    if (mentionsArtifact && (isPathLine || isLocationNarration)) {
+      removedPathNarration = true;
+      continue;
+    }
+    keptLines.push(line);
+  }
+
+  if (!removedPathNarration) return text;
+
+  const cleaned = keptLines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  if (cleaned) return cleaned;
+  return imageArtifacts.length === 1 ? 'Here it is.' : 'Here they are.';
+}
+
 async function deliverProactiveMessage(
   channelId: string,
   text: string,
@@ -151,7 +198,8 @@ async function startDiscordIntegration(): Promise<void> {
       userId: string,
       username: string,
       content: string,
-      reply: ReplyFn,
+      _reply: ReplyFn,
+      context,
     ) => {
       try {
         const result = await handleGatewayMessage({
@@ -161,20 +209,33 @@ async function startDiscordIntegration(): Promise<void> {
           userId,
           username,
           content,
+          onTextDelta: (delta) => {
+            void context.stream.append(delta);
+          },
           onProactiveMessage: async (message) => {
             await deliverProactiveMessage(channelId, message.text, 'delegate', message.artifacts);
           },
+          abortSignal: context.abortSignal,
         });
         if (result.status === 'error') {
-          await reply(formatError('Agent Error', result.error || 'Unknown error'));
+          const errorText = formatError('Agent Error', result.error || 'Unknown error');
+          await context.stream.fail(errorText);
           return;
         }
         const attachments = buildArtifactAttachments(result.artifacts);
-        await reply(buildResponseText(result.result || 'No response from agent.', result.toolsUsed), attachments);
+        const userText = simplifyImageAttachmentNarration(
+          result.result || 'No response from agent.',
+          result.artifacts,
+        );
+        await context.stream.finalize(
+          buildResponseText(userText, result.toolsUsed),
+          attachments,
+        );
       } catch (error) {
         const text = error instanceof Error ? error.message : String(error);
         logger.error({ error, sessionId, channelId }, 'Discord message handling failed');
-        await reply(formatError('Gateway Error', text));
+        const errorText = formatError('Gateway Error', text);
+        await context.stream.fail(errorText);
       }
     },
     async (

package/src/health.ts

@@ -146,9 +146,17 @@ async function handleApiChatStream(
     });
   };
 
+  const onTextDelta = (delta: string): void => {
+    sendEvent({
+      type: 'text',
+      delta,
+    });
+  };
+
   try {
     const result = await handleGatewayMessage({
       ...chatRequest,
+      onTextDelta,
       onToolProgress,
     });
     sendEvent({ type: 'result', result });

package/src/heartbeat.ts

@@ -12,6 +12,7 @@ import { appendSessionTranscript } from './session-transcripts.js';
 import { buildConversationContext } from './conversation.js';
 import { isWithinActiveHours, proactiveWindowLabel } from './proactive-policy.js';
 import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent } from './audit-events.js';
+import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
 
 const HEARTBEAT_PROMPT =
   '[Heartbeat poll] Check HEARTBEAT.md for periodic tasks. If nothing needs attention, reply HEARTBEAT_OK.';
@@ -136,6 +137,14 @@ export function startHeartbeat(
         runId,
         toolExecutions: output.toolExecutions || [],
       });
+      const tokenUsage = output.tokenUsage;
+      const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || estimateTokenCountFromMessages(messages);
+      const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || estimateTokenCountFromText(output.result || '');
+      const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+      const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
+      const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
+      const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
+      const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
       recordAuditEvent({
         sessionId,
         runId,
@@ -145,6 +154,17 @@ export function startHeartbeat(
           model: HYBRIDAI_MODEL,
           durationMs: Date.now() - startedAt,
           toolCallCount: (output.toolExecutions || []).length,
+          modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
+          promptTokens: apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens,
+          completionTokens: apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens,
+          totalTokens: apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens,
+          estimatedPromptTokens,
+          estimatedCompletionTokens,
+          estimatedTotalTokens,
+          apiUsageAvailable,
+          apiPromptTokens,
+          apiCompletionTokens,
+          apiTotalTokens,
         },
       });
       processSideEffects(output, sessionId, heartbeatChannelId);

package/src/observability-ingest.ts

@@ -222,6 +222,17 @@ function readNullableInteger(payload: Record<string, unknown>, key: string): num
   return null;
 }
 
+function readNullableBoolean(payload: Record<string, unknown>, key: string): boolean | null {
+  const value = payload[key];
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') return true;
+    if (normalized === 'false') return false;
+  }
+  return null;
+}
+
 function inferDenied(payload: Record<string, unknown>): boolean {
   if (typeof payload.denied === 'boolean') return payload.denied;
   if (payload.approved === false) return true;
@@ -257,6 +268,19 @@ function mapAuditRowToEvent(config: ResolvedIngestConfig, row: StructuredAuditEn
     denied: inferDenied(payload),
     error_type: readNullableString(payload, 'errorType'),
     duration_ms: readNullableInteger(payload, 'durationMs'),
+    model_calls: readNullableInteger(payload, 'modelCalls'),
+    prompt_chars: readNullableInteger(payload, 'promptChars'),
+    completion_chars: readNullableInteger(payload, 'completionChars'),
+    prompt_tokens: readNullableInteger(payload, 'promptTokens'),
+    completion_tokens: readNullableInteger(payload, 'completionTokens'),
+    total_tokens: readNullableInteger(payload, 'totalTokens'),
+    estimated_prompt_tokens: readNullableInteger(payload, 'estimatedPromptTokens'),
+    estimated_completion_tokens: readNullableInteger(payload, 'estimatedCompletionTokens'),
+    estimated_total_tokens: readNullableInteger(payload, 'estimatedTotalTokens'),
+    api_usage_available: readNullableBoolean(payload, 'apiUsageAvailable'),
+    api_prompt_tokens: readNullableInteger(payload, 'apiPromptTokens'),
+    api_completion_tokens: readNullableInteger(payload, 'apiCompletionTokens'),
+    api_total_tokens: readNullableInteger(payload, 'apiTotalTokens'),
     event_uid: buildEventUid(config, row),
   };
 }

package/src/prompt-hooks.ts

@@ -6,12 +6,14 @@ import path from 'path';
 
 export type PromptHookName = 'bootstrap' | 'memory' | 'safety';
 export type ExtendedPromptHookName = PromptHookName | 'proactivity';
+export type PromptMode = 'full' | 'minimal' | 'none';
 
 export interface PromptHookContext {
   agentId: string;
   sessionSummary?: string | null;
   skills: Skill[];
   purpose?: 'conversation' | 'memory-flush';
+  promptMode?: PromptMode;
   extraSafetyText?: string;
 }
 
@@ -72,6 +74,17 @@ function buildSafetyHook(context: PromptHookContext): string {
     'After file changes, run commands only when asked; otherwise explicitly offer to run them immediately.',
     'Only skip file creation when the user explicitly asks for snippet-only or explanation-only output.',
     '',
+    '## Web Retrieval Routing (web_fetch vs browser_*)',
+    'Decision rule: default to `web_fetch` for read-only content retrieval.',
+    'Use browser tools only when at least one of these is true: (1) known app-like/auth-gated URL, (2) interaction is required (click/type/login/scroll), (3) `web_fetch` returned escalation hints, (4) user explicitly requested browser use.',
+    'Prefer browser for: SPAs/client-rendered apps (React/Vue/Angular/Next client routes), dashboards/web apps, social feeds, login/OAuth/cookie-consent/CAPTCHA flows, or API-driven pages that populate after initial render.',
+    'Prefer web_fetch for: docs/wikis/READMEs/articles/reference pages, direct JSON/XML/text/CSV/PDF endpoints, and simple read-only extraction.',
+    'Escalation signals from web_fetch: `escalationHint` present, JavaScript-required pages, empty extraction, SPA shell-only pages, boilerplate-only extraction, or bot-blocked responses (403/429/challenge pages).',
+    'Cost note: browser calls are typically ~10-100x slower/more expensive than web_fetch.',
+    'Browser extraction flow (for read/summarize requests): after `browser_navigate`, call `browser_snapshot` with `mode="full"` before deciding content is unavailable.',
+    'If snapshot content is incomplete, run `browser_scroll` and then `browser_snapshot` again (repeat a few times for long/lazy-loaded pages).',
+    'Do not use `browser_pdf` as a text-reading step; it is an export artifact, not a text extraction tool.',
+    '',
     '## Browser Auth Handling',
     'When the user explicitly asks for login/auth-flow testing, browser tools may be used on the requested site, including filling credentials and submitting forms.',
     'Do not invent blanket restrictions such as "browser tools are only for public/unauthenticated pages" unless an actual tool/policy error says so.',
@@ -206,11 +219,27 @@ const PROMPT_HOOKS: PromptHook[] = [
   },
 ];
 
+function resolvePromptMode(context: PromptHookContext): PromptMode {
+  if (context.promptMode === 'minimal' || context.promptMode === 'none') return context.promptMode;
+  return 'full';
+}
+
+function isHookAllowedForMode(hookName: ExtendedPromptHookName, mode: PromptMode): boolean {
+  if (mode === 'none') return false;
+  if (mode === 'full') return true;
+  // Minimal mode keeps only safety + memory durability context.
+  return hookName === 'memory' || hookName === 'safety';
+}
+
 export function runPromptHooks(context: PromptHookContext): PromptHookOutput[] {
+  const mode = resolvePromptMode(context);
+  if (mode === 'none') return [];
+
   const runtime = getRuntimeConfig();
   const output: PromptHookOutput[] = [];
 
   for (const hook of PROMPT_HOOKS) {
+    if (!isHookAllowedForMode(hook.name, mode)) continue;
     if (!hook.isEnabled(runtime)) continue;
     const content = hook.run(context).trim();
     if (!content) continue;

package/src/runtime-config.ts

@@ -31,6 +31,9 @@ export interface RuntimeSecurityConfig {
 export interface RuntimeConfig {
   version: number;
   security: RuntimeSecurityConfig;
+  skills: {
+    extraDirs: string[];
+  };
   discord: {
     prefix: string;
   };
@@ -126,6 +129,9 @@ const DEFAULT_RUNTIME_CONFIG: RuntimeConfig = {
     trustModelVersion: '',
     trustModelAcceptedBy: '',
   },
+  skills: {
+    extraDirs: [],
+  },
   discord: {
     prefix: '!claw',
   },
@@ -326,6 +332,7 @@ function readLegacyEnvPatch(): DeepPartial<RuntimeConfig> {
 
   const patch: Record<string, unknown> = {
     discord: {},
+    skills: {},
     hybridai: {},
     container: {},
     heartbeat: {},
@@ -343,6 +350,7 @@ function readLegacyEnvPatch(): DeepPartial<RuntimeConfig> {
   };
 
   const discord = patch.discord as Record<string, unknown>;
+  const skills = patch.skills as Record<string, unknown>;
   const hybridai = patch.hybridai as Record<string, unknown>;
   const container = patch.container as Record<string, unknown>;
   const heartbeat = patch.heartbeat as Record<string, unknown>;
@@ -356,6 +364,7 @@ function readLegacyEnvPatch(): DeepPartial<RuntimeConfig> {
   const proactiveAutoRetry = proactive.autoRetry as Record<string, unknown>;
 
   if (env.DISCORD_PREFIX != null) discord.prefix = env.DISCORD_PREFIX;
+  if (env.SKILLS_EXTRA_DIRS != null) skills.extraDirs = env.SKILLS_EXTRA_DIRS;
 
   if (env.HYBRIDAI_BASE_URL != null) hybridai.baseUrl = env.HYBRIDAI_BASE_URL;
   if (env.HYBRIDAI_MODEL != null) hybridai.defaultModel = env.HYBRIDAI_MODEL;
@@ -452,6 +461,7 @@ function normalizeRuntimeConfig(patch?: DeepPartial<RuntimeConfig>): RuntimeConf
   const raw = patch ?? {};
 
   const rawSecurity = isRecord(raw.security) ? raw.security : {};
+  const rawSkills = isRecord(raw.skills) ? raw.skills : {};
   const rawDiscord = isRecord(raw.discord) ? raw.discord : {};
   const rawHybridAi = isRecord(raw.hybridai) ? raw.hybridai : {};
   const rawContainer = isRecord(raw.container) ? raw.container : {};
@@ -500,6 +510,9 @@ function normalizeRuntimeConfig(patch?: DeepPartial<RuntimeConfig>): RuntimeConf
       trustModelVersion: normalizeString(rawSecurity.trustModelVersion, DEFAULT_RUNTIME_CONFIG.security.trustModelVersion, { allowEmpty: true }),
       trustModelAcceptedBy: normalizeString(rawSecurity.trustModelAcceptedBy, DEFAULT_RUNTIME_CONFIG.security.trustModelAcceptedBy, { allowEmpty: true }),
     },
+    skills: {
+      extraDirs: normalizeStringArray(rawSkills.extraDirs, DEFAULT_RUNTIME_CONFIG.skills.extraDirs),
+    },
     discord: {
       prefix: normalizeString(rawDiscord.prefix, DEFAULT_RUNTIME_CONFIG.discord.prefix, { allowEmpty: false }),
     },
@@ -799,7 +812,11 @@ function migrateConfigSchemaOnStartup(): void {
   try {
     writeConfigFile(migrated);
     const from = previousVersion == null ? 'unknown' : String(previousVersion);
-    console.info(`[runtime-config] migrated config schema from v${from} to v${CONFIG_VERSION}`);
+    if (previousVersion !== CONFIG_VERSION) {
+      console.info(`[runtime-config] migrated config schema from v${from} to v${CONFIG_VERSION}`);
+    } else {
+      console.info(`[runtime-config] normalized config schema v${CONFIG_VERSION} (filled defaults/canonicalized values)`);
+    }
   } catch (err) {
     console.warn(`[runtime-config] schema migration failed: ${err instanceof Error ? err.message : String(err)}`);
   }

package/src/scheduled-task-runner.ts

@@ -1,6 +1,7 @@
 import { runAgent } from './agent.js';
 import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent } from './audit-events.js';
 import type { ChatMessage } from './types.js';
+import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
 
 export async function runIsolatedScheduledTask(params: {
   taskId: number;
@@ -53,6 +54,14 @@ export async function runIsolatedScheduledTask(params: {
       runId,
       toolExecutions: output.toolExecutions || [],
     });
+    const tokenUsage = output.tokenUsage;
+    const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || estimateTokenCountFromMessages(messages);
+    const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || estimateTokenCountFromText(output.result || '');
+    const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+    const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
+    const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
+    const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
+    const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
     recordAuditEvent({
       sessionId: cronSessionId,
       runId,
@@ -62,6 +71,17 @@ export async function runIsolatedScheduledTask(params: {
         model,
         durationMs: Date.now() - startedAt,
         toolCallCount: (output.toolExecutions || []).length,
+        modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
+        promptTokens: apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens,
+        completionTokens: apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens,
+        totalTokens: apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens,
+        estimatedPromptTokens,
+        estimatedCompletionTokens,
+        estimatedTotalTokens,
+        apiUsageAvailable,
+        apiPromptTokens,
+        apiCompletionTokens,
+        apiTotalTokens,
       },
     });
 

package/src/session-maintenance.ts

@@ -78,6 +78,7 @@ function buildSystemPrompt(agentId: string, sessionSummary?: string | null, extr
     sessionSummary,
     skills: loadSkills(agentId),
     purpose: 'memory-flush',
+    promptMode: 'minimal',
     extraSafetyText: extra,
   });
 }