@c4t4/heyamigo 0.9.18 → 0.9.20

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/estimates/async-task.js

@@ -0,0 +1,29 @@
+// Generic async-task estimator (non-browser background work).
+//
+// The general async lane is still on in-memory fastq (no durable
+// table). Real duration samples aren't queryable yet → the estimate
+// uses defaultMs every time until/unless that lane gets migrated to
+// SQLite. Cards still surface useful "long task incoming" UX.
+import { aggregateMean, humanDur, registerEstimator, } from './registry.js';
+class AsyncTaskEstimator {
+    kind = 'async-task';
+    // 3 min — generic background work tends to be moderate. A deeper
+    // research task might run longer; a quick one shorter. Single
+    // ballpark until we have real samples.
+    defaultMs = 3 * 60 * 1000;
+    matches(ctx) {
+        return ctx.taskKind === 'async';
+    }
+    // No durable samples (general async lane is still in-memory fastq).
+    // Returning [] forces aggregateMean to fall back to defaultMs.
+    querySamples() {
+        return [];
+    }
+    estimate(samples) {
+        return aggregateMean(samples, this.defaultMs);
+    }
+    format(estimate) {
+        return `background task, ~${humanDur(estimate.pointMs)}`;
+    }
+}
+registerEstimator(new AsyncTaskEstimator());

package/dist/estimates/browser-task.js

@@ -0,0 +1,49 @@
+// Generic browser-task estimator. Matches any agent-delegated
+// [ASYNC-BROWSER:] task. Pulls duration samples from the durable
+// browser_tasks table so the average reflects real observed runtimes.
+import { and, desc, eq, isNotNull } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { browserTasks } from '../db/schema.js';
+import { aggregateMean, humanDur, registerEstimator, } from './registry.js';
+class BrowserTaskEstimator {
+    kind = 'browser-task';
+    // 5 min is a reasonable ballpark for IG/TT scrapes. Real samples
+    // dominate after the first 1-2 jobs.
+    defaultMs = 5 * 60 * 1000;
+    matches(ctx) {
+        return ctx.taskKind === 'async-browser';
+    }
+    querySamples(limit = 20) {
+        const db = getDb();
+        // All done browser tasks — single bucket. Could be sliced further
+        // (per-domain) later via more-specific estimators registered ahead
+        // of this catch-all.
+        const rows = db
+            .select({
+            claimedAt: browserTasks.claimedAt,
+            updatedAt: browserTasks.updatedAt,
+        })
+            .from(browserTasks)
+            .where(and(eq(browserTasks.status, 'done'), isNotNull(browserTasks.claimedAt)))
+            .orderBy(desc(browserTasks.id))
+            .limit(limit)
+            .all();
+        return rows
+            .filter((r) => r.claimedAt !== null)
+            .map((r) => ({
+            durationMs: (r.updatedAt - r.claimedAt) * 1000,
+            finishedAt: r.updatedAt,
+        }))
+            .filter((s) => s.durationMs > 0);
+    }
+    estimate(samples) {
+        return aggregateMean(samples, this.defaultMs);
+    }
+    format(estimate) {
+        if (estimate.rangeMs) {
+            return `browser task, ~${humanDur(estimate.rangeMs.lowMs)} to ~${humanDur(estimate.rangeMs.highMs)}`;
+        }
+        return `browser task, ~${humanDur(estimate.pointMs)}`;
+    }
+}
+registerEstimator(new BrowserTaskEstimator());

package/dist/estimates/image-gen.js

