chatroom-cli 1.51.0 → 1.53.1

package/dist/index.js

@@ -26010,7 +26010,7 @@ class BaseCLIAgentService {
     }
     return null;
   }
-  async stop(pid) {
+  async stop(pid, _options) {
     try {
       this.deps.kill(-pid, "SIGTERM");
     } catch {
@@ -26172,6 +26172,7 @@ class PiRpcReader {
   toolCallCallbacks = [];
   toolResultCallbacks = [];
   anyEventCallbacks = [];
+  stateResponseCallbacks = [];
   constructor(stream) {
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
     rl.on("line", (line) => this._handleLine(line));
@@ -26194,6 +26195,9 @@ class PiRpcReader {
   onAnyEvent(cb) {
     this.anyEventCallbacks.push(cb);
   }
+  onStateResponse(cb) {
+    this.stateResponseCallbacks.push(cb);
+  }
   _handleLine(line) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -26207,6 +26211,15 @@ class PiRpcReader {
     for (const cb of this.anyEventCallbacks)
       cb();
     const type = event["type"];
+    if (type === "response" && event["command"] === "get_state") {
+      const data = event["data"];
+      const sessionId = data?.["sessionId"];
+      if (event["success"] === true && typeof sessionId === "string") {
+        for (const cb of this.stateResponseCallbacks)
+          cb(sessionId);
+      }
+      return;
+    }
     if (type === "message_update") {
       const assistantMessageEvent = event["assistantMessageEvent"];
       if (assistantMessageEvent?.["type"] === "text_delta") {
@@ -26252,7 +26265,11 @@ class PiRpcReader {
 var init_pi_rpc_reader = () => {};
 
 // src/infrastructure/services/remote-agents/pi/pi-agent-service.ts
-var PI_COMMAND = "pi", PiAgentService;
+import { join as join6 } from "node:path";
+function getPiSessionDir(workingDir) {
+  return join6(workingDir, ".chatroom", "pi-sessions");
+}
+var PI_COMMAND = "pi", PI_AGENT_NAME = "pi", GET_STATE_TIMEOUT_MS = 5000, SPAWN_READY_DELAY_MS = 500, PiAgentService;
 var init_pi_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_pi_rpc_reader();
@@ -26261,23 +26278,50 @@ var init_pi_agent_service = __esm(() => {
     displayName = "Pi";
     command = PI_COMMAND;
     childProcesses = new Map;
+    trackedSessions = new Map;
     constructor(deps) {
       super(deps);
     }
     untrack(pid) {
       this.childProcesses.delete(pid);
+      this.trackedSessions.delete(pid);
       super.untrack(pid);
     }
+    getHarnessReconnectContext(pid) {
+      const session = this.trackedSessions.get(pid);
+      if (!session) {
+        return;
+      }
+      return {
+        agentName: PI_AGENT_NAME,
+        ...session.model ? { model: session.model } : {}
+      };
+    }
+    async resumeFromDaemonMemory(options, stored) {
+      const { prompt, systemPrompt, model, context: context4 } = options;
+      const modelForSession = model ?? stored.model;
+      const childProcess = this.spawnPiRpcProcess({
+        workingDir: stored.workingDir,
+        systemPrompt,
+        model: modelForSession,
+        sessionId: stored.harnessSessionId
+      });
+      await this.waitForSpawnReady(childProcess);
+      await this.writePrompt(childProcess, prompt);
+      return this.wireRpcProcess({
+        childProcess,
+        context: context4,
+        workingDir: stored.workingDir,
+        model: modelForSession,
+        harnessSessionId: stored.harnessSessionId
+      });
+    }
     async resumeTurn(pid, prompt) {
       const child = this.childProcesses.get(pid);
-      if (!child?.stdin) {
+      if (!child) {
         throw new Error(`No tracked pi process or stdin for pid=${pid}`);
       }
-      const message = JSON.stringify({ type: "prompt", message: prompt }) + `
-`;
-      await new Promise((resolve, reject) => {
-        child.stdin.write(message, (err) => err ? reject(err) : resolve());
-      });
+      await this.writePrompt(child, prompt);
     }
     async isInstalled() {
       return this.checkInstalled(PI_COMMAND);
@@ -26307,16 +26351,46 @@ var init_pi_agent_service = __esm(() => {
       return models;
     }
     async spawn(options) {
-      const { prompt, systemPrompt, model } = options;
-      const args2 = ["--mode", "rpc", "--no-session"];
-      if (model) {
-        args2.push("--model", model);
+      const { prompt, systemPrompt, model, context: context4, workingDir } = options;
+      const childProcess = this.spawnPiRpcProcess({
+        workingDir,
+        systemPrompt,
+        model
+      });
+      await this.waitForSpawnReady(childProcess);
+      if (!childProcess.stdout) {
+        throw new Error("Pi RPC process has no stdout");
+      }
+      const reader = new PiRpcReader(childProcess.stdout);
+      const harnessSessionId = await this.querySessionId(reader, childProcess.stdin);
+      await this.writePrompt(childProcess, prompt);
+      return this.wireRpcProcess({
+        childProcess,
+        context: context4,
+        workingDir,
+        model,
+        harnessSessionId,
+        reader
+      });
+    }
+    spawnPiRpcProcess(args2) {
+      const rpcArgs = [
+        "--mode",
+        "rpc",
+        "--session-dir",
+        getPiSessionDir(args2.workingDir)
+      ];
+      if (args2.sessionId) {
+        rpcArgs.push("--session", args2.sessionId);
       }
-      if (systemPrompt) {
-        args2.push("--system-prompt", systemPrompt);
+      if (args2.model) {
+        rpcArgs.push("--model", args2.model);
       }
-      const childProcess = this.deps.spawn(PI_COMMAND, args2, {
-        cwd: options.workingDir,
+      if (args2.systemPrompt) {
+        rpcArgs.push("--system-prompt", args2.systemPrompt);
+      }
+      const childProcess = this.deps.spawn(PI_COMMAND, rpcArgs, {
+        cwd: args2.workingDir,
         stdio: ["pipe", "pipe", "pipe"],
         shell: false,
         detached: true,
@@ -26326,117 +26400,160 @@ var init_pi_agent_service = __esm(() => {
           GIT_SEQUENCE_EDITOR: "true"
         }
       });
-      childProcess.stdin?.write(JSON.stringify({ type: "prompt", message: prompt }) + `
-`);
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      return childProcess;
+    }
+    async waitForSpawnReady(childProcess) {
+      await new Promise((resolve) => setTimeout(resolve, SPAWN_READY_DELAY_MS));
       if (childProcess.killed || childProcess.exitCode !== null) {
         throw new Error(`Agent process exited immediately (exit code: ${childProcess.exitCode})`);
       }
       if (!childProcess.pid) {
         throw new Error("Agent process started but has no PID");
       }
+    }
+    writePrompt(child, prompt) {
+      return new Promise((resolve, reject) => {
+        if (!child.stdin) {
+          reject(new Error("Pi RPC process has no stdin"));
+          return;
+        }
+        const message = JSON.stringify({ type: "prompt", message: prompt }) + `
+`;
+        child.stdin.write(message, (err) => err ? reject(err) : resolve());
+      });
+    }
+    async querySessionId(reader, stdin) {
+      if (!stdin) {
+        throw new Error("Pi RPC process has no stdin");
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error(`get_state timed out after ${GET_STATE_TIMEOUT_MS}ms`));
+        }, GET_STATE_TIMEOUT_MS);
+        reader.onStateResponse((sessionId) => {
+          clearTimeout(timer);
+          resolve(sessionId);
+        });
+        stdin.write(JSON.stringify({ type: "get_state" }) + `
+`);
+      });
+    }
+    wireRpcProcess(args2) {
+      const { childProcess, context: context4, workingDir, model, harnessSessionId } = args2;
       const pid = childProcess.pid;
-      const context4 = options.context;
       this.childProcesses.set(pid, childProcess);
+      this.trackedSessions.set(pid, { harnessSessionId, workingDir, model });
       const entry = this.registerProcess(pid, context4);
       const roleTag = context4.role ?? "unknown";
       const chatroomSuffix = context4.chatroomId ? `@${context4.chatroomId.slice(-6)}` : "";
       const logPrefix = `[pi:${roleTag}${chatroomSuffix}`;
       const outputCallbacks = [];
-      if (childProcess.stdout) {
-        const reader = new PiRpcReader(childProcess.stdout);
-        let textBuffer = "";
-        let thinkingBuffer = "";
-        const flushText = () => {
-          if (!textBuffer)
-            return;
-          for (const line of textBuffer.split(`
+      const agentEndCallbacks = [];
+      const onExit4 = (cb) => {
+        childProcess.on("exit", (code2, signal) => {
+          this.childProcesses.delete(pid);
+          this.trackedSessions.delete(pid);
+          this.deleteProcess(pid);
+          cb({ code: code2, signal, context: context4 });
+        });
+      };
+      const onOutput = (cb) => {
+        outputCallbacks.push(cb);
+      };
+      const onAgentEnd = (cb) => {
+        agentEndCallbacks.push(cb);
+      };
+      const baseResult = {
+        pid,
+        harnessSessionId,
+        harnessReconnect: {
+          agentName: PI_AGENT_NAME,
+          ...model ? { model } : {}
+        },
+        onExit: onExit4,
+        onOutput
+      };
+      if (!childProcess.stdout) {
+        if (childProcess.stderr) {
+          childProcess.stderr.pipe(process.stderr, { end: false });
+          childProcess.stderr.on("data", () => {
+            entry.lastOutputAt = Date.now();
+            for (const cb of outputCallbacks)
+              cb();
+          });
+        }
+        return baseResult;
+      }
+      const reader = args2.reader ?? new PiRpcReader(childProcess.stdout);
+      let textBuffer = "";
+      let thinkingBuffer = "";
+      const flushText = () => {
+        if (!textBuffer)
+          return;
+        for (const line of textBuffer.split(`
 `)) {
-            if (line)
-              process.stdout.write(`${logPrefix} text] ${line}
+          if (line)
+            process.stdout.write(`${logPrefix} text] ${line}
 `);
-          }
-          textBuffer = "";
-        };
-        const flushThinking = () => {
-          if (!thinkingBuffer)
-            return;
-          for (const line of thinkingBuffer.split(`
+        }
+        textBuffer = "";
+      };
+      const flushThinking = () => {
+        if (!thinkingBuffer)
+          return;
+        for (const line of thinkingBuffer.split(`
 `)) {
-            if (line)
-              process.stdout.write(`${logPrefix} thinking] ${line}
+          if (line)
+            process.stdout.write(`${logPrefix} thinking] ${line}
 `);
-          }
-          thinkingBuffer = "";
-        };
-        reader.onTextDelta((delta) => {
-          flushThinking();
-          textBuffer += delta;
-          if (textBuffer.includes(`
+        }
+        thinkingBuffer = "";
+      };
+      reader.onTextDelta((delta) => {
+        flushThinking();
+        textBuffer += delta;
+        if (textBuffer.includes(`
 `))
-            flushText();
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
-        reader.onThinkingDelta((delta) => {
           flushText();
-          thinkingBuffer += delta;
-          if (thinkingBuffer.includes(`
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+      });
+      reader.onThinkingDelta((delta) => {
+        flushText();
+        thinkingBuffer += delta;
+        if (thinkingBuffer.includes(`
 `))
-            flushThinking();
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
-        reader.onAnyEvent(() => {
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
-        reader.onAgentEnd(() => {
-          flushText();
           flushThinking();
-          process.stdout.write(`${logPrefix} agent_end]
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+      });
+      reader.onAnyEvent(() => {
+        entry.lastOutputAt = Date.now();
+        for (const cb of outputCallbacks)
+          cb();
+      });
+      reader.onAgentEnd(() => {
+        flushText();
+        flushThinking();
+        process.stdout.write(`${logPrefix} agent_end]
 `);
-        });
-        reader.onToolCall((name, args3) => {
-          flushText();
-          flushThinking();
-          const argsStr = args3 != null ? ` args: ${JSON.stringify(args3)}` : "";
-          process.stdout.write(`${logPrefix} tool: ${name}${argsStr}]
+        for (const cb of agentEndCallbacks)
+          cb();
+      });
+      reader.onToolCall((name, toolArgs) => {
+        flushText();
+        flushThinking();
+        const argsStr = toolArgs != null ? ` args: ${JSON.stringify(toolArgs)}` : "";
+        process.stdout.write(`${logPrefix} tool: ${name}${argsStr}]
 `);
-        });
-        reader.onToolResult((name, result) => {
-          const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-          process.stdout.write(`${logPrefix} tool_result: ${name} result: ${resultStr}]
+      });
+      reader.onToolResult((name, result) => {
+        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+        process.stdout.write(`${logPrefix} tool_result: ${name} result: ${resultStr}]
 `);
-        });
-        if (childProcess.stderr) {
-          childProcess.stderr.pipe(process.stderr, { end: false });
-          childProcess.stderr.on("data", () => {
-            entry.lastOutputAt = Date.now();
-            for (const cb of outputCallbacks)
-              cb();
-          });
-        }
-        return {
-          pid,
-          onExit: (cb) => {
-            childProcess.on("exit", (code2, signal) => {
-              this.childProcesses.delete(pid);
-              this.deleteProcess(pid);
-              cb({ code: code2, signal, context: context4 });
-            });
-          },
-          onOutput: (cb) => {
-            outputCallbacks.push(cb);
-          },
-          onAgentEnd: (cb) => {
-            reader.onAgentEnd(cb);
-          }
-        };
-      }
+      });
       if (childProcess.stderr) {
         childProcess.stderr.pipe(process.stderr, { end: false });
         childProcess.stderr.on("data", () => {
@@ -26446,17 +26563,8 @@ var init_pi_agent_service = __esm(() => {
         });
       }
       return {
-        pid,
-        onExit: (cb) => {
-          childProcess.on("exit", (code2, signal) => {
-            this.childProcesses.delete(pid);
-            this.deleteProcess(pid);
-            cb({ code: code2, signal, context: context4 });
-          });
-        },
-        onOutput: (cb) => {
-          outputCallbacks.push(cb);
-        }
+        ...baseResult,
+        onAgentEnd
       };
     }
   };
@@ -27556,7 +27664,7 @@ class CursorSdkStreamAdapter {
 
 // src/infrastructure/services/remote-agents/cursor-sdk/cursor-sdk-agent-service.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { createRequire as createRequire3 } from "node:module";
 import { randomUUID } from "node:crypto";
 async function loadSdk() {
@@ -27577,7 +27685,7 @@ function getSdkPackageVersion() {
     return cachedSdkPackageVersion;
   const require3 = createRequire3(import.meta.url);
   const entry = require3.resolve("@cursor/sdk");
-  const packageJsonPath = join6(entry, "..", "..", "..", "package.json");
+  const packageJsonPath = join7(entry, "..", "..", "..", "package.json");
   const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
   cachedSdkPackageVersion = pkg.version;
   return pkg.version;
@@ -27596,6 +27704,9 @@ async function withTimeout(p, ms, label) {
       clearTimeout(timer);
   }
 }
+function buildAgentName(context4) {
+  return `${context4.role}@${context4.chatroomId.slice(-6)}`;
+}
 function waitForResumeOrAbort(session) {
   if (session.aborted)
     return Promise.resolve(null);
@@ -27690,10 +27801,13 @@ var init_cursor_sdk_agent_service = __esm(() => {
       session.abortResolve = undefined;
       resolve(prompt);
     }
-    async stop(pid) {
+    async stop(pid, options) {
       const session = this.sessions.get(pid);
       if (session) {
         session.aborted = true;
+        if (options?.preserveForResume) {
+          session.preserveForResume = true;
+        }
         session.abortResolve?.();
         const run3 = session.run;
         if (run3?.supports("cancel")) {
@@ -27703,7 +27817,7 @@ var init_cursor_sdk_agent_service = __esm(() => {
             console.warn(`[cursor-sdk] run.cancel for pid=${pid} failed:`, err instanceof Error ? err.message : err);
           }
         }
-        if (!session.agentClosed) {
+        if (!session.preserveForResume && !session.agentClosed) {
           try {
             session.agent.close();
             session.agentClosed = true;
@@ -27713,52 +27827,85 @@ var init_cursor_sdk_agent_service = __esm(() => {
       }
       await super.stop(pid);
     }
-    async spawn(options) {
+    getHarnessReconnectContext(pid) {
+      const session = this.sessions.get(pid);
+      if (!session) {
+        return;
+      }
+      return {
+        agentName: session.agentName,
+        ...session.model ? { model: session.model } : {}
+      };
+    }
+    async resumeFromDaemonMemory(options, stored) {
       const apiKey = process.env.CURSOR_API_KEY?.trim();
       if (!apiKey) {
         throw new Error("CURSOR_API_KEY is not set");
       }
-      const keeper = this.deps.spawn(process.execPath, ["-e", "setInterval(()=>{},2147483647)"], {
-        cwd: options.workingDir,
-        stdio: "ignore",
-        shell: false,
-        detached: true
-      });
-      if (!keeper.pid) {
-        keeper.kill();
-        throw new Error("Failed to spawn cursor-sdk keeper process");
-      }
+      const keeper = this.spawnKeeper(options.workingDir);
       const pid = keeper.pid;
       const context4 = options.context;
-      const entry = this.registerProcess(pid, context4);
-      const logPrefix = buildLogPrefix(context4);
+      const agentName = stored.agentName;
+      const modelId = resolveModelId(options.model ?? stored.model);
       const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
 
 ${options.prompt}` : options.prompt;
-      const exitCallbacks = [];
-      const outputCallbacks = [];
-      const agentEndCallbacks = [];
       let agent;
       try {
         const { Agent } = await loadSdk();
-        agent = await withTimeout(Agent.create({
+        agent = await withTimeout(Agent.resume(stored.harnessSessionId, {
           apiKey,
-          name: `${context4.role}@${context4.chatroomId.slice(-6)}`,
-          model: { id: resolveModelId(options.model) },
-          local: { cwd: options.workingDir, settingSources: [] }
-        }), AGENT_CREATE_TIMEOUT_MS, "Agent.create");
+          model: { id: modelId },
+          local: { cwd: stored.workingDir, settingSources: [] }
+        }), AGENT_CREATE_TIMEOUT_MS, "Agent.resume");
       } catch (err) {
         keeper.kill();
         this.deleteProcess(pid);
         throw err;
       }
+      return this.startRunningSession({
+        pid,
+        keeper,
+        agent,
+        context: context4,
+        agentName,
+        model: options.model ?? stored.model,
+        workingDir: stored.workingDir,
+        initialPrompt: fullPrompt,
+        forceFirstTurn: true
+      });
+    }
+    spawnKeeper(workingDir) {
+      const keeper = this.deps.spawn(process.execPath, ["-e", "setInterval(()=>{},2147483647)"], {
+        cwd: workingDir,
+        stdio: "ignore",
+        shell: false,
+        detached: true
+      });
+      if (!keeper.pid) {
+        keeper.kill();
+        throw new Error("Failed to spawn cursor-sdk keeper process");
+      }
+      return keeper;
+    }
+    startRunningSession(args2) {
+      const { pid, keeper, agent, context: context4, agentName, model, workingDir, initialPrompt, forceFirstTurn } = args2;
+      const entry = this.registerProcess(pid, context4);
+      const logPrefix = buildLogPrefix(context4);
       const session = {
         agent,
         keeper,
         aborted: false,
-        agentClosed: false
+        agentClosed: false,
+        preserveForResume: false,
+        agentName,
+        model,
+        workingDir
       };
       this.sessions.set(pid, session);
+      const exitCallbacks = [];
+      const outputCallbacks = [];
+      const agentEndCallbacks = [];
       const finishExit = (code2, signal) => {
         this.sessions.delete(pid);
         this.deleteProcess(pid);
@@ -27766,11 +27913,54 @@ ${options.prompt}` : options.prompt;
           cb({ code: code2, signal, context: context4 });
         }
       };
+      this.runTurnLoop({
+        pid,
+        agent,
+        session,
+        context: context4,
+        entry,
+        logPrefix,
+        initialPrompt,
+        forceFirstTurn,
+        finishExit,
+        outputCallbacks,
+        agentEndCallbacks
+      });
+      return {
+        pid,
+        harnessSessionId: agent.agentId,
+        harnessReconnect: {
+          agentName,
+          ...model ? { model } : {}
+        },
+        onExit: (cb) => {
+          exitCallbacks.push(cb);
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          agentEndCallbacks.push(cb);
+        }
+      };
+    }
+    runTurnLoop(args2) {
+      const {
+        agent,
+        session,
+        logPrefix,
+        initialPrompt,
+        forceFirstTurn,
+        finishExit,
+        entry,
+        outputCallbacks,
+        agentEndCallbacks
+      } = args2;
       (async () => {
         let exitCode = 0;
         let exitSignal = null;
-        let nextPrompt = fullPrompt;
-        let isFirstTurn = true;
+        let nextPrompt = initialPrompt;
+        let isFirstTurn = forceFirstTurn;
         try {
           while (!session.aborted) {
             const run3 = await withTimeout(agent.send(nextPrompt, {
@@ -27807,8 +27997,9 @@ ${options.prompt}` : options.prompt;
 `);
               break;
             }
+            const resumePromise = waitForResumeOrAbort(session);
             adapter.finish();
-            const resumePrompt = await waitForResumeOrAbort(session);
+            const resumePrompt = await resumePromise;
             if (resumePrompt === null || session.aborted) {
               if (session.aborted) {
                 exitCode = 1;
@@ -27824,30 +28015,57 @@ ${options.prompt}` : options.prompt;
           process.stderr.write(`${logPrefix} spawn-error] ${reason}
 `);
         } finally {
-          if (!session.agentClosed) {
+          if (!session.agentClosed && !session.preserveForResume) {
             try {
               agent.close();
               session.agentClosed = true;
             } catch {}
           }
           try {
-            keeper.kill();
+            session.keeper.kill();
           } catch {}
           finishExit(exitCode, exitSignal);
         }
       })();
-      return {
+    }
+    async spawn(options) {
+      const apiKey = process.env.CURSOR_API_KEY?.trim();
+      if (!apiKey) {
+        throw new Error("CURSOR_API_KEY is not set");
+      }
+      const keeper = this.spawnKeeper(options.workingDir);
+      const pid = keeper.pid;
+      const context4 = options.context;
+      const agentName = buildAgentName(context4);
+      const modelId = resolveModelId(options.model);
+      const fullPrompt = options.systemPrompt ? `${options.systemPrompt}
+
+${options.prompt}` : options.prompt;
+      let agent;
+      try {
+        const { Agent } = await loadSdk();
+        agent = await withTimeout(Agent.create({
+          apiKey,
+          name: agentName,
+          model: { id: modelId },
+          local: { cwd: options.workingDir, settingSources: [] }
+        }), AGENT_CREATE_TIMEOUT_MS, "Agent.create");
+      } catch (err) {
+        keeper.kill();
+        this.deleteProcess(pid);
+        throw err;
+      }
+      return this.startRunningSession({
         pid,
-        onExit: (cb) => {
-          exitCallbacks.push(cb);
-        },
-        onOutput: (cb) => {
-          outputCallbacks.push(cb);
-        },
-        onAgentEnd: (cb) => {
-          agentEndCallbacks.push(cb);
-        }
-      };
+        keeper,
+        agent,
+        context: context4,
+        agentName,
+        model: options.model,
+        workingDir: options.workingDir,
+        initialPrompt: fullPrompt,
+        forceFirstTurn: true
+      });
     }
   };
 });
@@ -30038,12 +30256,12 @@ function startSessionEventForwarder(client4, options) {
 // src/infrastructure/services/remote-agents/opencode-sdk/session-metadata-store.ts
 import { existsSync, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join7 } from "node:path";
+import { dirname as dirname2, join as join8 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
   constructor(filePath) {
-    this.filePath = filePath ?? join7(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
+    this.filePath = filePath ?? join8(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
   }
   load() {
     try {
@@ -30097,7 +30315,7 @@ async function withTimeout2(p, ms, label) {
       clearTimeout(timer);
   }
 }
-var OPENCODE_COMMAND2 = "opencode", SERVE_STARTUP_TIMEOUT_MS = 1e4, SESSION_CREATE_TIMEOUT_MS = 30000, PROMPT_ASYNC_TIMEOUT_MS = 60000, SESSION_ABORT_TIMEOUT_MS = 5000, AGENTS_LIST_TIMEOUT_MS = 1e4, OpenCodeSdkAgentService;
+var OPENCODE_COMMAND2 = "opencode", SERVE_STARTUP_TIMEOUT_MS = 1e4, SESSION_CREATE_TIMEOUT_MS = 30000, PROMPT_ASYNC_TIMEOUT_MS = 60000, SESSION_ABORT_TIMEOUT_MS = 5000, SESSION_GET_TIMEOUT_MS = 1e4, AGENTS_LIST_TIMEOUT_MS = 1e4, OpenCodeSdkAgentService;
 var init_opencode_sdk_agent_service = __esm(() => {
   init_dist();
   init_base_cli_agent_service();
@@ -30126,28 +30344,30 @@ var init_opencode_sdk_agent_service = __esm(() => {
       return output.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
     }
-    async stop(pid) {
+    async stop(pid, options) {
       const forwarder = this.forwarders.get(pid);
       if (forwarder) {
         forwarder.stop();
         this.forwarders.delete(pid);
       }
+      const preserveForResume = options?.preserveForResume === true;
       const meta = this.sessionStore.findByPid(pid);
       if (meta) {
-        try {
-          const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
-          await withTimeout2(client4.session.abort({ path: { id: meta.sessionId } }), SESSION_ABORT_TIMEOUT_MS, "session.abort");
-        } catch (err) {
-          console.warn(`[opencode-sdk] session.abort for pid=${pid} sessionId=${meta.sessionId} failed (continuing with SIGTERM):`, err instanceof Error ? err.message : err);
+        if (!preserveForResume) {
+          try {
+            const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
+            await withTimeout2(client4.session.abort({ path: { id: meta.sessionId } }), SESSION_ABORT_TIMEOUT_MS, "session.abort");
+          } catch (err) {
+            console.warn(`[opencode-sdk] session.abort for pid=${pid} sessionId=${meta.sessionId} failed (continuing with SIGTERM):`, err instanceof Error ? err.message : err);
+          }
         }
         this.sessionStore.remove(meta.sessionId);
       }
       await super.stop(pid);
     }
-    async spawn(options) {
-      const { prompt, systemPrompt, model, context: context4 } = options;
+    spawnServeProcess(workingDir) {
       const childProcess = this.deps.spawn(OPENCODE_COMMAND2, ["serve", "--print-logs"], {
-        cwd: options.workingDir,
+        cwd: workingDir,
         stdio: ["pipe", "pipe", "pipe"],
         shell: false,
         detached: true,
@@ -30160,6 +30380,146 @@ var init_opencode_sdk_agent_service = __esm(() => {
       if (!childProcess.pid) {
         throw new Error("Failed to spawn opencode serve process");
       }
+      return childProcess;
+    }
+    registerRunningSession(args2) {
+      const {
+        childProcess,
+        pid,
+        sessionId,
+        context: context4,
+        forwarder,
+        baseUrl,
+        agentName,
+        model,
+        workingDir
+      } = args2;
+      const meta = {
+        sessionId,
+        machineId: context4.machineId,
+        chatroomId: context4.chatroomId,
+        role: context4.role,
+        agentName,
+        ...model ? { model } : {},
+        pid,
+        createdAt: new Date().toISOString(),
+        baseUrl
+      };
+      this.sessionStore.upsert(meta);
+      const entry = this.registerProcess(pid, context4);
+      if (forwarder)
+        this.forwarders.set(pid, forwarder);
+      const outputCallbacks = [];
+      forwardFiltered(childProcess.stdout ?? undefined, process.stdout, isInfoLine);
+      forwardFiltered(childProcess.stderr ?? undefined, process.stderr, isInfoLine);
+      if (childProcess.stdout) {
+        childProcess.stdout.on("data", () => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+      }
+      if (childProcess.stderr) {
+        childProcess.stderr.on("data", () => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+      }
+      return {
+        pid,
+        harnessSessionId: sessionId,
+        harnessReconnect: {
+          agentName,
+          ...model ? { model } : {}
+        },
+        onExit: (cb) => {
+          childProcess.on("exit", (code2, signal) => {
+            const fwd = this.forwarders.get(pid);
+            if (fwd) {
+              fwd.stop();
+              this.forwarders.delete(pid);
+            }
+            this.sessionStore.remove(sessionId);
+            this.deleteProcess(pid);
+            cb({ code: code2, signal, context: context4 });
+          });
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        },
+        onAgentEnd: (cb) => {
+          forwarder?.onAgentEnd(cb);
+        }
+      };
+    }
+    async resumeFromDaemonMemory(options, session) {
+      const { prompt, systemPrompt, model, context: context4 } = options;
+      const sessionId = session.harnessSessionId;
+      const agentName = session.agentName;
+      const modelForSession = model ?? session.model;
+      const workingDir = session.workingDir;
+      const childProcess = this.spawnServeProcess(workingDir);
+      const pid = childProcess.pid;
+      const baseUrl = await waitForListeningUrl(childProcess, {
+        timeoutMs: SERVE_STARTUP_TIMEOUT_MS
+      }).catch((err) => {
+        childProcess.kill();
+        throw err;
+      });
+      const client4 = createOpencodeClient({ baseUrl });
+      let forwarder;
+      try {
+        const sessionInfo = await withTimeout2(client4.session.get({ path: { id: sessionId } }), SESSION_GET_TIMEOUT_MS, "session.get");
+        if (!sessionInfo.data?.id) {
+          throw new Error(`OpenCode session ${sessionId} not found (sessions may not survive serve restart)`);
+        }
+        forwarder = startSessionEventForwarder(client4, {
+          sessionId,
+          role: context4.role
+        });
+        const agentsResponse = await withTimeout2(client4.app.agents(), AGENTS_LIST_TIMEOUT_MS, "app.agents");
+        const availableAgents = agentsResponse.data ?? [];
+        const agentDef = availableAgents.find((a) => a.name === agentName);
+        const composedSystem = composeSystemPrompt(agentDef?.prompt, systemPrompt);
+        const modelParts = modelForSession ? parseModelId(modelForSession) : undefined;
+        await withTimeout2(client4.session.promptAsync({
+          path: { id: sessionId },
+          body: {
+            agent: agentName,
+            ...composedSystem ? { system: composedSystem } : {},
+            parts: [{ type: "text", text: prompt }],
+            ...modelParts ? { model: modelParts } : {},
+            tools: {
+              task: false,
+              question: false,
+              external_directory: false
+            }
+          }
+        }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[${new Date().toISOString()}] role:${context4.role} resume-error] ${reason}
+`);
+        forwarder?.stop();
+        childProcess.kill();
+        throw err;
+      }
+      return this.registerRunningSession({
+        childProcess,
+        pid,
+        sessionId,
+        context: context4,
+        forwarder,
+        baseUrl,
+        agentName,
+        model: modelForSession,
+        workingDir
+      });
+    }
+    async spawn(options) {
+      const { prompt, systemPrompt, model, context: context4 } = options;
+      const childProcess = this.spawnServeProcess(options.workingDir);
       const pid = childProcess.pid;
       const baseUrl = await waitForListeningUrl(childProcess, {
         timeoutMs: SERVE_STARTUP_TIMEOUT_MS
@@ -30213,59 +30573,26 @@ var init_opencode_sdk_agent_service = __esm(() => {
           this.sessionStore.remove(sessionId);
         throw err;
       }
-      const meta = {
+      return this.registerRunningSession({
+        childProcess,
+        pid,
         sessionId,
-        machineId: context4.machineId,
-        chatroomId: context4.chatroomId,
-        role: context4.role,
+        context: context4,
+        forwarder,
+        baseUrl,
         agentName,
-        ...model ? { model } : {},
-        pid,
-        createdAt: new Date().toISOString(),
-        baseUrl
-      };
-      this.sessionStore.upsert(meta);
-      const entry = this.registerProcess(pid, context4);
-      if (forwarder)
-        this.forwarders.set(pid, forwarder);
-      const outputCallbacks = [];
-      forwardFiltered(childProcess.stdout, process.stdout, isInfoLine);
-      forwardFiltered(childProcess.stderr, process.stderr, isInfoLine);
-      if (childProcess.stdout) {
-        childProcess.stdout.on("data", () => {
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
-      }
-      if (childProcess.stderr) {
-        childProcess.stderr.on("data", () => {
-          entry.lastOutputAt = Date.now();
-          for (const cb of outputCallbacks)
-            cb();
-        });
+        model,
+        workingDir: options.workingDir
+      });
+    }
+    getHarnessReconnectContext(pid) {
+      const meta = this.sessionStore.findByPid(pid);
+      if (!meta) {
+        return;
       }
       return {
-        pid,
-        harnessSessionId: sessionId,
-        onExit: (cb) => {
-          childProcess.on("exit", (code2, signal) => {
-            const fwd = this.forwarders.get(pid);
-            if (fwd) {
-              fwd.stop();
-              this.forwarders.delete(pid);
-            }
-            this.sessionStore.remove(sessionId);
-            this.deleteProcess(pid);
-            cb({ code: code2, signal, context: context4 });
-          });
-        },
-        onOutput: (cb) => {
-          outputCallbacks.push(cb);
-        },
-        onAgentEnd: (cb) => {
-          forwarder?.onAgentEnd(cb);
-        }
+        agentName: meta.agentName,
+        ...meta.model ? { model: meta.model } : {}
       };
     }
     async resumeTurn(pid, prompt) {
@@ -30400,16 +30727,16 @@ var MACHINE_CONFIG_VERSION = "1";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fs2 from "node:fs/promises";
 import { homedir as homedir3, hostname as hostname2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function chatroomConfigDir() {
-  return join8(homedir3(), ".chatroom");
+  return join9(homedir3(), ".chatroom");
 }
 async function ensureConfigDir2() {
   const dir = chatroomConfigDir();
   await fs2.mkdir(dir, { recursive: true, mode: 448 });
 }
 function getMachineConfigPath() {
-  return join8(chatroomConfigDir(), MACHINE_FILE);
+  return join9(chatroomConfigDir(), MACHINE_FILE);
 }
 async function loadConfigFile() {
   const configPath = getMachineConfigPath();
@@ -30501,7 +30828,7 @@ var init_storage2 = __esm(() => {
 // src/infrastructure/machine/daemon-state.ts
 import * as fs3 from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function agentKey(chatroomId, role) {
   return `${chatroomId}/${role}`;
 }
@@ -30509,7 +30836,7 @@ async function ensureStateDir() {
   await fs3.mkdir(STATE_DIR, { recursive: true, mode: 448 });
 }
 function stateFilePath(machineId) {
-  return join9(STATE_DIR, `${machineId}.json`);
+  return join10(STATE_DIR, `${machineId}.json`);
 }
 async function loadDaemonState(machineId) {
   const filePath = stateFilePath(machineId);
@@ -30591,8 +30918,8 @@ async function loadEventCursor(machineId) {
 }
 var CHATROOM_DIR2, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
-  CHATROOM_DIR2 = join9(homedir4(), ".chatroom");
-  STATE_DIR = join9(CHATROOM_DIR2, "machines", "state");
+  CHATROOM_DIR2 = join10(homedir4(), ".chatroom");
+  STATE_DIR = join10(CHATROOM_DIR2, "machines", "state");
 });
 
 // src/infrastructure/machine/index.ts
@@ -30965,9 +31292,9 @@ var init_init = __esm(() => {
 });
 
 // src/tools/output.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function resolveChatroomDir(workingDir) {
-  return join10(workingDir, CHATROOM_DIR3);
+  return join11(workingDir, CHATROOM_DIR3);
 }
 async function ensureChatroomDir(deps, workingDir) {
   const dir = resolveChatroomDir(workingDir);
@@ -30975,7 +31302,7 @@ async function ensureChatroomDir(deps, workingDir) {
   return dir;
 }
 async function ensureGitignore(deps, workingDir) {
-  const gitignorePath = join10(workingDir, ".gitignore");
+  const gitignorePath = join11(workingDir, ".gitignore");
   const entry = CHATROOM_DIR3;
   let content = "";
   try {
@@ -31005,7 +31332,7 @@ function formatOutputTimestamp(date = new Date) {
 function generateOutputPath(workingDir, toolName, extension, date) {
   const timestamp = formatOutputTimestamp(date);
   const filename = `${toolName}-${timestamp}.${extension}`;
-  return join10(resolveChatroomDir(workingDir), filename);
+  return join11(resolveChatroomDir(workingDir), filename);
 }
 var CHATROOM_DIR3 = ".chatroom";
 var init_output = () => {};
@@ -79408,20 +79735,20 @@ function formatTimestamp() {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile5, readdir, stat } from "node:fs/promises";
-import { join as join12, basename, resolve as resolve3 } from "node:path";
+import { join as join13, basename, resolve as resolve3 } from "node:path";
 async function resolveGlobPattern(rootDir, pattern) {
   const cleaned = pattern.replace(/\/+$/, "");
   if (cleaned.includes("..")) {
     return [];
   }
   if (cleaned.endsWith("/*")) {
-    const parentDir = join12(rootDir, cleaned.slice(0, -2));
+    const parentDir = join13(rootDir, cleaned.slice(0, -2));
     try {
       const entries2 = await readdir(parentDir, { withFileTypes: true });
       const dirs = [];
       for (const entry of entries2) {
         if (entry.isDirectory()) {
-          const dirPath = join12(parentDir, entry.name);
+          const dirPath = join13(parentDir, entry.name);
           if (resolve3(dirPath).startsWith(resolve3(rootDir))) {
             dirs.push(dirPath);
           }
@@ -79432,7 +79759,7 @@ async function resolveGlobPattern(rootDir, pattern) {
       return [];
     }
   } else {
-    const dir = join12(rootDir, cleaned);
+    const dir = join13(rootDir, cleaned);
     try {
       if (!resolve3(dir).startsWith(resolve3(rootDir)))
         return [];
@@ -79445,7 +79772,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile5(join12(dir, "package.json"), "utf-8");
+    const content = await readFile5(join13(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -79457,7 +79784,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile5(join12(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile5(join13(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -79484,7 +79811,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile5(join12(rootDir, "package.json"), "utf-8");
+    const content = await readFile5(join13(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -79533,11 +79860,11 @@ var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2, readFile as readFile6 } from "node:fs/promises";
-import { join as join13, relative, basename as basename2 } from "node:path";
+import { join as join14, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join13(workingDir, file));
+      await access2(join14(workingDir, file));
       return manager;
     } catch {}
   }
@@ -79584,7 +79911,7 @@ async function discoverCommands(workingDir) {
   const turboTaskNames = [];
   let rootPackageName = basename2(workingDir);
   try {
-    const pkgPath = join13(workingDir, "package.json");
+    const pkgPath = join14(workingDir, "package.json");
     const pkgContent = await readFile6(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     if (pkg.name)
@@ -79605,7 +79932,7 @@ async function discoverCommands(workingDir) {
   } catch {}
   const rootSubWorkspace = { type: "npm", path: ".", name: rootPackageName };
   try {
-    const turboPath = join13(workingDir, "turbo.json");
+    const turboPath = join14(workingDir, "turbo.json");
     const turboContent = await readFile6(turboPath, "utf-8");
     const turbo = JSON.parse(turboContent);
     if (turbo.tasks && typeof turbo.tasks === "object") {
@@ -79659,19 +79986,43 @@ var init_command_discovery = __esm(() => {
   ];
 });
 
-// src/commands/machine/daemon-start/command-sync-heartbeat.ts
-import { createHash as createHash2 } from "node:crypto";
-async function pushCommands(ctx) {
-  let workspaces;
+// src/commands/machine/daemon-start/workspace-cache.ts
+function invalidateWorkspacesForMachineCache(ctx) {
+  delete ctx._workspacesCache;
+}
+async function getWorkspacesForMachine(ctx) {
+  const extended = ctx;
+  const now = Date.now();
+  const cached4 = extended._workspacesCache;
+  if (cached4 && now - cached4.fetchedAt < CACHE_TTL_MS) {
+    return cached4.workspaces;
+  }
   try {
-    workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
+    const workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     });
+    extended._workspacesCache = { fetchedAt: now, workspaces };
+    return workspaces;
   } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces for command sync: ${getErrorMessage(err)}`);
-    return;
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces: ${getErrorMessage(err)}`);
+    return [];
   }
+}
+var CACHE_TTL_MS;
+var init_workspace_cache = __esm(() => {
+  init_reliability();
+  init_api3();
+  init_convex_error();
+  CACHE_TTL_MS = DAEMON_HEARTBEAT_INTERVAL_MS;
+});
+
+// src/commands/machine/daemon-start/command-sync-heartbeat.ts
+import { createHash as createHash2 } from "node:crypto";
+async function pushCommands(ctx) {
+  const workspaces = await getWorkspacesForMachine(ctx);
+  if (workspaces.length === 0)
+    return;
   const uniqueWorkingDirs = new Set(workspaces.map((ws) => ws.workingDir));
   if (uniqueWorkingDirs.size === 0)
     return;
@@ -79703,6 +80054,7 @@ var init_command_sync_heartbeat = __esm(() => {
   init_api3();
   init_command_discovery();
   init_convex_error();
+  init_workspace_cache();
 });
 
 // src/events/daemon/agent/on-request-start-agent.ts
@@ -79719,7 +80071,8 @@ async function onRequestStartAgent(ctx, event) {
     agentHarness: event.agentHarness,
     model: event.model,
     workingDir: event.workingDir,
-    reason: event.reason
+    reason: event.reason,
+    wantResume: event.wantResume ?? true
   });
   if (!result.success) {
     console.log(`[daemon] Agent start rejected for role=${event.role}: ${result.error ?? "unknown"}`);
@@ -79786,7 +80139,7 @@ var init_on_request_stop_agent = () => {};
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash3("sha256").update(url2).digest("hex").substring(0, 8);
@@ -79800,7 +80153,7 @@ function ensureChatroomDir2() {
   }
 }
 function getPidFilePath() {
-  return join14(CHATROOM_DIR4, getPidFileName());
+  return join15(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -79865,7 +80218,7 @@ function releaseLock() {
 var CHATROOM_DIR4;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join14(homedir5(), ".chatroom");
+  CHATROOM_DIR4 = join15(homedir5(), ".chatroom");
 });
 
 // src/infrastructure/git/types.ts
@@ -80251,6 +80604,13 @@ async function getCommitsAhead(workingDir) {
   const count3 = parseInt(result.stdout.trim(), 10);
   return Number.isNaN(count3) ? 0 : count3;
 }
+async function getCommitsBehind(workingDir) {
+  const result = await runGit("rev-list --count HEAD..@{upstream}", workingDir);
+  if ("error" in result)
+    return 0;
+  const count3 = parseInt(result.stdout.trim(), 10);
+  return Number.isNaN(count3) ? 0 : count3;
+}
 async function getCommitStatusChecks(cwd, ref) {
   const repoSlug = await getOriginRepoSlug(cwd);
   if (!repoSlug)
@@ -80387,16 +80747,9 @@ function makeBranchDependentFields(branch) {
   ];
 }
 async function pushGitState(ctx) {
-  let workspaces;
-  try {
-    workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId
-    });
-  } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces for git sync: ${getErrorMessage(err)}`);
+  const workspaces = await getWorkspacesForMachine(ctx);
+  if (workspaces.length === 0)
     return;
-  }
   const uniqueWorkingDirs = new Set(workspaces.map((ws) => ws.workingDir));
   if (uniqueWorkingDirs.size === 0)
     return;
@@ -80547,6 +80900,7 @@ var lastFullPushMs, branchField, GIT_STATE_FIELDS;
 var init_git_heartbeat = __esm(() => {
   init_reliability();
   init_api3();
+  init_workspace_cache();
   init_git_reader();
   init_git_state_pipeline();
   init_convex_error();
@@ -80600,6 +80954,14 @@ var init_git_heartbeat = __esm(() => {
       toMutationPartial: (raw) => ({ commitsAhead: raw }),
       defaultValue: 0
     },
+    {
+      key: "commitsBehind",
+      includeInSlim: false,
+      collect: (wd) => getCommitsBehind(wd),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ commitsBehind: raw }),
+      defaultValue: 0
+    },
     {
       key: "remotes",
       includeInSlim: false,
@@ -80940,16 +81302,9 @@ var init_git_subscription = __esm(() => {
 
 // src/commands/machine/daemon-start/commit-detail-sync.ts
 async function syncCommitDetails(ctx, seenShasMap) {
-  let workspaces;
-  try {
-    workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId
-    });
-  } catch (err) {
-    console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces for commit-detail sync: ${getErrorMessage(err)}`);
+  const workspaces = await getWorkspacesForMachine(ctx);
+  if (workspaces.length === 0)
     return;
-  }
   const uniqueWorkingDirs = new Set(workspaces.map((ws) => ws.workingDir));
   if (uniqueWorkingDirs.size === 0)
     return;
@@ -81054,6 +81409,7 @@ var init_commit_detail_sync = __esm(() => {
   init_api3();
   init_git_reader();
   init_convex_error();
+  init_workspace_cache();
   seenShas = new Map;
 });
 
@@ -82480,17 +82836,17 @@ import {
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getUrlHash2() {
   const url2 = getConvexUrl();
   return createHash6("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join16(homedir6(), ".chatroom");
-  return join16(dir, `daemon-children-${getUrlHash2()}.pids`);
+  const dir = join17(homedir6(), ".chatroom");
+  return join17(dir, `daemon-children-${getUrlHash2()}.pids`);
 }
 function ensureChatroomDir3() {
-  const dir = join16(homedir6(), ".chatroom");
+  const dir = join17(homedir6(), ".chatroom");
   if (!existsSync3(dir)) {
     mkdirSync5(dir, { recursive: true, mode: 448 });
   }
@@ -82584,7 +82940,7 @@ async function reapOrphanedProcessGroups() {
 var CHATROOM_DIR5;
 var init_orphan_tracker = __esm(() => {
   init_client2();
-  CHATROOM_DIR5 = join16(homedir6(), ".chatroom");
+  CHATROOM_DIR5 = join17(homedir6(), ".chatroom");
 });
 
 // src/commands/machine/daemon-start/handlers/process/state.ts
@@ -82722,7 +83078,7 @@ var init_killer = __esm(() => {
 // src/commands/machine/daemon-start/handlers/process/output-store.ts
 import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile8, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -82785,7 +83141,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join17(TEMP_DIR, `${runId}.log`);
+  const filePath = join18(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -82799,7 +83155,7 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join17(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join18(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
@@ -82815,9 +83171,28 @@ function consumePendingFullSync(runId) {
 }
 function startLogObserverPoll(ctx) {
   let stopped = false;
-  const poll4 = async () => {
+  let consecutiveIdlePolls = 0;
+  let pollInFlight = false;
+  let timeoutHandle = null;
+  const scheduleNext = (delayMs) => {
     if (stopped)
       return;
+    if (timeoutHandle)
+      clearTimeout(timeoutHandle);
+    timeoutHandle = setTimeout(() => {
+      poll4();
+    }, delayMs);
+    timeoutHandle.unref?.();
+  };
+  const poll4 = async () => {
+    if (stopped || pollInFlight)
+      return;
+    const hasLocalObservers = observedRunIds.size > 0;
+    if (!hasLocalObservers && consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE) {
+      scheduleNext(IDLE_POLL_INTERVAL_MS);
+      return;
+    }
+    pollInFlight = true;
     try {
       const runs = await ctx.deps.backend.query(api.commands.listRunsWithLogObservers, {
         sessionId: ctx.sessionId,
@@ -82831,31 +83206,40 @@ function startLogObserverPoll(ctx) {
           pendingFullSyncRunIds.add(run3._id);
         }
       }
+      const isActive2 = runs.length > 0 || hasLocalObservers;
+      if (isActive2) {
+        consecutiveIdlePolls = 0;
+        scheduleNext(ACTIVE_POLL_INTERVAL_MS);
+      } else {
+        consecutiveIdlePolls++;
+        scheduleNext(consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE ? IDLE_POLL_INTERVAL_MS : ACTIVE_POLL_INTERVAL_MS);
+      }
     } catch (err) {
       console.warn(`[${formatTimestamp()}] ⚠️ Log-observer poll failed: ${getErrorMessage(err)}`);
+      scheduleNext(ACTIVE_POLL_INTERVAL_MS);
+    } finally {
+      pollInFlight = false;
     }
   };
   poll4();
-  const handle = setInterval(() => {
-    poll4();
-  }, OUTPUT_FLUSH_INTERVAL_MS);
-  handle.unref?.();
   return {
     stop: () => {
       stopped = true;
-      clearInterval(handle);
+      if (timeoutHandle)
+        clearTimeout(timeoutHandle);
       observedRunIds.clear();
       pendingFullSyncRunIds.clear();
     }
   };
 }
-var observedRunIds, pendingFullSyncRunIds;
+var observedRunIds, pendingFullSyncRunIds, ACTIVE_POLL_INTERVAL_MS, IDLE_POLL_INTERVAL_MS = 15000, IDLE_SKIP_AFTER_CONSECUTIVE = 3;
 var init_log_observer_sync = __esm(() => {
   init_api3();
   init_convex_error();
   init_state2();
   observedRunIds = new Set;
   pendingFullSyncRunIds = new Set;
+  ACTIVE_POLL_INTERVAL_MS = OUTPUT_FLUSH_INTERVAL_MS;
 });
 
 // src/commands/machine/daemon-start/handlers/process/spawner.ts
@@ -83549,6 +83933,7 @@ function agentKey2(chatroomId, role) {
 class AgentProcessManager {
   deps;
   slots = new Map;
+  lastHarnessSessions = new Map;
   exitRetryQueue = [];
   exitRetryTimer = null;
   constructor(deps) {
@@ -83622,11 +84007,20 @@ class AgentProcessManager {
     return { success: true };
   }
   async handleAgentEnd(opts) {
+    const key = agentKey2(opts.chatroomId, opts.role);
+    const slot = this.slots.get(key);
+    if (slot?.resumeInFlight) {
+      console.log(`[AgentProcessManager] agent_end: skipping duplicate resume for ${opts.role} (resume already in flight)`);
+      return;
+    }
     const capabilities = getHarnessCapabilities(opts.harness);
-    console.log(`[AgentProcessManager] agent_end: role=${opts.role} pid=${opts.pid} harness=${opts.harness} wantResume=${opts.wantResume} supportsResume=${capabilities.supportsSessionResume}`);
-    if (capabilities.supportsSessionResume && opts.wantResume) {
+    console.log(`[AgentProcessManager] agent_end: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${capabilities.supportsSessionResume}`);
+    if (capabilities.supportsSessionResume) {
       const service = this.deps.agentServices.get(opts.harness);
       if (service?.resumeTurn) {
+        if (slot) {
+          slot.resumeInFlight = true;
+        }
         try {
           const resumePrompt = composeResumeMessage({
             chatroomId: opts.chatroomId,
@@ -83634,9 +84028,39 @@ class AgentProcessManager {
             convexUrl: this.deps.convexUrl
           });
           await service.resumeTurn(opts.pid, resumePrompt);
+          try {
+            await this.deps.backend.mutation(api.machines.emitSessionResumed, {
+              sessionId: this.deps.sessionId,
+              machineId: this.deps.machineId,
+              chatroomId: opts.chatroomId,
+              role: opts.role,
+              ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
+            });
+            console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumed for ${opts.role}`);
+          } catch (err) {
+            console.log(`   ⚠️  Failed to emit sessionResumed event: ${err.message}`);
+          }
           return;
         } catch (err) {
-          console.log(`[AgentProcessManager] ⚠️  resumeTurn failed for ${opts.role} (pid ${opts.pid}): ${err.message} — falling back to kill`);
+          const reason = err.message;
+          try {
+            await this.deps.backend.mutation(api.machines.emitSessionResumeFailed, {
+              sessionId: this.deps.sessionId,
+              machineId: this.deps.machineId,
+              chatroomId: opts.chatroomId,
+              role: opts.role,
+              reason,
+              ...slot?.harnessSessionId ? { harnessSessionId: slot.harnessSessionId } : {}
+            });
+            console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumeFailed for ${opts.role}`);
+          } catch (emitErr) {
+            console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${emitErr.message}`);
+          }
+          console.log(`[AgentProcessManager] ⚠️  resumeTurn failed for ${opts.role} (pid ${opts.pid}): ${reason} — falling back to kill`);
+        } finally {
+          if (slot) {
+            slot.resumeInFlight = false;
+          }
         }
       }
     }
@@ -83773,7 +84197,7 @@ class AgentProcessManager {
   getOrCreateSlot(key) {
     let slot = this.slots.get(key);
     if (!slot) {
-      slot = { state: "idle", wantResume: true };
+      slot = { state: "idle" };
       this.slots.set(key, slot);
     }
     return slot;
@@ -83847,7 +84271,15 @@ class AgentProcessManager {
   async executeEnsureRunning(key, slot, opts) {
     try {
       await this.killExistingBeforeSpawn(opts.chatroomId, opts.role);
-      return await this.doEnsureRunning(key, slot, opts);
+      const result = await this.doEnsureRunning(key, slot, opts);
+      if (!result.success && opts.reason === "platform.auto_restart_on_new_context") {
+        console.log(`[AgentProcessManager] Context auto-restart failed (${result.error ?? "unknown"}), ` + `attempting crash recovery (rate-limited)`);
+        return await this.doEnsureRunning(key, slot, {
+          ...opts,
+          reason: "platform.crash_recovery"
+        });
+      }
+      return result;
     } finally {
       if (slot.pendingOperation) {
         slot.pendingOperation = undefined;
@@ -83887,10 +84319,87 @@ class AgentProcessManager {
       this.exitRetryTimer = null;
     }
   }
+  async tryDaemonMemoryResume(opts) {
+    const capabilities = getHarnessCapabilities(opts.agentHarness);
+    if (!capabilities.supportsSessionResume) {
+      return null;
+    }
+    const stored = this.lastHarnessSessions.get(opts.key);
+    if (!stored) {
+      return null;
+    }
+    if (stored.workingDir !== opts.workingDir) {
+      this.clearLastHarnessSession(opts.key);
+      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, "working directory changed", stored.harnessSessionId);
+      return null;
+    }
+    if (stored.harness !== opts.agentHarness || !stored.agentName) {
+      this.clearLastHarnessSession(opts.key);
+      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, stored.harness !== opts.agentHarness ? "harness changed" : "incomplete session in daemon memory", stored.harnessSessionId);
+      return null;
+    }
+    if (!opts.service.resumeFromDaemonMemory) {
+      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, "daemon-memory session resume not yet supported", stored.harnessSessionId);
+      return null;
+    }
+    try {
+      const spawnResult = await opts.service.resumeFromDaemonMemory({
+        workingDir: stored.workingDir,
+        prompt: createSpawnPrompt(opts.initPrompt),
+        systemPrompt: opts.systemPrompt,
+        model: opts.model ?? stored.model,
+        context: {
+          machineId: this.deps.machineId,
+          chatroomId: opts.chatroomId,
+          role: opts.role
+        }
+      }, {
+        harnessSessionId: stored.harnessSessionId,
+        agentName: stored.agentName,
+        workingDir: stored.workingDir,
+        model: stored.model
+      });
+      await this.emitSessionResumed(opts.chatroomId, opts.role, stored.harnessSessionId);
+      return spawnResult;
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, reason, stored.harnessSessionId);
+      return null;
+    }
+  }
+  async emitSessionResumed(chatroomId, role, harnessSessionId) {
+    try {
+      await this.deps.backend.mutation(api.machines.emitSessionResumed, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId,
+        role,
+        ...harnessSessionId ? { harnessSessionId } : {}
+      });
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumed for ${role}`);
+    } catch (err) {
+      console.log(`   ⚠️  Failed to emit sessionResumed event: ${err.message}`);
+    }
+  }
+  async emitSessionResumeFailed(chatroomId, role, reason, harnessSessionId) {
+    try {
+      await this.deps.backend.mutation(api.machines.emitSessionResumeFailed, {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId,
+        role,
+        reason,
+        ...harnessSessionId ? { harnessSessionId } : {}
+      });
+      console.log(`[AgentProcessManager] ✅ Emitted agent.sessionResumeFailed for ${role}`);
+    } catch (err) {
+      console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${err.message}`);
+    }
+  }
   async doEnsureRunning(key, slot, opts) {
     slot.state = "spawning";
-    slot.wantResume = opts.wantResume ?? true;
-    console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${slot.wantResume} reason=${opts.reason}`);
+    const wantResume = opts.wantResume ?? true;
+    console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${wantResume} reason=${opts.reason}`);
     try {
       const spawnCheck = this.deps.spawning.shouldAllowSpawn(opts.chatroomId, opts.reason, {
         bypassConcurrentLimit: opts.reason.startsWith("user.")
@@ -83964,22 +84473,37 @@ class AgentProcessManager {
         return { success: false, error: `Unknown agent harness: ${opts.agentHarness}` };
       }
       let spawnResult;
-      try {
-        spawnResult = await service.spawn({
+      if (wantResume) {
+        spawnResult = await this.tryDaemonMemoryResume({
+          key,
+          chatroomId: opts.chatroomId,
+          role: opts.role,
+          agentHarness: opts.agentHarness,
           workingDir: opts.workingDir,
-          prompt: createSpawnPrompt(initPromptResult.initialMessage),
-          systemPrompt: initPromptResult.rolePrompt,
           model: opts.model,
-          context: {
-            machineId: this.deps.machineId,
-            chatroomId: opts.chatroomId,
-            role: opts.role
-          }
-        });
-      } catch (e) {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: `Failed to spawn agent: ${e.message}` };
+          initPrompt: initPromptResult.initialMessage,
+          systemPrompt: initPromptResult.rolePrompt,
+          service
+        }) ?? undefined;
+      }
+      if (!spawnResult) {
+        try {
+          spawnResult = await service.spawn({
+            workingDir: opts.workingDir,
+            prompt: createSpawnPrompt(initPromptResult.initialMessage),
+            systemPrompt: initPromptResult.rolePrompt,
+            model: opts.model,
+            context: {
+              machineId: this.deps.machineId,
+              chatroomId: opts.chatroomId,
+              role: opts.role
+            }
+          });
+        } catch (e) {
+          slot.state = "idle";
+          slot.pendingOperation = undefined;
+          return { success: false, error: `Failed to spawn agent: ${e.message}` };
+        }
       }
       const { pid } = spawnResult;
       this.deps.spawning.recordSpawn(opts.chatroomId);
@@ -83987,6 +84511,15 @@ class AgentProcessManager {
       slot.pid = pid;
       slot.harness = opts.agentHarness;
       slot.harnessSessionId = spawnResult.harnessSessionId;
+      if (spawnResult.harnessSessionId) {
+        this.recordLastHarnessSession(key, {
+          harnessSessionId: spawnResult.harnessSessionId,
+          harness: opts.agentHarness,
+          agentName: spawnResult.harnessReconnect?.agentName ?? "",
+          workingDir: opts.workingDir,
+          model: opts.model ?? spawnResult.harnessReconnect?.model
+        });
+      }
       slot.model = opts.model;
       slot.workingDir = opts.workingDir;
       slot.startedAt = this.deps.clock.now();
@@ -83998,7 +84531,8 @@ class AgentProcessManager {
         role: opts.role,
         pid,
         model: opts.model,
-        reason: opts.reason
+        reason: opts.reason,
+        ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {}
       }).catch((err) => {
         console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
       });
@@ -84020,8 +84554,7 @@ class AgentProcessManager {
             chatroomId: opts.chatroomId,
             role: opts.role,
             pid,
-            harness: opts.agentHarness,
-            wantResume: slot.wantResume
+            harness: opts.agentHarness
           });
         });
       }
@@ -84044,12 +84577,38 @@ class AgentProcessManager {
       return { success: false, error: `Unexpected error: ${e.message}` };
     }
   }
+  recordLastHarnessSession(key, ctx) {
+    this.lastHarnessSessions.set(key, ctx);
+  }
+  clearLastHarnessSession(key) {
+    this.lastHarnessSessions.delete(key);
+  }
+  readHarnessReconnectMetadata(service, pid) {
+    return service.getHarnessReconnectContext?.(pid);
+  }
   async doStop(key, slot, pid, opts) {
     try {
       const harness = slot.harness;
       const service = harness ? this.deps.agentServices.get(harness) : undefined;
+      const preserveForResume = opts.reason === "user.stop" && Boolean(slot.harnessSessionId);
+      if (harness && slot.harnessSessionId) {
+        if (preserveForResume) {
+          const harnessMeta = service ? this.readHarnessReconnectMetadata(service, pid) : undefined;
+          this.recordLastHarnessSession(key, {
+            harnessSessionId: slot.harnessSessionId,
+            harness,
+            agentName: harnessMeta?.agentName ?? "",
+            workingDir: slot.workingDir ?? "",
+            model: slot.model ?? harnessMeta?.model
+          });
+        } else {
+          this.clearLastHarnessSession(key);
+        }
+      } else if (!preserveForResume) {
+        this.clearLastHarnessSession(key);
+      }
       if (service) {
-        await service.stop(pid);
+        await service.stop(pid, { preserveForResume });
         service.untrack(pid);
       } else {
         try {
@@ -84121,7 +84680,7 @@ class SpawnRateLimiter {
     this.config = { ...DEFAULT_CONFIG2, ...config3 };
   }
   tryConsume(chatroomId, reason) {
-    if (reason.startsWith("user.")) {
+    if (reason.startsWith("user.") || reason === "platform.auto_restart_on_new_context") {
       return { allowed: true };
     }
     const bucket = this._getOrCreateBucket(chatroomId);
@@ -84750,6 +85309,37 @@ async function gitPull(workingDir) {
   }
   return { status: "available" };
 }
+async function gitPush(workingDir) {
+  const result = await runGit2("push", workingDir);
+  if ("error" in result) {
+    const message = result.error.message;
+    if (message.includes("no upstream branch")) {
+      return {
+        status: "error",
+        message: "No upstream branch configured. Set upstream with `git push -u`."
+      };
+    }
+    if (message.includes("Authentication failed") || message.includes("could not read")) {
+      return {
+        status: "error",
+        message: "Authentication failed. Run `gh auth status` to check your GitHub credentials."
+      };
+    }
+    return classifyError2(message);
+  }
+  const stderr = result.stderr.trim();
+  if (stderr && !stderr.includes("Everything up-to-date")) {
+    return { status: "available", message: stderr };
+  }
+  return { status: "available" };
+}
+async function gitSync(workingDir) {
+  const pullResult = await gitPull(workingDir);
+  if (pullResult.status === "error") {
+    return pullResult;
+  }
+  return gitPush(workingDir);
+}
 var execAsync4;
 var init_git_writer = __esm(() => {
   execAsync4 = promisify5(exec5);
@@ -84855,6 +85445,20 @@ async function executeLocalAction(action, workingDir) {
       }
       return { success: true, message: result.message ?? "Pull successful" };
     }
+    case "git-push": {
+      const result = await gitPush(workingDir);
+      if (result.status === "error") {
+        return { success: false, error: result.message };
+      }
+      return { success: true, message: result.message ?? "Push successful" };
+    }
+    case "git-sync": {
+      const result = await gitSync(workingDir);
+      if (result.status === "error") {
+        return { success: false, error: result.message };
+      }
+      return { success: true, message: result.message ?? "Sync successful" };
+    }
     default: {
       const _exhaustive = action;
       return { success: false, error: `Unknown action: ${_exhaustive}` };
@@ -85297,6 +85901,9 @@ async function dispatchCommandEvent(ctx, event, tracker) {
     const result = await executeLocalAction(event.action, event.workingDir);
     if (!result.success) {
       console.warn(`[${formatTimestamp()}] ⚠️  Local action failed: ${result.error}`);
+    } else if (event.action === "git-pull" || event.action === "git-push" || event.action === "git-sync" || event.action === "git-discard-all") {
+      ctx.lastPushedGitState.delete(makeGitStateKey(ctx.machineId, event.workingDir));
+      await pushSingleWorkspaceGitState(ctx, event.workingDir);
     }
     tracker.localActionIds.set(eventId, Date.now());
   } else if (eventType === "command.run") {
@@ -85354,6 +85961,7 @@ async function startCommandLoop(ctx) {
     }).then(() => {
       heartbeatCount++;
       console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
+      invalidateWorkspacesForMachineCache(ctx);
       if (!ctx.observedSyncEnabled) {
         pushGitState(ctx).catch((err) => {
           console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
@@ -85520,6 +86128,7 @@ var init_command_loop = __esm(() => {
   init_manager();
   init_init2();
   init_log_observer_sync();
+  init_workspace_cache();
   init_observed_sync();
   init_api3();
   init_client2();
@@ -86699,4 +87308,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=3E031CCB2CBFFA9464756E2164756E21
+//# debugId=D59205F0E7B31DAD64756E2164756E21