@c4t4/heyamigo 0.10.3 → 0.10.5

package/README.md

@@ -60,7 +60,7 @@ Other providers:
 | Role | Memory | Tools | Notes |
 |---|---|---|---|
 | admin | everything | all | unrestricted |
-| user | own profile | web search | can't see other users or internals |
+| user | own profile | none | can't see other users or internals |
 | guest | none | none | prompt-injection resistant |
 
 ## Personalities

package/config/access.example.json

@@ -13,9 +13,9 @@
       "dailyTokenLimit": null
     },
     "user": {
-      "description": "Can chat and search the web, scoped memory",
+      "description": "Can chat with scoped memory",
       "memory": "self",
-      "tools": ["WebSearch"],
+      "tools": [],
       "rules": [
         "Never reveal file paths, directory structure, or system architecture",
         "Never share personal data about other users",

package/config/memory-instructions.md

@@ -27,6 +27,20 @@ Relevant blocks appear in `[State]`, `[Map]`, `[Trees]`, `[Entities]`, `[Journal
 
 The system auto-suffixes a stats line (duration, tokens, ctx %). Do NOT write or mimic it. No `_stats_` italic footers.
 
+## Core queue contract
+
+Final reply is the control surface. Tags queue work, memory, schedules, threads, or media.
+Files/browser work are async. No tag = no side effect.
+
+## Core tag reference
+
+Common tags:
+- Work: `[ASYNC: task]`, `[ASYNC-BROWSER: task]`
+- Media: `[IMAGE|VIDEO|AUDIO|DOCUMENT: /absolute/path]`
+- Memory: `[DIGEST: reason]`, `[JOURNAL:slug - note]`, `[JOURNAL-NEW:slug - purpose]`
+- Time: `[REMIND: YYYY-MM-DD HH:MM - text]`, `[CRON: expr SAY|PROMPT|ASYNC|BROWSER - body]`
+- Threads: `THREAD-*` for active open loops shown in `[Live threads]`. Full grammar below.
+
 ## DIGEST
 
 Append `[DIGEST: <one-line reason>]` at END of reply when something is worth durable storage: new preference, key life/work fact, relationship/context shift, decision future replies should respect. Stripped before send. Sparingly — a few times per week.
@@ -114,18 +128,20 @@ You = chat track. Browser track = parallel Claude session on shared Chrome at `l
 
 Never call `browser_*` / `mcp__*playwright*` inline. Ever. Single URL, "just checking", everything — all via `[ASYNC-BROWSER: <task>]`. The browser worker has persistent session memory.
 
+Never use AI-internal web tools (`WebSearch`, `WebFetch`, `web_search`) for internet lookup. Search pages, current facts, prices, social profiles, websites, and screenshots are BrowserUse work via `[ASYNC-BROWSER: <task>]`. If BrowserUse is unavailable, say that; do not fall back to AI-internal lookup.
+
 ```
 On it.
 [ASYNC-BROWSER: Open instagram.com/rivoara_official on shared Chrome (IG already logged in, do NOT launch new browser). Extract bio + 5 latest captions. If login wall, report and stop. Bail after 3 retries.]
 ```
 
-### Non-browser long work → `[ASYNC: <task>]`
+### File/long non-browser work → `[ASYNC: <task>]`
 
-For >30s reasoning over many files, web_search batches, anything slow. Stateless per task — describe fully.
+File generation/edit/export, >30s reasoning over many files, anything slow that is not browser use. Stateless per task — describe fully.
 
 ### Don't delegate
 
-Answerable from your context / memory / `[State]` / recent entries. Short reasoning. Immediate questions. Single quick non-browser tool calls.
+Answerable from your context / memory / `[State]` / recent entries. Short reasoning. Immediate questions. Single quick non-browser tool calls. No browser/file-generation work here.
 
 ### Task description rules
 
@@ -145,7 +161,9 @@ If `[Async running — do NOT re-emit for these]` appears in your preamble, a wo
 [FILE: /absolute/path] | [IMAGE: ...] | [VIDEO: ...] | [AUDIO: ...] | [DOCUMENT: ...]
 ```
 
-Save to `storage/outbox/` (auto-deleted after send). Absolute paths only. Media type from extension. Single-file + short text (<1000 chars, non-audio) → text becomes caption.
+Save to `storage/outbox/` (auto-deleted after send). Absolute paths under `storage/outbox/` only. Media type from extension. Single-file + short text (<1000 chars, non-audio) → text becomes caption.
+
+Media tags deliver files that already exist. Main chat delegates file generation/edit/export with `[ASYNC: ...]`; the follow-up worker saves final files under `storage/outbox/` and emits one media tag per final file. If the requested file could not be produced, say that explicitly instead of implying delivery.
 
 ## Scheduling
 

package/dist/cli/setup.js

@@ -231,9 +231,9 @@ export async function runSetup() {
                     rules: [],
                 },
                 user: {
-                    description: 'Can chat and search the web, scoped memory',
+                    description: 'Can chat with scoped memory',
                     memory: 'self',
-                    tools: ['WebSearch'],
+                    tools: [],
                     rules: [
                         'Never reveal file paths, directory structure, or system architecture',
                         'Never share personal data about other users',
@@ -312,10 +312,10 @@ export async function runSetup() {
         }
         p.log.success('Claude authenticated');
         // Tool permissions — write .claude/settings.json in project root.
-        p.log.info('Claude needs tool permissions to browse the web, read files, and control the browser. ' +
+        p.log.info('Claude needs tool permissions to read files and control BrowserUse. ' +
             'This writes a .claude/settings.json file in the project directory.');
         const grantPermissions = await p.confirm({
-            message: 'Grant tool permissions? (WebFetch, WebSearch, Read, Edit, Write, browser)',
+            message: 'Grant tool permissions? (Read, Edit, Write, BrowserUse)',
             initialValue: true,
         });
         if (p.isCancel(grantPermissions) || !grantPermissions) {
@@ -335,8 +335,6 @@ export async function runSetup() {
                     ? permissions.allow
                     : [];
                 const required = [
-                    'WebFetch',
-                    'WebSearch',
                     'Read',
                     'Edit',
                     'Write',

package/dist/gateway/ingest.js

@@ -1,4 +1,5 @@
 import { unlink } from 'fs/promises';
+import { resolve } from 'path';
 import { getProvider } from '../ai/providers.js';
 import { getSession } from '../ai/sessions.js';
 import { config } from '../config.js';
@@ -40,6 +41,15 @@ function enqueueTextReply(incoming, text, idempotencyKey) {
         idempotencyKey,
     });
 }
+function buildImageGenRoutingContract() {
+    const outboxPath = resolve('storage/outbox');
+    return [
+        '[Image generation routing]',
+        'This turn is classified as image/file generation.',
+        'Do not perform file work in this foreground reply.',
+        `Reply briefly and emit [ASYNC: Generate the requested image using current chat context. Save final files under ${outboxPath}/. Follow-up reply must include one [IMAGE: /absolute/path] tag per final image, or say: Image job failed before producing a file.]`,
+    ].join('\n');
+}
 export async function processIncomingMessage(incoming, opts = {}) {
     const stored = toStored(incoming);
     const ageMs = Date.now() - stored.timestamp * 1000;
@@ -181,7 +191,20 @@ export async function processIncomingMessage(incoming, opts = {}) {
             chat,
         });
     }
-    const input = `${memoryPreamble}\n\n---\n\n${core}`;
+    const personId = personIdForAddress(incoming.address);
+    const actorPersonId = incoming.actorAddress
+        ? personIdForAddress(incoming.actorAddress)
+        : null;
+    const est = estimateJob({
+        description: stored.text,
+        attachments: media ? [{ kind: media.mediaType }] : undefined,
+        senderPersonId: actorPersonId ?? undefined,
+    });
+    const jobKind = est?.kind ?? null;
+    let input = `${memoryPreamble}\n\n---\n\n${core}`;
+    if (est?.kind === 'image-gen') {
+        input = `${input}\n\n---\n\n${buildImageGenRoutingContract()}`;
+    }
     logger.info({ ...logCtx, resume: !!existingSession, trigger: triggerReason }, 'message captured, enqueuing');
     const job = {
         jid: stored.jid,
@@ -195,16 +218,6 @@ export async function processIncomingMessage(incoming, opts = {}) {
         allowedTools: role.tools,
         allowedTags: role.tags,
     };
-    const personId = personIdForAddress(incoming.address);
-    const actorPersonId = incoming.actorAddress
-        ? personIdForAddress(incoming.actorAddress)
-        : null;
-    const est = estimateJob({
-        description: stored.text,
-        attachments: media ? [{ kind: media.mediaType }] : undefined,
-        senderPersonId: actorPersonId ?? undefined,
-    });
-    const jobKind = est?.kind ?? null;
     if (est) {
         enqueueOutbound({
             address: incoming.address,

package/dist/gateway/outgoing.js

@@ -1,5 +1,5 @@
-import { existsSync, statSync } from 'fs';
-import { extname } from 'path';
+import { existsSync, realpathSync, statSync } from 'fs';
+import { extname, isAbsolute, relative, resolve } from 'path';
 import { config } from '../config.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
@@ -8,16 +8,50 @@ import { enqueueOutbound } from '../queue/outbound.js';
 import { detectMediaType } from '../wa/sender.js';
 // Matches [FILE: path], [IMAGE: path], [VIDEO: path], [AUDIO: path], [DOCUMENT: path]
 const FILE_TAG_RE = /\[(?:FILE|IMAGE|VIDEO|AUDIO|DOCUMENT):\s*([^\]]+)\]/gi;
+function isInsideDir(parent, child) {
+    const rel = relative(parent, child);
+    return rel === '' || (!!rel && !rel.startsWith('..') && !isAbsolute(rel));
+}
+function outboxDir() {
+    const path = resolve(process.cwd(), 'storage/outbox');
+    return existsSync(path) ? realpathSync(path) : path;
+}
+function resolveSendableFile(path) {
+    const trimmed = path.trim();
+    if (!isAbsolute(trimmed)) {
+        logger.warn({ path: trimmed }, 'file tag ignored: path must be absolute');
+        return null;
+    }
+    if (!existsSync(trimmed)) {
+        logger.warn({ path: trimmed }, 'file path not found, skipping');
+        return null;
+    }
+    let realFile;
+    try {
+        const stat = statSync(trimmed);
+        if (!stat.isFile()) {
+            logger.warn({ path: trimmed }, 'file tag ignored: path is not a file');
+            return null;
+        }
+        realFile = realpathSync(trimmed);
+    }
+    catch (err) {
+        logger.warn({ err, path: trimmed }, 'file tag ignored: path unreadable');
+        return null;
+    }
+    const outbox = outboxDir();
+    if (!isInsideDir(outbox, realFile)) {
+        logger.warn({ path: trimmed, outbox }, 'file tag ignored: path is outside storage/outbox');
+        return null;
+    }
+    return realFile;
+}
 function extractFiles(reply) {
     const files = [];
     const text = reply.replace(FILE_TAG_RE, (_, path) => {
-        const trimmed = path.trim();
-        if (existsSync(trimmed)) {
-            files.push(trimmed);
-        }
-        else {
-            logger.warn({ path: trimmed }, 'file path not found, skipping');
-        }
+        const resolved = resolveSendableFile(path);
+        if (resolved)
+            files.push(resolved);
         return '';
     }).trim();
     return { text, files };
@@ -50,17 +84,56 @@ function fileSize(filePath) {
         return undefined;
     }
 }
+function hasSideEffects(stats) {
+    if (!stats)
+        return false;
+    return (stats.hasDigest ||
+        stats.journalSlugs.length > 0 ||
+        stats.journalCreateCount > 0 ||
+        stats.asyncCount > 0 ||
+        stats.asyncBrowserCount > 0 ||
+        stats.remindCount > 0 ||
+        stats.cronCount > 0 ||
+        stats.sendTextCount > 0 ||
+        stats.threadNewCount > 0 ||
+        stats.threadResolveCount > 0 ||
+        stats.threadDropCount > 0 ||
+        stats.threadCompressCount > 0 ||
+        stats.threadTouchCount > 0);
+}
 // `originalMsg` is currently ignored when routing through the outbound
 // queue — Baileys quoting needs the full WAMessage embedded in
 // contextInfo, which we'd have to serialize through the DB row and
 // reconstruct. Known regression for Phase 1; see refactor-scrap.md.
 // Kept in the signature so existing callers don't change.
 export async function handleReply(job, result, _originalMsg) {
-    const raw = result.reply?.replaceAll('—', ', ').replaceAll('–', '-');
-    if (!raw)
+    const raw = result.reply?.replaceAll('—', ', ').replaceAll('–', '-').trim();
+    const address = addressForJob(job);
+    if (!raw) {
+        const footer = result.stats && config.reply.showStats
+            ? formatStatsFooter(result.stats)
+            : '';
+        const text = hasSideEffects(result.stats) || (result.jobCards?.length ?? 0) > 0
+            ? 'Done.'
+            : config.reply.errorMessage;
+        enqueueOutbound({
+            address,
+            kind: 'text',
+            text: footer ? `${text}\n\n${footer}` : text,
+            idempotencyKey: `reply-empty-${job.jid}-${Date.now()}`,
+        });
+        for (const card of result.jobCards ?? []) {
+            enqueueOutbound({
+                address,
+                kind: 'text',
+                text: card.text,
+                idempotencyKey: card.idempotencyKey,
+            });
+        }
+        logger.warn({ jid: job.jid, cards: result.jobCards?.length ?? 0 }, 'empty reply converted to fallback outbound');
         return;
+    }
     const { text, files } = extractFiles(raw);
-    const address = addressForJob(job);
     // Surface media tags in the footer too. Files already parsed above
     // — just map each to its kind so the footer reads e.g. "+2 image".
     const mediaKinds = files.map(kindForFile);

package/dist/memory/journal-observer.js

@@ -2,7 +2,7 @@ import { getProvider } from '../ai/providers.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { readLast } from '../store/messages.js';
-import { appendEntry, getLastScannedTs, getJournal, readEntries, setLastScannedTs, } from './journals.js';
+import { appendEntry, getLastScannedTs, getJournal, normalizeTimestamp, readEntries, setLastScannedTs, } from './journals.js';
 // How many recent messages to include in the scan window on each sweep.
 // Observer runs every memory.sweepIntervalMs (default 3h), so this window
 // must cover at least that much chat activity to avoid gaps.
@@ -19,13 +19,21 @@ async function spawnObserver(prompt) {
     return reply;
 }
 function formatMsg(m) {
-    const date = new Date(m.timestamp * 1000)
-        .toISOString()
-        .slice(0, 16)
-        .replace('T', ' ');
+    const ts = normalizeMessageTs(m);
+    const date = ts === null ? 'unknown-time' : formatTs(ts);
     const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';
     return `[${m.timestamp}] ${who} (${date}): ${m.text}`;
 }
+function formatTs(ts) {
+    const date = new Date(ts * 1000);
+    if (!Number.isFinite(ts) || Number.isNaN(date.getTime())) {
+        return 'unknown-time';
+    }
+    return date.toISOString().slice(0, 16).replace('T', ' ');
+}
+function normalizeMessageTs(m) {
+    return normalizeTimestamp(m.timestamp);
+}
 function buildPrompt(params) {
     const { journal, recentEntries, messages } = params;
     const lines = [
@@ -42,8 +50,7 @@ function buildPrompt(params) {
         recentEntries.length
             ? recentEntries
                 .map((e) => {
-                const d = new Date(e.ts * 1000).toISOString().slice(0, 16).replace('T', ' ');
-                return `- [${d}] ${e.note}`;
+                return `- [${formatTs(e.ts)}] ${e.note}`;
             })
                 .join('\n')
             : '(none yet)',
@@ -107,7 +114,10 @@ export async function runJournalObserverForJid(params) {
     }
     const since = getLastScannedTs(slug, jid);
     const recent = await readLast(jid, SCAN_WINDOW);
-    const newMessages = recent.filter((m) => m.timestamp > since);
+    const newMessages = recent.filter((m) => {
+        const ts = normalizeMessageTs(m);
+        return ts !== null && ts > since;
+    });
     if (newMessages.length === 0) {
         return { appended: 0, scanned: 0 };
     }
@@ -136,7 +146,9 @@ export async function runJournalObserverForJid(params) {
             note: e.note,
         });
     }
-    const maxTs = newMessages[newMessages.length - 1].timestamp;
+    const maxTs = Math.max(...newMessages
+        .map(normalizeMessageTs)
+        .filter((ts) => ts !== null));
     setLastScannedTs(slug, jid, maxTs);
     logger.info({ slug, jid, scanned: newMessages.length, appended: entries.length }, 'journal observer pass complete');
     return { appended: entries.length, scanned: newMessages.length };

package/dist/memory/journals.js

@@ -3,6 +3,12 @@ import { dirname, resolve } from 'path';
 import { logger } from '../logger.js';
 import { parseFrontmatter, serializeFrontmatter, } from './frontmatter.js';
 import { memoryRoot } from './paths.js';
+const JOURNAL_SOURCES = new Set([
+    'reactive',
+    'observer',
+    'manual',
+    'async',
+]);
 // ---------- paths ----------
 function journalsRoot() {
     return resolve(memoryRoot(), 'journals');
@@ -177,14 +183,72 @@ export function updateJournalStatus(slug, status) {
     return j;
 }
 // ---------- entries ----------
+export function normalizeTimestamp(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? Math.floor(value) : null;
+    }
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const n = Number(trimmed);
+        return Number.isFinite(n) ? Math.floor(n) : null;
+    }
+    const parsed = Date.parse(trimmed);
+    if (!Number.isFinite(parsed))
+        return null;
+    return Math.floor(parsed / 1000);
+}
+function normalizeSource(value) {
+    return typeof value === 'string' && JOURNAL_SOURCES.has(value)
+        ? value
+        : 'manual';
+}
+function normalizeEntry(raw, slug, lineNumber) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const ts = normalizeTimestamp(obj.ts);
+    if (ts === null) {
+        logger.warn({ slug, lineNumber, ts: obj.ts }, 'journal entry skipped: invalid timestamp');
+        return null;
+    }
+    const note = typeof obj.note === 'string' && obj.note.trim()
+        ? obj.note.trim()
+        : typeof obj.title === 'string' && obj.title.trim()
+            ? obj.title.trim()
+            : typeof obj.summary === 'string' && obj.summary.trim()
+                ? obj.summary.trim()
+                : null;
+    if (!note) {
+        logger.warn({ slug, lineNumber }, 'journal entry skipped: missing note/title/summary');
+        return null;
+    }
+    return {
+        ts,
+        source: normalizeSource(obj.source),
+        jid: typeof obj.jid === 'string' ? obj.jid : undefined,
+        senderNumber: typeof obj.senderNumber === 'string' ? obj.senderNumber : undefined,
+        note,
+    };
+}
 export function appendEntry(slug, entry) {
     if (!journalExists(slug)) {
         logger.warn({ slug }, 'journal append ignored: unknown slug');
         return false;
     }
+    const ts = entry.ts === undefined
+        ? Math.floor(Date.now() / 1000)
+        : normalizeTimestamp(entry.ts);
+    if (ts === null) {
+        logger.warn({ slug, ts: entry.ts }, 'journal append ignored: invalid timestamp');
+        return false;
+    }
     const full = {
-        ts: entry.ts ?? Math.floor(Date.now() / 1000),
-        source: entry.source,
+        ts,
+        source: normalizeSource(entry.source),
         jid: entry.jid,
         senderNumber: entry.senderNumber,
         note: entry.note,
@@ -200,11 +264,15 @@ export function readEntries(slug, limit = 100) {
     if (!raw)
         return [];
     const lines = raw.trim().split(/\r?\n/).filter(Boolean);
-    const tail = limit > 0 ? lines.slice(-limit) : lines;
+    const startIdx = limit > 0 ? Math.max(0, lines.length - limit) : 0;
+    const tail = lines.slice(startIdx);
     const out = [];
-    for (const line of tail) {
+    for (let i = 0; i < tail.length; i++) {
+        const line = tail[i];
         try {
-            out.push(JSON.parse(line));
+            const entry = normalizeEntry(JSON.parse(line), slug, startIdx + i + 1);
+            if (entry)
+                out.push(entry);
         }
         catch {
             // skip malformed line

package/dist/memory/preamble.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
 import { config } from '../config.js';
 import { getTimezoneForSenderNumber } from '../db/identity-sync.js';
 import { listAsyncTasks } from '../queue/async-tasks.js';
@@ -14,8 +15,22 @@ import { getRoleForContext } from '../wa/whitelist.js';
 // pointers — the model already has the long form.
 const DIGEST_REMINDER = `[DIGEST: <reason>] at end of reply for durable facts. Sparingly.`;
 const JOURNAL_REMINDER = `[JOURNAL:<slug> — <note>] at end of reply when content fits an active journal. Use listed slugs only.`;
-const ASYNC_REMINDER = `Never call browser_* / mcp__*playwright* tools. Delegate via [ASYNC-BROWSER: <task>]. Non-browser long work → [ASYNC: <task>]. Irreversible writes: gather → confirm → act.`;
-const THREADS_REMINDER = `Threads = your active watchlist. Open new ones with [THREAD-NEW: title="..." summary="..."]. Close with [THREAD-RESOLVE:<id> — note] / [THREAD-DROP:<id> — reason] / [THREAD-COMPRESS:<id> — note]. Touch (mention naturally) with [THREAD-TOUCH:<id>]. Cool/defer with [THREAD-COOL:<id> — wait Nd]. User voice always wins.`;
+const ASYNC_REMINDER = `Browser use/search/current web -> [ASYNC-BROWSER: <task>]. Never WebSearch/WebFetch. File generation/edit/export and long non-browser work -> [ASYNC: <task>]. Irreversible writes: gather -> confirm -> act.`;
+const THREADS_REMINDER = `THREAD-* only for active open loops shown in [Live threads]: open/update/touch/cool/resolve/drop/compress/weight. Full grammar in tag docs.`;
+function buildCoreQueueContract(outboxPath) {
+    return [
+        '[Core queue contract]',
+        'Final reply is the control surface. Tags queue work, memory, schedules, threads, or media.',
+        'Files/browser work are async. No tag = no side effect.',
+        '',
+        '[Core tag reference]',
+        'Work: [ASYNC: task], [ASYNC-BROWSER: task]',
+        `Media: [IMAGE|VIDEO|AUDIO|DOCUMENT: /absolute/path] from ${outboxPath}/`,
+        'Memory: [DIGEST: reason], [JOURNAL:slug - note], [JOURNAL-NEW:slug - purpose]',
+        'Time: [REMIND: YYYY-MM-DD HH:MM - text], [CRON: expr SAY|PROMPT|ASYNC|BROWSER - body]',
+        'Threads: THREAD-* for active open loops shown in [Live threads]. Full grammar in tag docs.',
+    ].join('\n');
+}
 // Buildable per-turn so the agent always sees the SENDER's current
 // time. Grammar reference is in cached memory-instructions.md;
 // this is just the live time + format pointer.
@@ -55,10 +70,8 @@ export function buildMemoryPreamble(params) {
     sections.push(`[Identity] ${botName}. Stay in character (voice defined in system prompt).`);
     // Time — owner-tz timestamp, no exhortations
     sections.push(`[Time] ${buildTimeLine(config.owner.timezone)}`);
-    // Capabilities — tag list only. Rules/rationale are in system prompt.
-    sections.push('[Caps] Send files: [IMAGE|VIDEO|AUDIO|DOCUMENT: /abs/path]. ' +
-        'Output dir storage/outbox/ (auto-cleaned), scratch storage/temp/. ' +
-        'Browser → [ASYNC-BROWSER: <task>]. Long non-browser work → [ASYNC: <task>].');
+    // Core tag contract — this is the side-effect API for the queued app.
+    sections.push(buildCoreQueueContract(resolve('storage/outbox')));
     // Sender + role (+ FORBIDDEN rules for non-admin)
     sections.push(buildCriticalSection({
         senderNumber: params.senderNumber,
@@ -125,7 +138,7 @@ export function buildMemoryPreamble(params) {
         instructions.push(JOURNAL_REMINDER);
     }
     // Scheduling reminder — tells the agent the current local time in
-    // the SENDER's timezone + lists the REMIND/CRON/SEND-TEXT grammar.
+    // the SENDER's timezone + lists the REMIND/CRON grammar.
     // Without this the agent never emits the tag and reminders silently
     // never fire (was the root-cause of the May 2026 reminders-not-
     // working bug).

package/dist/queue/async-tasks.js

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { getProvider } from '../ai/providers.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { config } from '../config.js';
@@ -15,6 +16,12 @@ const CONCURRENCY = 3;
 // hints to the main Claude.
 const inProgress = new Map();
 const queue = fastq.promise(async (task) => {
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        address: task.address,
+        description: task.description.slice(0, 200),
+    }, 'async task claimed from queue');
     inProgress.set(task.id, task);
     try {
         await executeAsyncTask(task);
@@ -47,6 +54,15 @@ export function listAsyncTasks(jid) {
     return all.filter((t) => t.jid === jid);
 }
 // ---------- task runner ----------
+function fileDeliveryLines() {
+    const outboxPath = resolve('storage/outbox');
+    return [
+        `FILE DELIVERY:`,
+        `- If this worker creates, edits, exports, or generates files, save final files under ${outboxPath}/.`,
+        `- Deliver each final file with [IMAGE|VIDEO|AUDIO|DOCUMENT: /absolute/path].`,
+        `- If no file was produced, say that plainly.`,
+    ];
+}
 function buildPrompt(task) {
     const lines = [
         `You are a BACKGROUND WORKER doing a delayed chat reply. The chat already got an ack ("on it, will report back"). Now you do the work, and your output IS the follow-up chat reply — the full answer the owner is waiting for.`,
@@ -65,12 +81,15 @@ function buildPrompt(task) {
         `- Concrete findings, no filler. Numbers, names, dates. If you found 10 creators, list them — don't say "multiple creators".`,
         `- If the task failed or hit a wall (login wall, empty page, bot-detection, timeout), say so honestly and briefly. Don't fabricate.`,
         ``,
+        ...fileDeliveryLines(),
+        ``,
         `OPTIONAL MARKERS (at the END of your output, same pattern as main chat):`,
         `- [JOURNAL:<slug> — <one-line finding>] for any finding that belongs in an active journal. These run IN ADDITION to your chat reply — they file structured entries in journals/<slug>/entries.jsonl for future reference, dedup, and cross-session memory. Use existing slugs only (check [Journals: active] in your preamble). ONE marker per finding.`,
         `- [JOURNAL-NEW:<slug> — <one-line purpose>] if the task clearly deserves a new journal that doesn't exist yet. Conservative — only when the topic is a recurring tracking surface, not a one-off.`,
         `- [DIGEST: <one-line reason>] if you learned something durable about the owner or chat that should update the profile/brief.`,
         ``,
         `CONSTRAINTS:`,
+        `- You are already the async worker. Do the task here, including file work.`,
         `- Do NOT emit [ASYNC:...]. No recursive delegation.`,
         `- Markers are bonus persistence, not a substitute for the chat reply. Always write the chat reply first.`,
         `- Stay fully in character (personality).`,
@@ -297,6 +316,8 @@ function buildBrowserPrompt(task) {
         `- Concrete findings only. Numbers, names, dates. If you found 10 creators, list them.`,
         `- Failure mode: page hung, login wall, bot-detection, empty feed — say so briefly. Do NOT fabricate.`,
         ``,
+        ...fileDeliveryLines(),
+        ``,
         `BAIL CONDITIONS (stop and report, don't burn the clock):`,
         `- Same tool call with same args retried 3 times → stuck, bail.`,
         `- 3 consecutive empty/error responses from the site → site is throttling, bail.`,
@@ -309,6 +330,7 @@ function buildBrowserPrompt(task) {
         `- [DIGEST: <reason>] if a durable fact about the owner/chat came up.`,
         ``,
         `CONSTRAINTS:`,
+        `- You are already the browser worker. Do the browser task here.`,
         `- Do NOT emit [ASYNC:...] or [ASYNC-BROWSER:...]. No recursion.`,
         `- Markers are bonus persistence, not a substitute for the reply.`,
         `- Stay fully in character (personality).`,

package/dist/queue/browser-queue.js

@@ -11,10 +11,11 @@
 import { and, asc, eq, isNull, lte, or, sql } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { browserTasks } from '../db/schema.js';
+import { logger } from '../logger.js';
 export function enqueueBrowserJob(input) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
-    return db
+    const row = db
         .insert(browserTasks)
         .values({
         address: input.address,
@@ -37,11 +38,18 @@ export function enqueueBrowserJob(input) {
     })
         .returning()
         .get();
+    logger.info({
+        id: row.id,
+        address: row.address,
+        senderNumber: row.senderNumber,
+        chars: row.description.length,
+    }, 'browser job added to queue');
+    return row;
 }
 export function claimNextBrowserTask(workerId) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
-    return db.transaction((tx) => {
+    const claimed = db.transaction((tx) => {
         const target = tx
             .select({ id: browserTasks.id })
             .from(browserTasks)
@@ -64,6 +72,15 @@ export function claimNextBrowserTask(workerId) {
             .get();
         return claimed ?? null;
     });
+    if (claimed) {
+        logger.info({
+            id: claimed.id,
+            address: claimed.address,
+            workerId,
+            attempts: claimed.attempts,
+        }, 'browser job claimed from queue');
+    }
+    return claimed;
 }
 export function markBrowserTaskDone(id, workerId) {
     const db = getDb();

package/dist/queue/inbound.js

@@ -8,6 +8,7 @@
 import { and, asc, eq, isNull, lte, notInArray, or, sql } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { inbound } from '../db/schema.js';
+import { logger } from '../logger.js';
 // Idempotent on external_msg_id when set. Same channel message
 // arriving twice (Baileys replay, network retransmit) returns the
 // existing row instead of duplicating.
@@ -20,8 +21,15 @@ export function enqueueInbound(input) {
             .from(inbound)
             .where(eq(inbound.externalMsgId, input.externalMsgId))
             .get();
-        if (found)
+        if (found) {
+            logger.info({
+                id: found.id,
+                address: found.address,
+                externalMsgId: input.externalMsgId,
+                status: found.status,
+            }, 'inbound job enqueue deduped');
             return { inserted: false, row: found };
+        }
     }
     const row = db
         .insert(inbound)
@@ -51,6 +59,15 @@ export function enqueueInbound(input) {
     })
         .returning()
         .get();
+    logger.info({
+        id: row.id,
+        address: row.address,
+        kind: row.kind,
+        externalMsgId: row.externalMsgId,
+        triggerReason: row.triggerReason,
+        chars: row.text.length,
+        mediaBytes: row.mediaBytes,
+    }, 'inbound job added to queue');
     return { inserted: true, row };
 }
 // Atomic claim with per-address serialization. Skips any pending row
@@ -60,7 +77,7 @@ export function enqueueInbound(input) {
 export function claimNextInbound(workerId) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
-    return db.transaction((tx) => {
+    const claimed = db.transaction((tx) => {
         // Subquery: addresses currently claimed (= one in-flight per chat).
         const busyAddrs = tx
             .select({ address: inbound.address })
@@ -97,6 +114,16 @@ export function claimNextInbound(workerId) {
             .get();
         return claimed ?? null;
     });
+    if (claimed) {
+        logger.info({
+            id: claimed.id,
+            address: claimed.address,
+            workerId,
+            kind: claimed.kind,
+            attempts: claimed.attempts,
+        }, 'inbound job claimed from queue');
+    }
+    return claimed;
 }
 export function markInboundDone(id, workerId) {
     const db = getDb();

package/dist/queue/outbound.js

@@ -8,6 +8,7 @@
 import { and, asc, eq, isNull, lte, or, sql } from 'drizzle-orm';
 import { getDb } from '../db/index.js';
 import { outbound } from '../db/schema.js';
+import { logger } from '../logger.js';
 // Insert a row, or no-op when the same idempotency_key already exists.
 // Returns the row either way so callers can log/observe.
 export function enqueueOutbound(input) {
@@ -22,8 +23,16 @@ export function enqueueOutbound(input) {
             .from(outbound)
             .where(eq(outbound.idempotencyKey, input.idempotencyKey))
             .get();
-        if (found)
+        if (found) {
+            logger.info({
+                id: found.id,
+                address: found.address,
+                kind: found.kind,
+                idempotencyKey: input.idempotencyKey,
+                status: found.status,
+            }, 'outbound job enqueue deduped');
             return { inserted: false, row: found };
+        }
     }
     const inserted = db
         .insert(outbound)
@@ -47,6 +56,14 @@ export function enqueueOutbound(input) {
     })
         .returning()
         .get();
+    logger.info({
+        id: inserted.id,
+        address: inserted.address,
+        kind: inserted.kind,
+        idempotencyKey: inserted.idempotencyKey,
+        chars: inserted.text?.length ?? 0,
+        mediaBytes: inserted.mediaBytes,
+    }, 'outbound job added to queue');
     return { inserted: true, row: inserted };
 }
 // Atomic claim. Returns the row or null if nothing's ready.
@@ -57,7 +74,7 @@ export function claimNextOutbound(workerId) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
     // SQLite supports UPDATE ... RETURNING since 3.35.
-    return db.transaction((tx) => {
+    const claimed = db.transaction((tx) => {
         const target = tx
             .select({ id: outbound.id })
             .from(outbound)
@@ -80,6 +97,16 @@ export function claimNextOutbound(workerId) {
             .get();
         return claimed ?? null;
     });
+    if (claimed) {
+        logger.info({
+            id: claimed.id,
+            address: claimed.address,
+            workerId,
+            kind: claimed.kind,
+            attempts: claimed.attempts,
+        }, 'outbound job claimed from queue');
+    }
+    return claimed;
 }
 // Mark done — succeeds only when the row is still owned by the caller.
 // Returns whether the update actually applied.

package/dist/wa/whitelist.js

@@ -82,9 +82,9 @@ const DEFAULT_ROLES = {
         dailyTokenLimit: null,
     },
     user: {
-        description: 'Chat + web search, scoped memory',
+        description: 'Chat + scoped memory',
         memory: 'self',
-        tools: ['WebSearch'],
+        tools: [],
         // Users can flag memory observations and trigger digests on
         // themselves, but can't delegate background work or cross-chat
         // sends (those are owner-only).

package/package.json

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