@@ -15,6 +15,13 @@ class ImageGenEstimator {
     // observations.
     defaultMs = 30_000;
     matches(ctx) {
+        // Only match direct user input. When taskKind is set, the context
+        // is an agent-delegated task — those go through the browser/async
+        // estimators below, not here. Prevents an agent's
+        // "[ASYNC-BROWSER: generate marketing image of X]" from being
+        // mis-classified as a user-typed image-gen request.
+        if (ctx.taskKind)
+            return false;
         return IMAGE_GEN_RE.test(ctx.description);
     }
     estimate(samples) {

package/dist/estimates/index.js

@@ -6,7 +6,13 @@
 //
 // Adding a new kind = drop a file alongside image-gen.ts and import
 // it below. No other code in the codebase needs to change.
+// Order matters: more-specific estimators register first so they win
+// classify() over the catch-all task estimators. image-gen and other
+// user-input matchers can run first because they explicitly DON'T
+// match when ctx.taskKind is set.
 import './image-gen.js';
-// future: import './browser-ig.js'
+import './browser-task.js'; // catches all [ASYNC-BROWSER:] tasks
+import './async-task.js'; // catches all [ASYNC:] tasks
+// future: import './browser-ig.js'   // more specific than browser-task
 // future: import './voice-gen.js'
 export { classify, estimate, formatEstimateDefault, humanDur, listEstimators, querySamplesForKind, registerEstimator, } from './registry.js';

package/dist/estimates/registry.js

@@ -61,7 +61,10 @@ export function estimate(ctx) {
     const e = classify(ctx);
     if (!e)
         return null;
-    const samples = querySamplesForKind(e.kind);
+    // Estimator's own querySamples (if provided) takes precedence —
+    // browser/async estimators pull from their dedicated tables. Otherwise
+    // fall back to the inbound-by-kind default.
+    const samples = e.querySamples ? e.querySamples() : querySamplesForKind(e.kind);
     const result = e.estimate(samples);
     const text = (e.format ?? formatEstimateDefault)(result);
     return { kind: e.kind, result, text };

package/dist/gateway/outgoing.js

@@ -108,7 +108,25 @@ export async function handleReply(job, result, _originalMsg) {
             enqueuePiece({ address, kind: 'text', text: chunkForSend });
         }
     }
-    logger.info({ jid: job.jid, files: files.length, chars: text.length, pieces: pieceIdx }, 'reply enqueued for outbound');
+    // Job cards (ETAs for delegated async/browser tasks) go LAST so
+    // they arrive after the agent's reply chunks in chat. Each card
+    // has its own producer-supplied idempotencyKey; we don't slot them
+    // into the piece-numbered key space.
+    for (const card of result.jobCards ?? []) {
+        enqueueOutbound({
+            address,
+            kind: 'text',
+            text: card.text,
+            idempotencyKey: card.idempotencyKey,
+        });
+    }
+    logger.info({
+        jid: job.jid,
+        files: files.length,
+        chars: text.length,
+        pieces: pieceIdx,
+        cards: result.jobCards?.length ?? 0,
+    }, 'reply enqueued for outbound');
 }
 // Proactive outbound: send a message to a chat without an incoming
 // trigger. Same parsing as handleReply; enqueues outbound rows.

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

@@ -4,6 +4,7 @@ import { config } from '../config.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
 import { addDailyTokens } from '../store/usage.js';
+import { estimate as estimateJob } from '../estimates/index.js';
 import { extractFlags, filterFlagsByRole } from '../memory/digest-flag.js';
 import { isValidSlug } from '../memory/journals.js';
 import { enqueueAsyncTask, enqueueBrowserTask } from './async-tasks.js';
@@ -171,7 +172,15 @@ async function callClaude(job) {
     //   [ASYNC:...] → general lane, stateless, concurrency 3, non-browser work
     //   [ASYNC-BROWSER:...] → browser lane, persistent session, concurrency 1
     // Both report back via initiate() when done.
-    for (const t of asyncTasks) {
+    //
+    // For each delegation, we also build a "job card" — a short ETA
+    // message that handleReply will emit after the agent's reply
+    // chunks. Gives the user a visible "doing X, ~Y min" instead of
+    // wondering whether anything's happening.
+    const jobCards = [];
+    const cardBase = `card-${job.jid}-${Date.now()}`;
+    for (let i = 0; i < asyncTasks.length; i++) {
+        const t = asyncTasks[i];
         enqueueAsyncTask({
             jid: job.jid,
             senderNumber: job.senderNumber,
@@ -179,8 +188,19 @@ async function callClaude(job) {
             originatingMessage: job.text,
             allowedTools: job.allowedTools ?? 'all',
         });
+        const est = estimateJob({
+            description: t.description,
+            taskKind: 'async',
+        });
+        if (est) {
+            jobCards.push({
+                text: formatJobCard(est.text, t.description),
+                idempotencyKey: `${cardBase}-async-${i}`,
+            });
+        }
     }
-    for (const t of asyncBrowserTasks) {
+    for (let i = 0; i < asyncBrowserTasks.length; i++) {
+        const t = asyncBrowserTasks[i];
         enqueueBrowserTask({
             jid: job.jid,
             senderNumber: job.senderNumber,
@@ -188,6 +208,16 @@ async function callClaude(job) {
             originatingMessage: job.text,
             allowedTools: job.allowedTools ?? 'all',
         });
+        const est = estimateJob({
+            description: t.description,
+            taskKind: 'async-browser',
+        });
+        if (est) {
+            jobCards.push({
+                text: formatJobCard(est.text, t.description),
+                idempotencyKey: `${cardBase}-browser-${i}`,
+            });
+        }
     }
     // SEND-TEXT: cross-chat text send. Agent specified the destination
     // address explicitly. Just drops a row in outbound; sender worker
@@ -250,8 +280,18 @@ async function callClaude(job) {
             journalSlugs: journals.map((j) => j.slug),
             asyncCount: asyncTasks.length + asyncBrowserTasks.length,
         },
+        jobCards: jobCards.length > 0 ? jobCards : undefined,
     };
 }
+// Compact card text. Emoji + ETA + a brief excerpt of what the agent
+// delegated, so the user knows which job each card refers to when
+// multiple are running.
+function formatJobCard(etaText, description) {
+    const excerpt = description.length > 100
+        ? description.slice(0, 97) + '...'
+        : description;
+    return `🔄 ${etaText}\n${excerpt}`;
+}
 function titleCase(slug) {
     return slug
         .split('-')

package/package.json

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