chatroom-cli 1.36.0 → 1.37.1

package/dist/index.js

@@ -13426,6 +13426,10 @@ function startSessionEventForwarder(client4, options) {
   const errorTarget = options.errorTarget ?? process.stderr;
   let cancelled = false;
   let doneResolve;
+  let sessionStarted = false;
+  const seenToolStates = new Map;
+  let lastStatus;
+  const agentEndCallbacks = [];
   const donePromise = new Promise((resolve) => {
     doneResolve = resolve;
   });
@@ -13445,31 +13449,76 @@ function startSessionEventForwarder(client4, options) {
         const eventSession = eventSessionId(event);
         if (eventSession && eventSession !== options.sessionId)
           continue;
-        if (eventSession === undefined && event.type !== "session.idle" && event.type !== "session.compacted" && event.type !== "session.error" && event.type !== "session.status" && event.type !== "file.edited")
+        if (eventSession === undefined && event.type !== "message.part.updated" && event.type !== "session.idle" && event.type !== "session.compacted" && event.type !== "session.error" && event.type !== "session.status" && event.type !== "file.edited")
           continue;
+        if (!sessionStarted) {
+          sessionStarted = true;
+          target.write(formatLogLine(options, "session] Started", `role: ${options.role}`) + `
+`);
+        }
         switch (event.type) {
           case "message.part.updated": {
             const props = event.properties;
             const part = props?.part;
-            if (part?.type === "text" && part.delta) {
-              target.write(formatLogLine(options, "text", part.delta) + `
+            if (part?.type === "text") {
+              const chunk = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
+              if (chunk) {
+                target.write(formatLogLine(options, "text", chunk) + `
 `);
+              }
+            } else if (part?.type === "reasoning") {
+              const chunk = props?.delta !== undefined && props.delta !== "" ? props.delta : part.text;
+              if (chunk) {
+                target.write(formatLogLine(options, "thinking", chunk) + `
+`);
+              }
             } else if (part?.type === "tool" && part.tool) {
-              const state = props?.state ?? "started";
-              target.write(formatLogLine(options, "tool: " + part.tool, state) + `
+              let appendInput = function(base, input, tool) {
+                if (!input || typeof input === "object" && Object.keys(input).length === 0) {
+                  return base;
+                }
+                const inp = input;
+                if (tool === "bash" && typeof inp.command === "string") {
+                  return `${base}: ${inp.command}`;
+                }
+                const inputStr = typeof inp === "string" ? inp : JSON.stringify(inp);
+                return `${base}: ${inputStr}`;
+              };
+              const state = typeof props?.state === "string" ? props.state : typeof part.state?.status === "string" ? part.state.status : "started";
+              let payload = state;
+              if (part.state?.input) {
+                payload = appendInput(payload, part.state.input, part.tool);
+              }
+              if (state === "completed" && part.state?.time?.start !== undefined && part.state?.time?.end !== undefined) {
+                const duration = ((part.state.time.end - part.state.time.start) / 1000).toFixed(1);
+                payload = appendInput(`${state} (${duration}s)`, part.state.input, part.tool);
+              }
+              const callID = part.callID ?? "unknown";
+              const seenKey = `${callID}:${state}`;
+              if (!seenToolStates.has(seenKey)) {
+                seenToolStates.set(seenKey, payload);
+                target.write(formatLogLine(options, "tool: " + part.tool, payload) + `
 `);
+              }
+              if (state === "completed" || state === "error") {
+                seenToolStates.delete(seenKey);
+              }
             }
             break;
           }
           case "file.edited": {
             const props = event.properties;
-            target.write(formatLogLine(options, "file", props?.file) + `
+            const kind = props?.action ?? props?.kind;
+            const filePayload = kind ? `${props?.file} (${kind})` : props?.file;
+            target.write(formatLogLine(options, "file", filePayload) + `
 `);
             break;
           }
           case "session.idle": {
             target.write(formatLogLine(options, "agent_end") + `
 `);
+            for (const cb of agentEndCallbacks)
+              cb();
             break;
           }
           case "session.compacted": {
@@ -13479,15 +13528,25 @@ function startSessionEventForwarder(client4, options) {
           }
           case "session.status": {
             const props = event.properties;
-            target.write(formatLogLine(options, "status", props?.status?.type) + `
+            const currentStatus = props?.status?.type;
+            if (currentStatus !== lastStatus) {
+              lastStatus = currentStatus;
+              target.write(formatLogLine(options, "status", currentStatus) + `
 `);
+            }
             break;
           }
           case "session.error": {
             const props = event.properties;
             const err = props?.error;
             const errMsg = err?.name ? `${err.name}${err?.data?.message ? ": " + err.data.message : ""}` : String(err ?? "unknown");
-            errorTarget.write(formatLogLine(options, "error", errMsg) + `
+            let payload = errMsg;
+            if (props?.tool) {
+              payload += ` [tool: ${props.tool}]`;
+            } else if (props?.command) {
+              payload += ` [command: ${props.command}]`;
+            }
+            errorTarget.write(formatLogLine(options, "error", payload) + `
 `);
             break;
           }
@@ -13508,7 +13567,10 @@ function startSessionEventForwarder(client4, options) {
     stop: () => {
       cancelled = true;
     },
-    done: donePromise
+    done: donePromise,
+    onAgentEnd: (cb) => {
+      agentEndCallbacks.push(cb);
+    }
   };
 }
 
@@ -13629,7 +13691,12 @@ var init_opencode_sdk_agent_service = __esm(() => {
             agent: selected.name,
             ...composedSystem ? { system: composedSystem } : {},
             parts: [{ type: "text", text: prompt }],
-            ...modelParts ? { model: modelParts } : {}
+            ...modelParts ? { model: modelParts } : {},
+            tools: {
+              task: false,
+              question: false,
+              external_directory: false
+            }
           }
         }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
       } catch (err) {
@@ -13688,6 +13755,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
         },
         onOutput: (cb) => {
           outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          forwarder?.onAgentEnd(cb);
         }
       };
     }
@@ -56809,7 +56879,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 +57044,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 +57732,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 +57790,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 +57820,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 +57866,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 +57875,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 +57890,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 +57912,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 +58049,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 +58770,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`);
@@ -58494,6 +58949,13 @@ function handlePing() {
 // src/commands/machine/daemon-start/handlers/command-runner.ts
 import { spawn as spawn3 } from "node:child_process";
 import { access as access3 } from "node:fs/promises";
+function evictStalePendingStops() {
+  const evictBefore = Date.now() - PENDING_STOP_TTL_MS;
+  for (const [runId, ts] of pendingStops) {
+    if (ts < evictBefore)
+      pendingStops.delete(runId);
+  }
+}
 async function reportRunFailed(ctx, runId, reason) {
   try {
     await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -58538,6 +59000,21 @@ async function onCommandRun(ctx, event) {
     console.log(`[${formatTimestamp()}] ⚠️ Command already running: ${runIdStr}`);
     return;
   }
+  if (pendingStops.has(runIdStr)) {
+    pendingStops.delete(runIdStr);
+    console.log(`[${formatTimestamp()}] ⏭️ Skipping command run due to pending stop: ${commandName} (${runIdStr})`);
+    try {
+      await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        runId,
+        status: "stopped"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to update status to stopped for pending-stop skip: ${getErrorMessage(err)}`);
+    }
+    return;
+  }
   console.log(`[${formatTimestamp()}] \uD83D\uDE80 Running command: ${commandName} → ${script}`);
   if (!workingDir.startsWith("/")) {
     console.error(`[${formatTimestamp()}] ❌ Rejected command: workingDir is not absolute: ${workingDir}`);
@@ -58557,6 +59034,34 @@ async function onCommandRun(ctx, event) {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true
   });
+  const timeoutTimer = setTimeout(() => {
+    console.log(`[${formatTimestamp()}] ⏰ Command timed out after ${DEFAULT_COMMAND_TIMEOUT_MS / 60000} minutes: ${commandName} (runId: ${runIdStr})`);
+    const pid = child.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+    } else {
+      child.kill("SIGTERM");
+    }
+    setTimeout(() => {
+      if (!runningProcesses.has(runIdStr))
+        return;
+      console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing timed-out process: ${runIdStr}`);
+      if (pid) {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      } else {
+        child.kill("SIGKILL");
+      }
+    }, FORCE_KILL_DELAY_MS);
+  }, DEFAULT_COMMAND_TIMEOUT_MS);
+  timeoutTimer.unref?.();
   const tracked = {
     process: child,
     runId: runIdStr,
@@ -58564,7 +59069,8 @@ async function onCommandRun(ctx, event) {
     chunkIndex: 0,
     flushTimer: setInterval(() => {
       flushOutput(ctx, tracked).catch(() => {});
-    }, OUTPUT_FLUSH_INTERVAL_MS)
+    }, OUTPUT_FLUSH_INTERVAL_MS),
+    timeoutTimer
   };
   tracked.flushTimer.unref?.();
   runningProcesses.set(runIdStr, tracked);
@@ -58589,6 +59095,8 @@ async function onCommandRun(ctx, event) {
     console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     await flushOutput(ctx, tracked).catch(() => {});
     clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
     runningProcesses.delete(runIdStr);
     const status = code2 === 0 ? "completed" : signal ? "stopped" : "failed";
     try {
@@ -58606,6 +59114,8 @@ async function onCommandRun(ctx, event) {
   child.on("error", async (err) => {
     console.error(`[${formatTimestamp()}] ❌ Command spawn failed: ${commandName}: ${err.message}`);
     clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
     runningProcesses.delete(runIdStr);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
@@ -58624,6 +59134,8 @@ async function onCommandStop(ctx, event) {
   const tracked = runningProcesses.get(runIdStr);
   if (!tracked) {
     console.log(`[${formatTimestamp()}] ⚠️ No running process found for run: ${runIdStr}`);
+    pendingStops.set(runIdStr, Date.now());
+    console.log(`[${formatTimestamp()}] \uD83D\uDCDD Registered pending stop for run: ${runIdStr}`);
     try {
       await ctx.deps.backend.mutation(api.commands.updateRunStatus, {
         sessionId: ctx.sessionId,
@@ -58633,11 +59145,16 @@ async function onCommandStop(ctx, event) {
       });
       console.log(`[${formatTimestamp()}] \uD83D\uDCDD Marked orphaned run as stopped: ${runIdStr}`);
     } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark orphaned run as stopped: ${getErrorMessage(err)}`);
+      console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark orphaned run as stopped (will retry): ${getErrorMessage(err)}`);
+      throw err;
     }
     return;
   }
   console.log(`[${formatTimestamp()}] \uD83D\uDED1 Stopping command run: ${runIdStr}`);
+  if (tracked.timeoutTimer) {
+    clearTimeout(tracked.timeoutTimer);
+    tracked.timeoutTimer = null;
+  }
   const pid = tracked.process.pid;
   if (pid) {
     try {
@@ -58649,7 +59166,7 @@ async function onCommandStop(ctx, event) {
     tracked.process.kill("SIGTERM");
   }
   setTimeout(() => {
-    if (tracked.process.killed)
+    if (!runningProcesses.has(runIdStr))
       return;
     console.log(`[${formatTimestamp()}] \uD83D\uDD2A Force-killing process: ${runIdStr}`);
     if (pid) {
@@ -58661,14 +59178,55 @@ async function onCommandStop(ctx, event) {
     } else {
       tracked.process.kill("SIGKILL");
     }
-  }, 5000);
+  }, FORCE_KILL_DELAY_MS);
+}
+async function shutdownAllCommands(ctx) {
+  if (runningProcesses.size === 0)
+    return;
+  console.log(`[${formatTimestamp()}] Shutting down ${runningProcesses.size} running command(s)...`);
+  for (const [, tracked] of runningProcesses) {
+    clearInterval(tracked.flushTimer);
+    if (tracked.timeoutTimer)
+      clearTimeout(tracked.timeoutTimer);
+    await flushOutput(ctx, tracked).catch(() => {});
+    const pid = tracked.process.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+        tracked.process.kill("SIGTERM");
+      }
+    } else {
+      tracked.process.kill("SIGTERM");
+    }
+  }
+  await new Promise((resolve5) => {
+    const t = setTimeout(resolve5, 3000);
+    t.unref?.();
+  });
+  for (const [, tracked] of runningProcesses) {
+    const pid = tracked.process.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {}
+    } else {
+      try {
+        tracked.process.kill("SIGKILL");
+      } catch {}
+    }
+  }
+  runningProcesses.clear();
+  console.log(`[${formatTimestamp()}] All commands stopped`);
 }
-var runningProcesses, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE;
+var runningProcesses, pendingStops, PENDING_STOP_TTL_MS = 60000, OUTPUT_FLUSH_INTERVAL_MS = 3000, MAX_BUFFER_SIZE, DEFAULT_COMMAND_TIMEOUT_MS, FORCE_KILL_DELAY_MS = 5000;
 var init_command_runner = __esm(() => {
   init_api3();
   init_convex_error();
   runningProcesses = new Map;
+  pendingStops = new Map;
   MAX_BUFFER_SIZE = 100 * 1024;
+  DEFAULT_COMMAND_TIMEOUT_MS = 30 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/handlers/state-recovery.ts
@@ -58712,6 +59270,14 @@ var init_state_recovery = __esm(() => {
   init_api3();
 });
 
+// src/commands/machine/daemon-start/capabilities-snapshot.ts
+function harnessCapabilitiesFingerprint(harnesses, versions) {
+  const h = [...harnesses].sort().join("\x01");
+  const keys = Object.keys(versions).sort();
+  const v3 = keys.map((k) => `${k}:${JSON.stringify(versions[k] ?? null)}`).join("\x02");
+  return `${h}::${v3}`;
+}
+
 // src/infrastructure/local-api/routes/identity.ts
 async function handleIdentity(_req, ctx) {
   const identity = {
@@ -59727,6 +60293,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) {
@@ -59900,6 +60475,17 @@ async function recoverState(ctx) {
   } catch (e) {
     console.log(`   ⚠️  Failed to clear stale PIDs: ${getErrorMessage(e)}`);
   }
+  try {
+    const runResult = await ctx.deps.backend.mutation(api.commands.clearStaleCommandRuns, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    });
+    if (runResult.clearedCount > 0) {
+      console.log(`   \uD83E\uDDF9 Cleared ${runResult.clearedCount} stale command run(s) from backend`);
+    }
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear stale command runs: ${getErrorMessage(e)}`);
+  }
 }
 async function initDaemon() {
   if (!acquireLock()) {
@@ -59949,7 +60535,9 @@ async function initDaemon() {
         events,
         agentServices,
         lastPushedGitState: new Map,
-        lastPushedModels: availableModels
+        lastPushedModels: availableModels,
+        lastPushedHarnessFingerprint: harnessCapabilitiesFingerprint(config3.availableHarnesses, config3.harnessVersions),
+        observedSyncEnabled: featureFlags.observedSyncEnabled ?? false
       };
       registerEventListeners(ctx);
       logStartup(ctx, availableModels);
@@ -59991,11 +60579,13 @@ var init_init2 = __esm(() => {
   init_convex_error();
   init_version();
   init_pid();
+  init_featureFlags();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
 // src/events/lifecycle/on-daemon-shutdown.ts
 async function onDaemonShutdown(ctx) {
+  await shutdownAllCommands(ctx);
   const activeAgents = ctx.deps.agentProcessManager.listActive();
   if (activeAgents.length > 0) {
     console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s)...`);
@@ -60024,6 +60614,7 @@ async function onDaemonShutdown(ctx) {
 }
 var init_on_daemon_shutdown = __esm(() => {
   init_api3();
+  init_command_runner();
 });
 
 // src/infrastructure/git/git-writer.ts
@@ -60215,15 +60806,18 @@ function formatModelMap(map) {
   return Object.entries(map).map(([harness, models]) => `${harness}: ${models.join(", ")}`).join("; ");
 }
 async function refreshModels(ctx) {
-  if (!ctx.config)
-    return;
+  if (!ctx.config) {
+    return { kind: "noop" };
+  }
   const models = await discoverModels(ctx.agentServices);
   const freshConfig = ensureMachineRegistered();
   ctx.config.availableHarnesses = freshConfig.availableHarnesses;
   ctx.config.harnessVersions = freshConfig.harnessVersions;
-  const diff = diffModels(ctx.lastPushedModels, models);
-  if (!diff.hasChanges) {
-    return;
+  const modelDiff = diffModels(ctx.lastPushedModels, models);
+  const nextHarnessFingerprint = harnessCapabilitiesFingerprint(ctx.config.availableHarnesses, ctx.config.harnessVersions);
+  const harnessFingerprintChanged = ctx.lastPushedHarnessFingerprint !== null && nextHarnessFingerprint !== ctx.lastPushedHarnessFingerprint;
+  if (!modelDiff.hasChanges && !harnessFingerprintChanged) {
+    return { kind: "skipped_no_changes" };
   }
   const totalCount = Object.values(models).flat().length;
   try {
@@ -60235,15 +60829,19 @@ async function refreshModels(ctx) {
       availableModels: models
     });
     ctx.lastPushedModels = models;
-    if (Object.keys(diff.added).length > 0) {
-      console.log(`[${formatTimestamp()}] ➕ New models detected — ${formatModelMap(diff.added)}`);
+    ctx.lastPushedHarnessFingerprint = nextHarnessFingerprint;
+    if (Object.keys(modelDiff.added).length > 0) {
+      console.log(`[${formatTimestamp()}] ➕ New models detected — ${formatModelMap(modelDiff.added)}`);
     }
-    if (Object.keys(diff.removed).length > 0) {
-      console.log(`[${formatTimestamp()}] ➖ Models no longer available — ${formatModelMap(diff.removed)}`);
+    if (Object.keys(modelDiff.removed).length > 0) {
+      console.log(`[${formatTimestamp()}] ➖ Models no longer available — ${formatModelMap(modelDiff.removed)}`);
     }
     console.log(`[${formatTimestamp()}] \uD83D\uDD04 Model refresh pushed: ${totalCount > 0 ? `${totalCount} models` : "none discovered"}`);
+    return { kind: "pushed" };
   } catch (error) {
-    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${getErrorMessage(error)}`);
+    const message = getErrorMessage(error);
+    console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${message}`);
+    return { kind: "failed", message };
   }
 }
 function evictStaleDedupEntries(tracker) {
@@ -60260,6 +60858,10 @@ function evictStaleDedupEntries(tracker) {
     if (ts2 < evictBefore)
       tracker.gitRefreshIds.delete(id);
   }
+  for (const [id, ts2] of tracker.capabilitiesRefreshIds) {
+    if (ts2 < evictBefore)
+      tracker.capabilitiesRefreshIds.delete(id);
+  }
   for (const [id, ts2] of tracker.localActionIds) {
     if (ts2 < evictBefore)
       tracker.localActionIds.delete(id);
@@ -60272,6 +60874,7 @@ function evictStaleDedupEntries(tracker) {
     if (ts2 < evictBefore)
       tracker.commandStopIds.delete(id);
   }
+  evictStalePendingStops();
 }
 async function dispatchCommandEvent(ctx, event, tracker) {
   const eventId = event._id.toString();
@@ -60279,40 +60882,40 @@ async function dispatchCommandEvent(ctx, event, tracker) {
   if (event.type === "agent.requestStart") {
     if (tracker.commandIds.has(eventId))
       return;
-    tracker.commandIds.set(eventId, Date.now());
     await onRequestStartAgent(ctx, event);
+    tracker.commandIds.set(eventId, Date.now());
   } else if (event.type === "agent.requestStop") {
     if (tracker.commandIds.has(eventId))
       return;
-    tracker.commandIds.set(eventId, Date.now());
     await onRequestStopAgent(ctx, event);
+    tracker.commandIds.set(eventId, Date.now());
   } else if (event.type === "daemon.ping") {
     if (tracker.pingIds.has(eventId))
       return;
-    tracker.pingIds.set(eventId, Date.now());
     handlePing();
     await ctx.deps.backend.mutation(api.machines.ackPing, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
       pingEventId: event._id
     });
+    tracker.pingIds.set(eventId, Date.now());
   } else if (event.type === "daemon.gitRefresh") {
     if (tracker.gitRefreshIds.has(eventId))
       return;
-    tracker.gitRefreshIds.set(eventId, Date.now());
     const stateKey = makeGitStateKey(ctx.machineId, event.workingDir);
     ctx.lastPushedGitState.delete(stateKey);
     console.log(`[${formatTimestamp()}] \uD83D\uDD04 Git refresh requested for ${event.workingDir}`);
     await pushGitState(ctx);
+    tracker.gitRefreshIds.set(eventId, Date.now());
   } else if (event.type === "daemon.localAction") {
     if (tracker.localActionIds.has(eventId))
       return;
-    tracker.localActionIds.set(eventId, Date.now());
     console.log(`[${formatTimestamp()}] \uD83D\uDDA5️  Local action: ${event.action} → ${event.workingDir}`);
     const result = await executeLocalAction(event.action, event.workingDir);
     if (!result.success) {
       console.warn(`[${formatTimestamp()}] ⚠️  Local action failed: ${result.error}`);
     }
+    tracker.localActionIds.set(eventId, Date.now());
   } else if (eventType === "command.run") {
     if (tracker.commandRunIds.has(eventId))
       return;
@@ -60321,8 +60924,42 @@ async function dispatchCommandEvent(ctx, event, tracker) {
   } else if (eventType === "command.stop") {
     if (tracker.commandStopIds.has(eventId))
       return;
-    tracker.commandStopIds.set(eventId, Date.now());
     await onCommandStop(ctx, event);
+    tracker.commandStopIds.set(eventId, Date.now());
+  } else if (event.type === "daemon.refreshCapabilities") {
+    if (tracker.capabilitiesRefreshIds.has(eventId))
+      return;
+    console.log(`[${formatTimestamp()}] \uD83D\uDD04 Manual capabilities refresh requested`);
+    const outcome = await refreshModels(ctx);
+    tracker.capabilitiesRefreshIds.set(eventId, Date.now());
+    const batchId = "batchId" in event && event.batchId !== undefined ? event.batchId : undefined;
+    if (!batchId) {
+      return;
+    }
+    let status;
+    let errorMessage;
+    if (outcome.kind === "pushed") {
+      status = "completed";
+    } else if (outcome.kind === "skipped_no_changes") {
+      status = "skipped_no_changes";
+    } else if (outcome.kind === "failed") {
+      status = "failed";
+      errorMessage = outcome.message;
+    } else {
+      status = "failed";
+      errorMessage = "Daemon configuration unavailable";
+    }
+    try {
+      await ctx.deps.backend.mutation(api.machines.reportCapabilitiesRefreshResult, {
+        sessionId: ctx.sessionId,
+        batchId,
+        machineId: ctx.machineId,
+        status,
+        errorMessage
+      });
+    } catch (error) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Capabilities refresh report failed: ${getErrorMessage(error)}`);
+    }
   }
 }
 async function startCommandLoop(ctx) {
@@ -60334,12 +60971,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 +60987,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 +61004,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 +61020,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
@@ -60382,6 +61031,7 @@ Listening for commands...`);
     commandIds: new Map,
     pingIds: new Map,
     gitRefreshIds: new Map,
+    capabilitiesRefreshIds: new Map,
     localActionIds: new Map,
     commandRunIds: new Map,
     commandStopIds: new Map
@@ -60402,15 +61052,8 @@ Listening for commands...`);
       }
     }
   });
-  const modelRefreshTimer = setInterval(() => {
-    refreshModels(ctx).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Model refresh error: ${getErrorMessage(err)}`);
-    });
-  }, MODEL_REFRESH_INTERVAL_MS);
-  modelRefreshTimer.unref();
   return await new Promise(() => {});
 }
-var MODEL_REFRESH_INTERVAL_MS;
 var init_command_loop = __esm(() => {
   init_on_request_start_agent();
   init_on_request_stop_agent();
@@ -60420,6 +61063,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();
@@ -60428,7 +61072,6 @@ var init_command_loop = __esm(() => {
   init_local_actions();
   init_machine();
   init_convex_error();
-  MODEL_REFRESH_INTERVAL_MS = 10 * 1000;
 });
 
 // src/commands/machine/daemon-start/index.ts
@@ -61525,5 +62168,5 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=29314BC73A4B833B64756E2164756E21
+//# debugId=1C43E3169710F16B64756E2164756E21
 //# sourceMappingURL=index.js.map