chatroom-cli 1.36.0 → 1.36.1

package/dist/index.js

@@ -56809,7 +56809,7 @@ var init_telegram = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000;
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_SAFETY_POLL_MS = 30000;
 
 // src/events/daemon/agent/on-request-start-agent.ts
 async function onRequestStartAgent(ctx, event) {
@@ -56974,6 +56974,55 @@ var init_pid = __esm(() => {
   CHATROOM_DIR4 = join8(homedir5(), ".chatroom");
 });
 
+// src/infrastructure/git/git-state-pipeline.ts
+import { createHash as createHash3 } from "node:crypto";
+
+class GitStatePipeline {
+  fields;
+  constructor(fields) {
+    this.fields = fields;
+  }
+  async collect(workingDir, preCollected) {
+    const results = new Map(preCollected);
+    if (this.fields.length === 0)
+      return results;
+    const entries = await Promise.all(this.fields.filter((f) => !results.has(f.key)).map(async (field) => {
+      try {
+        const raw = await field.collect(workingDir);
+        return { key: field.key, raw };
+      } catch {
+        return { key: field.key, raw: field.defaultValue };
+      }
+    }));
+    for (const { key, raw } of entries) {
+      results.set(key, raw);
+    }
+    return results;
+  }
+  computeHash(values, slim) {
+    const hashInput = {};
+    for (const field of this.fields) {
+      if (slim && !field.includeInSlim)
+        continue;
+      const raw = values.get(field.key) ?? field.defaultValue;
+      hashInput[field.key] = field.toHashable(raw);
+    }
+    return createHash3("md5").update(JSON.stringify(hashInput)).digest("hex");
+  }
+  toMutationArgs(values, slim) {
+    const args = {};
+    for (const field of this.fields) {
+      if (slim && !field.includeInSlim)
+        continue;
+      const raw = values.get(field.key) ?? field.defaultValue;
+      Object.assign(args, field.toMutationPartial(raw));
+    }
+    args.pipelineMode = slim ? "slim" : "full";
+    return args;
+  }
+}
+var init_git_state_pipeline = () => {};
+
 // src/commands/machine/daemon-start/utils.ts
 function formatTimestamp() {
   return new Date().toISOString().replace("T", " ").substring(0, 19);
@@ -57613,6 +57662,28 @@ async function processMoreCommits(ctx, req) {
   });
   console.log(`[${formatTimestamp()}] \uD83D\uDCDC More commits appended: ${req.workingDir} (+${commits.length} commits, offset=${offset})`);
 }
