@mmmjk/context-bridge 0.1.0

package/dist/src/session-index.js

@@ -0,0 +1,369 @@
+import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { CC_PROJECTS, encodeCwd } from "./adapters/claude-code/render.js";
+import { CODEX_HOME } from "./adapters/codex/paths.js";
+import { isAgentBridgeCc, isAgentBridgeCodex } from "./sync.js";
+export function listSessions(opts = {}) {
+    const harness = opts.harness ?? "claude-code";
+    const cutoff = Date.now() - (opts.days ?? 365) * 86400_000;
+    let out = [];
+    if (harness === "claude-code" || harness === "both")
+        out.push(...listClaudeCode(cutoff));
+    if (harness === "codex" || harness === "both")
+        out.push(...listCodex(cutoff));
+    const source = opts.source ?? "all";
+    if (source !== "all")
+        out = out.filter((s) => sourceMatches(s.source_harness, source));
+    out.sort((a, b) => Date.parse(b.mtime_iso) - Date.parse(a.mtime_iso));
+    return out.slice(0, opts.limit ?? 20);
+}
+export function findSession(sessionId) {
+    return listSessions({ harness: "both", include_translated: true, limit: Number.MAX_SAFE_INTEGER }).find((s) => s.session_id === sessionId) ?? null;
+}
+export function cleanGenerated(opts = {}) {
+    const removed = [];
+    const skipped = [];
+    for (const s of listSessions({ harness: "both", include_translated: true, limit: Number.MAX_SAFE_INTEGER })) {
+        if (!s.translated)
+            continue;
+        try {
+            if (!opts.dry_run)
+                unlinkSync(s.path);
+            removed.push(s.path);
+        }
+        catch {
+            skipped.push(s.path);
+        }
+    }
+    return { removed, skipped };
+}
+export function dedupeGenerated(opts = {}) {
+    const seen = new Map();
+    const removed = [];
+    const skipped = [];
+    for (const s of listSessions({ harness: "both", include_translated: true, limit: Number.MAX_SAFE_INTEGER })) {
+        if (!s.translated)
+            continue;
+        const key = `${s.harness}|${s.cwd}|${displayPrompt(s) ?? ""}`;
+        const prev = seen.get(key);
+        if (!prev) {
+            seen.set(key, s);
+            continue;
+        }
+        const loser = Date.parse(s.mtime_iso) >= Date.parse(prev.mtime_iso) ? prev : s;
+        if (loser === prev)
+            seen.set(key, s);
+        try {
+            if (!opts.dry_run)
+                unlinkSync(loser.path);
+            removed.push(loser.path);
+        }
+        catch {
+            skipped.push(loser.path);
+        }
+    }
+    return { removed, skipped };
+}
+function listClaudeCode(cutoffMs) {
+    const out = [];
+    if (!existsSync(CC_PROJECTS))
+        return out;
+    for (const projectDir of childDirs(CC_PROJECTS)) {
+        for (const file of childJsonl(projectDir)) {
+            const st = statSync(file);
+            if (st.mtimeMs < cutoffMs)
+                continue;
+            const rows = readRows(file);
+            const first = rows.find((r) => r.cwd) ?? rows.find((r) => r.sessionId) ?? rows[0] ?? {};
+            const sessionId = String(first.sessionId ?? path.basename(file, ".jsonl"));
+            const cwd = String(first.cwd ?? decodeCwd(path.basename(projectDir)));
+            const sourceHarness = bridgeSourceFromClaudeMeta(rows) ?? bridgeSourceFromTitle(rows) ?? null;
+            out.push({
+                harness: "claude-code",
+                session_id: sessionId,
+                path: file,
+                cwd,
+                source_harness: sourceHarness,
+                first_prompt: firstClaudeUserPrompt(rows),
+                display_prompt: firstMeaningfulClaudeUserPrompt(rows),
+                session_title: claudeSessionTitle(rows),
+                start_command: startCommand("claude-code", cwd),
+                resume_command: resumeCommand("claude-code", sessionId, cwd),
+                launch_context: claudeLaunchContext(rows),
+                size_bytes: st.size,
+                mtime_iso: new Date(st.mtimeMs).toISOString(),
+                translated: isAgentBridgeCc(file),
+            });
+        }
+    }
+    return out;
+}
+function listCodex(cutoffMs) {
+    const out = [];
+    const root = path.join(CODEX_HOME, "sessions");
+    for (const file of walkJsonl(root)) {
+        const st = statSync(file);
+        if (st.mtimeMs < cutoffMs || !path.basename(file).startsWith("rollout-"))
+            continue;
+        const rows = readRows(file);
+        const meta = rows.find((r) => r.type === "session_meta")?.payload;
+        const turn = rows.find((r) => r.type === "turn_context")?.payload;
+        const sessionId = String(meta?.id ?? codexIdFromFilename(file));
+        const cwd = String(meta?.cwd ?? turn?.cwd ?? homedir());
+        const rawTitle = readCodexThreadName(sessionId);
+        const sourceHarness = bridgeSourceFromTitleString(rawTitle) ?? bridgeSourceFromMeta(meta) ?? null;
+        const title = rawTitle ? stripBridgeTitlePrefix(rawTitle) : null;
+        out.push({
+            harness: "codex",
+            session_id: sessionId,
+            path: file,
+            cwd,
+            source_harness: sourceHarness,
+            first_prompt: firstCodexUserPrompt(rows),
+            display_prompt: firstMeaningfulCodexUserPrompt(rows),
+            session_title: title,
+            start_command: startCommand("codex", cwd),
+            resume_command: resumeCommand("codex", sessionId, cwd),
+            launch_context: codexLaunchContext(meta, turn),
+            size_bytes: st.size,
+            mtime_iso: new Date(st.mtimeMs).toISOString(),
+            translated: isAgentBridgeCodex(file),
+        });
+    }
+    return out;
+}
+export function displayPrompt(session) {
+    return meaningfulText(session.session_title) ?? session.display_prompt ?? meaningfulText(session.first_prompt);
+}
+function claudeSessionTitle(rows) {
+    const title = rows.find((row) => row.type === "custom-title" && typeof row.customTitle === "string")?.customTitle;
+    return typeof title === "string" && title.trim() ? stripBridgeTitlePrefix(title) : null;
+}
+function bridgeSourceFromTitle(rows) {
+    const title = rows.find((row) => row.type === "custom-title" && typeof row.customTitle === "string")?.customTitle;
+    return typeof title === "string" ? bridgeSourceFromTitleString(title) : null;
+}
+function bridgeSourceFromClaudeMeta(rows) {
+    const meta = rows.find((row) => row.type === "context-bridge-meta");
+    const source = meta?.source_harness ?? meta?.sourceHarness;
+    return source === "claude-code" || source === "codex" ? source : null;
+}
+function bridgeSourceFromTitleString(value) {
+    const match = value?.match(/^\[from (claude-code|codex)\]\s*/);
+    return match?.[1] ?? null;
+}
+function bridgeSourceFromMeta(meta) {
+    if (meta?.originator !== "context-bridge" && meta?.originator !== "agent-session-transfer")
+        return null;
+    const source = meta.source_harness ?? meta.sourceHarness;
+    return source === "claude-code" || source === "codex" ? source : null;
+}
+export function sourceDisplay(source) {
+    if (source === "claude-code")
+        return "claude";
+    if (source === "codex")
+        return "codex";
+    return "";
+}
+function sourceMatches(source, filter) {
+    if (filter === "native" || filter === "local")
+        return source == null;
+    if (filter === "claude" || filter === "claude-code")
+        return source === "claude-code";
+    if (filter === "codex")
+        return source === "codex";
+    return false;
+}
+function firstClaudeUserPrompt(rows) {
+    for (const row of rows) {
+        if (row.type !== "user")
+            continue;
+        const prompt = claudeUserPrompt(row);
+        if (prompt)
+            return prompt;
+    }
+    return null;
+}
+function firstMeaningfulClaudeUserPrompt(rows) {
+    for (const row of rows) {
+        if (row.type !== "user")
+            continue;
+        const prompt = claudeUserPrompt(row);
+        if (prompt && !isBootstrapPrompt(prompt))
+            return prompt;
+    }
+    return null;
+}
+function claudeUserPrompt(row) {
+    const msg = row.message;
+    if (typeof msg?.content === "string" && msg.content.trim())
+        return msg.content;
+    if (Array.isArray(msg?.content)) {
+        const text = msg.content.find((b) => typeof b === "object" && b && b.type === "text");
+        if (typeof text?.text === "string" && text.text.trim())
+            return text.text;
+    }
+    return null;
+}
+function claudeLaunchContext(rows) {
+    const first = rows.find((r) => r.cwd || r.entrypoint || r.version || r.userType) ?? {};
+    const model = rows.map((r) => r.message?.model).find((v) => typeof v === "string");
+    return compactObject({
+        executable: "claude",
+        entrypoint: first.entrypoint,
+        version: first.version,
+        user_type: first.userType,
+        model,
+        git_branch: first.gitBranch,
+        inferred: true,
+        note: "Session files do not preserve the exact original shell argv; commands are reconstructed from session metadata.",
+    });
+}
+function codexLaunchContext(meta, turn) {
+    const sandbox = turn?.sandbox_policy;
+    return compactObject({
+        executable: "codex",
+        originator: meta?.originator,
+        source: meta?.source,
+        cli_version: meta?.cli_version,
+        model_provider: meta?.model_provider,
+        model: turn?.model,
+        reasoning_effort: turn?.effort,
+        approval_policy: turn?.approval_policy,
+        sandbox: sandbox?.type,
+        timezone: turn?.timezone,
+        inferred: true,
+        note: "Session files do not preserve the exact original shell argv; commands are reconstructed from session metadata.",
+    });
+}
+export function startCommand(harness, cwd) {
+    const executable = harness === "codex" ? "codex" : "claude";
+    return `cd ${shellQuote(cwd)} && ${executable}`;
+}
+export function resumeCommand(harness, sessionId, cwd) {
+    const command = harness === "codex" ? `codex exec resume ${shellQuote(sessionId)} "<your prompt>"` : `claude --resume ${shellQuote(sessionId)} -p "<your prompt>"`;
+    return cwd ? `cd ${shellQuote(cwd)} && ${command}` : command;
+}
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value != null && value !== ""));
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function firstCodexUserPrompt(rows) {
+    for (const row of rows) {
+        const prompt = codexUserPrompt(row);
+        if (prompt)
+            return prompt;
+    }
+    return null;
+}
+function firstMeaningfulCodexUserPrompt(rows) {
+    for (const row of rows) {
+        const prompt = codexUserPrompt(row);
+        if (prompt && !isBootstrapPrompt(prompt))
+            return prompt;
+    }
+    return null;
+}
+function codexUserPrompt(row) {
+    const payload = row.payload;
+    if (row.type === "response_item" && payload?.type === "message" && payload.role === "user") {
+        const content = payload.content;
+        const text = content?.find((c) => c.type === "input_text");
+        if (typeof text?.text === "string" && text.text.trim())
+            return text.text;
+    }
+    return null;
+}
+function isBootstrapPrompt(value) {
+    const text = value.trim();
+    return text.startsWith("# AGENTS.md instructions for ") ||
+        text.startsWith("<INSTRUCTIONS>") ||
+        text.startsWith("<environment_context>") ||
+        text.startsWith("<permissions instructions>") ||
+        /^<(?:command-message|command-name|command-args)>[\s\S]*?<\/(?:command-message|command-name|command-args)>/.test(text) ||
+        /^<local-command-[a-z-]+>/.test(text);
+}
+function meaningfulText(value) {
+    if (!value)
+        return null;
+    return isBootstrapPrompt(value) ? null : value;
+}
+function readCodexThreadName(sessionId) {
+    const idx = path.join(CODEX_HOME, "session_index.jsonl");
+    if (!existsSync(idx))
+        return null;
+    let found = null;
+    for (const line of readFileSync(idx, "utf8").split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            const name = String(row.thread_name ?? "").trim();
+            if (row.id === sessionId && name)
+                found = name;
+        }
+        catch { }
+    }
+    return found;
+}
+function stripBridgeTitlePrefix(value) {
+    return value.replace(/^\[from [^\]]+\]\s*/, "").trim();
+}
+function childDirs(dir) {
+    try {
+        return readdirSync(dir).map((f) => path.join(dir, f)).filter((p) => statSync(p).isDirectory());
+    }
+    catch {
+        return [];
+    }
+}
+function childJsonl(dir) {
+    try {
+        return readdirSync(dir).map((f) => path.join(dir, f)).filter((p) => p.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+}
+function walkJsonl(dir) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const item of readdirSync(dir)) {
+        const full = path.join(dir, item);
+        const st = statSync(full);
+        if (st.isDirectory())
+            out.push(...walkJsonl(full));
+        else if (full.endsWith(".jsonl"))
+            out.push(full);
+    }
+    return out;
+}
+function readRows(file) {
+    try {
+        return readFileSync(file, "utf8").split(/\r?\n/).filter(Boolean).map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return {};
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function codexIdFromFilename(file) {
+    const name = path.basename(file, ".jsonl");
+    return name.replace(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-/, "");
+}
+function decodeCwd(encoded) {
+    return encoded.startsWith("-") ? encoded.replace(/-/g, "/") : encoded;
+}
+export function expectedClaudeCodePath(cwd, sessionId) {
+    return path.join(CC_PROJECTS, encodeCwd(cwd), `${sessionId}.jsonl`);
+}

package/dist/src/sync-state.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+import { homedir } from "node:os";
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { readJsonFile, writeJsonFile } from "./utils/jsonl.js";
+export let STATE_PATH = path.join(homedir(), ".cache", "context-bridge", "sync-state.json");
+export function setStatePath(p) { STATE_PATH = p; }
+export function isUnchanged(source, directionKey, fingerprint = "") {
+    const rec = readJsonFile(STATE_PATH, {})[`${directionKey}|${source}`];
+    if (!rec || !existsSync(source))
+        return false;
+    const st = statSync(source);
+    return st.size === rec.size && Math.abs(st.mtimeMs / 1000 - Number(rec.mtime ?? 0)) < 1 && (rec.fingerprint ?? "") === fingerprint;
+}
+export function targetChanged(source, directionKey, targetPath, targetFingerprint = "") {
+    const rec = readJsonFile(STATE_PATH, {})[`${directionKey}|${source}`];
+    if (!rec || !existsSync(targetPath))
+        return false;
+    return Boolean(rec.target_path) &&
+        rec.target_path === targetPath &&
+        Boolean(rec.target_fingerprint) &&
+        rec.target_fingerprint !== targetFingerprint;
+}
+export function markTranslated(source, directionKey, fingerprint = "", targetPath, targetFingerprint = "") {
+    if (!existsSync(source))
+        return;
+    const st = statSync(source);
+    const data = readJsonFile(STATE_PATH, {});
+    data[`${directionKey}|${source}`] = { size: st.size, mtime: st.mtimeMs / 1000, fingerprint, target_path: targetPath, target_fingerprint: targetFingerprint };
+    writeJsonFile(STATE_PATH, data);
+}
+export function clear() {
+    if (existsSync(STATE_PATH))
+        unlinkSync(STATE_PATH);
+}

package/dist/src/sync.js

@@ -0,0 +1,174 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { deterministicUuid4, deterministicUuid7 } from "./canonical/ids.js";
+import { translate } from "./translator.js";
+import { encodeCwd, setCcProjects, CC_PROJECTS } from "./adapters/claude-code/render.js";
+import { CODEX_HOME, codexPath, setCodexHome } from "./adapters/codex/paths.js";
+import * as syncState from "./sync-state.js";
+import * as pairMap from "./pair-map.js";
+import * as claudeCode from "./adapters/claude-code/index.js";
+import * as codex from "./adapters/codex/index.js";
+export function makeStats() {
+    return { translated: 0, skipped_existing: 0, skipped_active: 0, skipped_too_big: 0, skipped_empty: 0, skipped_conflict: 0, failed: 0, failures: [] };
+}
+export function syncOnce(opts = {}) {
+    const direction = opts.direction ?? "both";
+    const cutoff = Date.now() - (opts.days ?? 365) * 86400_000;
+    const stats = makeStats();
+    if (direction === "cc-to-codex" || direction === "both")
+        for (const p of listCcSessions(cutoff))
+            tryTranslateOne(p, "claude-code", "codex", opts.max_bytes ?? 100 * 1024 * 1024, stats, opts.force ?? false, opts.log ?? (() => { }));
+    if (direction === "codex-to-cc" || direction === "both")
+        for (const p of listCodexSessions(cutoff))
+            tryTranslateOne(p, "codex", "claude-code", opts.max_bytes ?? 100 * 1024 * 1024, stats, opts.force ?? false, opts.log ?? (() => { }));
+    return stats;
+}
+function tryTranslateOne(source, src, tgt, maxBytes, stats, force, log) {
+    try {
+        const st = statSync(source);
+        if (st.size > maxBytes) {
+            stats.skipped_too_big++;
+            return;
+        }
+        const [targetPath, targetId] = expectedTarget(source, src, tgt);
+        const key = `${src}-to-${tgt}`;
+        const fingerprint = fileFingerprint(source);
+        const targetFingerprint = existsSync(targetPath) ? fileFingerprint(targetPath) : "";
+        if (!force && existsSync(targetPath) && syncState.isUnchanged(source, key, fingerprint)) {
+            stats.skipped_existing++;
+            return;
+        }
+        if (!force && existsSync(targetPath) && syncState.targetChanged(source, key, targetPath, targetFingerprint)) {
+            stats.skipped_conflict++;
+            log(`! ${src}->${tgt}: target modified, skipped ${targetPath}`);
+            return;
+        }
+        const session = src === "claude-code" ? claudeCode.ingest(source) : codex.ingest(source);
+        if (!session.moments.length) {
+            stats.skipped_empty++;
+            if (existsSync(targetPath) && (tgt === "claude-code" ? isAgentBridgeCc(targetPath) : isAgentBridgeCodex(targetPath)))
+                unlinkSync(targetPath);
+            return;
+        }
+        translate({ source_path: source, source_harness: src, target_harness: tgt, session_id: targetId, target_dir: tgt === "claude-code" ? CC_PROJECTS : CODEX_HOME, title_prefix: tgt === "claude-code" ? `[from ${src}] ` : undefined });
+        if (src === "claude-code" && tgt === "codex")
+            pairMap.record({ cc_id: path.basename(source, ".jsonl"), codex_id: targetId });
+        if (src === "codex" && tgt === "claude-code")
+            pairMap.record({ cc_id: targetId, codex_id: codexSourceId(readHead(source), source) });
+        syncState.markTranslated(source, key, fingerprint, targetPath, fileFingerprint(targetPath));
+        stats.translated++;
+        log(`✓ ${src}->${tgt}: ${path.basename(source)} -> ${targetId}`);
+    }
+    catch (e) {
+        stats.failed++;
+        stats.failures.push([source, e instanceof Error ? e.message : String(e)]);
+    }
+}
+export function expectedTarget(source, src, tgt) {
+    const head = readHead(source);
+    if (src === "claude-code" && tgt === "codex") {
+        const started = firstTimestamp(head);
+        const id = deterministicUuid7(`cc:${path.basename(source, ".jsonl")}`, started);
+        return [codexPath(id, started), id];
+    }
+    if (src === "codex" && tgt === "claude-code") {
+        const cwd = firstCwdCodex(head) ?? homedir();
+        const id = deterministicUuid4(`codex:${codexSourceId(head, source)}`);
+        return [path.join(CC_PROJECTS, encodeCwd(cwd), `${id}.jsonl`), id];
+    }
+    throw new Error(`${src}->${tgt} not supported`);
+}
+function readHead(p) {
+    return readFileSync(p, "utf8").split(/\r?\n/).filter(Boolean).slice(0, 10).map((l) => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return {};
+    } });
+}
+function firstTimestamp(rows) {
+    return String(rows.find((r) => r.timestamp)?.timestamp ?? "2026-01-01T00:00:00.000Z");
+}
+function firstCwdCodex(rows) {
+    for (const r of rows)
+        if (r.type === "session_meta")
+            return String((r.payload?.cwd) ?? "");
+    return null;
+}
+function codexSourceId(rows, p) {
+    for (const r of rows)
+        if (r.type === "session_meta" && r.payload?.id)
+            return String(r.payload.id);
+    return path.basename(p, ".jsonl").split("-").slice(-5).join("-");
+}
+function listCcSessions(cutoffMs) {
+    const out = [];
+    if (!existsSync(CC_PROJECTS))
+        return out;
+    for (const proj of childDirs(CC_PROJECTS))
+        for (const full of childJsonl(proj)) {
+            if (statSync(full).mtimeMs >= cutoffMs && !isAgentBridgeCc(full))
+                out.push(full);
+        }
+    return out.sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+}
+function listCodexSessions(cutoffMs) {
+    const root = path.join(CODEX_HOME, "sessions");
+    const out = [];
+    walk(root, out);
+    return out.filter((p) => path.basename(p).startsWith("rollout-") && p.endsWith(".jsonl") && statSync(p).mtimeMs >= cutoffMs && !isAgentBridgeCodex(p));
+}
+function childDirs(dir) {
+    try {
+        return readdirSync(dir).map((f) => path.join(dir, f)).filter((p) => statSync(p).isDirectory());
+    }
+    catch {
+        return [];
+    }
+}
+function childJsonl(dir) {
+    try {
+        return readdirSync(dir).map((f) => path.join(dir, f)).filter((p) => p.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+}
+function walk(dir, out) {
+    if (!existsSync(dir))
+        return;
+    for (const item of readdirSync(dir)) {
+        const full = path.join(dir, item);
+        const st = statSync(full);
+        if (st.isDirectory())
+            walk(full, out);
+        else
+            out.push(full);
+    }
+}
+export function isAgentBridgeCc(p) {
+    try {
+        const head = readFileSync(p, "utf8").slice(0, 4096);
+        return head.includes('"type":"context-bridge-meta"') ||
+            head.includes('"type": "context-bridge-meta"') ||
+            head.includes("[from ");
+    }
+    catch {
+        return false;
+    }
+}
+export function isAgentBridgeCodex(p) {
+    try {
+        const first = JSON.parse(readFileSync(p, "utf8").split(/\r?\n/)[0]);
+        return first.type === "session_meta" && (first.payload?.originator === "context-bridge" || first.payload?.originator === "agent-session-transfer");
+    }
+    catch {
+        return false;
+    }
+}
+export { setCcProjects, setCodexHome };
+function fileFingerprint(source) {
+    return createHash("sha256").update(readFileSync(source)).digest("hex");
+}

package/dist/src/title-sync.js

@@ -0,0 +1,67 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { CODEX_HOME } from "./adapters/codex/paths.js";
+import { read as readPairMap } from "./pair-map.js";
+import { findSession } from "./session-index.js";
+export function syncTitles() {
+    let updated_codex = 0;
+    let updated_claude_code = 0;
+    const pairs = readPairMap();
+    for (const [ccId, codexId] of Object.entries(pairs.cc_to_codex)) {
+        const cc = findSession(ccId);
+        const codex = findSession(codexId);
+        if (!cc && !codex)
+            continue;
+        const ccTitle = cc ? readClaudeTitle(cc.path) ?? cc.session_title ?? cc.first_prompt : null;
+        const codexTitle = codex ? readCodexTitle(codexId) ?? codex.session_title ?? codex.first_prompt : null;
+        if (ccTitle && codex && codexTitle !== ccTitle) {
+            appendCodexTitle(codexId, ccTitle);
+            updated_codex++;
+        }
+        if (codexTitle && cc && ccTitle !== codexTitle && cc.translated) {
+            appendClaudeTitle(cc.path, ccId, codexTitle);
+            updated_claude_code++;
+        }
+    }
+    return { updated_codex, updated_claude_code };
+}
+function readClaudeTitle(file) {
+    try {
+        for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const row = JSON.parse(line);
+            if (row.type === "custom-title" && typeof row.customTitle === "string")
+                return row.customTitle.replace(/^\[from [^\]]+\]\s*/, "");
+            if (row.type !== "custom-title")
+                break;
+        }
+    }
+    catch { }
+    return null;
+}
+function appendClaudeTitle(file, sessionId, title) {
+    appendFileSync(file, JSON.stringify({ type: "custom-title", customTitle: title, sessionId }) + "\n", "utf8");
+}
+function readCodexTitle(id) {
+    const p = path.join(CODEX_HOME, "session_index.jsonl");
+    if (!existsSync(p))
+        return null;
+    let found = null;
+    for (const line of readFileSync(p, "utf8").split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            if (row.id === id && typeof row.thread_name === "string")
+                found = row.thread_name.replace(/^\[from [^\]]+\]\s*/, "");
+        }
+        catch { }
+    }
+    return found;
+}
+function appendCodexTitle(id, title) {
+    const p = path.join(CODEX_HOME, "session_index.jsonl");
+    mkdirSync(path.dirname(p), { recursive: true });
+    appendFileSync(p, JSON.stringify({ id, thread_name: title, updated_at: new Date().toISOString() }) + "\n", "utf8");
+}

