@obtoai/agent-bridge 0.1.0-beta.22 → 0.1.0-beta.25

package/README.md

@@ -14,7 +14,15 @@ obto-bridge start    # daemon connects, you're live
 
 ## Status
 
-**Public beta.** Self-serve, no card. `obto-bridge init` creates a free account inline — no waiting on an invite, no support email loop. A Pro tier with longer Hindsight memory retention is coming; until then everyone gets the same daemon features on the free tier.
+**Public beta.** Self-serve. `obto-bridge init` creates an account inline — no waiting on an invite, no support email loop.
+
+## Pricing
+
+**$10/month, flat per account** — with a **14-day free trial** (card required at subscribe; cancel anytime during the trial at no charge). The subscription covers the relay service: the web UI, the secure message relay, and durable thread storage across all your machines.
+
+**Model usage is never included or marked up** — your agents run on your machine under your own Anthropic/OpenAI/provider credentials, billed directly to you. The bridge doesn't proxy model traffic.
+
+Invite accounts provisioned before billing activation keep full access with no subscription. Manage your subscription at `https://agent-bridge.obto.co/api/bridge/billing`.
 
 ## What you'll need
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obtoai/agent-bridge",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.25",
   "description": "Local consumer for the OBTO Agent Bridge. Receives bridge events over SSE and drives a coding agent (Claude Code or OpenAI Codex) on your machine.",
   "license": "Apache-2.0",
   "author": "OBTO Inc.",

package/src/bridge-http.js

@@ -89,8 +89,28 @@ const claimThread = (threadId, agentId) =>
 // filesystem scanner so the bridge UI can render them alongside bridge-owned
 // threads. Fire-and-forget; the bridge tolerates partial payloads and
 // re-observes on the next 30s tick.
-const postExternalSync = (agentId, sessions) =>
-  postJson('/api/bridge/external/sync', { agentId, sessions });
+// Phase 6.7 — `presentSessionIds` is the FULL on-disk inventory (external +
+// bridge-owned). The bridge marks rows missing from it as vanished so dead
+// sessions stop being adoptable, and restores them if the file reappears.
+const postExternalSync = (agentId, sessions, presentSessionIds) =>
+  postJson('/api/bridge/external/sync', { agentId, sessions, presentSessionIds });
+
+// Phase 6.6 — ship the FULL local session history for an adopted thread.
+// The route replaces the adoption-time partial backfill and is idempotent
+// (hist:<sessionId>:<idx> clientMsgIds), so retries are safe.
+const postExternalBackfill = (threadId, sessionId, messages) =>
+  postJson('/api/bridge/external/backfill', { threadId, sessionId, messages });
+
+// Phase 5a — read the newest messages on a thread (backward page ending at
+// `before`). Used to build the first-touch history block when an engine
+// takes over a thread that already has conversation.
+const getMessagesBefore = (threadId, beforeIso, limit) => {
+  const qs =
+    'threadId=' + encodeURIComponent(String(threadId || '')) +
+    '&before=' + encodeURIComponent(String(beforeIso || new Date().toISOString())) +
+    (limit ? '&limit=' + encodeURIComponent(String(limit)) : '');
+  return getJson('/api/messages?' + qs);
+};
 
 // Phase 6.4 — download an attachment's raw bytes for use as a Claude SDK
 // image content block. The serve route streams the file with its stored
@@ -119,8 +139,10 @@ module.exports = {
   buildHeaders,
   postMessage,
   getMessages,
+  getMessagesBefore,
   postAgentActivity,
   claimThread,
   postExternalSync,
+  postExternalBackfill,
   getAttachmentBytes,
 };

package/src/capabilities.js

@@ -1,9 +1,14 @@
 'use strict';
 
-// Phase 2b — what this machine can drive. The Claude Agent SDK is a hard
-// dependency of the daemon (declared in package.json), so `claude` is always
-// available. `codex` and `opencode` need their respective CLIs on PATH —
-// we probe with `which` (POSIX) or `where` (Windows).
+// Phase 2b — what this machine can drive.
+//
+// `claude` and `opencode` are bundled SDKs (declared in package.json) and
+// self-contained: claude uses the Claude Agent SDK; opencode uses
+// @opencode-ai/sdk's createOpencode() which spawns its own local HTTP server.
+// Neither needs a CLI on PATH — they're always advertised.
+//
+// `codex` uses @openai/codex-sdk which delegates to the user's `codex` CLI
+// for auth/config, so we still probe PATH for it.
 //
 // Sent to the bridge as `?capabilities=claude,codex,...` on SSE connect; the
 // bridge records them in `agent_bridge_daemons` so the UI picker can offer
