@c4t4/heyamigo 0.6.1 → 0.7.1

package/config/memory-instructions.md

@@ -133,44 +133,55 @@ Confirm the change in your reply so the owner sees what you did:
 
 ## ASYNC background work
 
-The chat queue is serialized per chat. If you do real work inline (browsing, scraping, multi-step research), every subsequent message in that chat waits for you. To stay responsive, delegate long work to a background worker.
+**ANY browser tool use goes through a background worker. No exceptions. Ever.**
+
+The chat queue is serialized per chat. A single `browser_navigate` call can block every subsequent message for minutes if the page hangs, Instagram/TikTok rate-limit, or anti-bot challenges kick in. This happens constantly in practice. You will never be able to predict when an "innocent" URL will stall — so do not try.
+
+Hard rule: if ANY part of fulfilling a request needs a browser tool (`browser_navigate`, `browser_click`, `browser_take_screenshot`, `browser_snapshot`, `browser_type`, `browser_evaluate`, or any `mcp__*playwright*` tool), delegate to the async lane. Even a single URL. Even "just checking quickly". Even when the user says "just".
+
+### How to delegate
 
 Two parts in the same reply:
 
-1. A one or two-sentence ack in the reply text: "On it, will report back." / "Scraping now, give me a few minutes." / "Looking into it."
-2. Append at the END:
+1. One or two-sentence ack in the reply text. Short. No over-explaining. Examples: "On it, will report back." / "Scraping now, few minutes." / "Looking into it."
+2. Append at the END of your reply:
    ```
    [ASYNC: <self-sufficient task description>]
    ```
 
-Example:
+Full example for a single-URL Instagram check:
 
 ```
-On it. Will send the list when it's ready.
+On it. Will send the bio and recent posts shortly.
 
-[ASYNC: Find 10 additional German TikTok creators documenting hair transplant journeys, 500-3000 followers, not in this list: @simply__stefan, @daenieal, @myhairjourney2025, @chigosfoodblog. Use the Rivoara TikTok account (already logged in) to browse. Output handle, follower count, one-line angle per creator.]
+[ASYNC: Navigate to https://instagram.com/rivoara_official using the browser tool. Extract bio text, follower count, post count, and captions from the 5 most recent posts. Output as plain text with clear sections. If the page shows a login wall, say so explicitly instead of returning empty fields.]
 ```
 
-### When to use ASYNC
+The async worker has full browser access and will do the work without blocking this chat. When done, the result lands in this chat as a new message.
 
-Use it for:
-- Browser work (scraping, multi-page research, form filling, anything touching >1 URL)
+### When to use ASYNC (besides browser)
+
+Also use it for:
 - Multi-step investigations with several tool calls
 - Anything you expect to take more than ~30 seconds
 
-Do NOT use it for:
-- A single quick URL fetch
-- Short calculations or reasoning
-- Anything you can answer from context alone
-- Things the owner needs answered in this reply, right now
+### When NOT to use ASYNC
+
+- Things answerable from your context, memory, compressed view, or recent entries — just answer
+- Short reasoning, calculations, or explanations
+- Immediate questions the owner needs answered RIGHT NOW in this reply
+- Single quick non-browser tool calls (e.g. one Read, one Grep)
+
+Browser is the hard "always async" rule. Everything else is judgment.
 
 ### Writing the task description
 
 The async worker has NO chat history, NO session, no memory of your conversation. Its only input is the description you write. Self-sufficient means:
 - Spell out exactly what to do.
-- Include every constraint, exclusion, and required context.
-- Reference specific tools or accounts (e.g. "use the Rivoara TikTok session").
-- Specify the expected output shape (list format, fields, order).
+- Include every constraint, exclusion, and required context (URLs, accounts, filters).
+- Reference any logged-in sessions the worker should use (e.g. "use the Rivoara TikTok account, already logged in").
+- Specify the expected output shape (fields, order, format).
+- If the task might hit a login wall, anti-bot page, or empty result — explicitly say what to do in that case.
 
 Over-specify. A vague description produces a vague result.
 
