lody 0.72.0 → 0.73.0

package/dist/index.js

@@ -58,7 +58,7 @@ import require$$1$5 from "node:worker_threads";
 import require$$1$7, { fileURLToPath } from "node:url";
 import require$$1$8 from "node:console";
 import require$$1$9 from "node:dns";
-import { C as CodeCollabV2OpenTextRequestSchema, a as CodeCollabV2RefreshTextRequestSchema, b as CodeCollabV2SaveTextRequestSchema, c as CodeCollabV2OpenCurrentDiffRequestSchema, d as CodeCollabV2OpenAllChangesDiffRequestSchema, e as CodeCollabV2OpenTurnDiffRequestSchema, f as CodeCollabV2InitDirectoryRequestSchema, g as CodeCollabV2OpenTextOkSchema, h as CodeCollabV2RefreshTextResponseSchema, i as CodeCollabV2SaveTextResponseSchema, j as CodeCollabV2OpenCurrentDiffResponseSchema, k as CodeCollabV2OpenAllChangesDiffResponseSchema, l as CodeCollabV2OpenTurnDiffResponseSchema, m as CodeCollabV2InitDirectoryOkSchema, n as CodeCollabV2LspUnsupportedSchema, o as CodeCollabV2ErrorSchema, p as CodeCollabV2RpcContentEnvelopeSchema, q as deriveCodeCollabV2ContentKeyId, r as CodeCollabV2ErrorCodeSchema, s as CodeCollabV2RpcResponseSchema, t as deriveCodeCollabV2ContentKeyBytes, u as buildCodeCollabFileIndexState, v as CODE_COLLAB_V2_TEXT_LIMITS, w as CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS, x as computeAllChanges, y as codeCollabFileIndexStatesEqual, z as scanGitDirectoryEntries, A as closeDirectoryQuietly, B as readCodeCollabFileIndexSignalFromFlock, D as writeCodeCollabFileIndexSignalToFlock, E as writeCodeCollabFileIndexToFlock } from "./chunks/directory-handle-D57OdGy1.js";
+import { C as CodeCollabV2OpenTextRequestSchema, a as CodeCollabV2RefreshTextRequestSchema, b as CodeCollabV2SaveTextRequestSchema, c as CodeCollabV2OpenCurrentDiffRequestSchema, d as CodeCollabV2OpenAllChangesDiffRequestSchema, e as CodeCollabV2OpenTurnDiffRequestSchema, f as CodeCollabV2InitDirectoryRequestSchema, g as CodeCollabV2OpenTextOkSchema, h as CodeCollabV2RefreshTextResponseSchema, i as CodeCollabV2SaveTextResponseSchema, j as CodeCollabV2OpenCurrentDiffResponseSchema, k as CodeCollabV2OpenAllChangesDiffResponseSchema, l as CodeCollabV2OpenTurnDiffResponseSchema, m as CodeCollabV2InitDirectoryOkSchema, n as CodeCollabV2LspUnsupportedSchema, o as CodeCollabV2ErrorSchema, p as CodeCollabV2RpcContentEnvelopeSchema, q as deriveCodeCollabV2ContentKeyId, r as CodeCollabV2ErrorCodeSchema, s as CodeCollabV2RpcResponseSchema, t as deriveCodeCollabV2ContentKeyBytes, u as readCodeCollabFileIndexSignalFromFlock, w as writeCodeCollabFileIndexSignalToFlock, v as writeCodeCollabFileIndexToFlock, x as buildCodeCollabFileIndexState, y as CODE_COLLAB_V2_TEXT_LIMITS, z as CODE_COLLAB_V2_ALL_CHANGES_DIFF_LIMITS, A as computeAllChanges, B as codeCollabFileIndexStatesEqual, D as scanGitDirectoryEntries, E as closeDirectoryQuietly } from "./chunks/directory-handle-QE16b3Ol.js";
 import * as fs$2 from "node:fs/promises";
 import fs__default$3, { mkdir as mkdir$1, mkdtemp, chmod, writeFile, rm, rename, stat, lstat, symlink, readdir, unlink, readFile, open, realpath, opendir } from "node:fs/promises";
 import { pipeline } from "node:stream/promises";
@@ -4190,7 +4190,7 @@ let __tla = Promise.all([
     }
   }
   const name$1 = "lody";
-  const version$7 = "0.72.0";
+  const version$7 = "0.73.0";
   const description$1 = "Lody Agent CLI tool for managing remote command execution";
   const type$2 = "module";
   const main$4 = "dist/index.js";
@@ -4617,22 +4617,22 @@ let __tla = Promise.all([
   const CODEX_REASONING_OPTIONS = [
     {
       value: "low",
-      name: "low",
+      name: "Low",
       description: "Fastest responses"
     },
     {
       value: "medium",
-      name: "medium",
+      name: "Medium",
       description: "Balanced reasoning"
     },
     {
       value: "high",
-      name: "high",
+      name: "High",
       description: "More reasoning for difficult tasks"
     },
     {
       value: "xhigh",
-      name: "xhigh",
+      name: "XHigh",
       description: "Extra reasoning for complex tasks"
     }
   ];
@@ -74726,6 +74726,7 @@ ${val.stack}`;
     return new Promise((resolve2) => setTimeout(resolve2, 0));
   }
   const YIELD_BUDGET_MS = 5;
+  const DEFAULT_COMPACTION_BYTE_THRESHOLD = 100 * 1024;
   const nowMs = typeof globalThis.performance?.now === "function" ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
   function stableVersion(vector) {
     const sorted = {};
@@ -74752,6 +74753,7 @@ ${val.stack}`;
     ensureFlockDocExists;
     retentionMs;
     persistDebounceMs;
+    compactionByteThreshold;
     flocks = /* @__PURE__ */ new Map();
     subscriptions = /* @__PURE__ */ new Map();
     persistedVersions = /* @__PURE__ */ new Map();
@@ -74759,6 +74761,8 @@ ${val.stack}`;
     dirtyFlockDocs = /* @__PURE__ */ new Set();
     existenceMaterialized = /* @__PURE__ */ new Set();
     docsWithVisibleContent = /* @__PURE__ */ new Set();
+    updateBytesSinceCompaction = /* @__PURE__ */ new Map();
+    queuedCompactions = /* @__PURE__ */ new Set();
     debounceTimer;
     flushScheduled = false;
     operationPromise = Promise.resolve();
@@ -74769,6 +74773,8 @@ ${val.stack}`;
       this.retentionMs = options.retentionMs;
       const configured = options.persistDebounceMs;
       this.persistDebounceMs = typeof configured === "number" && Number.isFinite(configured) && configured >= 0 ? configured : 0;
+      const configuredCompactionThreshold = options.compactionByteThreshold;
+      this.compactionByteThreshold = typeof configuredCompactionThreshold === "number" && Number.isFinite(configuredCompactionThreshold) && configuredCompactionThreshold >= 0 ? Math.floor(configuredCompactionThreshold) : DEFAULT_COMPACTION_BYTE_THRESHOLD;
     }
     async openFlockDoc(flockDocId) {
       return this.ensureFlockDoc(flockDocId);
@@ -74822,16 +74828,26 @@ ${val.stack}`;
         throw error2;
       }
     }
+    async persistFlockDocChanges(flockDocId, flock) {
+      await this.enqueueOperation(async () => {
+        if (this.flocks.get(flockDocId) !== flock) return;
+        await this.persistFlockDocUpdate(flockDocId, flock);
+      });
+    }
     async unloadFlockDoc(flockDocId) {
-      const flock = this.flocks.get(flockDocId);
-      if (!flock) return;
-      await this.persistFlockDocUpdate(flockDocId, flock);
-      this.subscriptions.get(flockDocId)?.();
-      this.subscriptions.delete(flockDocId);
-      this.flocks.delete(flockDocId);
-      this.persistedVersions.delete(flockDocId);
-      this.existenceMaterialized.delete(flockDocId);
-      this.docsWithVisibleContent.delete(flockDocId);
+      await this.enqueueOperation(async () => {
+        const flock = this.flocks.get(flockDocId);
+        if (!flock) return;
+        await this.persistFlockDocUpdate(flockDocId, flock);
+        this.subscriptions.get(flockDocId)?.();
+        this.subscriptions.delete(flockDocId);
+        this.flocks.delete(flockDocId);
+        this.persistedVersions.delete(flockDocId);
+        this.dirtyFlockDocs.delete(flockDocId);
+        this.existenceMaterialized.delete(flockDocId);
+        this.docsWithVisibleContent.delete(flockDocId);
+        this.updateBytesSinceCompaction.delete(flockDocId);
+      });
     }
     async dropFlockDoc(flockDocId) {
       await this.enqueueOperation(async () => {
@@ -74842,6 +74858,7 @@ ${val.stack}`;
         this.dirtyFlockDocs.delete(flockDocId);
         this.existenceMaterialized.delete(flockDocId);
         this.docsWithVisibleContent.delete(flockDocId);
+        this.updateBytesSinceCompaction.delete(flockDocId);
         await this.storage?.deleteFlockDoc?.(flockDocId);
       });
     }
@@ -74850,6 +74867,7 @@ ${val.stack}`;
       this.flushScheduled = false;
       while (true) {
         await this.enqueueOperation(() => this.drainDirtyFlockDocs());
+        await this.operationPromise;
         if (this.dirtyFlockDocs.size === 0 && !this.flushScheduled) break;
         this.flushScheduled = false;
       }
@@ -74871,6 +74889,8 @@ ${val.stack}`;
         this.dirtyFlockDocs.clear();
         this.existenceMaterialized.clear();
         this.docsWithVisibleContent.clear();
+        this.updateBytesSinceCompaction.clear();
+        this.queuedCompactions.clear();
       }
     }
     async loadOrCreateFlockDoc(flockDocId) {
@@ -74919,22 +74939,23 @@ ${val.stack}`;
       }
       if (versionEquals(previousVersion, nextVersion)) {
         await this.materializeExistence(flockDocId, flock);
-        this.dirtyFlockDocs.delete(flockDocId);
+        this.clearDirtyIfStable(flockDocId, nextVersion, flock);
         return;
       }
       const bundle = await exportJsonUpdate(flock, previousVersion);
       if (!hasBundleEntries(bundle)) {
         await this.materializeExistence(flockDocId, flock);
         this.persistedVersions.set(flockDocId, nextVersion);
-        this.dirtyFlockDocs.delete(flockDocId);
+        this.clearDirtyIfStable(flockDocId, nextVersion, flock);
         return;
       }
+      const update2 = encodeMetaJsonUpdate(bundle);
       this.persistedVersions.set(flockDocId, nextVersion);
       try {
         await this.storage.save({
           type: "flock-doc-update",
           flockDocId,
-          update: encodeMetaJsonUpdate(bundle)
+          update: update2
         });
         await this.materializeExistence(flockDocId, flock);
         this.clearDirtyIfStable(flockDocId, nextVersion, flock);
@@ -74942,6 +74963,31 @@ ${val.stack}`;
         this.persistedVersions.set(flockDocId, previousVersion);
         throw error2;
       }
+      this.scheduleFlockDocCompaction(flockDocId, flock, update2.byteLength);
+    }
+    scheduleFlockDocCompaction(flockDocId, flock, updateBytes) {
+      if (this.compactionByteThreshold === 0 || !this.storage?.compactFlockDoc) return;
+      const total = (this.updateBytesSinceCompaction.get(flockDocId) ?? 0) + updateBytes;
+      this.updateBytesSinceCompaction.set(flockDocId, total);
+      if (total < this.compactionByteThreshold) return;
+      this.queueFlockDocCompaction(flockDocId, flock);
+    }
+    queueFlockDocCompaction(flockDocId, flock) {
+      if (this.queuedCompactions.has(flockDocId)) return;
+      const storage = this.storage;
+      if (!storage?.compactFlockDoc) return;
+      this.queuedCompactions.add(flockDocId);
+      this.enqueueOperation(async () => {
+        try {
+          await yieldToMacroTask();
+          if (this.flocks.get(flockDocId) !== flock) return;
+          await storage.compactFlockDoc?.(flockDocId);
+          if (this.flocks.has(flockDocId)) this.updateBytesSinceCompaction.set(flockDocId, 0);
+          else this.updateBytesSinceCompaction.delete(flockDocId);
+        } finally {
+          this.queuedCompactions.delete(flockDocId);
+        }
+      }).catch(logAsyncError(`Flock document "${flockDocId}" compaction`));
     }
     async materializeExistence(flockDocId, flock) {
       if (this.existenceMaterialized.has(flockDocId)) return;
@@ -75940,7 +75986,7 @@ ${val.stack}`;
         } finally {
           this.eventBus.popEventBy();
         }
-        await this.flockDocManager.persistFlockDoc(flockDocId, flock);
+        await this.flockDocManager.persistFlockDocChanges(flockDocId, flock);
       }
     }
     async buildSyncPlan(options, buildOptions = {}) {
@@ -76423,7 +76469,8 @@ ${val.stack}`;
         storage: this.storage,
         ensureFlockDocExists: (flockDocId, expiresAtMs) => this.flockDocRegistry.ensureExists(flockDocId, expiresAtMs),
         retentionMs: getFlockDocRetentionMs,
-        persistDebounceMs: options.docPersistDebounceMs
+        persistDebounceMs: options.docPersistDebounceMs,
+        compactionByteThreshold: options.flockDocCompactionByteThreshold
       });
       if (this.storage) this.metaPersister = new MetaPersister({
         getMetaFlock,
@@ -85100,6 +85147,7 @@ stream:${scope2.streamId}`;
       return {
         save: (payload) => this.saveStorage(payload),
         compactMeta: () => this.compactMeta(),
+        compactFlockDoc: (flockDocId) => this.compactFlockDoc(flockDocId),
         loadDoc: (docId) => this.loadDoc(docId),
         loadFlockDoc: (flockDocId) => this.loadFlockDoc(flockDocId),
         deleteDoc: (docId) => this.deleteDoc(docId),
@@ -85148,6 +85196,9 @@ stream:${scope2.streamId}`;
       if (state2.needsCompaction) this.finalizeFlockDocCompaction(flockDocId, state2, await exportFlockFileSnapshot(state2.flock));
       return state2.flock;
     }
+    async compactFlockDoc(flockDocId) {
+      await this.loadFlockDoc(flockDocId);
+    }
     loadDocBody(docId) {
       const snapshotRow = this.stmts.selectDocSnapshot.get(docId);
       const updateRows = this.stmts.selectDocUpdates.all(docId);
@@ -107450,16 +107501,23 @@ ${value}`;
       },
       readJsonLive: async (streamId, state2, onBatch, liveOptions) => {
         const { client: streamClient, context: context2 } = getStreamClient(streamId, "live");
+        const modePolicy = liveOptions?.modePolicy;
+        const requestedMode = modePolicy?.selectRequestMode() ?? options.liveMode ?? "sse";
+        let observedTransport;
+        let deliveredBatch = false;
+        let readError;
         const watchdog = createLiveIdleWatchdog(options.liveIdleTimeoutMs ?? DEFAULT_LIVE_IDLE_TIMEOUT_MS, liveOptions?.signal);
         try {
           for await (const event of streamClient.live({
             offset: state2.nextOffset ?? "now",
-            mode: options.liveMode ?? "sse",
+            mode: requestedMode,
             signal: watchdog.signal
           })) {
             watchdog.reset();
+            observedTransport = event.mode;
             switch (event.type) {
               case "data":
+                deliveredBatch = true;
                 state2.nextOffset = event.nextOffset;
                 state2.cursor = event.cursor;
                 await onBatch({
@@ -107470,6 +107528,7 @@ ${value}`;
                 });
                 break;
               case "up_to_date": {
+                deliveredBatch = true;
                 state2.nextOffset = event.nextOffset;
                 state2.cursor = event.cursor;
                 await onBatch({
@@ -107481,6 +107540,7 @@ ${value}`;
                 break;
               }
               case "eof": {
+                deliveredBatch = true;
                 state2.nextOffset = event.nextOffset;
                 state2.cursor = void 0;
                 await onBatch({
@@ -107498,8 +107558,19 @@ ${value}`;
                 throw toLoroGatewayError("read live updates from", streamId, event.error, context2);
             }
           }
+        } catch (error2) {
+          readError = error2;
+          throw error2;
         } finally {
           watchdog.dispose();
+          if (modePolicy && liveOptions?.signal?.aborted !== true) {
+            modePolicy.noteReadOutcome({
+              requestedMode,
+              observedTransport,
+              deliveredBatch,
+              error: readError
+            });
+          }
         }
       }
     };
@@ -107962,6 +108033,8 @@ ${value}`;
     constructor(options) {
       this.options = options;
       this.responseStreamId = options.responseStreamId ?? `${getLoroWorkspaceRpcResponseStreamId(options.workspaceId)}:${crypto.randomUUID()}`;
+      this.liveModePolicy = options.liveModePolicy;
+      this.lastReportedTransport = options.liveModePolicy?.getDiagnostics().transport;
     }
     responseStreamId;
     responseState = {
@@ -107969,8 +108042,14 @@ ${value}`;
     };
     pending = /* @__PURE__ */ new Map();
     stopController = new AbortController();
+    liveModePolicy;
+    currentReadController = null;
+    lastReportedTransport;
     startedPromise = null;
     stopped = false;
+    getLiveModeDiagnostics() {
+      return this.liveModePolicy?.getDiagnostics() ?? null;
+    }
     getResponseStreamId() {
       return this.responseStreamId;
     }
@@ -107987,6 +108066,7 @@ ${value}`;
       return new Promise((resolve2) => {
         const timeoutId = setTimeout(() => {
           this.pending.delete(requestId);
+          this.noteLiveModeResponseTimeout();
           resolve2(null);
         }, registration.timeoutMs);
         this.pending.set(requestId, {
@@ -108033,8 +108113,39 @@ ${value}`;
         this.pending.delete(requestId);
       }
     }
+    noteLiveModeResponseTimeout() {
+      if (!this.liveModePolicy) {
+        return;
+      }
+      this.liveModePolicy.noteResponseTimeout();
+      if (!this.reportLiveModeChange()) {
+        return;
+      }
+      this.currentReadController?.abort();
+    }
+    reportLiveModeChange() {
+      const diagnostics2 = this.liveModePolicy?.getDiagnostics();
+      if (!diagnostics2 || diagnostics2.transport === this.lastReportedTransport) {
+        return false;
+      }
+      this.lastReportedTransport = diagnostics2.transport;
+      const label2 = this.options.logLabel ?? this.options.workspaceId;
+      this.options.trace?.("machine rpc live transport changed", {
+        workspaceId: this.options.workspaceId,
+        responseStreamId: this.responseStreamId,
+        ...diagnostics2
+      });
+      this.options.logger?.warn?.(`[rpc-client:${label2}] live transport -> ${diagnostics2.transport} (${diagnostics2.reason})`);
+      return true;
+    }
     async runResponseLoop() {
       while (!this.stopped) {
+        const readController = new AbortController();
+        const onStop = () => readController.abort();
+        this.stopController.signal.addEventListener("abort", onStop, {
+          once: true
+        });
+        this.currentReadController = readController;
         try {
           await this.options.streamClient.readJsonLive(this.responseStreamId, this.responseState, async (batch) => {
             this.responseState.nextOffset = batch.nextOffset ?? this.responseState.nextOffset;
@@ -108043,7 +108154,8 @@ ${value}`;
               await this.handleRawResponse(raw2);
             }
           }, {
-            signal: this.stopController.signal
+            signal: readController.signal,
+            modePolicy: this.liveModePolicy
           });
         } catch (error2) {
           if (this.stopped) {
@@ -108065,6 +108177,10 @@ ${value}`;
           const message = error2 instanceof Error ? error2.message : String(error2);
           this.options.logger?.warn?.(`[rpc-client:${this.options.logLabel ?? this.options.workspaceId}] response loop error: ${message}`);
           await delay$4(1e3);
+        } finally {
+          this.stopController.signal.removeEventListener("abort", onStop);
+          this.currentReadController = null;
+          this.reportLiveModeChange();
         }
       }
     }
@@ -108078,6 +108194,7 @@ ${value}`;
       if (!pending2) {
         return;
       }
+      this.liveModePolicy?.noteResponseReceived();
       const receivedAtMs = Date.now();
       this.options.trace?.("machine rpc transport response received", {
         workspaceId: this.options.workspaceId,
@@ -109840,6 +109957,50 @@ ${value}`;
       }
     }
   }