+async function processAllPullRequests(ctx, req) {
+  const pullRequests = await getAllPRs(req.workingDir);
+  await ctx.deps.backend.mutation(api.workspaces.upsertAllPullRequests, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    pullRequests
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCCB All pull requests pushed: ${req.workingDir} (${pullRequests.length} PRs)`);
+}
+async function processRecentCommits(ctx, req) {
+  const commits = await getRecentCommits(req.workingDir, COMMITS_PER_PAGE, 0);
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  await ctx.deps.backend.mutation(api.workspaces.upsertRecentCommits, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    commits,
+    hasMoreCommits
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Recent commits pushed: ${req.workingDir} (${commits.length} commits)`);
+}
 async function processRequests(ctx, requests, processedRequestIds, dedupTtlMs) {
   const evictBefore = Date.now() - dedupTtlMs;
   for (const [id, ts] of processedRequestIds) {
@@ -57649,6 +57720,12 @@ async function processRequests(ctx, requests, processedRequestIds, dedupTtlMs) {
         case "pr_commits":
           await processPRCommits(ctx, req);
           break;
+        case "all_pull_requests":
+          await processAllPullRequests(ctx, req);
+          break;
+        case "recent_commits":
+          await processRecentCommits(ctx, req);
+          break;
       }
       await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
         sessionId: ctx.sessionId,
@@ -57673,7 +57750,26 @@ var init_git_subscription = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/git-heartbeat.ts
-import { createHash as createHash3 } from "node:crypto";
+function makeBranchDependentFields(branch) {
+  return [
+    {
+      key: "openPullRequests",
+      includeInSlim: true,
+      collect: (wd) => getOpenPRsForBranch(wd, branch),
+      toHashable: (raw) => raw.map((pr) => pr.prNumber),
+      toMutationPartial: (raw) => ({ openPullRequests: raw }),
+      defaultValue: []
+    },
+    {
+      key: "headCommitStatus",
+      includeInSlim: true,
+      collect: (wd) => getCommitStatusChecks(wd, branch),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ headCommitStatus: raw }),
+      defaultValue: null
+    }
+  ];
+}
 async function pushGitState(ctx) {
   let workspaces;
   try {
@@ -57700,8 +57796,8 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
   const stateKey = makeGitStateKey(ctx.machineId, workingDir);
   const isRepo = await isGitRepo(workingDir);
   if (!isRepo) {
-    const stateHash2 = "not_found";
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+    const stateHash = "not_found";
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash)
       return;
     await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
@@ -57709,20 +57805,13 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
       workingDir,
       status: "not_found"
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    ctx.lastPushedGitState.set(stateKey, stateHash);
     return;
   }
-  const [branchResult, dirtyResult, diffStatResult, commits, commitsAhead] = await Promise.all([
-    getBranch(workingDir),
-    isDirty(workingDir),
-    getDiffStat(workingDir),
-    getRecentCommits(workingDir, COMMITS_PER_PAGE),
-    getCommitsAhead(workingDir)
-  ]);
-  const remotes = await getRemotes(workingDir);
+  const branchResult = await getBranch(workingDir);
   if (branchResult.status === "error") {
-    const stateHash2 = `error:${branchResult.message}`;
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+    const stateHash = `error:${branchResult.message}`;
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash)
       return;
     await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
@@ -57731,21 +57820,21 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
       status: "error",
       errorMessage: branchResult.message
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    ctx.lastPushedGitState.set(stateKey, stateHash);
     return;
   }
   if (branchResult.status === "not_found") {
     return;
   }
-  const openPRs = await getOpenPRsForBranch(workingDir, branchResult.branch);
-  const allPRs = await getAllPRs(workingDir);
-  const headCommitStatus = await getCommitStatusChecks(workingDir, branchResult.branch);
   const branch = branchResult.branch;
-  const isDirty2 = dirtyResult;
-  const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+  const allFields = [branchField, ...GIT_STATE_FIELDS, ...makeBranchDependentFields(branch)];
+  const pipeline2 = new GitStatePipeline(allFields);
+  const preCollected = new Map([["branch", branchResult]]);
+  const values = await pipeline2.collect(workingDir, preCollected);
+  const commits = values.get("commits");
   const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
-  const stateHash = createHash3("md5").update(JSON.stringify({ branch, isDirty: isDirty2, diffStat, commitsAhead, shas: commits.map((c) => c.sha), prs: openPRs.map((pr) => pr.prNumber), allPrs: allPRs.map((pr) => `${pr.prNumber}:${pr.state}`), remotes: remotes.map((r) => `${r.name}:${r.url}`), headCommitStatus })).digest("hex");
-  if (ctx.lastPushedGitState.get(stateKey) === stateHash) {
+  const hash = pipeline2.computeHash(values, false);
+  if (ctx.lastPushedGitState.get(stateKey) === hash) {
     return;
   }
   await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
@@ -57753,23 +57842,73 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
     machineId: ctx.machineId,
     workingDir,
     status: "available",
-    branch,
-    isDirty: isDirty2,
-    diffStat,
+    ...pipeline2.toMutationArgs(values, false),
     recentCommits: commits,
-    hasMoreCommits,
-    openPullRequests: openPRs,
-    allPullRequests: allPRs,
-    remotes,
-    commitsAhead,
-    headCommitStatus
+    hasMoreCommits
   });
