brand-manager-worker 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brand-manager-worker",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The Goose Tools brand-deal worker — your computer reads your brand email and drafts replies in your voice for goosetools.com, using your own Claude account. Drafts only; it never sends.",
   "repository": {
     "type": "git",

package/worker/agent-cli.js

@@ -0,0 +1,275 @@
+// Agent CLI adapter — runs a job's prompt through whichever coding-agent CLI
+// the user picked on goosetools.com (claim payloads carry `agentCli`).
+//
+// VENDORED FILE: keep byte-identical across brand-manager-worker,
+// caption-maker, and carousel-maker (worker/agent-cli.js in each). Fix a bug
+// here, copy it to the other two.
+//
+// Modes, chosen for speed-vs-capability (see brand-manager commit c0c1b33 —
+// tool-looping turned 36-second drafts into 10-minute ones):
+//   "text"    — plain prompt-in/text-out, no tool flags at all (captions).
+//   "oneshot" — tools explicitly OFF, all context inlined by the caller.
+//   "read"    — file-reading allowed (carousel drafts look at photos).
+//   "session" — tools ON and resumable where the CLI supports it.
+//
+// Honest capability notes per CLI:
+//   claude   — full support: fine tool control, JSON envelope, --resume.
+//   codex    — sandbox-level tool control only; resumable threads; JSONL out.
+//   gemini   — no headless resume: sessionId is always null, callers replay
+//              history (they already do this whenever sessionId is absent).
+//   opencode — plain text out; session continuation is version-dependent, so
+//              we don't claim it: sessionId is always null.
+//
+// Session ids are namespaced ("claude:<uuid>", "codex:<thread-id>") because
+// the server stores them per conversation and the user can switch agents
+// between turns — a Claude uuid means nothing to Codex. resolveSession()
+// drops a mismatched id so the caller falls back to history replay. Bare
+// un-prefixed ids predate namespacing and are treated as Claude's.
+
+import { spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
+
+export const AGENT_IDS = ["claude-code", "codex", "gemini", "opencode"];
+
+const INSTALL_HINTS = {
+  "claude-code": "npm install -g @anthropic-ai/claude-code",
+  codex: "npm install -g @openai/codex, then run: codex login",
+  gemini: "npm install -g @google/gemini-cli, then run: gemini (to sign in)",
+  opencode: "npm install -g opencode-ai, then run: opencode auth login",
+};
+
+const LABELS = {
+  "claude-code": "Claude Code",
+  codex: "Codex CLI",
+  gemini: "Gemini CLI",
+  opencode: "OpenCode",
+};
+
+// Session-id namespace per agent. claude-code writes "claude:" for continuity
+// with the bare ids already stored server-side.
+const SESSION_PREFIX = {
+  "claude-code": "claude",
+  codex: "codex",
+  gemini: "gemini",
+  opencode: "opencode",
+};
+
+function bin(agent) {
+  if (agent === "claude-code") return process.env.CLAUDE_BIN ?? "claude";
+  return agent; // codex / gemini / opencode binaries share their id
+}
+
+/** "claude" (legacy claim payloads) → "claude-code"; unknown → null. */
+export function normalizeAgent(v) {
+  if (v == null || v === "" ) return "claude-code";
+  if (v === "claude") return "claude-code";
+  return AGENT_IDS.includes(v) ? v : null;
+}
+
+/**
+ * Turn a stored (possibly namespaced, possibly another agent's) session id
+ * into one usable by `agent`, or null — null tells the caller to inline the
+ * conversation history instead of resuming.
+ */
+export function resolveSession(agent, sessionId) {
+  if (!sessionId) return null;
+  const idx = sessionId.indexOf(":");
+  if (idx === -1) {
+    // Legacy bare id — those were always Claude Code session uuids.
+    return agent === "claude-code" ? sessionId : null;
+  }
+  const prefix = sessionId.slice(0, idx);
+  return prefix === SESSION_PREFIX[agent] ? sessionId.slice(idx + 1) : null;
+}
+
+function namespaced(agent, rawId) {
+  return rawId ? `${SESSION_PREFIX[agent]}:${rawId}` : null;
+}
+
+// Strip ANSI escapes and other terminal noise some CLIs print around answers.
+export function cleanText(text) {
+  // eslint-disable-next-line no-control-regex
+  return String(text).replace(/\[[0-9;]*[A-Za-z]/g, "").trim();
+}
+
+// stdio[0] MUST be "ignore". Inherited stdin makes invocations hang forever
+// under launchd — brand-manager hit this exact bug (fixed in 3b1f955) and it
+// presents as the worker silently doing nothing after a reboot.
+function run(agent, args, { timeoutMs, cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin(agent), args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => (stdout += d));
+    child.stderr.on("data", (d) => (stderr += d));
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${LABELS[agent]} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(
+        err.code === "ENOENT"
+          ? new Error(
+              `${LABELS[agent]} isn't installed on this computer. Install: ${INSTALL_HINTS[agent]} — or switch your agent back to Claude Code in Setup on goosetools.com.`,
+            )
+          : err,
+      );
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else
+        reject(
+          new Error(`${LABELS[agent]} exited ${code}: ${stderr.slice(0, 600)}`),
+        );
+    });
+  });
+}
+
+/** Is the CLI on PATH? { installed, hint } — cheap, for startup diagnostics. */
+export function detect(agent) {
+  const res = spawnSync(bin(agent), ["--version"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10_000,
+  });
+  return {
+    installed: res.status === 0,
+    hint: INSTALL_HINTS[agent],
+    label: LABELS[agent],
+  };
+}
+
+// Tools Claude must NOT touch in oneshot mode — everything is inlined.
+const CLAUDE_TOOLS_OFF = "Read,Edit,Write,Bash,Glob,Grep,WebFetch,WebSearch";
+
+/**
+ * Run a prompt through the chosen agent CLI.
+ * Returns { text, sessionId } — sessionId is namespaced and null whenever
+ * the CLI can't resume (callers then replay history on the next turn).
+ */
+export async function runAgent({
+  agent = "claude-code",
+  prompt,
+  cwd,
+  mode = "text",
+  sessionId = null,
+  tools = "Read,Edit,Write,Glob,Grep",
+  timeoutMs = 5 * 60 * 1000,
+}) {
+  const normalized = normalizeAgent(agent);
+  if (!normalized) {
+    throw new Error(
+      `Unknown agent "${agent}" — update this worker: npx --yes <package>@latest install`,
+    );
+  }
+  const resume = resolveSession(normalized, sessionId);
+
+  if (normalized === "claude-code") {
+    if (mode === "session") {
+      const args = [
+        "-p",
+        prompt,
+        "--output-format",
+        "json",
+        "--permission-mode",
+        "acceptEdits",
+        "--allowedTools",
+        tools,
+      ];
+      if (resume) args.push("--resume", resume);
+      const raw = await run(normalized, args, { timeoutMs, cwd });
+      // The json envelope carries the session id. Be forgiving: a shape
+      // change shouldn't lose the user's answer.
+      try {
+        const parsed = JSON.parse(raw);
+        return {
+          text: parsed.result ?? parsed.text ?? raw,
+          sessionId: namespaced(
+            normalized,
+            parsed.session_id ?? parsed.sessionId ?? resume ?? null,
+          ),
+        };
+      } catch {
+        return { text: raw, sessionId: namespaced(normalized, resume) };
+      }
+    }
+    const args = ["-p", prompt, "--output-format", "text"];
+    if (mode === "oneshot") args.push("--disallowedTools", CLAUDE_TOOLS_OFF);
+    if (mode === "read") args.push("--allowedTools", "Read");
+    const text = await run(normalized, args, { timeoutMs, cwd });
+    return { text, sessionId: null };
+  }
+
+  if (normalized === "codex") {
+    // Sandbox is the only tool control codex offers; read-only + the prompt's
+    // own "don't use tools" language is the closest match to oneshot.
+    const sandbox = mode === "session" ? "workspace-write" : "read-only";
+    const args = ["exec"];
+    if (resume) args.push("resume", resume);
+    args.push("--skip-git-repo-check", "--sandbox", sandbox, "--json");
+    if (cwd) args.push("--cd", cwd);
+    args.push(prompt);
+    const raw = await run(normalized, args, { timeoutMs, cwd });
+    // --json emits JSONL events; harvest the thread id and the last agent
+    // message, falling back to the raw output if the shape ever changes.
+    let threadId = resume ?? null;
+    let last = null;
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("{")) continue;
+      try {
+        const evt = JSON.parse(trimmed);
+        threadId =
+          evt.thread_id ?? evt.session_id ?? evt.thread?.id ?? threadId;
+        const item = evt.item ?? evt;
+        const type = item.item_type ?? item.type;
+        if (
+          (type === "agent_message" || type === "assistant_message") &&
+          typeof (item.text ?? item.message) === "string"
+        ) {
+          last = item.text ?? item.message;
+        }
+      } catch {
+        // not an event line — ignore
+      }
+    }
+    return {
+      text: cleanText(last ?? raw),
+      sessionId: mode === "session" ? namespaced(normalized, threadId) : null,
+    };
+  }
+
+  if (normalized === "gemini") {
+    // No reliable headless resume — never claim one. Session mode gets yolo
+    // approvals so its tools can run unattended.
+    const args = ["-p", prompt, "--output-format", "json"];
+    if (mode === "session") args.push("--yolo");
+    let raw;
+    try {
+      raw = await run(normalized, args, { timeoutMs, cwd });
+    } catch (err) {
+      // Older gemini builds lack --output-format; retry plain.
+      if (!/output-format|unknown option/i.test(String(err.message))) throw err;
+      raw = await run(normalized, ["-p", prompt], { timeoutMs, cwd });
+      return { text: cleanText(raw), sessionId: null };
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return {
+        text: cleanText(parsed.response ?? parsed.result ?? raw),
+        sessionId: null,
+      };
+    } catch {
+      return { text: cleanText(raw), sessionId: null };
+    }
+  }
+
+  // opencode — plain text out; we don't claim session continuation (it's
+  // version-dependent), so every turn replays history.
+  const raw = await run(normalized, ["run", prompt], { timeoutMs, cwd });
+  return { text: cleanText(raw), sessionId: null };
+}

