@letta-ai/dreams 0.0.1 → 0.0.3

package/README.md

@@ -15,38 +15,77 @@ npx @letta-ai/dreams@latest onboard --json
 
 1. verifies Node >= 22.13 through the bin preflight
 2. installs the exact CLI version under `~/.dreams/cli/<version>/`
-3. creates or preserves the stable launcher at `~/.dreams/bin/dreams`
+3. activates it through the stable launcher at `~/.dreams/bin/dreams`
 4. creates or preserves the installation id in `~/.dreams/installation.json`
-5. installs `~/.claude/skills/dreams-setup/SKILL.md`
+5. installs `~/.claude/skills/dreams-setup/` (skill + init snapshot template)
 6. initializes and migrates `~/.dreams/dreams.db`
-7. returns the next agent action based on authentication state
+7. returns a skill handoff (`status: "ready"`) with absolute `cli_path` and skill path
 
-It does not start login or `orient` itself. An unauthenticated response directs
-the agent to run `auth login` and then rerun `onboard`; an authenticated
-response directs the agent to run `orient`. Repeated calls are safe and return
-the same action until authentication state changes.
+It does **not** check authentication or choose login/orient next steps. The
+installed `dreams-setup` skill owns sequencing (authenticate → detect source →
+init snapshot → activate → test connection). Repeated `onboard` calls are safe
+and repair local setup only.
 
 ### Commands
 
-- `dreams onboard [--json]` — install or repair local setup and return the next
-  setup action.
-- `dreams status [--json]` — installation, durable CLI, SQLite, setup skill,
-  and authentication state.
+- `dreams onboard [--json]` — install or repair local setup and hand off to the
+  setup skill.
+- `dreams rollback [--json]` — reactivate the previous completed CLI version.
+- `dreams status [--json]` — installation, active and previous CLI versions,
+  SQLite, setup skill, and authentication state.
 - `dreams auth login [--json]` — OAuth device code sign-in (see Auth below).
 - `dreams auth status [--json]` — authentication state; tokens are masked
   (`at-let-…abcd`), never printed.
 - `dreams auth logout [--json]` — best-effort revoke of Dreams' refresh token,
   then clear stored credentials.
+- `dreams dev reset local [--confirm] [--json]` — preview or remove only local
+  SQLite and blob state.
+- `dreams dev reset identity [--confirm] [--json]` — preview or remove local
+  state, stored Dreams credentials, and the installation identity.
 
 Local state lives in `~/.dreams/`. Requires Node >= 22.13, where built-in
 `node:sqlite` no longer requires the `--experimental-sqlite` flag.
 
+### CLI upgrades and rollback
+
+Installed CLI versions are immutable under `~/.dreams/cli/<version>/`. The
+atomic `~/.dreams/cli/activation.json` record selects the active version and
+retains one previous version. The stable launcher reads that record rather than
+pointing directly at a version.
+
+Run `dreams rollback` to reactivate the previous completed version. The launcher
+also rolls back automatically when an active CLI cannot reach its startup
+readiness marker, then retries the original command once. Normal command errors
+after readiness, including invalid arguments, authentication failures, and
+network failures, never trigger rollback.
+
+### Development reset
+
+Development resets are preview-only until `--confirm` is provided. `local`
+removes `dreams.db`, its SQLite sidecars, and `~/.dreams/blobs/`; it preserves
+credentials and the installation identity. `identity` removes those local files
+plus Dreams' stored credentials and `installation.json`, so the next `onboard`
+mints a new device identity. Both scopes preserve installed CLI versions, the
+stable launcher, the setup skill, and every Cloud resource. Confirmed resets
+hold the same local-state lock as onboarding, auth, source, and upload commands,
+so they fail instead of deleting files another process is using. If
+`DREAMS_CREDENTIALS_BACKEND=file` is forced, identity reset clears the file and
+explicitly reports that the OS keychain was not checked.
+
+Test-workspace cleanup is intentionally not available through this local CLI.
+It is a separate internal Cloud operation with different credentials and data
+cleanup semantics. `dreams dev reset test-workspace` fails without deleting
+anything.
+
 ## Local sources (Claude Code)
 
 The CLI maintains a crash-safe local SQLite store (`~/.dreams/dreams.db`) that
 discovers Claude Code transcripts and prepares immutable upload segments before
 they are sent to Letta Cloud.
 
