@indigoai-us/hq-cli 5.88.0 → 5.88.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [5.88.1]
+
+### Fixed
+
+- `hq core checkpoint` no longer wedges its maintenance-sibling queue forever
+  when the recorded lock PID is recycled by another user's process. An `EPERM`
+  from the liveness probe now means "not our sibling" rather than "sibling
+  alive", locks expire after 60 minutes, and `pending.jsonl` is capped at the
+  50 newest payloads with the queue depth reported in the busy message so a
+  stall is visible instead of silent. (#313)
+
 ## [5.88.0]
 
 ### Changed

package/dist/commands/core-checkpoint.js

@@ -19,6 +19,10 @@ const CODEX_SIBLING_MODEL = "gpt-5.6-terra";
 const CODEX_SIBLING_REASONING_EFFORT = "high";
 const CLAUDE_SIBLING_MODEL = "claude-opus-5";
 const CLAUDE_SIBLING_EFFORT = "medium";
+/** A sibling still holding the lock after this long is treated as abandoned. */
+const SIBLING_LOCK_TTL_MS = 60 * 60 * 1000;
+/** Newest-wins cap so a wedged sibling cannot grow an unbounded queue. */
+const MAX_PENDING_PAYLOADS = 50;
 class CheckpointUsageError extends Error {
 }
 function printResult(line) {
@@ -405,26 +409,58 @@ function siblingPayload(input, threadPath) {
         pending_payloads: [],
     };
 }
-function existingSiblingPid(lockPath) {
+/**
+ * PID of a sibling that is genuinely still working, or null when the lock is
+ * stale and this process should take it over.
+ *
+ * A lock is stale when the PID is gone, when it cannot be signalled, or when
+ * the run has outlived {@link SIBLING_LOCK_TTL_MS}. Siblings are spawned as
+ * this user, so an EPERM means the PID was recycled by somebody else's
+ * process — not that our sibling is alive. Treating an unsignalable PID as
+ * alive wedges the queue permanently: on 2026-08-03 a lock landed on a
+ * root-owned kernel thread and every checkpoint for the next two days queued
+ * behind a sibling that had never existed.
+ */
+function existingSiblingPid(lockPath, now) {
+    let raw;
+    let writtenAtMs;
+    try {
+        raw = fs.readFileSync(lockPath, "utf8").trim();
+        writtenAtMs = fs.statSync(lockPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    if (now - writtenAtMs >= SIBLING_LOCK_TTL_MS)
+        return null;
     try {
-        const pid = Number.parseInt(fs.readFileSync(lockPath, "utf8").trim(), 10);
-        if (!Number.isSafeInteger(pid) || pid <= 0)
-            return null;
         process.kill(pid, 0);
         return pid;
     }
-    catch (error) {
-        if (error?.code === "EPERM") {
-            try {
-                return Number.parseInt(fs.readFileSync(lockPath, "utf8").trim(), 10);
-            }
-            catch {
-                return null;
-            }
-        }
+    catch {
         return null;
     }
 }
+/**
+ * Queue a payload for the next sibling, keeping only the newest entries. An
+ * unbounded queue hides a wedged sibling instead of surfacing it. Returns the
+ * resulting queue depth so the caller can report it.
+ */
+function appendPending(pendingPath, payload) {
+    fs.appendFileSync(pendingPath, `${JSON.stringify(payload)}\n`);
+    const lines = fs
+        .readFileSync(pendingPath, "utf8")
+        .split("\n")
+        .filter((line) => line.trim());
+    if (lines.length <= MAX_PENDING_PAYLOADS)
+        return lines.length;
+    const kept = lines.slice(-MAX_PENDING_PAYLOADS);
+    fs.writeFileSync(pendingPath, `${kept.join("\n")}\n`);
+    return kept.length;
+}
 function drainPending(pendingPath) {
     if (!fs.existsSync(pendingPath))
         return [];
@@ -449,11 +485,11 @@ function startSibling(liveRoot, input, threadPath, backend) {
     const pendingPath = path.join(siblingRoot, "pending.jsonl");
     const lockPath = path.join(stateDir, "checkpoint-sibling.lock");
     const payload = siblingPayload(input, threadPath);
-    const activePid = existingSiblingPid(lockPath);
+    const activePid = existingSiblingPid(lockPath, Date.now());
     fs.mkdirSync(siblingRoot, { recursive: true });
     if (activePid !== null) {
-        fs.appendFileSync(pendingPath, `${JSON.stringify(payload)}\n`);
-        printResult("checkpoint: sibling busy — payload queued");
+        const depth = appendPending(pendingPath, payload);
+        printResult(`checkpoint: sibling busy — payload queued (${depth} pending)`);
         return;
     }
     const runDir = path.join(siblingRoot, `${formatTimestamp(new Date())}-${summarySlug(input.summary ?? "checkpoint")}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.88.0",
+  "version": "5.88.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {