@letta-ai/dreams 0.0.1

package/dist/cloud/client.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Minimal typed client for the Dreams Cloud API ([02] contract).
+ *
+ * - Bearer credentials come from the shared Dreams auth subsystem.
+ * - Redirects are refused while carrying Authorization (a redirect on an API
+ *   POST is misconfiguration or an attempt to exfiltrate the token).
+ * - Outcomes are classified from structured server error codes where present,
+ *   falling back to HTTP status, so callers branch on intent rather than status.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudError = exports.CloudAuthError = void 0;
+exports.registerSource = registerSource;
+exports.uploadObject = uploadObject;
+const zlib = __importStar(require("node:zlib"));
+const index_1 = require("../auth/index");
+const oauth_1 = require("../auth/oauth");
+class CloudAuthError extends Error {
+    code;
+    constructor(message, code = null) {
+        super(message);
+        this.code = code;
+        this.name = "CloudAuthError";
+    }
+}
+exports.CloudAuthError = CloudAuthError;
+class CloudError extends Error {
+    retryable;
+    status;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "CloudError";
+        this.retryable = options.retryable ?? false;
+        this.status = options.status ?? null;
+    }
+}
+exports.CloudError = CloudError;
+// Comfortably below the source lease TTL (30s) so a stalled request cannot
+// outlive the lease and let another process reclaim it mid-flight.
+const REQUEST_TIMEOUT_MS = 20_000;
+function errorDetail(error) {
+    const cause = error.cause;
+    return cause?.code || cause?.message || (error instanceof Error ? error.message : String(error));
+}
+function parseRetryAfter(value) {
+    if (!value)
+        return null;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : null;
+}
+async function request(method, path, body) {
+    const auth = await (0, index_1.getAuthHeader)(); // throws NotAuthenticatedError when no credential exists
+    const url = `${(0, oauth_1.apiBaseUrl)()}${path}`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method,
+            headers: { ...auth, "content-type": "application/json", accept: "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            redirect: "manual",
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        // Timeouts and connection failures are retryable (the row stays pending).
+        throw new CloudError(`network error contacting ${url} (${errorDetail(error)})`, { retryable: true });
+    }
+    if (response.type === "opaqueredirect" || response.status === 0 || (response.status >= 300 && response.status < 400)) {
+        throw new CloudError(`refusing to follow a redirect from ${url} while authenticated`, { status: response.status });
+    }
+    let json = null;
+    const text = await response.text();
+    if (text) {
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = null;
+        }
+    }
+    return { status: response.status, json, retryAfterMs: parseRetryAfter(response.headers.get("retry-after")) };
+}
+function serverCode(json) {
+    if (!json)
+        return null;
+    const code = json.code ?? json.error;
+    return typeof code === "string" ? code : null;
+}
+function serverMessage(json, fallback) {
+    if (json) {
+        const message = json.message ?? json.error_description ?? json.detail;
+        if (typeof message === "string")
+            return message;
+    }
+    return fallback;
+}
+function classifyAuthOrRetry(status, json, path) {
+    const code = serverCode(json);
+    if (status === 401 || status === 403)
+        throw new CloudAuthError(serverMessage(json, `unauthorized (${status})`), code);
+    if (status === 429 || status >= 500)
+        throw new CloudError(serverMessage(json, `server error ${status} from ${path}`), { retryable: true, status });
+    throw new CloudError(serverMessage(json, `unexpected ${status} from ${path}`), { status });
+}
+/**
+ * Register (and, on the server, provision the workspace for) a source. The [02]
+ * contract has no separate workspace endpoint: this call returns the workspace
+ * id, so it is also how the CLI resolves the workspace.
+ */
+async function registerSource(input) {
+    const r = await request("POST", "/v1/dreams/sources", {
+        source_type: input.sourceType,
+        source_key: input.sourceKey,
+        display_name: input.displayName,
+        installation_id: input.installationId,
+        adapter_version: input.adapterVersion,
+        privacy_config_hash: input.privacyConfigHash ?? null,
+        backfill_policy: input.backfillPolicy ?? null,
+    });
+    if (r.status !== 200 && r.status !== 201)
+        classifyAuthOrRetry(r.status, r.json, "sources");
+    const id = r.json?.id;
+    if (typeof id !== "string")
+        throw new CloudError("source response missing id", { retryable: true });
+    return {
+        serverSourceId: id,
+        status: typeof r.json?.status === "string" ? r.json.status : "active",
+        workspaceId: typeof r.json?.workspace_id === "string" ? r.json.workspace_id : null,
+    };
+}
+async function uploadObject(input) {
+    const content = zlib.gzipSync(input.bytes).toString("base64");
+    const r = await request("POST", "/v1/dreams/uploads", {
+        source_id: input.sourceId,
+        client_upload_id: input.clientUploadId,
+        content_sha256: input.contentSha256,
+        content_encoding: "gzip+base64",
+        content,
+        source_schema: input.sourceSchema,
+        source_metadata: input.sourceMetadata,
+        priority: input.priority,
+        cli_version: input.cliVersion,
+        adapter_version: input.adapterVersion,
+    });
+    const code = serverCode(r.json);
+    const message = serverMessage(r.json, `upload responded ${r.status}`);
+    // Strictly validate 2xx bodies before treating anything as accepted. The [02]
+    // ack must carry upload_id, accepted_at, and a content_sha256 that echoes the
+    // exact row hash; anything else (including a mismatched hash) is retryable, so
+    // the row stays pending and the immutable blob is retained.
+    if (r.status === 201 || r.status === 200) {
+        const status = typeof r.json?.status === "string" ? r.json.status : null;
+        const uploadId = typeof r.json?.upload_id === "string" ? r.json.upload_id : null;
+        const echoedSha = typeof r.json?.content_sha256 === "string" ? r.json.content_sha256 : null;
+        const acceptedAt = typeof r.json?.accepted_at === "string" ? r.json.accepted_at : null;
+        const valid = uploadId !== null && acceptedAt !== null && echoedSha === input.contentSha256;
+        if (valid && status === "accepted")
+            return { kind: "accepted", uploadId: uploadId, contentSha256: echoedSha, acceptedAt };
+        if (valid && status === "duplicate")
+            return { kind: "duplicate", uploadId, contentSha256: echoedSha, acceptedAt };
+        return { kind: "retryable", code: "malformed_success_body", message: `malformed or hash-mismatched ${r.status} upload ack`, retryAfterMs: null };
+    }
+    // Prefer structured codes over bare status.
+    if (code) {
+        if (/auth|credential|unauthorized|forbidden/i.test(code))
+            return { kind: "unauthenticated", code, message };
+        if (/source.*(paus|revok|not_upload|unusable|disabled)/i.test(code))
+            return { kind: "source_unusable", code, message };
+        if (/conflict|mismatch|invalid|malformed|too_large|payload/i.test(code))
+            return { kind: "quarantine", code, message };
+        if (/rate|capacity|unavailable|timeout|throttle|retry/i.test(code))
+            return { kind: "retryable", code, message, retryAfterMs: r.retryAfterMs };
+    }
+    if (r.status === 401 || r.status === 403)
+        return { kind: "unauthenticated", code, message };
+    if (r.status === 404)
+        return { kind: "not_found", code, message };
+    // [02] returns message-only 409s for BOTH client_upload_id/content conflicts and
+    // a source becoming non-upload-capable. Without a discriminating code we cannot
+    // safely make the row permanent (quarantine), so we conservatively stop the
+    // source instead of silently dropping data.
+    if (r.status === 409)
+        return { kind: "source_unusable", code: code ?? "conflict", message };
+    if (r.status === 400 || r.status === 413 || (r.status >= 400 && r.status < 500 && r.status !== 429))
+        return { kind: "quarantine", code: code ?? `http_${r.status}`, message };
+    return { kind: "retryable", code, message, retryAfterMs: r.retryAfterMs };
+}

package/dist/cloud/upload.js

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * Upload orchestration ([07]): drain the local pending queue to the Dreams Cloud
+ * under the shared source-mutation lease.
+ *
+ * Rules (Amelia sign-off):
+ *  - No eligible due rows => no auth and no network.
+ *  - Register workspace/source fresh per invocation (server-idempotent), so a
+ *    changed LETTA_BASE_URL never reuses another environment's IDs.
+ *  - Policy is re-evaluated immediately before each send (the linearization
+ *    point); a row disallowed by tightened policy is canceled, not uploaded.
+ *  - Mark-accepted and acknowledged-cursor collapse happen in one owner-fenced
+ *    transaction. The cursor advances through accepted+excluded coverage only,
+ *    stalling at the first pending/quarantined gap, never past queued_through.
+ *  - Never sleep holding the lease: retryable rows get next_attempt_at and the
+ *    run continues with other due rows, then exits.
+ *  - Blob lifecycle: retain for pending/retryable/quarantined; delete after the
+ *    accepted (or canceled) transaction commits.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpload = runUpload;
+const path = __importStar(require("node:path"));
+const index_1 = require("./../auth/index");
+const claude_1 = require("./../local/claude");
+const config_1 = require("./../local/config");
+const db_1 = require("./../local/db");
+const dreamignore_1 = require("./../local/dreamignore");
+const leases_1 = require("./../local/leases");
+const scan_1 = require("./../local/scan");
+const blobs_1 = require("./../local/blobs");
+const version_1 = require("./../version");
+const client_1 = require("./client");
+/**
+ * Final local policy gate: ONE fresh roots/.dreamignore snapshot drives both the
+ * eligibility decision and the fingerprint, so a tightening cannot be recorded
+ * without also being evaluated (P1). Called immediately before the send.
+ */
+function evaluatePolicy(db, cwd) {
+    const roots = (0, config_1.getApprovedRoots)(db);
+    const approvedRoot = cwd ? (0, config_1.isUnderApprovedRoot)(roots, cwd) : null;
+    if (!approvedRoot || !cwd)
+        return { eligible: false, approvedRoot: null, fingerprint: null };
+    const ignoreText = (0, dreamignore_1.loadDreamignoreText)(approvedRoot);
+    const eligible = !(0, dreamignore_1.isIgnored)((0, dreamignore_1.parseDreamignore)(ignoreText), path.relative(approvedRoot, cwd), true);
+    return { eligible, approvedRoot, fingerprint: (0, scan_1.policyFingerprint)(roots, approvedRoot, ignoreText) };
+}
+const SOURCE_SCHEMA = "claude-code-jsonl-v1";
+const UPLOAD_CAPABLE = new Set(["active", "backfilling", "discovered", "awaiting_approval"]);
+const MAX_BACKOFF_MS = 5 * 60_000;
+function localSourceId() {
+    return `src_${claude_1.CLAUDE_SOURCE_TYPE}`;
+}
+function dueRows(db, localSource) {
+    return db
+        .prepare(`SELECT q.id, q.upload_id, q.source_file_id, q.session_id, q.generation, q.start_offset, q.end_offset,
+              q.content_sha256, q.priority, q.policy_fingerprint, sf.cwd
+       FROM upload_queue q JOIN source_files sf ON sf.id = q.source_file_id
+       WHERE q.source_id = ? AND q.state = 'pending'
+         AND (q.next_attempt_at IS NULL OR q.next_attempt_at <= ?)
+       ORDER BY CASE q.priority WHEN 'live' THEN 0 WHEN 'backfill' THEN 1 ELSE 2 END,
+                q.session_id, q.generation, q.start_offset`)
+        .all(localSource, (0, db_1.nowIso)());
+}
+function backoffMs(attempts, retryAfterMs) {
+    const exponential = Math.min(MAX_BACKOFF_MS, 1000 * 2 ** Math.min(Math.max(attempts, 1), 8));
+    return Math.max(exponential, retryAfterMs ?? 0);
+}
+/**
+ * Delete a blob only when no pending/quarantined row still needs it (accepted
+ * rows do not). Fenced + write-lock-held across the check and unlink so a stale
+ * process cannot delete a blob the current lease holder just re-referenced (P2).
+ */
+function gcBlob(db, contentSha, owner) {
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        const row = db
+            .prepare("SELECT count(*) c FROM upload_queue WHERE content_sha256 = ? AND state IN ('pending','quarantined')")
+            .get(contentSha);
+        if (row.c === 0)
+            (0, blobs_1.deleteBlob)(contentSha);
+    });
+}
+/**
+ * Advance the acknowledged cursor for one source_file through the contiguous
+ * union of accepted queue intervals and excluded ranges, stopping at the first
+ * pending/quarantined gap and never exceeding queued_through_offset.
+ */
+function collapseAckCursor(db, sourceFileId) {
+    const cursor = db
+        .prepare("SELECT queued_through_offset, acked_offset FROM source_cursors WHERE source_file_id = ?")
+        .get(sourceFileId);
+    if (!cursor)
+        return;
+    const intervals = db
+        .prepare(`SELECT start_offset, end_offset FROM upload_queue WHERE source_file_id = ? AND state = 'accepted'
+       UNION ALL
+       SELECT start_offset, end_offset FROM excluded_ranges WHERE source_file_id = ?
+       ORDER BY start_offset, end_offset`)
+        .all(sourceFileId, sourceFileId);
+    let acked = cursor.acked_offset;
+    for (const interval of intervals) {
+        if (interval.start_offset > acked)
+            break; // gap (pending/quarantined/uncovered)
+        if (interval.end_offset > acked)
+            acked = interval.end_offset;
+    }
+    acked = Math.min(acked, cursor.queued_through_offset);
+    if (acked !== cursor.acked_offset) {
+        db.prepare("UPDATE source_cursors SET acked_offset = ?, updated_at = ? WHERE source_file_id = ?").run(acked, (0, db_1.nowIso)(), sourceFileId);
+    }
+}
+function cancelRowForPolicy(db, row, owner) {
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        const info = db.prepare("UPDATE upload_queue SET state = 'canceled', updated_at = ? WHERE id = ? AND state = 'pending'").run((0, db_1.nowIso)(), row.id);
+        if (info.changes === 0)
+            return;
+        (0, scan_1.addExcludedRange)(db, row.source_file_id, row.start_offset, row.end_offset, "privacy");
+        collapseAckCursor(db, row.source_file_id);
+    });
+    gcBlob(db, row.content_sha256, owner);
+}
+function markAccepted(db, row, serverUploadId, acceptedAt, owner) {
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        db.prepare("UPDATE upload_queue SET state = 'accepted', server_upload_id = ?, accepted_at = ?, last_error_code = NULL, last_error_message = NULL, updated_at = ? WHERE id = ?").run(serverUploadId, acceptedAt ?? (0, db_1.nowIso)(), (0, db_1.nowIso)(), row.id);
+        collapseAckCursor(db, row.source_file_id);
+    });
+    gcBlob(db, row.content_sha256, owner); // safe: the server has durably accepted it
+}
+function quarantineRow(db, row, code, message, owner) {
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        db.prepare("UPDATE upload_queue SET state = 'quarantined', last_error_code = ?, last_error_message = ?, updated_at = ? WHERE id = ?").run(code, message.slice(0, 500), (0, db_1.nowIso)(), row.id);
+        // The gap deliberately stalls this generation's acknowledged cursor.
+    });
+}
+function scheduleRetry(db, row, code, message, retryAfterMs, owner) {
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        const attempts = db.prepare("SELECT attempts FROM upload_queue WHERE id = ?").get(row.id).attempts + 1;
+        const next = new Date(Date.now() + backoffMs(attempts, retryAfterMs)).toISOString();
+        db.prepare("UPDATE upload_queue SET attempts = ?, next_attempt_at = ?, last_error_code = ?, last_error_message = ?, updated_at = ? WHERE id = ?").run(attempts, next, code, message.slice(0, 500), (0, db_1.nowIso)(), row.id);
+    });
+}
+function refreshPolicyFingerprint(db, row, fingerprint, owner) {
+    if (fingerprint === row.policy_fingerprint)
+        return;
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        db.prepare("UPDATE upload_queue SET policy_fingerprint = ?, updated_at = ? WHERE id = ?").run(fingerprint, (0, db_1.nowIso)(), row.id);
+    });
+}
+async function runUpload(db, options) {
+    const owner = options.leaseOwner;
+    const local = localSourceId();
+    const summary = {
+        local_source_id: null,
+        server_source_id: null,
+        workspace_id: null,
+        source_status: null,
+        due: 0,
+        accepted: 0,
+        duplicate: 0,
+        quarantined: 0,
+        retry_scheduled: 0,
+        canceled_by_policy: 0,
+        bytes_uploaded: 0,
+        stopped_reason: null,
+        partial: false,
+    };
+    const sourceExists = db.prepare("SELECT id FROM sources WHERE id = ?").get(local);
+    if (!sourceExists)
+        return summary; // nothing scanned yet
+    summary.local_source_id = local;
+    let due = dueRows(db, local);
+    summary.due = due.length;
+    if (due.length === 0)
+        return summary; // no eligible pending rows => no auth, no network
+    // Register the source fresh (server-idempotent). Per [02] this also provisions
+    // and returns the workspace, so there is no separate workspace call. Registering
+    // per invocation, bound to the current base URL, avoids reusing a prior env's IDs.
+    let registration;
+    try {
+        if (!(0, leases_1.renewLease)(db, leases_1.SOURCE_LEASE, owner))
+            throw new leases_1.LeaseLostError(leases_1.SOURCE_LEASE);
+        registration = await (0, client_1.registerSource)({
+            sourceType: claude_1.CLAUDE_SOURCE_TYPE,
+            sourceKey: claude_1.CLAUDE_SOURCE_TYPE,
+            displayName: "Claude Code",
+            installationId: options.installationId,
+            adapterVersion: claude_1.CLAUDE_ADAPTER_VERSION,
+        });
+    }
+    catch (error) {
+        if (error instanceof index_1.NotAuthenticatedError) {
+            summary.stopped_reason = "not authenticated: run `dreams auth login`";
+            summary.partial = true;
+            return summary;
+        }
+        if (error instanceof client_1.CloudAuthError) {
+            summary.stopped_reason = `authentication failed: ${error.message}`;
+            summary.partial = true;
+            return summary;
+        }
+        if (error instanceof client_1.CloudError) {
+            summary.stopped_reason = `could not resolve source: ${error.message}`;
+            summary.partial = true;
+            return summary;
+        }
+        throw error;
+    }
+    summary.server_source_id = registration.serverSourceId;
+    summary.source_status = registration.status;
+    summary.workspace_id = registration.workspaceId;
+    persistBindings(db, registration, owner);
+    if (!UPLOAD_CAPABLE.has(registration.status)) {
+        summary.stopped_reason = `source is ${registration.status} (not upload-capable)`;
+        summary.partial = true;
+        return summary;
+    }
+    let reRegistered = false;
+    for (let index = 0; index < due.length; index++) {
+        const row = due[index];
+        if (!(0, leases_1.renewLease)(db, leases_1.SOURCE_LEASE, owner))
+            throw new leases_1.LeaseLostError(leases_1.SOURCE_LEASE);
+        // Prepare the payload first.
+        let bytes;
+        try {
+            bytes = (0, blobs_1.readBlob)(row.content_sha256); // verifies the hash
+        }
+        catch (error) {
+            const code = error.code === "ENOENT" ? "blob_missing" : "blob_corrupt";
+            quarantineRow(db, row, code, error instanceof Error ? error.message : String(error), owner);
+            summary.quarantined++;
+            summary.partial = true;
+            continue;
+        }
+        // Final local policy gate (one snapshot for eligibility AND fingerprint),
+        // immediately before the send — the policy linearization point.
+        const policy = evaluatePolicy(db, row.cwd);
+        if (!policy.eligible) {
+            cancelRowForPolicy(db, row, owner);
+            summary.canceled_by_policy++;
+            continue;
+        }
+        if (policy.fingerprint)
+            refreshPolicyFingerprint(db, row, policy.fingerprint, owner);
+        // Renew immediately before the network attempt so the request cannot outlive the lease.
+        if (!(0, leases_1.renewLease)(db, leases_1.SOURCE_LEASE, owner))
+            throw new leases_1.LeaseLostError(leases_1.SOURCE_LEASE);
+        let outcome;
+        try {
+            outcome = await (0, client_1.uploadObject)({
+                sourceId: registration.serverSourceId,
+                clientUploadId: row.upload_id,
+                contentSha256: row.content_sha256,
+                bytes,
+                sourceSchema: SOURCE_SCHEMA,
+                sourceMetadata: { session_id: row.session_id, generation: row.generation, start_offset: row.start_offset, end_offset: row.end_offset },
+                priority: row.priority,
+                cliVersion: (0, version_1.packageVersion)(),
+                adapterVersion: claude_1.CLAUDE_ADAPTER_VERSION,
+            });
+        }
+        catch (error) {
+            if (error instanceof index_1.NotAuthenticatedError) {
+                summary.stopped_reason = "not authenticated: run `dreams auth login`";
+                summary.partial = true;
+                return summary;
+            }
+            if (error instanceof client_1.CloudAuthError) {
+                summary.stopped_reason = `authentication failed: ${error.message}`;
+                summary.partial = true;
+                return summary;
+            }
+            if (error instanceof client_1.CloudError && error.retryable) {
+                scheduleRetry(db, row, "network", error.message, null, owner);
+                summary.retry_scheduled++;
+                continue;
+            }
+            throw error; // programming/unexpected error
+        }
+        switch (outcome.kind) {
+            case "accepted":
+                markAccepted(db, row, outcome.uploadId, outcome.acceptedAt, owner);
+                summary.accepted++;
+                summary.bytes_uploaded += bytes.length;
+                break;
+            case "duplicate":
+                markAccepted(db, row, outcome.uploadId, outcome.acceptedAt, owner);
+                summary.duplicate++;
+                break;
+            case "unauthenticated":
+                summary.stopped_reason = `authentication failed: ${outcome.message}`;
+                summary.partial = true;
+                return summary;
+            case "source_unusable":
+                summary.stopped_reason = `source not upload-capable: ${outcome.message}`;
+                summary.partial = true;
+                return summary;
+            case "not_found":
+                if (reRegistered) {
+                    summary.stopped_reason = `source not found after re-registration: ${outcome.message}`;
+                    summary.partial = true;
+                    return summary;
+                }
+                reRegistered = true;
+                {
+                    // Renew before this second network attempt so the two bounded requests
+                    // cannot exceed the lease TTL before persistBindings commits (P2).
+                    if (!(0, leases_1.renewLease)(db, leases_1.SOURCE_LEASE, owner))
+                        throw new leases_1.LeaseLostError(leases_1.SOURCE_LEASE);
+                    const again = await (0, client_1.registerSource)({
+                        sourceType: claude_1.CLAUDE_SOURCE_TYPE,
+                        sourceKey: claude_1.CLAUDE_SOURCE_TYPE,
+                        displayName: "Claude Code",
+                        installationId: options.installationId,
+                        adapterVersion: claude_1.CLAUDE_ADAPTER_VERSION,
+                    });
+                    summary.server_source_id = again.serverSourceId;
+                    summary.source_status = again.status;
+                    summary.workspace_id = again.workspaceId;
+                    persistBindings(db, again, owner);
+                    registration.serverSourceId = again.serverSourceId;
+                }
+                index--; // retry the same row once with the refreshed source id
+                break;
+            case "quarantine":
+                quarantineRow(db, row, outcome.code, outcome.message, owner);
+                summary.quarantined++;
+                summary.partial = true;
+                break;
+            case "retryable":
+                scheduleRetry(db, row, outcome.code, outcome.message, outcome.retryAfterMs, owner);
+                summary.retry_scheduled++;
+                break;
+        }
+    }
+    return summary;
+}
+function persistBindings(db, registration, owner) {
+    const base = process.env.LETTA_BASE_URL || "https://api.letta.com";
+    (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        db.prepare(`INSERT INTO workspace_bindings (id, api_base_url, workspace_id, organization_id, user_id, created_at, updated_at)
+       VALUES (1, ?, ?, NULL, NULL, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET api_base_url = excluded.api_base_url, workspace_id = excluded.workspace_id, updated_at = excluded.updated_at`).run(base, registration.workspaceId, (0, db_1.nowIso)(), (0, db_1.nowIso)());
+        db.prepare("UPDATE sources SET server_source_id = ?, status = ?, updated_at = ? WHERE id = ?").run(registration.serverSourceId, registration.status, (0, db_1.nowIso)(), localSourceId());
+    });
+}