+  class CodeCollabFileIndexChangedPublishError extends Error {
+    constructor(cause) {
+      super("Code Collab file-index publication failed after changing local Flock state.", {
+        cause
+      });
+      this.name = "CodeCollabFileIndexChangedPublishError";
+    }
+  }
+  async function publishCodeCollabFileIndexFlock(args2) {
+    const handle = await args2.repo.openFlockDoc(args2.flockDocId);
+    if (args2.reconcileRemote) {
+      await handle.syncOnce();
+    }
+    const changed = writeCodeCollabFileIndexToFlock(handle.flock, args2.fileIndex, args2.updatedAtMs);
+    if (!changed) {
+      return {
+        changed: false
+      };
+    }
+    try {
+      await args2.repo.flush();
+      await handle.syncOnce();
+    } catch (error2) {
+      throw new CodeCollabFileIndexChangedPublishError(error2);
+    }
+    return {
+      changed: true
+    };
+  }
+  async function publishCodeCollabFileIndexSignalFlock(args2) {
+    const handle = await args2.repo.openFlockDoc(args2.flockDocId);
+    await handle.syncOnce();
+    const previous = readCodeCollabFileIndexSignalFromFlock(handle.flock);
+    const revision = (previous?.r ?? 0) + 1;
+    const changed = writeCodeCollabFileIndexSignalToFlock(handle.flock, revision, args2.updatedAtMs);
+    if (changed) {
+      await args2.repo.flush();
+      await handle.syncOnce();
+    }
+    return {
+      changed,
+      revision
+    };
+  }
   const WorkspaceSummarySchema = object$1({
     id: string$1(),
     name: string$1(),
@@ -135149,6 +135310,30 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     const localProjects = await readMachineLocalProjects(repo, workspaceId, machineId);
     return localProjects[localProjectId] ?? null;
   }
+  const defaultSleep$1 = (ms2) => new Promise((resolve2) => setTimeout(resolve2, ms2));
+  async function resolveWorkspaceLocalProjectRootPathWithRetry(repo, workspaceId, machineId, localProjectId, options = {}) {
+    const maxAttempts = Math.max(1, options.maxAttempts ?? readTimeoutEnv("LODY_LOCAL_PROJECT_RESOLVE_MAX_ATTEMPTS", 4));
+    const retryDelayMs = options.retryDelayMs ?? readTimeoutEnv("LODY_LOCAL_PROJECT_RESOLVE_RETRY_DELAY_MS", 400);
+    const syncTimeoutMs = options.syncTimeoutMs ?? readTimeoutEnv("LODY_LOCAL_PROJECT_RESOLVE_SYNC_TIMEOUT_MS", 1500);
+    const sleep2 = options.sleep ?? defaultSleep$1;
+    for (let attempt = 1; ; attempt += 1) {
+      const rootPath = await resolveWorkspaceLocalProjectRootPath(repo, workspaceId, machineId, localProjectId);
+      if (rootPath !== null) {
+        return rootPath;
+      }
+      if (attempt >= maxAttempts) {
+        return null;
+      }
+      options.onRetry?.(attempt, maxAttempts);
+      if (options.requestSync) {
+        try {
+          await withTimeout$3(options.requestSync(), syncTimeoutMs, `Timeout waiting for machine Flock sync (localProject=${localProjectId})`);
+        } catch {
+        }
+      }
+      await sleep2(retryDelayMs);
+    }
+  }
   class ConcurrentQueue {
     constructor(maxConcurrency = 30) {
       this.maxConcurrency = maxConcurrency;
@@ -136455,6 +136640,15 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       return (await checkoutLocalProjectBranchAtRootPath(workdir, branch)).currentBranch;
     }
+    resolveLocalProjectWorkdirForTurn(localProjectId) {
+      return resolveWorkspaceLocalProjectRootPathWithRetry(this.deps.workspaceDocument.repo, this.deps.workspaceId, this.deps.machineId, localProjectId, {
+        requestSync: () => this.deps.workspaceDocument.syncMachineFlockDoc(this.deps.machineId, {
+          reason: "session-local-project-resolve",
+          timeoutMs: readTimeoutEnv("LODY_LOCAL_PROJECT_RESOLVE_SYNC_TIMEOUT_MS", 1500)
+        }),
+        onRetry: (attempt, maxAttempts) => this.deps.logger.debug(`Local project ${localProjectId} not visible in machine Flock yet; pulling machine Flock and retrying (attempt ${attempt}/${maxAttempts})`)
+      });
+    }
     async handleTurnError(sessionId, sessionDoc, error2) {
       await this.deps.turnFinalization.finalizeACPState(sessionId);
       await this.persistCodeCollabTurnDiffsAfterACPFinalization(sessionId, this.currentTurnBySession.get(sessionId));
@@ -137171,7 +137365,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         const meta = yield* self2.tryPromise(() => sessionDoc.getMetaState());
         project = project ?? self2.resolveProjectFromMeta(meta, message.project?.branch);
         const localProjectId = project?.kind === "local" ? project.localProjectId : void 0;
-        const restoreWorkdir = localProjectId ? (yield* self2.tryPromise(() => resolveWorkspaceLocalProjectRootPath(self2.deps.workspaceDocument.repo, self2.deps.workspaceId, self2.deps.machineId, localProjectId))) ?? void 0 : void 0;
+        const restoreWorkdir = localProjectId ? (yield* self2.tryPromise(() => self2.resolveLocalProjectWorkdirForTurn(localProjectId))) ?? void 0 : void 0;
         if (project?.kind === "local" && !restoreWorkdir) {
           const missingMessage = `Local project not found in workspace: ${project.localProjectId}`;
           self2.deps.logger.warn(`[${sessionId}] ${missingMessage}`);
@@ -137649,7 +137843,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       const githubRepoFullName = resolveProjectGitHubRepo(project);
       const shouldPrepareWorktree = project?.kind === "github" && !!githubRepoFullName || project?.kind === "local" && project.useWorktree === true;
       let branch = project?.branch?.trim() || void 0;
-      const workdir = project?.kind === "local" ? await resolveWorkspaceLocalProjectRootPath(this.deps.workspaceDocument.repo, this.deps.workspaceId, this.deps.machineId, project.localProjectId) ?? void 0 : void 0;
+      const workdir = project?.kind === "local" ? await this.resolveLocalProjectWorkdirForTurn(project.localProjectId) ?? void 0 : void 0;
       this.deps.logger.info(`Session create received: ${sessionId}`);
       const agentConfig = acpSessionConfig;
       const promptText = agentConfig.prompt ?? "";
@@ -138617,67 +138811,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.releaseWaiters();
     }
   }
-  class SessionUserResolver {
-    constructor(logger2, workspaceId) {
-      this.logger = logger2;
-      this.workspaceId = workspaceId;
-      this.client = LODY_AUTH_URL ? new ConvexHttpClient(LODY_AUTH_URL) : null;
-    }
-    client;
-    cache = /* @__PURE__ */ new Map();
-    async resolve(userId) {
-      const normalizedUserId = userId.trim();
-      if (!normalizedUserId) {
-        return {
-          id: userId,
-          name: userId,
-          email: buildMissingEmail("lody", userId)
-        };
-      }
-      const existing = this.cache.get(normalizedUserId);
-      if (existing) {
-        return await existing;
-      }
-      const request2 = this.fetchUser(normalizedUserId).catch((error2) => {
-        this.cache.delete(normalizedUserId);
-        throw error2;
-      });
-      this.cache.set(normalizedUserId, request2);
-      return await request2;
-    }
-    clear() {
-      this.cache.clear();
-    }
-    async fetchUser(userId) {
-      if (!this.client) {
-        return this.fallbackUser(userId);
-      }
-      try {
-        const user = await this.client.query(api$1.auth.getUserById, {
-          userId,
-          workspaceId: this.workspaceId
-        });
-        const email = typeof user?.email === "string" && user.email.trim() ? user.email.trim() : buildMissingEmail("lody", userId);
-        const name2 = typeof user?.name === "string" && user.name.trim() ? user.name.trim() : email;
-        return {
-          id: userId,
-          name: name2,
-          email
-        };
-      } catch (error2) {
-        this.logger.debug(`[session-user-resolver] Failed to resolve user ${userId} in workspace ${this.workspaceId}: ${formatErrorMessage(error2)}`);
-        return this.fallbackUser(userId);
-      }
-    }
-    fallbackUser(userId) {
-      const email = buildMissingEmail("lody", userId);
-      return {
-        id: userId,
-        name: email,
-        email
-      };
-    }
-  }
   class AccessDenied extends TaggedError("AccessDenied") {
   }
   class AccessIndeterminate extends TaggedError("AccessIndeterminate") {
@@ -138720,6 +138853,26 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     const policy = whileInput(jittered$12, (error2) => error2._tag === "AccessIndeterminate");
     yield* retry$2(attempt, policy).pipe(catchTag("AccessIndeterminate", () => _void));
   });
+  async function mapWithConcurrency$1(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 SESSION_BOOTSTRAP_RECONCILE_CONCURRENCY = 4;
   const isConfigOptionValueRecord = (value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return false;
@@ -138729,7 +138882,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
   class SessionDispatchWatcher {
     constructor(deps) {
       this.deps = deps;
-      this.userResolver = deps.userResolver ?? new SessionUserResolver(deps.logger, deps.workspaceId);
+      this.userResolver = deps.userResolver;
     }
     watchedSessions = /* @__PURE__ */ new Map();
     sessionCheckChains = /* @__PURE__ */ new Map();
@@ -139030,9 +139183,9 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (!this.started) {
         return;
       }
-      const reconcileFailures = await Promise.all([
+      const reconcileFailures = await mapWithConcurrency$1([
         ...sessionRoomIds
-      ].map(async (roomId) => {
+      ], SESSION_BOOTSTRAP_RECONCILE_CONCURRENCY, async (roomId) => {
         if (!this.started) {
           return false;
         }
@@ -139043,7 +139196,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         } catch {
           return true;
         }
-      }));
+      });
       const failedCount = reconcileFailures.filter(Boolean).length;
       if (failedCount > 0) {
         this.deps.logger.warn(`[dispatch] Owned-session bootstrap completed with ${failedCount}/${sessionRoomIds.size} session reconcile failure(s) (reason=${reason})`);
@@ -139966,6 +140119,148 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       return true;
     }
   }
+  const DEFAULT_AI_GIT_AUTHOR_NAME = "LodyAI";
+  const DEFAULT_AI_GIT_AUTHOR_EMAIL = "agent@lody.ai";
+  const trimNonEmpty$1 = (value) => {
+    const trimmed2 = value?.trim();
+    return trimmed2 !== void 0 && trimmed2.length > 0 ? trimmed2 : void 0;
+  };
+  const isUsableEmail = (email) => {
+    const trimmed2 = trimNonEmpty$1(email);
+    return trimmed2 !== void 0 && !isMissingEmail(trimmed2);
+  };
+  const buildGitHubNoreplyEmail = (githubAccountId, githubLogin) => {
+    const accountId = trimNonEmpty$1(githubAccountId);
+    const login = trimNonEmpty$1(githubLogin);
+    if (!accountId || !login || !/^\d+$/.test(accountId)) {
+      return void 0;
+    }
+    return `${accountId}+${login}@users.noreply.github.com`;
+  };
+  const normalizeName = (name2, email) => {
+    if (name2 !== void 0 && !isMissingEmail(name2)) {
+      return name2;
+    }
+    return email;
+  };
+  const readGitConfig = (key2, cwd) => {
+    try {
+      const output = execFileSync("git", [
+        "config",
+        key2
+      ], {
+        cwd,
+        encoding: "utf8",
+        stdio: [
+          "ignore",
+          "pipe",
+          "ignore"
+        ]
+      });
+      return trimNonEmpty$1(output);
+    } catch {
+      return void 0;
+    }
+  };
+  const readHostDefaultGitIdentity = (cwd) => ({
+    name: trimNonEmpty$1(process.env.GIT_AUTHOR_NAME) ?? trimNonEmpty$1(process.env.GIT_COMMITTER_NAME) ?? readGitConfig("user.name", cwd),
+    email: trimNonEmpty$1(process.env.GIT_AUTHOR_EMAIL) ?? trimNonEmpty$1(process.env.GIT_COMMITTER_EMAIL) ?? readGitConfig("user.email", cwd)
+  });
+  const resolveSessionGitIdentity = (requested, defaultIdentity, cwd) => {
+    const resolvedDefaultIdentity = readHostDefaultGitIdentity(cwd);
+    const requestedEmail = trimNonEmpty$1(requested.email);
+    if (isUsableEmail(requestedEmail)) {
+      return {
+        name: normalizeName(trimNonEmpty$1(requested.name), requestedEmail),
+        email: requestedEmail
+      };
+    }
+    const defaultEmail = trimNonEmpty$1(resolvedDefaultIdentity.email);
+    if (isUsableEmail(defaultEmail)) {
+      return {
+        name: normalizeName(trimNonEmpty$1(resolvedDefaultIdentity.name), defaultEmail),
+        email: defaultEmail
+      };
+    }
+    return {
+      name: DEFAULT_AI_GIT_AUTHOR_NAME,
+      email: DEFAULT_AI_GIT_AUTHOR_EMAIL
+    };
+  };
+  const trimNonEmpty = (value) => {
+    const trimmed2 = value?.trim();
+    return trimmed2 !== void 0 && trimmed2.length > 0 ? trimmed2 : void 0;
+  };
+  class SessionUserResolver {
+    constructor(logger2, workspaceId, cliToken, options) {
+      this.logger = logger2;
+      this.workspaceId = workspaceId;
+      this.cliToken = cliToken;
+      this.client = LODY_AUTH_URL ? new ConvexHttpClient(LODY_AUTH_URL) : null;
+      this.queryProfile = options?.queryProfile ?? (async (args2) => await this.client?.query(api$1.auth.getWorkspaceUserProfileForCliToken, args2) ?? null);
+    }
+    client;
+    queryProfile;
+    cache = /* @__PURE__ */ new Map();
+    async resolve(userId) {
+      const normalizedUserId = userId.trim();
+      if (!normalizedUserId) {
+        return {
+          id: userId,
+          name: userId,
+          email: buildMissingEmail("lody", userId)
+        };
+      }
+      const existing = this.cache.get(normalizedUserId);
+      if (existing) {
+        return await existing;
+      }
+      const request2 = this.fetchUser(normalizedUserId).catch((error2) => {
+        this.cache.delete(normalizedUserId);
+        throw error2;
+      });
+      this.cache.set(normalizedUserId, request2);
+      return await request2;
+    }
+    clear() {
+      this.cache.clear();
+    }
+    async fetchUser(userId) {
+      try {
+        const profile = await this.queryProfile({
+          cliToken: this.cliToken,
+          workspaceId: this.workspaceId,
+          userId
+        });
+        if (!profile) {
+          this.logger.debug(`[session-user-resolver] User ${userId} not resolvable in workspace ${this.workspaceId}; using placeholder identity`);
+          return this.fallbackUser(userId);
+        }
+        return this.toSessionUserProfile(userId, profile);
+      } catch (error2) {
+        this.logger.debug(`[session-user-resolver] Failed to resolve user ${userId} in workspace ${this.workspaceId}: ${formatErrorMessage(error2)}`);
+        return this.fallbackUser(userId);
+      }
+    }
+    toSessionUserProfile(userId, profile) {
+      const accountEmail = trimNonEmpty(profile.email);
+      const email = (accountEmail && !isMissingEmail(accountEmail) ? accountEmail : void 0) ?? buildGitHubNoreplyEmail(profile.githubAccountId, profile.githubLogin) ?? accountEmail ?? buildMissingEmail("lody", userId);
+      const name2 = trimNonEmpty(profile.name) ?? trimNonEmpty(profile.githubLogin) ?? email;
+      return {
+        id: userId,
+        name: name2,
+        email
+      };
+    }
+    fallbackUser(userId) {
+      const email = buildMissingEmail("lody", userId);
+      return {
+        id: userId,
+        name: email,
+        email
+      };
+    }
+  }
   const DAY_MS$1 = 24 * 60 * 60 * 1e3;
   const TERMINAL_RETENTION_MS = 7 * DAY_MS$1;
   const MATERIALIZATION_CLAIM_MS = 6e4;
@@ -141043,6 +141338,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         return;
       }
       const frozen = operation.frozenContinuationConfig.inputConfig;
+      const requester = await this.resolveRequesterIdentity(operation.requesterUserId);
       await this.options.executionService.continueSession({
         type: "session/chat",
         sessionId: delivery.requesterSessionId,
@@ -141074,8 +141370,8 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         },
         userTurnId: delivery.systemTurnId,
         userId: operation.requesterUserId,
-        userName: operation.requesterUserId,
-        userEmail: buildMissingEmail("lody", operation.requesterUserId)
+        userName: requester.name,
+        userEmail: requester.email
       }, {
         dispatchSource: "delivery",
         onTurnClaimed: async () => {
@@ -141087,6 +141383,26 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
         this.withStore((store) => store.consumeDelivery(delivery.requesterSessionId, delivery.operationId));
       }
     }
+    async resolveRequesterIdentity(requesterUserId) {
+      const fallback2 = {
+        name: requesterUserId,
+        email: buildMissingEmail("lody", requesterUserId)
+      };
+      const resolver = this.options.userResolver;
+      if (!resolver) {
+        return fallback2;
+      }
+      try {
+        const profile = await resolver.resolve(requesterUserId);
+        return {
+          name: profile.name,
+          email: profile.email
+        };
+      } catch (error2) {
+        this.options.logger.debug(`[operation-coordinator] Failed to resolve requester identity ${requesterUserId}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        return fallback2;
+      }
+    }
     async resolveFrozenConfiguration(operation) {
       const agentConfigId = operation.frozenContinuationConfig.agentConfigId;
       if (!agentConfigId) return "available";
@@ -147784,6 +148100,7 @@ ${entry.text}`).join("\n\n");
   function isCodeCollabV2ServiceError(error2) {
     return error2 instanceof CodeCollabV2ServiceError;
   }
+  const DEFAULT_CODE_COLLAB_REPUBLISH_CONCURRENCY = 4;
   class CodeCollabV2Service {
     constructor(deps) {
       this.deps = deps;
@@ -147792,9 +148109,16 @@ ${entry.text}`).join("\n\n");
     publishedStateByOwnerSessionId = /* @__PURE__ */ new Map();
     watchByOwnerSessionId = /* @__PURE__ */ new Map();
     refreshQueueByOwnerSessionId = /* @__PURE__ */ new Map();
+    publishChainByOwnerSessionId = /* @__PURE__ */ new Map();
+    pendingFileIndexSignalByOwnerSessionId = /* @__PURE__ */ new Set();
+    republishRequestedGeneration = 0;
+    republishCompletedGeneration = 0;
+    republishDrainPromise = null;
+    disposed = false;
     logger = getLogger("code-collab");
     writeChainByAbsolutePath = /* @__PURE__ */ new Map();
     dispose() {
+      this.disposed = true;
       for (const ownerSessionId of this.watchByOwnerSessionId.keys()) {
         this.releaseWorkspaceWatch(ownerSessionId);
       }
@@ -148063,25 +148387,79 @@ ${entry.text}`).join("\n\n");
         ...this.stateByOwnerSessionId.keys(),
         ...this.watchByOwnerSessionId.keys()
       ]);
-      await Promise.allSettled([
+      await mapWithConcurrency$1([
         ...ownerSessionIds
-      ].map(async (sessionId) => {
-        await this.refreshSharedState({
-          sessionId
-        }, {
-          forcePublish: true
-        });
-      }));
+      ], DEFAULT_CODE_COLLAB_REPUBLISH_CONCURRENCY, async (sessionId) => {
+        try {
+          await this.refreshSharedState({
+            sessionId
+          }, {
+            forcePublish: true
+          });
+        } catch (error2) {
+          this.logger.debug(`[code-collab] known file-index refresh failed ownerSessionId=${sessionId}: ${formatErrorMessage(error2)}`);
+        }
+      });
     }
     async republishKnownSharedStates() {
-      await Promise.allSettled([
-        ...this.stateByOwnerSessionId.entries()
-      ].map(async ([ownerSessionId, state2]) => {
-        await this.publishOwnerState(ownerSessionId, state2, {
-          forcePublish: true,
-          persistAllChangesDiffStats: true
+      if (this.disposed) {
+        return;
+      }
+      const requestedGeneration = this.republishRequestedGeneration + 1;
+      this.republishRequestedGeneration = requestedGeneration;
+      while (!this.disposed && this.republishCompletedGeneration < requestedGeneration) {
+        this.ensureRepublishDrain();
+        await this.republishDrainPromise;
+      }
+    }
+    ensureRepublishDrain() {
+      if (this.republishDrainPromise || this.disposed) {
+        return;
+      }
+      const drain = Promise.resolve().then(async () => await this.drainRepublishRequests());
+      const beforeCleanup = this.deps.testOnlyBeforeRepublishDrainCleanup;
+      const drainAfterCleanupBoundary = beforeCleanup ? drain.then(beforeCleanup, async (error2) => {
+        await beforeCleanup();
+        throw error2;
+      }) : drain;
+      const managedDrain = drainAfterCleanupBoundary.finally(() => {
+        if (this.republishDrainPromise === managedDrain) {
+          this.republishDrainPromise = null;
+          if (!this.disposed && this.republishCompletedGeneration < this.republishRequestedGeneration) {
+            this.ensureRepublishDrain();
+          }
+        }
+      });
+      this.republishDrainPromise = managedDrain;
+    }
+    async drainRepublishRequests() {
+      while (!this.disposed) {
+        const targetGeneration = this.republishRequestedGeneration;
+        if (this.republishCompletedGeneration >= targetGeneration) {
+          return;
+        }
+        const ownerSessionIds = [
+          ...this.stateByOwnerSessionId.keys()
+        ];
+        await mapWithConcurrency$1(ownerSessionIds, DEFAULT_CODE_COLLAB_REPUBLISH_CONCURRENCY, async (ownerSessionId) => {
+          if (this.disposed) {
+            return;
+          }
+          const state2 = this.stateByOwnerSessionId.get(ownerSessionId);
+          if (!state2) {
+            return;
+          }
+          try {
+            await this.publishOwnerState(ownerSessionId, state2, {
+              forcePublish: true,
+              persistAllChangesDiffStats: true
+            });
+          } catch (error2) {
+            this.logger.debug(`[code-collab] file-index republish failed ownerSessionId=${ownerSessionId}: ${formatErrorMessage(error2)}`);
+          }
         });
-      }));
+        this.republishCompletedGeneration = targetGeneration;
+      }
     }
     enqueueSharedStateRefresh(ownerSessionId, refresh) {
       let queue2 = this.refreshQueueByOwnerSessionId.get(ownerSessionId);
@@ -148660,7 +149038,7 @@ ${entry.text}`).join("\n\n");
       if (missingWorkspacePaths.length === 0) {
         return;
       }
-      await Promise.all(missingWorkspacePaths.map(async (workspacePath) => {
+      await mapWithConcurrency$1(missingWorkspacePaths, DEFAULT_CODE_COLLAB_REPUBLISH_CONCURRENCY, async (workspacePath) => {
         const absolutePath = path__default$1.resolve(resolved.workspaceRoot, workspacePath);
         const value = await classifyPathForFileTree(absolutePath).catch((error2) => {
           const code2 = errorCode$1(error2);
@@ -148679,7 +149057,7 @@ ${entry.text}`).join("\n\n");
         if (!isLazyDirectoryValue(value)) {
           deleteDescendantFileTreeEntries(state2.fileTree, workspacePath, fileTreeIndex);
         }
-      }));
+      });
     }
     async computeAllChangesFromDiffStore(resolved) {
       const store = this.deps.diffStore;
@@ -148893,24 +149271,34 @@ ${entry.text}`).join("\n\n");
       throw new Error(`Unsupported Code Collab v2 diff snapshot: ${String(exhaustive)}`);
     }
     async publishOwnerState(ownerSessionId, state2, options = {}) {
-      const startedAtMs = Date.now();
-      if (!this.deps.publishFileIndex) {
-        return;
-      }
-      const cloneStartedAtMs = Date.now();
-      const fileTree = cloneFileTreeState(state2.fileTree);
-      const allChanges = cloneAllChangesState(state2.allChanges);
-      const cloneMs = Date.now() - cloneStartedAtMs;
-      const buildStartedAtMs = Date.now();
-      const fileIndex = buildCodeCollabFileIndexState(fileTree, allChanges);
-      const buildMs = Date.now() - buildStartedAtMs;
-      await this.publishPreparedOwnerFileIndex(ownerSessionId, fileIndex, options, {
-        startedAtMs,
-        cloneMs,
-        buildMs
+      await this.enqueueOwnerPublication(ownerSessionId, async () => {
+        const startedAtMs = Date.now();
+        if (!this.deps.publishFileIndex || this.disposed) {
+          return;
+        }
+        const cloneStartedAtMs = Date.now();
+        const fileTree = cloneFileTreeState(state2.fileTree);
+        const allChanges = cloneAllChangesState(state2.allChanges);
+        const cloneMs = Date.now() - cloneStartedAtMs;
+        const buildStartedAtMs = Date.now();
+        const fileIndex = buildCodeCollabFileIndexState(fileTree, allChanges);
+        const buildMs = Date.now() - buildStartedAtMs;
+        await this.publishPreparedOwnerFileIndexNow(ownerSessionId, fileIndex, options, {
+          startedAtMs,
+          cloneMs,
+          buildMs
+        });
       });
     }
     async publishPreparedOwnerFileIndex(ownerSessionId, fileIndex, options = {}, metrics = {}) {
+      await this.enqueueOwnerPublication(ownerSessionId, async () => {
+        if (this.disposed) {
+          return;
+        }
+        await this.publishPreparedOwnerFileIndexNow(ownerSessionId, fileIndex, options, metrics);
+      });
+    }
+    async publishPreparedOwnerFileIndexNow(ownerSessionId, fileIndex, options, metrics) {
       const startedAtMs = metrics.startedAtMs ?? Date.now();
       const publishFileIndex = this.deps.publishFileIndex;
       const publishFileIndexSignal = this.deps.publishFileIndexSignal;
@@ -148935,18 +149323,30 @@ ${entry.text}`).join("\n\n");
       this.publishedStateByOwnerSessionId.set(ownerSessionId, nextPublishedState);
       const publishStartedAtMs = Date.now();
       try {
-        await publishFileIndex({
-          ownerSessionId,
-          fileIndex,
-          allChangesDiffStats: summarizeFileIndexAllChanges(fileIndex),
-          persistAllChangesDiffStats: options.persistAllChangesDiffStats === true,
-          updatedAtMs
-        });
-        if (publishFileIndexSignal && (options.forcePublish === true || sameFileIndex !== true)) {
+        let publishResult;
+        try {
+          publishResult = await publishFileIndex({
+            ownerSessionId,
+            fileIndex,
+            allChangesDiffStats: summarizeFileIndexAllChanges(fileIndex),
+            persistAllChangesDiffStats: options.persistAllChangesDiffStats === true,
+            updatedAtMs,
+            reconcileRemote: options.forcePublish === true
+          });
+        } catch (error2) {
+          if (error2 instanceof CodeCollabFileIndexChangedPublishError) {
+            this.pendingFileIndexSignalByOwnerSessionId.add(ownerSessionId);
+          }
+          throw error2;
+        }
+        const shouldPublishSignal = publishResult?.changed !== false || sameFileIndex !== true || this.pendingFileIndexSignalByOwnerSessionId.has(ownerSessionId);
+        if (publishFileIndexSignal && shouldPublishSignal) {
+          this.pendingFileIndexSignalByOwnerSessionId.add(ownerSessionId);
           await publishFileIndexSignal({
             ownerSessionId,
             updatedAtMs
           });
+          this.pendingFileIndexSignalByOwnerSessionId.delete(ownerSessionId);
         }
         const publishMs = Date.now() - publishStartedAtMs;
         this.logger.info(`[code-collab] file-index publish completed ownerSessionId=${ownerSessionId} paths=${pathCount} durationMs=${Date.now() - startedAtMs} cloneMs=${metrics.cloneMs ?? 0} buildMs=${metrics.buildMs ?? 0} equalityMs=${equalityMs} publishMs=${publishMs} force=${options.forcePublish === true}${metrics.workerMs === void 0 ? "" : ` workerMs=${metrics.workerMs}`}`);
@@ -148961,6 +149361,18 @@ ${entry.text}`).join("\n\n");
         throw error2;
       }
     }
+    enqueueOwnerPublication(ownerSessionId, task) {
+      const previous = this.publishChainByOwnerSessionId.get(ownerSessionId) ?? Promise.resolve();
+      const result = previous.catch(() => void 0).then(task);
+      const settled = result.then(() => void 0, () => void 0);
+      this.publishChainByOwnerSessionId.set(ownerSessionId, settled);
+      void settled.finally(() => {
+        if (this.publishChainByOwnerSessionId.get(ownerSessionId) === settled) {
+          this.publishChainByOwnerSessionId.delete(ownerSessionId);
+        }
+      });
+      return result;
+    }
   }
   function cloneFileTreeValue(value) {
     return value === true ? true : {
@@ -156716,18 +157128,13 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
         publishFileIndex: async (state2) => {
           const publishStartedAtMs = Date.now();
           const pathCount = Object.keys(state2.fileIndex).length;
-          const openStartedAtMs = Date.now();
-          const handle = await this.workspaceDocument.repo.openFlockDoc(getCodeCollabFileIndexFlockDocId(this.workspaceId, state2.ownerSessionId));
-          const openMs = Date.now() - openStartedAtMs;
-          const writeStartedAtMs = Date.now();
-          const changed = writeCodeCollabFileIndexToFlock(handle.flock, state2.fileIndex, state2.updatedAtMs);
-          const writeMs = Date.now() - writeStartedAtMs;
-          const flushStartedAtMs = Date.now();
-          await this.workspaceDocument.repo.flush();
-          const flushMs = Date.now() - flushStartedAtMs;
-          const syncStartedAtMs = Date.now();
-          await handle.syncOnce();
-          const syncMs = Date.now() - syncStartedAtMs;
+          const result = await publishCodeCollabFileIndexFlock({
+            repo: this.workspaceDocument.repo,
+            flockDocId: getCodeCollabFileIndexFlockDocId(this.workspaceId, state2.ownerSessionId),
+            fileIndex: state2.fileIndex,
+            updatedAtMs: state2.updatedAtMs,
+            reconcileRemote: state2.reconcileRemote
+          });
           if (state2.persistAllChangesDiffStats && state2.allChangesDiffStats) {
             try {
               await this.persistCodeCollabAllChangesDiffStats(state2.ownerSessionId, state2.allChangesDiffStats);
@@ -156735,28 +157142,17 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
               this.logger.debug(`[code-collab-v2] Failed to persist All Changes diffStats ownerSessionId=${state2.ownerSessionId}: ${formatErrorMessage(error2)}`);
             }
           }
-          this.logger.info(`[code-collab-v2] file-index flock publish completed ownerSessionId=${state2.ownerSessionId} paths=${pathCount} changed=${changed} durationMs=${Date.now() - publishStartedAtMs} openMs=${openMs} writeMs=${writeMs} flushMs=${flushMs} syncMs=${syncMs}`);
+          this.logger.info(`[code-collab-v2] file-index flock publish completed ownerSessionId=${state2.ownerSessionId} paths=${pathCount} changed=${result.changed} reconcileRemote=${state2.reconcileRemote} durationMs=${Date.now() - publishStartedAtMs}`);
+          return result;
         },
         publishFileIndexSignal: async (state2) => {
           const publishStartedAtMs = Date.now();
-          const openStartedAtMs = Date.now();
-          const handle = await this.workspaceDocument.repo.openFlockDoc(getCodeCollabFileIndexSignalFlockDocId(this.workspaceId, state2.ownerSessionId));
-          const openMs = Date.now() - openStartedAtMs;
-          const preSyncStartedAtMs = Date.now();
-          await handle.syncOnce();
-          const preSyncMs = Date.now() - preSyncStartedAtMs;
-          const writeStartedAtMs = Date.now();
-          const previous = readCodeCollabFileIndexSignalFromFlock(handle.flock);
-          const revision = (previous?.r ?? 0) + 1;
-          const changed = writeCodeCollabFileIndexSignalToFlock(handle.flock, revision, state2.updatedAtMs);
-          const writeMs = Date.now() - writeStartedAtMs;
-          const flushStartedAtMs = Date.now();
-          await this.workspaceDocument.repo.flush();
-          const flushMs = Date.now() - flushStartedAtMs;
-          const syncStartedAtMs = Date.now();
-          await handle.syncOnce();
-          const syncMs = Date.now() - syncStartedAtMs;
-          this.logger.info(`[code-collab-v2] file-index signal publish completed ownerSessionId=${state2.ownerSessionId} revision=${revision} changed=${changed} durationMs=${Date.now() - publishStartedAtMs} openMs=${openMs} preSyncMs=${preSyncMs} writeMs=${writeMs} flushMs=${flushMs} syncMs=${syncMs}`);
+          const result = await publishCodeCollabFileIndexSignalFlock({
+            repo: this.workspaceDocument.repo,
+            flockDocId: getCodeCollabFileIndexSignalFlockDocId(this.workspaceId, state2.ownerSessionId),
+            updatedAtMs: state2.updatedAtMs
+          });
+          this.logger.info(`[code-collab-v2] file-index signal publish completed ownerSessionId=${state2.ownerSessionId} revision=${result.revision} changed=${result.changed} durationMs=${Date.now() - publishStartedAtMs}`);
         }
       });
       if (typeof this.workspaceDocument.onMetaRoomSynced === "function") {
@@ -157047,11 +157443,13 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
       } else {
         this.logger.debug("Streams RPC disabled: missing LODY_AUTH_URL / LODY_AUTH_SITE_URL");
       }
+      this.sessionUserResolver = new SessionUserResolver(this.logger, this.workspaceId, this.token);
       this.sessionDispatchWatcher = new SessionDispatchWatcher({
         logger: this.logger,
         machineId: this.machineId,
         workspaceId: this.workspaceId,
         currentUserId: this.userId,
+        userResolver: this.sessionUserResolver,
         workspaceDocument: this.workspaceDocument,
         executionService: this.executionService,
         getPreparedSessionLaunchConfig: (input2) => this.sessionManager.getPreparedSessionLaunchConfig(input2),
@@ -157081,6 +157479,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
         workspaceDocument: this.workspaceDocument,
         executionService: this.executionService,
         dispatchWatcher: this.sessionDispatchWatcher,
+        userResolver: this.sessionUserResolver,
         logger: this.logger,
         materializeTarget: async (operation, item, index) => await this.materializeOperationTarget(operation, item, index)
       });
@@ -157151,6 +157550,7 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
     providerSetupManager;
     previewService;
     sessionDispatchWatcher;
+    sessionUserResolver;
     operationCoordinator;
     autoPromptRunner;
     turnPostProcessingService;
@@ -171153,66 +171553,6 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
     }
     return child.pid;
   }
-  const DEFAULT_AI_GIT_AUTHOR_NAME = "LodyAI";
-  const DEFAULT_AI_GIT_AUTHOR_EMAIL = "agent@lody.ai";
-  const trimNonEmpty = (value) => {
-    const trimmed2 = value?.trim();
-    return trimmed2 !== void 0 && trimmed2.length > 0 ? trimmed2 : void 0;
-  };
-  const isUsableEmail = (email) => {
-    const trimmed2 = trimNonEmpty(email);
-    return trimmed2 !== void 0 && !isMissingEmail(trimmed2);
-  };
-  const normalizeName = (name2, email) => {
-    if (name2 !== void 0 && !isMissingEmail(name2)) {
-      return name2;
-    }
-    return email;
-  };
-  const readGitConfig = (key2, cwd) => {
-    try {
-      const output = execFileSync("git", [
-        "config",
-        key2
-      ], {
-        cwd,
-        encoding: "utf8",
-        stdio: [
-          "ignore",
-          "pipe",
-          "ignore"
-        ]
-      });
-      return trimNonEmpty(output);
-    } catch {
-      return void 0;
-    }
-  };
-  const readHostDefaultGitIdentity = (cwd) => ({
-    name: trimNonEmpty(process.env.GIT_AUTHOR_NAME) ?? trimNonEmpty(process.env.GIT_COMMITTER_NAME) ?? readGitConfig("user.name", cwd),
-    email: trimNonEmpty(process.env.GIT_AUTHOR_EMAIL) ?? trimNonEmpty(process.env.GIT_COMMITTER_EMAIL) ?? readGitConfig("user.email", cwd)
-  });
-  const resolveSessionGitIdentity = (requested, defaultIdentity, cwd) => {
-    const resolvedDefaultIdentity = readHostDefaultGitIdentity(cwd);
-    const requestedEmail = trimNonEmpty(requested.email);
-    if (isUsableEmail(requestedEmail)) {
-      return {
-        name: normalizeName(trimNonEmpty(requested.name), requestedEmail),
-        email: requestedEmail
-      };
-    }
-    const defaultEmail = trimNonEmpty(resolvedDefaultIdentity.email);
-    if (isUsableEmail(defaultEmail)) {
-      return {
-        name: normalizeName(trimNonEmpty(resolvedDefaultIdentity.name), defaultEmail),
-        email: defaultEmail
-      };
-    }
-    return {
-      name: DEFAULT_AI_GIT_AUTHOR_NAME,
-      email: DEFAULT_AI_GIT_AUTHOR_EMAIL
-    };
-  };
   const getDefaultSessionWorkdir = (sessionId) => path__default.join(os__default.homedir(), ".lody", "chats", sessionId);
   const ensureDefaultSessionWorkdir = (sessionId) => {
     const dir = getDefaultSessionWorkdir(sessionId);
@@ -172036,7 +172376,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
       this.sessionSandboxFactory = options?.sessionSandboxFactory ?? createSessionSandboxFactory({
         logger: this.logger
       });
-      this.preparationUserResolver = new SessionUserResolver(this.logger, this.workspaceId);
+      this.preparationUserResolver = new SessionUserResolver(this.logger, this.workspaceId, this.token);
       this.preparationService = new SessionPreparationService(this.logger, {
         hardTtlMs: SESSION_PREPARATION_HARD_TTL_MS,
         maxConcurrent: MAX_CONCURRENT_SESSION_PREPARATIONS
@@ -180020,152 +180360,17 @@ Shutting down gracefully${reason}...`);
       throw error2;
     }
   }
