lody 0.67.3 → 0.68.0

package/dist/index.js

@@ -4188,7 +4188,7 @@ let __tla = Promise.all([
     }
   }
   const name$1 = "lody";
-  const version$3 = "0.67.3";
+  const version$3 = "0.68.0";
   const description$1 = "Lody Agent CLI tool for managing remote command execution";
   const type$2 = "module";
   const main$4 = "dist/index.js";
@@ -4534,6 +4534,274 @@ let __tla = Promise.all([
     return void 0;
   };
   const isBuiltinAgentType = (agentType) => agentType === "claude" || agentType === "codex";
+  const CODEX_STATIC_MODES = [
+    {
+      id: "read-only",
+      name: "Read-only",
+      description: "Requires approval to edit files and run commands."
+    },
+    {
+      id: "agent",
+      name: "Agent",
+      description: "Read and edit files, and run commands."
+    },
+    {
+      id: "agent-full-access",
+      name: "Agent (full access)",
+      description: "Codex can edit files outside this workspace and run commands with network access. Exercise caution when using."
+    }
+  ];
+  const CODEX_STATIC_MODELS = [
+    {
+      modelId: "gpt-5.5",
+      name: "gpt-5.5",
+      description: "Latest frontier Codex model"
+    },
+    {
+      modelId: "gpt-5.4",
+      name: "gpt-5.4",
+      description: "Frontier Codex model"
+    },
+    {
+      modelId: "gpt-5.4-mini",
+      name: "gpt-5.4-mini",
+      description: "Smaller, faster Codex model"
+    }
+  ];
+  const CODEX_REASONING_OPTIONS = [
+    {
+      value: "low",
+      name: "low",
+      description: "Fastest responses"
+    },
+    {
+      value: "medium",
+      name: "medium",
+      description: "Balanced reasoning"
+    },
+    {
+      value: "high",
+      name: "high",
+      description: "More reasoning for difficult tasks"
+    },
+    {
+      value: "xhigh",
+      name: "xhigh",
+      description: "Extra reasoning for complex tasks"
+    }
+  ];
+  const CODEX_STATIC_CONFIG_OPTIONS = [
+    {
+      id: "mode",
+      name: "Mode",
+      description: "Approval and sandboxing preset for the session",
+      category: "mode",
+      type: "select",
+      currentValue: "agent",
+      options: CODEX_STATIC_MODES.map((mode2) => ({
+        value: mode2.id,
+        name: mode2.name,
+        description: mode2.description ?? void 0
+      }))
+    },
+    {
+      id: "model",
+      name: "Model",
+      description: "Model Codex uses for the session",
+      category: "model",
+      type: "select",
+      currentValue: "gpt-5.5",
+      options: CODEX_STATIC_MODELS.map((model) => ({
+        value: model.modelId,
+        name: model.name,
+        description: model.description ?? void 0
+      }))
+    },
+    {
+      id: "reasoning_effort",
+      name: "Reasoning effort",
+      description: "How much reasoning effort the model should use",
+      category: "thought_level",
+      type: "select",
+      currentValue: "medium",
+      options: CODEX_REASONING_OPTIONS
+    },
+    {
+      id: "fast-mode",
+      name: "Fast mode",
+      description: "1.5x speed, increased usage",
+      category: "fast-mode",
+      type: "select",
+      currentValue: "off",
+      options: [
+        {
+          value: "off",
+          name: "Off",
+          description: "Default speed, normal usage"
+        },
+        {
+          value: "on",
+          name: "On",
+          description: "1.5x speed, increased usage"
+        }
+      ]
+    },
+    {
+      id: "plan-mode",
+      name: "Plan mode",
+      description: "Plan without modifying files; switch off to implement the approved plan",
+      category: "plan-mode",
+      type: "select",
+      currentValue: "off",
+      options: [
+        {
+          value: "off",
+          name: "Off",
+          description: "Implement changes normally"
+        },
+        {
+          value: "on",
+          name: "On",
+          description: "Plan without modifying files; switch off to implement the approved plan"
+        }
+      ]
+    }
+  ];
+  const CLAUDE_STATIC_MODES = [
+    {
+      id: "auto",
+      name: "Auto",
+      description: "Use a model classifier to approve/deny permission prompts"
+    },
+    {
+      id: "default",
+      name: "Default",
+      description: "Standard behavior, prompts for dangerous operations"
+    },
+    {
+      id: "acceptEdits",
+      name: "Accept Edits",
+      description: "Auto-accept file edit operations"
+    },
+    {
+      id: "plan",
+      name: "Plan Mode",
+      description: "Planning mode, no actual tool execution"
+    },
+    {
+      id: "dontAsk",
+      name: "Don't Ask",
+      description: "Don't prompt for permissions, deny if not pre-approved"
+    }
+  ];
+  const CLAUDE_STATIC_MODELS = [
+    {
+      modelId: "default",
+      name: "Default",
+      description: "Claude Code default model"
+    },
+    {
+      modelId: "opus",
+      name: "Opus",
+      description: "Claude Opus"
+    },
+    {
+      modelId: "sonnet",
+      name: "Sonnet",
+      description: "Claude Sonnet"
+    },
+    {
+      modelId: "haiku",
+      name: "Haiku",
+      description: "Claude Haiku"
+    }
+  ];
+  const CLAUDE_STATIC_CONFIG_OPTIONS = [
+    {
+      id: "mode",
+      name: "Mode",
+      description: "Session permission mode",
+      category: "mode",
+      type: "select",
+      currentValue: "default",
+      options: CLAUDE_STATIC_MODES.map((mode2) => ({
+        value: mode2.id,
+        name: mode2.name,
+        description: mode2.description ?? void 0
+      }))
+    },
+    {
+      id: "model",
+      name: "Model",
+      description: "AI model to use",
+      category: "model",
+      type: "select",
+      currentValue: "default",
+      options: CLAUDE_STATIC_MODELS.map((model) => ({
+        value: model.modelId,
+        name: model.name,
+        description: model.description ?? void 0
+      }))
+    },
+    {
+      id: "effort",
+      name: "Effort",
+      description: "Available effort levels for this model",
+      category: "thought_level",
+      type: "select",
+      currentValue: "default",
+      options: [
+        {
+          value: "default",
+          name: "Default"
+        },
+        {
+          value: "low",
+          name: "Low"
+        },
+        {
+          value: "medium",
+          name: "Medium"
+        },
+        {
+          value: "high",
+          name: "High"
+        }
+      ]
+    }
+  ];
+  const cloneConfigOption = (option2) => ({
+    ...option2,
+    options: option2.options.map((value) => ({
+      ...value
+    }))
+  });
+  const cloneStaticCapabilities = (capabilities) => ({
+    modes: capabilities.modes.map((mode2) => ({
+      ...mode2
+    })),
+    models: capabilities.models.map((model) => ({
+      ...model
+    })),
+    configOptions: capabilities.configOptions.map(cloneConfigOption)
+  });
+  const getStaticBuiltinAcpCapabilities = (cliType, agentType, runtimeOverrides) => {
+    if (cliType !== "builtin" || !agentType || !isBuiltinAgentType(agentType)) {
+      return void 0;
+    }
+    if (hasBuiltinRuntimeOverrideValues(runtimeOverrides)) {
+      return void 0;
+    }
+    return cloneStaticCapabilities(agentType === "claude" ? {
+      modes: CLAUDE_STATIC_MODES,
+      models: CLAUDE_STATIC_MODELS,
+      configOptions: CLAUDE_STATIC_CONFIG_OPTIONS
+    } : {
+      modes: CODEX_STATIC_MODES,
+      models: CODEX_STATIC_MODELS,
+      configOptions: CODEX_STATIC_CONFIG_OPTIONS
+    });
+  };
   const leastPermissionModeRank = (value, name2) => {
     const normalized = `${value} ${name2}`.toLowerCase().replace(/[\s_-]+/g, "-");
     if (normalized.includes("read-only") || normalized.includes("readonly")) return 0;
@@ -78955,6 +79223,252 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       }
     }
   }
+  const isRecoverableMachineFlockRoomStatus = (status) => status === "disconnected" || status === "error";
+  class MachineFlockSyncCoordinator {
+    repo;
+    workspaceId;
+    logger;
+    random;
+    retryBaseDelayMs;
+    retryMaxDelayMs;
+    states = /* @__PURE__ */ new Map();
+    cleanedUp = false;
+    constructor(options) {
+      this.repo = options.repo;
+      this.workspaceId = options.workspaceId;
+      this.logger = options.logger;
+      this.random = options.random ?? Math.random;
+      this.retryBaseDelayMs = options.retryBaseDelayMs;
+      this.retryMaxDelayMs = options.retryMaxDelayMs;
+    }
+    ensureJoined(machineId, options = {}) {
+      const state2 = this.getState(machineId);
+      return this.ensureStateJoined(state2, options.reason ?? "ensure-joined");
+    }
+    markDirty(machineId, options = {}) {
+      if (this.cleanedUp) {
+        return;
+      }
+      const state2 = this.getState(machineId);
+      state2.dirty = true;
+      state2.dirtyVersion += 1;
+      if (options.resetBackoff) {
+        state2.retryAttempt = 0;
+      }
+      const reason = options.reason ?? "dirty";
+      void this.ensureStateJoined(state2, `dirty:${reason}`).catch((error2) => {
+        this.logger.debug(`[${this.workspaceId}] Machine Flock room join failed before background sync (machine=${machineId} reason=${reason}): ${formatErrorMessage(error2)}`);
+      });
+      void this.syncNow(machineId, {
+        ...options,
+        reason,
+        scheduleRetry: options.scheduleRetry ?? true
+      });
+    }
+    async syncNow(machineId, options = {}) {
+      if (this.cleanedUp) {
+        return false;
+      }
+      const state2 = this.getState(machineId);
+      if (state2.activeSync) {
+        return await state2.activeSync;
+      }
+      state2.activeSync = this.syncStateNow(state2, options).finally(() => {
+        state2.activeSync = null;
+      });
+      return await state2.activeSync;
+    }
+    retryDirtyNow(reason) {
+      if (this.cleanedUp) {
+        return;
+      }
+      for (const state2 of this.states.values()) {
+        if (!state2.dirty) {
+          continue;
+        }
+        this.clearRetryTimer(state2);
+        state2.retryAttempt = 0;
+        void this.syncNow(state2.machineId, {
+          reason,
+          scheduleRetry: true,
+          resetBackoff: true
+        });
+      }
+    }
+    async cleanUp() {
+      this.cleanedUp = true;
+      const pendingOperations = [];
+      for (const state2 of this.states.values()) {
+        this.clearRetryTimer(state2);
+        if (state2.activeSync) {
+          pendingOperations.push(state2.activeSync);
+        }
+        if (state2.joinPromise) {
+          pendingOperations.push(state2.joinPromise);
+        }
+        this.releaseRoomSubscription(state2);
+      }
+      await Promise.allSettled(pendingOperations);
+      this.states.clear();
+    }
+    async syncStateNow(state2, options) {
+      const reason = options.reason ?? "sync-now";
+      if (options.resetBackoff) {
+        state2.retryAttempt = 0;
+      }
+      this.clearRetryTimer(state2);
+      try {
+        await this.ensureStateJoined(state2, `sync:${reason}`);
+      } catch (error2) {
+        this.logger.debug(`[${this.workspaceId}] Machine Flock room join failed before sync (machine=${state2.machineId} reason=${reason}): ${formatErrorMessage(error2)}`);
+      }
+      const syncVersion = state2.dirtyVersion;
+      const timeoutMs = options.timeoutMs ?? readTimeoutEnv("LODY_LORO_SYNC_MACHINE_FLOCK_TIMEOUT_MS", 8e3);
+      const timeoutMessage = `Timeout waiting for machine Flock doc sync (doc=${state2.docId})`;
+      try {
+        const handle = await this.repo.openFlockDoc(state2.docId);
+        await withTimeout$3(handle.syncOnce(), timeoutMs, timeoutMessage);
+        if (state2.dirtyVersion === syncVersion) {
+          state2.dirty = false;
+          state2.retryAttempt = 0;
+        } else if (state2.dirty) {
+          this.scheduleRetry(state2, `${reason}:new-writes`, true);
+        }
+        this.logger.debug(`[${this.workspaceId}] Machine Flock doc synced (machine=${state2.machineId} reason=${reason})`);
+        return true;
+      } catch (error2) {
+        this.logger.debug(`[${this.workspaceId}] Machine Flock doc sync was not confirmed before continuing (machine=${state2.machineId} reason=${reason}): ${formatErrorMessage(error2)}`);
+        if (options.scheduleRetry ?? true) {
+          state2.dirty = true;
+          this.scheduleRetry(state2, reason, false);
+        }
+        return false;
+      }
+    }
+    async ensureStateJoined(state2, reason) {
+      if (this.cleanedUp) {
+        return;
+      }
+      if (state2.roomSub) {
+        if (!isRecoverableMachineFlockRoomStatus(state2.roomSub.status)) {
+          return;
+        }
+        this.releaseRoomSubscription(state2, state2.roomSub);
+      }
+      if (state2.joinPromise) {
+        return await state2.joinPromise;
+      }
+      state2.joinPromise = (async () => {
+        const handle = await this.repo.openFlockDoc(state2.docId);
+        const sub = await handle.joinRoom();
+        if (this.cleanedUp) {
+          sub.unsubscribe();
+          return;
+        }
+        state2.roomSub = sub;
+        state2.detachRoomStatusListener = sub.onStatusChange((status) => {
+          this.handleRoomStatusChange(state2, sub, status);
+        });
+        this.handleRoomStatusChange(state2, sub, sub.status);
+        if (state2.roomSub !== sub) {
+          return;
+        }
+        void sub.firstSyncedWithRemote.then(() => {
+          if (this.cleanedUp || state2.roomSub !== sub) {
+            return;
+          }
+          this.logger.debug(`[${this.workspaceId}] Machine Flock room first sync completed (machine=${state2.machineId} reason=${reason})`);
+        }, (error2) => {
+          if (this.cleanedUp || state2.roomSub !== sub) {
+            return;
+          }
+          this.logger.debug(`[${this.workspaceId}] Machine Flock room first sync failed (machine=${state2.machineId} reason=${reason}): ${formatErrorMessage(error2)}`);
+        });
+      })();
+      try {
+        await state2.joinPromise;
+      } finally {
+        state2.joinPromise = null;
+      }
+    }
+    handleRoomStatusChange(state2, sub, status) {
+      if (this.cleanedUp || state2.roomSub !== sub) {
+        return;
+      }
+      if (!isRecoverableMachineFlockRoomStatus(status)) {
+        return;
+      }
+      this.logger.debug(`[${this.workspaceId}] Machine Flock room became ${status}; will rejoin before the next sync (machine=${state2.machineId})`);
+      this.releaseRoomSubscription(state2, sub);
+      if (state2.dirty) {
+        this.scheduleRetry(state2, `room-${status}`, false);
+      }
+    }
+    releaseRoomSubscription(state2, sub = state2.roomSub) {
+      if (!sub || state2.roomSub !== sub) {
+        return;
+      }
+      state2.detachRoomStatusListener?.();
+      state2.detachRoomStatusListener = null;
+      state2.roomSub = null;
+      sub.unsubscribe();
+    }
+    scheduleRetry(state2, reason, resetBackoff) {
+      if (this.cleanedUp || !state2.dirty) {
+        return;
+      }
+      if (resetBackoff) {
+        state2.retryAttempt = 0;
+      }
+      if (state2.retryTimer) {
+        return;
+      }
+      const delayMs = computeLoroReconnectDelayMs(state2.retryAttempt, {
+        baseDelayMs: this.retryBaseDelayMs ?? readTimeoutEnv("LODY_LORO_MACHINE_FLOCK_RETRY_BASE_DELAY_MS", 1e3),
+        maxDelayMs: this.retryMaxDelayMs ?? readTimeoutEnv("LODY_LORO_MACHINE_FLOCK_RETRY_MAX_DELAY_MS", 6e4),
+        random: this.random
+      });
+      state2.retryAttempt += 1;
+      state2.retryTimer = setTimeout(() => {
+        state2.retryTimer = null;
+        if (this.cleanedUp || !state2.dirty) {
+          return;
+        }
+        void this.syncNow(state2.machineId, {
+          reason: `retry:${reason}`,
+          scheduleRetry: true
+        });
+      }, delayMs);
+      this.logger.debug(`[${this.workspaceId}] Scheduled Machine Flock doc sync retry in ${delayMs}ms (machine=${state2.machineId} reason=${reason})`);
+    }
+    clearRetryTimer(state2) {
+      if (!state2.retryTimer) {
+        return;
+      }
+      clearTimeout(state2.retryTimer);
+      state2.retryTimer = null;
+    }
+    getState(machineId) {
+      const existing = this.states.get(machineId);
+      if (existing) {
+        return existing;
+      }
+      const state2 = {
+        machineId,
+        docId: getMachineFlockDocId(this.workspaceId, machineId),
+        dirty: false,
+        dirtyVersion: 0,
+        retryAttempt: 0,
+        retryTimer: null,
+        activeSync: null,
+        joinPromise: null,
+        roomSub: null,
+        detachRoomStatusListener: null
+      };
+      this.states.set(machineId, state2);
+      return state2;
+    }
+  }
   const SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
     "token",
     "access_token",
@@ -98517,7 +99031,7 @@ ${value}`;
     ]);
     return mergeAgentConfigs(loroRepoMetaConfigs, machineFlockConfigs);
   }
-  async function upsertMachineAgentConfig(repo, workspaceId, config2) {
+  async function upsertMachineAgentConfig(repo, workspaceId, config2, options = {}) {
     const handle = await repo.openFlockDoc(getMachineFlockDocId(workspaceId, config2.machineId));
     const changed = writeMachineFlockRowToFlock(handle.flock, {
       key: machineFlockKeys.agentConfig(config2.id),
@@ -98528,10 +99042,16 @@ ${value}`;
       return;
     }
     await repo.flush();
-    await handle.syncOnce().catch(() => void 0);
+    if (options.sync) {
+      options.sync.markMachineFlockDocDirty(config2.machineId, {
+        reason: options.reason ?? "agent-config-upsert"
+      });
+    } else {
+      await handle.syncOnce().catch(() => void 0);
+    }
     await deleteLoroRepoMetaAgentConfigIfPresent(repo, config2.id);
   }
-  async function deleteMachineAgentConfig(repo, workspaceId, config2) {
+  async function deleteMachineAgentConfig(repo, workspaceId, config2, options = {}) {
     const handle = await repo.openFlockDoc(getMachineFlockDocId(workspaceId, config2.machineId));
     const changed = deleteMachineFlockRowFromFlock(handle.flock, machineFlockKeys.agentConfig(config2.id));
     if (!changed) {
@@ -98539,7 +99059,13 @@ ${value}`;
       return;
     }
     await repo.flush();
-    await handle.syncOnce().catch(() => void 0);
+    if (options.sync) {
+      options.sync.markMachineFlockDocDirty(config2.machineId, {
+        reason: options.reason ?? "agent-config-delete"
+      });
+    } else {
+      await handle.syncOnce().catch(() => void 0);
+    }
     await deleteLoroRepoMetaAgentConfigIfPresent(repo, config2.id);
   }
   async function listMachineAgentConfigs(repo, workspaceId, machineIds) {
@@ -98735,11 +99261,21 @@ ${value}`;
           this.initialMetaSyncCompleted = true;
         }
       });
+      this.machineFlockSync = new MachineFlockSyncCoordinator({
+        repo,
+        workspaceId,
+        logger: logger2
+      });
+      this.detachMachineFlockMetaRoomSyncedListener = this.connectionRecovery.onMetaRoomSynced((reason) => {
+        this.machineFlockSync.retryDirtyNow(`meta-room-synced:${reason}`);
+      });
     }
     sessions = /* @__PURE__ */ new Map();
     machine = null;
     machineExistenceWatcher = null;
     connectionRecovery;
+    machineFlockSync;
+    detachMachineFlockMetaRoomSyncedListener = null;
     initialMetaSyncCompleted = false;
     initialMetaSyncPromise;
     presenceRuntime;
@@ -98926,6 +99462,70 @@ ${value}`;
     async waitUntilMetaSynced(options = {}) {
       return await this.connectionRecovery.waitUntilMetaSynced(options);
     }
+    async syncMetaOrThrow(options = {}) {
+      const reason = options.reason ?? "explicit-sync";
+      const timeoutMs = options.timeoutMs ?? readTimeoutEnv("LODY_LORO_SYNC_META_TIMEOUT_MS", 2e4);
+      const timeoutMessage = `Timeout waiting for workspace metadata sync (workspace=${this.workspaceId})`;
+      try {
+        await withTimeout$3(this.repo.sync({
+          scope: "meta"
+        }), timeoutMs, timeoutMessage);
+        this.initialMetaSyncCompleted = true;
+      } catch (error2) {
+        throw new Error(`Workspace metadata sync failed (${reason}): ${formatErrorMessage(error2)}`, {
+          cause: error2
+        });
+      }
+    }
+    async syncDocOrThrow(docId, options = {}) {
+      const reason = options.reason ?? "explicit-sync";
+      const timeoutMs = options.timeoutMs ?? readTimeoutEnv("LODY_LORO_SYNC_DOC_TIMEOUT_MS", 8e3);
+      const timeoutMessage = `Timeout waiting for document sync (doc=${docId})`;
+      try {
+        await withTimeout$3(this.repo.sync({
+          scope: "doc",
+          docIds: [
+            docId
+          ]
+        }), timeoutMs, timeoutMessage);
+      } catch (error2) {
+        throw new Error(`Document sync failed for ${docId} (${reason}): ${formatErrorMessage(error2)}`, {
+          cause: error2
+        });
+      }
+    }
+    async syncFlockDocOrThrow(flockDocId, options = {}) {
+      const reason = options.reason ?? "explicit-sync";
+      const timeoutMs = options.timeoutMs ?? readTimeoutEnv("LODY_LORO_SYNC_MACHINE_FLOCK_TIMEOUT_MS", 8e3);
+      const timeoutMessage = `Timeout waiting for Flock document sync (doc=${flockDocId})`;
+      try {
+        await withTimeout$3(this.repo.sync({
+          scope: "doc",
+          flockDocIds: [
+            flockDocId
+          ]
+        }), timeoutMs, timeoutMessage);
+      } catch (error2) {
+        throw new Error(`Flock document sync failed for ${flockDocId} (${reason}): ${formatErrorMessage(error2)}`, {
+          cause: error2
+        });
+      }
+    }
+    async syncMachineFlockDoc(machineId, options = {}) {
+      return await this.machineFlockSync.syncNow(machineId, {
+        ...options,
+        reason: options.reason ?? "explicit-sync",
+        scheduleRetry: options.scheduleRetry ?? true
+      });
+    }
+    markMachineFlockDocDirty(machineId, options = {}) {
+      this.machineFlockSync.markDirty(machineId, options);
+    }
+    ensureMachineFlockDocJoined(machineId, options = {}) {
+      void this.machineFlockSync.ensureJoined(machineId, options).catch((error2) => {
+        this.logger.debug(`[${this.workspaceId}] Failed to join Machine Flock room (machine=${machineId} reason=${options.reason ?? "ensure-joined"}): ${formatErrorMessage(error2)}`);
+      });
+    }
     async destroyRepo(options) {
       const repoDestroyPromise = this.repo.destroy();
       if (!options.fast) {
@@ -99038,6 +99638,9 @@ ${value}`;
         cliType,
         agentType,
         env: {}
+      }, {
+        sync: this,
+        reason: "agent-config-upsert"
       });
       return agentConfigId;
     }
@@ -99045,7 +99648,7 @@ ${value}`;
     }
     async registerMachine(machineId, machine) {
       if (!this.machine) {
-        this.machine = new MachineDocument(this.repo, this.workspaceId, machineId);
+        this.machine = this.createMachineDocument(machineId);
         await this.machine.init();
       }
       await this.machine.setMetaState({
@@ -99056,25 +99659,32 @@ ${value}`;
     }
     async updateRateLimits(machineId, cliType, limits) {
       if (!this.machine) {
-        this.machine = new MachineDocument(this.repo, this.workspaceId, machineId);
+        this.machine = this.createMachineDocument(machineId);
         await this.machine.init();
       }
       await this.machine.updateRateLimits(cliType, limits);
     }
     async updateAcpCapabilities(machineId, cliType, agentType, modes, models, configOptions, availableCommands, sourceVersion) {
       if (!this.machine) {
-        this.machine = new MachineDocument(this.repo, this.workspaceId, machineId);
+        this.machine = this.createMachineDocument(machineId);
         await this.machine.init();
       }
       await this.machine.updateAcpCapabilities(cliType, agentType, modes, models, configOptions, availableCommands, sourceVersion);
     }
     async getAcpCapabilities(machineId, cliType, agentType) {
       if (!this.machine) {
-        this.machine = new MachineDocument(this.repo, this.workspaceId, machineId);
+        this.machine = this.createMachineDocument(machineId);
         await this.machine.init();
       }
       return this.machine.getAcpCapabilities(cliType, agentType);
     }
+    createMachineDocument(machineId) {
+      return new MachineDocument(this.repo, this.workspaceId, machineId, (reason) => {
+        this.markMachineFlockDocDirty(machineId, {
+          reason
+        });
+      });
+    }
     async restoreMachineDocument(machineId) {
       const machineRoomId = getMachineRoomId(machineId);
       await this.repo.restoreDoc(machineRoomId);
@@ -99104,6 +99714,9 @@ ${value}`;
       } catch (error2) {
         this.logger.debug(`[${this.workspaceId}] Failed to stop Loro presence runtime: ${formatErrorMessage(error2)}`);
       }
+      this.detachMachineFlockMetaRoomSyncedListener?.();
+      this.detachMachineFlockMetaRoomSyncedListener = null;
+      await this.machineFlockSync.cleanUp();
       await this.connectionRecovery.cleanUp();
       for (const [sessionId, pending2] of this.pendingSessionDocs) {
         try {
@@ -99988,10 +100601,11 @@ ${value}`;
     return meta.meta;
   };
   class MachineDocument {
-    constructor(repo, workspaceId, machineId) {
+    constructor(repo, workspaceId, machineId, markMachineFlockDirty) {
       this.repo = repo;
       this.workspaceId = workspaceId;
       this.machineId = machineId;
+      this.markMachineFlockDirty = markMachineFlockDirty;
       this.roomId = getMachineRoomId(this.machineId);
     }
     roomId;
@@ -100031,7 +100645,11 @@ ${value}`;
         });
         if (changed) {
           await this.repo.flush();
-          await handle.syncOnce().catch(() => void 0);
+          if (this.markMachineFlockDirty) {
+            this.markMachineFlockDirty("rate-limit-update");
+          } else {
+            await handle.syncOnce().catch(() => void 0);
+          }
         }
       });
     }
@@ -100064,7 +100682,11 @@ ${value}`;
       });
       if (changed) {
         await this.repo.flush();
-        await handle.syncOnce().catch(() => void 0);
+        if (this.markMachineFlockDirty) {
+          this.markMachineFlockDirty("acp-capability-update");
+        } else {
+          await handle.syncOnce().catch(() => void 0);
+        }
       }
     }
     async getAcpCapabilities(cliType, agentType) {
@@ -102156,7 +102778,9 @@ The file is not available yet and could not be downloaded; ask the user to resen
     return remoteName;
   }
   async function probeGitHubRemoteAtRootPath(rootPath) {
-    await assertGitRepository(rootPath);
+    if (!await isGitRepository(rootPath)) {
+      return null;
+    }
     const remotes = await listGitRemotes(rootPath);
     if (remotes.length === 0) return null;
     const currentBranchRemote = await resolveCurrentBranchRemote(rootPath, remotes);
@@ -117765,18 +118389,6 @@ ${fallbackStderrTail}` : errorMessage;
   function shouldScrubClaudeAuthEnv(cliType, agentType) {
     return cliType === "builtin" && agentType === "claude" || cliType === "registry" && agentType === "claude-p";
   }
-  async function getStaticBuiltinAcpCapabilities(agentType) {
-    if (!isBuiltinAgentType(agentType)) {
-      return void 0;
-    }
-    const baseline = agentType === "claude" ? (await import("./chunks/baseline-config-CcYq1mUH.js")).getClaudeBaselineConfig() : (await import("./chunks/baseline-config-BPa_f3S0.js")).getCodexBaselineConfig();
-    const configOptions = normalizeConfigOptions(baseline.configOptions);
-    return {
-      modes: baseline.modes,
-      models: baseline.models,
-      configOptions
-    };
-  }
   function isSelectGroup$1(item) {
     return typeof item === "object" && item !== null && "group" in item;
   }
@@ -117854,7 +118466,7 @@ ${fallbackStderrTail}` : errorMessage;
   async function fetchAcpCapabilities(cliType, agentType, logger2, env2, customAcp, runtimeOverrides, options = {}) {
     const allowStaticBuiltinCapabilities = options.allowStaticBuiltinCapabilities ?? true;
     if (allowStaticBuiltinCapabilities && cliType === "builtin" && !hasBuiltinRuntimeOverrideValues(runtimeOverrides)) {
-      const staticCapabilities = await getStaticBuiltinAcpCapabilities(agentType);
+      const staticCapabilities = getStaticBuiltinAcpCapabilities(cliType, agentType, runtimeOverrides);
       if (staticCapabilities) {
         logger2.debug(`[acp-capabilities] Using static builtin capabilities (agentType=${agentType})`);
         return staticCapabilities;
@@ -121377,7 +121989,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       ...flockLocalProjects
     };
   }
-  async function upsertMachineLocalProject(repo, workspaceId, machineId, project, nowMs2 = getServerNow()) {
+  async function upsertMachineLocalProject(repo, workspaceId, machineId, project, nowMs2 = getServerNow(), options = {}) {
     const handle = await repo.openFlockDoc(getMachineFlockDocId(workspaceId, machineId));
     const changed = writeMachineFlockRowToFlock(handle.flock, {
       key: machineFlockKeys.localProject(project.id),
@@ -121387,14 +121999,26 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       return;
     }
     await repo.flush();
-    await handle.syncOnce();
+    if (options.sync) {
+      options.sync.markMachineFlockDocDirty(machineId, {
+        reason: options.reason ?? "local-project-upsert"
+      });
+    } else {
+      await handle.syncOnce().catch(() => void 0);
+    }
   }
-  async function removeMachineLocalProject(repo, workspaceId, machineId, localProjectId, nowMs2 = getServerNow()) {
+  async function removeMachineLocalProject(repo, workspaceId, machineId, localProjectId, nowMs2 = getServerNow(), options = {}) {
     const handle = await repo.openFlockDoc(getMachineFlockDocId(workspaceId, machineId));
     const changed = deleteMachineFlockRowFromFlock(handle.flock, machineFlockKeys.localProject(localProjectId), nowMs2);
     if (changed) {
       await repo.flush();
-      await handle.syncOnce().catch(() => void 0);
+      if (options.sync) {
+        options.sync.markMachineFlockDocDirty(machineId, {
+          reason: options.reason ?? "local-project-remove"
+        });
+      } else {
+        await handle.syncOnce().catch(() => void 0);
+      }
     }
     const machineRoomId = getMachineRoomId(machineId);
     const current2 = await repo.getDocMeta(machineRoomId);
@@ -133814,7 +134438,10 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
               ]))
             }
           }
-        }, lastListedAt);
+        }, lastListedAt, {
+          sync: this.manager,
+          reason: "local-project-history-sync"
+        });
       });
       return catalog;
     }
