@indigoai-us/hq-cli 5.158.0 → 5.160.0

package/dist/lib/lanes/store.js

@@ -421,6 +421,11 @@ export function parseLaneRecord(raw, filePath) {
     if (!isLaneProvider(raw.provider)) {
         throw new LaneSchemaError(`Unknown provider ${JSON.stringify(raw.provider)}`, { path: filePath, value: raw.provider });
     }
+    if (raw.worker_policy_delivery !== undefined &&
+        raw.worker_policy_delivery !== "hook" &&
+        raw.worker_policy_delivery !== "prompt") {
+        throw new LaneSchemaError(`Unknown worker policy delivery mode ${JSON.stringify(raw.worker_policy_delivery)}`, { path: filePath, field: "worker_policy_delivery", value: raw.worker_policy_delivery });
+    }
     parseLaneStories(raw, filePath);
     parseOptionalCompanyField(raw, filePath);
     parseOptionalMeshCompanyField(raw, filePath);

package/dist/lib/lanes/types.d.ts

@@ -296,6 +296,8 @@ export interface LaneRecord {
     worker_profile_hash?: string;
     /** Profile fields intentionally unsupported by the selected provider. */
     worker_profile_ignored?: string[];
+    /** How policy files were delivered on the most recent profile spawn. */
+    worker_policy_delivery?: "hook" | "prompt";
     provider: LaneProvider;
     account?: string;
     /** Eligible accounts for a queue entry created without an explicit account. */
@@ -400,9 +402,9 @@ export interface LaneRecord {
     /** Cache counters from the last exited run's result. Nothing else from the payload. */
     last_run_usage?: LaneRunUsage;
     /**
-     * Spec §4: one repair turn when the final output fails parseLaneEnvelope.
-     * Written by the watcher before the repair spawn, updated on the repair
-     * run's exit. Absent when every envelope this lane wrote parsed first time.
+     * Spec §4: one repair turn per expected envelope slot when the final output
+     * is invalid or missing. Written before repair spawn and updated on repair
+     * exit. Absent when each slot's first envelope parsed successfully.
      */
     envelope_repair?: LaneEnvelopeRepair;
     /** Last successful lane_progress mesh delivery, preserved across watcher restarts. */

package/dist/lib/lanes/types.js

@@ -214,12 +214,12 @@ export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spaw
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
     schema_version: ["creator"], lane_id: ["creator"], company: ["creator"],
-    project_id: ["command"], story_id: ["command"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator"],
+    project_id: ["command"], story_id: ["command"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
-    priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"], worker_profile: ["creator"], worker_profile_hash: ["creator", "spawn"], worker_profile_ignored: ["creator", "spawn"],
+    priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],

package/dist/lib/lanes/watcher.d.ts

@@ -174,8 +174,10 @@ export interface LatestEnvelopeFile {
     path: string;
     text: string;
     envelope: LaneEnvelope | null;
-    /** Parser message when `envelope` is null. */
+    /** Parser message, or the missing-slot reason, when `envelope` is null. */
     error: string | null;
+    /** True when the manifest's expected envelope slot was never created. */
+    missing?: boolean;
 }
 export declare function readLatestEnvelope(hqRoot: string, laneId: string, minName?: string): LaneEnvelope | null;
 /** Valid-only view over `readLatestEnvelopeFile`; an unparseable file reads as absent. */
@@ -187,6 +189,8 @@ export declare function readLatestEnvelopeRecord(hqRoot: string, laneId: string,
  * would otherwise be marked done again from the previous one.
  */
 export declare function readLatestEnvelopeFile(hqRoot: string, laneId: string, minName?: string): LatestEnvelopeFile | null;
+/** A descriptor for this run's manifest slot when no envelope file was written. */
+export declare function missingExpectedEnvelopeFile(hqRoot: string, laneId: string, envelopePath: string | undefined): LatestEnvelopeFile | null;
 export interface WatcherLoopDeps {
     sleep?: (ms: number) => Promise<void>;
     now?: () => number;
@@ -230,13 +234,15 @@ export type EnvelopeRepairDecision = {
     errors: string[];
 };
 /**
- * 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 declare function decideEnvelopeRepair(hqRoot: string, laneId: string, latest: LatestEnvelopeFile, nowMs: number, spawnRepair: NonNullable<WatcherLoopDeps["spawnRepair"]>, logDecision: (record: Record<string, unknown>) => void): EnvelopeRepairDecision;
 /** Exported so tests can prove the watcher reads the live record, not spawn env. */

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.158.0",
+  "version": "5.160.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {