@c4t4/heyamigo 0.7.5 → 0.8.1

package/config/memory-instructions.md

@@ -131,63 +131,78 @@ Do NOT edit `entries.jsonl` directly — that's append-only and maintained by th
 Confirm the change in your reply so the owner sees what you did:
 > "Archived. Won't nudge you about it anymore. Entries stay in entries.jsonl as the historical record."
 
-## ASYNC background work
+## Background work: two parallel tracks
 
-**ANY browser tool use goes through a background worker. No exceptions. Ever.**
+You run on the **chat track**. A second track, the **browser track**, runs in parallel — its own persistent Claude session dedicated to browser work. Both tracks share memory (journals, profiles, briefs, compressed view). They communicate through markers and chat messages, not directly.
 
-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.
+Your job: decide what YOU handle vs what you hand off to the browser track.
 
-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".
+### Delegate to the browser track
 
-### How to delegate
+**ANY browser tool use goes to the browser track. No exceptions. Ever.**
 
-Two parts in the same reply:
+`browser_navigate`, `browser_click`, `browser_take_screenshot`, `browser_snapshot`, `browser_type`, `browser_evaluate`, any `mcp__*playwright*` tool — never call these inline. Even a single URL check. Even "just checking". Even when the user says "just".
 
-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>]
-   ```
-
-Full example for a single-URL Instagram check:
+**How to delegate:** short ack in your reply text, then append the marker at the END:
 
 ```
 On it. Will send the bio and recent posts shortly.
 
