@synkro-sh/cli 1.1.6 → 1.1.7

package/dist/bootstrap.js

@@ -1335,7 +1335,7 @@ returns the assistant's response text. ONE CC startup (~3.5s) amortizes
 across N gradings.
 
 Session bloat is bounded: the daemon rotates its claude subprocess every
-ROTATION_CALLS (default 30) gradings or ROTATION_AGE_SEC (default 1h),
+ROTATION_CALLS (default 10) gradings or ROTATION_AGE_SEC (default 1h),
 whichever comes first. Each rotation eats a one-time ~5s primer cost; calls
 in between target ~2-3s steady-state.
 
@@ -1365,9 +1365,9 @@ def mode_paths(mode):
 MODE = "edit"
 PID_FILE, SOCK_PATH, LOG_FILE = mode_paths(MODE)
 
-ROTATION_CALLS = int(os.environ.get("SYNKRO_DAEMON_ROTATE_CALLS", "30"))
+ROTATION_CALLS = int(os.environ.get("SYNKRO_DAEMON_ROTATE_CALLS", "10"))
 ROTATION_AGE_SEC = int(os.environ.get("SYNKRO_DAEMON_ROTATE_AGE", "3600"))
-GRADE_TIMEOUT_SEC = 60
+GRADE_TIMEOUT_SEC = int(os.environ.get("SYNKRO_DAEMON_GRADE_TIMEOUT", "10"))
 DEFAULT_MODEL = os.environ.get("SYNKRO_DAEMON_MODEL", "claude-sonnet-4-6")
 MAX_PROMPT_BYTES = 4 * 1024 * 1024
 
@@ -1380,6 +1380,8 @@ def log(msg):
         pass
 
 
+PREWARM_HEADROOM = 4
+
 class GraderDaemon:
     def __init__(self, primer):
         self.primer = primer or ""
@@ -1387,14 +1389,12 @@ class GraderDaemon:
         self.calls = 0
         self.start_time = 0.0
         self.lock = threading.Lock()
+        self._next_proc = None
+        self._prewarm_thread = None
         self._spawn()
 
