@c4t4/heyamigo 0.9.17 → 0.9.19

package/dist/ai/claude.js

@@ -202,6 +202,9 @@ export async function runClaudeTask(params) {
 }
 export const claudeProvider = {
     name: 'claude',
+    // Claude CLI's `result` event reports per-turn usage (just the
+    // tokens consumed by this single resume invocation).
+    usageReportingMode: 'per-turn',
     ask: askClaude,
     runTask: runClaudeTask,
     reloadSystemPrompt,

package/dist/ai/codex.js

@@ -267,6 +267,11 @@ async function askCodex(params) {
 }
 export const codexProvider = {
     name: 'codex',
+    // Codex CLI's `turn.completed.usage` reports cumulative totals for
+    // the entire resume thread, not just this one turn. Worker uses
+    // this flag to delta-math each turn before display so the context
+    // % doesn't blow up to thousands after many resume turns.
+    usageReportingMode: 'cumulative',
     ask: askCodex,
     runTask: runCodexTask,
     reloadSystemPrompt,

package/dist/ai/spawn.js

@@ -180,8 +180,14 @@ export async function runClaude(opts) {
 }
 // Per-lane defaults. Individual callers can override, but these are the
 // shipped caps. Browser-heavy work lives in the async lane.
+//
+// Values picked to accommodate /goal-style long-running tasks (Claude
+// Code / Codex CLI support multi-hour goal sessions). Matching claim
+// TTLs in queue/inbound.ts and queue/browser-queue.ts MUST exceed
+// these — otherwise the orchestrator reclaims live workers and the
+// same task gets processed twice.
 export const TIMEOUT_MS = {
-    main: 5 * 60 * 1000,
-    async: 15 * 60 * 1000,
-    background: 3 * 60 * 1000,
+    main: 30 * 60 * 1000, // 30 min — chat track, covers /goal
+    async: 60 * 60 * 1000, // 60 min — async lane, deep browser scrapes
+    background: 5 * 60 * 1000, // 5 min — digest / sweep / housekeeping
 };

package/dist/gateway/commands.js

@@ -34,8 +34,11 @@ export async function tryCommand(ctx) {
         if (info.usage) {
             const max = config.claude.contextWindow;
             const used = info.usage.totalContextTokens;
-            const leftPct = Math.max(0, 100 - (used / max) * 100).toFixed(1);
-            lines.push(`Context: ${used.toLocaleString()} / ${max.toLocaleString()} (${leftPct}% left)`);
+            // Clamp leftPct to [0, 100] so stale or inconsistent data
+            // doesn't surface a negative or >100 percentage.
+            const leftRatio = Math.max(0, Math.min(1, 1 - used / max));
+            const leftPct = (leftRatio * 100).toFixed(1);
+            lines.push(`Context: ${used.toLocaleString()} / ${max.toLocaleString()} (${leftPct}% left, last turn)`);
             lines.push(`Turns: ${info.usage.numTurns}`);
         }
         await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);

package/dist/gateway/outgoing.js

@@ -171,13 +171,21 @@ export function formatStatsFooter(stats) {
         ? ` (${compactTokens(stats.cacheReadTokens)} cached)`
         : '';
     parts.push(`${inStr}↑${cacheStr} ${outStr}↓`);
-    // Context % — only when worth calling out
+    // Context % — only when worth calling out. Skipped when pct is
+    // implausible (>120%) — usually means cumulative/per-turn token
+    // counts got crossed by a stale session. Better to show nothing
+    // than display "7018% ctx" and lose user trust.
     if (stats.contextWindow > 0) {
         const pct = Math.round((stats.totalContextTokens / stats.contextWindow) * 100);
-        if (pct >= 90)
+        if (pct > 120) {
+            // skip — data is stale or inconsistent
+        }
+        else if (pct >= 90) {
             parts.push(`⚠ ${pct}% ctx`);
-        else if (pct >= 70)
+        }
+        else if (pct >= 70) {
             parts.push(`${pct}% ctx`);
+        }
     }
     if (stats.fresh)
         parts.push('fresh');

package/dist/queue/browser-queue.js

@@ -121,8 +121,11 @@ export function markBrowserTaskRetryOrDlq(id, workerId, errorMessage) {
         return { retried: true, deadLettered: false };
     });
 }
-// Browser tasks take 1-15 min routinely. Generous reclaim TTL.
-const CLAIM_TTL_SECONDS = 20 * 60;
+// MUST exceed TIMEOUT_MS.async (60min as of the /goal-friendly bump)
+// so live browser workers don't get reclaimed mid-spawn. 5min headroom
+// past the spawn cap so the orchestrator only catches truly dead
+// workers. Browser tasks legitimately run 30-45min for deep scrapes.
+const CLAIM_TTL_SECONDS = 65 * 60;
 export function reclaimStuckBrowserTasks() {
     const db = getDb();
     const cutoff = Math.floor(Date.now() / 1000) - CLAIM_TTL_SECONDS;

package/dist/queue/inbound.js

@@ -170,10 +170,11 @@ export function markInboundFailed(id, workerId, errorMessage) {
         .all();
     return result.length > 0;
 }
-// Orchestrator helper. Chat workers run longer than sender workers
-// (AI calls + memory writes), so the TTL is more generous. 300s
-// matches the typical chat-track timeout (5min).
-const CLAIM_TTL_SECONDS = 360;
+// Orchestrator helper. MUST exceed TIMEOUT_MS.main (30min as of the
+// /goal-friendly bump) so live workers don't get reclaimed mid-spawn.
+// 5min headroom past the spawn cap so the orchestrator only catches
+// rows whose worker actually died.
+const CLAIM_TTL_SECONDS = 35 * 60;
 export function reclaimStuckInbound() {
     const db = getDb();
     const cutoff = Math.floor(Date.now() / 1000) - CLAIM_TTL_SECONDS;

package/dist/queue/worker.js

@@ -1,5 +1,5 @@
 import { getProvider } from '../ai/providers.js';
-import { clearSession, setSession, setUsage } from '../ai/sessions.js';
+import { clearSession, getSessionInfo, setSession, setUsage, } from '../ai/sessions.js';
 import { config } from '../config.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
@@ -18,6 +18,9 @@ async function callClaude(job) {
     const startedAt = Date.now();
     const wasFresh = !job.sessionId;
     const provider = getProvider();
+    // Capture prior session usage BEFORE the ask call so we can compute
+    // per-turn deltas regardless of the provider's reporting mode.
+    const priorUsage = getSessionInfo(job.jid, provider.name)?.usage;
     const { reply, sessionId, usage } = await provider.ask({
         input: job.input,
         sessionId: job.sessionId,
@@ -27,20 +30,76 @@ async function callClaude(job) {
     if (!job.sessionId) {
         setSession(job.jid, provider.name, sessionId);
     }
-    const totalContextTokens = usage.inputTokens +
-        usage.cacheReadTokens +
-        usage.cacheCreationTokens +
-        usage.outputTokens;
+    // Reconcile per-turn vs cumulative reporting. See AiProvider
+    // .usageReportingMode for context. For cumulative providers (Codex),
+    // the reported usage = whole-thread totals; we subtract the prior
+    // cumulative to get this turn's cost. For per-turn providers
+    // (Claude), the reported usage IS this turn's cost; we sum into
+    // the running cumulative.
+    //
+    // Fallback baseline: if cumulative* fields aren't stored yet
+    // (first turn after this fix deploys), use the prior plain field
+    // values. That treats the existing buggy-cumulative storage as the
+    // baseline so the next delta is accurate.
+    const baseCumInput = priorUsage?.cumulativeInputTokens ?? priorUsage?.inputTokens ?? 0;
+    const baseCumCacheRead = priorUsage?.cumulativeCacheReadTokens ?? priorUsage?.cacheReadTokens ?? 0;
+    const baseCumCacheCreate = priorUsage?.cumulativeCacheCreationTokens ?? priorUsage?.cacheCreationTokens ?? 0;
+    const baseCumOutput = priorUsage?.cumulativeOutputTokens ?? priorUsage?.outputTokens ?? 0;
+    let turnInput;
+    let turnCacheRead;
+    let turnCacheCreate;
+    let turnOutput;
+    let newCumInput;
+    let newCumCacheRead;
+    let newCumCacheCreate;
+    let newCumOutput;
+    if (provider.usageReportingMode === 'cumulative') {
+        // Reported usage IS the cumulative total. Delta = current - prev.
+        // Math.max(0, …) protects against the rare case where the CLI's
+        // counter resets (e.g. fresh session that we still tracked) —
+        // never display negative deltas.
+        newCumInput = usage.inputTokens;
+        newCumCacheRead = usage.cacheReadTokens;
+        newCumCacheCreate = usage.cacheCreationTokens;
+        newCumOutput = usage.outputTokens;
+        turnInput = Math.max(0, newCumInput - baseCumInput);
+        turnCacheRead = Math.max(0, newCumCacheRead - baseCumCacheRead);
+        turnCacheCreate = Math.max(0, newCumCacheCreate - baseCumCacheCreate);
+        turnOutput = Math.max(0, newCumOutput - baseCumOutput);
+    }
+    else {
+        // Reported usage IS per-turn already. Accumulate into cumulative.
+        turnInput = usage.inputTokens;
+        turnCacheRead = usage.cacheReadTokens;
+        turnCacheCreate = usage.cacheCreationTokens;
+        turnOutput = usage.outputTokens;
+        newCumInput = baseCumInput + turnInput;
+        newCumCacheRead = baseCumCacheRead + turnCacheRead;
+        newCumCacheCreate = baseCumCacheCreate + turnCacheCreate;
+        newCumOutput = baseCumOutput + turnOutput;
+    }
+    // totalContextTokens is the PROMPT side (input + cache reads + cache
+    // creation). Output is response, not context. The old code included
+    // outputTokens here which was wrong.
+    const totalContextTokens = turnInput + turnCacheRead + turnCacheCreate;
     setUsage(job.jid, provider.name, {
-        ...usage,
+        inputTokens: turnInput,
+        cacheReadTokens: turnCacheRead,
+        cacheCreationTokens: turnCacheCreate,
+        outputTokens: turnOutput,
         totalContextTokens,
+        numTurns: usage.numTurns,
+        cumulativeInputTokens: newCumInput,
+        cumulativeCacheReadTokens: newCumCacheRead,
+        cumulativeCacheCreationTokens: newCumCacheCreate,
+        cumulativeOutputTokens: newCumOutput,
         updatedAt: Math.floor(Date.now() / 1000),
     });
     // Per-user daily token accounting. Owner sender is exempt by check at the
     // incoming gate, but we still bill so /usage reflects reality if added.
     // Cache-read tokens are excluded — they don't cost real budget.
     if (job.senderNumber) {
-        addDailyTokens(job.senderNumber, usage.inputTokens + usage.outputTokens);
+        addDailyTokens(job.senderNumber, turnInput + turnOutput);
     }
     const rawFlags = extractFlags(reply);
     const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, sendTexts, crons, reminds, } = filterFlagsByRole(rawFlags, job.allowedTags);
@@ -179,9 +238,11 @@ async function callClaude(job) {
         reply: clean,
         stats: {
             durationMs,
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            cacheReadTokens: usage.cacheReadTokens,
+            // All per-turn values now (delta-corrected for cumulative
+            // providers above). Footer shows these directly.
+            inputTokens: turnInput,
+            outputTokens: turnOutput,
+            cacheReadTokens: turnCacheRead,
             totalContextTokens,
             contextWindow: config.claude.contextWindow,
             fresh: wasFresh,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.9.17",
+  "version": "0.9.19",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",