@@ -139197,7 +139824,10 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
         rootPath: entry.rootPath,
         createdAtMs: previous?.createdAtMs ?? nowMs2,
         lastOpenedAtMs: nowMs2
-      }, nowMs2);
+      }, nowMs2, {
+        sync: this.workspaceDocument,
+        reason: "local-project-add"
+      });
     }
     async authorizeLocalProjectRoot(args2) {
       const access = await canUseMachineForCliToken({
@@ -148234,6 +148864,8 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
       await next2;
     }
   }
+  const BUILTIN_AGENT_CONFIG_INITIAL_RETRY_DELAY_MS = 1e4;
+  const BUILTIN_AGENT_CONFIG_MAX_RETRY_DELAY_MS = 5 * 6e4;
   class Lody {
     constructor(options, documentManager) {
       this.options = options;
@@ -148274,6 +148906,9 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     runtime;
     supportRegistryAgentTypes;
     cleanedUp = false;
+    builtinAgentConfigRetryTimer;
+    pendingBuiltinAgentConfigRetryCliTypes = /* @__PURE__ */ new Set();
+    builtinAgentConfigRetryAttempt = 0;
     static async create(options) {
       const manager = await LoroDocumentManager.create(options.workspaceId, options.userId, () => options.token, options.logger);
       return new Lody(options, manager);
@@ -148281,25 +148916,49 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     async start() {
       void getLoginShellEnv();
       await this.runtime.initialize();
+      this.documentManager.ensureMachineFlockDocJoined(this.machineId, {
+        reason: "lody-start"
+      });
     }
     async registerAgent(cliTypes) {
       await this.runtime.initialize();
       if (this.documentManager.hasCompletedInitialMetaSync()) {
-        await this.ensureBuiltinAgentConfigs(cliTypes);
+        await this.ensureBuiltinAgentConfigsOrRetry(cliTypes);
       } else {
         this.logger.debug(`[agent-config] Initial meta sync is not complete for workspace ${this.workspaceId}; deferring builtin agent registration`);
         void this.documentManager.waitForInitialMetaSync().then(async (completed) => {
           if (!completed || this.cleanedUp) {
             return;
           }
-          await this.ensureBuiltinAgentConfigs(cliTypes);
+          await this.ensureBuiltinAgentConfigsOrRetry(cliTypes);
         }).catch((error2) => {
           this.logger.debug(`[agent-config] Deferred builtin agent registration failed: ${formatErrorMessage(error2)}`);
         });
       }
       void this.refreshBuiltinCapabilities(cliTypes);
     }
+    async ensureBuiltinAgentConfigsOrRetry(cliTypes) {
+      if (this.cleanedUp) {
+        return;
+      }
+      const completed = await this.ensureBuiltinAgentConfigs(cliTypes);
+      if (!completed) {
+        this.scheduleBuiltinAgentConfigRetry(cliTypes);
+        return;
+      }
+      this.builtinAgentConfigRetryAttempt = 0;
+    }
     async ensureBuiltinAgentConfigs(cliTypes) {
+      if (cliTypes.length === 0) {
+        return true;
+      }
+      const syncedMachineFlock = await this.documentManager.syncMachineFlockDoc(this.machineId, {
+        reason: "builtin-agent-registration"
+      });
+      if (!syncedMachineFlock) {
+        this.logger.debug(`[agent-config] Machine Flock sync is not complete for workspace ${this.workspaceId} machine ${this.machineId}; skipping builtin agent registration for this attempt`);
+        return false;
+      }
       const builtinDisplayName = {
         claude: "Claude Code",
         codex: "Codex"
@@ -148310,6 +148969,40 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
           await this.documentManager.createAgentConfig("builtin", cliType, this.machineId, builtinDisplayName[cliType]);
         }
       }
+      return true;
+    }
+    scheduleBuiltinAgentConfigRetry(cliTypes) {
+      if (cliTypes.length === 0 || this.cleanedUp) {
+        return;
+      }
+      for (const cliType of cliTypes) {
+        this.pendingBuiltinAgentConfigRetryCliTypes.add(cliType);
+      }
+      if (this.builtinAgentConfigRetryTimer) {
+        return;
+      }
+      const delayMs = this.nextBuiltinAgentConfigRetryDelayMs();
+      this.logger.debug(`[agent-config] Scheduling builtin agent registration retry in ${delayMs}ms for workspace ${this.workspaceId} machine ${this.machineId}`);
+      this.builtinAgentConfigRetryTimer = setTimeout(() => {
+        this.builtinAgentConfigRetryTimer = void 0;
+        if (this.cleanedUp) {
+          this.pendingBuiltinAgentConfigRetryCliTypes.clear();
+          return;
+        }
+        const retryCliTypes = [
+          ...this.pendingBuiltinAgentConfigRetryCliTypes
+        ];
+        this.pendingBuiltinAgentConfigRetryCliTypes.clear();
+        void this.ensureBuiltinAgentConfigsOrRetry(retryCliTypes).catch((error2) => {
+          this.logger.debug(`[agent-config] Retried builtin agent registration failed: ${formatErrorMessage(error2)}`);
+        });
+      }, delayMs);
+      this.builtinAgentConfigRetryTimer.unref?.();
+    }
+    nextBuiltinAgentConfigRetryDelayMs() {
+      const multiplier = 2 ** Math.min(this.builtinAgentConfigRetryAttempt, 5);
+      this.builtinAgentConfigRetryAttempt += 1;
+      return Math.min(BUILTIN_AGENT_CONFIG_INITIAL_RETRY_DELAY_MS * multiplier, BUILTIN_AGENT_CONFIG_MAX_RETRY_DELAY_MS);
     }
     async refreshBuiltinCapabilities(cliTypes) {
       for (const cliType of cliTypes) {
@@ -148340,6 +149033,12 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     }
     cleanup = async () => {
       this.cleanedUp = true;
+      if (this.builtinAgentConfigRetryTimer) {
+        clearTimeout(this.builtinAgentConfigRetryTimer);
+        this.builtinAgentConfigRetryTimer = void 0;
+      }
+      this.pendingBuiltinAgentConfigRetryCliTypes.clear();
+      this.builtinAgentConfigRetryAttempt = 0;
       return await this.runtime.cleanup();
     };
     async dispatchLocalControl(message) {
@@ -150549,10 +151248,16 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
         rootPath: entry.rootPath,
         createdAtMs: previous?.createdAtMs ?? nowMs2,
         lastOpenedAtMs: nowMs2
-      }, nowMs2);
+      }, nowMs2, {
+        sync: runtime.lody.documentManager,
+        reason: "local-project-add"
+      });
     }
     async removeProjectMetaInWorkspace(runtime, localProjectId) {
-      await removeMachineLocalProject(runtime.lody.documentManager.repo, runtime.workspace.id, this.machineId, localProjectId);
+      await removeMachineLocalProject(runtime.lody.documentManager.repo, runtime.workspace.id, this.machineId, localProjectId, void 0, {
+        sync: runtime.lody.documentManager,
+        reason: "local-project-delete"
+      });
     }
     async listProjectsByWorkspace() {
       const groups = [];
@@ -177422,6 +178127,29 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       throw new Error(`Workspace metadata changes were not confirmed by Loro Streams (${reason}). Retry the command after checking network connectivity.`);
     }
   }
+  function buildOfflineHint(error2) {
+    return new Error(`${formatErrorMessage(error2)} Use --offline to read the local cache without syncing.`, {
+      cause: error2
+    });
+  }
+  async function syncWorkspaceMetaForRead(manager, reason) {
+    try {
+      await manager.syncMetaOrThrow({
+        reason
+      });
+    } catch (error2) {
+      throw buildOfflineHint(error2);
+    }
+  }
+  async function syncDocForRead(manager, docId, reason) {
+    try {
+      await manager.syncDocOrThrow(docId, {
+        reason
+      });
+    } catch (error2) {
+      throw buildOfflineHint(error2);
+    }
+  }
   async function listAliveRoomIds(manager, predicate) {
     const scanner = manager.repo.getMeta();
     if (!scanner) {
@@ -177600,16 +178328,19 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       await action();
       await exitOneShotCommand(0);
     } catch (error2) {
+      const commandError = error2 && typeof error2 === "object" ? error2 : void 0;
       const message = formatErrorMessage(error2);
-      if (options.json || options.jsonl) {
-        printJson({
-          ok: false,
-          error: message
-        });
-      } else {
-        getLogger(loggerName).error(message);
+      if (commandError?.suppressCommandErrorOutput !== true) {
+        if (options.json || options.jsonl) {
+          printJson({
+            ok: false,
+            error: message
+          });
+        } else {
+          getLogger(loggerName).error(message);
+        }
       }
-      await exitOneShotCommand(1);
+      await exitOneShotCommand(commandError?.exitCode ?? 1);
     }
   }
   var debug_1;
@@ -180339,16 +181070,28 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       configOptionValues
     };
   }