-  ctx.lastPushedGitState.set(stateKey, stateHash);
-  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${isDirty2 ? ", dirty" : ", clean"})`);
+  ctx.lastPushedGitState.set(stateKey, hash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${values.get("isDirty") ? ", dirty" : ", clean"})`);
   prefetchMissingCommitDetails(ctx, workingDir, commits).catch((err) => {
     console.warn(`[${formatTimestamp()}] ⚠️  Commit pre-fetch failed for ${workingDir}: ${getErrorMessage(err)}`);
   });
 }
+async function pushSingleWorkspaceGitSummaryForObserved(ctx, workingDir, reason = "safety-poll") {
+  const stateKey = makeGitStateKey(ctx.machineId, workingDir);
+  const isRepo = await isGitRepo(workingDir);
+  if (!isRepo) {
+    const stateHash = "not_found";
+    if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === stateHash)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      status: "not_found"
+    });
+    ctx.lastPushedGitState.set(stateKey, stateHash);
+    return;
+  }
+  const branchResult = await getBranch(workingDir);
+  if (branchResult.status === "error") {
+    const stateHash = `error:${branchResult.message}`;
+    if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === stateHash)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      status: "error",
+      errorMessage: branchResult.message
+    });
+    ctx.lastPushedGitState.set(stateKey, stateHash);
+    return;
+  }
+  if (branchResult.status === "not_found") {
+    return;
+  }
+  const branch = branchResult.branch;
+  const slimFields = [
+    branchField,
+    ...GIT_STATE_FIELDS.filter((f) => f.includeInSlim),
+    ...makeBranchDependentFields(branch)
+  ];
+  const pipeline2 = new GitStatePipeline(slimFields);
+  const preCollected = new Map([["branch", branchResult]]);
+  const values = await pipeline2.collect(workingDir, preCollected);
+  const hash = pipeline2.computeHash(values, true);
+  if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === hash) {
+    return;
+  }
+  await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "available",
+    ...pipeline2.toMutationArgs(values, true)
+  });
+  ctx.lastPushedGitState.set(stateKey, hash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed git summary pushed: ${workingDir} (${branch}${values.get("isDirty") ? ", dirty" : ", clean"})${reason === "refresh" ? " [refresh]" : ""}`);
+}
 async function prefetchMissingCommitDetails(ctx, workingDir, commits) {
   if (commits.length === 0)
     return;
@@ -57840,11 +57979,87 @@ async function prefetchSingleCommit(ctx, workingDir, sha, commits) {
   });
   console.log(`[${formatTimestamp()}] ✅ Pre-fetched: ${sha.slice(0, 7)} in ${workingDir}`);
 }
+var branchField, GIT_STATE_FIELDS;
 var init_git_heartbeat = __esm(() => {
+  init_git_state_pipeline();
   init_git_subscription();
   init_api3();
   init_git_reader();
   init_convex_error();
+  branchField = {
+    key: "branch",
+    includeInSlim: true,
+    collect: () => {
+      throw new Error("branch must be pre-collected");
+    },
+    toHashable: (raw) => {
+      const r = raw;
+      return r.status === "available" ? r.branch : "unknown";
+    },
+    toMutationPartial: (raw) => {
+      const r = raw;
+      return r.status === "available" ? { branch: r.branch } : {};
+    },
+    defaultValue: { status: "not_found" }
+  };
+  GIT_STATE_FIELDS = [
+    {
+      key: "isDirty",
+      includeInSlim: true,
+      collect: (wd) => isDirty(wd),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ isDirty: raw }),
+      defaultValue: false
+    },
+    {
+      key: "diffStat",
+      includeInSlim: false,
+      collect: (wd) => getDiffStat(wd),
+      toHashable: (raw) => {
+        const r = raw;
+        return r.status === "available" ? r.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+      },
+      toMutationPartial: (raw) => {
+        const r = raw;
+        return {
+          diffStat: r.status === "available" ? r.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 }
+        };
+      },
+      defaultValue: { status: "not_found" }
+    },
+    {
+      key: "commits",
+      includeInSlim: false,
+      collect: (wd) => getRecentCommits(wd, COMMITS_PER_PAGE),
+      toHashable: (raw) => raw.map((c) => c.sha),
+      toMutationPartial: () => ({}),
+      defaultValue: []
+    },
+    {
+      key: "commitsAhead",
+      includeInSlim: false,
+      collect: (wd) => getCommitsAhead(wd),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ commitsAhead: raw }),
+      defaultValue: 0
+    },
+    {
+      key: "remotes",
+      includeInSlim: false,
+      collect: (wd) => getRemotes(wd),
+      toHashable: (raw) => raw.map((r) => `${r.name}:${r.url}`),
+      toMutationPartial: (raw) => ({ remotes: raw }),
+      defaultValue: []
+    },
+    {
+      key: "allPullRequests",
+      includeInSlim: false,
+      collect: (wd) => getAllPRs(wd),
+      toHashable: (raw) => raw.map((pr) => `${pr.prNumber}:${pr.state}`),
+      toMutationPartial: (raw) => ({ allPullRequests: raw }),
+      defaultValue: []
+    }
+  ];
 });
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
@@ -58485,6 +58700,176 @@ var init_file_tree_subscription = __esm(() => {
   init_convex_error();
 });
 
+// src/commands/machine/daemon-start/observed-sync.ts
+function startObservedSyncSubscription(ctx, wsClient2) {
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Starting observed-sync subscription (reactive)`);
+  const observedWorkingDirs = new Map;
+  const chatroomRefreshState = new Map;
+  const skippedPushCount = new Map;
+  const pendingRefresh = new Map;
+  let stopped = false;
+  let reconcileInFlight = false;
+  const unsubscribe = wsClient2.onUpdate(api.machines.getObservedChatroomsForMachine, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  }, (observed) => {
+    if (stopped)
+      return;
+    handleObservedChange(observed ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Observed-sync subscription error: ${getErrorMessage(err)}`);
+  });
+  const reconcileIntervalMs = Math.max(OBSERVATION_TTL_MS / 2, OBSERVED_SAFETY_POLL_MS);
+  const reconcileTimer = setInterval(() => {
+    if (stopped || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    ctx.deps.backend.query(api.machines.getObservedChatroomsForMachine, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    }).then((observed) => {
+      if (!stopped)
+        handleObservedChange(observed ?? []);
+    }).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Observed-sync reconcile query failed: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      reconcileInFlight = false;
+    });
+  }, reconcileIntervalMs);
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync subscription started`);
+  return {
+    stop: () => {
+      stopped = true;
+      unsubscribe();
+      clearInterval(reconcileTimer);
+      for (const [wd, state] of observedWorkingDirs) {
+        clearInterval(state.intervalHandle);
+        const skips = skippedPushCount.get(wd) ?? 0;
+        if (skips > 0) {
+          console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
+        } else {
+          console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
+        }
+      }
+      observedWorkingDirs.clear();
+      skippedPushCount.clear();
+      pendingRefresh.clear();
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync subscription stopped`);
+    }
+  };
+  function handleObservedChange(observed) {
+    const newWorkingDirs = new Set;
+    const refreshedWorkingDirs = new Set;
+    for (const chatroom of observed) {
+      const chatroomId = chatroom.chatroomId;
+      const currentRefresh = chatroom.lastRefreshedAt;
+      const previous = chatroomRefreshState.get(chatroomId);
+      const wasRefreshed = currentRefresh !== null && currentRefresh !== undefined && (previous === undefined || (previous.lastRefreshedAt ?? 0) < currentRefresh);
+      if (wasRefreshed) {
+        chatroomRefreshState.set(chatroomId, { lastRefreshedAt: currentRefresh });
+        for (const wd of chatroom.workingDirs) {
+          refreshedWorkingDirs.add(wd);
+        }
+      }
+      for (const wd of chatroom.workingDirs) {
+        newWorkingDirs.add(wd);
+      }
+    }
+    for (const [chatroomId] of chatroomRefreshState) {
+      const stillObserved = observed.some((c) => c.chatroomId === chatroomId);
+      if (!stillObserved) {
+        chatroomRefreshState.delete(chatroomId);
+      }
+    }
+    const currentWorkingDirs = new Set(observedWorkingDirs.keys());
+    let addedCount = 0;
+    let removedCount = 0;
+    for (const wd of currentWorkingDirs) {
+      if (!newWorkingDirs.has(wd)) {
+        const state = observedWorkingDirs.get(wd);
+        if (state) {
+          clearInterval(state.intervalHandle);
+          observedWorkingDirs.delete(wd);
+          const skips = skippedPushCount.get(wd) ?? 0;
+          if (skips > 0) {
+            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
+          } else {
+            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
+          }
+          skippedPushCount.delete(wd);
+          pendingRefresh.delete(wd);
+          removedCount++;
+        }
+      }
+    }
+    for (const wd of newWorkingDirs) {
+      if (!observedWorkingDirs.has(wd)) {
+        observedWorkingDirs.set(wd, {
+          intervalHandle: setInterval(() => {
+            schedulePushForWorkingDir(wd, "safety-poll");
+          }, OBSERVED_SAFETY_POLL_MS),
+          pushInFlight: false
+        });
+        console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Started observing ${wd}`);
+        schedulePushForWorkingDir(wd, "safety-poll");
+        addedCount++;
+      }
+    }
+    if (addedCount > 0 || removedCount > 0) {
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observing ${observedWorkingDirs.size} working dir(s)`);
+    }
+    for (const wd of refreshedWorkingDirs) {
+      if (observedWorkingDirs.has(wd)) {
+        console.log(`[${formatTimestamp()}] \uD83D\uDD04 Refresh triggered for ${wd}`);
+        schedulePushForWorkingDir(wd, "refresh");
+      }
+    }
+  }
+  function schedulePushForWorkingDir(workingDir, reason = "safety-poll") {
+    if (stopped)
+      return;
+    const state = observedWorkingDirs.get(workingDir);
+    if (!state)
+      return;
+    if (state.pushInFlight) {
+      if (reason === "refresh") {
+        pendingRefresh.set(workingDir, true);
+      }
+      const current = skippedPushCount.get(workingDir) ?? 0;
+      skippedPushCount.set(workingDir, current + 1);
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Skipping observed push for ${workingDir} (${reason}, in flight)`);
+      return;
+    }
+    state.pushInFlight = true;
+    pushForWorkingDir(workingDir, reason).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Push failed for ${workingDir}: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      const s = observedWorkingDirs.get(workingDir);
+      if (s) {
+        s.pushInFlight = false;
+        if (pendingRefresh.get(workingDir)) {
+          pendingRefresh.delete(workingDir);
+          schedulePushForWorkingDir(workingDir, "refresh");
+        }
+      }
+    });
+  }
+  async function pushForWorkingDir(workingDir, reason = "safety-poll") {
+    await pushSingleWorkspaceGitSummaryForObserved(ctx, workingDir, reason).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Observed git summary push failed for ${workingDir}: ${getErrorMessage(err)}`);
+    });
+    await pushSingleWorkspaceCommands(ctx, workingDir).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Command sync failed for ${workingDir}: ${getErrorMessage(err)}`);
+    });
+  }
+}
+var init_observed_sync = __esm(() => {
+  init_api3();
+  init_git_heartbeat();
+  init_command_sync_heartbeat();
+  init_convex_error();
+});
+
 // src/commands/machine/daemon-start/handlers/ping.ts
 function handlePing() {
   console.log(`   ↪ Responding: pong`);
@@ -59727,6 +60112,15 @@ var init_agent_process_manager = __esm(() => {
   init_api3();
 });
 
+// ../../services/backend/config/featureFlags.ts
+var featureFlags;
+var init_featureFlags = __esm(() => {
+  featureFlags = {
+    observedSyncEnabled: false,
+    disableLogin: false
+  };
+});
+
 // src/commands/machine/daemon-start/init.ts
 import { stat as stat2 } from "node:fs/promises";
 async function discoverModels(agentServices) {
@@ -59949,7 +60343,8 @@ async function initDaemon() {
         events,
         agentServices,
         lastPushedGitState: new Map,
-        lastPushedModels: availableModels
+        lastPushedModels: availableModels,
+        observedSyncEnabled: featureFlags.observedSyncEnabled ?? false
       };
       registerEventListeners(ctx);
       logStartup(ctx, availableModels);
@@ -59991,6 +60386,7 @@ var init_init2 = __esm(() => {
   init_convex_error();
   init_version();
   init_pid();
+  init_featureFlags();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
@@ -60334,12 +60730,14 @@ async function startCommandLoop(ctx) {
     }).then(() => {
       heartbeatCount++;
       console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
-      pushGitState(ctx).catch((err) => {
-        console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
-      });
-      pushCommands(ctx).catch((err) => {
-        console.warn(`[${formatTimestamp()}] ⚠️  Command sync failed: ${getErrorMessage(err)}`);
-      });
+      if (!ctx.observedSyncEnabled) {
+        pushGitState(ctx).catch((err) => {
+          console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
+        });
+        pushCommands(ctx).catch((err) => {
+          console.warn(`[${formatTimestamp()}] ⚠️  Command sync failed: ${getErrorMessage(err)}`);
+        });
+      }
     }).catch((err) => {
       console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${getErrorMessage(err)}`);
     });
@@ -60348,8 +60746,13 @@ async function startCommandLoop(ctx) {
   let gitSubscriptionHandle = null;
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
-  pushGitState(ctx).catch(() => {});
-  pushCommands(ctx).catch(() => {});
+  let observedSyncSubscriptionHandle = null;
+  if (ctx.observedSyncEnabled) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync enabled, skipping immediate push`);
+  } else {
+    pushGitState(ctx).catch(() => {});
+    pushCommands(ctx).catch(() => {});
+  }
   const shutdown = async () => {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
@@ -60360,6 +60763,8 @@ async function startCommandLoop(ctx) {
       fileContentSubscriptionHandle.stop();
     if (fileTreeSubscriptionHandle)
       fileTreeSubscriptionHandle.stop();
+    if (observedSyncSubscriptionHandle)
+      observedSyncSubscriptionHandle.stop();
     await onDaemonShutdown(ctx);
     if (ctx.stopLocalApi) {
       await ctx.stopLocalApi().catch(() => {});
@@ -60374,6 +60779,9 @@ async function startCommandLoop(ctx) {
   gitSubscriptionHandle = startGitRequestSubscription(ctx, wsClient2);
   fileContentSubscriptionHandle = startFileContentSubscription(ctx, wsClient2);
   fileTreeSubscriptionHandle = startFileTreeSubscription(ctx, wsClient2);
+  if (ctx.observedSyncEnabled) {
+    observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
+  }
   console.log(`
 Listening for commands...`);
   console.log(`Press Ctrl+C to stop
@@ -60420,6 +60828,7 @@ var init_command_loop = __esm(() => {
   init_file_content_subscription();
   init_file_tree_subscription();
   init_git_subscription();
+  init_observed_sync();
   init_command_runner();
   init_init2();
   init_api3();
@@ -61525,5 +61934,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=29314BC73A4B833B64756E2164756E21
+//# debugId=C6BB51F249BBA12864756E2164756E21
 //# sourceMappingURL=index.js.map