package/worker/agent.js

@@ -12,8 +12,21 @@ import { BRAND_DIR } from "./paths.js";
 // Automated / no-reply senders never send brand deals — skip them WITHOUT
 // spending a Claude call. Conservative on purpose: real brands/agencies use
 // human addresses.
-const AUTOMATED_SENDER =
-  /no-?reply|do-?not-?reply|noreply|mailer-daemon|postmaster|notifications?@|accounts\.google\.com|@.*\.(beehiiv|substack)\.com|@e\.|@email\.|@mail\./i;
+const AUTOMATED_SENDER = new RegExp(
+  [
+    // Classic no-reply shapes.
+    "no-?reply", "do-?not-?reply", "noreply", "mailer-daemon", "postmaster",
+    "notifications?@", "accounts\\.google\\.com",
+    "@.*\\.(beehiiv|substack)\\.com",
+    // Bulk-mail SUBDOMAINS. Retail blasts send from things like
+    // news.emailmarket.shein.com, which slipped past the old @mail./@email.
+    // patterns and cost a full Claude call each — 7 SHEIN cart reminders in
+    // one scan. Matched as a leading label so a real company domain like
+    // news-corp.com or mailchimp.com (an agency's own address) is untouched.
+    "@(e|news|newsletter|email|emails|mail|mailer|marketing|promo|promos|campaign|campaigns|updates|offers|deals|shop|store|hello|info)[.-]",
+  ].join("|"),
+  "i",
+);
 
 export const isAutomated = (from) => AUTOMATED_SENDER.test(from);
 

package/worker/api.js

@@ -45,7 +45,11 @@ export const TOKEN =
   localEnv.WORKER_TOKEN ??
   sharedEnv.WORKER_TOKEN;
 
-export const POLL_MS = 30_000;
+// 5 min, not 30s: a 24/7 30s poll kept the prod database awake around the
+// clock and burned its whole compute quota. Brand work is background inbox
+// tending — nobody is watching a spinner — and the loop drains bursts
+// immediately once one job is claimed, so only the first pickup waits.
+export const POLL_MS = 5 * 60 * 1000;
 
 /** POST to /api/brand/worker/<path>. Returns null on 204 (no work). */
 export async function api(path, body) {

package/worker/claude.js

@@ -1,77 +1,59 @@
-// Running Claude on this machine.
+// Running the user's coding agent on this machine.
+//
+// Historically this file shelled out to Claude Code directly; the actual CLI
+// plumbing now lives in agent-cli.js (vendored, shared across the Goose Tools
+// workers) and honors the agent the user picked on goosetools.com — the claim
+// payload's `agentCli`. index.js calls setAgent() once per job; the worker
+// handles jobs serially, so module state is safe.
 //
 // Two modes, and the split matters for speed. brand-manager learned this the
-// hard way (commit c0c1b33): letting Claude loop on tools to gather its own
+// hard way (commit c0c1b33): letting the agent loop on tools to gather its own
 // context took 5–10 minutes per draft versus ~36 seconds when everything was
 // inlined up front. So:
 //
 //   oneShot()  — drafting. Tools OFF, all context inlined by the caller. Fast.
 //   session()  — chat, voice-audit, stats, learn. Tools ON, scoped to the
-//                brand directory, and resumable so a follow-up message
-//                remembers the previous turn.
+//                brand directory, and resumable where the CLI supports it
+//                (Claude and Codex do; Gemini and OpenCode return a null
+//                sessionId, and callers replay history instead).
 //
-// There is no API key anywhere here. This runs on the user's own Claude
-// subscription via the `claude` CLI, same as every other Goose Tools worker.
+// There is no API key anywhere here. This runs on the user's own agent
+// subscription via that agent's CLI, same as every other Goose Tools worker.
 
-import { spawn } from "node:child_process";
+import { runAgent, normalizeAgent, resolveSession } from "./agent-cli.js";
 
-const CLAUDE_BIN = process.env.CLAUDE_BIN ?? "claude";
+let currentAgent = "claude-code";
 
-// stdio[0] MUST be "ignore". Inherited stdin makes every invocation hang
-// forever under launchd — brand-manager hit this exact bug (fixed in 3b1f955)
-// and it presents as the worker silently doing nothing after a reboot.
-function run(args, { timeoutMs, cwd }) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(CLAUDE_BIN, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (d) => (stdout += d));
-    child.stderr.on("data", (d) => (stderr += d));
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      reject(new Error(`claude timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(
-        err.code === "ENOENT"
-          ? new Error("Claude Code not found. Install: npm install -g @anthropic-ai/claude-code")
-          : err,
-      );
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (code === 0) resolve(stdout);
-      else reject(new Error(`claude exited ${code}: ${stderr.slice(0, 600)}`));
-    });
-  });
+/** Set by index.js from the claim payload before each job's handler runs. */
+export function setAgent(agentCli) {
+  currentAgent = normalizeAgent(agentCli) ?? "claude-code";
+}
+
+export function getAgent() {
+  return currentAgent;
 }
 
 /** Single-shot, no tools. For drafting, where the caller inlines all context. */
 export async function oneShot(prompt, { timeoutMs = 4 * 60 * 1000, cwd } = {}) {
-  return run(
-    [
-      "-p",
-      prompt,
-      "--output-format",
-      "text",
-      "--disallowedTools",
-      "Read,Edit,Write,Bash,Glob,Grep,WebFetch,WebSearch",
-    ],
-    { timeoutMs, cwd },
-  );
+  const { text } = await runAgent({
+    agent: currentAgent,
+    prompt,
+    cwd,
+    mode: "oneshot",
+    timeoutMs,
+  });
+  return text;
 }
 
 /**
- * A real, resumable Claude Code session with tools, scoped to the brand
- * directory. This is what makes the website chat behave like talking to the
- * agent in a terminal: it can read the ledgers, edit the rate card, search
- * Gmail through the worker's own commands, and remember the last turn.
+ * A real, resumable agent session with tools, scoped to the brand directory.
+ * This is what makes the website chat behave like talking to the agent in a
+ * terminal: it can read the ledgers, edit the rate card, and (where the CLI
+ * supports resuming) remember the last turn.
  *
- * Returns { text, sessionId } — pass sessionId back in to continue.
+ * Returns { text, sessionId } — pass sessionId back in to continue. The id is
+ * namespaced per agent; a stored id from a different agent is dropped and the
+ * caller's history-replay path covers the gap.
  */
 export async function session(
   prompt,
@@ -84,39 +66,33 @@ export async function session(
     tools = "Read,Edit,Write,Glob,Grep",
   } = {},
 ) {
-  const args = [
-    "-p",
+  return runAgent({
+    agent: currentAgent,
     prompt,
-    "--output-format",
-    "json",
-    "--permission-mode",
-    "acceptEdits",
-    "--allowedTools",
+    cwd,
+    mode: "session",
+    sessionId,
     tools,
-  ];
-  if (sessionId) args.push("--resume", sessionId);
-
-  const raw = await run(args, { timeoutMs, cwd });
+    timeoutMs,
+  });
+}
 
-  // --output-format json gives a result envelope carrying the session id.
-  // Be forgiving: a shape change shouldn't lose the user's answer, so fall
-  // back to treating the output as plain text.
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      text: parsed.result ?? parsed.text ?? raw,
-      sessionId: parsed.session_id ?? parsed.sessionId ?? sessionId ?? null,
-    };
-  } catch {
-    return { text: raw, sessionId: sessionId ?? null };
-  }
+/**
+ * Would `sessionId` actually resume under the current agent? Callers check
+ * this before building a prompt so they can inline conversation history when
+ * the answer is no (agent switched, or the CLI can't resume at all).
+ */
+export function canResume(sessionId) {
+  if (!sessionId) return false;
+  if (currentAgent === "gemini" || currentAgent === "opencode") return false;
+  return resolveSession(currentAgent, sessionId) !== null;
 }
 
 /**
- * Pull a JSON object out of Claude's text output. Ported verbatim in spirit
- * from brand-manager's parseDecision: prefer a fenced block, else take the
- * first {...last }. Returns null on failure — the caller must treat that as
- * "retry later", never as "skip this thread".
+ * Pull a JSON object out of the agent's text output. Ported verbatim in
+ * spirit from brand-manager's parseDecision: prefer a fenced block, else take
+ * the first {...last }. Returns null on failure — the caller must treat that
+ * as "retry later", never as "skip this thread".
  */
 export function parseJson(text) {
   const fenced = text.match(/```json\s*([\s\S]*?)```/);

package/worker/cli.js

@@ -15,7 +15,7 @@ import { fileURLToPath } from "node:url";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-const command = ["install", "update", "status", "uninstall", "run"].includes(process.argv[2])
+const command = ["install", "update", "status", "uninstall", "run", "doctor"].includes(process.argv[2])
   ? process.argv[2]
   : "run";
 
@@ -48,7 +48,10 @@ function has(cmd) {
   }
 }
 
-if (!has("claude")) {
+// Claude Code is the default agent, so it's required to set up; the other
+// agents (picked in Setup on goosetools.com) are checked lazily per job and
+// reported by `doctor`.
+if (command !== "doctor" && !has("claude")) {
   console.error(
     "\nClaude Code isn't installed yet (it writes your replies).\n" +
       "Install it with:  npm install -g @anthropic-ai/claude-code\n" +
@@ -58,7 +61,15 @@ if (!has("claude")) {
   process.exit(1);
 }
 
-if (command === "install") {
+if (command === "doctor") {
+  const { AGENT_IDS, detect } = await import("./agent-cli.js");
+  for (const id of AGENT_IDS) {
+    const d = detect(id);
+    console.log(
+      `${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`,
+    );
+  }
+} else if (command === "install") {
   const { install } = await import("./service.js");
   install({
     url: (flag("--url") ?? "https://goosetools.com").replace(/\/$/, ""),

package/worker/handlers.js

@@ -12,7 +12,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { classify, decide, learnFromEdit } from "./agent.js";
 import { extractContracts } from "./attachments.js";
-import { session } from "./claude.js";
+import { session, canResume } from "./claude.js";
 import { invalidateContext } from "./context.js";
 import { appendDraftLog, lastDraftFor } from "./drafts-log.js";
 import { createReplyDraft } from "./gmail-draft.js";
@@ -35,18 +35,6 @@ const noGmail = () => ({
   error: "Gmail isn't connected — connect your email on goosetools.com/dashboard/brand-manager",
 });
 
-/** Thread metadata rows for the mirror, from fetched threads. */
-const threadMeta = (threads) =>
-  threads.map((t) => ({
-    threadId: t.id,
-    accountEmail: t.account,
-    fromName: t.last.from.replace(/\s*<[^>]*>\s*/, "").trim() || null,
-    fromEmail: (t.last.from.match(/<([^>]+)>/)?.[1] ?? t.last.from).trim() || null,
-    subject: t.subject,
-    lastMessageAt: t.last.date,
-    hasUnsentDraft: t.hasUnsentDraft,
-  }));
-
 /** Resolve decision attachment paths ("stats/screenshots/x.png") under BRAND_DIR. */
 const resolveAttachments = (paths = []) =>
   paths.map((p) => (p.startsWith("/") ? p : join(BRAND_DIR, p))).filter((p) => existsSync(p));
@@ -73,7 +61,7 @@ async function draftForThread(job, thread) {
     return {
       ok: true,
       summary: `skip — ${decision.summary}`,
-      mirror: buildMirror({ threads: threadMeta([thread]) }),
+      mirror: buildMirror({ threads: [thread] }),
     };
   }
 
@@ -105,7 +93,7 @@ async function draftForThread(job, thread) {
     summary: decision.summary,
     resultBody: decision.body ?? "",
     flags: decision.flags ?? [],
-    mirror: buildMirror({ threads: threadMeta([thread]) }),
+    mirror: buildMirror({ threads: [thread] }),
   };
 }
 
@@ -177,7 +165,7 @@ export async function runScan(job) {
     ok: true,
     summary: lines.length ? lines.join(" · ").slice(0, 1900) : "No new brand mail needing a draft.",
     flags,
-    mirror: buildMirror({ threads: threadMeta(threads) }),
+    mirror: buildMirror({ threads }),
   };
 }
 
@@ -213,7 +201,7 @@ export async function runChat(job) {
     `base/rules/feedback-loop.md before saving any preference), voice/ playbook/ deals/ stats/ are`,
     `their personal layer — read what you need, and APPEND edits per the feedback loop.`,
     `You cannot send email, and you cannot access Gmail from this session.`,
-    job.sessionId ? "" : history ? `\nConversation so far:\n${history}` : "",
+    canResume(job.sessionId) ? "" : history ? `\nConversation so far:\n${history}` : "",
     threadBlock,
     ``,
     `The creator says:`,

package/worker/index.js

@@ -13,6 +13,7 @@ import { api, syncAssets, BASE_URL, POLL_MS, TOKEN } from "./api.js";
 import { BRAND_DIR, ensureDirs } from "./paths.js";
 import { buildMirror } from "./mirror.js";
 import { runOutreachChat, runOutreachDraft } from "./outreach.js";
+import { setAgent } from "./claude.js";
 import {
   runChat,
   runDraft,
@@ -37,6 +38,9 @@ console.log(`brand worker → ${BASE_URL}`);
 console.log(`files        → ${BRAND_DIR}`);
 
 async function handle(job) {
+  // The claim payload says which agent CLI the user picked; handlers and the
+  // claude.js delegates read it for the duration of this job.
+  setAgent(job.agentCli);
   switch (job.kind) {
     case "index": {
       // Pure local read — no Gmail needed, so this works with nothing else

package/worker/mirror.js

@@ -74,15 +74,22 @@ export function collectKnowledge() {
  * machine is defined in exactly one place, right here.
  */
 export function collectThreads(threads) {
-  return threads.map((t) => ({
-    threadId: t.id,
-    accountEmail: t.account ?? null,
-    fromName: t.fromName ?? null,
-    fromEmail: t.fromEmail ?? null,
-    subject: t.subject ?? null,
-    lastMessageAt: t.lastMessageAt ?? null,
-    hasUnsentDraft: Boolean(t.hasUnsentDraft),
-  }));
+  return threads.map((t) => {
+    // Raw Thread objects in, mirror rows out. This is the ONLY place that
+    // shape is decided — callers must not pre-map, or threadId silently
+    // becomes undefined and the server drops the row (which is exactly what
+    // happened: deals and knowledge mirrored, threads never did).
+    const from = t.last?.from ?? "";
+    return {
+      threadId: t.id,
+      accountEmail: t.account ?? null,
+      fromName: from.replace(/\s*<[^>]*>\s*/, "").replace(/^"|"$/g, "").trim() || null,
+      fromEmail: (from.match(/<([^>]+)>/)?.[1] ?? from).trim() || null,
+      subject: t.subject ?? null,
+      lastMessageAt: t.last?.date ?? null,
+      hasUnsentDraft: Boolean(t.hasUnsentDraft),
+    };
+  });
 }
 
 /** The full mirror payload for a complete() call. */

package/worker/outreach.js

@@ -13,7 +13,7 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { BASE_DIR, BRAND_DIR, PLAYBOOK_DIR, STATS_DIR, VOICE_DIR } from "./paths.js";
-import { oneShot, parseJson, session } from "./claude.js";
+import { oneShot, parseJson, session, canResume } from "./claude.js";
 import { createGmailDraft } from "./gmail-draft.js";
 
 const read = (p, cap = 20_000) =>
@@ -60,7 +60,7 @@ function historyBlock(history) {
  */
 export async function runOutreachChat(job) {
   const prompt = `${outreachMode()}
-${job.sessionId ? "" : historyBlock(job.history)}
+${canResume(job.sessionId) ? "" : historyBlock(job.history)}
 ## This turn
 
 The creator says: "${job.instruction ?? ""}"

package/worker/service.js

@@ -62,7 +62,16 @@ function servicePath() {
     npmGlobalBin(),
     ...(process.platform === "win32"
       ? [process.env.PATH ?? ""]
-      : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]),
+      : [
+          "/opt/homebrew/bin",
+          "/usr/local/bin",
+          // opencode's installer and some npm setups drop binaries here.
+          `${process.env.HOME ?? ""}/.local/bin`,
+          "/usr/bin",
+          "/bin",
+          "/usr/sbin",
+          "/sbin",
+        ]),
   ].filter(Boolean);
   return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
 }