@c4t4/heyamigo 0.8.7 → 0.8.8

package/dist/ai/claude.js

@@ -104,3 +104,105 @@ export async function askClaude(params) {
     });
     return result;
 }
+// Claude's per-mode permission + tool defaults. The caller can still override
+// allowedTools explicitly; mode just sets the floor.
+function permissionModeFor(mode) {
+    switch (mode) {
+        case 'read-only':
+            return 'default'; // prompts on writes; we layer allowedTools to enforce
+        case 'auto':
+        case 'full':
+            return 'acceptEdits';
+    }
+}
+function defaultAllowedToolsFor(mode) {
+    if (mode === 'read-only')
+        return ['Read', 'Grep', 'Glob', 'WebFetch'];
+    return undefined; // no restriction
+}
+function buildTaskArgs(params) {
+    const args = [
+        '-p',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        permissionModeFor(params.mode),
+    ];
+    if (params.sessionId) {
+        args.push('--resume', params.sessionId);
+    }
+    else if (params.includeSystemPrompt) {
+        args.push('--append-system-prompt', systemPrompt());
+    }
+    // On fresh sessions, fold the configured baseline read dirs in too. On
+    // resume Claude already has them baked into the session state.
+    if (!params.sessionId && params.includeSystemPrompt) {
+        for (const dir of config.claude.addDirs) {
+            args.push('--add-dir', resolve(process.cwd(), dir));
+        }
+    }
+    for (const dir of params.addDirs ?? []) {
+        args.push('--add-dir', resolve(process.cwd(), dir));
+    }
+    const allowedTools = params.allowedTools && params.allowedTools !== 'all'
+        ? params.allowedTools
+        : defaultAllowedToolsFor(params.mode);
+    if (allowedTools && allowedTools.length > 0) {
+        args.push('--allowedTools', allowedTools.join(','));
+    }
+    return args;
+}
+function laneTimeoutMs(lane) {
+    return TIMEOUT_MS[lane];
+}
+export async function runClaudeTask(params) {
+    const args = buildTaskArgs(params);
+    const { stdout, stderr, durationMs } = await runClaude({
+        args,
+        input: params.input,
+        timeoutMs: laneTimeoutMs(params.lane),
+        caller: params.caller,
+    });
+    const startedAt = Date.now() - durationMs;
+    const parsed = parseStreamJson(stdout);
+    if (!parsed) {
+        throw new Error(`${params.caller} stream-json produced no result event: ${stdout.slice(0, 200)}`);
+    }
+    if (parsed.isError || parsed.subtype !== 'success' || !parsed.result) {
+        throw new Error(`${params.caller} bad output: ${parsed.result || stdout.slice(0, 200)}`);
+    }
+    const reply = parsed.result.trim();
+    const 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.numTurns ?? 0,
+    };
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: params.caller,
+        args,
+        input: params.input,
+        output: reply,
+        sessionId: parsed.sessionId ?? undefined,
+        usage,
+        durationMs,
+        stderr,
+        eventTypes: parsed.eventTypes,
+    });
+    return {
+        reply,
+        sessionId: parsed.sessionId ?? undefined,
+        usage,
+    };
+}
+export const claudeProvider = {
+    name: 'claude',
+    ask: askClaude,
+    runTask: runClaudeTask,
+    reloadSystemPrompt,
+};

package/dist/ai/codex.js

@@ -0,0 +1,224 @@
+// Codex CLI provider. Maps the neutral AiProvider contract onto
+// `codex exec --json`. Flag names match the public CLI docs as of writing
+// (developers.openai.com/codex/cli/features); if your local Codex version
+// uses different flags, the small surface here is the only place to adjust.
+//
+// What's wired:
+//   - exec mode with --json (NDJSON event stream on stdout)
+//   - --add-dir for extra writable roots
+//   - --sandbox-mode for tier (read-only / workspace-write / danger-full-access)
+//   - --resume <id> for session continuation
+//   - prompt passed on stdin (matches the spawn plumbing that already
+//     pipes input to child.stdin)
+//
+// What's deliberately coarse:
+//   - allowedTools is ignored on this provider. Codex has no per-tool
+//     allowlist; the sandbox mode is the only knob. The mode argument
+//     covers the practical cases (read vs. write vs. full).
+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)
+        return cachedSystemPrompt;
+    const personality = readFileSync(resolve(process.cwd(), config.claude.personalityFile), 'utf-8');
+    let memoryInstructions = '';
+    try {
+        memoryInstructions = readFileSync(resolve(process.cwd(), config.memory.instructionsFile), 'utf-8');
+    }
+    catch {
+        // memory instructions optional
+    }
+    cachedSystemPrompt = memoryInstructions
+        ? `${personality}\n\n---\n\n${memoryInstructions}`
+        : personality;
+    return cachedSystemPrompt;
+}
+function reloadSystemPrompt() {
+    cachedSystemPrompt = null;
+}
+// Codex sandbox vocabulary. The CLI flag is --sandbox-mode (or --sandbox in
+// some builds); values are: read-only, workspace-write, danger-full-access.
+function sandboxFor(mode) {
+    switch (mode) {
+        case 'read-only':
+            return 'read-only';
+        case 'auto':
+            return 'workspace-write';
+        case 'full':
+            return 'danger-full-access';
+    }
+}
+function laneTimeoutMs(lane) {
+    return TIMEOUT_MS[lane];
+}
+function buildExecArgs(params) {
+    const args = ['exec', '--json'];
+    args.push('--sandbox-mode', sandboxFor(params.mode));
+    if (params.sessionId) {
+        // Resume keeps the prior conversation; system prompt and add-dirs
+        // were baked in on the original turn.
+        args.push('--resume', params.sessionId);
+    }
+    else {
+        for (const dir of params.addDirs ?? []) {
+            args.push('--add-dir', resolve(process.cwd(), dir));
+        }
+        if (params.includeSystemPrompt) {
+            // Codex doesn't have Claude's --append-system-prompt. The portable
+            // approach is to inline the personality at the top of the prompt.
+            // (An alternative is writing AGENTS.md into cwd; we don't do that
+            // here because it'd mutate the repo.)
+            params.prompt = `${systemPrompt()}\n\n---\n\n${params.prompt}`;
+        }
+    }
+    // Prompt as positional arg. `codex exec` reads stdin only with `-`, and
+    // passing it positionally avoids ambiguity with the spawn pipe.
+    args.push(params.prompt);
+    return args;
+}
+function parseCodexOutput(stdout) {
+    const events = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Codex occasionally emits non-JSON preamble; skip it.
+        }
+    }
+    if (events.length === 0)
+        return null;
+    // Find the final agent message. Codex labels it variously across
+    // versions — try the common shapes in order.
+    let reply = null;
+    for (let i = events.length - 1; i >= 0; i--) {
+        const ev = events[i];
+        if (ev.msg?.type === 'agent_message' &&
+            typeof ev.msg.message === 'string') {
+            reply = ev.msg.message;
+            break;
+        }
+        if (typeof ev.message === 'string') {
+            reply = ev.message;
+            break;
+        }
+        if (typeof ev.text === 'string') {
+            reply = ev.text;
+            break;
+        }
+    }
+    if (reply === null)
+        return null;
+    // Session id — Codex uses different field names across versions.
+    let sessionId;
+    for (const ev of events) {
+        const id = ev.session_id ?? ev.conversation_id ?? ev.response_id;
+        if (typeof id === 'string' && id) {
+            sessionId = id;
+            break;
+        }
+    }
+    // Usage — last event with a usage object wins (final turn totals).
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    for (let i = events.length - 1; i >= 0; i--) {
+        const u = events[i].usage;
+        if (u) {
+            inputTokens = u.input_tokens ?? 0;
+            outputTokens = u.output_tokens ?? 0;
+            cacheReadTokens = u.cached_input_tokens ?? 0;
+            break;
+        }
+    }
+    return {
+        reply: reply.trim(),
+        sessionId,
+        usage: {
+            inputTokens,
+            cacheReadTokens,
+            cacheCreationTokens: 0,
+            outputTokens,
+            numTurns: 0,
+        },
+    };
+}
+async function runCodexTask(params) {
+    const args = buildExecArgs({
+        mode: params.mode,
+        addDirs: params.addDirs,
+        sessionId: params.sessionId,
+        includeSystemPrompt: params.includeSystemPrompt,
+        prompt: params.input,
+    });
+    logger.debug({ caller: params.caller, resume: !!params.sessionId }, 'spawning codex exec');
+    // input is empty here — the prompt rides in argv (Codex exec semantics).
+    // Empty stdin end() is harmless.
+    const { stdout, stderr, durationMs } = await runClaude({
+        args,
+        input: '',
+        timeoutMs: laneTimeoutMs(params.lane),
+        caller: params.caller,
+        bin: 'codex',
+    });
+    const startedAt = Date.now() - durationMs;
+    const parsed = parseCodexOutput(stdout);
+    if (!parsed) {
+        throw new Error(`codex produced no parseable result; stdout: ${stdout.slice(0, 500)}`);
+    }
+    void logPrompt({
+        ts: Math.floor(startedAt / 1000),
+        caller: params.caller,
+        args,
+        input: params.input,
+        output: parsed.reply,
+        sessionId: parsed.sessionId,
+        usage: parsed.usage,
+        durationMs,
+        stderr,
+    });
+    return parsed;
+}
+async function askCodex(params) {
+    const result = await runCodexTask({
+        input: params.input,
+        caller: 'worker',
+        mode: 'auto',
+        lane: 'main',
+        sessionId: params.sessionId,
+        includeSystemPrompt: true,
+        allowedTools: params.allowedTools,
+        addDirs: [
+            config.memory.dir,
+            config.storage.mediaDir,
+        ],
+    });
+    if (!result.sessionId) {
+        throw new Error('codex ask: response missing session id');
+    }
+    return {
+        reply: result.reply,
+        sessionId: result.sessionId,
+        usage: result.usage ?? {
+            inputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            outputTokens: 0,
+            numTurns: 0,
+        },
+    };
+}
+export const codexProvider = {
+    name: 'codex',
+    ask: askCodex,
+    runTask: runCodexTask,
+    reloadSystemPrompt,
+};

package/dist/ai/provider.js

@@ -0,0 +1,9 @@
+// Provider abstraction for the user-facing chat ask path. Lets the worker
+// route conversation turns to either Claude or Codex (or any future CLI)
+// without knowing the wire details.
+//
+// Scope: covers the interactive worker call (one turn in, one turn out, with
+// resumable session ids and per-role tool gating). Memory digests, async
+// tasks, and the journal observers stay on `runClaude` directly — they're
+// Claude-specific batch pipelines and not in this interface.
+export {};

package/dist/ai/providers.js

@@ -0,0 +1,18 @@
+import { config } from '../config.js';
+import { claudeProvider } from './claude.js';
+import { codexProvider } from './codex.js';
+const REGISTRY = {
+    claude: claudeProvider,
+    codex: codexProvider,
+};
+// Resolve the active provider. Defaults to claude if no override is set in
+// config; pass an explicit name to force one (useful for per-role routing
+// once access.json learns about it).
+export function getProvider(name) {
+    const resolved = name ?? config.ai.provider;
+    return REGISTRY[resolved];
+}
+export function reloadAllSystemPrompts() {
+    for (const p of Object.values(REGISTRY))
+        p.reloadSystemPrompt();
+}

package/dist/ai/spawn.js

@@ -100,23 +100,26 @@ function killGroup(child, signal) {
 // should go through this.
 export async function runClaude(opts) {
     const { args, input, timeoutMs, caller } = opts;
+    const bin = opts.bin ?? 'claude';
     const startedAt = Date.now();
     return new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('claude', args, {
+        const env = { ...process.env };
+        if (bin === 'claude') {
+            // 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?". Only meaningful
+            // for the Anthropic CLI; other providers ignore it.
+            env.ANTHROPIC_LOG = process.env.ANTHROPIC_LOG ?? 'debug';
+        }
+        const child = spawn(bin, 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,
-            // 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',
-            },
+            env,
         });
         let stdout = '';
         let stderr = '';
@@ -153,7 +156,7 @@ export async function runClaude(opts) {
             settled = true;
             clearTimeout(timer);
             logFail(`spawn failed: ${err.message}`);
-            rejectPromise(new ClaudeSpawnError(caller, `claude spawn failed: ${err.message}`));
+            rejectPromise(new ClaudeSpawnError(caller, `${bin} spawn failed: ${err.message}`));
         });
         child.on('close', (code, signal) => {
             if (settled)
@@ -167,7 +170,7 @@ export async function runClaude(opts) {
             }
             if (code !== 0) {
                 logFail(`exit ${code}: ${stderr.slice(0, 500)}`);
-                return rejectPromise(new ClaudeSpawnError(caller, `claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+                return rejectPromise(new ClaudeSpawnError(caller, `${bin} exited with code ${code}: ${stderr.slice(0, 500)}`));
             }
             resolvePromise({ stdout, stderr, durationMs });
         });

package/dist/cli/setup.js

@@ -18,6 +18,41 @@ function which(bin) {
     const r = run(`which ${bin}`);
     return r.ok ? r.output : null;
 }
+// Idempotently add the Playwright MCP entry to ~/.codex/config.toml so the
+// Codex CLI auto-launches the same MCP server Claude uses. We don't have a
+// TOML parser available; the entry has a fixed, simple shape so a text-level
+// presence check + append is safe enough here. Returns true if the entry was
+// added or already present, false on write failure.
+function addPlaywrightToCodexConfig(cdpUrl) {
+    const codexDir = resolve(homedir(), '.codex');
+    const configPath = resolve(codexDir, 'config.toml');
+    const block = [
+        '',
+        '[mcp_servers.playwright]',
+        'command = "npx"',
+        `args = ["@playwright/mcp@latest", "--cdp-endpoint", "${cdpUrl}"]`,
+        '',
+    ].join('\n');
+    try {
+        mkdirSync(codexDir, { recursive: true });
+        let existing = '';
+        if (existsSync(configPath)) {
+            existing = readFileSync(configPath, 'utf-8');
+            // Match both [mcp_servers.playwright] and [mcp_servers."playwright"].
+            if (/\[mcp_servers\.(?:"?)playwright(?:"?)\]/.test(existing)) {
+                return true;
+            }
+        }
+        const next = existing.endsWith('\n') || existing === ''
+            ? existing + block
+            : existing + '\n' + block;
+        writeFileSync(configPath, next, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function runLive(cmd) {
     const result = spawnSync('sh', ['-c', cmd], { stdio: 'inherit' });
     return result.status === 0;
@@ -296,16 +331,26 @@ export async function runSetup() {
         if (!isLinux) {
             p.log.warning('Automated browser setup is available on Linux only. ' +
                 'On macOS/Windows: start Chrome with --remote-debugging-port=9222 manually, ' +
-                'then run: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"');
+                'then for Claude: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"; ' +
+                'for Codex: add [mcp_servers.playwright] to ~/.codex/config.toml.');
         }
         else {
             // ── Check if already running ─────────────────────────────
             const cdpUrl = 'http://localhost:9222';
             const alreadyRunning = run(`curl -s '${cdpUrl}/json/version'`);
             const mcpConfigured = run('claude mcp list 2>/dev/null').output.includes('playwright');
+            const hasCodex = !!which('codex');
             if (alreadyRunning.ok && alreadyRunning.output.includes('Browser') && mcpConfigured) {
                 p.log.success('Chrome already running (localhost:9222)');
                 p.log.success('Claude already connected to Chrome');
+                if (hasCodex) {
+                    if (addPlaywrightToCodexConfig(cdpUrl)) {
+                        p.log.success('Codex connected to Chrome (~/.codex/config.toml)');
+                    }
+                    else {
+                        p.log.warning('Could not write ~/.codex/config.toml — add [mcp_servers.playwright] manually');
+                    }
+                }
                 p.log.info('View browser (SSH tunnel):\n' +
                     `  ssh -L 6090:127.0.0.1:6090 ${process.env.USER || 'root'}@<server-ip>\n` +
                     '  Then open: http://localhost:6090/vnc.html');
@@ -394,6 +439,16 @@ export async function runSetup() {
                             sc.stop('Connection failed');
                             p.log.warning('Run manually: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"');
                         }
+                        // Mirror the MCP entry into Codex if it's installed, so the same
+                        // browser lane works when ai.provider is flipped to codex.
+                        if (hasCodex) {
+                            if (addPlaywrightToCodexConfig(cdpUrl)) {
+                                p.log.success('Codex connected to Chrome (~/.codex/config.toml)');
+                            }
+                            else {
+                                p.log.warning('Could not write ~/.codex/config.toml — add [mcp_servers.playwright] manually');
+                            }
+                        }
                         if (vncInstalled) {
                             p.log.info('Watch the browser (localhost only, via SSH tunnel):\n' +
                                 `  ssh -L 6090:127.0.0.1:6090 ${process.env.USER || 'root'}@<server-ip>\n` +

package/dist/config.js

@@ -24,6 +24,11 @@ const ConfigSchema = z.object({
         status: z.array(z.string()),
         reload: z.array(z.string()),
     }),
+    ai: z
+        .object({
+        provider: z.enum(['claude', 'codex']).default('claude'),
+    })
+        .default({ provider: 'claude' }),
     claude: z.object({
         model: z.string(),
         personalityFile: z.string(),

package/dist/gateway/commands.js

@@ -1,5 +1,5 @@
 import { clearSession, getSessionInfo } from '../ai/sessions.js';
-import { reloadSystemPrompt } from '../ai/claude.js';
+import { reloadAllSystemPrompts } from '../ai/providers.js';
 import { config } from '../config.js';
 import { runDigestNow } from '../memory/scheduler.js';
 import { sendText } from '../wa/sender.js';
@@ -41,7 +41,7 @@ export async function tryCommand(ctx) {
         return true;
     }
     if (config.commands.reload.includes(cmd)) {
-        reloadSystemPrompt();
+        reloadAllSystemPrompts();
         const existed = clearSession(ctx.jid);
         const reply = existed
             ? 'Personality reloaded and session reset.'

package/dist/memory/compressed.js

@@ -1,10 +1,8 @@
 import { existsSync, readFileSync, readdirSync, writeFileSync, } from 'fs';
 import { dirname, resolve } from 'path';
 import { mkdirSync } from 'fs';
-import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
-import { config } from '../config.js';
+import { getProvider } from '../ai/providers.js';
 import { logger } from '../logger.js';
-import { logPrompt } from '../promptlog.js';
 import { listJournals, readEntries } from './journals.js';
 import { memoryRoot, treeRoot, entityIndexPath } from './paths.js';
 // The compressed view is a rolling index across all memory: people, chats,
@@ -221,42 +219,13 @@ ${raw}
 Output ONLY the compressed index in the exact format above. No preamble, no explanation, no code fences.`;
 }
 async function spawnGenerator(prompt) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
-    ];
-    const { stdout, stderr, durationMs } = await runClaude({
-        args,
+    const { reply } = await getProvider().runTask({
         input: prompt,
-        timeoutMs: TIMEOUT_MS.background,
         caller: 'compressed',
+        mode: 'auto',
+        lane: 'background',
     });
-    const startedAt = Date.now() - durationMs;
-    const parsed = parseStreamJson(stdout);
-    if (!parsed) {
-        throw new Error(`compressed stream-json produced no result event: ${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({
-        ts: Math.floor(startedAt / 1000),
-        caller: 'compressed',
-        args,
-        input: prompt,
-        output,
-        durationMs,
-        stderr,
-        eventTypes: parsed.eventTypes,
-    });
-    return output;
+    return reply;
 }
 let buildInFlight = null;
 export async function rebuildCompressed() {

package/dist/memory/digest.js

@@ -1,51 +1,19 @@
-import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { getProvider } from '../ai/providers.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
-import { logPrompt } from '../promptlog.js';
 import { readLast } from '../store/messages.js';
 import { markCompressedDirty } from './compressed.js';
 import { readBrief, readProfile, setLastDigestedAt, writeBrief, writeProfile, } from './store.js';
-/**
- * Run a stateless Claude call to consolidate memory.
- * Returns the new content Claude proposed.
- */
+// Stateless agent call to consolidate memory. Routed through the provider
+// abstraction so it runs on whichever CLI is configured.
 async function spawnDigester(prompt) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
-    ];
-    const { stdout, stderr, durationMs } = await runClaude({
-        args,
+    const { reply } = await getProvider().runTask({
         input: prompt,
-        timeoutMs: TIMEOUT_MS.background,
-        caller: 'digester',
-    });
-    const startedAt = Date.now() - durationMs;
-    const parsed = parseStreamJson(stdout);
-    if (!parsed) {
-        throw new Error(`digester stream-json produced no result event: ${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({
-        ts: Math.floor(startedAt / 1000),
         caller: 'digester',
-        args,
-        input: prompt,
-        output,
-        durationMs,
-        stderr,
-        eventTypes: parsed.eventTypes,
+        mode: 'auto',
+        lane: 'background',
     });
-    return output;
+    return reply;
 }
 function formatMessagesForDigest(messages) {
     return messages

package/dist/memory/journal-nudger.js

@@ -1,8 +1,7 @@
-import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { getProvider } from '../ai/providers.js';
 import { config } from '../config.js';
 import { initiate } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
-import { logPrompt } from '../promptlog.js';
 import { readLast } from '../store/messages.js';
 import { canSendProactive } from '../wa/whitelist.js';
 import { isInQuietHours, nextFireTs, parseCadence, } from './journal-cadence.js';
@@ -15,42 +14,13 @@ function defaultNudgeJid() {
     return `${config.owner.number}@s.whatsapp.net`;
 }
 async function spawnComposer(prompt) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
-    ];
-    const { stdout, stderr, durationMs } = await runClaude({
-        args,
+    const { reply } = await getProvider().runTask({
         input: prompt,
-        timeoutMs: TIMEOUT_MS.background,
-        caller: 'journal-nudger',
-    });
-    const startedAt = Date.now() - durationMs;
-    const parsed = parseStreamJson(stdout);
-    if (!parsed) {
-        throw new Error(`nudger stream-json produced no result event: ${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({
-        ts: Math.floor(startedAt / 1000),
         caller: 'journal-nudger',
-        args,
-        input: prompt,
-        output,
-        durationMs,
-        stderr,
-        eventTypes: parsed.eventTypes,
+        mode: 'auto',
+        lane: 'background',
     });
-    return output;
+    return reply;
 }
 function formatMsg(m) {
     const who = m.direction === 'out' ? 'assistant' : m.pushName || m.senderNumber || 'user';

package/dist/memory/journal-observer.js

@@ -1,52 +1,22 @@
-import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { getProvider } from '../ai/providers.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
-import { logPrompt } from '../promptlog.js';
 import { readLast } from '../store/messages.js';
 import { appendEntry, getLastScannedTs, getJournal, 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.
 const SCAN_WINDOW = 200;
-// How many recent entries to show Claude for dedup context.
+// How many recent entries to show the observer for dedup context.
 const DEDUP_WINDOW = 20;
 async function spawnObserver(prompt) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
-    ];
-    const { stdout, stderr, durationMs } = await runClaude({
-        args,
+    const { reply } = await getProvider().runTask({
         input: prompt,
-        timeoutMs: TIMEOUT_MS.background,
-        caller: 'journal-observer',
-    });
-    const startedAt = Date.now() - durationMs;
-    const parsed = parseStreamJson(stdout);
-    if (!parsed) {
-        throw new Error(`journal observer stream-json produced no result event: ${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({
-        ts: Math.floor(startedAt / 1000),
         caller: 'journal-observer',
-        args,
-        input: prompt,
-        output,
-        durationMs,
-        stderr,
-        eventTypes: parsed.eventTypes,
+        mode: 'auto',
+        lane: 'background',
     });
-    return output;
+    return reply;
 }
 function formatMsg(m) {
     const date = new Date(m.timestamp * 1000)

package/dist/queue/async-tasks.js

@@ -1,12 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, resolve } from 'path';
-import { parseStreamJson, runClaude, TIMEOUT_MS } from '../ai/spawn.js';
+import { getProvider } from '../ai/providers.js';
 import { config } from '../config.js';
 import fastq from 'fastq';
 import { initiate } from '../gateway/outgoing.js';
 import { logger } from '../logger.js';
-import { logPrompt } from '../promptlog.js';
-// Concurrency: how many async Claude workers can run simultaneously.
+// Concurrency: how many async workers can run simultaneously.
 // Start conservative — each process is expensive (Playwright, multi-minute runs).
 // Tune via config.asyncTasks.concurrency once we have real usage data.
 const CONCURRENCY = 3;
@@ -18,7 +17,7 @@ const inProgress = new Map();
 const queue = fastq.promise(async (task) => {
     inProgress.set(task.id, task);
     try {
-        await runTask(task);
+        await executeAsyncTask(task);
     }
     catch (err) {
         logger.error({ err, id: task.id, jid: task.jid }, 'async task failed unexpectedly');
@@ -48,26 +47,6 @@ export function listAsyncTasks(jid) {
     return all.filter((t) => t.jid === jid);
 }
 // ---------- task runner ----------
-let cachedSystemPrompt = null;
-function systemPrompt() {
-    if (cachedSystemPrompt !== null)
-        return cachedSystemPrompt;
-    const personality = readFileSync(resolve(process.cwd(), config.claude.personalityFile), 'utf-8');
-    let memoryInstructions = '';
-    try {
-        memoryInstructions = readFileSync(resolve(process.cwd(), config.memory.instructionsFile), 'utf-8');
-    }
-    catch {
-        // optional
-    }
-    cachedSystemPrompt = memoryInstructions
-        ? `${personality}\n\n---\n\n${memoryInstructions}`
-        : personality;
-    return cachedSystemPrompt;
-}
-export function reloadAsyncSystemPrompt() {
-    cachedSystemPrompt = null;
-}
 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.`,
@@ -109,66 +88,28 @@ function buildPrompt(task) {
     ];
     return lines.join('\n');
 }
-function buildArgs(task) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
-        '--append-system-prompt',
-        systemPrompt(),
+function asyncTaskAddDirs() {
+    return [
+        ...config.claude.addDirs,
+        config.memory.dir,
+        config.storage.mediaDir,
     ];
-    for (const dir of config.claude.addDirs) {
-        args.push('--add-dir', resolve(process.cwd(), dir));
-    }
-    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 spawnClaudeForTask(task, prompt) {
-    const args = buildArgs(task);
-    const { stdout, stderr, durationMs } = await runClaude({
-        args,
-        input: prompt,
-        timeoutMs: TIMEOUT_MS.async,
-        caller: 'async-task',
-    });
-    const startedAt = Date.now() - durationMs;
-    const parsed = parseStreamJson(stdout);
-    if (!parsed) {
-        throw new Error(`async task stream-json produced no result event: ${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({
-        ts: Math.floor(startedAt / 1000),
-        caller: 'async-task',
-        args,
-        input: prompt,
-        output,
-        durationMs,
-        stderr,
-        eventTypes: parsed.eventTypes,
-    });
-    return output;
-}
-async function runTask(task) {
+async function executeAsyncTask(task) {
     const prompt = buildPrompt(task);
     const elapsedLog = () => `${Math.round((Date.now() - task.startedAt * 1000) / 1000)}s`;
     let output;
     try {
-        output = await spawnClaudeForTask(task, prompt);
+        const { reply } = await getProvider().runTask({
+            input: prompt,
+            caller: 'async-task',
+            mode: 'auto',
+            lane: 'async',
+            includeSystemPrompt: true,
+            addDirs: asyncTaskAddDirs(),
+            allowedTools: task.allowedTools,
+        });
+        output = reply;
     }
     catch (err) {
         logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'async task claude call failed');
@@ -394,89 +335,44 @@ function buildBrowserPrompt(task, isResume) {
     ];
     return lines.join('\n');
 }
-function buildBrowserArgs(task, sessionId) {
-    const args = [
-        '-p',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '--model',
-        config.claude.model,
-        '--permission-mode',
-        'acceptEdits',
+function browserAddDirs() {
+    return [
+        ...config.claude.addDirs,
+        config.memory.dir,
+        config.storage.mediaDir,
     ];
-    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;
+    let reply;
+    let returnedSessionId;
     try {
-        const result = await runClaude({
-            args,
+        const result = await getProvider().runTask({
             input: prompt,
-            timeoutMs: TIMEOUT_MS.async,
             caller: 'browser-task',
+            mode: 'auto',
+            lane: 'async',
+            includeSystemPrompt: !isResume,
+            addDirs: browserAddDirs(),
+            allowedTools: task.allowedTools,
+            sessionId: session.sessionId ?? undefined,
         });
-        stdout = result.stdout;
-        stderr = result.stderr;
-        durationMs = result.durationMs;
+        reply = result.reply;
+        returnedSessionId = result.sessionId;
     }
     catch (err) {
-        logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'browser task claude call failed');
+        logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'browser task provider 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;
+    // Persist the session id. On first call the provider returns the new
+    // sessionId; on resume it may return the same or a rotated one.
     if (returnedSessionId) {
         const now = Math.floor(Date.now() / 1000);
         saveBrowserSession({
@@ -486,20 +382,9 @@ async function runBrowserTask(task) {
             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 { clean, digest, journals, journalCreates } = extractFlags(reply);
     const { appendEntry, createJournal, getJournal, isValidSlug } = await import('../memory/journals.js');
     for (const op of journalCreates) {
         if (!isValidSlug(op.slug))

package/dist/queue/worker.js

@@ -1,4 +1,4 @@
-import { askClaude } from '../ai/claude.js';
+import { getProvider } from '../ai/providers.js';
 import { clearSession, setSession, setUsage } from '../ai/sessions.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
@@ -14,7 +14,7 @@ function isStaleSessionError(err) {
 async function callClaude(job) {
     const startedAt = Date.now();
     const wasFresh = !job.sessionId;
-    const { reply, sessionId, usage } = await askClaude({
+    const { reply, sessionId, usage } = await getProvider().ask({
         input: job.input,
         sessionId: job.sessionId,
         allowedTools: job.allowedTools,

package/package.json

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