@@ -22,9 +27,8 @@ const onPath = (cmd) => {
 };
 
 const detect = () => {
-  const out = ['claude']; // bundled SDK; always advertised
+  const out = ['claude', 'opencode']; // bundled SDKs; always advertised
   if (onPath('codex')) out.push('codex');
-  if (onPath('opencode')) out.push('opencode');
   return out;
 };
 

package/src/claude-driver.js

@@ -7,6 +7,10 @@ const os = require('os');
 const { encodeProjectDir } = require('./session-scanner');
 const bridgeHttp = require('./bridge-http');
 const { buildBridgeMcpServer } = require('./bridge-mcp-server');
+// Phase 5a — when this engine first touches a thread that already has bridge
+// history (provider switch / adopted thread), inject that history into the
+// first prompt so the session starts with context instead of amnesia.
+const { buildHistoryBlock } = require('./history');
 
 // Per-thread promise queue. Concurrent AMQP messages targeting the same thread
 // are serialized so first-touch session creation completes before any resume,
@@ -336,7 +340,18 @@ const consumeQuery = async (q) => {
 const driveFirstTouch = async ({ threadId, projectDir, payload, log }) => {
   const sdk = await import('@anthropic-ai/claude-agent-sdk');
   const bridgeServer = await buildBridgeMcpServer({ log });
-  const prompt = await buildPromptForSdk(payload, buildBootstrapPrompt(payload), log);
+  // Phase 5a — prior thread history (empty string for brand-new threads).
+  const historyBlock = await buildHistoryBlock({
+    threadId,
+    currentMessageId: payload.messageId,
+    engineName: 'Claude',
+    log,
+  });
+  const prompt = await buildPromptForSdk(
+    payload,
+    historyBlock + buildBootstrapPrompt(payload),
+    log,
+  );
   const options = Object.assign(
     {
       cwd: projectDir,
@@ -439,13 +454,41 @@ const driveResume = async ({ threadId, sessionId, projectDir, jsonlPath, lastJso
   return { stopReason, assistantTextChars, lastJsonlMtimeMs: newMtime };
 };
 
+// A turn that errored before producing ANY assistant output never called
+// bridge_post — from the human's perspective that is pure dead air. Claude is
+// the one engine whose driver doesn't relay output itself, so failures here
+// MUST be surfaced explicitly.
+const turnProducedNothing = (result) =>
+  !!result &&
+  !result.skipped &&
+  String(result.stopReason || '').indexOf('error') !== -1 &&
+  !(result.assistantTextChars > 0);
+
+const postBridgeNotice = async ({ threadId, kind, body, log }) => {
+  try {
+    const r = await bridgeHttp.postMessage({
+      threadId,
+      author: 'claude-bridge',
+      role: 'agent',
+      kind: kind || 'error',
+      body,
+    });
+    if (!r.ok) log('error', 'bridge notice post failed', { threadId, status: r.status });
+  } catch (e) {
+    log('error', 'bridge notice post threw', {
+      threadId,
+      error: e && e.message ? e.message : String(e),
+    });
+  }
+};
+
 const drive = (params) => {
   const key = params.threadId;
   const prev = queues.get(key) || Promise.resolve();
   const next = prev
-    .then(() => {
+    .then(async () => {
       if (params.binding && params.binding.sessionId) {
-        return driveResume({
+        const result = await driveResume({
           threadId: params.threadId,
           sessionId: params.binding.sessionId,
           projectDir: params.binding.projectDir,
@@ -454,19 +497,80 @@ const drive = (params) => {
           payload: params.payload,
           log: params.log,
         });
+
+        // Resume produced zero output and errored — the original engine
+        // session is unusable (moved/deleted JSONL, corrupt state, wrong
+        // machine). Fall back to a FRESH session: the Phase 5a history block
+        // in driveFirstTouch carries the thread context across, so the user
+        // gets a real answer instead of silence. Tell them what happened
+        // first — honest context loss beats quiet failure.
+        if (turnProducedNothing(result)) {
+          params.log('warn', 'resume produced no output — falling back to fresh session with thread history', {
+            threadId: params.threadId,
+            sessionId: params.binding.sessionId,
+            stopReason: result.stopReason,
+          });
+          await postBridgeNotice({
+            threadId: params.threadId,
+            kind: 'status',
+            body: '⚠️ Could not resume the original local session (`' +
+              params.binding.sessionId + '`) — its session file appears to be ' +
+              'missing or unusable. Starting a fresh session seeded with this ' +
+              'thread\'s history…',
+            log: params.log,
+          });
+          const fresh = await driveFirstTouch({
+            threadId: params.threadId,
+            projectDir: (params.binding && params.binding.projectDir) || params.projectDir,
+            payload: params.payload,
+            log: params.log,
+          });
+          if (turnProducedNothing(fresh)) {
+            await postBridgeNotice({
+              threadId: params.threadId,
+              kind: 'error',
+              body: 'The fresh Claude session also failed (' + fresh.stopReason +
+                ') before producing any output. Check the daemon log on the ' +
+                'machine for the underlying SDK error.',
+              log: params.log,
+            });
+          }
+          return fresh;
+        }
+        return result;
       }
-      return driveFirstTouch({
+
+      const result = await driveFirstTouch({
         threadId: params.threadId,
         projectDir: params.projectDir,
         payload: params.payload,
         log: params.log,
       });
+      if (turnProducedNothing(result)) {
+        await postBridgeNotice({
+          threadId: params.threadId,
+          kind: 'error',
+          body: 'The Claude session failed (' + result.stopReason + ') before ' +
+            'producing any output. Check the daemon log on the machine for ' +
+            'the underlying SDK error.',
+          log: params.log,
+        });
+      }
+      return result;
     })
-    .catch((err) => {
+    .catch(async (err) => {
       params.log('error', 'drive failed', {
         threadId: params.threadId,
         error: err && err.message ? err.message : String(err),
       });
+      // Even hard throws must not be silent on the thread.
+      await postBridgeNotice({
+        threadId: params.threadId,
+        kind: 'error',
+        body: 'Claude turn failed on the daemon: ' +
+          (err && err.message ? err.message : String(err)),
+        log: params.log,
+      });
       throw err;
     });
   queues.set(key, next);

package/src/codex-driver.js

@@ -25,6 +25,9 @@
 const { loadConfig } = require('./config');
 const { buildEnvelope } = require('./claude-driver');
 const bridgeHttp = require('./bridge-http');
+// Phase 5a — Codex has no MCP thread_read; its only shot at prior thread
+// context is inline injection into the first prompt.
+const { buildHistoryBlock } = require('./history');
 
 // Per-thread promise queue — concurrent replies on one thread are serialized
 // so first-touch completes before any resume. Mirrors claude-driver.
@@ -48,8 +51,8 @@ const attachmentDropNote = (payload) => {
     'image in words if you need its content.]\n\n';
 };
 
-const buildCodexPrompt = (payload, isFirst) => {
-  const head = attachmentDropNote(payload) + buildEnvelope(payload);
+const buildCodexPrompt = (payload, isFirst, historyBlock) => {
+  const head = (historyBlock || '') + attachmentDropNote(payload) + buildEnvelope(payload);
   if (!isFirst) return head;
   return head +
     '\n\n---\n' +
@@ -137,9 +140,22 @@ const driveTurn = async ({ threadId, projectDir, resumeId, payload, log }) => {
   let finalResponse = '';
   let failure = null;
 
+  // Phase 5a — on first touch of a thread with prior bridge history (provider
+  // switch or adopted thread), give Codex that history inline. Resumes don't
+  // need it: the engine session already holds its own context.
+  let historyBlock = '';
+  if (isFirst) {
+    historyBlock = await buildHistoryBlock({
+      threadId,
+      currentMessageId: payload.messageId,
+      engineName: 'Codex',
+      log,
+    });
+  }
+
   try {
     const res = await runCodex({
-      prompt: buildCodexPrompt(payload, isFirst),
+      prompt: buildCodexPrompt(payload, isFirst, historyBlock),
       projectDir,
       resumeId,
     });

package/src/daemon.js

@@ -7,6 +7,12 @@ const { drive, tryResolvePermission, agentFor } = require('./driver');
 const { postAgentActivity, claimThread, postExternalSync } = require('./bridge-http');
 const { detect: detectCapabilities } = require('./capabilities');
 const { scanAll: scanExternalSessions } = require('./external-scanner');
+// Phase 6.5 — OpenCode desktop/CLI uses SQLite instead of JSONL; separate
+// scanner reads ~/.local/share/opencode/opencode.db read-only via the
+// sqlite3 CLI subprocess. Empty array when SQLite or the DB isn't present.
+const { scanAll: scanOpencodeSessions } = require('./opencode-sqlite-scanner');
+// Phase 6.6 — full-history backfill for adopted threads (fire-and-forget).
+const { backfillFullHistory } = require('./history');
 
 const log = (level, msg, data) => {
   const line = { ts: new Date().toISOString(), level, msg };
@@ -160,6 +166,12 @@ const handleEvent = async (sseEvent) => {
         source: ea.source,
       });
     }
+    // Phase 6.6 — ship the FULL local session history to the bridge so the
+    // web thread shows the whole conversation, not the ~10-turn adoption
+    // preview. Runs off the hot path; idempotent server-side. Fired even
+    // when the cwd guard above declined the resume binding — history is
+    // about what the user SEES, independent of whether we can resume.
+    backfillFullHistory({ threadId, externalAdoption: ea, log });
   }
 
   log('event', 'reply received', {
@@ -295,11 +307,31 @@ const ownedSessionIdsFromState = () => {
 };
 const externalScanTick = async () => {
   try {
-    const all = scanExternalSessions();
+    // Phase 6.5 — fold opencode SQLite sessions into the same external sync
+    // payload. Both scanners are best-effort and return [] on failure, so a
+    // dead SQLite CLI or missing DB never breaks the JSONL path.
+    const fromJsonl = scanExternalSessions();
+    let fromOpencode = [];
+    let scanDegraded = false;
+    try {
+      fromOpencode = scanOpencodeSessions();
+    } catch (e) {
+      // Phase 6.7 — a failed sub-scan means our inventory is INCOMPLETE this
+      // tick; sending it would falsely mark that source's sessions vanished.
+      scanDegraded = true;
+      log('warn', 'opencode sqlite scan failed', { error: e && e.message ? e.message : String(e) });
+    }
+    const all = fromJsonl.concat(fromOpencode);
     const owned = ownedSessionIdsFromState();
     const external = all.filter((s) => s && s.sessionId && !owned.has(String(s.sessionId)));
-    if (external.length === 0) return;
-    const r = await postExternalSync(cfg.agentId, external);
+    // Phase 6.7 — full inventory (external + owned) so the bridge can mark
+    // rows whose local file vanished. Sent even when `external` is empty;
+    // the bridge ignores empty inventories, so a glitched scan is harmless.
+    const presentSessionIds = scanDegraded
+      ? [] // incomplete inventory — skip reconciliation this tick
+      : all.filter((s) => s && s.sessionId).map((s) => String(s.sessionId));
+    if (external.length === 0 && presentSessionIds.length === 0) return;
+    const r = await postExternalSync(cfg.agentId, external, presentSessionIds);
     if (!r || !r.ok) {
       log('warn', 'external sync rejected', {
         status: r && r.status,
@@ -310,6 +342,8 @@ const externalScanTick = async () => {
       log('debug', 'external sync ok', {
         sent: external.length,
         upserted: (r.data && r.data.count) || 0,
+        vanished: (r.data && r.data.vanished) || 0,
+        restored: (r.data && r.data.restored) || 0,
       });
     }
   } catch (e) {

package/src/external-scanner.js

@@ -543,4 +543,77 @@ const scanAll = () => {
   return claude.concat(codex);
 };
 
-module.exports = { scanAll, scanClaude, scanCodex, extractLastMessage, decodeClaudeProjectDir };
+// ── Phase 6.6 — full-history reads for adoption backfill ──────────────────
+// Unlike the 30s discovery scan (tail-bounded by design), the one-time
+// backfill on adoption wants the WHOLE session. Same parsing pipeline as
+// extractRecentMessages — coalescing, injection filtering, markdown-safe
+// whitespace — just fed the entire file instead of a 512KB tail.
+
+const FULL_READ_MAX_BYTES = 50 * 1024 * 1024; // refuse to slurp >50MB
+
+// Locate the JSONL file for a (source, sessionId). Walks the same roots the
+// discovery scan walks. Returns the absolute path or null.
+const findSessionFile = (source, sessionId) => {
+  const sid = String(sessionId || '').trim();
+  if (!sid) return null;
+
+  if (source === 'codex') {
+    let years;
+    try { years = fs.readdirSync(CODEX_DIR); } catch (_) { return null; }
+    for (const y of years) {
+      if (!/^\d{4}$/.test(y)) continue;
+      let months; try { months = fs.readdirSync(path.join(CODEX_DIR, y)); } catch (_) { continue; }
+      for (const m of months) {
+        if (!/^\d{2}$/.test(m)) continue;
+        let days; try { days = fs.readdirSync(path.join(CODEX_DIR, y, m)); } catch (_) { continue; }
+        for (const d of days) {
+          if (!/^\d{2}$/.test(d)) continue;
+          const dPath = path.join(CODEX_DIR, y, m, d);
+          let files; try { files = fs.readdirSync(dPath); } catch (_) { continue; }
+          for (const f of files) {
+            if (f.startsWith('rollout-') && f.endsWith('-' + sid + '.jsonl')) {
+              return path.join(dPath, f);
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  // claude — CLI/extension root + every Desktop local-agent root.
+  const roots = [CLAUDE_DIR].concat(findClaudeDesktopProjectRoots());
+  for (const root of roots) {
+    let projects;
+    try { projects = fs.readdirSync(root); } catch (_) { continue; }
+    for (const p of projects) {
+      const candidate = path.join(root, p, sid + '.jsonl');
+      try { if (fs.statSync(candidate).isFile()) return candidate; } catch (_) {}
+    }
+  }
+  return null;
+};
+
+// Read and parse the ENTIRE session file into normalized turns, oldest-first:
+// [{role, body, ts}]. Caps at maxTurns (keeping the newest). Returns [] on
+// any failure or when the file exceeds the slurp cap.
+const extractAllMessages = (filePath, maxTurns = 1000) => {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size === 0 || stat.size > FULL_READ_MAX_BYTES) return [];
+    const text = fs.readFileSync(filePath, 'utf8');
+    return extractRecentMessages(text, maxTurns);
+  } catch (_) {
+    return [];
+  }
+};
+
+module.exports = {
+  scanAll,
+  scanClaude,
+  scanCodex,
+  extractLastMessage,
+  decodeClaudeProjectDir,
+  findSessionFile,
+  extractAllMessages,
+};

package/src/history.js

@@ -0,0 +1,170 @@
+'use strict';
+
+// Phase 6.6 (daemon half) + Phase 5a.
+//
+// Two related capabilities, one module:
+//
+// 1. FULL-HISTORY BACKFILL (Phase 6.6). At adopt time the bridge only has the
+//    scanner's ~10 recent turns. When the daemon first drives an adopted
+//    thread it calls backfillFullHistory(), which reads the COMPLETE local
+//    session (Claude/Codex JSONL or OpenCode SQLite) and POSTs it to
+//    /api/bridge/external/backfill. The bridge swaps the partial for the full
+//    history with original timestamps. Fire-and-forget: a failed backfill
+//    never blocks the actual turn, and the route's hist:<sid>:<idx>
+//    clientMsgIds make retries idempotent.
+//
+// 2. HISTORY INJECTION (Phase 5a — provider switching, stage 1). When an
+//    engine FIRST touches a thread that already has bridge messages (the
+//    thread was switched from another provider, or adopted), the new engine
+//    knows nothing. buildHistoryBlock() pulls the thread's recent messages
+//    from the bridge and renders a bounded context block the drivers prepend
+//    to the engine's first prompt. This is the pre-Hindsight handoff: cheap,
+//    lossy beyond the caps, but immediately testable. Hindsight summarization
+//    can later replace the raw transcript with a distilled one without
+//    touching the drivers — only this function changes.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const bridgeHttp = require('./bridge-http');
+const { findSessionFile, extractAllMessages } = require('./external-scanner');
+const { fullMessagesFor } = require('./opencode-sqlite-scanner');
+
+// ── Full-history backfill ─────────────────────────────────────────────────
+
+const BACKFILL_MAX_TURNS = 1000;
+
+// Read the complete message history of a local session, normalized to
+// [{role:'user'|'assistant', body, ts}]. Returns [] when the session can't
+// be found or parsed — caller treats that as "nothing to backfill".
+const readFullSessionHistory = (source, sessionId) => {
+  try {
+    if (source === 'opencode') {
+      return fullMessagesFor(sessionId, BACKFILL_MAX_TURNS);
+    }
+    // claude + codex are both JSONL on disk.
+    const filePath = findSessionFile(source, sessionId);
+    if (!filePath) return [];
+    return extractAllMessages(filePath, BACKFILL_MAX_TURNS);
+  } catch (_) {
+    return [];
+  }
+};
+
+// Threads we've already backfilled this daemon lifetime. The server route is
+// idempotent anyway (clientMsgId dedupe), so this is purely a noise guard.
+const backfilledThreads = new Set();
+
+// Fire-and-forget. Reads the full session and ships it to the bridge.
+const backfillFullHistory = ({ threadId, externalAdoption, log }) => {
+  const ea = externalAdoption || {};
+  const sessionId = String(ea.sessionId || '').trim();
+  const source = String(ea.source || 'claude');
+  if (!threadId || !sessionId) return;
+  if (backfilledThreads.has(threadId)) return;
+  backfilledThreads.add(threadId);
+
+  // setImmediate keeps file IO + the POST entirely off the reply hot path.
+  setImmediate(async () => {
+    try {
+      const messages = readFullSessionHistory(source, sessionId);
+      // The adopt route already inserted ~10 turns; a full read that isn't
+      // meaningfully bigger adds nothing but churn.
+      if (!messages || messages.length === 0) {
+        log('info', 'history backfill: no local history found', { threadId, source, sessionId });
+        return;
+      }
+      const r = await bridgeHttp.postExternalBackfill(threadId, sessionId, messages);
+      if (r && r.ok) {
+        log('info', 'history backfill complete', {
+          threadId,
+          source,
+          sessionId,
+          sent: messages.length,
+          inserted: r.data && r.data.inserted,
+          deduped: r.data && r.data.deduped,
+          removedPartial: r.data && r.data.removedPartial,
+        });
+      } else {
+        backfilledThreads.delete(threadId); // retry on the next reply
+        log('warn', 'history backfill rejected', {
+          threadId,
+          status: r && r.status,
+          body: r && r.data,
+        });
+      }
+    } catch (e) {
+      backfilledThreads.delete(threadId);
+      log('warn', 'history backfill failed', {
+        threadId,
+        error: e && e.message ? e.message : String(e),
+      });
+    }
+  });
+};
+
+// ── Phase 5a — history injection on first touch ───────────────────────────
+
+const HISTORY_MAX_MESSAGES = 40;
+const HISTORY_MSG_CHARS = 3000;
+const HISTORY_TOTAL_CHARS = 24000;
+
+const trimBody = (s) => {
+  const t = String(s || '').trim();
+  return t.length > HISTORY_MSG_CHARS ? t.slice(0, HISTORY_MSG_CHARS) + ' …[truncated]' : t;
+};
+
+// Pull the newest messages on a bridge thread and render them as a bounded
+// context block for a first-touch prompt. Returns '' when the thread has no
+// prior conversation (brand-new thread — nothing to inject), so callers can
+// unconditionally prepend the result.
+//
+// currentMessageId: the reply that triggered this turn — excluded, since the
+// envelope already carries it.
+const buildHistoryBlock = async ({ threadId, currentMessageId, engineName, log }) => {
+  let rows = [];
+  try {
+    const r = await bridgeHttp.getMessagesBefore(threadId, new Date().toISOString(), HISTORY_MAX_MESSAGES);
+    if (r && r.ok && r.data && Array.isArray(r.data.messages)) {
+      rows = r.data.messages;
+    }
+  } catch (e) {
+    if (log) log('warn', 'history block fetch failed', {
+      threadId,
+      error: e && e.message ? e.message : String(e),
+    });
+    return '';
+  }
+
+  const lines = [];
+  let total = 0;
+  for (const m of rows) {
+    if (!m || !m.body) continue;
+    if (currentMessageId && m.messageId === currentMessageId) continue;
+    // Skip permission-relay questions — transient plumbing, not conversation.
+    if (m.author === 'claude-bridge-perm') continue;
+    const who = m.role === 'human' ? 'human' : (m.author || 'agent');
+    const body = trimBody(m.body);
+    const line = '[' + (m.createdAt || '?') + ' | ' + who + ']\n' + body;
+    if (total + line.length > HISTORY_TOTAL_CHARS) break;
+    total += line.length;
+    lines.push(line);
+  }
+  if (lines.length === 0) return '';
+
+  return (
+    '[OBTO Agent Bridge — prior conversation on this thread]\n' +
+    'This thread already has history: the human (and possibly other AI ' +
+    'engines) exchanged the messages below before you' +
+    (engineName ? ' (' + engineName + ')' : '') +
+    ' were brought in. Treat it as authoritative context — do not re-ask ' +
+    'for information it already contains. The newest message (your actual ' +
+    'task) follows after the block.\n\n' +
+    '--- thread history start ---\n' +
+    lines.join('\n\n') +
+    '\n--- thread history end ---\n\n'
+  );
+};
+
+module.exports = { backfillFullHistory, buildHistoryBlock, readFullSessionHistory };

package/src/opencode-driver.js

@@ -19,6 +19,9 @@
 const { loadConfig } = require('./config');
 const { buildEnvelope } = require('./claude-driver');
 const bridgeHttp = require('./bridge-http');
+// Phase 5a — opencode has no MCP thread_read; prior thread context arrives
+// via inline injection into the first prompt, same as the Codex driver.
+const { buildHistoryBlock } = require('./history');
 
 // Per-thread promise queue — concurrent replies on one thread are serialized
 // so first-touch completes before any resume. Mirrors codex-driver.
@@ -45,8 +48,8 @@ const attachmentDropNote = (payload) => {
     'image in words if you need its content.]\n\n';
 };
 
-const buildOpencodePrompt = (payload, isFirst) => {
-  const head = attachmentDropNote(payload) + buildEnvelope(payload);
+const buildOpencodePrompt = (payload, isFirst, historyBlock) => {
+  const head = (historyBlock || '') + attachmentDropNote(payload) + buildEnvelope(payload);
   if (!isFirst) return head;
   return head +
     '\n\n---\n' +
@@ -153,9 +156,22 @@ const driveTurn = async ({ threadId, projectDir, resumeId, payload, log }) => {
   let finalResponse = '';
   let failure = null;
 
+  // Phase 5a — on first touch of a thread with prior bridge history (provider
+  // switch or adopted thread), give opencode that history inline. Resumes
+  // don't need it: the engine session already holds its own context.
+  let historyBlock = '';
+  if (isFirst) {
+    historyBlock = await buildHistoryBlock({
+      threadId,
+      currentMessageId: payload.messageId,
+      engineName: 'opencode',
+      log,
+    });
+  }
+
   try {
     const res = await runOpencode({
-      prompt: buildOpencodePrompt(payload, isFirst),
+      prompt: buildOpencodePrompt(payload, isFirst, historyBlock),
       projectDir,
       resumeId,
     });

package/src/opencode-sqlite-scanner.js

@@ -0,0 +1,209 @@
+'use strict';
+
+// Phase 6.5 — surface OpenCode desktop/CLI conversations to the bridge.
+//
+// OpenCode stores sessions in SQLite at ~/.local/share/opencode/opencode.db
+// (shared between the CLI and the Electron desktop app). Schema (relevant
+// subset, captured 2026-06-07):
+//
+//   session(id, project_id, parent_id, directory, title, time_created,
+//           time_updated, agent, model, ...)
+//   message(id, session_id, time_created, data JSON)   -- data.role: user|assistant|...
+//   part(id, message_id, session_id, time_created, data JSON)   -- data.type: text|reasoning|step-start|...
+//   project(id, worktree, name, ...)
+//
+// We read via the `sqlite3` CLI subprocess (ships on macOS, standard on
+// Linux) rather than adding a native dependency (better-sqlite3) to the
+// daemon's install footprint. Opens in `-readonly` mode so live writes from
+// the desktop app are safe — SQLite WAL allows concurrent reads.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync, execFileSync } = require('child_process');
+
+const OPENCODE_DB = path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+
+// Match the limits the Claude/Codex scanners use so the bridge UI's
+// preview/title rendering looks consistent across sources.
+const SESSION_LIMIT = 500;
+const RECENT_TURN_COUNT = 10;
+const RECENT_MESSAGE_BODY_MAX = 4000;
+const PREVIEW_MAX_CHARS = 240;
+const QUERY_TIMEOUT_MS = 8000;
+
+let sqliteAvailableCached = null;
+const sqliteAvailable = () => {
+  if (sqliteAvailableCached !== null) return sqliteAvailableCached;
+  try {
+    const r = spawnSync('sqlite3', ['-version'], { encoding: 'utf8' });
+    sqliteAvailableCached = r.status === 0;
+  } catch (_) {
+    sqliteAvailableCached = false;
+  }
+  return sqliteAvailableCached;
+};
+
+const dbExists = () => {
+  try { return fs.existsSync(OPENCODE_DB); } catch (_) { return false; }
+};
+
+// Run a single SQL query against the OpenCode DB and parse `-json` output.
+// Returns [] on any failure (missing CLI, locked DB beyond timeout, bad SQL).
+// The daemon's external scan is fire-and-forget and runs every 30s, so we
+// MUST NOT throw out — at worst we miss this tick.
+const queryJson = (sql) => {
+  try {
+    const out = execFileSync('sqlite3', ['-readonly', '-json', OPENCODE_DB, sql], {
+      encoding: 'utf8',
+      timeout: QUERY_TIMEOUT_MS,
+      maxBuffer: 32 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (!out || !out.trim()) return [];
+    return JSON.parse(out);
+  } catch (_) {
+    return [];
+  }
+};
+
+// Take a string and slice/trim to PREVIEW_MAX_CHARS for the sidebar preview.
+const previewOf = (s) => {
+  const t = String(s || '').replace(/\s+/g, ' ').trim();
+  return t.length > PREVIEW_MAX_CHARS ? t.slice(0, PREVIEW_MAX_CHARS) : t;
+};
+
+// Trim a recentMessages body to the same RECENT_MESSAGE_BODY_MAX cap as the
+// other scanners so the bridge's per-row payload stays bounded.
+const bodyOf = (s) => {
+  const t = String(s || '');
+  return t.length > RECENT_MESSAGE_BODY_MAX ? t.slice(0, RECENT_MESSAGE_BODY_MAX) : t;
+};
+
+// Pull the last N text-bearing turns for one session. Skip control rows
+// (step-start, reasoning, tool-use) so the preview matches what the human
+// actually said and what the assistant actually replied.
+const recentMessagesFor = (sessionId) => {
+  const safeId = String(sessionId).replace(/'/g, "''");
+  // Last N text parts in order. We take 2*N from the tail then sort because
+  // SQLite's LIMIT is fastest with DESC + ascending re-sort in JS.
+  const rows = queryJson(
+    "SELECT p.time_created AS ts, " +
+    "json_extract(m.data, '$.role') AS role, " +
+    "json_extract(p.data, '$.text') AS text " +
+    "FROM part p JOIN message m ON p.message_id = m.id " +
+    "WHERE p.session_id = '" + safeId + "' " +
+    "AND json_extract(p.data, '$.type') = 'text' " +
+    "ORDER BY p.time_created DESC LIMIT " + (RECENT_TURN_COUNT * 2),
+  );
+  rows.reverse();
+  // Coalesce consecutive same-role rows (assistant turn can be split across
+  // parts) and tail to N.
+  const coalesced = [];
+  for (const r of rows) {
+    if (!r || !r.text) continue;
+    const role = r.role === 'user' ? 'user' : 'assistant';
+    const last = coalesced[coalesced.length - 1];
+    if (last && last.role === role) {
+      last.text += '\n\n' + r.text;
+      last.ts = r.ts;
+    } else {
+      coalesced.push({ role, text: r.text, ts: r.ts });
+    }
+  }
+  const sliced = coalesced.slice(-RECENT_TURN_COUNT);
+  return sliced.map((m) => ({ role: m.role, body: bodyOf(m.text), ts: m.ts }));
+};
+
+const lastMessageFor = (sessionId) => {
+  const safeId = String(sessionId).replace(/'/g, "''");
+  const rows = queryJson(
+    "SELECT json_extract(m.data, '$.role') AS role, json_extract(p.data, '$.text') AS text " +
+    "FROM part p JOIN message m ON p.message_id = m.id " +
+    "WHERE p.session_id = '" + safeId + "' " +
+    "AND json_extract(p.data, '$.type') = 'text' " +
+    "ORDER BY p.time_created DESC LIMIT 1",
+  );
+  if (!rows.length) return null;
+  const r = rows[0];
+  return {
+    author: r.role === 'user' ? 'user' : 'assistant',
+    preview: previewOf(r.text),
+  };
+};
+
+// Public API. Returns the same shape that postExternalSync expects (same as
+// claude/codex rows). Best-effort: returns [] if SQLite/DB unavailable.
+const scanAll = () => {
+  if (!dbExists() || !sqliteAvailable()) return [];
+
+  // Top-level sessions only — skip sub-sessions (parent_id non-null), they
+  // belong to a parent and showing them as standalone rows would clutter
+  // the sidebar with duplicate-looking conversations.
+  const sessions = queryJson(
+    "SELECT s.id AS sessionId, s.title, s.directory, " +
+    "s.time_created AS createdMs, s.time_updated AS updatedMs, " +
+    "s.agent, s.model, " +
+    "p.name AS projectName, p.worktree AS projectWorktree " +
+    "FROM session s LEFT JOIN project p ON s.project_id = p.id " +
+    "WHERE (s.parent_id IS NULL OR s.parent_id = '') " +
+    "ORDER BY s.time_updated DESC LIMIT " + SESSION_LIMIT,
+  );
+
+  const out = [];
+  for (const s of sessions) {
+    if (!s || !s.sessionId) continue;
+    const dir = s.directory || s.projectWorktree || '';
+    const recentMessages = recentMessagesFor(s.sessionId);
+    const lastMsg = lastMessageFor(s.sessionId);
+    out.push({
+      source: 'opencode',
+      sessionId: String(s.sessionId),
+      // The bridge's adoption path uses projectDir for resume cwd. OpenCode
+      // stores the absolute path in `directory` (or project.worktree as
+      // backup); pass it through as both projectDir and projectName so the
+      // daemon's "looksAbsolute" guard in daemon.js handleEvent accepts it.
+      projectDir: dir,
+      projectName: dir,
+      title: String(s.title || '').trim() || null,
+      recentMessages: recentMessages,
+      lastActivityAt: typeof s.updatedMs === 'number' ? s.updatedMs : Number(s.updatedMs) || 0,
+      lastMessagePreview: lastMsg ? lastMsg.preview : '',
+      lastMessageAuthor: lastMsg ? lastMsg.author : null,
+    });
+  }
+  return out;
+};
+
+// Phase 6.6 — full-history read for adoption backfill. Same shape as
+// recentMessagesFor but unbounded by RECENT_TURN_COUNT (capped at maxTurns,
+// keeping the newest). Returns [] when SQLite/DB unavailable.
+const fullMessagesFor = (sessionId, maxTurns = 1000) => {
+  if (!dbExists() || !sqliteAvailable()) return [];
+  const safeId = String(sessionId).replace(/'/g, "''");
+  const rows = queryJson(
+    "SELECT p.time_created AS ts, " +
+    "json_extract(m.data, '$.role') AS role, " +
+    "json_extract(p.data, '$.text') AS text " +
+    "FROM part p JOIN message m ON p.message_id = m.id " +
+    "WHERE p.session_id = '" + safeId + "' " +
+    "AND json_extract(p.data, '$.type') = 'text' " +
+    "ORDER BY p.time_created ASC LIMIT " + (Math.max(1, maxTurns) * 4),
+  );
+  const coalesced = [];
+  for (const r of rows) {
+    if (!r || !r.text) continue;
+    const role = r.role === 'user' ? 'user' : 'assistant';
+    const last = coalesced[coalesced.length - 1];
+    if (last && last.role === role) {
+      last.text += '\n\n' + r.text;
+      last.ts = r.ts;
+    } else {
+      coalesced.push({ role, text: r.text, ts: r.ts });
+    }
+  }
+  const sliced = coalesced.slice(-Math.max(1, maxTurns));
+  return sliced.map((m) => ({ role: m.role, body: bodyOf(m.text), ts: m.ts }));
+};
+
+module.exports = { scanAll, fullMessagesFor, OPENCODE_DB };