chatroom-cli 1.6.5 → 1.7.1

package/dist/index.js

@@ -14022,29 +14022,149 @@ async function recoverAgentState(ctx) {
   const entries = ctx.deps.machine.listAgentEntries(ctx.machineId);
   if (entries.length === 0) {
     console.log(`   No agent entries found — nothing to recover`);
-    return;
-  }
-  let recovered = 0;
-  let cleared = 0;
-  for (const { chatroomId, role, entry } of entries) {
-    const { pid, harness } = entry;
-    const service = ctx.agentServices.get(harness) ?? ctx.agentServices.values().next().value;
-    const alive = service ? service.isAlive(pid) : false;
-    if (alive) {
-      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
-      recovered++;
-    } else {
-      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
-      await clearAgentPidEverywhere(ctx, chatroomId, role);
-      cleared++;
+  } else {
+    let recovered = 0;
+    let cleared = 0;
+    const chatroomIds = new Set;
+    for (const { chatroomId, role, entry } of entries) {
+      const { pid, harness } = entry;
+      const service = ctx.agentServices.get(harness) ?? ctx.agentServices.values().next().value;
+      const alive = service ? service.isAlive(pid) : false;
+      if (alive) {
+        console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
+        recovered++;
+        chatroomIds.add(chatroomId);
+      } else {
+        console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
+        await clearAgentPidEverywhere(ctx, chatroomId, role);
+        cleared++;
+      }
+    }
+    console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
+    for (const chatroomId of chatroomIds) {
+      try {
+        const configsResult = await ctx.deps.backend.query(api.machines.getMachineAgentConfigs, {
+          sessionId: ctx.sessionId,
+          chatroomId
+        });
+        for (const config3 of configsResult.configs) {
+          if (config3.machineId === ctx.machineId && config3.workingDir) {
+            ctx.activeWorkingDirs.add(config3.workingDir);
+          }
+        }
+      } catch {}
+    }
+    if (ctx.activeWorkingDirs.size > 0) {
+      console.log(`   \uD83D\uDD00 Recovered ${ctx.activeWorkingDirs.size} active working dir(s) for git tracking`);
     }
   }
-  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
 }
 var init_state_recovery = __esm(() => {
+  init_api3();
   init_shared();
 });
 
+// src/infrastructure/services/harness-spawning/rate-limiter.ts
+class SpawnRateLimiter {
+  config;
+  buckets = new Map;
+  constructor(config3 = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config3 };
+  }
+  tryConsume(chatroomId, reason) {
+    if (reason.startsWith("user.")) {
+      return { allowed: true };
+    }
+    const bucket = this._getOrCreateBucket(chatroomId);
+    this._refill(bucket);
+    if (bucket.tokens < 1) {
+      const elapsed = Date.now() - bucket.lastRefillAt;
+      const retryAfterMs = this.config.refillRateMs - elapsed;
+      console.warn(`⚠️ [RateLimiter] Agent spawn rate-limited for chatroom ${chatroomId} (reason: ${reason}). Retry after ${retryAfterMs}ms`);
+      return { allowed: false, retryAfterMs };
+    }
+    bucket.tokens -= 1;
+    const remaining = Math.floor(bucket.tokens);
+    if (remaining <= LOW_TOKEN_THRESHOLD) {
+      console.warn(`⚠️ [RateLimiter] Agent spawn tokens running low for chatroom ${chatroomId} (${remaining}/${this.config.maxTokens} remaining)`);
+    }
+    return { allowed: true };
+  }
+  getStatus(chatroomId) {
+    const bucket = this._getOrCreateBucket(chatroomId);
+    this._refill(bucket);
+    return {
+      remaining: Math.floor(bucket.tokens),
+      total: this.config.maxTokens
+    };
+  }
+  _getOrCreateBucket(chatroomId) {
+    if (!this.buckets.has(chatroomId)) {
+      this.buckets.set(chatroomId, {
+        tokens: this.config.initialTokens,
+        lastRefillAt: Date.now()
+      });
+    }
+    return this.buckets.get(chatroomId);
+  }
+  _refill(bucket) {
+    const now = Date.now();
+    const elapsed = now - bucket.lastRefillAt;
+    if (elapsed >= this.config.refillRateMs) {
+      const tokensToAdd = Math.floor(elapsed / this.config.refillRateMs);
+      bucket.tokens = Math.min(this.config.maxTokens, bucket.tokens + tokensToAdd);
+      bucket.lastRefillAt += tokensToAdd * this.config.refillRateMs;
+    }
+  }
+}
+var DEFAULT_CONFIG, LOW_TOKEN_THRESHOLD = 1;
+var init_rate_limiter = __esm(() => {
+  DEFAULT_CONFIG = {
+    maxTokens: 5,
+    refillRateMs: 60000,
+    initialTokens: 5
+  };
+});
+
+// src/infrastructure/services/harness-spawning/harness-spawning-service.ts
+class HarnessSpawningService {
+  rateLimiter;
+  concurrentAgents = new Map;
+  constructor({ rateLimiter }) {
+    this.rateLimiter = rateLimiter;
+  }
+  shouldAllowSpawn(chatroomId, reason) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    if (current >= MAX_CONCURRENT_AGENTS_PER_CHATROOM) {
+      console.warn(`⚠️ [HarnessSpawningService] Concurrent agent limit reached for chatroom ${chatroomId} ` + `(${current}/${MAX_CONCURRENT_AGENTS_PER_CHATROOM} active agents). Spawn rejected.`);
+      return { allowed: false };
+    }
+    const result = this.rateLimiter.tryConsume(chatroomId, reason);
+    if (!result.allowed) {
+      console.warn(`⚠️ [HarnessSpawningService] Spawn blocked by rate limiter for chatroom ${chatroomId} ` + `(reason: ${reason}).`);
+    }
+    return result;
+  }
+  recordSpawn(chatroomId) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    this.concurrentAgents.set(chatroomId, current + 1);
+  }
+  recordExit(chatroomId) {
+    const current = this.concurrentAgents.get(chatroomId) ?? 0;
+    const next = Math.max(0, current - 1);
+    this.concurrentAgents.set(chatroomId, next);
+  }
+  getConcurrentCount(chatroomId) {
+    return this.concurrentAgents.get(chatroomId) ?? 0;
+  }
+}
+var MAX_CONCURRENT_AGENTS_PER_CHATROOM = 10;
+
+// src/infrastructure/services/harness-spawning/index.ts
+var init_harness_spawning = __esm(() => {
+  init_rate_limiter();
+});
+
 // src/commands/machine/pid.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
