@neerajvipparla/agentbridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 neerajvipparla
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# agentbridge
+
+Phase 1 of a Claude Code ⇄ OpenCode context bridge: fork a chat session from
+one agent into the other, and record every fork as a commit in a local git
+ledger.
+
+```
+agentbridge list [-s claude|opencode] [--dir <path>] [--all]
+agentbridge show <session-id> [-s claude|opencode] [--dir <path>]
+agentbridge fork [session-id] [-s claude|opencode] [--dir <path>] [--dry-run]
+                 [--title <t>] [--provider <id>] [--agent <name>]
+agentbridge sync [session-id] [--dir <path>] [--strategy timestamp|abort]
+agentbridge watch [session-id] [--dir <path>] [--strategy timestamp|abort] [--interval <ms>]
+agentbridge log  [--dir <path>] [--limit <n>]
+```
+
+Typical flow:
+
+- `agentbridge list` (or `list -s opencode`) to see what's available.
+- `agentbridge show <id>` to read the full transcript.
+- `agentbridge fork <id>` to clone the session into the *other* tool.
+
+`--source` / `-s` selects the source tool:
+
+| Command | Default source | `-s opencode` |
+|---|---|---|
+| `list` | Claude Code sessions | OpenCode sessions |
+| `show` | auto-detect by id | OpenCode session |
+| `fork` | auto-detect by id (or latest Claude) | OpenCode → Claude Code |
+
+Auto-detection: ids starting with `ses_` are OpenCode; everything else is
+treated as a Claude Code session id.
+
+Run `agentbridge fork` with no arguments inside a project you've used `claude`
+in, and it will find the most recent Claude Code session, convert it into
+OpenCode's format, commit both representations to `.agentbridge/ledger/`, and
+run `opencode import` so the conversation shows up in OpenCode.
+
+Run `agentbridge fork <ses_...> -s opencode` to go the other way: it exports
+the OpenCode session, converts it back to a Claude Code JSONL transcript, and
+writes it to `~/.claude/projects/<encoded-dir>/<uuid>.jsonl` so `claude` can
+resume it.
+
+Re-running `fork` on an unchanged session is a no-op (same target id, no new
+ledger commit). If the source session has grown since the last fork, it
+updates the target in place and records a new commit containing only the diff.
+
+`--dry-run` converts and writes the ledger commit, but skips the final
+`opencode import` / Claude file write.
+
+## Bidirectional sync (`sync`)
+
+`agentbridge sync [session-id]` reconciles a conversation that has been edited
+in both tools since the last fork/sync.
+
+- It reads the current Claude transcript and the current OpenCode session.
+- It compares both to the last synced state stored in `.agentbridge/ledger/`.
+- It merges only the *new* turns into both tools.
+
+```bash
+agentbridge sync                          # latest session in the ledger
+agentbridge sync <claude-uuid>            # by Claude session id
+agentbridge sync <ses_...>                # by OpenCode session id
+agentbridge sync --strategy abort         # refuse if both sides changed
+agentbridge sync --strategy timestamp     # merge by timestamp (default)
+```
+
+Conflict strategies:
+
+- `timestamp` (default) — append new turns from both sides and sort by time.
+  This is the recommended default for conversations because turns are
+  append-only and chronological order is usually the right merge.
+- `abort` — stop and show how many new turns each side has, so you can resolve
+  manually. Use this when you want full control over the merge.
+
+`sync` also records a ledger commit, so you can roll back or inspect the diff.
+
+## Live sync (`watch`)
+
+`agentbridge watch [session-id]` monitors the Claude session file and polls
+OpenCode, automatically syncing when either side changes.
+
+```bash
+agentbridge watch                     # latest session in the ledger
+agentbridge watch <ses_...>           # watch a specific OpenCode session
+agentbridge watch --interval 1000     # poll OpenCode every 1 second
+agentbridge watch --strategy abort    # stop and warn on conflicts
+```
+
+Press **Ctrl-C** to stop. The default poll interval is 5 seconds.
+
+**Safety note:** `watch` uses the same merge strategy as `sync`. With the default
+`timestamp` strategy it will auto-merge both sides' new turns. If you prefer to
+review every conflict, use `--strategy abort`.
+
+## Install
+
+```
+npm install -g @neerajvipparla/agentbridge
+```
+
+The package is published under a scoped name (npm's automated policy flags
+`agentbridge` as too similar to an existing, unrelated `agent-bridge`
+package) but the command it installs is still plain `agentbridge`.
+
+Or run it once without installing:
+
+```
+npx -y @neerajvipparla/agentbridge list
+```
+
+Requires `git` and the `opencode` CLI on your `PATH`.
+
+### From source
+
+```
+git clone https://github.com/neerajvipparla/Agentbridge.git
+cd Agentbridge
+npm install
+npm link   # or: node bin/agentbridge.js ...
+```
+
+## How the conversion works
+
+Claude Code stores one JSONL file per session at
+`~/.claude/projects/<encoded-cwd>/<session-uuid>.jsonl`, where `<encoded-cwd>`
+is the absolute working directory with **every non-alphanumeric character**
+replaced by `-` (e.g. `/Users/me/.config/my_app` →
+`-Users-me--config-my-app`), not just the path separators.
+Each line is an entry with a `type` (`user`/`assistant`/...), a `message`
+object whose `content` is either a string or an array of blocks (`text`,
+`thinking`, `tool_use`, `tool_result`), and Claude's own `uuid`/`parentUuid`
+chain. `src/readers/claude-reader.js` finds and parses these files; `toConversation()`
+filters out subagent ("sidechain") and internal ("meta") entries so you get
+the same linear conversation you'd see in the Claude Code TUI.
+
+`src/converters/claude-to-opencode.js` turns Claude Code into OpenCode's import/export
+JSON shape; `src/converters/opencode-to-claude.js` runs the reverse direction. Both are built on the
+same import/export JSON contract that was reverse-engineered from
+`opencode@1.18.5` by round-tripping synthetic sessions through
+`opencode import ...` / `opencode export ...` and reading OpenCode's generated
+SDK types in `@opencode-ai/sdk/dist/gen/types.gen.d.ts`.
+
+Forward (`converter.js`) mapping:
+
+```
+Claude JSONL  →  OpenCode { info, messages:[{info, parts}] }
+```
+
+- Claude's `text` / `thinking` blocks → OpenCode `text` / `reasoning` parts.
+- Claude's `tool_use` blocks → OpenCode `tool` parts. The matching
+  `tool_result` (or the raw `toolUseResult` field on the following entry) is
+  folded into the tool part's `state` instead of being rendered as a separate
+  message. If no result is found, the part is marked `status: "pending"`.
+- Claude's synthetic "here's your tool result" user turn is *not* emitted as
+  its own OpenCode message (it would show up as an empty bubble); its content
+  is already captured in the tool part above.
+- Empty assistant turns (e.g. redacted thinking blocks that keep only a
+  `signature` and no text) are also skipped to avoid blank bubbles.
+
+Reverse (`opencode-to-claude.js`) mapping:
+
+```
+OpenCode { info, messages:[{info, parts}] }  →  Claude JSONL
+```
+
+- OpenCode `text` / `reasoning` parts → Claude `text` / `thinking` blocks.
+- OpenCode `tool` parts are expanded back into the two-entry structure Claude
+  Code uses: an assistant entry containing a `tool_use` block, followed by a
+  synthetic user entry containing the matching `tool_result` block plus a
+  `toolUseResult` fallback.
+- A **fresh, deterministic Claude session UUID** is generated from the
+  OpenCode session id rather than reusing the `ses_...` id (the formats are
+  intentionally different). Re-importing the same OpenCode session produces
+  the same Claude id, so reverse-forking is also idempotent.
+
+In both directions, IDs and timestamps are **derived deterministically** from
+the source tool's own ids/timestamps (sha256-based), not random. This is what
+makes re-forking idempotent. Override `--provider` / `--agent` on forward
+forks if your OpenCode config names them differently.
+
+## Known limitations
+
+- Parallel tool calls within a single assistant turn are matched to their
+  results positionally (FIFO) when Claude Code doesn't tag the result with a
+  `tool_use_id`. This is correct for the common one-tool-per-turn case;
+  heavily parallel tool use could mis-pair in rare cases.
+- File attachments, permission prompts, Claude Code slash commands, and
+  OpenCode-specific part types besides `text` / `reasoning` / `tool` aren't
+  converted yet.
+- One session at a time; no batch mode.
+- `sync` merges by timestamp; it does not yet de-duplicate semantically
+  identical turns added independently on both sides.
+- OpenCode's `export` command can be lossy while the OpenCode server is running
+  or when a session was imported and then continued. `agentbridge` now reads
+  OpenCode's SQLite database directly as a fallback, and `sync` rebuilds the
+  merged state from the ledger baseline so history is not silently dropped.
+  However, uncommitted/in-progress turns that OpenCode has not yet flushed to
+  disk cannot be synced until OpenCode persists them.
+
+## Phase 2: bidirectional sync (implemented)
+
+The `agentbridge sync` command implements steps 1-3:
+
+1. **Both directions get a converter.** Done: `converter.js` (Claude → OpenCode)
+   and `opencode-to-claude.js` (OpenCode → Claude). Both write through the
+   same ledger.
+2. **The ledger is the source of truth for "what did we last sync".**
+   `sync` reads the last ledger commit for the session pair, diffs it against
+   the current state of both tools, and only merges the new turns. The merged
+   state is always rebuilt from the ledger baseline so a partial OpenCode export
+   (e.g. while the server is running) cannot erase history.
+3. **Conflict handling:** `timestamp` (default) appends both sides' new turns
+   in chronological order; `abort` refuses and reports the conflict so you
+   can resolve manually.
+4. **Live sync:** `agentbridge watch` monitors the Claude JSONL file with
+   `fs.watch` and polls OpenCode's state, auto-syncing on change.
+5. **OpenCode export robustness:** `opencode-reader.js` falls back to reading
+   OpenCode's SQLite database directly when the CLI `export` is incomplete. The
+   fallback requires Node.js 22.5+ (`node:sqlite`).