@@ -198,6 +209,6 @@ Rules:
 
 You have a Chrome browser via Playwright MCP: `browser_navigate`, `browser_take_screenshot`, `browser_snapshot`, `browser_click`, `browser_type`, `browser_evaluate`, etc.
 
-For anything beyond a single page load, use `[ASYNC: ...]` instead of running inline. Browser work blocks the main queue.
+**Never use them inline.** All browser work goes through the async lane — see the ASYNC section above. No exceptions for "quick checks" or "just one URL". Delegate every time.
 
-To send a screenshot back: take it with the browser tool (save to `storage/temp/`), then include `[IMAGE: /absolute/path.png]` in your reply.
+To send a screenshot back from an async task: the async worker takes it with the browser tool (saving to `storage/temp/`), then includes `[IMAGE: /absolute/path.png]` in its result message.

package/dist/ai/claude.js

@@ -1,9 +1,9 @@
-import { spawn } from 'child_process';
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
+import { runClaude, TIMEOUT_MS } from './spawn.js';
 let cachedSystemPrompt = null;
 function systemPrompt() {
     if (cachedSystemPrompt !== null)
@@ -56,80 +56,47 @@ function buildArgs(params) {
 }
 export async function askClaude(params) {
     const args = buildArgs(params);
-    const startedAt = Date.now();
     logger.debug({ resume: !!params.sessionId, inputChars: params.input.length }, 'spawning claude');
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk.toString('utf-8');
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += chunk.toString('utf-8');
-        });
-        child.on('error', (err) => {
-            void logPrompt({
-                ts: Math.floor(startedAt / 1000),
-                caller: 'worker',
-                args,
-                input: params.input,
-                error: `spawn failed: ${err.message}`,
-                durationMs: Date.now() - startedAt,
-            });
-            rejectPromise(new Error(`claude spawn failed: ${err.message}`));
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'worker',
-                    args,
-                    input: params.input,
-                    error: `exit ${code}: ${stderr.slice(0, 500)}`,
-                    durationMs: Date.now() - startedAt,
-                });
-                return rejectPromise(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error || parsed.subtype !== 'success') {
-                    return rejectPromise(new Error(`claude returned error (subtype=${parsed.subtype}): ${parsed.result ?? stderr.slice(0, 200)}`));
-                }
-                if (!parsed.result || !parsed.session_id) {
-                    return rejectPromise(new Error(`claude output missing result or session_id: ${stdout.slice(0, 200)}`));
-                }
-                const result = {
-                    reply: parsed.result,
-                    sessionId: parsed.session_id,
-                    usage: {
-                        inputTokens: parsed.usage?.input_tokens ?? 0,
-                        cacheReadTokens: parsed.usage?.cache_read_input_tokens ?? 0,
-                        cacheCreationTokens: parsed.usage?.cache_creation_input_tokens ?? 0,
-                        outputTokens: parsed.usage?.output_tokens ?? 0,
-                        numTurns: parsed.num_turns ?? 0,
-                    },
-                };
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'worker',
-                    args,
-                    input: params.input,
-                    output: result.reply,
-                    sessionId: result.sessionId,
-                    usage: result.usage,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(result);
-            }
-            catch (err) {
-                rejectPromise(new Error(`failed to parse claude output: ${err.message}\nstdout: ${stdout.slice(0, 500)}`));
-            }
-        });
-        child.stdin.write(params.input);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: params.input,
+        timeoutMs: TIMEOUT_MS.main,
+        caller: 'worker',
     });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`failed to parse claude output: ${err.message}\nstdout: ${stdout.slice(0, 500)}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success') {
+        throw new Error(`claude returned error (subtype=${parsed.subtype}): ${parsed.result ?? ''}`);
+    }
+    if (!parsed.result || !parsed.session_id) {
+        throw new Error(`claude output missing result or session_id: ${stdout.slice(0, 200)}`);
+    }
+    const result = {
+        reply: parsed.result,
+        sessionId: parsed.session_id,
+        usage: {
+            inputTokens: parsed.usage?.input_tokens ?? 0,
+            cacheReadTokens: parsed.usage?.cache_read_input_tokens ?? 0,
+            cacheCreationTokens: parsed.usage?.cache_creation_input_tokens ?? 0,
+            outputTokens: parsed.usage?.output_tokens ?? 0,
+            numTurns: parsed.num_turns ?? 0,
+        },
+    };
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'worker',
+        args,
+        input: params.input,
+        output: result.reply,
+        sessionId: result.sessionId,
+        usage: result.usage,
+        durationMs,
+    });
+    return result;
 }

package/dist/ai/spawn.js

@@ -0,0 +1,121 @@
+import { spawn } from 'child_process';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+export class ClaudeTimeoutError extends Error {
+    caller;
+    durationMs;
+    timeoutMs;
+    constructor(caller, durationMs, timeoutMs) {
+        super(`${caller} timed out after ${Math.round(durationMs / 1000)}s (cap ${Math.round(timeoutMs / 1000)}s)`);
+        this.caller = caller;
+        this.durationMs = durationMs;
+        this.timeoutMs = timeoutMs;
+        this.name = 'ClaudeTimeoutError';
+    }
+}
+export class ClaudeSpawnError extends Error {
+    caller;
+    constructor(caller, message) {
+        super(message);
+        this.caller = caller;
+        this.name = 'ClaudeSpawnError';
+    }
+}
+// Kill the process group of a detached child. Playwright MCP and any Chromium
+// children sit under the claude subprocess; without process-group kill they
+// linger after we SIGTERM the parent and accumulate on the host.
+function killGroup(child, signal) {
+    if (!child.pid)
+        return;
+    try {
+        // Negative PID = target the whole process group (see kill(2)).
+        process.kill(-child.pid, signal);
+    }
+    catch (err) {
+        // Fallback: signal just the parent. Better than nothing.
+        try {
+            child.kill(signal);
+        }
+        catch {
+            logger.warn({ err, pid: child.pid }, 'failed to kill claude subprocess');
+        }
+    }
+}
+// Run a `claude -p ...` subprocess with a hard timeout, full-tree kill on
+// expiry, and uniform promptlog handling. All claude spawns in the codebase
+// should go through this.
+export async function runClaude(opts) {
+    const { args, input, timeoutMs, caller } = opts;
+    const startedAt = Date.now();
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn('claude', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: opts.cwd ?? process.cwd(),
+            // detached:true puts the child in its own process group, so killGroup
+            // can SIGTERM the whole tree (Playwright MCP, Chromium, etc.) at once.
+            detached: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const logFail = (error) => void logPrompt({
+            ts: Math.floor(startedAt / 1000),
+            caller,
+            args,
+            input,
+            error,
+            durationMs: Date.now() - startedAt,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            logger.warn({ caller, pid: child.pid, timeoutMs }, 'claude subprocess timed out, killing process group');
+            killGroup(child, 'SIGTERM');
+            // Grace window, then SIGKILL if still alive.
+            setTimeout(() => {
+                if (!settled)
+                    killGroup(child, 'SIGKILL');
+            }, 2000).unref();
+        }, timeoutMs);
+        timer.unref();
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf-8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf-8');
+        });
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            logFail(`spawn failed: ${err.message}`);
+            rejectPromise(new ClaudeSpawnError(caller, `claude spawn failed: ${err.message}`));
+        });
+        child.on('close', (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const durationMs = Date.now() - startedAt;
+            if (timedOut) {
+                logFail(`timeout after ${durationMs}ms (cap ${timeoutMs}ms); signal=${signal}`);
+                return rejectPromise(new ClaudeTimeoutError(caller, durationMs, timeoutMs));
+            }
+            if (code !== 0) {
+                logFail(`exit ${code}: ${stderr.slice(0, 500)}`);
+                return rejectPromise(new ClaudeSpawnError(caller, `claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+            }
+            resolvePromise({ stdout, durationMs });
+        });
+        child.stdin.write(input);
+        child.stdin.end();
+    });
+}
+// Per-lane defaults. Individual callers can override, but these are the
+// shipped caps. Browser-heavy work lives in the async lane.
+export const TIMEOUT_MS = {
+    main: 5 * 60 * 1000,
+    async: 15 * 60 * 1000,
+    background: 3 * 60 * 1000,
+};