-    def _spawn(self):
-        if self.proc and self.proc.poll() is None:
-            try: self.proc.terminate(); self.proc.wait(timeout=3)
-            except Exception: self.proc.kill()
-        log("spawning claude subprocess")
-        self.proc = subprocess.Popen(
+    def _make_proc(self):
+        return subprocess.Popen(
             [
                 "claude", "--print", "--model", DEFAULT_MODEL,
                 "--input-format=stream-json",
@@ -1405,41 +1405,26 @@ class GraderDaemon:
             stdin=subprocess.PIPE, stdout=subprocess.PIPE,
             stderr=subprocess.DEVNULL, text=True, bufsize=1,
         )
-        if self.primer:
-            self._send(self.primer)
-            primer_resp = self._recv()
-            log(f"primer ack: {primer_resp[:80]!r}")
-        self.calls = 0
-        self.start_time = time.time()
 
-    def _send(self, text):
+    def _send_to(self, proc, text):
         msg = json.dumps({
             "type": "user",
             "message": {"role": "user", "content": [{"type": "text", "text": text}]},
             "parent_tool_use_id": None,
             "session_id": "",
         })
-        try:
-            self.proc.stdin.write(msg + "\\n")
-            self.proc.stdin.flush()
-        except (BrokenPipeError, OSError) as e:
-            log(f"send broke: {e}; respawn")
-            self._spawn()
-            self.proc.stdin.write(msg + "\\n")
-            self.proc.stdin.flush()
+        proc.stdin.write(msg + "\\n")
+        proc.stdin.flush()
 
-    def _recv(self):
+    def _recv_from(self, proc):
         acc = []
         deadline = time.time() + GRADE_TIMEOUT_SEC
         while True:
             if time.time() > deadline:
-                log("recv timeout; respawn")
-                self._spawn()
+                log("recv timeout")
                 return ""
-            line = self.proc.stdout.readline()
+            line = proc.stdout.readline()
             if not line:
-                log("subprocess closed stdout; respawn")
-                self._spawn()
                 return ""
             try:
                 obj = json.loads(line)
@@ -1453,18 +1438,87 @@ class GraderDaemon:
             elif t == "result":
                 return "".join(acc)
 
+    def _spawn(self):
+        if self.proc and self.proc.poll() is None:
+            try: self.proc.terminate(); self.proc.wait(timeout=3)
+            except Exception: self.proc.kill()
+        log("spawning claude subprocess")
+        self.proc = self._make_proc()
+        if self.primer:
+            self._send_to(self.proc, self.primer)
+            primer_resp = self._recv_from(self.proc)
+            log(f"primer ack: {primer_resp[:80]!r}")
+        self.calls = 0
+        self.start_time = time.time()
+        self._next_proc = None
+
+    def _prewarm_worker(self):
+        try:
+            log("pre-warming next subprocess")
+            proc = self._make_proc()
+            if self.primer:
+                self._send_to(proc, self.primer)
+                resp = self._recv_from(proc)
+                log(f"pre-warm ack: {resp[:80]!r}")
+            self._next_proc = proc
+            log("pre-warm ready")
+        except Exception as e:
+            log(f"pre-warm failed: {e}")
+            self._next_proc = None
+
+    def _maybe_prewarm(self):
+        if self._prewarm_thread and self._prewarm_thread.is_alive():
+            return
+        if self._next_proc is not None:
+            return
+        if self.calls >= ROTATION_CALLS - PREWARM_HEADROOM:
+            self._prewarm_thread = threading.Thread(target=self._prewarm_worker, daemon=True)
+            self._prewarm_thread.start()
+
+    def _try_rotate(self):
+        if self._next_proc and self._next_proc.poll() is None:
+            log("hot-swapping to pre-warmed subprocess")
+            old = self.proc
+            self.proc = self._next_proc
+            self._next_proc = None
+            self._prewarm_thread = None
+            self.calls = 0
+            self.start_time = time.time()
+            if old and old.poll() is None:
+                threading.Thread(target=lambda: (old.terminate(), old.wait()), daemon=True).start()
+            return True
+        log("pre-warm not ready, deferring rotation")
+        return False
+
+    def _send(self, text):
+        try:
+            self._send_to(self.proc, text)
+        except (BrokenPipeError, OSError) as e:
+            log(f"send broke: {e}; respawn")
+            self._spawn()
+            self._send_to(self.proc, text)
+
+    def _recv(self):
+        resp = self._recv_from(self.proc)
+        if not resp and (not self.proc or self.proc.poll() is not None):
+            log("subprocess died; respawn")
+            self._spawn()
+        return resp
+
     def grade(self, prompt):
         with self.lock:
-            age = time.time() - self.start_time
-            if self.calls >= ROTATION_CALLS or age >= ROTATION_AGE_SEC:
-                log(f"rotating: calls={self.calls} age={age:.0f}s")
-                self._spawn()
             t0 = time.time()
             self._send(prompt)
             resp = self._recv()
             elapsed = (time.time() - t0) * 1000
             self.calls += 1
             log(f"grade #{self.calls} elapsed={elapsed:.0f}ms resp_chars={len(resp)}")
+            age = time.time() - self.start_time
+            if self.calls >= ROTATION_CALLS or age >= ROTATION_AGE_SEC:
+                if not self._try_rotate():
+                    self._maybe_prewarm()
+            else:
+                self._maybe_prewarm()
             return resp
 
 
@@ -2090,7 +2144,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_GATEWAY_URL=${shellQuoteSingle(safeGateway)}`,
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.1.6")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.1.7")}`
   ];
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
   if (safeOrgId) lines.push(`SYNKRO_ORG_ID=${shellQuoteSingle(safeOrgId)}`);