@indigoai-us/hq-cli 5.159.0 → 5.161.0

package/dist/lib/lanes/watcher.js

@@ -499,6 +499,25 @@ export function readLatestEnvelopeFile(hqRoot, laneId, minName) {
         };
     }
 }
+/** A descriptor for this run's manifest slot when no envelope file was written. */
+export function missingExpectedEnvelopeFile(hqRoot, laneId, envelopePath) {
+    if (!envelopePath || !path.isAbsolute(envelopePath))
+        return null;
+    const runDir = laneRunDir(hqRoot, laneId);
+    const expectedPath = path.resolve(envelopePath);
+    const expectedDir = path.resolve(runDir, "envelopes");
+    const filename = path.basename(expectedPath);
+    if (path.dirname(expectedPath) !== expectedDir || !filename.endsWith(".json"))
+        return null;
+    return {
+        ref: path.posix.join("envelopes", filename),
+        path: expectedPath,
+        text: "",
+        envelope: null,
+        error: `Missing expected envelope file: ${expectedPath}`,
+        missing: true,
+    };
+}
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with
  * the event name and the error message, and never propagates: the lane's
@@ -677,6 +696,9 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
             }
         }
         const latestFile = readLatestEnvelopeFile(hqRoot, laneId, minEnvelopeName);
+        const missingExpected = !processAlive && latestFile === null
+            ? missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)
+            : null;
         const latest = latestFile && latestFile.envelope
             ? { envelope: latestFile.envelope, ref: latestFile.ref }
             : null;
@@ -719,30 +741,37 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 process.stderr.write(`hq lanes watcher: quota read failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
             }
         }
-        // Spec §4: the process exited and its envelope file does not parse.
-        // Exactly one repair turn, then failed with both errors. A provider
+        // Spec §4: the process exited and its envelope file does not parse, or
+        // this run never wrote its expected slot. Exactly one repair turn. A provider
         // rejection skips the repair: the provider refused the turn, so a
         // second turn on the same model and account would be refused the same
         // way. A quota signal skips it too: a repair turn on an exhausted account
         // fails the same way, and would end the lane envelope_invalid without
         // ever recording the hold. The quota result applies immediately instead.
         let invalidEnvelope = null;
+        const repairCandidate = latestFile ?? missingExpected;
         if (!processAlive &&
             !envelope &&
             !providerRejection &&
             !quota &&
-            latestFile &&
-            latestFile.envelope === null) {
-            const repair = decideEnvelopeRepair(hqRoot, laneId, latestFile, now(), spawnRepair, logDecision);
-            if (repair.action === "spawned") {
-                lastSignalMs = now();
-                lastAlive = null;
-                if (progressed)
-                    lastSeenMtime = newestMtime;
-                await sleep(pollMs);
-                continue;
+            repairCandidate &&
+            repairCandidate.envelope === null) {
+            const lane = repairCandidate.missing ? readLaneSoft(hqRoot, laneId) : null;
+            const missingRepairAllowed = !repairCandidate.missing ||
+                (lane !== null && envelopeRepairMode(lane.provider) === "resume");
+            if (missingRepairAllowed) {
+                const repair = decideEnvelopeRepair(hqRoot, laneId, repairCandidate, now(), spawnRepair, logDecision);
+                if (repair.action === "spawned") {
+                    lastSignalMs = now();
+                    lastAlive = null;
+                    if (progressed)
+                        lastSeenMtime = newestMtime;
+                    await sleep(pollMs);
+                    continue;
+                }
+                if (!repairCandidate.missing)
+                    invalidEnvelope = { errors: repair.errors };
             }
-            invalidEnvelope = { errors: repair.errors };
         }
         if (processAlive === false && envelope && latestFile) {
             markRepairSucceeded(hqRoot, laneId, latestFile.ref);
@@ -919,13 +948,15 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     }
 }
 /**
- * Spec §4 repair decision for an exited worker whose envelope file does not
- * parse. First failure on a resumable provider with a recorded session id:
- * record `envelope_repair` on the lane and spawn the repair turn. A provider
- * with no session resume gets the same single attempt as a fresh turn. Anything
- * else (already attempted, no session id on a resumable provider, spawn
- * failure): give up with every error collected, and the caller classifies
- * the lane `failed` with reason `envelope_invalid`.
+ * Spec §4 repair decision for an exited worker whose expected envelope is
+ * invalid or missing. First failure on a resumable provider with a recorded
+ * session id: record `envelope_repair` on the lane and spawn the repair turn.
+ * A provider with no session resume gets the same single attempt as a fresh
+ * turn for invalid files. Anything else (already attempted, no session id on a
+ * resumable provider, non-running lane, spawn failure): give up with every
+ * error collected. The caller preserves the normal interrupted classification
+ * for a missing file and uses `envelope_invalid` only for an existing invalid
+ * file.
  */
 export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair, logDecision) {
     const at = new Date(nowMs).toISOString();
@@ -933,8 +964,18 @@ export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair,
     const lane = readLaneSoft(hqRoot, laneId);
     if (!lane)
         return { action: "give_up", errors: [error] };
+    if (lane.state !== "running") {
+        logDecision({ event: "envelope_repair", at, outcome: "skipped", skipped_reason: "lane_not_running", error });
+        return { action: "give_up", errors: [error] };
+    }
+    const runDir = laneRunDir(hqRoot, laneId);
+    const manifest = readSpawnManifest(runDir);
     const prior = lane.envelope_repair;
-    if (prior && prior.attempted) {
+    const repairRef = missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)?.ref ??
+        prior?.envelope_ref ??
+        latest.ref;
+    const priorAppliesToSlot = prior?.envelope_ref === undefined || prior.envelope_ref === repairRef;
+    if (prior && prior.attempted && priorAppliesToSlot) {
         // The repair turn ran and its output does not parse either.
         if (prior.attempted) {
             const errors = [prior.first_error, error];
@@ -952,21 +993,21 @@ export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair,
         }
         return { action: "give_up", errors: [prior.first_error] };
     }
-    const runDir = laneRunDir(hqRoot, laneId);
     // `resume` (claude, codex) continues the recorded session; `fresh_turn`
     // (grok) runs the repair prompt as a new single turn on the same account.
     const mode = envelopeRepairMode(lane.provider);
     let skipped;
     let sessionId = null;
     if (mode === "resume") {
-        const result = readWorkerRunResult(runDir, lane.provider, readSpawnManifest(runDir).worker_out_offset ?? 0);
-        sessionId = result?.session_id ?? null;
+        const result = readWorkerRunResult(runDir, lane.provider, manifest.worker_out_offset ?? 0);
+        sessionId = result?.session_id ??
+            [manifest.resume?.session_id, lane.provider_session_id, lane.last_resume?.session_id].find((candidate) => typeof candidate === "string" && candidate.trim().length > 0) ?? null;
         if (sessionId === null)
             skipped = result?.session_id_absent ?? "no_result_json";
     }
     const base = {
         first_error: error,
-        envelope_ref: latest.ref,
+        envelope_ref: repairRef,
         at,
     };
     if (skipped !== undefined) {
@@ -981,6 +1022,7 @@ export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair,
             envelopePath: latest.path,
             error,
             rawText: latest.text,
+            missing: latest.missing,
         });
         logDecision({ event: "envelope_repair", at, outcome: "spawned", mode, pid, session_id: sessionId, error });
         return { action: "spawned" };

package/package.json

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