package/dist/gateway/incoming.js

@@ -166,15 +166,29 @@ async function processMessages(messages, sock, ownerJid, isHistorySync = false)
                     clearInterval(typingHeartbeat);
                 typingHeartbeat = null;
             };
+            // Defense-in-depth: if nothing else clears the heartbeat within 10 min
+            // (e.g. a code path forgot), force-stop. Prevents runaway "typing..."
+            // indicators when the pipeline silently fails.
+            const typingSafetyCap = setTimeout(() => {
+                if (typingHeartbeat) {
+                    logger.warn({ jid: job.jid }, 'typingHeartbeat safety-cap fired, forcing clear');
+                    stopTyping();
+                }
+            }, 10 * 60 * 1000);
+            typingSafetyCap.unref();
             enqueue(job)
-                .then((result) => {
-                stopTyping();
-                return handleReply(job, result, msg);
-            })
+                .then((result) => handleReply(job, result, msg))
                 .catch((err) => {
+                const isTimeout = err instanceof Error && err.name === 'ClaudeTimeoutError';
+                logger.error({ err, jid: job.jid, isTimeout }, 'pipeline failed');
+                const replyText = isTimeout
+                    ? 'That request timed out. The task was cancelled, queue is moving.'
+                    : config.reply.errorMessage;
+                return handleReply(job, { reply: replyText }, msg).catch((e) => logger.error({ err: e, jid: job.jid }, 'failed to send error reply'));
+            })
+                .finally(() => {
                 stopTyping();
-                logger.error({ err, jid: job.jid }, 'pipeline failed');
-                void handleReply(job, { reply: config.reply.errorMessage }, msg).catch((e) => logger.error({ err: e, jid: job.jid }, 'failed to send error reply'));
+                clearTimeout(typingSafetyCap);
             });
         }
         catch (err) {

package/dist/memory/compressed.js

@@ -1,7 +1,7 @@
-import { spawn } from 'child_process';
 import { existsSync, readFileSync, readdirSync, writeFileSync, } from 'fs';
 import { dirname, resolve } from 'path';
 import { mkdirSync } from 'fs';
+import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -230,64 +230,33 @@ async function spawnGenerator(prompt) {
         '--permission-mode',
         'acceptEdits',
     ];
-    const startedAt = Date.now();
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (c) => {
-            stdout += c.toString('utf-8');
-        });
-        child.stderr.on('data', (c) => {
-            stderr += c.toString('utf-8');
-        });
-        const logFail = (error) => void logPrompt({
-            ts: Math.floor(startedAt / 1000),
-            caller: 'compressed',
-            args,
-            input: prompt,
-            error,
-            durationMs: Date.now() - startedAt,
-        });
-        child.on('error', (err) => {
-            logFail(`spawn failed: ${err.message}`);
-            rejectPromise(err);
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
-                return rejectPromise(new Error(`compressed generator exit ${code}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error ||
-                    parsed.subtype !== 'success' ||
-                    !parsed.result) {
-                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
-                    return rejectPromise(new Error('compressed generator bad output'));
-                }
-                const output = parsed.result.trim();
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'compressed',
-                    args,
-                    input: prompt,
-                    output,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(output);
-            }
-            catch (err) {
-                logFail(`parse failed: ${err.message}`);
-                rejectPromise(err);
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: prompt,
+        timeoutMs: TIMEOUT_MS.background,
+        caller: 'compressed',
+    });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`compressed parse failed: ${err.message}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`compressed bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    }
+    const output = parsed.result.trim();
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'compressed',
+        args,
+        input: prompt,
+        output,
+        durationMs,
     });
+    return output;
 }
 let buildInFlight = null;
 export async function rebuildCompressed() {

package/dist/memory/digest.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -19,62 +19,33 @@ async function spawnDigester(prompt) {
         '--permission-mode',
         'acceptEdits',
     ];
-    const startedAt = Date.now();
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk.toString('utf-8');
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += chunk.toString('utf-8');
-        });
-        const logFail = (error) => void logPrompt({
-            ts: Math.floor(startedAt / 1000),
-            caller: 'digester',
-            args,
-            input: prompt,
-            error,
-            durationMs: Date.now() - startedAt,
-        });
-        child.on('error', (err) => {
-            logFail(`spawn failed: ${err.message}`);
-            rejectPromise(new Error(`digester spawn failed: ${err.message}`));
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
-                return rejectPromise(new Error(`digester exit ${code}: ${stderr.slice(0, 300)}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
-                    return rejectPromise(new Error(`digester bad output: ${parsed.result ?? stderr.slice(0, 200)}`));
-                }
-                const output = parsed.result.trim();
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'digester',
-                    args,
-                    input: prompt,
-                    output,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(output);
-            }
-            catch (err) {
-                logFail(`parse failed: ${err.message}`);
-                rejectPromise(new Error(`digester parse failed: ${err.message}`));
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: prompt,
+        timeoutMs: TIMEOUT_MS.background,
+        caller: 'digester',
+    });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`digester parse failed: ${err.message}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`digester bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    }
+    const output = parsed.result.trim();
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'digester',
+        args,
+        input: prompt,
+        output,
+        durationMs,
     });
+    return output;
 }
 function formatMessagesForDigest(messages) {
     return messages

package/dist/memory/journal-nudger.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { initiate } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
@@ -24,64 +24,33 @@ async function spawnComposer(prompt) {
         '--permission-mode',
         'acceptEdits',
     ];
-    const startedAt = Date.now();
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (c) => {
-            stdout += c.toString('utf-8');
-        });
-        child.stderr.on('data', (c) => {
-            stderr += c.toString('utf-8');
-        });
-        const logFail = (error) => void logPrompt({
-            ts: Math.floor(startedAt / 1000),
-            caller: 'journal-nudger',
-            args,
-            input: prompt,
-            error,
-            durationMs: Date.now() - startedAt,
-        });
-        child.on('error', (err) => {
-            logFail(`spawn failed: ${err.message}`);
-            rejectPromise(err);
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
-                return rejectPromise(new Error(`nudger exit ${code}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error ||
-                    parsed.subtype !== 'success' ||
-                    !parsed.result) {
-                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
-                    return rejectPromise(new Error('nudger bad output'));
-                }
-                const output = parsed.result.trim();
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'journal-nudger',
-                    args,
-                    input: prompt,
-                    output,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(output);
-            }
-            catch (err) {
-                logFail(`parse failed: ${err.message}`);
-                rejectPromise(err);
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: prompt,
+        timeoutMs: TIMEOUT_MS.background,
+        caller: 'journal-nudger',
+    });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`nudger parse failed: ${err.message}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`nudger bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    }
+    const output = parsed.result.trim();
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'journal-nudger',
+        args,
+        input: prompt,
+        output,
+        durationMs,
     });
+    return output;
 }
 function formatMsg(m) {
     const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';

package/dist/memory/journal-observer.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -20,64 +20,33 @@ async function spawnObserver(prompt) {
         '--permission-mode',
         'acceptEdits',
     ];
-    const startedAt = Date.now();
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk.toString('utf-8');
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += chunk.toString('utf-8');
-        });
-        const logFail = (error) => void logPrompt({
-            ts: Math.floor(startedAt / 1000),
-            caller: 'journal-observer',
-            args,
-            input: prompt,
-            error,
-            durationMs: Date.now() - startedAt,
-        });
-        child.on('error', (err) => {
-            logFail(`spawn failed: ${err.message}`);
-            rejectPromise(new Error(`journal observer spawn failed: ${err.message}`));
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
-                return rejectPromise(new Error(`journal observer exit ${code}: ${stderr.slice(0, 300)}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error ||
-                    parsed.subtype !== 'success' ||
-                    !parsed.result) {
-                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
-                    return rejectPromise(new Error(`journal observer bad output: ${parsed.result ?? stderr.slice(0, 200)}`));
-                }
-                const output = parsed.result.trim();
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'journal-observer',
-                    args,
-                    input: prompt,
-                    output,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(output);
-            }
-            catch (err) {
-                logFail(`parse failed: ${err.message}`);
-                rejectPromise(new Error(`journal observer parse failed: ${err.message}`));
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: prompt,
+        timeoutMs: TIMEOUT_MS.background,
+        caller: 'journal-observer',
+    });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`journal observer parse failed: ${err.message}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`journal observer bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    }
+    const output = parsed.result.trim();
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'journal-observer',
+        args,
+        input: prompt,
+        output,
+        durationMs,
     });