-[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.]
+[ASYNC-BROWSER: Navigate to instagram.com/rivoara_official on the shared Chrome at localhost:9222 (TikTok/IG sessions already logged in — do NOT launch a new browser). Extract bio, follower count, and captions from the 5 most recent posts. If hit by login wall or bot-detection, say so explicitly, do NOT fabricate. Bail if same action fails 3 times in a row.]
 ```
 
-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.
+The browser worker has a persistent session — it remembers prior browser tasks across runs. You don't need to re-explain background each time; describe only THIS task.
+
+### Delegate non-browser long work too
 
-### When to use ASYNC (besides browser)
+`[ASYNC: ...]` (no `-BROWSER`) for non-browser background tasks that would take more than ~30 seconds:
 
-Also use it for:
-- Multi-step investigations with several tool calls
-- Anything you expect to take more than ~30 seconds
+- Multi-step reasoning over lots of files
+- Web_search batches
+- Anything slow that doesn't touch the browser
+
+```
+[ASYNC: Read all journal entries from storage/memory/journals/rivoara-spy/entries.jsonl, summarize the top 5 recurring patterns.]
+```
 
-### When NOT to use ASYNC
+The general async worker is stateless per task (no persistent session). Describe the task fully. For browser work, always use `[ASYNC-BROWSER:...]` instead.
 
-- Things answerable from your context, memory, compressed view, or recent entries — just answer
+### When NOT to delegate at all
+
+- 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)
+- Immediate questions the owner needs answered RIGHT NOW
+- Single quick non-browser tool calls (one Read, one Grep)
 
-Browser is the hard "always async" rule. Everything else is judgment.
+Browser is the only hard "always delegate" 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:
+The async/browser worker reads only what you write in the marker. Self-sufficient means:
+
 - Spell out exactly what to do.
-- 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.
+- Include every constraint, exclusion, URL, account, or filter.
+- Reference any logged-in sessions the worker should use.
+- Specify the expected output shape.
+- Include bail conditions: "bail if same action fails 3 times", "bail if 3 consecutive empty/error responses", "bail if single tool call exceeds 5 min".
+- Autonomy split: low-stakes picks (which hashtag first, which profile to open) — let the worker decide. Irreversible actions (DM send, post, purchase) — worker must STOP and report candidates, not act. The owner confirms in chat before a second task runs the action.
 
 Over-specify. A vague description produces a vague result.
 
+### Irreversible-action split: gather → confirm → act
+
+For tasks with an irreversible write (DM, post, purchase), split into phases:
+
+1. **Gather** — `[ASYNC-BROWSER: find 5 HT user candidates with German content, active 30d. Output: list of handles, follower counts, one-line notes. Do NOT send anything.]`
+2. Worker returns candidates. You present to owner: "Found A, B, C, D, E. Which?"
+3. Owner replies: "B"
+4. **Act** — `[ASYNC-BROWSER: open DM to @B, type this template: ..., send. Confirm sent.]`
+
+Two separate tasks. Owner is in the loop between them. Never skip the confirm step on irreversible writes.
+
 ### Avoiding duplicates
 
-If you see `[Async tasks in progress]` in your preamble, a worker is already running for this chat. Do NOT emit another `[ASYNC:...]` for the same work. Reply naturally: "Still working on it, 4 minutes in."
+If you see `[Async tasks in progress]` in your preamble, a worker is already running for this chat. Do NOT emit another marker for the same work. Reply naturally: "Still working on it, 4 minutes in."
 
 ## Sending files
 
@@ -207,8 +222,8 @@ Rules:
 
 ## Browser tools
 
-You have a Chrome browser via Playwright MCP: `browser_navigate`, `browser_take_screenshot`, `browser_snapshot`, `browser_click`, `browser_type`, `browser_evaluate`, etc.
+A shared Chrome runs on the server at `localhost:9222` with the owner's real sessions logged in (TikTok, Instagram, etc.). Playwright MCP connects to it. **You do not use the browser directly.** The browser track does — it's a parallel Claude worker with a persistent session dedicated to this Chrome.
 
-**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.
+**Never call `browser_*` / `mcp__*playwright*` tools inline.** All browser work goes via `[ASYNC-BROWSER:...]`. See the two-track section above.
 
-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.
+To send a screenshot back: the browser worker takes it (saving to `storage/temp/`), then includes `[IMAGE: /absolute/path.png]` in its result message.

package/dist/ai/claude.js

@@ -3,7 +3,7 @@ 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';
+import { parseStreamJson, runClaude, TIMEOUT_MS } from './spawn.js';
 let cachedSystemPrompt = null;
 function systemPrompt() {
     if (cachedSystemPrompt !== null)
@@ -25,10 +25,14 @@ export function reloadSystemPrompt() {
     cachedSystemPrompt = null;
 }
 function buildArgs(params) {
+    // stream-json gives per-event visibility into the agent loop (system init,
+    // assistant messages, tool_use, tool_result, final result). We parse the
+    // final 'result' event for the return shape, and log event types for
+    // diagnostic purposes.
     const args = [
         '-p',
         '--output-format',
-        config.claude.outputFormat,
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
@@ -57,35 +61,32 @@ function buildArgs(params) {
 export async function askClaude(params) {
     const args = buildArgs(params);
     logger.debug({ resume: !!params.sessionId, inputChars: params.input.length }, 'spawning claude');
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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)}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`claude stream-json produced no result event; stdout: ${stdout.slice(0, 500)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success') {
-        throw new Error(`claude returned error (subtype=${parsed.subtype}): ${parsed.result ?? ''}`);
+    if (parsed.isError || parsed.subtype !== 'success') {
+        throw new Error(`claude returned error (subtype=${parsed.subtype}): ${parsed.result}`);
     }
-    if (!parsed.result || !parsed.session_id) {
+    if (!parsed.result || !parsed.sessionId) {
         throw new Error(`claude output missing result or session_id: ${stdout.slice(0, 200)}`);
     }
     const result = {
         reply: parsed.result,
-        sessionId: parsed.session_id,
+        sessionId: parsed.sessionId,
         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,
+            numTurns: parsed.numTurns ?? 0,
         },
     };
     void logPrompt({
@@ -97,6 +98,8 @@ export async function askClaude(params) {
         sessionId: result.sessionId,
         usage: result.usage,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return result;
 }

package/dist/ai/spawn.js

@@ -21,6 +21,60 @@ export class ClaudeSpawnError extends Error {
         this.name = 'ClaudeSpawnError';
     }
 }
+// Parse Claude CLI's --output-format stream-json output. Each line is a JSON
+// event; the final event with type === 'result' carries the completion
+// summary (same shape as the old single-json output format). Returns null if
+// no result event is found — caller should treat that as an error.
+export function parseStreamJson(stdout) {
+    const events = [];
+    const eventTypes = [];
+    const lines = stdout.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            events.push(parsed);
+            if (typeof parsed.type === 'string')
+                eventTypes.push(parsed.type);
+        }
+        catch {
+            // Ignore malformed lines — Claude CLI occasionally emits preamble or
+            // debug lines that aren't JSON; the structured events we need are
+            // always well-formed.
+        }
+    }
+    // Find the final result event. Walk from end to handle any stray events
+    // after 'result' (shouldn't happen but be defensive).
+    let resultEvent = null;
+    for (let i = events.length - 1; i >= 0; i--) {
+        if (events[i].type === 'result') {
+            resultEvent = events[i];
+            break;
+        }
+    }
+    if (!resultEvent)
+        return null;
+    return {
+        result: typeof resultEvent.result === 'string' ? resultEvent.result : '',
+        sessionId: typeof resultEvent.session_id === 'string'
+            ? resultEvent.session_id
+            : null,
+        usage: resultEvent.usage && typeof resultEvent.usage === 'object'
+            ? resultEvent.usage
+            : undefined,
+        isError: !!resultEvent.is_error,
+        subtype: typeof resultEvent.subtype === 'string'
+            ? resultEvent.subtype
+            : undefined,
+        numTurns: typeof resultEvent.num_turns === 'number'
+            ? resultEvent.num_turns
+            : undefined,
+        eventTypes,
+        events,
+    };
+}
 // 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.