@@ -14275,7 +14395,8 @@ function createDefaultDeps16() {
     clock: {
       now: () => Date.now(),
       delay: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))
-    }
+    },
+    spawning: new HarnessSpawningService({ rateLimiter: new SpawnRateLimiter })
   };
 }
 function validateAuthentication(convexUrl) {
@@ -14392,7 +14513,9 @@ async function initDaemon() {
     config: config3,
     deps,
     events,
-    agentServices
+    agentServices,
+    activeWorkingDirs: new Set,
+    lastPushedGitState: new Map
   };
   registerEventListeners(ctx);
   logStartup(ctx, availableModels);
@@ -14407,6 +14530,7 @@ var init_init2 = __esm(() => {
   init_machine();
   init_intentional_stops();
   init_remote_agents();
+  init_harness_spawning();
   init_error_formatting();
   init_version();
   init_pid();
@@ -14515,6 +14639,7 @@ async function executeStartAgent(ctx, args) {
   const { pid } = spawnResult;
   const msg = `Agent spawned (PID: ${pid})`;
   console.log(`   ✅ ${msg}`);
+  ctx.deps.spawning.recordSpawn(chatroomId);
   try {
     await ctx.deps.backend.mutation(api.machines.updateSpawnedAgent, {
       sessionId: ctx.sessionId,
@@ -14537,7 +14662,9 @@ async function executeStartAgent(ctx, args) {
     harness: agentHarness,
     model
   });
+  ctx.activeWorkingDirs.add(workingDir);
   spawnResult.onExit(({ code: code2, signal }) => {
+    ctx.deps.spawning.recordExit(chatroomId);
     const pendingReason = ctx.deps.stops.consume(chatroomId, role);
     const stopReason = pendingReason ?? resolveStopReason(code2, signal, false);
     ctx.events.emit("agent:exited", {
@@ -14582,6 +14709,12 @@ async function onRequestStartAgent(ctx, event) {
     console.log(`[daemon] ⏰ Skipping expired agent.requestStart for role=${event.role} (deadline passed)`);
     return;
   }
+  const spawnCheck = ctx.deps.spawning.shouldAllowSpawn(event.chatroomId, event.reason);
+  if (!spawnCheck.allowed) {
+    const retryMsg = spawnCheck.retryAfterMs ? ` Retry after ${spawnCheck.retryAfterMs}ms.` : "";
+    console.warn(`[daemon] ⚠️  Spawn suppressed for chatroom=${event.chatroomId} role=${event.role} reason=${event.reason}.${retryMsg}`);
+    return;
+  }
   await executeStartAgent(ctx, {
     chatroomId: event.chatroomId,
     role: event.role,
@@ -14695,6 +14828,514 @@ function handlePing() {
   return { result: "pong", failed: false };
 }
 
+// src/infrastructure/git/types.ts
+function makeGitStateKey(machineId, workingDir) {
+  return `${machineId}::${workingDir}`;
+}
+var FULL_DIFF_MAX_BYTES = 500000, COMMITS_PER_PAGE = 20;
+
+// src/infrastructure/git/git-reader.ts
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+async function runGit(args, cwd) {
+  try {
+    const result = await execAsync2(`git ${args}`, {
+      cwd,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_PAGER: "cat", NO_COLOR: "1" },
+      maxBuffer: FULL_DIFF_MAX_BYTES + 64 * 1024
+    });
+    return result;
+  } catch (err) {
+    return { error: err };
+  }
+}
+function isGitNotInstalled(message) {
+  return message.includes("command not found") || message.includes("ENOENT") || message.includes("not found") || message.includes("'git' is not recognized");
+}
+function isNotAGitRepo(message) {
+  return message.includes("not a git repository") || message.includes("Not a git repository");
+}
+function isPermissionDenied(message) {
+  return message.includes("Permission denied") || message.includes("EACCES");
+}
+function isEmptyRepo(stderr) {
+  return stderr.includes("does not have any commits yet") || stderr.includes("no commits yet") || stderr.includes("ambiguous argument 'HEAD'") || stderr.includes("unknown revision or path");
+}
+function classifyError(errMessage) {
+  if (isGitNotInstalled(errMessage)) {
+    return { status: "error", message: "git is not installed or not in PATH" };
+  }
+  if (isNotAGitRepo(errMessage)) {
+    return { status: "not_found" };
+  }
+  if (isPermissionDenied(errMessage)) {
+    return { status: "error", message: `Permission denied: ${errMessage}` };
+  }
+  return { status: "error", message: errMessage.trim() };
+}
+async function isGitRepo(workingDir) {
+  const result = await runGit("rev-parse --git-dir", workingDir);
+  if ("error" in result)
+    return false;
+  return result.stdout.trim().length > 0;
+}
+async function getBranch(workingDir) {
+  const result = await runGit("rev-parse --abbrev-ref HEAD", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (errMsg.includes("unknown revision") || errMsg.includes("No such file or directory") || errMsg.includes("does not have any commits")) {
+      return { status: "available", branch: "HEAD" };
+    }
+    return classifyError(errMsg);
+  }
+  const branch = result.stdout.trim();
+  if (!branch) {
+    return { status: "error", message: "git rev-parse returned empty output" };
+  }
+  return { status: "available", branch };
+}
+async function isDirty(workingDir) {
+  const result = await runGit("status --porcelain", workingDir);
+  if ("error" in result)
+    return false;
+  return result.stdout.trim().length > 0;
+}
+function parseDiffStatLine(statLine) {
+  const filesMatch = statLine.match(/(\d+)\s+file/);
+  const insertMatch = statLine.match(/(\d+)\s+insertion/);
+  const deleteMatch = statLine.match(/(\d+)\s+deletion/);
+  return {
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
+    deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0
+  };
+}
+async function getDiffStat(workingDir) {
+  const result = await runGit("diff HEAD --stat", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (isEmptyRepo(result.error.message)) {
+      return { status: "no_commits" };
+    }
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    return classified;
+  }
+  const output = result.stdout;
+  const stderr = result.stderr;
+  if (isEmptyRepo(stderr)) {
+    return { status: "no_commits" };
+  }
+  if (!output.trim()) {
+    return {
+      status: "available",
+      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
+    };
+  }
+  const lines = output.trim().split(`
+`);
+  const summaryLine = lines[lines.length - 1] ?? "";
+  const diffStat = parseDiffStatLine(summaryLine);
+  return { status: "available", diffStat };
+}
+async function getFullDiff(workingDir) {
+  const result = await runGit("diff HEAD", workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    if (isEmptyRepo(errMsg)) {
+      return { status: "no_commits" };
+    }
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    return classified;
+  }
+  const stderr = result.stderr;
+  if (isEmptyRepo(stderr)) {
+    return { status: "no_commits" };
+  }
+  const raw = result.stdout;
+  const byteLength2 = Buffer.byteLength(raw, "utf8");
+  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
+    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
+    return { status: "truncated", content: truncated, truncated: true };
+  }
+  return { status: "available", content: raw, truncated: false };
+}
+async function getRecentCommits(workingDir, count = 20, skip = 0) {
+  const format = "%H%x00%h%x00%s%x00%an%x00%aI";
+  const skipArg = skip > 0 ? ` --skip=${skip}` : "";
+  const result = await runGit(`log -${count}${skipArg} --format=${format}`, workingDir);
+  if ("error" in result) {
+    return [];
+  }
+  const output = result.stdout.trim();
+  if (!output)
+    return [];
+  const commits = [];
+  for (const line of output.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const parts = trimmed.split("\x00");
+    if (parts.length !== 5)
+      continue;
+    const [sha, shortSha, message, author, date] = parts;
+    commits.push({ sha, shortSha, message, author, date });
+  }
+  return commits;
+}
+async function getCommitDetail(workingDir, sha) {
+  const result = await runGit(`show ${sha} --format="" --stat -p`, workingDir);
+  if ("error" in result) {
+    const errMsg = result.error.message;
+    const classified = classifyError(errMsg);
+    if (classified.status === "not_found")
+      return { status: "not_found" };
+    if (isEmptyRepo(errMsg) || errMsg.includes("unknown revision") || errMsg.includes("bad object") || errMsg.includes("does not exist")) {
+      return { status: "not_found" };
+    }
+    return classified;
+  }
+  const raw = result.stdout;
+  const byteLength2 = Buffer.byteLength(raw, "utf8");
+  if (byteLength2 > FULL_DIFF_MAX_BYTES) {
+    const truncated = Buffer.from(raw, "utf8").subarray(0, FULL_DIFF_MAX_BYTES).toString("utf8");
+    return { status: "truncated", content: truncated, truncated: true };
+  }
+  return { status: "available", content: raw, truncated: false };
+}
+async function getCommitMetadata(workingDir, sha) {
+  const format = "%s%x00%an%x00%aI";
+  const result = await runGit(`log -1 --format=${format} ${sha}`, workingDir);
+  if ("error" in result)
+    return null;
+  const output = result.stdout.trim();
+  if (!output)
+    return null;
+  const parts = output.split("\x00");
+  if (parts.length !== 3)
+    return null;
+  return { message: parts[0], author: parts[1], date: parts[2] };
+}
+var execAsync2;
+var init_git_reader = __esm(() => {
+  execAsync2 = promisify2(exec2);
+});
+
+// src/commands/machine/daemon-start/git-polling.ts
+function startGitPollingLoop(ctx) {
+  const timer = setInterval(() => {
+    runPollingTick(ctx).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️  Git polling tick failed: ${err.message}`);
+    });
+  }, GIT_POLLING_INTERVAL_MS);
+  timer.unref();
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git polling loop started (interval: ${GIT_POLLING_INTERVAL_MS}ms)`);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git polling loop stopped`);
+    }
+  };
+}
+function extractDiffStatFromShowOutput(content) {
+  for (const line of content.split(`
+`)) {
+    if (/\d+\s+file.*changed/.test(line)) {
+      return parseDiffStatLine(line);
+    }
+  }
+  return { filesChanged: 0, insertions: 0, deletions: 0 };
+}
+async function processFullDiff(ctx, req) {
+  const result = await getFullDiff(req.workingDir);
+  if (result.status === "available" || result.status === "truncated") {
+    const diffStatResult = await getDiffStat(req.workingDir);
+    const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      diffContent: result.content,
+      truncated: result.truncated,
+      diffStat
+    });
+    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed: ${req.workingDir} (${diffStat.filesChanged} files, ${result.truncated ? "truncated" : "complete"})`);
+  } else {
+    await ctx.deps.backend.mutation(api.workspaces.upsertFullDiff, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      diffContent: "",
+      truncated: false,
+      diffStat: { filesChanged: 0, insertions: 0, deletions: 0 }
+    });
+    console.log(`[${formatTimestamp()}] \uD83D\uDCC4 Full diff pushed (empty): ${req.workingDir} (${result.status})`);
+  }
+}
+async function processCommitDetail(ctx, req) {
+  if (!req.sha) {
+    throw new Error("commit_detail request missing sha");
+  }
+  const [result, metadata] = await Promise.all([
+    getCommitDetail(req.workingDir, req.sha),
+    getCommitMetadata(req.workingDir, req.sha)
+  ]);
+  if (result.status === "not_found") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      sha: req.sha,
+      status: "not_found",
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
+    return;
+  }
+  if (result.status === "error") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir: req.workingDir,
+      sha: req.sha,
+      status: "error",
+      errorMessage: result.message,
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
+    return;
+  }
+  const diffStat = extractDiffStatFromShowOutput(result.content);
+  await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    sha: req.sha,
+    status: "available",
+    diffContent: result.content,
+    truncated: result.truncated,
+    message: metadata?.message,
+    author: metadata?.author,
+    date: metadata?.date,
+    diffStat
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Commit detail pushed: ${req.sha.slice(0, 7)} in ${req.workingDir}`);
+}
+async function processMoreCommits(ctx, req) {
+  const offset = req.offset ?? 0;
+  const commits = await getRecentCommits(req.workingDir, COMMITS_PER_PAGE, offset);
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  await ctx.deps.backend.mutation(api.workspaces.appendMoreCommits, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    commits,
+    hasMoreCommits
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC More commits appended: ${req.workingDir} (+${commits.length} commits, offset=${offset})`);
+}
+async function runPollingTick(ctx) {
+  const requests = await ctx.deps.backend.query(api.workspaces.getPendingRequests, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  });
+  if (requests.length === 0)
+    return;
+  for (const req of requests) {
+    try {
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "processing"
+      });
+      switch (req.requestType) {
+        case "full_diff":
+          await processFullDiff(ctx, req);
+          break;
+        case "commit_detail":
+          await processCommitDetail(ctx, req);
+          break;
+        case "more_commits":
+          await processMoreCommits(ctx, req);
+          break;
+      }
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "done"
+      });
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Failed to process ${req.requestType} request: ${err.message}`);
+      await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
+        sessionId: ctx.sessionId,
+        requestId: req._id,
+        status: "error"
+      }).catch(() => {});
+    }
+  }
+}
+var GIT_POLLING_INTERVAL_MS = 5000;
+var init_git_polling = __esm(() => {
+  init_api3();
+  init_git_reader();
+});
+
+// src/commands/machine/daemon-start/git-heartbeat.ts
+import { createHash as createHash2 } from "node:crypto";
+async function pushGitState(ctx) {
+  if (ctx.activeWorkingDirs.size === 0)
+    return;
+  for (const workingDir of ctx.activeWorkingDirs) {
+    try {
+      await pushSingleWorkspaceGitState(ctx, workingDir);
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed for ${workingDir}: ${err.message}`);
+    }
+  }
+}
+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)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      status: "not_found"
+    });
+    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    return;
+  }
+  const [branchResult, dirtyResult, diffStatResult, commits] = await Promise.all([
+    getBranch(workingDir),
+    isDirty(workingDir),
+    getDiffStat(workingDir),
+    getRecentCommits(workingDir, COMMITS_PER_PAGE)
+  ]);
+  if (branchResult.status === "error") {
+    const stateHash2 = `error:${branchResult.message}`;
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+      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, stateHash2);
+    return;
+  }
+  if (branchResult.status === "not_found") {
+    return;
+  }
+  const branch = branchResult.branch;
+  const isDirty2 = dirtyResult;
+  const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  const stateHash = createHash2("md5").update(JSON.stringify({ branch, isDirty: isDirty2, diffStat, shas: commits.map((c) => c.sha) })).digest("hex");
+  if (ctx.lastPushedGitState.get(stateKey) === stateHash) {
+    return;
+  }
+  await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "available",
+    branch,
+    isDirty: isDirty2,
+    diffStat,
+    recentCommits: commits,
+    hasMoreCommits
+  });
+  ctx.lastPushedGitState.set(stateKey, stateHash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${isDirty2 ? ", dirty" : ", clean"})`);
+  prefetchMissingCommitDetails(ctx, workingDir, commits).catch((err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️  Commit pre-fetch failed for ${workingDir}: ${err.message}`);
+  });
+}
+async function prefetchMissingCommitDetails(ctx, workingDir, commits) {
+  if (commits.length === 0)
+    return;
+  const shas = commits.map((c) => c.sha);
+  const missingShas = await ctx.deps.backend.query(api.workspaces.getMissingCommitShas, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    shas
+  });
+  if (missingShas.length === 0)
+    return;
+  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Pre-fetching ${missingShas.length} commit(s) for ${workingDir}`);
+  for (const sha of missingShas) {
+    try {
+      await prefetchSingleCommit(ctx, workingDir, sha, commits);
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️  Pre-fetch failed for ${sha.slice(0, 7)}: ${err.message}`);
+    }
+  }
+}
+async function prefetchSingleCommit(ctx, workingDir, sha, commits) {
+  const metadata = commits.find((c) => c.sha === sha);
+  const result = await getCommitDetail(workingDir, sha);
+  if (result.status === "not_found") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      sha,
+      status: "not_found",
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
+    return;
+  }
+  if (result.status === "error") {
+    await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      sha,
+      status: "error",
+      errorMessage: result.message,
+      message: metadata?.message,
+      author: metadata?.author,
+      date: metadata?.date
+    });
+    return;
+  }
+  const diffStat = extractDiffStatFromShowOutput(result.content);
+  await ctx.deps.backend.mutation(api.workspaces.upsertCommitDetail, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    sha,
+    status: "available",
+    diffContent: result.content,
+    truncated: result.truncated,
+    message: metadata?.message,
+    author: metadata?.author,
+    date: metadata?.date,
+    diffStat
+  });
+  console.log(`[${formatTimestamp()}] ✅ Pre-fetched: ${sha.slice(0, 7)} in ${workingDir}`);
+}
+var init_git_heartbeat = __esm(() => {
+  init_api3();
+  init_git_reader();
+  init_git_polling();
+});
+
 // src/commands/machine/daemon-start/command-loop.ts
 async function refreshModels(ctx) {
   if (!ctx.config)
@@ -14717,7 +15358,7 @@ async function refreshModels(ctx) {
     console.warn(`[${formatTimestamp()}] ⚠️  Model refresh failed: ${error.message}`);
   }
 }
-function evictStaleDedupEntries(processedCommandIds, processedPingIds) {
+function evictStaleDedupEntries(processedCommandIds, processedPingIds, processedGitRefreshIds) {
   const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
   for (const [id, ts] of processedCommandIds) {
     if (ts < evictBefore)
@@ -14727,8 +15368,12 @@ function evictStaleDedupEntries(processedCommandIds, processedPingIds) {
     if (ts < evictBefore)
       processedPingIds.delete(id);
   }
+  for (const [id, ts] of processedGitRefreshIds) {
+    if (ts < evictBefore)
+      processedGitRefreshIds.delete(id);
+  }
 }
-async function dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds) {
+async function dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds, processedGitRefreshIds) {
   const eventId = event._id.toString();
   if (event.type === "agent.requestStart") {
     if (processedCommandIds.has(eventId))
@@ -14750,6 +15395,14 @@ async function dispatchCommandEvent(ctx, event, processedCommandIds, processedPi
       machineId: ctx.machineId,
       pingEventId: event._id
     });
+  } else if (event.type === "daemon.gitRefresh") {
+    if (processedGitRefreshIds.has(eventId))
+      return;
+    processedGitRefreshIds.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);
   }
 }
 async function startCommandLoop(ctx) {
@@ -14761,15 +15414,21 @@ 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: ${err.message}`);
+      });
     }).catch((err) => {
       console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${err.message}`);
     });
   }, DAEMON_HEARTBEAT_INTERVAL_MS);
   heartbeatTimer.unref();