+- `dreams source detect [--json]` — detect Claude Code from harness filesystem
+  facts under `~/.claude` (no transcript reads) and register an installation-scoped
+  Cloud source in status `detected`. Idempotent; does not scan or upload.
 - `dreams source approve-root <path> [--json]` — approve a work root. Sources
   are **deny-by-default**: no transcript bytes are queued until their working
   directory is under an approved root.
@@ -57,8 +96,23 @@ they are sent to Letta Cloud.
   before anything is enqueued.
 - `dreams source list [--json]` — show the DB path, approved roots, sources, and
   the pending upload queue.
-- `dreams upload [--json]` — authenticate, register the source, and upload due
-  queue entries to Letta Cloud.
+- `dreams snapshots create --type <type> --file <path> --client-request-id <id> [--workspace-id <id>] [--json]`
+  — submit a skill-authored JSON snapshot (256 KiB UTF-8 object cap) to
+  `POST /v1/dreams/workspaces/{workspaceId}/snapshots`. Workspace defaults to the
+  local binding from `source detect`.
+- `dreams upload [--json]` — authenticate, refresh source registration, and
+  upload due queue entries. Upload accepts `detected` sources; Cloud promotes to
+  `active` after durable acceptance.
+- `dreams sync [--force] [--json]` — hook-safe scheduler: records a durable sync
+  trigger and runs a detached worker that live-scans tracked sessions and uploads
+  with a per-pass budget (~3h cadence unless `--force` or retry-due).
+- `dreams sync pause|resume|status [--json]` — pause makes hook wakes no-ops;
+  resume clears pause and requests one immediate sync.
+- `dreams backfill start --since <RFC3339> [--json]` — approve a frozen
+  `[since, until=now]` historical window and run one bounded local scan/queue
+  pass (session frontier, newest unfinished sessions first; no upload).
+  Re-running the same active `--since` is idempotent; a different active policy
+  fails closed. Sync drains live first, then backfill by newest session mtime.
 
 Local cursors track a `queued_through_offset` (advanced as segments are queued)
 separately from an `acked_offset` (advanced only after durable Cloud
@@ -127,20 +181,20 @@ npm test                        # build + node:test suite (uses a temp HOME)
 ## Testing the npx bootstrap via tarball (no publish)
 
 ```sh
-npm pack                     # produces letta-ai-dreams-0.0.1.tgz
+npm pack                     # produces letta-ai-dreams-0.0.3.tgz
 cd "$(mktemp -d)"
-npx -y -p /absolute/path/to/dreams/letta-ai-dreams-0.0.1.tgz dreams onboard
+npx -y -p /absolute/path/to/dreams/letta-ai-dreams-0.0.3.tgz dreams onboard
 ```
 
 (The `-p <tarball> dreams` form is required: a bare `npx <tarball>` treats the
 path as a script to execute, not a package to install.)
 
 `onboard` writes to `~/.dreams/` and installs
-`~/.claude/skills/dreams-setup/SKILL.md`. Set `HOME` to a temporary directory
-for a sandboxed run.
+`~/.claude/skills/dreams-setup/` (including the init snapshot template). Set
+`HOME` to a temporary directory for a sandboxed run.
 
 ## Deferred
 
-- `orient` and its Cloud-backed setup actions
-- Shared-memory generation and review
-- Automated source configuration and historical backfill
+- Shared-memory repository generation and review
+- Hook installation and default Dream schedule creation
+- `dreams backfill start` (skill optional background history import)

package/dist/auth/commands.js

@@ -7,8 +7,8 @@
  * {"status":"authenticated",…} object once the user approves in the browser.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandAuthLogin = commandAuthLogin;
 exports.renderAuthStatus = renderAuthStatus;
+exports.commandAuthLogin = commandAuthLogin;
 exports.commandAuthStatus = commandAuthStatus;
 exports.commandAuthLogout = commandAuthLogout;
 const browser_1 = require("./browser");
@@ -17,12 +17,13 @@ const index_1 = require("./index");
 const credentials_1 = require("./credentials");
 const oauth_refresh_1 = require("./oauth-refresh");
 const oauth_1 = require("./oauth");
+const state_lock_1 = require("../local/state-lock");
 /** `auth login` short-circuits when the stored token is valid for >7 days. */
 const REAUTH_MARGIN_MS = 7 * 24 * 60 * 60 * 1000;
 function printJsonLine(value) {
     console.log(JSON.stringify(value));
 }
-async function commandAuthLogin(json) {
+async function commandAuthLoginUnlocked(json) {
     const stored = (0, credentials_1.loadCredentials)();
     if (stored && stored.credentials.access_token && !(0, credentials_1.expiresWithin)(stored.credentials, REAUTH_MARGIN_MS)) {
         if (json) {
@@ -111,7 +112,7 @@ function renderAuthStatus(info) {
         `  Device id:    ${info.device_id}`,
     ].join("\n");
 }
-function commandAuthStatus(json) {
+function commandAuthStatusUnlocked(json) {
     const info = (0, index_1.authStatusInfo)();
     if (json) {
         console.log(JSON.stringify(info, null, 2));
@@ -121,7 +122,7 @@ function commandAuthStatus(json) {
     }
     return 0;
 }
-async function commandAuthLogout(json) {
+async function commandAuthLogoutUnlocked(json) {
     const stored = (0, credentials_1.loadCredentials)();
     if (!stored) {
         if (json)
@@ -139,3 +140,44 @@ async function commandAuthLogout(json) {
         console.log("Logged out: refresh token revoked and local credentials cleared.");
     return 0;
 }
+function stateBusy(json) {
+    const message = "Another Dreams command is using local state. Try again after it finishes.";
+    if (json)
+        printJsonLine({ status: "error", code: "local_state_busy", message });
+    else
+        process.stderr.write(message + "\n");
+    return 1;
+}
+async function commandAuthLogin(json) {
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return await commandAuthLoginUnlocked(json);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+function commandAuthStatus(json) {
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return commandAuthStatusUnlocked(json);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
+async function commandAuthLogout(json) {
+    const lock = (0, state_lock_1.acquireLocalStateLock)();
+    if (lock === null)
+        return stateBusy(json);
+    try {
+        return await commandAuthLogoutUnlocked(json);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}

package/dist/auth/credentials.js

@@ -108,15 +108,26 @@ function keychainRead(account) {
         return null; // no entry, or keychain unusable — fall through to file
     }
 }
-function keychainDelete(account) {
+function keychainDelete(account, strict) {
     const ctor = keyringCtor();
-    if (!ctor)
-        return;
+    if (!ctor) {
+        if (backendOverride() === "file")
+            return "not_checked_file_backend";
+        if (strict) {
+            throw new Error("Could not verify OS keychain cleanup because @napi-rs/keyring is unavailable. " +
+                "Rerun where keychain support is available.");
+        }
+        return "unavailable";
+    }
     try {
         new ctor(KEYCHAIN_SERVICE, account).deleteCredential();
+        return "cleared";
     }
-    catch {
-        // already gone or keychain unusable
+    catch (error) {
+        if (strict) {
+            throw new Error(`Could not clear Dreams credentials from the OS keychain: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return "unavailable";
     }
 }
 // --- file backend ------------------------------------------------------------
@@ -202,10 +213,19 @@ function saveCredentials(credentials) {
     fileWrite(credentials);
 }
 /** Clear both backends (login/logout/invalid_grant paths). */
-function clearCredentials() {
-    keychainDelete(REFRESH_ACCOUNT);
-    keychainDelete(ACCESS_ACCOUNT);
+function clearCredentials(options = {}) {
+    const strict = options.strictKeychain === true;
+    const refresh = keychainDelete(REFRESH_ACCOUNT, strict);
+    const access = keychainDelete(ACCESS_ACCOUNT, strict);
     fs.rmSync(credentialsFilePath(), { force: true });
+    return {
+        file: "cleared",
+        keychain: refresh === "not_checked_file_backend" || access === "not_checked_file_backend"
+            ? "not_checked_file_backend"
+            : refresh === "cleared" && access === "cleared"
+                ? "cleared"
+                : "unavailable",
+    };
 }
 function expiresWithin(credentials, marginMs = exports.EXPIRY_MARGIN_MS) {
     const at = Date.parse(credentials.expires_at);

package/dist/cli.js

@@ -4,47 +4,146 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const index_1 = require("./auth/index");
 const commands_1 = require("./auth/commands");
+const development_reset_1 = require("./development-reset");
 const commands_2 = require("./local/commands");
 const db_1 = require("./local/db");
+const state_lock_1 = require("./local/state-lock");
+const launcher_1 = require("./launcher");
 const managed_install_1 = require("./managed-install");
 const onboard_1 = require("./onboard");
+const snapshots_1 = require("./snapshots");
 const skill_1 = require("./skill");
 const store_1 = require("./store");
+const backfill_1 = require("./local/backfill");
+const sync_1 = require("./sync");
 const version_1 = require("./version");
 const USAGE = `Usage: dreams <command> [options]
 
 Commands:
-  onboard                    Install Dreams locally and return the next setup action
+  onboard                    Install Dreams locally and hand off to the setup skill
+  rollback                   Reactivate the previous installed CLI version
   status                     Show installation, skill, CLI, database, and auth state
   auth login                 Connect this device to Letta (OAuth device code flow)
   auth status                Show authentication state (never prints tokens)
   auth logout                Revoke Dreams' refresh token and clear stored credentials
+  dev reset local            Preview/reset local SQLite and blob state
+  dev reset identity         Preview/reset local state, credentials, and device identity
+  source detect              Detect Claude Code and register a detected Cloud source
   source scan                Discover Claude Code sessions and build the local upload queue
   source approve-root <path> Approve a work root so its transcripts become eligible
   source list                Show local sources, approved roots, and the pending queue
+  snapshots create           Submit a skill-authored snapshot JSON file to Cloud
+  sync                       Schedule a hook-safe sync worker (live then active backfill)
+  sync pause|resume|status   Pause/resume hooks or show sync diagnostics
+  backfill start             Queue a bounded historical backfill window (local only)
   upload                     Upload pending queued objects to Letta Cloud
 
 Options:
-  --json     Machine-readable JSON output
-  --version  Print the CLI version
-  --help     Show this help
+  --json                 Machine-readable JSON output
+  --confirm              Apply a development reset preview
+  --force                Bypass sync cadence (never bypasses pause/privacy)
+  --source <type>        Sync source adapter (claude-code default; codex)
+  --since <RFC3339>      Backfill window start (with backfill start)
+  --type <type>          Snapshot type (with snapshots create)
+  --file <path>          Snapshot JSON file (with snapshots create)
+  --client-request-id <id>  Idempotency key (with snapshots create)
+  --workspace-id <id>    Override workspace id (defaults to local binding)
+  --version              Print the CLI version
+  --help                 Show this help
 `;
-const COMMANDS_WITH_SUBCOMMANDS = new Set(["auth", "source"]);
+const COMMANDS_WITH_SUBCOMMANDS = new Set(["auth", "dev", "source", "snapshots", "sync", "backfill"]);
 function parseArgs(argv) {
     const parsed = {
         positionals: [],
         json: false,
+        confirm: false,
         help: false,
         version: false,
+        force: false,
+        worker: false,
+        source: undefined,
+        since: undefined,
+        type: undefined,
+        file: undefined,
+        clientRequestId: undefined,
+        workspaceId: undefined,
         unknown: [],
     };
-    for (const arg of argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
         if (arg === "--json")
             parsed.json = true;
+        else if (arg === "--confirm")
+            parsed.confirm = true;
+        else if (arg === "--force")
+            parsed.force = true;
+        else if (arg === "--worker")
+            parsed.worker = true;
+        else if (arg === "--source") {
+            const value = argv[++i];
+            if (value === undefined || value.trim() === "")
+                parsed.unknown.push("--source");
+            else
+                parsed.source = value;
+        }
+        else if (arg.startsWith("--source=")) {
+            const value = arg.slice("--source=".length);
+            if (value.trim() === "")
+                parsed.unknown.push("--source=");
+            else
+                parsed.source = value;
+        }
         else if (arg === "--help" || arg === "-h")
             parsed.help = true;
         else if (arg === "--version" || arg === "-v")
             parsed.version = true;
+        else if (arg === "--since") {
+            const value = argv[++i];
+            if (value === undefined)
+                parsed.unknown.push("--since");
+            else
+                parsed.since = value;
+        }
+        else if (arg.startsWith("--since="))
+            parsed.since = arg.slice("--since=".length);
+        else if (arg === "--type") {
+            const value = argv[++i];
+            if (value === undefined)
+                parsed.unknown.push("--type");
+            else
+                parsed.type = value;
+        }
+        else if (arg.startsWith("--type="))
+            parsed.type = arg.slice("--type=".length);
+        else if (arg === "--file") {
+            const value = argv[++i];
+            if (value === undefined)
+                parsed.unknown.push("--file");
+            else
+                parsed.file = value;
+        }
+        else if (arg.startsWith("--file="))
+            parsed.file = arg.slice("--file=".length);
+        else if (arg === "--client-request-id") {
+            const value = argv[++i];
+            if (value === undefined)
+                parsed.unknown.push("--client-request-id");
+            else
+                parsed.clientRequestId = value;
+        }
+        else if (arg.startsWith("--client-request-id=")) {
+            parsed.clientRequestId = arg.slice("--client-request-id=".length);
+        }
+        else if (arg === "--workspace-id") {
+            const value = argv[++i];
+            if (value === undefined)
+                parsed.unknown.push("--workspace-id");
+            else
+                parsed.workspaceId = value;
+        }
+        else if (arg.startsWith("--workspace-id=")) {
+            parsed.workspaceId = arg.slice("--workspace-id=".length);
+        }
         else if (arg.startsWith("-"))
             parsed.unknown.push(arg);
         else
@@ -52,14 +151,17 @@ function parseArgs(argv) {
     }
     return parsed;
 }
-function commandStatus(json) {
+function commandStatusUnlocked(json) {
     const installation = (0, store_1.loadOrCreateInstallation)();
     const auth = (0, index_1.authStatusInfo)();
+    const activation = (0, launcher_1.readActivation)();
     const status = {
         installation_id: installation.installation_id,
         installation_created_at: installation.created_at,
         state: auth.authenticated ? "authenticated" : "unauthenticated",
         cli_path: (0, managed_install_1.stableCliPath)(),
+        active_cli_version: activation?.active_version ?? null,
+        previous_cli_version: activation?.previous_version ?? null,
         database_path: (0, db_1.dbFilePath)(),
         skill_version: (0, skill_1.installedSkillVersion)(),
         skill_path: (0, skill_1.skillFilePath)(),
@@ -72,7 +174,7 @@ function commandStatus(json) {
     else {
         const authLine = auth.authenticated
             ? `yes (via ${auth.source}, token ${auth.access_token ?? "pending refresh"}${auth.expires_at ? `, expires ${auth.expires_at}` : ""})`
-            : "no (run `dreams onboard`)";
+            : "no (run `dreams auth login`)";
         console.log([
             "Dreams status",
             "",
@@ -80,6 +182,8 @@ function commandStatus(json) {
             `  Created at:      ${status.installation_created_at}`,
             `  State:           ${status.state}`,
             `  Durable CLI:     ${status.cli_path}`,
+            `  Active version:  ${status.active_cli_version ?? "(not activated)"}`,
+            `  Previous version:${status.previous_cli_version ? ` ${status.previous_cli_version}` : " (none)"}`,
             `  Skill installed: ${status.skill_version ? `v${status.skill_version} at ${status.skill_path}` : "no"}`,
             `  Authenticated:   ${authLine}`,
             `  Database:        ${status.database_path}`,
@@ -88,6 +192,23 @@ function commandStatus(json) {
     }
     return 0;
 }
+async function commandStatus(json) {
+    const lock = await (0, state_lock_1.waitForLocalStateLock)();
+    if (lock === null) {
+        const message = "Another Dreams command is using local state. Try again after it finishes.";
+        if (json)
+            console.log(JSON.stringify({ status: "error", code: "local_state_busy", message }));
+        else
+            process.stderr.write(message + "\n");
+        return 1;
+    }
+    try {
+        return commandStatusUnlocked(json);
+    }
+    finally {
+        (0, state_lock_1.releaseLocalStateLock)(lock);
+    }
+}
 function commandAuth(subcommand, json) {
     switch (subcommand) {
         case "login":
@@ -101,6 +222,17 @@ function commandAuth(subcommand, json) {
             return 1;
     }
 }
+function commandDevelopment(positionals, confirmed, json) {
+    if (positionals[1] !== "reset") {
+        process.stderr.write(`Unknown dev subcommand: ${positionals[1] ?? "(none)"} — expected reset\n\n${USAGE}`);
+        return 1;
+    }
+    if (positionals.length > 3) {
+        process.stderr.write(`Unexpected argument(s): ${positionals.slice(3).join(", ")}\n\n${USAGE}`);
+        return 1;
+    }
+    return (0, development_reset_1.commandDevelopmentReset)(positionals[2], confirmed, json);
+}
 async function runCli() {
     const args = parseArgs(process.argv.slice(2));
     const command = args.positionals[0];
@@ -113,6 +245,26 @@ async function runCli() {
         process.stdout.write(USAGE);
         return args.help ? 0 : 1;
     }
+    if (args.confirm && (command !== "dev" || subcommand !== "reset")) {
+        process.stderr.write(`--confirm is only valid with \`dreams dev reset\`\n\n${USAGE}`);
+        return 1;
+    }
+    if ((args.type || args.file || args.clientRequestId || args.workspaceId) && command !== "snapshots") {
+        process.stderr.write(`Snapshot options are only valid with \`dreams snapshots create\`\n\n${USAGE}`);
+        return 1;
+    }
+    if ((args.force || args.worker) && command !== "sync") {
+        process.stderr.write(`--force/--worker are only valid with \`dreams sync\`\n\n${USAGE}`);
+        return 1;
+    }
+    if (args.source && command !== "sync") {
+        process.stderr.write(`--source is only valid with \`dreams sync\`\n\n${USAGE}`);
+        return 1;
+    }
+    if (args.since && command !== "backfill") {
+        process.stderr.write(`--since is only valid with \`dreams backfill start\`\n\n${USAGE}`);
+        return 1;
+    }
     if (args.unknown.length > 0) {
         process.stderr.write(`Unknown argument(s): ${args.unknown.join(", ")}\n\n${USAGE}`);
         return 1;
@@ -122,15 +274,52 @@ async function runCli() {
         process.stderr.write(`Unexpected argument(s): ${args.positionals.slice(1).join(", ")}\n\n${USAGE}`);
         return 1;
     }
+    if (command === "snapshots" && args.positionals.length > 2) {
+        process.stderr.write(`Unexpected argument(s): ${args.positionals.slice(2).join(", ")}\n\n${USAGE}`);
+        return 1;
+    }
+    if (command === "sync" && args.positionals.length > 2) {
+        process.stderr.write(`Unexpected argument(s): ${args.positionals.slice(2).join(", ")}\n\n${USAGE}`);
+        return 1;
+    }
+    if (command === "backfill" && args.positionals.length > 2) {
+        process.stderr.write(`Unexpected argument(s): ${args.positionals.slice(2).join(", ")}\n\n${USAGE}`);
+        return 1;
+    }
     switch (command) {
         case "onboard":
             return (0, onboard_1.commandOnboard)(args.json);
+        case "rollback":
+            return (0, launcher_1.commandRollback)(args.json);
         case "status":
             return commandStatus(args.json);
         case "auth":
             return commandAuth(subcommand, args.json);
+        case "dev":
+            return commandDevelopment(args.positionals, args.confirm, args.json);
         case "source":
             return (0, commands_2.commandSource)(subcommand, args.positionals[2], args.json);
+        case "snapshots":
+            return (0, snapshots_1.commandSnapshots)(subcommand, {
+                type: args.type,
+                file: args.file,
+                clientRequestId: args.clientRequestId,
+                workspaceId: args.workspaceId,
+                json: args.json,
+            });
+        case "sync":
+            return (0, sync_1.commandSync)(subcommand, {
+                json: args.json,
+                force: args.force,
+                worker: args.worker,
+                sourceType: args.source,
+            });
+        case "backfill":
+            if (subcommand !== "start") {
+                process.stderr.write(`Unknown backfill subcommand: ${subcommand ?? "(none)"} — expected start\n\n${USAGE}`);
+                return 1;
+            }
+            return (0, backfill_1.commandBackfillStart)({ since: args.since, json: args.json });
         case "upload":
             return (0, commands_2.commandUpload)(args.json);
         default:
@@ -139,6 +328,7 @@ async function runCli() {
     }
 }
 function main() {
+    (0, launcher_1.signalLauncherReady)();
     runCli().then((code) => process.exit(code), (error) => {
         process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
         process.exit(1);