@@ -54,6 +108,15 @@ export async function runClaude(opts) {
             // 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,
+            // ANTHROPIC_LOG=debug surfaces the SDK's HTTP layer to stderr:
+            // request URLs, status codes, retries, rate-limit notices. We
+            // capture stderr and put a truncated copy into the promptlog so
+            // we can diagnose API hangs/rate-limits post-mortem instead of
+            // staring at "Claude subprocess is idle, why?".
+            env: {
+                ...process.env,
+                ANTHROPIC_LOG: process.env.ANTHROPIC_LOG ?? 'debug',
+            },
         });
         let stdout = '';
         let stderr = '';
@@ -106,7 +169,7 @@ export async function runClaude(opts) {
                 logFail(`exit ${code}: ${stderr.slice(0, 500)}`);
                 return rejectPromise(new ClaudeSpawnError(caller, `claude exited with code ${code}: ${stderr.slice(0, 500)}`));
             }
-            resolvePromise({ stdout, durationMs });
+            resolvePromise({ stdout, stderr, durationMs });
         });
         child.stdin.write(input);
         child.stdin.end();

package/dist/memory/compressed.js

@@ -1,7 +1,7 @@
 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 { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -224,28 +224,25 @@ async function spawnGenerator(prompt) {
     const args = [
         '-p',
         '--output-format',
-        'json',
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
         'acceptEdits',
     ];
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`compressed stream-json produced no result event: ${stdout.slice(0, 200)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-        throw new Error(`compressed bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    if (parsed.isError || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`compressed bad output: ${parsed.result || stdout.slice(0, 200)}`);
     }
     const output = parsed.result.trim();
     void logPrompt({
@@ -255,6 +252,8 @@ async function spawnGenerator(prompt) {
         input: prompt,
         output,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return output;
 }

package/dist/memory/digest-flag.js

@@ -8,7 +8,13 @@
 // drops it entirely. That bug leaked two real markers into user-facing
 // replies today (DIGEST ~morning, ASYNC later). This parser closes that
 // whole class of failure.
-const KINDS = ['DIGEST', 'JOURNAL', 'JOURNAL-NEW', 'ASYNC'];
+const KINDS = [
+    'DIGEST',
+    'JOURNAL',
+    'JOURNAL-NEW',
+    'ASYNC',
+    'ASYNC-BROWSER',
+];
 // Walk backwards from the end of the string, tracking bracket depth, to find
 // the `[` that matches the final `]`. Returns the tag kind, its payload, and
 // everything before the tag. Returns null if the tail doesn't cleanly look
@@ -51,9 +57,11 @@ function peelTrailingTag(raw) {
 }
 // Peel trailing tags off the end of a reply. Supported:
 //   [DIGEST: <reason>]
-//   [JOURNAL:<slug> — <note>]         (append entry)
-//   [JOURNAL-NEW:<slug> — <purpose>]  (create journal)
-//   [ASYNC: <self-sufficient task description>]
+//   [JOURNAL:<slug> — <note>]                  (append entry)
+//   [JOURNAL-NEW:<slug> — <purpose>]           (create journal)
+//   [ASYNC: <self-sufficient task description>]         (general async lane)
+//   [ASYNC-BROWSER: <self-sufficient task description>] (browser lane,
+//                                                        serialized, 1)
 // Multiple tags supported in any order at the tail. Tags must be the LAST
 // thing in the reply (after trimming trailing whitespace).
 //
@@ -65,6 +73,7 @@ export function extractFlags(reply) {
     const journals = [];
     const journalCreates = [];
     const asyncTasks = [];
+    const asyncBrowserTasks = [];
     while (true) {
         const peeled = peelTrailingTag(current);
         if (!peeled)
@@ -91,8 +100,20 @@ export function extractFlags(reply) {
                 asyncTasks.unshift({ description: payload });
             }
         }
+        else if (kind === 'ASYNC-BROWSER') {
+            if (payload.length >= 8) {
+                asyncBrowserTasks.unshift({ description: payload });
+            }
+        }
     }
-    return { clean: current, digest, journals, journalCreates, asyncTasks };
+    return {
+        clean: current,
+        digest,
+        journals,
+        journalCreates,
+        asyncTasks,
+        asyncBrowserTasks,
+    };
 }
 // Legacy helper kept so existing callers still compile.
 export function extractDigestFlag(reply) {

package/dist/memory/digest.js

@@ -1,4 +1,4 @@
-import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -13,28 +13,25 @@ async function spawnDigester(prompt) {
     const args = [
         '-p',
         '--output-format',
-        'json',
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
         'acceptEdits',
     ];
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`digester stream-json produced no result event: ${stdout.slice(0, 200)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-        throw new Error(`digester bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    if (parsed.isError || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`digester bad output: ${parsed.result || stdout.slice(0, 200)}`);
     }
     const output = parsed.result.trim();
     void logPrompt({
@@ -44,6 +41,8 @@ async function spawnDigester(prompt) {
         input: prompt,
         output,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return output;
 }

package/dist/memory/journal-nudger.js

@@ -1,4 +1,4 @@
-import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { initiate } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
@@ -18,28 +18,25 @@ async function spawnComposer(prompt) {
     const args = [
         '-p',
         '--output-format',
-        'json',
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
         'acceptEdits',
     ];
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`nudger stream-json produced no result event: ${stdout.slice(0, 200)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-        throw new Error(`nudger bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    if (parsed.isError || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`nudger bad output: ${parsed.result || stdout.slice(0, 200)}`);
     }
     const output = parsed.result.trim();
     void logPrompt({
@@ -49,6 +46,8 @@ async function spawnComposer(prompt) {
         input: prompt,
         output,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return output;
 }

package/dist/memory/journal-observer.js

@@ -1,4 +1,4 @@
-import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
@@ -14,28 +14,25 @@ async function spawnObserver(prompt) {
     const args = [
         '-p',
         '--output-format',
-        'json',
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
         'acceptEdits',
     ];
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`journal observer stream-json produced no result event: ${stdout.slice(0, 200)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-        throw new Error(`journal observer bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    if (parsed.isError || 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({
@@ -45,6 +42,8 @@ async function spawnObserver(prompt) {
         input: prompt,
         output,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return output;
 }

package/dist/memory/preamble.js

@@ -10,7 +10,7 @@ import { ensureScaffold } from './store.js';
 import { getRoleForContext } from '../wa/whitelist.js';
 const DIGEST_REMINDER = `When something worth remembering happens (new preference, key fact, life event, changed plan), append [DIGEST: <one-line reason>] to the END of your reply. It will be stripped before sending. Flag sparingly.`;
 const JOURNAL_REMINDER = `When a message contains info for one of the journals above, append [JOURNAL:<slug> — <one-line note>] to the END of your reply. Multiple tags OK. Only use slugs listed; never invent. Full rules are in your memory instructions.`;
-const ASYNC_REMINDER = `BROWSER / SCRAPE / MULTI-STEP RESEARCH = always async. Never call browser tools (browser_navigate, browser_click, browser_take_screenshot, browser_evaluate, any mcp__*playwright*) inline — they block this chat for minutes when pages hang. Instead: send a short ack ("On it, will report back.") AND append [ASYNC: <self-sufficient task description>] at the END of your reply. The async worker has full browser access and will report back here. Even for "just one URL" — always async.`;
+const ASYNC_REMINDER = `TWO TRACKS run in parallel: you are the chat track, a separate browser track runs a persistent Claude session dedicated to the shared Chrome at localhost:9222. Never call browser tools (browser_*, mcp__*playwright*) yourself — delegate via [ASYNC-BROWSER: <self-sufficient task description>] at the END of your reply, plus a short ack ("On it, will report back."). For non-browser long work (>30s, multi-step reasoning) use [ASYNC: ...]. Irreversible actions (DM send, post, purchase) split into gather→confirm→act phases — never send on your own judgment.`;
 function buildCriticalSection(params) {
     const { senderNumber, roleName, role, userName } = params;
     const who = userName
@@ -59,9 +59,8 @@ export function buildMemoryPreamble(params) {
         '  [AUDIO: /absolute/path/to/file.mp3]\n' +
         '  [DOCUMENT: /absolute/path/to/file.pdf]\n' +
         'The tag will be stripped from the message. Use absolute paths only.\n\n' +
-        'Browser (Playwright MCP): a real Chrome browser is available for navigation, clicks, forms, screenshots, page content. ' +
-        'DO NOT call browser tools inline from this main chat lane — they block the chat queue for minutes when pages stall (login walls, anti-bot, rate limits). ' +
-        'ALL browser work goes through the async lane. When a request needs browser: send a short ack AND append [ASYNC: <self-sufficient task description>] at the END of your reply. The async worker has full browser access; it will send the result back to this chat as a new message. Even a single URL check goes async. No exceptions.\n\n' +
+        'Browser (Playwright MCP): a real Chrome at localhost:9222 with the owner\'s sessions logged in (TikTok, Instagram, etc.). DO NOT call browser tools yourself — they belong to the BROWSER TRACK, a parallel Claude worker with its own persistent session on that Chrome. ' +
+        'When a request needs browser work: send a short ack AND append [ASYNC-BROWSER: <self-sufficient task description>] at the END of your reply. The browser worker picks it up, does the work in the logged-in Chrome, sends the result back to this chat as a new message. Single URL, quick check, full scrape — all go via [ASYNC-BROWSER:...]. No exceptions.\n\n' +
         'File storage: if you need to save any files (screenshots, research, notes), always save them to storage/temp/. Never save files to the project root.');
     // Critical section
     sections.push(buildCriticalSection({

package/dist/promptlog.js

@@ -1,6 +1,21 @@
 import { appendFile, mkdir, readdir, unlink } from 'fs/promises';
 import { resolve } from 'path';
 import { config } from './config.js';
+// Hard caps on fields that can grow unbounded. Prevents promptlog entries
+// from exploding when a run produces huge stdout/stderr. prunePrompts
+// still handles multi-day retention separately.
+const STDOUT_MAX_BYTES = 100_000;
+const STDERR_MAX_BYTES = 50_000;
+const INPUT_MAX_BYTES = 200_000;
+function truncateWithMarker(s, maxBytes) {
+    if (!s)
+        return s;
+    // Rough byte size via length — fine for mostly-ASCII prompt payloads.
+    if (s.length <= maxBytes)
+        return s;
+    const extra = s.length - maxBytes;
+    return s.slice(0, maxBytes) + `\n… [truncated ${extra} bytes]`;
+}
 let dirReady = false;
 function promptsDir() {
     return resolve(process.cwd(), 'storage/prompts');
@@ -18,7 +33,17 @@ function logFilePath() {
 export async function logPrompt(entry) {
     try {
         await ensureDir();
-        await appendFile(logFilePath(), JSON.stringify(entry) + '\n', 'utf-8');
+        const capped = {
+            ...entry,
+            input: truncateWithMarker(entry.input, INPUT_MAX_BYTES),
+        };
+        if (entry.output !== undefined) {
+            capped.output = truncateWithMarker(entry.output, STDOUT_MAX_BYTES);
+        }
+        if (entry.stderr !== undefined) {
+            capped.stderr = truncateWithMarker(entry.stderr, STDERR_MAX_BYTES);
+        }
+        await appendFile(logFilePath(), JSON.stringify(capped) + '\n', 'utf-8');
     }
     catch {
         // logging must never break the main flow

package/dist/queue/async-tasks.js

@@ -1,6 +1,6 @@
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
-import { runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
 import { config } from '../config.js';
 import fastq from 'fastq';
 import { initiate } from '../gateway/outgoing.js';
@@ -113,7 +113,7 @@ function buildArgs(task) {
     const args = [
         '-p',
         '--output-format',
-        'json',
+        'stream-json',
         '--model',
         config.claude.model,
         '--permission-mode',
@@ -135,22 +135,19 @@ function buildArgs(task) {
 }
 async function spawnClaudeForTask(task, prompt) {
     const args = buildArgs(task);
-    const { stdout, durationMs } = await runClaude({
+    const { stdout, stderr, 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}`);
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`async task stream-json produced no result event: ${stdout.slice(0, 200)}`);
     }
-    if (parsed.is_error || parsed.subtype !== 'success' || !parsed.result) {
-        throw new Error(`async task bad output: ${parsed.result ?? stdout.slice(0, 200)}`);
+    if (parsed.isError || 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({
@@ -160,6 +157,8 @@ async function spawnClaudeForTask(task, prompt) {
         input: prompt,
         output,
         durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
     });
     return output;
 }
@@ -275,3 +274,293 @@ function titleCaseSlug(slug) {
 function truncate(s, n) {
     return s.length > n ? s.slice(0, n - 1) + '…' : s;
 }
+// ============================================================================
+// BROWSER LANE
+// ============================================================================
+// A second async lane dedicated to browser work. Key differences vs the
+// general async lane above:
+//
+// - Concurrency is 1. Serialized against itself because (a) the shared
+//   Playwright MCP + Chrome is one physical resource, (b) the session below
+//   is persistent and --resume doesn't allow concurrent resumes.
+// - One GLOBAL persistent session stored at storage/browser-session.json.
+//   First browser task bootstraps fresh (captures sessionId). Subsequent
+//   tasks spawn with --resume <sessionId>, so the browser Claude carries
+//   memory of prior tasks across runs.
+// - Task description is added as a new user message to the persistent
+//   session. The worker sees the accumulated history automatically.
+function browserSessionFilePath() {
+    return resolve(process.cwd(), config.memory.dir, 'browser-session.json');
+}
+function loadBrowserSession() {
+    const path = browserSessionFilePath();
+    if (!existsSync(path)) {
+        return { sessionId: null, createdAt: 0, lastUsedAt: 0, resumeCount: 0 };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        return {
+            sessionId: parsed.sessionId ?? null,
+            createdAt: parsed.createdAt ?? 0,
+            lastUsedAt: parsed.lastUsedAt ?? 0,
+            resumeCount: parsed.resumeCount ?? 0,
+        };
+    }
+    catch {
+        return { sessionId: null, createdAt: 0, lastUsedAt: 0, resumeCount: 0 };
+    }
+}
+function saveBrowserSession(state) {
+    const path = browserSessionFilePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+// Reset the browser session. Callable from outside if the session gets
+// corrupted or we want a fresh start. Not wired into any command yet.
+export function resetBrowserSession() {
+    saveBrowserSession({
+        sessionId: null,
+        createdAt: 0,
+        lastUsedAt: 0,
+        resumeCount: 0,
+    });
+    logger.info('browser session reset');
+}
+const browserQueue = fastq.promise(async (task) => {
+    inProgress.set(task.id, task);
+    try {
+        await runBrowserTask(task);
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid }, 'browser task failed unexpectedly');
+    }
+    finally {
+        inProgress.delete(task.id);
+    }
+}, 1);
+export function enqueueBrowserTask(input) {
+    const task = {
+        ...input,
+        id: `browser-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        startedAt: Math.floor(Date.now() / 1000),
+    };
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        description: task.description.slice(0, 200),
+    }, 'browser task enqueued');
+    browserQueue.push(task).catch((err) => logger.error({ err, id: task.id }, 'browser queue push failed'));
+    return task;
+}
+function buildBrowserPrompt(task, isResume) {
+    // Framing tuned for the dedicated browser worker.
+    const lines = [
+        isResume
+            ? `You are the BROWSER WORKER. Another task just came in. You already have memory of prior browser tasks in this session — act on it accordingly. Use the shared Chrome at localhost:9222 via Playwright MCP (already logged into the owner's sessions like TikTok, Instagram, etc. — do NOT log out, do NOT start a new browser instance).`
+            : `You are the BROWSER WORKER. You run in a persistent session dedicated to browser tasks for the owner. The chat already got its ack; your output IS the follow-up chat reply the owner is waiting for. Use the shared Chrome at localhost:9222 via Playwright MCP (already authenticated with the owner's sessions — TikTok, Instagram, etc. — do NOT log out, do NOT launch a new browser).`,
+        ``,
+        `TASK:`,
+        task.description,
+        ``,
+        `ORIGINAL USER MESSAGE (for reference):`,
+        task.originatingMessage,
+        ``,
+        `Sender: ${task.senderName ?? task.senderNumber}`,
+        ``,
+        `HOW TO OUTPUT:`,
+        `- Write the full answer as a natural chat reply. Same voice as the main chat Claude, just delayed.`,
+        `- Open with a short "about the X you asked about..." reference — the owner may have asked for several things.`,
+        `- 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.`,
+        ``,
+        `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.`,
+        `- Any single tool call running past 5 min → bail.`,
+        `- Autonomy: pick and proceed on low-stakes choices (which hashtag first, which profile to open). For IRREVERSIBLE writes (DM send, post, purchase), do NOT act — stop and report candidates so the owner can confirm in chat.`,
+        ``,
+        `OPTIONAL MARKERS (at the END of your output):`,
+        `- [JOURNAL:<slug> — <one-line finding>] per finding that belongs in an active journal.`,
+        `- [JOURNAL-NEW:<slug> — <purpose>] if a clearly-recurring tracking surface doesn't have a journal yet.`,
+        `- [DIGEST: <reason>] if a durable fact about the owner/chat came up.`,
+        ``,
+        `CONSTRAINTS:`,
+        `- Do NOT emit [ASYNC:...] or [ASYNC-BROWSER:...]. No recursion.`,
+        `- Markers are bonus persistence, not a substitute for the reply.`,
+        `- Stay fully in character (personality).`,
+        ``,
+        `Do the work. Write the reply. Markers optional at the end.`,
+    ];
+    return lines.join('\n');
+}
+function buildBrowserArgs(task, sessionId) {
+    const args = [
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+    ];
+    if (sessionId) {
+        // Resume — system prompt and memory-dirs are already baked into session
+        args.push('--resume', sessionId);
+    }
+    else {
+        // First call — bootstrap the persistent session
+        args.push('--append-system-prompt', systemPrompt());
+        for (const dir of config.claude.addDirs) {
+            args.push('--add-dir', resolve(process.cwd(), dir));
+        }
+    }
+    // Memory + media dirs re-added each call (harmless if already baked; needed
+    // on fresh bootstrap; lets the browser worker Read updated memory files
+    // between turns).
+    args.push('--add-dir', resolve(process.cwd(), config.memory.dir));
+    args.push('--add-dir', resolve(process.cwd(), config.storage.mediaDir));
+    if (task.allowedTools &&
+        task.allowedTools !== 'all' &&
+        task.allowedTools.length > 0) {
+        args.push('--allowedTools', task.allowedTools.join(','));
+    }
+    return args;
+}
+async function runBrowserTask(task) {
+    const session = loadBrowserSession();
+    const isResume = !!session.sessionId;
+    const prompt = buildBrowserPrompt(task, isResume);
+    const args = buildBrowserArgs(task, session.sessionId);
+    const startedAtMs = Date.now();
+    const elapsedLog = () => `${Math.round((Date.now() - task.startedAt * 1000) / 1000)}s`;
+    let stdout;
+    let stderr;
+    let durationMs;
+    try {
+        const result = await runClaude({
+            args,
+            input: prompt,
+            timeoutMs: TIMEOUT_MS.async,
+            caller: 'browser-task',
+        });
+        stdout = result.stdout;
+        stderr = result.stderr;
+        durationMs = result.durationMs;
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'browser task claude call failed');
+        await initiate({
+            jid: task.jid,
+            text: `Heads up: the browser task "${truncate(task.description, 80)}" failed. Ask me again and I'll retry.`,
+        });
+        return;
+    }
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        logger.error({ id: task.id }, 'browser task stream-json produced no result event');
+        await initiate({
+            jid: task.jid,
+            text: `Heads up: the browser task "${truncate(task.description, 80)}" returned an unparseable response.`,
+        });
+        return;
+    }
+    if (parsed.isError || parsed.subtype !== 'success' || !parsed.result) {
+        logger.error({ id: task.id, subtype: parsed.subtype, isError: parsed.isError }, 'browser task bad output');
+        await initiate({
+            jid: task.jid,
+            text: `Heads up: the browser task "${truncate(task.description, 80)}" returned an error.`,
+        });
+        return;
+    }
+    // Persist the session id. On first call Claude returns the new sessionId;
+    // on resume it may return the same or a rotated one.
+    const returnedSessionId = parsed.sessionId;
+    if (returnedSessionId) {
+        const now = Math.floor(Date.now() / 1000);
+        saveBrowserSession({
+            sessionId: returnedSessionId,
+            createdAt: session.createdAt || now,
+            lastUsedAt: now,
+            resumeCount: (session.resumeCount ?? 0) + (isResume ? 1 : 0),
+        });
+    }
+    void logPrompt({
+        ts: Math.floor(startedAtMs / 1000),
+        caller: 'browser-task',
+        args,
+        input: prompt,
+        output: parsed.result,
+        sessionId: returnedSessionId ?? undefined,
+        durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
+    });
+    // Route markers the same way the general async lane does.
+    const { extractFlags } = await import('../memory/digest-flag.js');
+    const { clean, digest, journals, journalCreates } = extractFlags(parsed.result);
+    const { appendEntry, createJournal, getJournal, isValidSlug } = await import('../memory/journals.js');
+    for (const op of journalCreates) {
+        if (!isValidSlug(op.slug))
+            continue;
+        if (getJournal(op.slug))
+            continue;
+        try {
+            createJournal({
+                slug: op.slug,
+                name: titleCaseSlug(op.slug),
+                purpose: op.purpose,
+            });
+            logger.info({ slug: op.slug, id: task.id }, 'journal created via browser task marker');
+        }
+        catch (err) {
+            logger.error({ err, op, id: task.id }, 'browser JOURNAL-NEW failed');
+        }
+    }
+    let appendedCount = 0;
+    for (const j of journals) {
+        const ok = appendEntry(j.slug, {
+            source: 'async',
+            jid: task.jid,
+            senderNumber: task.senderNumber,
+            note: j.note,
+        });
+        if (ok)
+            appendedCount++;
+    }
+    if (digest) {
+        const { scheduleDigest } = await import('../memory/scheduler.js');
+        scheduleDigest({
+            jid: task.jid,
+            number: task.senderNumber,
+            reason: digest,
+        });
+    }
+    const chatText = clean.trim();
+    if (chatText.length > 0) {
+        await initiate({ jid: task.jid, text: chatText });
+    }
+    else if (appendedCount > 0 ||
+        journalCreates.length > 0 ||
+        digest !== null) {
+        const bits = [];
+        if (appendedCount > 0) {
+            bits.push(`${appendedCount} journal ${appendedCount === 1 ? 'entry' : 'entries'}`);
+        }
+        if (journalCreates.length > 0) {
+            bits.push(`${journalCreates.length} journal${journalCreates.length === 1 ? '' : 's'} created`);
+        }
+        if (digest)
+            bits.push('digest scheduled');
+        await initiate({ jid: task.jid, text: `Done. ${bits.join(', ')}.` });
+    }
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        elapsed: elapsedLog(),
+        isResume,
+        appended: appendedCount,
+        createdJournals: journalCreates.length,
+        digestFired: !!digest,
+        chatSent: chatText.length,
+    }, 'browser task completed');
+}

package/dist/queue/worker.js

@@ -5,7 +5,7 @@ import { logger } from '../logger.js';
 import { extractFlags } from '../memory/digest-flag.js';
 import { appendEntry, createJournal, getJournal, isValidSlug, } from '../memory/journals.js';
 import { scheduleDigest } from '../memory/scheduler.js';
-import { enqueueAsyncTask } from './async-tasks.js';
+import { enqueueAsyncTask, enqueueBrowserTask } from './async-tasks.js';
 function isStaleSessionError(err) {
     return (err instanceof Error &&
         err.message.includes('No conversation found'));
@@ -31,7 +31,7 @@ async function callClaude(job) {
         totalContextTokens,
         updatedAt: Math.floor(Date.now() / 1000),
     });
-    const { clean, digest, journals, journalCreates, asyncTasks } = extractFlags(reply);
+    const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, } = extractFlags(reply);
     if (digest) {
         logger.info({ jid: job.jid, number: job.senderNumber, reason: digest }, 'DIGEST flag raised, scheduling');
         scheduleDigest({
@@ -74,10 +74,11 @@ async function callClaude(job) {
             logger.warn({ slug: j.slug, jid: job.jid }, 'JOURNAL flag pointed at unknown slug, dropped');
         }
     }
-    // Async tasks: Claude delegated long work (browser scrapes, multi-step
-    // research, etc.) to the background lane. The clean reply above is the
-    // user-facing ack and will be sent normally. The async tasks run stateless
-    // in their own queue and report back via initiate() when done.
+    // Async tasks: Claude delegated to background workers. Chat reply above
+    // is the user-facing ack. Two lanes:
+    //   [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) {
         enqueueAsyncTask({
             jid: job.jid,
@@ -87,6 +88,15 @@ async function callClaude(job) {
             allowedTools: job.allowedTools ?? 'all',
         });
     }
+    for (const t of asyncBrowserTasks) {
+        enqueueBrowserTask({
+            jid: job.jid,
+            senderNumber: job.senderNumber,
+            description: t.description,
+            originatingMessage: job.text,
+            allowedTools: job.allowedTools ?? 'all',
+        });
+    }
     return {
         reply: clean,
         stats: {
@@ -99,7 +109,7 @@ async function callClaude(job) {
             fresh: wasFresh,
             hasDigest: digest !== null,
             journalSlugs: journals.map((j) => j.slug),
-            asyncCount: asyncTasks.length,
+            asyncCount: asyncTasks.length + asyncBrowserTasks.length,
         },
     };
 }

package/package.json

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