@letta-ai/dreams 0.0.1 → 0.0.4

package/dist/local/commands.js

@@ -10,13 +10,17 @@ exports.commandSourceScan = commandSourceScan;
 exports.commandUpload = commandUpload;
 exports.commandSourceApproveRoot = commandSourceApproveRoot;
 exports.commandSourceList = commandSourceList;
+exports.commandSourceDetect = commandSourceDetect;
 exports.commandSource = commandSource;
 const store_1 = require("../store");
+const upload_1 = require("../cloud/upload");
 const config_1 = require("./config");
 const db_1 = require("./db");
+const detect_1 = require("./detect");
 const leases_1 = require("./leases");
 const scan_1 = require("./scan");
-const upload_1 = require("../cloud/upload");
+const source_adapters_1 = require("./source-adapters");
+const state_lock_1 = require("./state-lock");
 function open() {
     const installation = (0, store_1.loadOrCreateInstallation)();
     const db = (0, db_1.openDb)({
@@ -31,7 +35,7 @@ function emit(json, payload, human) {
     else
         console.log(human());
 }
-/** Optional override for the per-segment byte cap (advanced/testing); ignored if not a positive integer. */
+/** Optional override for the soft segment packing target (advanced/testing). */
 function maxSegmentBytesOverride() {
     const raw = process.env.DREAMS_MAX_SEGMENT_BYTES;
     if (!raw)
@@ -39,7 +43,15 @@ function maxSegmentBytesOverride() {
     const value = Number(raw);
     return Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
-function commandSourceScan(json) {
+/** Optional override for the hard per-record ceiling (advanced/testing). */
+function maxRecordBytesOverride() {
+    const raw = process.env.DREAMS_MAX_RECORD_BYTES;
+    if (!raw)
+        return undefined;
+    const value = Number(raw);
+    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function commandSourceScanUnlocked(json, adapter) {
     const { db, installationId } = open();
     try {
         const owner = (0, leases_1.acquireLease)(db, leases_1.SOURCE_LEASE);
@@ -49,7 +61,13 @@ function commandSourceScan(json) {
         }
         let summary;
         try {
-            summary = (0, scan_1.reconcile)(db, { installationId, leaseOwner: owner, maxSegmentBytes: maxSegmentBytesOverride() });
+            summary = (0, scan_1.reconcile)(db, {
+                installationId,
+                leaseOwner: owner,
+                adapter,
+                maxSegmentBytes: maxSegmentBytesOverride(),
+                maxRecordBytes: maxRecordBytesOverride(),
+            });
         }
         finally {
             (0, leases_1.releaseLease)(db, leases_1.SOURCE_LEASE, owner);
@@ -72,7 +90,7 @@ function commandSourceScan(json) {
         (0, db_1.closeDb)();
     }
 }
-async function commandUpload(json) {
+async function commandUploadUnlocked(json, adapter) {
     const { db, installationId } = open();
     try {
         const owner = (0, leases_1.acquireLease)(db, leases_1.SOURCE_LEASE);
@@ -82,7 +100,11 @@ async function commandUpload(json) {
         }
         let summary;
         try {
-            summary = await (0, upload_1.runUpload)(db, { installationId, leaseOwner: owner });
+            summary = await (0, upload_1.runUpload)(db, {
+                installationId,
+                leaseOwner: owner,
+                adapter,
+            });
         }
         finally {
             (0, leases_1.releaseLease)(db, leases_1.SOURCE_LEASE, owner);
@@ -108,36 +130,43 @@ async function commandUpload(json) {
         (0, db_1.closeDb)();
     }
 }
-function commandSourceApproveRoot(json, root) {
+function commandSourceApproveRootUnlocked(json, root) {
     if (!root) {
-        process.stderr.write("Usage: dreams source approve-root <path>\n");
+        process.stderr.write("Usage: dreams source approve-dir <path>\n");
         return 1;
     }
     const { db } = open();
     try {
         const roots = (0, config_1.approveRoot)(db, root);
-        emit(json, { status: "ok", approved_roots: roots }, () => `Approved roots:\n${roots.map((r) => `  ${r}`).join("\n") || "  (none)"}`);
+        emit(json, { status: "ok", approved_roots: roots, approved_directories: roots }, () => `Approved directories:\n${roots.map((r) => `  ${r}`).join("\n") || "  (none)"}`);
         return 0;
     }
     finally {
         (0, db_1.closeDb)();
     }
 }
-function commandSourceList(json) {
+function commandSourceListUnlocked(json) {
     const { db } = open();
     try {
         const roots = (0, config_1.getApprovedRoots)(db);
         const sources = db
-            .prepare("SELECT id, source_type, source_key, display_name, status FROM sources ORDER BY id")
+            .prepare("SELECT id, source_type, source_key, display_name, status, server_source_id FROM sources ORDER BY id")
             .all();
         const queue = (0, scan_1.listPendingQueue)(db);
-        emit(json, { status: "ok", db_path: (0, db_1.dbFilePath)(), approved_roots: roots, sources, pending_uploads: queue }, () => [
+        emit(json, {
+            status: "ok",
+            db_path: (0, db_1.dbFilePath)(),
+            approved_roots: roots,
+            approved_directories: roots,
+            sources,
+            pending_uploads: queue,
+        }, () => [
             `Dream local sources`,
             ``,
-            `  DB:             ${(0, db_1.dbFilePath)()}`,
-            `  Approved roots: ${roots.length ? roots.join(", ") : "(none — deny by default)"}`,
-            `  Sources:        ${sources.length}`,
-            `  Pending uploads: ${queue.length}`,
+            `  DB:                  ${(0, db_1.dbFilePath)()}`,
+            `  Approved directories: ${roots.length ? roots.join(", ") : "(none — deny by default)"}`,
+            `  Sources:             ${sources.length}`,
+            `  Pending uploads:     ${queue.length}`,
         ].join("\n"));
         return 0;
     }
@@ -145,16 +174,121 @@ function commandSourceList(json) {
         (0, db_1.closeDb)();
     }
 }
-function commandSource(subcommand, positional, json) {
+async function commandSourceDetectUnlocked(json, adapter) {
+    const { db, installationId } = open();
+    try {
+        const owner = (0, leases_1.acquireLease)(db, leases_1.SOURCE_LEASE);
+        if (owner === null) {
+            emit(json, { status: "busy", reason: "another source operation holds the local lease" }, () => "Another Dreams source operation is in progress; skipping.");
+            return 0;
+        }
+        let result;
+        try {
+            result = await (0, detect_1.runSourceDetect)(db, {
+                installationId,
+                leaseOwner: owner,
+                adapter,
+            });
+        }
+        finally {
+            (0, leases_1.releaseLease)(db, leases_1.SOURCE_LEASE, owner);
+        }
+        emit(json, result, () => [
+            result.status === "ok" ? "Source detection complete" : "Source detection failed",
+            ``,
+            `  Harness:          ${result.harness}${result.harness_present ? "" : " (not found)"}`,
+            `  Local source:     ${result.local_source_id ?? "(none)"}`,
+            `  Server source:    ${result.server_source_id ?? "(none)"}`,
+            `  Workspace:        ${result.workspace_id ?? "(none)"}`,
+            `  Source status:    ${result.source_status ?? "(none)"}`,
+            `  Registration:     ${result.registration}`,
+            result.message ? `  Message:          ${result.message}` : ``,
+        ].filter((line) => line !== ``).join("\n"));
+        return result.status === "ok" ? 0 : 1;
+    }
+    finally {
+        (0, db_1.closeDb)();
+    }
+}
+function stateBusy(json) {
+    emit(json, { status: "busy", reason: "another Dreams command holds the local state lock" }, () => "Another Dreams command is using local state; skipping.");
+    return 0;
+}
+function commandSourceScan(json, sourceType) {
+    const adapter = (0, source_adapters_1.resolveSourceAdapter)(sourceType);
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return commandSourceScanUnlocked(json, adapter);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+async function commandUpload(json, sourceType) {
+    const adapter = (0, source_adapters_1.resolveSourceAdapter)(sourceType);
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return await commandUploadUnlocked(json, adapter);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+function commandSourceApproveRoot(json, root) {
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return commandSourceApproveRootUnlocked(json, root);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+function commandSourceList(json) {
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return commandSourceListUnlocked(json);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+async function commandSourceDetect(json, sourceType) {
+    const adapter = (0, source_adapters_1.resolveSourceAdapter)(sourceType);
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return await commandSourceDetectUnlocked(json, adapter);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+function commandSource(subcommand, positional, json, sourceType) {
+    if (sourceType !== undefined && subcommand !== "detect" && subcommand !== "scan") {
+        process.stderr.write(`--source is only valid with \`dreams source detect\` or \`dreams source scan\`\n`);
+        return 1;
+    }
     switch (subcommand) {
+        case "detect":
+            return commandSourceDetect(json, sourceType);
         case "scan":
-            return commandSourceScan(json);
+            return commandSourceScan(json, sourceType);
         case "approve-root":
+        case "approve-dir":
             return commandSourceApproveRoot(json, positional);
         case "list":
             return commandSourceList(json);
         default:
-            process.stderr.write(`Unknown source subcommand: ${subcommand ?? "(none)"} — expected scan, approve-root, or list\n`);
+            process.stderr.write(`Unknown source subcommand: ${subcommand ?? "(none)"} — expected detect, scan, approve-root, approve-dir, or list\n`);
             return 1;
     }
 }

package/dist/local/db.js

@@ -188,6 +188,74 @@ const MIGRATIONS = [
         // Due-row selection: pending rows for a source, ordered by priority then time.
         `CREATE INDEX idx_upload_queue_due ON upload_queue (source_id, state, priority, next_attempt_at)`,
     ],
+    [
+        // Hook-safe sync worker ([LET-10237]): durable trigger coalescing + runtime status.
+        `CREATE TABLE sync_triggers (
+       source_id      TEXT PRIMARY KEY REFERENCES sources(id) ON DELETE CASCADE,
+       requested_gen  INTEGER NOT NULL DEFAULT 0,
+       processed_gen  INTEGER NOT NULL DEFAULT 0,
+       forced         INTEGER NOT NULL DEFAULT 0,
+       session_hints  TEXT,
+       updated_at     TEXT NOT NULL
+     )`,
+        `CREATE TABLE sync_runtime (
+       id                 INTEGER PRIMARY KEY CHECK (id = 1),
+       paused             INTEGER NOT NULL DEFAULT 0,
+       state              TEXT NOT NULL DEFAULT 'idle',
+       last_attempt_at    TEXT,
+       last_success_at    TEXT,
+       last_error_at      TEXT,
+       last_error_code    TEXT,
+       last_error_message TEXT,
+       next_due_at        TEXT,
+       updated_at         TEXT NOT NULL
+     )`,
+        `INSERT INTO sync_runtime (id, paused, state, updated_at) VALUES (1, 0, 'idle', datetime('now'))`,
+    ],
+    [
+        // Backfill session frontier ([LET-10239]): per-generation completion for an
+        // approved [since_at, until_at] window. Mtime orders unfinished sessions only.
+        // Rows are scoped by policy_id so a later window cannot inherit stale completes.
+        `CREATE TABLE backfill_frontier (
+       policy_id      TEXT NOT NULL,
+       source_id      TEXT NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
+       session_id     TEXT NOT NULL,
+       generation     INTEGER NOT NULL,
+       source_file_id INTEGER REFERENCES source_files(id) ON DELETE SET NULL,
+       mtime_ms       INTEGER,
+       status         TEXT NOT NULL DEFAULT 'pending',
+       completed_at   TEXT,
+       updated_at     TEXT NOT NULL,
+       PRIMARY KEY (policy_id, session_id, generation)
+     )`,
+        `CREATE INDEX idx_backfill_frontier_unfinished
+       ON backfill_frontier (policy_id, status, mtime_ms)`,
+    ],
+    [
+        // Per-source sync schedule ([LET-10314]): cadence/retry isolation across adapters.
+        // Global pause/running remain on sync_runtime; due state lives on sync_triggers.
+        `ALTER TABLE sync_triggers ADD COLUMN state TEXT NOT NULL DEFAULT 'idle'`,
+        `ALTER TABLE sync_triggers ADD COLUMN last_attempt_at TEXT`,
+        `ALTER TABLE sync_triggers ADD COLUMN last_success_at TEXT`,
+        `ALTER TABLE sync_triggers ADD COLUMN last_error_at TEXT`,
+        `ALTER TABLE sync_triggers ADD COLUMN last_error_code TEXT`,
+        `ALTER TABLE sync_triggers ADD COLUMN last_error_message TEXT`,
+        `ALTER TABLE sync_triggers ADD COLUMN next_due_at TEXT`,
+        // Preserve any pre-migration global cadence onto the default Claude trigger row.
+        `UPDATE sync_triggers
+        SET next_due_at = (SELECT next_due_at FROM sync_runtime WHERE id = 1),
+            last_attempt_at = (SELECT last_attempt_at FROM sync_runtime WHERE id = 1),
+            last_success_at = (SELECT last_success_at FROM sync_runtime WHERE id = 1),
+            last_error_at = (SELECT last_error_at FROM sync_runtime WHERE id = 1),
+            last_error_code = (SELECT last_error_code FROM sync_runtime WHERE id = 1),
+            last_error_message = (SELECT last_error_message FROM sync_runtime WHERE id = 1),
+            state = COALESCE((SELECT state FROM sync_runtime WHERE id = 1), 'idle')
+      WHERE source_id = 'src_claude-code'`,
+    ],
+    [
+        // Track which source currently owns the singleton worker ([LET-10317]).
+        `ALTER TABLE sync_runtime ADD COLUMN active_source_id TEXT`,
+    ],
 ];
 exports.SCHEMA_VERSION = MIGRATIONS.length;
 function tx(db, fn) {

package/dist/local/detect.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * `dreams source detect` — register a harness as a detected Cloud source
+ * without reading transcripts, approving roots, scanning, or uploading.
+ *
+ * CLI defaults to the Claude adapter; pass an explicit adapter for Codex
+ * (`dreams source detect --source codex`) ([LET-10313] / [LET-10315]).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectClaudeCodeHarness = detectClaudeCodeHarness;
+exports.localClaudeSourceId = localClaudeSourceId;
+exports.ensureLocalDetectedSource = ensureLocalDetectedSource;
+exports.runSourceDetect = runSourceDetect;
+const index_1 = require("../auth/index");
+const client_1 = require("../cloud/client");
+const version_1 = require("../version");
+const skill_1 = require("../skill");
+const bindings_1 = require("./bindings");
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const db_1 = require("./db");
+const leases_1 = require("./leases");
+/**
+ * Deterministic harness-owned filesystem facts only. Never opens transcript
+ * files or walks session contents.
+ */
+function detectClaudeCodeHarness(home) {
+    const result = (0, claude_1.detectClaudeCodeHarness)(home);
+    return { present: result.present, harness: claude_1.claudeSourceAdapter.sourceType, evidence: result.evidence };
+}
+function localClaudeSourceId() {
+    return claude_1.claudeSourceAdapter.sourceId;
+}
+/** Ensure the local sources row exists without touching queues or files. */
+function ensureLocalDetectedSource(db, owner, adapter) {
+    const id = adapter.sourceId;
+    return (0, db_1.tx)(db, () => {
+        (0, leases_1.assertLeaseHeld)(db, leases_1.SOURCE_LEASE, owner);
+        const existing = db.prepare("SELECT id FROM sources WHERE id = ?").get(id);
+        if (!existing) {
+            const now = (0, db_1.nowIso)();
+            db.prepare(`INSERT INTO sources (id, source_type, source_key, display_name, adapter_version, status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'detected', ?, ?)`).run(id, adapter.sourceType, adapter.sourceKey, adapter.displayName, adapter.adapterVersion, now, now);
+        }
+        return id;
+    });
+}
+async function runSourceDetect(db, options) {
+    const adapter = options.adapter;
+    const detection = adapter.detect();
+    if (!detection.present) {
+        return {
+            status: "error",
+            harness: adapter.sourceType,
+            harness_present: false,
+            evidence: [],
+            local_source_id: null,
+            server_source_id: null,
+            workspace_id: null,
+            source_status: null,
+            registration: "skipped",
+            message: adapter.sourceType === claude_1.claudeSourceAdapter.sourceType
+                ? "Claude Code was not detected under ~/.claude"
+                : adapter.sourceType === codex_1.CODEX_SOURCE_TYPE
+                    ? "Codex was not detected under ~/.codex"
+                    : `${adapter.displayName} was not detected`,
+        };
+    }
+    const localId = ensureLocalDetectedSource(db, options.leaseOwner, adapter);
+    const before = db.prepare("SELECT server_source_id, status FROM sources WHERE id = ?").get(localId);
+    let registration;
+    try {
+        registration = await (0, client_1.registerSource)({
+            sourceType: adapter.sourceType,
+            sourceKey: adapter.sourceKey,
+            displayName: adapter.displayName,
+            installationId: options.installationId,
+            adapterVersion: adapter.adapterVersion,
+            // Required for detection-only create: Cloud defaults omitted status to active.
+            status: "detected",
+            cliVersion: (0, version_1.packageVersion)(),
+            skillVersion: (0, skill_1.installedSkillVersion)(),
+            platform: process.platform,
+        });
+    }
+    catch (error) {
+        if (error instanceof index_1.NotAuthenticatedError) {
+            return {
+                status: "error",
+                harness: adapter.sourceType,
+                harness_present: true,
+                evidence: detection.evidence,
+                local_source_id: localId,
+                server_source_id: before.server_source_id,
+                workspace_id: null,
+                source_status: before.status,
+                registration: "skipped",
+                message: "not authenticated: run `dreams auth login`",
+            };
+        }
+        if (error instanceof client_1.CloudAuthError) {
+            return {
+                status: "error",
+                harness: adapter.sourceType,
+                harness_present: true,
+                evidence: detection.evidence,
+                local_source_id: localId,
+                server_source_id: before.server_source_id,
+                workspace_id: null,
+                source_status: before.status,
+                registration: "skipped",
+                message: `authentication failed: ${error.message}`,
+            };
+        }
+        if (error instanceof client_1.CloudError) {
+            return {
+                status: "error",
+                harness: adapter.sourceType,
+                harness_present: true,
+                evidence: detection.evidence,
+                local_source_id: localId,
+                server_source_id: before.server_source_id,
+                workspace_id: null,
+                source_status: before.status,
+                registration: "skipped",
+                message: `could not register source: ${error.message}`,
+            };
+        }
+        throw error;
+    }
+    const persisted = (0, bindings_1.persistSourceBindings)(db, localId, {
+        serverSourceId: registration.serverSourceId,
+        status: registration.status,
+        workspaceId: registration.workspaceId,
+    }, options.leaseOwner);
+    return {
+        status: "ok",
+        harness: adapter.sourceType,
+        harness_present: true,
+        evidence: detection.evidence,
+        local_source_id: localId,
+        server_source_id: persisted.serverSourceId,
+        workspace_id: persisted.workspaceId,
+        source_status: persisted.status,
+        registration: before.server_source_id ? "refreshed" : "created",
+        message: null,
+    };
+}

package/dist/local/discovered.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Harness-agnostic session discovery shape ([LET-10313]).
+ * Parsing and filesystem layout stay inside each source adapter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/local/hooks-install.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * `dreams hooks install [--dry-run] [--source <type>] [--json]`
+ *
+ * CLI owns the mutation; the setup skill owns consent and showing the dry-run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandHooksInstall = commandHooksInstall;
+const claude_1 = require("./claude");
+const claude_hooks_1 = require("./claude-hooks");
+const codex_1 = require("./codex");
+const codex_hooks_1 = require("./codex-hooks");
+const source_adapters_1 = require("./source-adapters");
+const skill_1 = require("../skill");
+const managed_install_1 = require("../managed-install");
+function emit(json, payload, human) {
+    if (json)
+        console.log(JSON.stringify(payload, null, 2));
+    else
+        console.log(human());
+}
+function commandHooksInstall(options) {
+    let sources;
+    try {
+        if (options.sourceType) {
+            const adapter = (0, source_adapters_1.resolveSourceAdapter)(options.sourceType);
+            if (adapter.sourceType !== "claude-code" && adapter.sourceType !== "codex") {
+                process.stderr.write(`hooks install does not support source type ${adapter.sourceType}\n`);
+                return 1;
+            }
+            sources = [adapter.sourceType];
+        }
+        else {
+            sources = ["claude-code", "codex"];
+        }
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 1;
+    }
+    const cliPath = (0, managed_install_1.stableCliPath)();
+    const results = [];
+    const humanLines = [
+        options.dryRun ? "Dreams hooks install (dry-run — no files written)" : "Dreams hooks install",
+        "",
+        `  CLI path: ${cliPath}`,
+    ];
+    for (const source of sources) {
+        if (source === "claude-code") {
+            const present = (0, claude_1.detectClaudeCodeHarness)().present;
+            if (!present && options.sourceType === undefined) {
+                humanLines.push("", "Claude Code: harness not detected — skipped");
+                results.push({ source: "claude-code", status: "skipped", reason: "harness_not_detected" });
+                continue;
+            }
+            const plan = (0, claude_hooks_1.planClaudeHooksInstall)({ cliPath });
+            if (!options.dryRun)
+                (0, claude_hooks_1.installClaudeHooks)({ cliPath });
+            results.push({
+                source: "claude-code",
+                status: options.dryRun ? "dry_run" : plan.changed ? "updated" : "unchanged",
+                settings_path: plan.settings_path,
+                changed: plan.changed,
+                session_start_command: plan.session_start_command,
+                stop_command: plan.stop_command,
+                next_contents: options.dryRun ? plan.next_contents : undefined,
+            });
+            humanLines.push("", `Claude Code (${options.dryRun ? "dry-run" : plan.changed ? "updated" : "unchanged"}):`, `  Settings: ${plan.settings_path}`, `  SessionStart → wake: ${plan.session_start_command}`, `  Stop → sync:         ${plan.stop_command}`);
+            continue;
+        }
+        const present = (0, codex_1.detectCodexHarness)().present;
+        if (!present && options.sourceType === undefined) {
+            humanLines.push("", "Codex: harness not detected — skipped");
+            results.push({ source: "codex", status: "skipped", reason: "harness_not_detected" });
+            continue;
+        }
+        const hookScriptPath = (0, skill_1.codexSyncHookScriptPath)();
+        const plan = (0, codex_hooks_1.planCodexHooksInstall)({ cliPath, hookScriptPath });
+        if (!options.dryRun)
+            (0, codex_hooks_1.installCodexHooks)({ cliPath, hookScriptPath });
+        results.push({
+            source: "codex",
+            status: options.dryRun ? "dry_run" : plan.hooks_changed || plan.config_changed ? "updated" : "unchanged",
+            hooks_path: plan.hooks_path,
+            config_path: plan.config_path,
+            hooks_changed: plan.hooks_changed,
+            config_changed: plan.config_changed,
+            session_start_command: plan.session_start_command,
+            stop_command: plan.stop_command,
+            next_hooks_contents: options.dryRun ? plan.next_hooks_contents : undefined,
+            next_config_contents: options.dryRun ? plan.next_config_contents : undefined,
+        });
+        humanLines.push("", `Codex (${options.dryRun ? "dry-run" : plan.hooks_changed || plan.config_changed ? "updated" : "unchanged"}):`, `  Hooks:  ${plan.hooks_path}`, `  Config: ${plan.config_path}`, `  SessionStart → wake: ${plan.session_start_command}`, `  Stop → sync:         ${plan.stop_command}`, options.dryRun ? "  (Also ensures [features].hooks = true in config.toml)" : "");
+    }
+    emit(options.json, {
+        status: "ok",
+        dry_run: options.dryRun,
+        cli_path: cliPath,
+        results,
+    }, () => humanLines.filter((line) => line !== "").join("\n"));
+    return 0;
+}

package/dist/local/leases.js

@@ -42,7 +42,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LeaseLostError = exports.SOURCE_LEASE = void 0;
+exports.LeaseLostError = exports.SYNC_WORKER_LEASE = exports.SOURCE_LEASE = void 0;
 exports.assertLeaseHeld = assertLeaseHeld;
 exports.renewLease = renewLease;
 exports.acquireLease = acquireLease;
@@ -57,6 +57,8 @@ const DEFAULT_TTL_MS = 30_000;
  * against this one lease so they never interleave writes.
  */
 exports.SOURCE_LEASE = "source";
+/** Election lease for the detached sync worker so only one worker runs at a time. */
+exports.SYNC_WORKER_LEASE = "sync-worker";
 /** Thrown when a write is attempted after the lease was lost/reclaimed. */
 class LeaseLostError extends Error {
     constructor(name) {