package/dist/src/translator.js

@@ -0,0 +1,24 @@
+import * as claudeCode from "./adapters/claude-code/index.js";
+import * as codex from "./adapters/codex/index.js";
+export function translate(opts) {
+    if (opts.source_harness === "claude-code" && opts.target_harness === "codex") {
+        const session = claudeCode.ingest(opts.source_path, { follow_subagents: opts.follow_subagents });
+        return codex.render(session, { target_dir: opts.target_dir, session_id: opts.session_id });
+    }
+    if (opts.source_harness === "codex" && opts.target_harness === "claude-code") {
+        const session = codex.ingest(opts.source_path);
+        return claudeCode.render(session, { target_dir: opts.target_dir, session_id: opts.session_id, title_prefix: opts.title_prefix ?? `[from ${opts.source_harness}] ` });
+    }
+    throw new Error(`Direction not implemented: ${opts.source_harness} -> ${opts.target_harness}`);
+}
+export function copySession(opts) {
+    if (opts.source_harness === "claude-code" && opts.target_harness === "codex") {
+        const session = claudeCode.ingest(opts.source_path, { follow_subagents: opts.follow_subagents });
+        return codex.render(session, { target_dir: opts.target_dir, copy_mode: true });
+    }
+    if (opts.source_harness === "codex" && opts.target_harness === "claude-code") {
+        const session = codex.ingest(opts.source_path);
+        return claudeCode.render(session, { target_dir: opts.target_dir, copy_mode: true });
+    }
+    throw new Error(`Direction not implemented: ${opts.source_harness} -> ${opts.target_harness}`);
+}