-  const agentConfigListCommand = new Command("list").description("List agent configs in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--json", "Print JSON output").option("--debug", "Enable debug output").action(async (options) => {
+  const agentConfigListCommand = new Command("list").description("List agent configs in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--machine <idOrName>", "Only include configs for one machine").option("--json", "Print JSON output").option("--debug", "Enable debug output").action(async (options) => {
     await runOneShotCommand("agent-config", options, async () => {
       const auth = getAuthContextOrThrow$1("agent-config");
       const workspace = await resolveWorkspaceOrThrow$1(auth, options.workspace);
       await withWorkspaceManager$1(auth, workspace, "agent-config", async (manager) => {
-        const configs = await listAgentConfigsForWorkspace$1(manager, workspace.id);
+        const machineSelector = normalizeCliValue(options.machine);
+        let machineId;
+        if (machineSelector) {
+          const machine = resolveMachineOrThrow(await listMachineMetasForWorkspace(manager), {
+            selector: machineSelector,
+            authMachineId: auth.machineId
+          });
+          machineId = machine.id;
+        }
+        const configs = (await listAgentConfigsForWorkspace$1(manager, workspace.id)).filter((config2) => machineId === void 0 || config2.machineId === machineId);
         if (options.json) {
           printJson({
             ok: true,
             workspaceId: workspace.id,
+            ...machineId ? {
+              machineId
+            } : {},
             agentConfigs: configs.map(toAgentConfigOutput)
           });
           return;
@@ -180805,13 +181548,21 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     }
     throw new Error(`Agent config not found: ${normalizedSelector}. Candidates: ${formatAgentConfigCandidates(configs)}`);
   }
+  function resolveCreateAgentSelector(options) {
+    const agent2 = normalizeCliValue(options.agent);
+    const agentConfig = normalizeCliValue(options.agentConfig);
+    if (agent2 && agentConfig && agent2 !== agentConfig) {
+      throw new Error("Pass either --agent or --agent-config, not both.");
+    }
+    return agentConfig ?? agent2;
+  }
   function buildAgentPrompt(prompt2, agentPrompt = "") {
     return [
       agentPrompt,
       prompt2
     ].filter((part) => part?.trim()).join("\n\n");
   }
-  function parsePositiveIntOption(value) {
+  function parsePositiveIntOption$1(value) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isFinite(parsed) || parsed <= 0) {
       throw new Error(`Invalid numeric value: ${value}`);
@@ -180898,6 +181649,9 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     return entries.map((entry) => `[${entry.role}] ${entry.timestamp} ${entry.id}
 ${entry.text}`).join("\n\n");
   }
+  function renderAssistantTurnCompletion(content) {
+    return extractTranscriptText(content, "assistant") ?? "No visible assistant reply found.";
+  }
   async function readStdinText() {
     const chunks = [];
     return await new Promise((resolve2, reject) => {
@@ -181198,15 +181952,22 @@ ${entry.text}`).join("\n\n");
     const effectiveSelector = normalizeCliValue(selector) ?? normalizeCliValue(process.env.LODY_WORKSPACE_ID);
     return selectWorkspaceSummary(workspaces, effectiveSelector);
   }
-  async function resolveWorkspaceForSessionOrThrow(auth, sessionId, selector) {
+  async function resolveWorkspaceForSessionOrThrow(auth, sessionId, options) {
     const workspaces = await listWorkspacesForToken(auth.token);
+    const selector = typeof options === "string" ? options : options?.workspace;
+    const shouldSync = typeof options === "object" && options.offline !== true;
+    const syncReason = typeof options === "object" ? options.reason : void 0;
     const effectiveSelector = normalizeCliValue(selector) ?? normalizeCliValue(process.env.LODY_WORKSPACE_ID);
+    const sessionExistsInWorkspace = async (workspace) => await withWorkspaceManager(auth, workspace, async (manager) => {
+      if (shouldSync) {
+        await syncWorkspaceMetaForRead(manager, syncReason ?? `session.resolve:${sessionId}:${workspace.id}`);
+      }
+      const raw2 = await manager.repo.getDocMeta(getSessionRoomId(sessionId));
+      return !!raw2?.meta && !isLoroRepoDocDeleted(raw2);
+    });
     if (effectiveSelector) {
       const workspace = selectWorkspaceSummary(workspaces, effectiveSelector);
-      const exists = await withWorkspaceManager(auth, workspace, async (manager) => {
-        const raw2 = await manager.repo.getDocMeta(getSessionRoomId(sessionId));
-        return !!raw2?.meta && !isLoroRepoDocDeleted(raw2);
-      });
+      const exists = await sessionExistsInWorkspace(workspace);
       if (!exists) {
         throw new Error(`Session not found in workspace ${workspace.id}: ${sessionId}`);
       }
@@ -181214,10 +181975,7 @@ ${entry.text}`).join("\n\n");
     }
     if (workspaces.length === 1) {
       const workspace = workspaces[0];
-      const exists = await withWorkspaceManager(auth, workspace, async (manager) => {
-        const raw2 = await manager.repo.getDocMeta(getSessionRoomId(sessionId));
-        return !!raw2?.meta && !isLoroRepoDocDeleted(raw2);
-      });
+      const exists = await sessionExistsInWorkspace(workspace);
       if (!exists) {
         throw new Error(`Session not found: ${sessionId}`);
       }
@@ -181225,10 +181983,7 @@ ${entry.text}`).join("\n\n");
     }
     const matches = [];
     for (const workspace of workspaces) {
-      const exists = await withWorkspaceManager(auth, workspace, async (manager) => {
-        const raw2 = await manager.repo.getDocMeta(getSessionRoomId(sessionId));
-        return !!raw2?.meta && !isLoroRepoDocDeleted(raw2);
-      });
+      const exists = await sessionExistsInWorkspace(workspace);
       if (exists) {
         matches.push(workspace);
       }
@@ -181241,6 +181996,13 @@ ${entry.text}`).join("\n\n");
     }
     return matches[0];
   }
+  async function syncSessionReadData(manager, sessionId, offline, reason) {
+    if (offline === true) {
+      return;
+    }
+    await syncWorkspaceMetaForRead(manager, `${reason}:meta`);
+    await syncDocForRead(manager, getSessionRoomId(sessionId), `${reason}:doc`);
+  }
   async function resolveSessionMetaOrThrow(manager, sessionId) {
     const raw2 = await manager.repo.getDocMeta(getSessionRoomId(sessionId));
     if (!raw2?.meta || isLoroRepoDocDeleted(raw2)) {
@@ -181575,6 +182337,37 @@ ${entry.text}`).join("\n\n");
       messageQueueCount: docState?.mq?.length ?? 0
     };
   }
+  async function buildSessionStatusResult(workspace, manager, sessionId) {
+    const session = await resolveSessionMetaOrThrow(manager, sessionId);
+    const sessionDoc = await manager.getOrCreateSessionDoc(sessionId);
+    const history = await sessionDoc.getHistory();
+    const assistantTurnId = resolveActiveAssistantTurnId(history);
+    return {
+      workspace,
+      sessionId,
+      status: session.status,
+      machineId: session.machineId,
+      agent: {
+        cliType: session.cliType,
+        agentType: session.agentType,
+        ...session.agentConfigId ? {
+          agentConfigId: session.agentConfigId
+        } : {}
+      },
+      archived: session.isArchived === true,
+      ...assistantTurnId ? {
+        activeTurn: {
+          assistantTurnId,
+          ...session.processingUserMsgId ? {
+            processingUserMsgId: session.processingUserMsgId
+          } : {},
+          ...session.latestUserMsgId ? {
+            latestUserMsgId: session.latestUserMsgId
+          } : {}
+        }
+      } : {}
+    };
+  }
   function printHumanSessionList(sessions) {
     if (sessions.length === 0) {
       console.log("No sessions found.");
@@ -181622,6 +182415,16 @@ ${entry.text}`).join("\n\n");
     console.log(`createdAt: ${session.createdAt}`);
     console.log(`lastHistoryAt: ${result.latestHistoryAt ?? "-"}`);
   }
+  function printHumanSessionStatus(result) {
+    console.log(`id: ${result.sessionId}`);
+    console.log(`workspace: ${result.workspace.slug ?? result.workspace.id}`);
+    console.log(`machine: ${result.machineId}`);
+    console.log(`status: ${result.status?.type ?? "unknown"}`);
+    console.log(`archived: ${result.archived ? "yes" : "no"}`);
+    console.log(`agent: ${result.agent.cliType}/${result.agent.agentType}`);
+    console.log(`agentConfigId: ${result.agent.agentConfigId ?? "-"}`);
+    console.log(`activeTurn: ${result.activeTurn?.assistantTurnId ?? "-"}`);
+  }
   async function runSessionCommand(options, action) {
     if (options.debug) {
       rootLogger.setDebug(true);
@@ -181680,7 +182483,7 @@ ${entry.text}`).join("\n\n");
       process.exit(code2);
     }
   }
-  const sessionCreateCommand = new Command("create").description("Create a new session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--agent-config <idOrName>", "Agent config id or name").option("--title <title>", "Session title").option("--repo <owner/repo>", "GitHub repository to attach").option("--local-project <id|name|path>", "Local project id, name, or root path").option("--worktree", "Create an isolated git worktree for --local-project").option("--branch <name>", "Git branch to use for GitHub repos or local git projects").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--env <keyValue>", "Deprecated per-session env override; configure env on the agent config instead", collectListOption, []).option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--timeout <seconds>", "Wait timeout in seconds for structured output", parsePositiveIntOption).option("--debug", "Enable debug output").argument("[prompt]", "Prompt text").action(async (promptArg, options) => {
+  const sessionCreateCommand = new Command("create").description("Create a new session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--agent <idOrName>", "Agent config id or name").option("--agent-config <idOrName>", "Agent config id or name").option("--title <title>", "Session title").option("--repo <owner/repo>", "GitHub repository to attach").option("--local-project <id|name|path>", "Local project id, name, or root path").option("--worktree", "Create an isolated git worktree for --local-project").option("--branch <name>", "Git branch to use for GitHub repos or local git projects").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--env <keyValue>", "Deprecated per-session env override; configure env on the agent config instead", collectListOption, []).option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--wait", "Wait for the assistant turn to complete before exiting").option("--timeout <seconds>", "Wait timeout in seconds for --wait, --json, and --jsonl", parsePositiveIntOption$1).option("--debug", "Enable debug output").argument("[prompt]", "Prompt text").action(async (promptArg, options) => {
     await runSessionCommand(options, async () => {
       const outputMode = resolveStructuredOutputMode(options);
       const createStartMs = Date.now();
@@ -181693,12 +182496,16 @@ ${entry.text}`).join("\n\n");
         const prompt2 = await readPromptText(options, promptArg);
         await ensureLocalRuntimeAvailable(auth.machineId, workspace.id);
         await withWorkspaceManager(auth, workspace, async (manager) => {
-          const agentConfig = await resolveAgentConfigOrThrow(manager, workspace.id, options.agentConfig);
+          const agentSelector = resolveCreateAgentSelector(options);
+          const agentConfig = await resolveAgentConfigOrThrow(manager, workspace.id, agentSelector);
           const dispatchConfig = resolveTurnDispatchConfig({
             mode: options.mode,
             model: options.model
           });
-          const result = await createSessionResult(auth, workspace, manager, prompt2, options, agentConfig, dispatchConfig, outputMode === "human" ? void 0 : {
+          const result = await createSessionResult(auth, workspace, manager, prompt2, options, agentConfig, dispatchConfig, outputMode === "human" ? options.wait === true ? {
+            outputMode: "json",
+            timeoutMs: resolveStructuredOutputTimeoutMs(options.timeout)
+          } : void 0 : {
             outputMode,
             timeoutMs: resolveStructuredOutputTimeoutMs(options.timeout),
             onEvent: outputMode === "jsonl" ? (event) => printJson(event) : void 0
@@ -181749,13 +182556,29 @@ ${entry.text}`).join("\n\n");
             }
             return;
           }
+          console.log(result.sessionId);
+          if (options.wait === true) {
+            const completionPromise = result.completionPromise;
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for session create --wait output.");
+            }
+            const completedTurn = await completionPromise;
+            captureSessionCommandEvent("session_create_succeeded", {
+              output_mode: outputMode,
+              turn_duration_ms: completedTurn.durationMs
+            }, {
+              distinctId: auth.machineId
+            });
+            console.log("");
+            console.log(renderAssistantTurnCompletion(completedTurn.content));
+            return;
+          }
           captureSessionCommandEvent("session_create_succeeded", {
             output_mode: outputMode,
             turn_duration_ms: Date.now() - createStartMs
           }, {
             distinctId: auth.machineId
           });
-          console.log(result.sessionId);
         });
       } catch (error2) {
         captureSessionCommandEvent("session_create_failed", {
@@ -181766,7 +182589,7 @@ ${entry.text}`).join("\n\n");
       }
     });
   });
-  const sessionChatCommand = new Command("chat").description("Send a new user prompt to an existing session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--timeout <seconds>", "Wait timeout in seconds for structured output", parsePositiveIntOption).option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").argument("[prompt]", "Prompt text").action(async (sessionIdArg, promptArg, options) => {
+  const sessionChatCommand = new Command("chat").description("Send a new user prompt to an existing session on the current machine").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--mode <modeId>", "ACP mode override").option("--model <modelId>", "ACP model override").option("--prompt <text>", "Prompt text").option("--prompt-file <path>", "Read prompt text from file, or - for stdin").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--wait", "Wait for the assistant turn to complete before exiting").option("--timeout <seconds>", "Wait timeout in seconds for --wait, --json, and --jsonl", parsePositiveIntOption$1).option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").argument("[prompt]", "Prompt text").action(async (sessionIdArg, promptArg, options) => {
     await runSessionCommand(options, async () => {
       const outputMode = resolveStructuredOutputMode(options);
       const auth = getAuthContextOrThrow();
@@ -181813,15 +182636,16 @@ ${entry.text}`).join("\n\n");
           configOptionValues: dispatchConfig.configOptionValues,
           resume: session.acpSessionId ?? void 0
         }));
-        const completionAbortController = outputMode === "human" ? void 0 : new AbortController();
-        const completionPromise = outputMode === "human" ? void 0 : waitForTurnCompletion({
+        const shouldWaitForCompletion = outputMode !== "human" || options.wait === true;
+        const completionAbortController = shouldWaitForCompletion ? new AbortController() : void 0;
+        const completionPromise = shouldWaitForCompletion ? waitForTurnCompletion({
           sessionDoc,
           userTurnId,
-          outputMode,
+          outputMode: outputMode === "human" ? "json" : outputMode,
           timeoutMs: resolveStructuredOutputTimeoutMs(options.timeout),
           signal: completionAbortController?.signal,
           onEvent: outputMode === "jsonl" ? (event) => printJson(event) : void 0
-        });
+        }) : void 0;
         try {
           await updateSessionActivityTimestampsBestEffort(manager, sessionId);
           await ensureSessionDocSynced(sessionDoc, `session.chat:${sessionId}:${userTurnId}`);
@@ -181862,6 +182686,18 @@ ${entry.text}`).join("\n\n");
           }
           return;
         }
+        if (options.wait === true) {
+          try {
+            if (!completionPromise) {
+              throw new Error("Missing completion promise for session chat --wait output.");
+            }
+            const completedTurn = await completionPromise;
+            console.log(renderAssistantTurnCompletion(completedTurn.content));
+          } catch (error2) {
+            throw buildStructuredWaitError("json", sessionId, userTurnId, error2);
+          }
+          return;
+        }
         console.log(userTurnId);
       });
     });
@@ -181903,11 +182739,14 @@ ${entry.text}`).join("\n\n");
       });
     });
   });
-  const sessionListCommand = new Command("list").description("List sessions in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--archived", "Only include archived sessions").option("--all", "Include active and archived sessions").option("--limit <count>", "Maximum number of sessions to print", parsePositiveIntOption).option("--json", "Print JSON output").option("--debug", "Enable debug output").action(async (options) => {
+  const sessionListCommand = new Command("list").description("List sessions in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--archived", "Only include archived sessions").option("--all", "Include active and archived sessions").option("--limit <count>", "Maximum number of sessions to print", parsePositiveIntOption$1).option("--offline", "Read the local cache without syncing first").option("--json", "Print JSON output").option("--debug", "Enable debug output").action(async (options) => {
     await runSessionCommand(options, async () => {
       const auth = getAuthContextOrThrow();
       const workspace = await resolveWorkspaceOrThrow(auth, options.workspace);
       await withWorkspaceManager(auth, workspace, async (manager) => {
+        if (options.offline !== true) {
+          await syncWorkspaceMetaForRead(manager, `session.list:${workspace.id}`);
+        }
         const sessions = sortSessionMetas(filterSessionMetas(await listSessionMetasForWorkspace(manager), {
           archivedOnly: options.archived,
           includeAll: options.all
@@ -181925,7 +182764,7 @@ ${entry.text}`).join("\n\n");
       });
     });
   });
-  const sessionHistoryCommand = new Command("history").description("Read visible session transcript history").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--limit <count>", "Maximum number of transcript turns to print", parsePositiveIntOption).option("--all", "Include all transcript turns").option("--reverse", "Print newest transcript turns first").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").action(async (sessionIdArg, options) => {
+  const sessionHistoryCommand = new Command("history").description("Read visible session transcript history").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--limit <count>", "Maximum number of transcript turns to print", parsePositiveIntOption$1).option("--all", "Include all transcript turns").option("--reverse", "Print newest transcript turns first").option("--offline", "Read the local cache without syncing first").option("--json", "Print JSON output").option("--jsonl", "Print JSON Lines output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").action(async (sessionIdArg, options) => {
     await runSessionCommand(options, async () => {
       const outputMode = resolveStructuredOutputMode(options);
       if (options.all && typeof options.limit === "number") {
@@ -181936,8 +182775,13 @@ ${entry.text}`).join("\n\n");
       if (!sessionId) {
         throw new Error("Missing session ID. Pass one explicitly or set LODY_SESSION_ID.");
       }
-      const workspace = await resolveWorkspaceForSessionOrThrow(auth, sessionId, options.workspace);
+      const workspace = await resolveWorkspaceForSessionOrThrow(auth, sessionId, {
+        workspace: options.workspace,
+        offline: options.offline,
+        reason: `session.history.resolve:${sessionId}`
+      });
       await withWorkspaceManager(auth, workspace, async (manager) => {
+        await syncSessionReadData(manager, sessionId, options.offline, `session.history:${sessionId}`);
         await resolveSessionMetaOrThrow(manager, sessionId);
         const sessionDoc = await manager.getOrCreateSessionDoc(sessionId);
         const transcript = toSessionTranscriptEntries(await sessionDoc.getHistory());
@@ -181971,15 +182815,20 @@ ${entry.text}`).join("\n\n");
       });
     });
   });
-  const sessionShowCommand = new Command("show").description("Show session metadata").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").action(async (sessionIdArg, options) => {
+  const sessionShowCommand = new Command("show").description("Show session metadata").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--offline", "Read the local cache without syncing first").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").action(async (sessionIdArg, options) => {
     await runSessionCommand(options, async () => {
       const auth = getAuthContextOrThrow();
       const sessionId = normalizeCliValue(sessionIdArg) ?? normalizeCliValue(process.env.LODY_SESSION_ID);
       if (!sessionId) {
         throw new Error("Missing session ID. Pass one explicitly or set LODY_SESSION_ID.");
       }
-      const workspace = await resolveWorkspaceForSessionOrThrow(auth, sessionId, options.workspace);
+      const workspace = await resolveWorkspaceForSessionOrThrow(auth, sessionId, {
+        workspace: options.workspace,
+        offline: options.offline,
+        reason: `session.show.resolve:${sessionId}`
+      });
       await withWorkspaceManager(auth, workspace, async (manager) => {
+        await syncSessionReadData(manager, sessionId, options.offline, `session.show:${sessionId}`);
         const result = await buildSessionShowResult(workspace, manager, sessionId);
         if (options.json) {
           printJson({
@@ -181992,6 +182841,32 @@ ${entry.text}`).join("\n\n");
       });
     });
   });
+  const sessionStatusCommand = new Command("status").description("Show current session status").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--offline", "Read the local cache without syncing first").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").action(async (sessionIdArg, options) => {
+    await runSessionCommand(options, async () => {
+      const auth = getAuthContextOrThrow();
+      const sessionId = normalizeCliValue(sessionIdArg) ?? normalizeCliValue(process.env.LODY_SESSION_ID);
+      if (!sessionId) {
+        throw new Error("Missing session ID. Pass one explicitly or set LODY_SESSION_ID.");
+      }
+      const workspace = await resolveWorkspaceForSessionOrThrow(auth, sessionId, {
+        workspace: options.workspace,
+        offline: options.offline,
+        reason: `session.status.resolve:${sessionId}`
+      });
+      await withWorkspaceManager(auth, workspace, async (manager) => {
+        await syncSessionReadData(manager, sessionId, options.offline, `session.status:${sessionId}`);
+        const result = await buildSessionStatusResult(workspace, manager, sessionId);
+        if (options.json) {
+          printJson({
+            ok: true,
+            ...result
+          });
+          return;
+        }
+        printHumanSessionStatus(result);
+      });
+    });
+  });
   const sessionRenameCommand = new Command("rename").description("Rename a session").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--title <title>", "New session title").option("--json", "Print JSON output").option("--debug", "Enable debug output").argument("[sessionId]", "Session ID; falls back to LODY_SESSION_ID").argument("[title]", "New session title").action(async (sessionIdArg, titleArg, options) => {
     await runSessionCommand(options, async () => {
       const auth = getAuthContextOrThrow();
@@ -182200,7 +183075,270 @@ ${entry.text}`).join("\n\n");
       });
     });
   });
-  const sessionCommand = new Command("session").description("Manage sessions without the web UI").addCommand(sessionCreateCommand).addCommand(sessionChatCommand).addCommand(sessionCancelCommand).addCommand(sessionListCommand).addCommand(sessionHistoryCommand).addCommand(sessionShowCommand).addCommand(sessionRenameCommand).addCommand(sessionArchiveCommand).addCommand(sessionRestoreCommand).addCommand(sessionDeleteCommand);
+  const sessionCommand = new Command("session").description("Manage sessions without the web UI").addCommand(sessionCreateCommand).addCommand(sessionChatCommand).addCommand(sessionCancelCommand).addCommand(sessionListCommand).addCommand(sessionHistoryCommand).addCommand(sessionShowCommand).addCommand(sessionStatusCommand).addCommand(sessionRenameCommand).addCommand(sessionArchiveCommand).addCommand(sessionRestoreCommand).addCommand(sessionDeleteCommand);
+  async function mapWithConcurrency(items2, concurrency, worker) {
+    if (items2.length === 0) {
+      return [];
+    }
+    const limit2 = Math.max(1, Math.floor(concurrency));
+    const results = new Array(items2.length);
+    let nextIndex = 0;
+    const runWorker = async () => {
+      while (nextIndex < items2.length) {
+        const currentIndex = nextIndex;
+        nextIndex += 1;
+        results[currentIndex] = await worker(items2[currentIndex], currentIndex);
+      }
+    };
+    await Promise.all(Array.from({
+      length: Math.min(limit2, items2.length)
+    }, () => runWorker()));
+    return results;
+  }
+  const DEFAULT_SYNC_CONCURRENCY = 4;
+  function parsePositiveIntOption(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(`Invalid numeric value: ${value}`);
+    }
+    return parsed;
+  }
+  function createWorkspaceSummary(workspaceId) {
+    return {
+      workspaceId,
+      totals: {
+        meta: 0,
+        doc: 0,
+        flock: 0
+      },
+      completed: {
+        meta: 0,
+        doc: 0,
+        flock: 0
+      },
+      failed: {
+        meta: 0,
+        doc: 0,
+        flock: 0
+      },
+      failures: []
+    };
+  }
+  function mergeSummaries(workspaces) {
+    const failures2 = workspaces.flatMap((workspace) => workspace.failures);
+    let total = 0;
+    let completed = 0;
+    let failed = 0;
+    for (const workspace of workspaces) {
+      for (const kind of [
+        "meta",
+        "doc",
+        "flock"
+      ]) {
+        total += workspace.totals[kind];
+        completed += workspace.completed[kind];
+        failed += workspace.failed[kind];
+      }
+    }
+    return {
+      ok: failures2.length === 0,
+      workspaces,
+      total,
+      completed,
+      failed,
+      failures: failures2
+    };
+  }
+  function buildProgressEvent(input2) {
+    return {
+      type: "progress",
+      workspaceId: input2.workspaceId,
+      kind: input2.kind,
+      id: input2.id,
+      total: input2.total,
+      completed: input2.completed,
+      failed: input2.failed,
+      remaining: Math.max(0, input2.total - input2.completed - input2.failed),
+      ok: input2.ok,
+      ...input2.error ? {
+        error: input2.error
+      } : {}
+    };
+  }
+  function printHumanProgress(event) {
+    const status = event.ok ? "synced" : "failed";
+    const failedText = event.failed > 0 ? `, failed ${event.failed}` : "";
+    console.log(`[${event.workspaceId}] ${event.kind} ${event.id}: ${status} (${event.completed}/${event.total}${failedText})`);
+    if (event.error) {
+      console.log(`  ${event.error}`);
+    }
+  }
+  function emitProgress(event, outputMode) {
+    if (outputMode === "jsonl") {
+      printJson(event);
+      return;
+    }
+    if (outputMode === "human") {
+      printHumanProgress(event);
+    }
+  }
+  function recordSyncResult(args2) {
+    if (args2.ok) {
+      args2.summary.completed[args2.kind] += 1;
+    } else {
+      args2.summary.failed[args2.kind] += 1;
+      args2.summary.failures.push({
+        workspaceId: args2.summary.workspaceId,
+        kind: args2.kind,
+        id: args2.id,
+        error: args2.error ?? "Sync failed."
+      });
+    }
+    emitProgress(buildProgressEvent({
+      workspaceId: args2.summary.workspaceId,
+      kind: args2.kind,
+      id: args2.id,
+      total: args2.summary.totals[args2.kind],
+      completed: args2.summary.completed[args2.kind],
+      failed: args2.summary.failed[args2.kind],
+      ok: args2.ok,
+      error: args2.error
+    }), args2.outputMode);
+  }
+  async function syncItems(input2) {
+    input2.summary.totals[input2.kind] = input2.ids.length;
+    await mapWithConcurrency(input2.ids, input2.concurrency, async (id2) => {
+      try {
+        await input2.syncOne(id2);
+        recordSyncResult({
+          summary: input2.summary,
+          kind: input2.kind,
+          id: id2,
+          ok: true,
+          outputMode: input2.outputMode
+        });
+      } catch (error2) {
+        recordSyncResult({
+          summary: input2.summary,
+          kind: input2.kind,
+          id: id2,
+          ok: false,
+          error: formatErrorMessage(error2),
+          outputMode: input2.outputMode
+        });
+      }
+    });
+  }
+  async function listMachineFlockDocIds(manager, workspaceId) {
+    const machines = await listAliveDocMetas(manager, isMachineDocRoomId);
+    return machines.map((entry) => getMachineFlockDocId(workspaceId, entry.meta.id)).sort((left2, right2) => left2.localeCompare(right2));
+  }
+  async function syncWorkspace(input2) {
+    const workspaceId = input2.workspace.id;
+    const summary2 = createWorkspaceSummary(input2.workspace.id);
+    await withWorkspaceManager$1(input2.auth, input2.workspace, "sync", async (manager) => {
+      summary2.totals.meta = 1;
+      try {
+        await manager.syncMetaOrThrow({
+          reason: `sync:${workspaceId}:meta`
+        });
+        recordSyncResult({
+          summary: summary2,
+          kind: "meta",
+          id: "meta",
+          ok: true,
+          outputMode: input2.outputMode
+        });
+      } catch (error2) {
+        recordSyncResult({
+          summary: summary2,
+          kind: "meta",
+          id: "meta",
+          ok: false,
+          error: formatErrorMessage(error2),
+          outputMode: input2.outputMode
+        });
+        return;
+      }
+      const docIds = (await listAliveRoomIds(manager, () => true)).sort((left2, right2) => left2.localeCompare(right2));
+      const flockDocIds = await listMachineFlockDocIds(manager, workspaceId);
+      await syncItems({
+        summary: summary2,
+        kind: "doc",
+        ids: docIds,
+        concurrency: input2.concurrency,
+        outputMode: input2.outputMode,
+        syncOne: async (id2) => {
+          await manager.syncDocOrThrow(id2, {
+            reason: `sync:${workspaceId}:doc:${id2}`
+          });
+        }
+      });
+      await syncItems({
+        summary: summary2,
+        kind: "flock",
+        ids: flockDocIds,
+        concurrency: input2.concurrency,
+        outputMode: input2.outputMode,
+        syncOne: async (id2) => {
+          await manager.syncFlockDocOrThrow(id2, {
+            reason: `sync:${workspaceId}:flock:${id2}`
+          });
+        }
+      });
+    });
+    return summary2;
+  }
+  function printHumanSummary(summary2) {
+    console.log(`Finished sync: ${summary2.completed}/${summary2.total} item(s) synced, ${summary2.failed} failed.`);
+    if (summary2.failures.length > 0) {
+      console.log("Failures:");
+      for (const failure of summary2.failures) {
+        console.log(`- [${failure.workspaceId}] ${failure.kind} ${failure.id}: ${failure.error}`);
+      }
+    }
+  }
+  function createAlreadyPrintedError() {
+    return Object.assign(new Error("Sync completed with failures."), {
+      suppressCommandErrorOutput: true,
+      exitCode: 1
+    });
+  }
+  const syncCommand = new Command("sync").description("Sync workspace Loro data to the local cache").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--all-workspace", "Sync all accessible workspaces").option("--concurrency <count>", "Maximum number of documents to sync concurrently", parsePositiveIntOption, DEFAULT_SYNC_CONCURRENCY).option("--json", "Print final JSON summary").option("--jsonl", "Print JSON Lines progress events and final summary").option("--debug", "Enable debug output").action(async (options) => {
+    await runOneShotCommand("sync", options, async () => {
+      const outputMode = resolveStructuredOutputMode$1(options);
+      const auth = getAuthContextOrThrow$1("sync");
+      if (options.allWorkspace && options.workspace) {
+        throw new Error("Pass either --workspace or --all-workspace, not both.");
+      }
+      const workspaces = options.allWorkspace ? await listWorkspacesForToken(auth.token) : [
+        await resolveWorkspaceOrThrow$1(auth, options.workspace)
+      ];
+      const workspaceSummaries = [];
+      for (const workspace of workspaces) {
+        workspaceSummaries.push(await syncWorkspace({
+          auth,
+          workspace,
+          concurrency: options.concurrency ?? DEFAULT_SYNC_CONCURRENCY,
+          outputMode
+        }));
+      }
+      const summary2 = mergeSummaries(workspaceSummaries);
+      if (outputMode === "jsonl") {
+        printJson({
+          type: "summary",
+          ...summary2
+        });
+      } else if (outputMode === "json") {
+        printJson(summary2);
+      } else {
+        printHumanSummary(summary2);
+      }
+      if (!summary2.ok) {
+        throw createAlreadyPrintedError();
+      }
+    });
+  });
   function sortWorkspaceSummaries(workspaces) {
     return [
       ...workspaces
@@ -182342,19 +183480,53 @@ ${entry.text}`).join("\n\n");
       } : {}
     };
   }
-  function toMachineJsonEntry(machine, includeAcpCapabilities) {
-    if (includeAcpCapabilities) {
-      return machine;
+  function toMachineJsonEntry(machine, options) {
+    const withoutOptional = {
+      ...machine
+    };
+    if (!options.includeAcpCapabilities) {
+      delete withoutOptional.acpCapabilities;
     }
-    const { acpCapabilities: _acpCapabilities, ...rest } = machine;
-    return rest;
+    if (!options.includeAgents) {
+      delete withoutOptional.agentConfigs;
+    }
+    return withoutOptional;
+  }
+  function formatMachineAgents(machine) {
+    const configs = machine.agentConfigs ?? [];
+    if (configs.length === 0) {
+      return "-";
+    }
+    return configs.map((config2) => `${config2.name} (${config2.agentType})`).join(",");
   }
-  function printHumanMachineList(machines, currentMachineId) {
+  async function attachAgentConfigsToMachines(repo, workspaceId, machines) {
+    const configs = await listMergedAgentConfigs(repo, workspaceId, machines.map((machine) => machine.id));
+    const configsByMachine = /* @__PURE__ */ new Map();
+    for (const config2 of configs) {
+      const current2 = configsByMachine.get(config2.machineId) ?? [];
+      current2.push(config2);
+      configsByMachine.set(config2.machineId, current2);
+    }
+    for (const values of configsByMachine.values()) {
+      values.sort((left2, right2) => {
+        const nameCompare = left2.name.localeCompare(right2.name);
+        if (nameCompare !== 0) {
+          return nameCompare;
+        }
+        return left2.id.localeCompare(right2.id);
+      });
+    }
+    return machines.map((machine) => ({
+      ...machine,
+      agentConfigs: configsByMachine.get(machine.id) ?? []
+    }));
+  }
+  function printHumanMachineList(machines, currentMachineId, includeAgents) {
     if (machines.length === 0) {
       console.log("No machines found.");
       return;
     }
-    console.log(renderTerminalTable([
+    const columns = [
       {
         header: "ID"
       },
@@ -182367,30 +183539,49 @@ ${entry.text}`).join("\n\n");
       {
         header: "CLI"
       }
-    ], machines.map((machine) => [
-      machine.id,
-      machine.id === currentMachineId ? `${machine.name} (current)` : machine.name,
-      machine.online ? "online" : "offline",
-      formatMachineCli(machine)
-    ])));
+    ];
+    if (includeAgents) {
+      columns.push({
+        header: "Agents"
+      });
+    }
+    console.log(renderTerminalTable(columns, machines.map((machine) => {
+      const row = [
+        machine.id,
+        machine.id === currentMachineId ? `${machine.name} (current)` : machine.name,
+        machine.online ? "online" : "offline",
+        formatMachineCli(machine)
+      ];
+      if (includeAgents) {
+        row.push(formatMachineAgents(machine));
+      }
+      return row;
+    })));
   }
-  const machineCommand = new Command("machine").description("Inspect registered machines").addCommand(new Command("list").description("List machines in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--online-only", "Only include machines with a recent heartbeat").option("--json", "Print JSON output").option("--include-acp-capabilities", "Include acpCapabilities in JSON output").option("--debug", "Enable debug output").action(async (options) => {
+  const machineCommand = new Command("machine").description("Inspect registered machines").addCommand(new Command("list").description("List machines in a workspace").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--online-only", "Only include machines with a recent heartbeat").option("--json", "Print JSON output").option("--include-acp-capabilities", "Include acpCapabilities in JSON output").option("--include-agents", "Include agent config summaries per machine").option("--debug", "Enable debug output").action(async (options) => {
     await runOneShotCommand("machine", options, async () => {
       const auth = getAuthContextOrThrow$1("machine");
       const workspace = await resolveWorkspaceOrThrow$1(auth, options.workspace);
       await withWorkspaceManager$1(auth, workspace, "machine", async (manager) => {
-        const machines = sortMachineMetas((await listAliveDocMetas(manager, isMachineDocRoomId)).map((entry) => entry.meta), auth.machineId).map(toMachineListEntry).filter((machine) => !options.onlineOnly || machine.online);
+        let machines = sortMachineMetas((await listAliveDocMetas(manager, isMachineDocRoomId)).map((entry) => entry.meta), auth.machineId).map(toMachineListEntry).filter((machine) => !options.onlineOnly || machine.online);
+        if (options.includeAgents === true) {
+          machines = await attachAgentConfigsToMachines(manager.repo, workspace.id, machines);
+        }
         if (options.json) {
           const includeAcpCapabilities = options.includeAcpCapabilities === true;
+          const includeAgents = options.includeAgents === true;
           const jsonMachines = await Promise.all(machines.map((machine) => mergeMachineFlockJsonState(manager.repo, workspace.id, machine, includeAcpCapabilities)));
           printJson({
             ok: true,
             workspaceId: workspace.id,
-            machines: jsonMachines.map((machine) => toMachineJsonEntry(machine, includeAcpCapabilities))
+            machines: jsonMachines.map((machine) => toMachineJsonEntry(machine, {
+              includeAcpCapabilities,
+              includeAgents
+            }))
           });
           return;
         }
-        printHumanMachineList(machines, auth.machineId);
+        printHumanMachineList(machines, auth.machineId, options.includeAgents === true);
       });
     });
   }));
@@ -182572,25 +183763,6 @@ ${entry.text}`).join("\n\n");
       ].sort((left2, right2) => left2.imageId.localeCompare(right2.imageId))
     };
   }
-  async function mapWithConcurrency(items2, concurrency, worker) {
-    if (items2.length === 0) {
-      return [];
-    }
-    const limit2 = Math.max(1, Math.floor(concurrency));
-    const results = new Array(items2.length);
-    let nextIndex = 0;
-    const runWorker = async () => {
-      while (nextIndex < items2.length) {
-        const currentIndex = nextIndex;
-        nextIndex += 1;
-        results[currentIndex] = await worker(items2[currentIndex], currentIndex);
-      }
-    };
-    await Promise.all(Array.from({
-      length: Math.min(limit2, items2.length)
-    }, () => runWorker()));
-    return results;
-  }
   const MIME_EXTENSION_MAP = {
     "image/png": ".png",
     "image/jpeg": ".jpg",
@@ -183011,6 +184183,7 @@ ${entry.text}`).join("\n\n");
       warnings
     };
   }
+  const EXPORT_SYNC_CONCURRENCY = 4;
   function buildDefaultOutputDir() {
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
     return path__default$1.resolve(process.cwd(), `lody-export-${timestamp2}`);
@@ -183019,7 +184192,14 @@ ${entry.text}`).join("\n\n");
     const candidate = (workspace.slug?.trim() || workspace.id).trim();
     return candidate.replace(/[\\/]/g, "_");
   }
-  const exportCommand = new Command("export").description("Export user-facing workspace session data").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--all-workspace", "Export all accessible workspaces").option("--no-images", "Skip downloading image binaries").option("--debug", "Enable debug output").argument("[outputDir]", "Output directory for export files").action(async (outputDirArg, options) => {
+  async function syncWorkspaceSessionsForExport(manager, workspace) {
+    await syncWorkspaceMetaForRead(manager, `export:${workspace.id}:meta`);
+    const sessions = await listAliveDocMetas(manager, isSessionDocRoomId);
+    await mapWithConcurrency(sessions, EXPORT_SYNC_CONCURRENCY, async (entry) => {
+      await syncDocForRead(manager, getSessionRoomId(entry.meta.id), `export:${workspace.id}:${entry.meta.id}`);
+    });
+  }
+  const exportCommand = new Command("export").description("Export user-facing workspace session data").option("--workspace <idOrSlug>", "Target workspace id or slug").option("--all-workspace", "Export all accessible workspaces").option("--no-images", "Skip downloading image binaries").option("--offline", "Read the local cache without syncing first").option("--debug", "Enable debug output").argument("[outputDir]", "Output directory for export files").action(async (outputDirArg, options) => {
     await runOneShotCommand("export", options, async () => {
       const auth = getAuthContextOrThrow$1("export");
       const outputDir = path__default$1.resolve(outputDirArg ?? buildDefaultOutputDir());
@@ -183034,6 +184214,9 @@ ${entry.text}`).join("\n\n");
       for (const workspace of workspaces) {
         const workspaceOutputDir = path__default$1.join(outputDir, toWorkspaceDirName(workspace));
         const result = await withWorkspaceManager$1(auth, workspace, "export", async (manager) => {
+          if (options.offline !== true) {
+            await syncWorkspaceSessionsForExport(manager, workspace);
+          }
           return await exportWorkspaceData({
             manager,
             workspace,
@@ -183157,7 +184340,7 @@ ${entry.text}`).join("\n\n");
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-DoxiB4Vb.js");
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer--K5LcsS4.js");
     const template = await resolveReviewViewerTemplate();
     const html = injectReviewSnapshot(template, data);
     const outputPath = options.output ? path__default$1.resolve(options.output) : defaultHtmlOutputPath(inputPath);
@@ -200486,6 +201669,7 @@ ${lines2.join("\n")}` : ""}${suffix}`);
   program.addCommand(startCommand);
   program.addCommand(projectCommand);
   program.addCommand(sessionCommand);
+  program.addCommand(syncCommand);
   program.addCommand(workspaceCommand);
   program.addCommand(agentConfigCommand);
   program.addCommand(machineCommand);