+    return output;
 }
 function formatMsg(m) {
     const date = new Date(m.timestamp * 1000)

package/dist/queue/async-tasks.js

@@ -1,6 +1,6 @@
-import { spawn } from 'child_process';
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
+import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import fastq from 'fastq';
 import { initiate } from '../gateway/outgoing.js';
@@ -118,64 +118,33 @@ function buildArgs(task) {
 }
 async function spawnClaudeForTask(task, prompt) {
     const args = buildArgs(task);
-    const startedAt = Date.now();
-    return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: process.cwd(),
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (c) => {
-            stdout += c.toString('utf-8');
-        });
-        child.stderr.on('data', (c) => {
-            stderr += c.toString('utf-8');
-        });
-        const logFail = (error) => void logPrompt({
-            ts: Math.floor(startedAt / 1000),
-            caller: 'async-task',
-            args,
-            input: prompt,
-            error,
-            durationMs: Date.now() - startedAt,
-        });
-        child.on('error', (err) => {
-            logFail(`spawn failed: ${err.message}`);
-            rejectPromise(err);
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
-                return rejectPromise(new Error(`async task exit ${code}`));
-            }
-            try {
-                const parsed = JSON.parse(stdout);
-                if (parsed.is_error ||
-                    parsed.subtype !== 'success' ||
-                    !parsed.result) {
-                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
-                    return rejectPromise(new Error('async task bad output'));
-                }
-                const output = parsed.result.trim();
-                void logPrompt({
-                    ts: Math.floor(startedAt / 1000),
-                    caller: 'async-task',
-                    args,
-                    input: prompt,
-                    output,
-                    durationMs: Date.now() - startedAt,
-                });
-                resolvePromise(output);
-            }
-            catch (err) {
-                logFail(`parse failed: ${err.message}`);
-                rejectPromise(err);
-            }
-        });
-        child.stdin.write(prompt);
-        child.stdin.end();
+    const { stdout, durationMs } = await runClaude({
+        args,
+        input: prompt,
+        timeoutMs: TIMEOUT_MS.async,
+        caller: 'async-task',
+    });
+    const startedAt = Date.now() - durationMs;
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (err) {
+        throw new Error(`async task parse failed: ${err.message}`);
+    }
+    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`async task bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    }
+    const output = parsed.result.trim();
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: 'async-task',
+        args,
+        input: prompt,
+        output,
+        durationMs,
     });
+    return output;
 }
 async function runTask(task) {
     const prompt = buildPrompt(task);

package/package.json

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