+  const gitPollingHandle = startGitPollingLoop(ctx);
+  pushGitState(ctx).catch(() => {});
   const shutdown = async () => {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
     clearInterval(heartbeatTimer);
+    gitPollingHandle.stop();
     await onDaemonShutdown(ctx);
     releaseLock();
     process.exit(0);
@@ -14784,17 +15443,18 @@ Listening for commands...`);
 `);
   const processedCommandIds = new Map;
   const processedPingIds = new Map;
+  const processedGitRefreshIds = new Map;
   wsClient2.onUpdate(api.machines.getCommandEvents, {
     sessionId: ctx.sessionId,
     machineId: ctx.machineId
   }, async (result) => {
     if (!result.events || result.events.length === 0)
       return;
-    evictStaleDedupEntries(processedCommandIds, processedPingIds);
+    evictStaleDedupEntries(processedCommandIds, processedPingIds, processedGitRefreshIds);
     for (const event of result.events) {
       try {
         console.log(`[${formatTimestamp()}] \uD83D\uDCE1 Stream command event: ${event.type}`);
-        await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds);
+        await dispatchCommandEvent(ctx, event, processedCommandIds, processedPingIds, processedGitRefreshIds);
       } catch (err) {
         console.error(`[${formatTimestamp()}] ❌ Stream command event failed: ${err.message}`);
       }
@@ -14818,6 +15478,8 @@ var init_command_loop = __esm(() => {
   init_on_request_start_agent();
   init_on_request_stop_agent();
   init_pid();
+  init_git_polling();
+  init_git_heartbeat();
   MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatroom-cli",
-  "version": "1.6.5",
+  "version": "1.7.1",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {