@letta-ai/dreams 0.0.3 → 0.0.4

package/dist/local/codex.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Codex source adapter — discovery and harness detection ([LET-10314]).
+ * Codex source adapter — discovery and harness detection ([LET-10314] / [LET-10317]).
  *
  * On-disk layout (fail closed when unrecognized):
  *   ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<sessionId>.jsonl
@@ -18,7 +18,8 @@
  *    `codex-rs/hooks/schema/generated/session-start.command.input.schema.json`)
  * Pin: https://github.com/openai/codex/tree/fb6aad9ae34116128e537696c24e35fe6548e1c2
  *
- * Subagent rollouts are skipped. Paths stay private to this module.
+ * Subagent rollouts are skipped. Classification shares one path with discovery
+ * so status diagnostics and ingest agree. Paths stay private to this module.
  * Registration lives in `source-adapters.ts` (not the default).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -59,6 +60,8 @@ exports.codexSourceAdapter = exports.CODEX_DISPLAY_NAME = exports.CODEX_SOURCE_I
 exports.codexSessionsDir = codexSessionsDir;
 exports.validateCodexSessionId = validateCodexSessionId;
 exports.detectCodexHarness = detectCodexHarness;
+exports.classifyCodexRollout = classifyCodexRollout;
+exports.inspectCodexDiscovery = inspectCodexDiscovery;
 exports.discoverSessions = discoverSessions;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
@@ -74,6 +77,9 @@ const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 const HEAD_READ_BYTES = 256 * 1024;
 /** Timestamp uses hyphens instead of colons: YYYY-MM-DDTHH-MM-SS. */
 const ROLLOUT_RE = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([A-Za-z0-9][A-Za-z0-9_-]{0,127})\.jsonl$/;
+/** Broader candidate gate for diagnostics — drifted names still count as candidates. */
+const ROLLOUT_CANDIDATE_RE = /^rollout-.*\.jsonl$/i;
+const MAX_EXAMPLES = 5;
 function codexSessionsDir() {
     return path.join(os.homedir(), ".codex", "sessions");
 }
@@ -116,27 +122,43 @@ function detectCodexHarness(home = os.homedir()) {
     }
     return { present: true, evidence };
 }
-function readFirstRecord(filePath) {
+function readFirstRecordDetailed(filePath) {
     let fd;
     try {
         fd = fs.openSync(filePath, "r");
         const buf = Buffer.alloc(HEAD_READ_BYTES);
         const read = fs.readSync(fd, buf, 0, HEAD_READ_BYTES, 0);
+        if (read === 0)
+            return { ok: false, reason: "empty" };
         const head = buf.subarray(0, read);
         const nl = head.indexOf(0x0a);
-        if (nl === -1)
-            return null;
-        const line = head.subarray(0, nl).toString("utf8").trim();
+        const lineBytes = nl === -1 ? head : head.subarray(0, nl);
+        const line = lineBytes.toString("utf8").trim();
         if (line === "")
-            return null;
-        return JSON.parse(line);
+            return { ok: false, reason: "empty" };
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                return { ok: false, reason: "unsupported_metadata" };
+            }
+            return { ok: true, record: parsed };
+        }
+        catch {
+            return { ok: false, reason: "malformed_json" };
+        }
     }
     catch {
-        return null;
+        return { ok: false, reason: "unreadable" };
     }
     finally {
-        if (fd !== undefined)
-            fs.closeSync(fd);
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
     }
 }
 function isSubagentMeta(payload) {
@@ -158,36 +180,119 @@ function statSignals(filePath) {
     const mtime = Number.isFinite(stat.mtimeMs) ? Math.floor(stat.mtimeMs) : null;
     return { size: stat.size, inode, birthtime_ms: birthtime, mtime_ms: mtime };
 }
+function homeRelative(filePath, home = os.homedir()) {
+    const homeReal = (() => {
+        try {
+            return (0, config_1.canonicalize)(home);
+        }
+        catch {
+            return path.resolve(home);
+        }
+    })();
+    const fileReal = (() => {
+        try {
+            return (0, config_1.canonicalize)(filePath);
+        }
+        catch {
+            return path.resolve(filePath);
+        }
+    })();
+    if (fileReal === homeReal || fileReal.startsWith(homeReal + path.sep)) {
+        return path.join("~", path.relative(homeReal, fileReal));
+    }
+    return path.basename(filePath);
+}
 /**
- * Enumerate top-level Codex rollout files. Malformed, truncated, escaped,
- * identity-mismatched, and subagent files are skipped (fail closed).
- *
- * Optional `sessionsDir` is Codex-private (tests / direct callers).
+ * Classify one rollout candidate. Shared by discovery ingest and status
+ * diagnostics — a "supported" result is exactly what `discoverSessions` emits.
  */
-function discoverSessions(sessionsDir = codexSessionsDir()) {
-    const sessions = [];
-    let rootReal;
+function classifyCodexRollout(filePath, filenameId, options) {
+    const basename = path.basename(filePath);
+    const relative_path = homeRelative(filePath, options.home);
+    if (!validateCodexSessionId(filenameId)) {
+        return { kind: "unsupported", reason: "invalid_session_id", basename, relative_path };
+    }
+    let realPath;
     try {
-        rootReal = (0, config_1.canonicalize)(sessionsDir);
-        if (!fs.statSync(rootReal).isDirectory())
-            return sessions;
+        realPath = (0, config_1.canonicalize)(filePath);
     }
     catch {
-        return sessions;
+        return { kind: "unsupported", reason: "unreadable", basename, relative_path };
+    }
+    if (!underRoot(options.sessionsRootReal, realPath)) {
+        return { kind: "excluded", reason: "escaped_path", basename, relative_path };
+    }
+    const first = readFirstRecordDetailed(filePath);
+    if (!first.ok) {
+        return { kind: "unsupported", reason: first.reason, basename, relative_path };
+    }
+    const record = first.record;
+    if (record.type !== "session_meta") {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    const payload = record.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    const meta = payload;
+    if (isSubagentMeta(meta)) {
+        return { kind: "excluded", reason: "subagent", basename, relative_path };
+    }
+    const sessionId = typeof meta.id === "string" ? meta.id : typeof meta.session_id === "string" ? meta.session_id : null;
+    if (!sessionId) {
+        return { kind: "unsupported", reason: "unsupported_metadata", basename, relative_path };
+    }
+    if (sessionId !== filenameId) {
+        return { kind: "unsupported", reason: "session_id_mismatch", basename, relative_path };
     }
+    if (typeof meta.session_id === "string" && typeof meta.id === "string" && meta.session_id !== meta.id) {
+        return { kind: "unsupported", reason: "session_id_mismatch", basename, relative_path };
+    }
+    if (!validateCodexSessionId(sessionId)) {
+        return { kind: "unsupported", reason: "invalid_session_id", basename, relative_path };
+    }
+    let cwd = null;
+    if (typeof meta.cwd === "string") {
+        try {
+            cwd = (0, config_1.canonicalize)(meta.cwd);
+        }
+        catch {
+            cwd = null;
+        }
+    }
+    try {
+        const signals = statSignals(filePath);
+        return {
+            kind: "supported",
+            session: {
+                path: filePath,
+                real_path: realPath,
+                session_id: sessionId,
+                cwd,
+                size: signals.size,
+                inode: signals.inode,
+                birthtime_ms: signals.birthtime_ms,
+                mtime_ms: signals.mtime_ms,
+                first_chunk_fp: (0, transcript_bytes_1.firstChunkFingerprint)(filePath),
+            },
+        };
+    }
+    catch {
+        return { kind: "unsupported", reason: "unreadable", basename, relative_path };
+    }
+}
+function* walkRolloutCandidates(sessionsRootReal) {
     let yearEntries;
     try {
-        yearEntries = fs.readdirSync(rootReal, { withFileTypes: true });
+        yearEntries = fs.readdirSync(sessionsRootReal, { withFileTypes: true });
     }
     catch {
-        return sessions;
+        return;
     }
     for (const yearEntry of yearEntries) {
-        if (!yearEntry.isDirectory())
-            continue;
-        if (!/^\d{4}$/.test(yearEntry.name))
+        if (!yearEntry.isDirectory() || !/^\d{4}$/.test(yearEntry.name))
             continue;
-        const yearDir = path.join(rootReal, yearEntry.name);
+        const yearDir = path.join(sessionsRootReal, yearEntry.name);
         let monthEntries;
         try {
             monthEntries = fs.readdirSync(yearDir, { withFileTypes: true });
@@ -196,9 +301,7 @@ function discoverSessions(sessionsDir = codexSessionsDir()) {
             continue;
         }
         for (const monthEntry of monthEntries) {
-            if (!monthEntry.isDirectory())
-                continue;
-            if (!/^\d{2}$/.test(monthEntry.name))
+            if (!monthEntry.isDirectory() || !/^\d{2}$/.test(monthEntry.name))
                 continue;
             const monthDir = path.join(yearDir, monthEntry.name);
             let dayEntries;
@@ -209,9 +312,7 @@ function discoverSessions(sessionsDir = codexSessionsDir()) {
                 continue;
             }
             for (const dayEntry of dayEntries) {
-                if (!dayEntry.isDirectory())
-                    continue;
-                if (!/^\d{2}$/.test(dayEntry.name))
+                if (!dayEntry.isDirectory() || !/^\d{2}$/.test(dayEntry.name))
                     continue;
                 const dayDir = path.join(monthDir, dayEntry.name);
                 let files;
@@ -224,80 +325,176 @@ function discoverSessions(sessionsDir = codexSessionsDir()) {
                 for (const file of files) {
                     if (!file.isFile())
                         continue;
-                    const match = ROLLOUT_RE.exec(file.name);
-                    if (!match)
-                        continue;
-                    const filenameId = match[1];
-                    if (!validateCodexSessionId(filenameId))
+                    if (!ROLLOUT_CANDIDATE_RE.test(file.name))
                         continue;
-                    const filePath = path.join(dayDir, file.name);
-                    try {
-                        let realPath;
-                        try {
-                            realPath = (0, config_1.canonicalize)(filePath);
-                        }
-                        catch {
-                            continue;
-                        }
-                        if (!underRoot(rootReal, realPath))
-                            continue;
-                        const record = readFirstRecord(filePath);
-                        if (!record)
-                            continue;
-                        if (record.type !== "session_meta")
-                            continue;
-                        const payload = record.payload;
-                        if (!payload || typeof payload !== "object" || Array.isArray(payload))
-                            continue;
-                        const meta = payload;
-                        if (isSubagentMeta(meta))
-                            continue;
-                        // Prefer payload.id; accept payload.session_id when present (same ThreadId).
-                        const sessionId = typeof meta.id === "string"
-                            ? meta.id
-                            : typeof meta.session_id === "string"
-                                ? meta.session_id
-                                : null;
-                        if (!sessionId || sessionId !== filenameId)
-                            continue;
-                        if (typeof meta.session_id === "string" &&
-                            typeof meta.id === "string" &&
-                            meta.session_id !== meta.id) {
-                            continue;
-                        }
-                        if (!validateCodexSessionId(sessionId))
-                            continue;
-                        let cwd = null;
-                        if (typeof meta.cwd === "string") {
-                            try {
-                                cwd = (0, config_1.canonicalize)(meta.cwd);
-                            }
-                            catch {
-                                // Unresolvable cwd → discover but deny-by-default at policy gate.
-                                cwd = null;
-                            }
-                        }
-                        const signals = statSignals(filePath);
-                        sessions.push({
-                            path: filePath,
-                            real_path: realPath,
-                            session_id: sessionId,
-                            cwd,
-                            size: signals.size,
-                            inode: signals.inode,
-                            birthtime_ms: signals.birthtime_ms,
-                            mtime_ms: signals.mtime_ms,
-                            first_chunk_fp: (0, transcript_bytes_1.firstChunkFingerprint)(filePath),
-                        });
+                    const match = ROLLOUT_RE.exec(file.name);
+                    if (match) {
+                        yield { filePath: path.join(dayDir, file.name), filenameId: match[1], supportedName: true };
                     }
-                    catch {
-                        // Fail closed for this candidate only — never abort the whole pass.
-                        continue;
+                    else {
+                        yield { filePath: path.join(dayDir, file.name), filenameId: null, supportedName: false };
                     }
                 }
             }
         }
     }
+}
+function actionableDriftMessage() {
+    return [
+        "Codex rollout files were found but none use a supported format.",
+        "Repair/upgrade with `npx @letta-ai/dreams@latest onboard --json`, then rerun `dreams sync status --source codex --json`.",
+        "If still unsupported, preserve a sample rollout basename and report the new format.",
+    ].join(" ");
+}
+/**
+ * Walk Codex rollout candidates and classify each. Never throws for bad files.
+ */
+function inspectCodexDiscovery(sessionsDir = codexSessionsDir(), home = os.homedir()) {
+    const harness = detectCodexHarness(home);
+    const by_reason = {};
+    const examples = [];
+    let candidates = 0;
+    let supported = 0;
+    let unsupported = 0;
+    let excluded_subagent = 0;
+    let excluded_other = 0;
+    if (!harness.present) {
+        return {
+            harness_present: false,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "absent",
+            message: "Codex was not detected under ~/.codex",
+        };
+    }
+    let sessionsRootReal;
+    let sessionsDirPresent = false;
+    try {
+        sessionsRootReal = (0, config_1.canonicalize)(sessionsDir);
+        sessionsDirPresent = fs.statSync(sessionsRootReal).isDirectory();
+    }
+    catch {
+        return {
+            harness_present: true,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "empty",
+            message: "Codex is present but no sessions directory was found",
+        };
+    }
+    if (!sessionsDirPresent) {
+        return {
+            harness_present: true,
+            sessions_dir_present: false,
+            candidates: 0,
+            supported: 0,
+            unsupported: 0,
+            excluded_subagent: 0,
+            excluded_other: 0,
+            by_reason: {},
+            examples: [],
+            status: "empty",
+            message: "Codex is present but no sessions directory was found",
+        };
+    }
+    for (const { filePath, filenameId, supportedName } of walkRolloutCandidates(sessionsRootReal)) {
+        candidates++;
+        const result = supportedName
+            ? classifyCodexRollout(filePath, filenameId, { sessionsRootReal, home })
+            : {
+                kind: "unsupported",
+                reason: "invalid_session_id",
+                basename: path.basename(filePath),
+                relative_path: homeRelative(filePath, home),
+            };
+        if (result.kind === "supported") {
+            supported++;
+            continue;
+        }
+        if (result.kind === "excluded") {
+            if (result.reason === "subagent")
+                excluded_subagent++;
+            else
+                excluded_other++;
+            continue;
+        }
+        unsupported++;
+        by_reason[result.reason] = (by_reason[result.reason] ?? 0) + 1;
+        if (examples.length < MAX_EXAMPLES) {
+            examples.push({
+                reason: result.reason,
+                basename: result.basename,
+                relative_path: result.relative_path,
+            });
+        }
+    }
+    let status = "ok";
+    let message = null;
+    if (candidates === 0) {
+        status = "empty";
+        message = "Codex is present but no rollout files were found";
+    }
+    else if (supported === 0 && unsupported > 0) {
+        status = "warning";
+        message = actionableDriftMessage();
+    }
+    else if (supported > 0 && unsupported > 0) {
+        status = "warning";
+        message =
+            "Some Codex rollout files use an unsupported format and were skipped. " +
+                "Rerun `dreams sync status --source codex --json` after upgrading Dreams; " +
+                "supported sessions continue to sync.";
+    }
+    return {
+        harness_present: true,
+        sessions_dir_present: true,
+        candidates,
+        supported,
+        unsupported,
+        excluded_subagent,
+        excluded_other,
+        by_reason,
+        examples,
+        status,
+        message,
+    };
+}
+/**
+ * Enumerate top-level Codex rollout files. Malformed, truncated, escaped,
+ * identity-mismatched, and subagent files are skipped (fail closed).
+ *
+ * Optional `sessionsDir` is Codex-private (tests / direct callers).
+ */
+function discoverSessions(sessionsDir = codexSessionsDir()) {
+    const sessions = [];
+    let rootReal;
+    try {
+        rootReal = (0, config_1.canonicalize)(sessionsDir);
+        if (!fs.statSync(rootReal).isDirectory())
+            return sessions;
+    }
+    catch {
+        return sessions;
+    }
+    for (const { filePath, filenameId, supportedName } of walkRolloutCandidates(rootReal)) {
+        if (!supportedName || filenameId === null)
+            continue;
+        const result = classifyCodexRollout(filePath, filenameId, { sessionsRootReal: rootReal });
+        if (result.kind === "supported")
+            sessions.push(result.session);
+    }
     sessions.sort((a, b) => a.path.localeCompare(b.path));
     return sessions;
 }

package/dist/local/commands.js

@@ -51,7 +51,7 @@ function maxRecordBytesOverride() {
     const value = Number(raw);
     return Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
-function commandSourceScanUnlocked(json) {
+function commandSourceScanUnlocked(json, adapter) {
     const { db, installationId } = open();
     try {
         const owner = (0, leases_1.acquireLease)(db, leases_1.SOURCE_LEASE);
@@ -64,7 +64,7 @@ function commandSourceScanUnlocked(json) {
             summary = (0, scan_1.reconcile)(db, {
                 installationId,
                 leaseOwner: owner,
-                adapter: (0, source_adapters_1.defaultSourceAdapter)(),
+                adapter,
                 maxSegmentBytes: maxSegmentBytesOverride(),
                 maxRecordBytes: maxRecordBytesOverride(),
             });
@@ -90,7 +90,7 @@ function commandSourceScanUnlocked(json) {
         (0, db_1.closeDb)();
     }
 }
-async function commandUploadUnlocked(json) {
+async function commandUploadUnlocked(json, adapter) {
     const { db, installationId } = open();
     try {
         const owner = (0, leases_1.acquireLease)(db, leases_1.SOURCE_LEASE);
@@ -103,7 +103,7 @@ async function commandUploadUnlocked(json) {
             summary = await (0, upload_1.runUpload)(db, {
                 installationId,
                 leaseOwner: owner,
-                adapter: (0, source_adapters_1.defaultSourceAdapter)(),
+                adapter,
             });
         }
         finally {
@@ -132,13 +132,13 @@ async function commandUploadUnlocked(json) {
 }
 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 {
@@ -153,13 +153,20 @@ function commandSourceListUnlocked(json) {
             .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;
     }
@@ -167,12 +174,12 @@ function commandSourceListUnlocked(json) {
         (0, db_1.closeDb)();
     }
 }
-async function commandSourceDetectUnlocked(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.");
+            emit(json, { status: "busy", reason: "another source operation holds the local lease" }, () => "Another Dreams source operation is in progress; skipping.");
             return 0;
         }
         let result;
@@ -180,7 +187,7 @@ async function commandSourceDetectUnlocked(json) {
             result = await (0, detect_1.runSourceDetect)(db, {
                 installationId,
                 leaseOwner: owner,
-                adapter: (0, source_adapters_1.defaultSourceAdapter)(),
+                adapter,
             });
         }
         finally {
@@ -207,23 +214,25 @@ 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) {
+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);
+        return commandSourceScanUnlocked(json, adapter);
     }
     finally {
         (0, state_lock_1.releaseLocalStateLock)(lock);
     }
 }
-async function commandUpload(json) {
+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);
+        return await commandUploadUnlocked(json, adapter);
     }
     finally {
         (0, state_lock_1.releaseLocalStateLock)(lock);
@@ -251,29 +260,35 @@ function commandSourceList(json) {
         (0, state_lock_1.releaseLocalStateLock)(lock);
     }
 }
-async function commandSourceDetect(json) {
+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);
+        return await commandSourceDetectUnlocked(json, adapter);
     }
     finally {
         (0, state_lock_1.releaseLocalStateLock)(lock);
     }
 }
-function commandSource(subcommand, positional, json) {
+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);
+            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 detect, 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

@@ -252,6 +252,10 @@ const MIGRATIONS = [
             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) {