-  async function exitLogin(code2) {
-    await flushTelemetry();
-    process.exit(code2);
-  }
-  const loginCommand = new Command("login").description("Login to Lody using device authorization flow or an API key").option("-d, --debug", "enable debug output").option("--machine-name <name>", "Machine name to register (defaults to hostname)").option("--auth <api-key>", "Use a CLI API key for non-interactive login").action(async (options) => {
-    if (options.debug) {
-      rootLogger.setDebug(true);
-    }
-    const logger2 = getLogger("login");
-    const authClient = new AuthClient(logger2);
-    const providedAuth = options.auth?.trim();
-    const authMethod = providedAuth ? "api_key" : "device_auth";
-    try {
-      if (options.auth !== void 0 && !providedAuth) {
-        captureAuthEvent("login_failed", {
-          auth_method: "api_key",
-          reason_code: "missing_api_key"
-        });
-        logger2.error("Missing API key for --auth.");
-        await exitLogin(1);
-      }
-      captureAuthEvent("login_started", {
-        auth_method: authMethod
-      });
-      if (providedAuth) {
-        const result2 = await performLoginWithApiKey(authClient, logger2, {
-          apiKey: providedAuth,
-          machineName: options.machineName
-        });
-        if (result2.success) {
-          captureAuthEvent("login_succeeded", {
-            auth_method: "api_key"
-          });
-          logger2.success("\n" + chalk.green("\u2713") + " Successfully logged in!");
-          logger2.info("  User: " + chalk.cyan(result2.user.name || result2.user.email));
-          logger2.info("  Email: " + chalk.cyan(result2.user.email));
-        } else {
-          captureAuthEvent("login_failed", {
-            auth_method: "api_key"
-          });
-          await reportError("login", result2.error, {
-            message: "Login failed using --auth",
-            logger: logger2
-          });
-          await exitLogin(1);
-        }
-        await flushTelemetry();
-        return;
-      }
-      const existingAuth = authClient.getAuthInfo();
-      if (existingAuth) {
-        logger2.debug("Found existing authentication, checking validity...");
-        const validation2 = await authClient.validateToken(existingAuth.token);
-        if (validation2.valid && validation2.user) {
-          captureAuthEvent("login_succeeded", {
-            auth_method: "device_auth",
-            already_logged_in: true
-          });
-          logger2.success("\n" + chalk.green("\u2713") + " You are already logged in!");
-          logger2.info("  User: " + chalk.cyan(validation2.user.name || validation2.user.email));
-          logger2.info("  Email: " + chalk.cyan(validation2.user.email));
-          await flushTelemetry();
-          return;
-        } else if (isRetryableTokenValidationFailure(validation2)) {
-          captureAuthEvent("login_failed", {
-            auth_method: "device_auth",
-            reason_code: "auth_service_unreachable"
-          });
-          logger2.error(`Unable to validate existing authentication because the auth service is unreachable: ${validation2.error ?? "network error"}`);
-          await exitLogin(1);
-        } else if (isTokenValidationUnavailable(validation2)) {
-          captureAuthEvent("login_failed", {
-            auth_method: "device_auth",
-            reason_code: "auth_validation_unavailable"
-          });
-          logger2.error(`Unable to validate existing authentication: ${validation2.error ?? validation2.reason}`);
-          await exitLogin(1);
-        } else {
-          logger2.debug("Existing authentication is invalid, proceeding with new login...");
-        }
-      }
-      logger2.info("Initializing device authorization...");
-      const result = await performLogin(authClient, logger2, {
-        machineName: options.machineName
-      });
-      if (result.success) {
-        captureAuthEvent("login_succeeded", {
-          auth_method: "device_auth"
-        });
-        logger2.success("\n" + chalk.green("\u2713") + " Successfully logged in!");
-        logger2.info("  User: " + chalk.cyan(result.user.name || result.user.email));
-        logger2.info("  Email: " + chalk.cyan(result.user.email));
-      } else {
-        captureAuthEvent("login_failed", {
-          auth_method: "device_auth"
-        });
-        await reportError("login", result.error, {
-          message: "Login failed during device authorization",
-          logger: logger2
-        });
-        await exitLogin(1);
-      }
-      await flushTelemetry();
-    } catch (error2) {
-      captureAuthEvent("login_failed", {
-        auth_method: authMethod,
-        reason_code: "exception"
-      });
-      await reportError("login", error2, {
-        message: "Login command failed",
-        logger: logger2
-      });
-      await exitLogin(1);
-    }
-  });
-  const logoutCommand = new Command("logout").description("Logout from Lody and clear saved authentication").option("-d, --debug", "enable debug output").action(async (options) => {
-    if (options.debug) {
-      rootLogger.setDebug(true);
-    }
-    const logger2 = getLogger("logout");
-    const authClient = new AuthClient(logger2);
-    const logoutResult = authClient.logout();
-    if (!logoutResult.success) {
-      captureAuthEvent("logout_failed");
-      await reportError("logout", logoutResult.error, {
-        message: "Logout failed",
-        logger: logger2
-      });
-      await flushTelemetry();
-      process.exit(1);
-    }
-    if (!logoutResult.user) {
-      captureAuthEvent("logout_succeeded", {
-        was_logged_in: false
-      });
-      logger2.info("You are not logged in.");
-      await flushTelemetry();
-      return;
-    }
-    captureAuthEvent("logout_succeeded", {
-      was_logged_in: true
+  function buildOpenLocalProjectDeepLink(input2) {
+    const search2 = new URLSearchParams({
+      machine: input2.machineId,
+      project: input2.localProjectId
     });
-    logger2.info(`Logging out user: ${chalk.cyan(logoutResult.user.email)}`);
-    logger2.success("\n" + chalk.green("\u2713") + " Successfully logged out!");
-    await flushTelemetry();
-  });
+    const workspaceSlug = input2.workspaceSlug?.trim();
+    if (workspaceSlug) {
+      search2.set("workspaceSlug", workspaceSlug);
+    }
+    return `lody://chat/new?${search2.toString()}`;
+  }
   const isUpKey = (key2) => key2.name === "up" || key2.name === "k" || key2.ctrl && key2.name === "p";
   const isDownKey = (key2) => key2.name === "down" || key2.name === "j" || key2.ctrl && key2.name === "n";
   const isSpaceKey = (key2) => key2.name === "space";
@@ -205610,21 +205815,6 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     Separator
   };
   const LOCAL_CONTROL_TIMEOUT_MS = 15e3;
-  function setDebugIfEnabled(options) {
-    if (options.debug) {
-      rootLogger.setDebug(true);
-    }
-  }
-  function resolveMachineIdOrExit() {
-    const logger2 = getLogger("project");
-    const authClient = new AuthClient(logger2);
-    const authInfo = authClient.getAuthInfo();
-    if (!authInfo) {
-      logger2.error("Not logged in. Run `lody login` first.");
-      process.exit(1);
-    }
-    return authInfo.machine.machineId;
-  }
   async function sendLocalProjectControl(message) {
     try {
       await ensureDaemonReachable();
@@ -205688,8 +205878,8 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     }
     return candidates.length > 0 ? candidates : null;
   }
-  function printWorkspaceCandidates(candidates) {
-    const logger2 = getLogger("project");
+  function printWorkspaceCandidates(candidates, loggerName) {
+    const logger2 = getLogger(loggerName);
     logger2.info("Available workspaces:");
     for (const item of candidates) {
       const slug = item.slug ? ` (${item.slug})` : "";
@@ -205697,8 +205887,8 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     }
     logger2.info("Use --workspace <id|slug|name>.");
   }
-  async function promptWorkspaceSelection(candidates) {
-    const logger2 = getLogger("project");
+  async function promptWorkspaceSelection(candidates, loggerName) {
+    const logger2 = getLogger(loggerName);
     const choices = candidates.map((candidate) => {
       const slug = candidate.slug ? ` (${candidate.slug})` : "";
       return {
@@ -205722,13 +205912,264 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       return null;
     }
   }
+  async function resolveLocalProjectForApp(args2) {
+    const buildRequest = (workspace) => ({
+      type: "local-project/add",
+      machineId: args2.machineId,
+      rootPath: args2.rootPath,
+      ...workspace ? {
+        workspace
+      } : {}
+    });
+    let response2 = await args2.send(buildRequest(args2.workspaceSelector));
+    let workspaceSlug = null;
+    if (!response2.ok && response2.error === "workspace_required" && args2.canPrompt) {
+      const candidates = extractWorkspaceCandidates(response2);
+      if (candidates) {
+        const selectedWorkspaceId = await args2.promptWorkspace(candidates);
+        if (!selectedWorkspaceId) {
+          throw new Error("Workspace selection is required to open a local project.");
+        }
+        workspaceSlug = candidates.find((c) => c.id === selectedWorkspaceId)?.slug ?? null;
+        response2 = await args2.send(buildRequest(selectedWorkspaceId));
+      }
+    }
+    if (!response2.ok) {
+      if (response2.error === "daemon_unavailable") {
+        return {
+          localProjectId: createLocalProjectId(args2.rootPath),
+          name: getLocalProjectNameFromRootPath(args2.rootPath),
+          workspaceSlug: null,
+          registered: false
+        };
+      }
+      const candidates = extractWorkspaceCandidates(response2);
+      if (candidates) {
+        throw new Error(`${response2.message} Pass --workspace <id|slug|name>. Candidates: ${candidates.map(formatWorkspaceCandidate).join(", ")}`);
+      }
+      throw new Error(response2.message);
+    }
+    if (response2.type !== "local-project/add") {
+      throw new Error(`Unexpected response type: ${response2.type}`);
+    }
+    return {
+      localProjectId: response2.result.localProjectId,
+      name: response2.result.name,
+      workspaceSlug,
+      registered: true
+    };
+  }
+  const appCommand = new Command("app").description("Open the Lody desktop app on a new chat with a local directory selected (registers it if needed)").argument("[path]", "Local project directory to select", ".").option("--workspace <selector>", "Target workspace id, slug, or name").option("--json", "Print JSON output").option("-d, --debug", "Enable debug output").action(async (projectPath, options) => {
+    await runOneShotCommand("app", options, async () => {
+      const logger2 = getLogger("app");
+      const auth = getAuthContextOrThrow$1("app");
+      const rootPath = ensureLocalProjectRootPath(path__default$1.resolve(projectPath ?? "."));
+      const target = await resolveLocalProjectForApp({
+        machineId: auth.machineId,
+        rootPath,
+        workspaceSelector: options.workspace,
+        canPrompt: !options.json && !options.workspace && !!process.stdin.isTTY && !!process.stdout.isTTY,
+        send: sendLocalProjectControl,
+        promptWorkspace: (candidates) => promptWorkspaceSelection(candidates, "app")
+      });
+      const deepLink = buildOpenLocalProjectDeepLink({
+        machineId: auth.machineId,
+        localProjectId: target.localProjectId,
+        workspaceSlug: target.workspaceSlug
+      });
+      try {
+        await openBrowser(deepLink);
+      } catch (error2) {
+        throw new Error(`Could not hand the link to the operating system. Is the Lody desktop app installed? Open it manually: ${deepLink}`, {
+          cause: error2
+        });
+      }
+      if (options.json) {
+        printJson({
+          ok: true,
+          machineId: auth.machineId,
+          localProjectId: target.localProjectId,
+          name: target.name,
+          rootPath,
+          registered: target.registered,
+          deepLink
+        });
+        return;
+      }
+      if (!target.registered) {
+        logger2.warn("\u26A0\uFE0F  Local CLI daemon is not running, so this directory could not be registered. If it is new, add it from the desktop app after it starts.");
+      }
+      logger2.success(`\u2705 Opening Lody desktop: ${target.name} (${rootPath})`);
+    });
+  });
+  async function exitLogin(code2) {
+    await flushTelemetry();
+    process.exit(code2);
+  }
+  const loginCommand = new Command("login").description("Login to Lody using device authorization flow or an API key").option("-d, --debug", "enable debug output").option("--machine-name <name>", "Machine name to register (defaults to hostname)").option("--auth <api-key>", "Use a CLI API key for non-interactive login").action(async (options) => {
+    if (options.debug) {
+      rootLogger.setDebug(true);
+    }
+    const logger2 = getLogger("login");
+    const authClient = new AuthClient(logger2);
+    const providedAuth = options.auth?.trim();
+    const authMethod = providedAuth ? "api_key" : "device_auth";
+    try {
+      if (options.auth !== void 0 && !providedAuth) {
+        captureAuthEvent("login_failed", {
+          auth_method: "api_key",
+          reason_code: "missing_api_key"
+        });
+        logger2.error("Missing API key for --auth.");
+        await exitLogin(1);
+      }
+      captureAuthEvent("login_started", {
+        auth_method: authMethod
+      });
+      if (providedAuth) {
+        const result2 = await performLoginWithApiKey(authClient, logger2, {
+          apiKey: providedAuth,
+          machineName: options.machineName
+        });
+        if (result2.success) {
+          captureAuthEvent("login_succeeded", {
+            auth_method: "api_key"
+          });
+          logger2.success("\n" + chalk.green("\u2713") + " Successfully logged in!");
+          logger2.info("  User: " + chalk.cyan(result2.user.name || result2.user.email));
+          logger2.info("  Email: " + chalk.cyan(result2.user.email));
+        } else {
+          captureAuthEvent("login_failed", {
+            auth_method: "api_key"
+          });
+          await reportError("login", result2.error, {
+            message: "Login failed using --auth",
+            logger: logger2
+          });
+          await exitLogin(1);
+        }
+        await flushTelemetry();
+        return;
+      }
+      const existingAuth = authClient.getAuthInfo();
+      if (existingAuth) {
+        logger2.debug("Found existing authentication, checking validity...");
+        const validation2 = await authClient.validateToken(existingAuth.token);
+        if (validation2.valid && validation2.user) {
+          captureAuthEvent("login_succeeded", {
+            auth_method: "device_auth",
+            already_logged_in: true
+          });
+          logger2.success("\n" + chalk.green("\u2713") + " You are already logged in!");
+          logger2.info("  User: " + chalk.cyan(validation2.user.name || validation2.user.email));
+          logger2.info("  Email: " + chalk.cyan(validation2.user.email));
+          await flushTelemetry();
+          return;
+        } else if (isRetryableTokenValidationFailure(validation2)) {
+          captureAuthEvent("login_failed", {
+            auth_method: "device_auth",
+            reason_code: "auth_service_unreachable"
+          });
+          logger2.error(`Unable to validate existing authentication because the auth service is unreachable: ${validation2.error ?? "network error"}`);
+          await exitLogin(1);
+        } else if (isTokenValidationUnavailable(validation2)) {
+          captureAuthEvent("login_failed", {
+            auth_method: "device_auth",
+            reason_code: "auth_validation_unavailable"
+          });
+          logger2.error(`Unable to validate existing authentication: ${validation2.error ?? validation2.reason}`);
+          await exitLogin(1);
+        } else {
+          logger2.debug("Existing authentication is invalid, proceeding with new login...");
+        }
+      }
+      logger2.info("Initializing device authorization...");
+      const result = await performLogin(authClient, logger2, {
+        machineName: options.machineName
+      });
+      if (result.success) {
+        captureAuthEvent("login_succeeded", {
+          auth_method: "device_auth"
+        });
+        logger2.success("\n" + chalk.green("\u2713") + " Successfully logged in!");
+        logger2.info("  User: " + chalk.cyan(result.user.name || result.user.email));
+        logger2.info("  Email: " + chalk.cyan(result.user.email));
+      } else {
+        captureAuthEvent("login_failed", {
+          auth_method: "device_auth"
+        });
+        await reportError("login", result.error, {
+          message: "Login failed during device authorization",
+          logger: logger2
+        });
+        await exitLogin(1);
+      }
+      await flushTelemetry();
+    } catch (error2) {
+      captureAuthEvent("login_failed", {
+        auth_method: authMethod,
+        reason_code: "exception"
+      });
+      await reportError("login", error2, {
+        message: "Login command failed",
+        logger: logger2
+      });
+      await exitLogin(1);
+    }
+  });
+  const logoutCommand = new Command("logout").description("Logout from Lody and clear saved authentication").option("-d, --debug", "enable debug output").action(async (options) => {
+    if (options.debug) {
+      rootLogger.setDebug(true);
+    }
+    const logger2 = getLogger("logout");
+    const authClient = new AuthClient(logger2);
+    const logoutResult = authClient.logout();
+    if (!logoutResult.success) {
+      captureAuthEvent("logout_failed");
+      await reportError("logout", logoutResult.error, {
+        message: "Logout failed",
+        logger: logger2
+      });
+      await flushTelemetry();
+      process.exit(1);
+    }
+    if (!logoutResult.user) {
+      captureAuthEvent("logout_succeeded", {
+        was_logged_in: false
+      });
+      logger2.info("You are not logged in.");
+      await flushTelemetry();
+      return;
+    }
+    captureAuthEvent("logout_succeeded", {
+      was_logged_in: true
+    });
+    logger2.info(`Logging out user: ${chalk.cyan(logoutResult.user.email)}`);
+    logger2.success("\n" + chalk.green("\u2713") + " Successfully logged out!");
+    await flushTelemetry();
+  });
+  function setDebugIfEnabled(options) {
+    if (options.debug) {
+      rootLogger.setDebug(true);
+    }
+  }
+  function resolveMachineIdOrExit() {
+    const logger2 = getLogger("project");
+    const authClient = new AuthClient(logger2);
+    const authInfo = authClient.getAuthInfo();
+    if (!authInfo) {
+      logger2.error("Not logged in. Run `lody login` first.");
+      process.exit(1);
+    }
+    return authInfo.machine.machineId;
+  }
   function printProjectControlError(action, response2) {
     const logger2 = getLogger("project");
     logger2.error(`Failed to ${action}: ${response2.message}`);
     if (response2.error === "workspace_required") {
       const candidates = extractWorkspaceCandidates(response2);
       if (candidates && candidates.length > 0) {
-        printWorkspaceCandidates(candidates);
+        printWorkspaceCandidates(candidates, "project");
       }
     }
   }
@@ -205826,7 +206267,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     if (!response2.ok && response2.error === "workspace_required" && canPromptForWorkspace) {
       const candidates = extractWorkspaceCandidates(response2);
       if (candidates && candidates.length > 0) {
-        const selectedWorkspace = await promptWorkspaceSelection(candidates);
+        const selectedWorkspace = await promptWorkspaceSelection(candidates, "project");
         if (!selectedWorkspace) {
           process.exit(1);
         }
@@ -205989,25 +206430,6 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
     ], rows));
   });
   const projectCommand = new Command("project").description("Manage local projects").addCommand(projectAddCommand).addCommand(projectDeleteCommand).addCommand(projectListCommand);
-  async function mapWithConcurrency$1(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);
@@ -207258,7 +207680,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-CkoswOhv.js");
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-BbX0BXrV.js");
     const template = await resolveReviewViewerTemplate();
     const html = injectReviewSnapshot(template, data);
     const outputPath = options.output ? path__default$1.resolve(options.output) : defaultHtmlOutputPath(inputPath);
@@ -227337,6 +227759,7 @@ ${lines2.join("\n")}` : ""}${suffix}`);
   program.addCommand(loginCommand);
   program.addCommand(logoutCommand);
   program.addCommand(startCommand);
+  program.addCommand(appCommand);
   program.addCommand(projectCommand);
   program.addCommand(sessionCommand);
   program.addCommand(syncCommand);