package/bin/agentbridge.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  findLatestSession as findLatestClaudeSession,
+  findSessionById as findClaudeSessionById,
+  findProjectDir,
+  listSessions as listClaudeSessions,
+  listAllProjectDirs,
+  parseSessionFile,
+  toConversation,
+  summarizeSession as summarizeClaudeSession,
+  renderTranscript as renderClaudeTranscript,
+  claudeProjectsDir,
+  encodeProjectPath,
+} from "../src/readers/claude-reader.js";
+import {
+  findLatestSession as findLatestOpenCodeSession,
+  findSessionById as findOpenCodeSessionById,
+  listSessions as listOpenCodeSessions,
+  listSessionsForDir as listOpenCodeSessionsForDir,
+  summarizeSession as summarizeOpenCodeSession,
+  renderTranscript as renderOpenCodeTranscript,
+} from "../src/readers/opencode-reader.js";
+import { convertToOpenCode } from "../src/converters/claude-to-opencode.js";
+import { convertToClaude } from "../src/converters/opencode-to-claude.js";
+import { importIntoOpenCode } from "../src/writers/opencode-import.js";
+import { writeClaudeSession } from "../src/writers/claude-writer.js";
+import { ledgerPath, commitFork, log as ledgerLog } from "../src/ledger/git-ledger.js";
+import { syncSession, resolveSessionPair } from "../src/sync/sync.js";
+import { watchSession, waitForInterrupt } from "../src/sync/watch.js";
+
+const program = new Command();
+
+program
+  .name("agentbridge")
+  .description("Fork chat sessions between Claude Code and OpenCode, recorded as local git commits.")
+  .version("0.1.0");
+
+function resolveSource(sessionId, explicit) {
+  if (explicit) {
+    if (explicit !== "claude" && explicit !== "opencode") {
+      throw new Error(`Unknown source "${explicit}". Use "claude" or "opencode".`);
+    }
+    return explicit;
+  }
+  // Auto-detect: OpenCode session ids start with "ses_".
+  if (sessionId && sessionId.startsWith("ses_")) return "opencode";
+  return "claude";
+}
+
+function renderClaudeList(rows, showCwd) {
+  if (rows.length === 0) {
+    console.log("No non-empty sessions found.");
+    return;
+  }
+  for (const r of rows) {
+    const when = new Date(r.mtime).toLocaleString();
+    console.log(`${r.id}`);
+    console.log(`  ${when}  ·  ${r.messageCount} messages${showCwd ? `  ·  ${r.cwd}` : ""}`);
+    console.log(`  "${r.firstMessage}"`);
+    console.log("");
+  }
+}
+
+function renderOpenCodeList(rows) {
+  if (rows.length === 0) {
+    console.log("No OpenCode sessions found.");
+    return;
+  }
+  for (const r of rows) {
+    const when = new Date(r.updated).toLocaleString();
+    console.log(`${r.id}`);
+    console.log(`  ${when}  ·  ${r.messageCount} messages  ·  ${r.cwd}`);
+    console.log(`  "${r.firstMessage}"`);
+    console.log("");
+  }
+}
+
+program
+  .command("list")
+  .alias("ls")
+  .description("List sessions you can fork, newest first")
+  .option("-d, --dir <path>", "project directory (defaults to cwd for Claude; omitted = all for OpenCode)")
+  .option("-a, --all", "list sessions across every project Claude Code has seen, not just this one", false)
+  .option("-s, --source <tool>", 'source tool: "claude" or "opencode" (defaults to claude)')
+  .action((opts) => {
+    const source = opts.source || "claude";
+    if (source === "opencode") {
+      const sessions = opts.dir
+        ? listOpenCodeSessionsForDir(path.resolve(opts.dir))
+        : listOpenCodeSessions();
+      const rows = sessions
+        .map((s) => ({
+          ...s,
+          ...summarizeOpenCodeSession(s.session),
+        }))
+        .filter((r) => r.messageCount > 0);
+      renderOpenCodeList(rows);
+      console.log(`Preview one in full with:  agentbridge show <session-id> -s opencode`);
+      console.log(`Fork one to Claude Code with: agentbridge fork <session-id> -s opencode`);
+      return;
+    }
+
+    const searchDir = opts.dir ? path.resolve(opts.dir) : process.cwd();
+    const targets = opts.all
+      ? listAllProjectDirs()
+      : (() => {
+          const dir = findProjectDir(searchDir);
+          return dir ? [dir] : [];
+        })();
+
+    if (targets.length === 0) {
+      console.log(
+        opts.all
+          ? "No Claude Code sessions found anywhere under ~/.claude/projects."
+          : `No Claude Code sessions found for ${searchDir}. Try --all to search every project, or run \`claude\` here first.`
+      );
+      return;
+    }
+
+    const rows = [];
+    for (const dir of targets) {
+      for (const session of listClaudeSessions(dir)) {
+        const entries = parseSessionFile(session.file);
+        const summary = summarizeClaudeSession(entries);
+        if (summary.messageCount === 0) continue;
+        rows.push({ ...session, ...summary });
+      }
+    }
+    rows.sort((a, b) => b.mtime - a.mtime);
+
+    renderClaudeList(rows, opts.all);
+    console.log(`Preview one in full with:  agentbridge show <session-id>${opts.all ? " --all" : ""}`);
+    console.log(`Fork one to OpenCode with: agentbridge fork <session-id>`);
+  });
+
+program
+  .command("show")
+  .description("Print the full transcript of a session")
+  .argument("<session-id>", "session id")
+  .option("-d, --dir <path>", "project directory (defaults to cwd)", process.cwd())
+  .option("-a, --all", "search every project Claude Code has seen, not just --dir", false)
+  .option("-s, --source <tool>", 'source tool: "claude" or "opencode" (auto-detect)')
+  .action((sessionId, opts) => {
+    const source = resolveSource(sessionId, opts.source);
+    if (source === "opencode") {
+      const session = findOpenCodeSessionById(sessionId);
+      if (!session) {
+        console.error(`Could not find OpenCode session "${sessionId}".`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(renderOpenCodeTranscript(session.session));
+      return;
+    }
+
+    const dir = path.resolve(opts.dir);
+    const session = findClaudeSessionById(sessionId, dir);
+    if (!session) {
+      console.error(`Could not find Claude Code session "${sessionId}" (looked under ~/.claude/projects).`);
+      process.exitCode = 1;
+      return;
+    }
+    const entries = parseSessionFile(session.file);
+    console.log(renderClaudeTranscript(entries));
+  });
+
+program
+  .command("fork")
+  .description("Fork a session into the other tool and record it in the local git ledger")
+  .argument("[session-id]", "session id to fork (defaults to the most recent one)")
+  .option("-d, --dir <path>", "project directory (forward: source dir; reverse: target dir)", process.cwd())
+  .option("-s, --source <tool>", 'source tool: "claude" or "opencode" (auto-detect)')
+  .option("--title <title>", "title for the new OpenCode session (forward only)")
+  .option("--provider <providerID>", "OpenCode provider id to attribute assistant turns to (forward only)", "anthropic")
+  .option("--agent <agent>", "OpenCode agent name (forward only)", "build")
+  .option("--dry-run", "convert and write the ledger commit, but skip the final import/write", false)
+  .action((sessionId, opts) => {
+    const source = resolveSource(sessionId, opts.source);
+
+    if (source === "opencode") {
+      const session = sessionId ? findOpenCodeSessionById(sessionId) : findLatestOpenCodeSession();
+      if (!session) {
+        console.error(
+          sessionId
+            ? `Could not find OpenCode session "${sessionId}".`
+            : `No OpenCode sessions found. Have you run \`opencode\` yet?`
+        );
+        process.exitCode = 1;
+        return;
+      }
+
+      const dir = path.resolve(opts.dir || session.session.info?.directory || process.cwd());
+      const entries = convertToClaude(session.session, { directory: dir });
+      if (entries.length === 0) {
+        console.error(`Session ${session.id} has no user/assistant messages to fork.`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const ledgerDir = ledgerPath(dir);
+      const { hash, changed } = commitFork(ledgerDir, {
+        sessionId: session.id,
+        claudeSource: { data: entries },
+        opencodeSource: { data: session.session },
+        direction: "opencode -> claude-code",
+      });
+      console.log(
+        changed
+          ? `Ledger commit ${hash.slice(0, 10)} recorded at ${ledgerDir}`
+          : `No changes since last fork (ledger already at ${hash.slice(0, 10)})`
+      );
+
+      if (opts.dryRun) {
+        console.log(`Dry run: skipped writing Claude file. Claude session id: ${entries[0].sessionId}`);
+        return;
+      }
+
+      try {
+        const { filePath } = writeClaudeSession(entries, dir);
+        console.log(`Wrote Claude session to ${filePath}`);
+        console.log(`Resume it with: run \`claude\` in ${dir}`);
+      } catch (err) {
+        console.error(err.message);
+        process.exitCode = 1;
+      }
+      return;
+    }
+
+    const dir = path.resolve(opts.dir);
+    const session = sessionId ? findClaudeSessionById(sessionId, dir) : findLatestClaudeSession(dir);
+    if (!session) {
+      console.error(
+        sessionId
+          ? `Could not find Claude Code session "${sessionId}" (looked under ~/.claude/projects).`
+          : `No Claude Code sessions found for ${dir}. Have you run \`claude\` here yet?`
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const entries = toConversation(parseSessionFile(session.file));
+    if (entries.length === 0) {
+      console.error(`Session ${session.id} has no user/assistant messages to fork.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const title = opts.title ?? `Forked from Claude Code (${session.id.slice(0, 8)})`;
+    const converted = convertToOpenCode(entries, {
+      directory: dir,
+      title,
+      providerID: opts.provider,
+      agent: opts.agent,
+    });
+
+    const ledgerDir = ledgerPath(dir);
+    const { hash, changed } = commitFork(ledgerDir, {
+      sessionId: session.id,
+      claudeSource: { path: session.file },
+      opencodeSource: { data: converted },
+      direction: "claude-code -> opencode",
+    });
+    console.log(
+      changed
+        ? `Ledger commit ${hash.slice(0, 10)} recorded at ${ledgerDir}`
+        : `No changes since last fork (ledger already at ${hash.slice(0, 10)})`
+    );
+
+    if (opts.dryRun) {
+      console.log(`Dry run: skipped \`opencode import\`. Converted OpenCode session id: ${converted.info.id}`);
+      return;
+    }
+
+    try {
+      const out = importIntoOpenCode(converted, { cwd: dir });
+      console.log(out || `Imported into OpenCode as ${converted.info.id}`);
+      console.log(`Resume it with: opencode --session ${converted.info.id}`);
+    } catch (err) {
+      console.error(err.message);
+      process.exitCode = 1;
+    }
+  });
+
+program
+  .command("sync")
+  .description("Reconcile a conversation that has been edited in both tools")
+  .argument("[session-id]", "Claude or OpenCode session id (defaults to the most recently forked session in the ledger)")
+  .option("-d, --dir <path>", "project directory (defaults to cwd)", process.cwd())
+  .option("-s, --strategy <strategy>", 'merge strategy: "timestamp" (default) or "abort"', "timestamp")
+  .option("--provider <providerID>", "OpenCode provider id for new Claude turns", "anthropic")
+  .option("--agent <agent>", "OpenCode agent name for new Claude turns", "build")
+  .option("--dry-run", "compute the merge but skip writing files or importing", false)
+  .action((sessionId, opts) => {
+    const dir = path.resolve(opts.dir);
+    const ledgerDir = ledgerPath(dir);
+    if (!fs.existsSync(path.join(ledgerDir, ".git"))) {
+      console.error(`No ledger found at ${ledgerDir}. Run a fork first.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const mapping = resolveSessionPair(ledgerDir, sessionId, ledgerLog);
+    if (!mapping) {
+      console.error(
+        `No mapping found for "${sessionId || "the latest ledger commit"}" in the ledger. ` +
+          `You may need to run a fork first so the session pair is recorded.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const result = syncSession({
+      ledgerDir,
+      dir,
+      claudeId: mapping.claudeId,
+      opencodeId: mapping.opencodeId,
+      strategy: opts.strategy,
+      dryRun: opts.dryRun,
+      provider: opts.provider,
+      agent: opts.agent,
+    });
+
+    if (result.claudeNew !== undefined && result.opencodeNew !== undefined && (result.claudeNew > 0 || result.opencodeNew > 0)) {
+      console.log(`Syncing ${result.claudeNew} new Claude turns and ${result.opencodeNew} new OpenCode turns.`);
+    }
+    if (result.message) console.log(result.message);
+    if (result.error) console.error(result.error);
+    if (result.exitCode) process.exitCode = result.exitCode;
+  });
+
+program
+  .command("watch")
+  .description("Auto-sync a conversation when either tool changes (press Ctrl-C to stop)")
+  .argument("[session-id]", "Claude or OpenCode session id (defaults to the most recently forked session in the ledger)")
+  .option("-d, --dir <path>", "project directory (defaults to cwd)", process.cwd())
+  .option("-s, --strategy <strategy>", 'merge strategy: "timestamp" (default) or "abort"', "timestamp")
+  .option("-i, --interval <ms>", "OpenCode poll interval in milliseconds", "5000")
+  .option("--provider <providerID>", "OpenCode provider id for new Claude turns", "anthropic")
+  .option("--agent <agent>", "OpenCode agent name for new Claude turns", "build")
+  .action(async (sessionId, opts) => {
+    const dir = path.resolve(opts.dir);
+    const ledgerDir = ledgerPath(dir);
+    if (!fs.existsSync(path.join(ledgerDir, ".git"))) {
+      console.error(`No ledger found at ${ledgerDir}. Run a fork first.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const mapping = resolveSessionPair(ledgerDir, sessionId, ledgerLog);
+    if (!mapping) {
+      console.error(
+        `No mapping found for "${sessionId || "the latest ledger commit"}" in the ledger. ` +
+          `You may need to run a fork first so the session pair is recorded.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const { claudeId, opencodeId } = mapping;
+    const claudeProjectDir = path.join(claudeProjectsDir(), encodeProjectPath(dir));
+    const claudeFile = path.join(claudeProjectDir, `${claudeId}.jsonl`);
+    if (!fs.existsSync(claudeFile)) {
+      console.error(`Claude session file not found: ${claudeFile}`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const strategy = opts.strategy;
+    if (strategy !== "timestamp" && strategy !== "abort") {
+      console.error(`Unknown strategy "${strategy}". Use "timestamp" or "abort".`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const interval = Number(opts.interval);
+    if (!Number.isFinite(interval) || interval < 500) {
+      console.error("Interval must be at least 500 ms.");
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(`Watching ${claudeFile} and OpenCode session ${opencodeId} (poll every ${interval}ms). Press Ctrl-C to stop.`);
+    const handle = watchSession({
+      claudeFile,
+      claudeId,
+      opencodeId,
+      ledgerDir,
+      dir,
+      strategy,
+      interval,
+      provider: opts.provider,
+      agent: opts.agent,
+      onEvent: (type, message) => {
+        if (type === "error") console.error(message);
+        else console.log(message);
+      },
+    });
+
+    await waitForInterrupt();
+    handle.stop();
+  });
+
+program
+  .command("log")
+  .description("Show the fork history recorded in the local git ledger")
+  .option("-d, --dir <path>", "project directory (defaults to cwd)", process.cwd())
+  .option("-n, --limit <count>", "number of entries to show", "20")
+  .action((opts) => {
+    const dir = path.resolve(opts.dir);
+    const entries = ledgerLog(ledgerPath(dir), Number(opts.limit));
+    if (entries.length === 0) {
+      console.log("No forks recorded yet. Run `agentbridge fork` first.");
+      return;
+    }
+    for (const e of entries) {
+      console.log(`${e.hash.slice(0, 10)}  ${e.date}  ${e.message}`);
+    }
+  });
+
+program.parse();