@alsdd/t3-import 0.0.0-stage → 0.1.1-alsd.1

package/dist/target/sync.js

@@ -0,0 +1,879 @@
+import Database from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { sourceDriver } from "../core/providers.js";
+import { isTerminalTurn } from "../core/types.js";
+import { checkpointForThread, legacyTurnSemanticHash, parseCheckpoint, turnSemanticHash } from "../core/checkpoint.js";
+import { canonicalPath, deterministicUuid, isObject, sha256, stringValue } from "../core/util.js";
+import { safetyError, writeError } from "../core/errors.js";
+import { assertT3Closed, isV2Database, targetMigration, validateTargetDatabase } from "./schema.js";
+import { assertV2ThreadSettled, prepareV2Write, v2ProviderThreads, v2SourceConflict, v2Thread } from "./v2.js";
+import { threadWorkingDirectory } from "./destination.js";
+import { listImports, recordImports } from "./ledger.js";
+import { IMPORTER_VERSION, MAX_SAFE_IMPORT_EVENTS, acquireLock, compactThreadForImport, createBackup, event, materializeAssets, planThread, projectionBacklog, } from "./importer.js";
+export function targetId(paths) {
+    return sha256(canonicalPath(paths.dbPath));
+}
+export function readEvents(db, threadId) {
+    const rows = db.prepare(`
+    SELECT sequence, event_id eventId, event_type type, payload_json payload, metadata_json metadata
+    FROM orchestration_events WHERE aggregate_kind = 'thread' AND stream_id = ? ORDER BY sequence
+  `).all(threadId);
+    const parsed = rows.flatMap((row) => {
+        try {
+            const payload = JSON.parse(row.payload);
+            const metadata = JSON.parse(row.metadata);
+            return isObject(payload) && isObject(metadata) ? [{ ...row, payload, metadata }] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (!isV2Database(db))
+        return parsed;
+    // A migrated thread retains its original V1 event stream. T3's lazy V1
+    // transcript copies are the same history, not a second set of messages.
+    const turns = db.prepare("SELECT payload_json payload FROM orchestration_v2_projection_provider_turns WHERE provider_thread_id IN (SELECT provider_thread_id FROM orchestration_v2_projection_provider_threads WHERE thread_id=?)").all(threadId);
+    const nativeTurns = new Map(turns.map((row) => {
+        const turn = JSON.parse(row.payload);
+        const native = isObject(turn.nativeTurnRef) ? stringValue(turn.nativeTurnRef.nativeId) : undefined;
+        return [String(turn.id), native];
+    }));
+    const items = db.prepare("SELECT payload_json payload FROM orchestration_v2_projection_turn_items WHERE thread_id=? AND type IN ('user_message','assistant_message')").all(threadId);
+    const messageTurns = new Map(items.map((row) => {
+        const item = JSON.parse(row.payload);
+        return [String(item.messageId), nativeTurns.get(String(item.providerTurnId))];
+    }));
+    return parsed.flatMap((row) => {
+        if (row.eventId.startsWith("migration:v1:"))
+            return [];
+        if (row.type === "message.updated")
+            return [{ ...row, type: "thread.message-sent", payload: { ...row.payload, messageId: row.payload.id, turnId: messageTurns.get(String(row.payload.id)) ?? row.metadata.providerTurnId, streaming: false } }];
+        if (row.type === "provider-turn.updated") {
+            const nativeId = isObject(row.payload.nativeTurnRef) ? stringValue(row.payload.nativeTurnRef.nativeId) : undefined;
+            const status = row.payload.status === "completed" ? "ready" : row.payload.status === "failed" ? "error" : ["interrupted", "cancelled"].includes(String(row.payload.status)) ? "interrupted" : undefined;
+            return status && nativeId ? [{ ...row, type: "thread.session-set", metadata: { ...row.metadata, providerTurnId: nativeId, v2Native: true }, payload: { session: { status } } }] : [];
+        }
+        if (row.type === "thread.metadata-updated")
+            return [{ ...row, type: "thread.meta-updated", payload: { ...row.payload, threadId } }];
+        if (row.type === "turn-item.updated" && row.metadata.t3ImportTerminalStatus)
+            return [{ ...row, type: "thread.session-set", payload: { session: { status: row.metadata.t3ImportTerminalStatus === "completed" ? "ready" : row.metadata.t3ImportTerminalStatus === "failed" ? "error" : "interrupted" } } }];
+        if (row.type === "thread.created")
+            return [{ ...row, payload: { ...row.payload, threadId } }];
+        return [row];
+    });
+}
+export function createEvent(events) {
+    return events.find((row) => row.type === "thread.created");
+}
+export function currentTitle(db, threadId, events) {
+    if (isV2Database(db)) {
+        const title = stringValue(v2Thread(db, threadId)?.title);
+        if (title)
+            return title;
+    }
+    const table = db.prepare("SELECT 1 found FROM sqlite_master WHERE type='table' AND name='projection_threads'").get();
+    if (table) {
+        const row = db.prepare("SELECT title FROM projection_threads WHERE thread_id = ? AND deleted_at IS NULL").get(threadId);
+        if (row?.title)
+            return row.title;
+    }
+    for (const row of [...events].reverse()) {
+        if (row.type === "thread.meta-updated") {
+            const title = stringValue(row.payload.title);
+            if (title)
+                return title;
+        }
+    }
+    return stringValue(createEvent(events)?.payload.title) ?? "Imported conversation";
+}
+export function existingProvider(db, thread, record, events) {
+    const runtime = db.prepare(`
+    SELECT provider_name providerName, provider_instance_id instanceId, adapter_key adapterKey
+    FROM provider_session_runtime WHERE thread_id = ?
+  `).get(record.threadId);
+    const current = isV2Database(db) ? v2Thread(db, record.threadId) : undefined;
+    const createdSelection = current?.modelSelection ?? createEvent(events)?.payload.modelSelection;
+    const selection = isObject(createdSelection) ? createdSelection : {};
+    const options = Array.isArray(selection.options)
+        ? selection.options.filter((value) => isObject(value) && typeof value.id === "string" && (typeof value.value === "string" || typeof value.value === "boolean"))
+        : [];
+    const providerName = runtime?.providerName ?? sourceDriver(thread.source);
+    return {
+        providerName,
+        instanceId: stringValue(current?.providerInstanceId) ?? runtime?.instanceId ?? stringValue(selection.instanceId) ?? providerName,
+        adapterKey: runtime?.adapterKey ?? providerName,
+        model: stringValue(selection.model) ?? thread.model,
+        options,
+    };
+}
+function canonicalMarker(seed) {
+    return deterministicUuid(`t3-import:event:${seed}:thread.created`);
+}
+const NATIVE_CODEX_SEED_PREFIX = "t3-import:native-codex:";
+function nativeSeedPrefix(source) {
+    return source === "opencode" ? "t3-import:native-opencode:" : NATIVE_CODEX_SEED_PREFIX;
+}
+function nativeProviderRecord(db, paths, thread) {
+    const driver = sourceDriver(thread.source);
+    if (isV2Database(db)) {
+        const linked = v2ProviderThreads(db).filter((row) => row.driver === driver && isObject(row.nativeThreadRef) && row.nativeThreadRef.driver === driver && row.nativeThreadRef.strength === "strong"
+            && row.nativeThreadRef.nativeId === thread.sourceSessionId && typeof row.appThreadId === "string"
+            && !v2Thread(db, row.appThreadId)?.deletedAt);
+        const ids = [...new Set(linked.map((row) => String(row.appThreadId)))];
+        if (ids.length > 1)
+            throw safetyError("Multiple V2 threads refer to this source provider session. Resolve the ambiguous binding before synchronizing.");
+        const threadId = ids[0];
+        if (threadId) {
+            const events = readEvents(db, threadId);
+            const created = createEvent(events);
+            const projectId = stringValue(created?.payload.projectId);
+            if (created && projectId && canonicalPath(threadWorkingDirectory(db, threadId, "").cwd) === canonicalPath(thread.workspace)) {
+                return { targetId: targetId(paths), source: thread.source, sourceSessionId: thread.sourceSessionId,
+                    sourceKey: thread.sourceKey, sourceFingerprint: "", projectId, threadId,
+                    importedAt: stringValue(created.payload.createdAt) ?? thread.createdAt,
+                    importerVersion: "native-adoption", migration: targetMigration(db),
+                    firstSequence: created.sequence, lastSequence: events.at(-1)?.sequence ?? created.sequence,
+                    resumable: true, backupPath: "", warnings: [],
+                    identitySeed: `${nativeSeedPrefix(thread.source)}${thread.sourceSessionId}:${threadId}`,
+                    currentSourceKey: thread.sourceKey, sourceTitle: thread.title, isCanonical: true };
+            }
+            return undefined;
+        }
+    }
+    if (thread.source !== "codex")
+        return undefined;
+    const candidates = db.prepare(`
+    SELECT thread_id threadId, resume_cursor_json cursor, runtime_payload_json runtime, status
+    FROM provider_session_runtime
+    WHERE provider_name = 'codex' AND adapter_key = 'codex'
+  `).all();
+    const matches = candidates.filter((candidate) => {
+        if (candidate.threadId === thread.sourceSessionId || candidate.status !== "stopped")
+            return false;
+        try {
+            const cursor = candidate.cursor ? JSON.parse(candidate.cursor) : {};
+            return stringValue(cursor.threadId) === thread.sourceSessionId;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (matches.length !== 1)
+        return undefined;
+    const threadId = matches[0].threadId;
+    const events = readEvents(db, threadId);
+    const created = createEvent(events);
+    if (!created || events.some((row) => row.type === "thread.deleted"))
+        return undefined;
+    const projectId = stringValue(created.payload.projectId);
+    if (!projectId)
+        return undefined;
+    const project = db.prepare(`
+    SELECT payload_json payload FROM orchestration_events
+    WHERE aggregate_kind = 'project' AND stream_id = ? AND event_type = 'project.created'
+    ORDER BY sequence LIMIT 1
+  `).get(projectId);
+    if (!project)
+        return undefined;
+    try {
+        const root = stringValue(JSON.parse(project.payload).workspaceRoot);
+        const runtime = matches[0].runtime ? JSON.parse(matches[0].runtime) : undefined;
+        const cwd = isObject(runtime) ? stringValue(runtime.cwd) : undefined;
+        // Scratch threads run in a per-thread directory below the T3 project root.
+        // Accept only an exact recorded runtime cwd, never an ancestor/path guess.
+        if (!root || (canonicalPath(root) !== canonicalPath(thread.workspace)
+            && (!cwd || canonicalPath(cwd) !== canonicalPath(thread.workspace))))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const identitySeed = `${nativeSeedPrefix(thread.source)}${thread.sourceSessionId}:${threadId}`;
+    return {
+        targetId: targetId(paths), source: thread.source, sourceSessionId: thread.sourceSessionId,
+        sourceKey: thread.sourceKey, sourceFingerprint: "", projectId, threadId,
+        importedAt: stringValue(created.payload.createdAt) ?? thread.createdAt,
+        importerVersion: "native-adoption", migration: targetMigration(db),
+        firstSequence: created.sequence, lastSequence: events.at(-1)?.sequence ?? created.sequence,
+        resumable: true, backupPath: "", warnings: [], identitySeed,
+        currentSourceKey: thread.sourceKey,
+        sourceTitle: thread.title,
+        isCanonical: true,
+    };
+}
+export function validRecord(db, record) {
+    if (record.identitySeed.startsWith(nativeSeedPrefix(record.source))) {
+        if (isV2Database(db) && v2ProviderThreads(db, record.threadId).some((row) => row.driver === sourceDriver(record.source) && isObject(row.nativeThreadRef) && row.nativeThreadRef.driver === sourceDriver(record.source) && row.nativeThreadRef.strength === "strong" && row.nativeThreadRef.nativeId === record.sourceSessionId)) {
+            return Boolean(v2Thread(db, record.threadId)) && !v2Thread(db, record.threadId)?.deletedAt;
+        }
+        const runtime = db.prepare(`
+      SELECT resume_cursor_json cursor FROM provider_session_runtime
+      WHERE thread_id = ? AND provider_name = 'codex' AND adapter_key = 'codex'
+    `).get(record.threadId);
+        if (!runtime)
+            return false;
+        try {
+            const cursor = runtime.cursor ? JSON.parse(runtime.cursor) : {};
+            const events = readEvents(db, record.threadId);
+            return stringValue(cursor.threadId) === record.sourceSessionId
+                && Boolean(createEvent(events))
+                && !events.some((row) => row.type === "thread.deleted");
+        }
+        catch {
+            return false;
+        }
+    }
+    return Boolean(db.prepare(`
+    SELECT 1 found FROM orchestration_events
+    WHERE stream_id = ? AND event_type = 'thread.created' AND event_id = ? LIMIT 1
+  `).get(record.threadId, canonicalMarker(record.identitySeed)));
+}
+export function fallbackRecord(db, paths, thread) {
+    let threadId;
+    let seed = thread.sourceKey;
+    if (thread.source === "codex") {
+        threadId = thread.sourceSessionId;
+    }
+    else if (thread.source === "opencode") {
+        if (!isV2Database(db))
+            return undefined;
+        threadId = deterministicUuid(`t3-import:thread:${thread.sourceKey}`);
+    }
+    else {
+        if (isV2Database(db))
+            threadId = deterministicUuid(`t3-import:thread:${thread.sourceKey}`);
+        const candidates = db.prepare("SELECT thread_id threadId, resume_cursor_json cursor FROM provider_session_runtime WHERE provider_name = 'claudeAgent'").all();
+        for (const candidate of candidates) {
+            try {
+                const cursor = candidate.cursor ? JSON.parse(candidate.cursor) : {};
+                if (cursor.resume !== thread.sourceSessionId)
+                    continue;
+                threadId = candidate.threadId;
+                const leaf = stringValue(cursor.resumeSessionAt);
+                if (leaf)
+                    seed = `claude:${thread.sourceSessionId}:${leaf}`;
+                break;
+            }
+            catch { /* continue */ }
+        }
+    }
+    if (!threadId)
+        return undefined;
+    const events = readEvents(db, threadId);
+    // Early 0.1 builds used the bare Codex session ID as their deterministic
+    // event seed. Discovery now exposes `codex:<session-id>`, but the imported
+    // stream and provider thread ID remain the bare UUID. Accept both markers
+    // and retain the marker's original seed so checkpoint IDs can be rebuilt.
+    const seeds = thread.source === "codex"
+        ? [thread.sourceKey, thread.sourceSessionId]
+        : [seed];
+    const matched = seeds
+        .map((candidate) => ({ candidate, created: events.find((row) => row.eventId === canonicalMarker(candidate)) }))
+        .find((candidate) => candidate.created);
+    const created = matched?.created;
+    if (!created)
+        return thread.source !== "claude" ? nativeProviderRecord(db, paths, thread) : undefined;
+    seed = matched.candidate;
+    const projectId = stringValue(created.payload.projectId);
+    if (!projectId)
+        return undefined;
+    return {
+        targetId: targetId(paths), source: thread.source, sourceSessionId: thread.sourceSessionId,
+        sourceKey: seed, sourceFingerprint: "", projectId, threadId,
+        importedAt: stringValue(created.payload.createdAt) ?? thread.createdAt,
+        importerVersion: "legacy", migration: targetMigration(db),
+        firstSequence: created.sequence, lastSequence: events.at(-1)?.sequence ?? created.sequence,
+        resumable: true, backupPath: "", warnings: [], identitySeed: seed,
+        currentSourceKey: seed, sourceTitle: stringValue(created.payload.title) ?? thread.title,
+        isCanonical: true,
+    };
+}
+function replacementMetadataRecord(db, paths, thread) {
+    const rows = db.prepare(`
+    SELECT stream_id threadId, sequence, payload_json payload, metadata_json metadata
+    FROM orchestration_events
+    WHERE aggregate_kind = 'thread' AND event_type = 'thread.created'
+    ORDER BY sequence DESC
+  `).all();
+    for (const row of rows) {
+        try {
+            const payload = JSON.parse(row.payload);
+            const metadata = JSON.parse(row.metadata);
+            if (!isObject(payload) || !isObject(metadata) || !isObject(metadata.t3Import))
+                continue;
+            const marker = metadata.t3Import;
+            if (marker.canonical !== true || marker.source !== thread.source || marker.sourceSessionId !== thread.sourceSessionId)
+                continue;
+            const events = readEvents(db, row.threadId);
+            if (events.some((candidate) => candidate.type === "thread.deleted"))
+                continue;
+            const projectId = stringValue(payload.projectId);
+            const identitySeed = stringValue(marker.identitySeed);
+            const sourceKey = stringValue(marker.sourceKey) ?? thread.sourceKey;
+            if (!projectId || !identitySeed)
+                continue;
+            return {
+                targetId: targetId(paths), source: thread.source, sourceSessionId: thread.sourceSessionId,
+                sourceKey, sourceFingerprint: "", projectId, threadId: row.threadId,
+                importedAt: stringValue(payload.createdAt) ?? thread.createdAt, importerVersion: "metadata-recovered",
+                migration: targetMigration(db), firstSequence: row.sequence,
+                lastSequence: events.at(-1)?.sequence ?? row.sequence, resumable: marker.resumable !== false, backupPath: "",
+                warnings: [isV2Database(db) ? "Recovered canonical import identity from T3 event metadata." : "Recovered canonical replacement identity from T3 event metadata."], identitySeed,
+                currentSourceKey: sourceKey, sourceTitle: stringValue(payload.title) ?? thread.title,
+                isCanonical: true,
+            };
+        }
+        catch { /* continue */ }
+    }
+    return undefined;
+}
+export function findRecord(db, paths, thread) {
+    const candidates = listImports(targetId(paths), thread.source).filter((row) => row.sourceSessionId === thread.sourceSessionId);
+    const canonicalCandidates = candidates.filter((row) => row.isCanonical === true || (row.isCanonical === undefined && validRecord(db, row) && row.identitySeed === row.sourceKey));
+    const valid = canonicalCandidates.filter((row) => validRecord(db, row));
+    if (thread.source === "codex") {
+        const record = valid.find((row) => (row.sourceKey === thread.sourceKey || row.currentSourceKey === thread.sourceKey)) ?? replacementMetadataRecord(db, paths, thread) ?? fallbackRecord(db, paths, thread);
+        return { ...(record ? { record } : {}), stale: canonicalCandidates.length > 0 && valid.length === 0 };
+    }
+    const resumable = valid.find((row) => row.resumable);
+    const record = resumable ?? (valid.length === 1 ? valid[0] : undefined) ?? replacementMetadataRecord(db, paths, thread) ?? fallbackRecord(db, paths, thread);
+    return { ...(record ? { record } : {}), stale: canonicalCandidates.length > 0 && valid.length === 0 };
+}
+export function bootstrapCheckpoint(thread, record, events) {
+    const saved = [...events].reverse().find((row) => row.metadata.t3ImportCheckpoint);
+    const savedCheckpoint = saved ? parseCheckpoint(JSON.stringify(saved.metadata.t3ImportCheckpoint)) : undefined;
+    if (savedCheckpoint)
+        return { checkpoint: savedCheckpoint, lastSequence: saved.sequence };
+    const byId = new Map(events.map((row) => [row.eventId, row]));
+    const importedEvent = (...keys) => keys
+        .map((key) => byId.get(deterministicUuid(`t3-import:event:${record.identitySeed}:${key}`)))
+        .find((row) => row !== undefined);
+    const turns = [];
+    let lastSequence = record.firstSequence;
+    for (const [index, turn] of thread.turns.entries()) {
+        // The initial one-off Codex importer used longer event-key suffixes. Its
+        // payloads and provider IDs are canonical, so validate them identically
+        // while accepting either deterministic layout.
+        const user = importedEvent(`turn.${index}.user`, `turn.${index}.user-message`);
+        const start = importedEvent(`turn.${index}.start`, `turn.${index}.start-requested`);
+        const running = importedEvent(`turn.${index}.running`, `turn.${index}.session-running`);
+        const settled = importedEvent(`turn.${index}.settled`, `turn.${index}.session-ready`);
+        if (!user || !start || !running || !settled)
+            break;
+        if (stringValue(user.payload.text) !== turn.user.text || stringValue(running.metadata.providerTurnId) !== turn.id)
+            return undefined;
+        // New imports settle before their messages for per-projector bootstrap;
+        // older imports settled last. The next user message bounds either layout.
+        const nextUser = events.find((row) => row.sequence > user.sequence && row.type === "thread.message-sent" && row.payload.role === "user");
+        const turnEvents = events.filter((row) => row.sequence >= user.sequence && row.sequence < (nextUser?.sequence ?? Infinity));
+        const assistant = turnEvents
+            .filter((row) => row.type === "thread.message-sent" && row.payload.role === "assistant")
+            .map((row) => stringValue(row.payload.text) ?? "");
+        if (assistant.join("\n\u0000\n") !== turn.assistant.map((message) => message.text).join("\n\u0000\n"))
+            return undefined;
+        const status = terminalStatusFromEvent(settled);
+        if (!status || status !== turn.status)
+            return undefined;
+        turns.push({ id: turn.id, status, ...(turn.terminalReason ? { terminalReason: turn.terminalReason } : {}), ...(turn.terminalError ? { terminalError: turn.terminalError } : {}), hash: turnSemanticHash(turn) });
+        lastSequence = Math.max(lastSequence, settled.sequence, ...turnEvents.map((row) => row.sequence));
+    }
+    return turns.length > 0 ? { checkpoint: { version: 2, turns }, lastSequence } : undefined;
+}
+function verifiedSourcePrefixLength(thread, checkpoint) {
+    if (checkpoint.version === 1) {
+        let sourceIndex = 0;
+        for (const saved of checkpoint.turns) {
+            while (thread.turns[sourceIndex] && thread.turns[sourceIndex].status !== "completed")
+                sourceIndex += 1;
+            const current = thread.turns[sourceIndex];
+            if (!current || current.id !== saved.id || legacyTurnSemanticHash(current) !== saved.hash)
+                return undefined;
+            sourceIndex += 1;
+        }
+        return sourceIndex;
+    }
+    if (thread.turns.length < checkpoint.turns.length)
+        return undefined;
+    const valid = checkpoint.turns.every((saved, index) => {
+        const current = thread.turns[index];
+        return Boolean(current && current.id === saved.id && current.status === saved.status && current.terminalReason === saved.terminalReason && current.terminalError === saved.terminalError && turnSemanticHash(current) === saved.hash);
+    });
+    return valid ? checkpoint.turns.length : undefined;
+}
+function terminalStatusFromEvent(row) {
+    if (!row || row.type !== "thread.session-set" || !isObject(row.payload.session))
+        return undefined;
+    switch (stringValue(row.payload.session.status)) {
+        case "ready":
+        case "idle": return "completed";
+        case "interrupted":
+        case "stopped": return "interrupted";
+        case "error": return "failed";
+        default: return undefined;
+    }
+}
+function settledProviderTurns(events, afterSequence) {
+    return events.flatMap((row) => {
+        if (row.sequence <= afterSequence)
+            return [];
+        const id = stringValue(row.metadata.providerTurnId);
+        const status = terminalStatusFromEvent(row);
+        return id && status ? [{ id, status }] : [];
+    });
+}
+function codexAdoptedTurns(thread, start, events, afterSequence) {
+    const settled = settledProviderTurns(events, afterSequence);
+    const byId = new Map(settled.map((entry) => [entry.id, entry.status]));
+    let adopted = 0;
+    while (thread.turns[start + adopted] && byId.has(thread.turns[start + adopted].id)) {
+        const turn = thread.turns[start + adopted];
+        if (byId.get(turn.id) !== turn.status)
+            return -1;
+        adopted += 1;
+    }
+    if (thread.turns.slice(start + adopted + 1).some((turn) => byId.has(turn.id)))
+        return -1;
+    return adopted;
+}
+function sourceAttachments(turn) {
+    return turn.user.attachments.map((attachment) => ({ name: attachment.name, mimeType: attachment.mimeType, sizeBytes: attachment.sizeBytes }));
+}
+function eventAttachments(row) {
+    if (!row)
+        return undefined;
+    if (!Array.isArray(row.payload.attachments))
+        return [];
+    const attachments = row.payload.attachments.flatMap((value) => {
+        if (!isObject(value))
+            return [];
+        const name = stringValue(value.name);
+        const mimeType = stringValue(value.mimeType);
+        const sizeBytes = typeof value.sizeBytes === "number" ? value.sizeBytes : undefined;
+        return name && mimeType && sizeBytes !== undefined ? [{ name, mimeType, sizeBytes }] : [];
+    });
+    return attachments.length === row.payload.attachments.length ? attachments : undefined;
+}
+function nativeCodexPrefixLength(thread, events) {
+    const v2Terminal = new Map(events.filter((row) => row.metadata.v2Native === true).map((row) => [stringValue(row.metadata.providerTurnId), terminalStatusFromEvent(row)]));
+    const turns = [];
+    const messages = new Map();
+    let active;
+    for (const row of events) {
+        if (row.type === "thread.message-sent") {
+            const role = stringValue(row.payload.role);
+            if (role === "user") {
+                if (active)
+                    turns.push(active);
+                active = { user: row, assistant: [] };
+            }
+            else if (role === "assistant") {
+                if (!active)
+                    return undefined;
+                // Match T3's message projector: streaming events append deltas;
+                // a non-empty final event replaces the accumulated text, while an
+                // empty final event retains it.
+                const messageId = stringValue(row.payload.messageId);
+                const providerTurnId = stringValue(row.payload.turnId) ?? stringValue(row.metadata.providerTurnId);
+                if (providerTurnId) {
+                    if (active.providerTurnId && active.providerTurnId !== providerTurnId)
+                        return undefined;
+                    active.providerTurnId = providerTurnId;
+                }
+                const existingIndex = messageId
+                    ? active.assistant.findIndex((message) => stringValue(message.payload.messageId) === messageId)
+                    : -1;
+                const previous = messageId ? messages.get(messageId) : undefined;
+                const text = stringValue(row.payload.text) ?? "";
+                const previousText = stringValue(previous?.payload.text) ?? "";
+                const merged = {
+                    ...row,
+                    payload: { ...row.payload, text: row.payload.streaming === true ? previousText + text : text || previousText },
+                };
+                // One assistant message can span multiple steered user inputs.
+                // All those turn fragments share the same accumulated snapshot.
+                if (previous)
+                    Object.assign(previous, merged);
+                const snapshot = previous ?? merged;
+                if (messageId)
+                    messages.set(messageId, snapshot);
+                if (existingIndex >= 0)
+                    active.assistant[existingIndex] = snapshot;
+                else
+                    active.assistant.push(snapshot);
+            }
+        }
+        else if (row.type === "thread.session-set" && active?.assistant.length && !active.status) {
+            const status = terminalStatusFromEvent(row);
+            if (status)
+                active.status = status;
+        }
+    }
+    if (active)
+        turns.push(active);
+    if (turns.length === 0)
+        return undefined;
+    // T3 stores each steered input as a user message. Codex stores all inputs
+    // handled by one provider turn together. Merge only with an explicit shared
+    // provider turn ID, allowing a user-only fragment between matching IDs.
+    const grouped = [];
+    for (const [index, turn] of turns.entries()) {
+        const previous = grouped.at(-1);
+        const bridge = !turn.providerTurnId && !turn.status && turn.assistant.length === 0
+            && previous?.providerTurnId === turns[index + 1]?.providerTurnId;
+        if (previous?.providerTurnId && !previous.status
+            && (previous.providerTurnId === turn.providerTurnId || bridge)) {
+            const previousAttachments = eventAttachments(previous.user);
+            const nextAttachments = eventAttachments(turn.user);
+            if (!previousAttachments || !nextAttachments)
+                return undefined;
+            previous.user = {
+                ...previous.user,
+                payload: {
+                    ...previous.user.payload,
+                    text: `${stringValue(previous.user.payload.text) ?? ""}\n\n${stringValue(turn.user.payload.text) ?? ""}`,
+                    attachments: [...previousAttachments, ...nextAttachments],
+                },
+            };
+            previous.assistant = [...new Set([...previous.assistant, ...turn.assistant])];
+            if (turn.status)
+                previous.status = turn.status;
+        }
+        else
+            grouped.push(turn);
+    }
+    if (grouped.length > thread.turns.length)
+        return undefined;
+    for (const [index, native] of grouped.entries()) {
+        const v2Status = native.providerTurnId ? v2Terminal.get(native.providerTurnId) : undefined;
+        if (v2Status)
+            native.status = v2Status;
+        const source = thread.turns[index];
+        const nativeUser = stringValue(native.user.payload.text);
+        const sourceUser = source?.user.text ?? "";
+        // A resumed Codex rollout may start with a context envelope before the
+        // original T3 prompt. Accept that only when the visible prompt is its exact
+        // final segment; all later turns must match byte-for-byte.
+        const userMatches = sourceUser === nativeUser
+            || (thread.source === "codex" && index === 0 && sourceUser.endsWith(`\n\n${nativeUser}`));
+        const actualAttachments = eventAttachments(native.user);
+        const expectedAttachments = source ? sourceAttachments(source) : [];
+        const actualAssistant = native.assistant.map((row) => stringValue(row.payload.text) ?? "");
+        const expectedAssistant = source?.assistant.map((message) => message.text) ?? [];
+        if (!source || (native.providerTurnId && native.providerTurnId !== source.id) || !userMatches || actualAttachments === undefined
+            || JSON.stringify(actualAttachments) !== JSON.stringify(expectedAttachments)
+            || JSON.stringify(actualAssistant) !== JSON.stringify(expectedAssistant)
+            || native.status !== source.status)
+            return undefined;
+    }
+    return grouped.length;
+}
+function nativeCodexAdoptedTurns(thread, start, events, afterSequence) {
+    const suffix = events.filter((row) => row.sequence > afterSequence);
+    if (!suffix.some((row) => row.type === "thread.message-sent"
+        && (row.payload.role === "user" || row.payload.role === "assistant")))
+        return 0;
+    return nativeCodexPrefixLength({ ...thread, turns: thread.turns.slice(start) }, suffix) ?? -1;
+}
+function claudeAdoptedTurns(thread, start, events, afterSequence) {
+    const messages = events.filter((row) => row.sequence > afterSequence && row.type === "thread.message-sent" && (row.payload.role === "user" || row.payload.role === "assistant"));
+    let cursor = 0;
+    let adopted = 0;
+    const settled = settledProviderTurns(events, afterSequence);
+    for (const turn of thread.turns.slice(start)) {
+        const expected = [{ role: "user", text: turn.user.text }, ...turn.assistant.map((message) => ({ role: "assistant", text: message.text }))];
+        const rows = messages.slice(cursor, cursor + expected.length);
+        if (rows.length === 0)
+            break;
+        const actual = rows.map((row) => ({ role: row.payload.role, text: stringValue(row.payload.text) ?? "" }));
+        const attachments = eventAttachments(rows[0]);
+        if (JSON.stringify(actual) !== JSON.stringify(expected) || attachments === undefined || JSON.stringify(attachments) !== JSON.stringify(sourceAttachments(turn)))
+            return -1;
+        if (!settled[adopted] || settled[adopted].status !== turn.status)
+            return -1;
+        cursor += expected.length;
+        adopted += 1;
+    }
+    return cursor === messages.length ? adopted : -1;
+}
+function conflictResult(thread, status, warning, record) {
+    return {
+        source: thread.source, sourceId: thread.sourceSessionId, sourceKey: thread.sourceKey,
+        status, ...(record ? { threadId: record.threadId, projectId: record.projectId } : {}),
+        title: thread.title, turnsAdded: 0, turnsAdopted: 0, events: 0, attachments: 0,
+        titleAction: "unchanged", resumable: Boolean(record?.resumable), warnings: [warning],
+    };
+}
+function buildPlan(db, paths, conversation, dryRun) {
+    const sourceThread = conversation.threads.find((thread) => thread.currentBranch) ?? conversation.threads[0];
+    if (!sourceThread)
+        throw writeError(`Conversation ${conversation.summary.id} has no importable task.`);
+    const thread = compactThreadForImport({ ...sourceThread, turns: sourceThread.turns.filter(isTerminalTurn) });
+    if (thread.turns.length === 0 && (thread.ignoredInProgressTurns ?? 0) > 0) {
+        const result = conflictResult(thread, "not-imported", "Conversation has no terminal turns; its active turn was ignored.");
+        return { conversation, thread, result, titleEvent: false, previouslyImported: false };
+    }
+    const match = findRecord(db, paths, thread);
+    if (!match.record) {
+        const result = conflictResult(thread, "not-imported", match.stale ? "The ledger entry is stale because its T3 task is missing." : "Conversation has not been imported into this T3 database.");
+        return { conversation, thread, result, titleEvent: false, previouslyImported: match.stale };
+    }
+    const record = match.record;
+    if (isV2Database(db)) {
+        assertV2ThreadSettled(db, record.threadId);
+        const current = v2Thread(db, record.threadId);
+        if (current?.deletedAt)
+            return { conversation, thread, record, result: conflictResult(thread, "target-missing", "The V2 thread is deleted.", record), titleEvent: false, previouslyImported: true };
+        const conflict = v2SourceConflict(db, record.threadId, thread);
+        if (conflict)
+            return { conversation, thread, record, result: conflictResult(thread, "history-diverged", conflict, record), titleEvent: false, previouslyImported: true };
+    }
+    const events = readEvents(db, record.threadId);
+    if (!createEvent(events))
+        return { conversation, thread, record, result: conflictResult(thread, "target-missing", "The imported T3 task no longer exists.", record), titleEvent: false, previouslyImported: true };
+    if (thread.source === "claude" && conversation.summary.branches !== 1) {
+        return { conversation, thread, record, result: conflictResult(thread, "branch-sync-unsupported", "Claude synchronization currently requires exactly one non-sidechain leaf.", record), titleEvent: false, previouslyImported: true };
+    }
+    const nativeAdoption = record.identitySeed.startsWith(nativeSeedPrefix(record.source));
+    const bootstrapped = record.checkpoint ? undefined : bootstrapCheckpoint(thread, record, events);
+    const checkpoint = record.checkpoint ?? bootstrapped?.checkpoint;
+    const sourcePrefixLength = checkpoint
+        ? verifiedSourcePrefixLength(thread, checkpoint)
+        : nativeAdoption ? nativeCodexPrefixLength(thread, events) : undefined;
+    if (sourcePrefixLength === undefined || (!checkpoint && !nativeAdoption)) {
+        return { conversation, thread, record, result: conflictResult(thread, "history-diverged", "Previously imported history is no longer an unchanged source prefix.", record), titleEvent: false, previouslyImported: true };
+    }
+    const adopted = nativeAdoption
+        ? checkpoint ? nativeCodexAdoptedTurns(thread, sourcePrefixLength, events, record.lastSequence) : 0
+        : thread.source !== "claude"
+            ? isV2Database(db) ? nativeCodexAdoptedTurns(thread, sourcePrefixLength, events, bootstrapped?.lastSequence ?? record.lastSequence) : codexAdoptedTurns(thread, sourcePrefixLength, events, bootstrapped?.lastSequence ?? record.lastSequence)
+            : claudeAdoptedTurns(thread, sourcePrefixLength, events, bootstrapped?.lastSequence ?? record.lastSequence);
+    if (adopted < 0)
+        return { conversation, thread, record, result: conflictResult(thread, "history-diverged", "T3 contains an ambiguous or partial provider turn suffix.", record), titleEvent: false, previouslyImported: true };
+    const newTurns = thread.turns.slice(sourcePrefixLength + adopted);
+    const t3Title = currentTitle(db, record.threadId, events);
+    const baselineTitle = record.sourceTitle || stringValue(createEvent(events)?.payload.title) || thread.title;
+    let titleAction = "unchanged";
+    const warnings = [...thread.warnings];
+    if (thread.title !== baselineTitle) {
+        if (t3Title === baselineTitle)
+            titleAction = "updated";
+        else if (t3Title !== thread.title) {
+            titleAction = "preserved-local";
+            warnings.push(`Preserved locally edited T3 title '${t3Title}' instead of provider title '${thread.title}'.`);
+        }
+    }
+    const provider = existingProvider(db, thread, record, events);
+    const syncThread = { ...thread, turns: newTurns, warnings };
+    const turnOffset = nativeAdoption ? sourcePrefixLength : (checkpoint?.turns.length ?? sourcePrefixLength) + adopted;
+    const planned = planThread(syncThread, record.threadId, record.projectId, paths, provider, record.identitySeed, undefined, record.resumable && Boolean(thread.resumeCursor), conversation.fingerprint, turnOffset, false);
+    planned.checkpoint = checkpointForThread(thread);
+    if (nativeAdoption)
+        markAsHistoricalTranscript(planned);
+    if (titleAction === "updated") {
+        planned.events.push(event(record.identitySeed, `sync.title.${events.filter((row) => row.type === "thread.meta-updated").length}`, "thread", record.threadId, "thread.meta-updated", thread.updatedAt, "provider", { threadId: record.threadId, title: thread.title, updatedAt: thread.updatedAt }, { adapterKey: provider.adapterKey }));
+    }
+    const changed = planned.events.length > 0 || adopted > 0 || !record.checkpoint || record.currentSourceKey !== thread.sourceKey;
+    const status = dryRun && changed ? "dry-run" : planned.events.length > 0 || adopted > 0 ? "synced" : "up-to-date";
+    const result = {
+        source: thread.source, sourceId: thread.sourceSessionId, sourceKey: thread.sourceKey,
+        status, threadId: record.threadId, projectId: record.projectId, title: thread.title,
+        turnsAdded: newTurns.length, turnsAdopted: adopted, events: planned.events.length,
+        attachments: planned.assets.length, titleAction, resumable: planned.resumable, warnings: planned.warnings,
+    };
+    return {
+        conversation, thread, record, result, planned, checkpoint: checkpointForThread(thread),
+        titleEvent: titleAction === "updated", previouslyImported: true,
+        ...(adopted > 0 && events.at(-1) ? { adoptionSequence: events.at(-1).sequence } : {}),
+    };
+}
+function hasConflict(status) {
+    return ["history-diverged", "branch-sync-unsupported", "target-missing", "not-imported"].includes(status);
+}
+/**
+ * Native Codex wrappers already exist in T3, so newly discovered Codex turns
+ * are transcript history. Emit them with T3's history-import semantics rather
+ * than replaying them as live provider turns; a turn-start request would ask
+ * the provider to execute historical work again.
+ */
+function markAsHistoricalTranscript(planned) {
+    planned.events = planned.events
+        .filter((row) => row.type !== "thread.turn-start-requested" && row.type !== "thread.session-set")
+        .map((row) => {
+        if (row.type === "thread.message-sent") {
+            return {
+                ...row,
+                payload: { ...row.payload, turnId: null },
+                metadata: { ...row.metadata, historyImport: true },
+            };
+        }
+        if (row.type === "thread.activity-appended") {
+            const activity = row.payload.activity;
+            return {
+                ...row,
+                payload: { ...row.payload, activity: { ...activity, turnId: null } },
+                metadata: { ...row.metadata, historyImport: true },
+            };
+        }
+        return row;
+    });
+}
+function aggregate(results, dryRun) {
+    if (dryRun && results.some((result) => result.status === "dry-run"))
+        return "dry-run";
+    const conflicts = results.some((result) => hasConflict(result.status));
+    const synced = results.some((result) => result.status === "synced");
+    if (conflicts && synced)
+        return "mixed";
+    if (conflicts)
+        return "conflict";
+    return synced ? "synced" : "up-to-date";
+}
+export async function inspectConversationSync(conversation, paths) {
+    const db = new Database(paths.dbPath, { readonly: true, fileMustExist: true });
+    try {
+        validateTargetDatabase(db);
+        const plan = buildPlan(db, paths, conversation, false);
+        const result = plan.result;
+        const activeOnly = plan.thread.turns.length === 0 && (plan.thread.ignoredInProgressTurns ?? 0) > 0;
+        const status = activeOnly
+            ? "active-only"
+            : result.status === "not-imported" ? "new"
+                : result.status === "synced" || result.status === "dry-run" ? "syncable"
+                    : result.status === "up-to-date" ? "up-to-date"
+                        : result.status;
+        const newTurns = plan.thread.turns.slice(Math.max(0, plan.thread.turns.length - result.turnsAdded));
+        return {
+            sourceId: result.sourceId, status, newTurns: result.turnsAdded,
+            newCompletedTurns: newTurns.filter((turn) => turn.status === "completed").length,
+            newInterruptedTurns: newTurns.filter((turn) => turn.status === "interrupted").length,
+            newFailedTurns: newTurns.filter((turn) => turn.status === "failed").length,
+            ignoredActiveTurns: plan.thread.ignoredInProgressTurns ?? 0,
+            adoptedTurns: result.turnsAdopted, titleChanged: result.titleAction === "updated",
+            selectable: status === "new" || status === "syncable", previouslyImported: plan.previouslyImported,
+            ...(result.threadId ? { threadId: result.threadId } : {}), warnings: result.warnings,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export async function syncConversations(selections, paths, options) {
+    await assertT3Closed(paths);
+    const releaseLock = options.dryRun ? () => { } : acquireLock(paths);
+    const db = new Database(paths.dbPath, { readonly: options.dryRun, fileMustExist: true });
+    let backup = null;
+    let v2Committed = false;
+    const warnings = [];
+    try {
+        const schema = validateTargetDatabase(db);
+        const plans = selections.map((selection) => buildPlan(db, paths, selection.conversation, options.dryRun));
+        const writable = plans.filter((plan) => plan.planned && !hasConflict(plan.result.status));
+        const eventPlans = writable.filter((plan) => plan.planned.events.length > 0);
+        const t3Plans = writable.filter((plan) => plan.planned.events.length > 0 || plan.result.turnsAdopted > 0);
+        const v2Write = isV2Database(db) && eventPlans.length ? await prepareV2Write(db, eventPlans.map((plan) => plan.planned)) : undefined;
+        if (v2Write)
+            for (const plan of eventPlans)
+                plan.result.events = plan.planned.targetEventCount;
+        if (t3Plans.length > 0) {
+            const backlog = projectionBacklog(db);
+            if (backlog.backlog > 0 && !options.allowProjectionBacklog)
+                throw safetyError(`T3 has ${backlog.backlog} unprojected event${backlog.backlog === 1 ? "" : "s"}. Open T3 and let it finish loading before synchronizing.`);
+            const count = eventPlans.reduce((sum, plan) => sum + (plan.planned.targetEventCount ?? plan.planned.events.length), 0);
+            if (count > MAX_SAFE_IMPORT_EVENTS)
+                throw safetyError(`Synchronization would append ${count} events, exceeding the safe one-launch limit of ${MAX_SAFE_IMPORT_EVENTS}. Sync fewer conversations at a time.`);
+        }
+        if (options.dryRun)
+            return { schemaVersion: 1, status: aggregate(plans.map((plan) => plan.result), true), target: paths.dbPath, migration: schema.migration, backup: null, results: plans.map((plan) => plan.result), warnings, hasConflicts: plans.some((plan) => hasConflict(plan.result.status)) };
+        if (t3Plans.length > 0)
+            backup = createBackup(db, paths);
+        const assets = eventPlans.length > 0 ? materializeAssets(eventPlans.map((plan) => plan.planned), paths, randomUUID()) : { created: [], cleanup: () => { } };
+        const ledgerRecords = [];
+        try {
+            const v2Written = v2Write ? await v2Write.write() : undefined;
+            v2Committed = Boolean(v2Written);
+            const nextVersion = db.prepare("SELECT COALESCE(MAX(stream_version), -1) + 1 nextVersion FROM orchestration_events WHERE aggregate_kind = ? AND stream_id = ?");
+            const insert = db.prepare(`INSERT INTO orchestration_events (event_id, aggregate_kind, stream_id, stream_version, event_type, occurred_at, command_id, causation_event_id, correlation_id, actor_kind, payload_json, metadata_json) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, ?, ?, ?)`);
+            const upsertRuntime = db.prepare(`
+        INSERT INTO provider_session_runtime (thread_id, provider_name, provider_instance_id, adapter_key, runtime_mode, status, last_seen_at, resume_cursor_json, runtime_payload_json)
+        VALUES (?, ?, ?, ?, 'full-access', 'stopped', ?, ?, ?)
+        ON CONFLICT(thread_id) DO UPDATE SET provider_name=excluded.provider_name, provider_instance_id=excluded.provider_instance_id, adapter_key=excluded.adapter_key, runtime_mode=excluded.runtime_mode, status=excluded.status, last_seen_at=excluded.last_seen_at, resume_cursor_json=excluded.resume_cursor_json, runtime_payload_json=excluded.runtime_payload_json
+      `);
+            const collectRecords = () => {
+                for (const plan of writable) {
+                    const record = plan.record;
+                    const planned = plan.planned;
+                    let first = Number.MAX_SAFE_INTEGER;
+                    let last = Math.max(record.lastSequence, plan.adoptionSequence ?? record.lastSequence);
+                    let version = v2Written ? 0 : nextVersion.get("thread", record.threadId).nextVersion;
+                    if (v2Written) {
+                        const sequence = v2Written.get(planned);
+                        if (sequence) {
+                            first = sequence.first;
+                            last = Math.max(last, sequence.last);
+                        }
+                    }
+                    for (const row of v2Written ? [] : planned.events) {
+                        const inserted = insert.run(row.eventId, row.aggregateKind, row.streamId, version++, row.type, row.occurredAt, row.actorKind, JSON.stringify(row.payload), JSON.stringify(row.metadata));
+                        const sequence = Number(inserted.lastInsertRowid);
+                        first = Math.min(first, sequence);
+                        last = Math.max(last, sequence);
+                    }
+                    if (!isV2Database(db) && (planned.events.length > 0 || plan.result.turnsAdopted > 0) && planned.resumable && plan.thread.resumeCursor) {
+                        const cursor = plan.thread.source === "claude" ? { threadId: record.threadId, ...plan.thread.resumeCursor } : plan.thread.resumeCursor;
+                        upsertRuntime.run(record.threadId, planned.provider.providerName, planned.provider.instanceId, planned.provider.adapterKey, plan.thread.updatedAt, JSON.stringify(cursor), JSON.stringify({ cwd: plan.thread.workspace, model: planned.provider.model, activeTurnId: null, lastError: null, modelSelection: { instanceId: planned.provider.instanceId, model: planned.provider.model, options: planned.provider.options }, lastRuntimeEvent: `t3-import.sync.${plan.thread.source}`, lastRuntimeEventAt: plan.thread.updatedAt }));
+                    }
+                    if (planned.events.length > 0)
+                        plan.result.sequence = { first, last };
+                    ledgerRecords.push({
+                        ...record, sourceFingerprint: plan.conversation.fingerprint,
+                        currentSourceKey: plan.thread.sourceKey,
+                        ...(plan.thread.leafId ? { sourceLeafId: plan.thread.leafId } : {}),
+                        sourceTitle: plan.thread.title, checkpoint: plan.checkpoint, syncedAt: new Date().toISOString(),
+                        importerVersion: IMPORTER_VERSION, migration: schema.migration,
+                        lastSequence: last, backupPath: backup ?? record.backupPath, warnings: plan.result.warnings,
+                        isCanonical: true,
+                    });
+                }
+            };
+            if (v2Written)
+                collectRecords();
+            else
+                db.transaction(collectRecords)();
+            assets.cleanup();
+        }
+        catch (error) {
+            if (!v2Committed)
+                for (const path of assets.created)
+                    rmSync(path, { force: true });
+            assets.cleanup();
+            throw error;
+        }
+        if (ledgerRecords.length) {
+            try {
+                recordImports(ledgerRecords);
+            }
+            catch (error) {
+                if (!v2Committed)
+                    throw error;
+                warnings.push(`V2 synchronization committed, but the external ledger could not be updated: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const integrity = String(db.pragma("integrity_check", { simple: true }));
+        if (integrity !== "ok")
+            throw writeError(`Post-sync integrity check failed: ${integrity}`);
+        return { schemaVersion: 1, status: aggregate(plans.map((plan) => plan.result), false), target: paths.dbPath, migration: schema.migration, backup, results: plans.map((plan) => plan.result), warnings, hasConflicts: plans.some((plan) => hasConflict(plan.result.status)) };
+    }
+    catch (error) {
+        if (v2Committed)
+            throw writeError(`V2 synchronization committed, but post-write verification or bookkeeping failed: ${error instanceof Error ? error.message : String(error)}. Attachments were retained. Inspect the target and recover the external ledger before further writes.`, error);
+        if (error instanceof Error && error.name === "ImporterError")
+            throw error;
+        throw writeError(`Synchronization failed: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+    finally {
+        db.close();
+        releaseLock();
+    }
+}
+//# sourceMappingURL=sync.js.map