@indigoai-us/hq-cli 5.345.77 → 5.345.79

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.345.79] — 2026-10-11
+- `hq lanes` no longer fails every list, message, or admission command when
+  one lane still has leftover queue details from an older worker-profile wait.
+  Those leftover details are dropped on read, cleared when the queue reason
+  changes, and one unreadable lane is skipped so the rest of the host stays
+  usable.
+- `hq doctor --fix` still refreshes a stale company sync journal when
+  `.claude/`, `.codex/`, or `.grok/` has uncommitted changes. Those dirty
+  files still block hook-file repairs unless you pass `--force`.
+
 ## [5.345.77] — 2026-10-10
 - Local bots no longer fail a turn when the installed Codex is too old for the
   model it was asked to use (often the model a newer Codex app set in your own

package/dist/lib/doctor/fix/apply.d.ts

@@ -5,9 +5,12 @@
  * wrapped in guardrails that are NOT polish — each is a PRD acceptance criterion:
  *
  *   1. Dirty-tree refusal. If the working tree has uncommitted changes under
- *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses and exits non-zero
- *      unless `--force`, so a repair can never be tangled up with unrelated
- *      in-flight edits to the security layer.
+ *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses hook-file repairs
+ *      and exits non-zero unless `--force`, so those writes can never be
+ *      tangled up with unrelated in-flight edits to the security layer.
+ *      Repairs that do not write those trees (a stale-company `refresh-sync`
+ *      pull) still run: the SessionStart health hook never passes `--force`,
+ *      and blocking the pull left `sync.journal.<slug>` WARN after `--fix`.
  *   2. Allowlist only. It repairs the classified safe classes — restore an
  *      execute bit, add a hook id to the gate profiles it is missing from,
  *      re-register a script present on disk, or pull a company whose local

package/dist/lib/doctor/fix/apply.js

@@ -5,9 +5,12 @@
  * wrapped in guardrails that are NOT polish — each is a PRD acceptance criterion:
  *
  *   1. Dirty-tree refusal. If the working tree has uncommitted changes under
- *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses and exits non-zero
- *      unless `--force`, so a repair can never be tangled up with unrelated
- *      in-flight edits to the security layer.
+ *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses hook-file repairs
+ *      and exits non-zero unless `--force`, so those writes can never be
+ *      tangled up with unrelated in-flight edits to the security layer.
+ *      Repairs that do not write those trees (a stale-company `refresh-sync`
+ *      pull) still run: the SessionStart health hook never passes `--force`,
+ *      and blocking the pull left `sync.journal.<slug>` WARN after `--fix`.
  *   2. Allowlist only. It repairs the classified safe classes — restore an
  *      execute bit, add a hook id to the gate profiles it is missing from,
  *      re-register a script present on disk, or pull a company whose local
@@ -107,20 +110,34 @@ export async function applyFixes(options) {
         ...over,
     });
     // 1. Dirty-tree refusal (AC8). Never write over uncommitted security-layer
-    //    edits unless the user forces it.
-    if (!options.force) {
-        const dirty = (options.dirtyCheck ?? uncommittedHookConfigChanges)(hqRoot);
-        if (dirty.length > 0) {
-            writeErr(`hq doctor --fix: refusing to run — uncommitted changes under ` +
-                `${HOOK_CONFIG_DIRS.join(", ")}:\n` +
-                dirty.map((line) => `  ${line}`).join("\n") +
-                `\nCommit or stash them, or re-run with --force.\n`);
-            return empty({ exitCode: 1, refused: "dirty-tree" });
-        }
-    }
+    //    edits unless the user forces it. Probe once; hook-file plans are
+    //    dropped per pass so a stale-journal pull can still run.
+    const dirty = options.force
+        ? []
+        : (options.dirtyCheck ?? uncommittedHookConfigChanges)(hqRoot);
+    const refuseDirtyHookWrites = (plans) => {
+        if (dirty.length === 0)
+            return plans;
+        const allowed = plans.filter((plan) => plan.relpath.length === 0);
+        if (allowed.length === plans.length)
+            return plans;
+        if (allowed.length === 0)
+            return "refuse";
+        writeErr(`hq doctor --fix: skipping hook-file repairs — uncommitted changes under ` +
+            `${HOOK_CONFIG_DIRS.join(", ")}. Refreshing sync journals still runs; ` +
+            `re-run with --force to repair hook files.\n`);
+        return allowed;
+    };
+    const refuseDirtyTree = () => {
+        writeErr(`hq doctor --fix: refusing to run — uncommitted changes under ` +
+            `${HOOK_CONFIG_DIRS.join(", ")}:\n` +
+            dirty.map((line) => `  ${line}`).join("\n") +
+            `\nCommit or stash them, or re-run with --force.\n`);
+        return empty({ exitCode: 1, refused: "dirty-tree" });
+    };
     // Resolve the customer-visible manual-only output gate once per fix run.
-    // Keep it behind the dirty-tree guard, and fail open to the pre-change
-    // output if the identity is absent or the registry lookup fails.
+    // Fail open to the pre-change output if the identity is absent or the
+    // registry lookup fails.
     let showManualOnlyRemediations = false;
     try {
         showManualOnlyRemediations =
@@ -172,7 +189,16 @@ export async function applyFixes(options) {
         ];
     };
     for (let pass = 1; pass <= MAX_FIX_PASSES; pass += 1) {
-        const plans = buildPlans(findings);
+        const plannedThisPass = refuseDirtyHookWrites(buildPlans(findings));
+        if (plannedThisPass === "refuse") {
+            if (planned.length === 0)
+                return refuseDirtyTree();
+            write(`Pass ${pass}/${MAX_FIX_PASSES}: remaining repairs write hook files; ` +
+                `stopped because the tree is dirty.\n`);
+            refused = "dirty-tree";
+            break;
+        }
+        const plans = plannedThisPass;
         if (plans.length === 0)
             break;
         fixableCount += plans.length;

package/dist/lib/lanes/spawn.js

@@ -677,6 +677,7 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
             ...lane,
             state: "queued",
             queued_reason: "account_retry",
+            queued_details: undefined,
             queued_at: at,
             terminal_reason: undefined,
             terminal_details: undefined,

package/dist/lib/lanes/store.js

@@ -386,6 +386,28 @@ function parseLaneStories(raw, filePath) {
         }
     }
 }
+/** Profile, disk, and admit details are only valid for their matching queue reason. */
+function queuedDetailsAreStale(state, queuedReason, detailsReason) {
+    if (detailsReason === "worker_profile_changed") {
+        return queuedReason !== "worker_profile_changed";
+    }
+    if (detailsReason === "low_disk") {
+        return state !== "queued" || queuedReason !== "low_disk";
+    }
+    if (detailsReason === "admit_failed") {
+        return state !== "queued" || queuedReason !== "admit_failed";
+    }
+    return false;
+}
+function withoutStaleQueuedDetails(record) {
+    const details = record.queued_details;
+    if (details === undefined)
+        return record;
+    if (!queuedDetailsAreStale(record.state, record.queued_reason, details.reason)) {
+        return record;
+    }
+    return { ...record, queued_details: undefined };
+}
 export function parseLaneRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Lane record must be a JSON object", {
@@ -638,7 +660,11 @@ export function parseLaneRecord(raw, filePath) {
             });
         }
         const detailsRecord = details;
-        if (detailsRecord.reason === "worker_profile_changed") {
+        if (queuedDetailsAreStale(raw.state, raw.queued_reason, detailsRecord.reason)) {
+            normalized = { ...raw };
+            delete normalized.queued_details;
+        }
+        else if (detailsRecord.reason === "worker_profile_changed") {
             if ((detailsRecord.expected_hash !== null && typeof detailsRecord.expected_hash !== "string") ||
                 typeof detailsRecord.actual_hash !== "string" || detailsRecord.actual_hash === "" ||
                 typeof detailsRecord.recovery_command !== "string" || detailsRecord.recovery_command.trim() === "") {
@@ -647,17 +673,6 @@ export function parseLaneRecord(raw, filePath) {
                     field: "queued_details",
                 });
             }
-            if (raw.queued_reason !== "worker_profile_changed") {
-                if (raw.queued_reason === undefined) {
-                    throw new LaneSchemaError("queued_details requires queued_reason worker_profile_changed", {
-                        path: filePath,
-                        field: "queued_details",
-                        queued_reason: raw.queued_reason,
-                    });
-                }
-                normalized = { ...raw };
-                delete normalized.queued_details;
-            }
         }
         else if (detailsRecord.reason === "outpost_dispatch_unknown") {
             if (raw.state !== "queued" ||
@@ -1505,10 +1520,10 @@ export function readAllLanes(hqRoot, deps = defaultStoreDeps()) {
             const identity = indexedDeps.outpostIdentity();
             const isRemoteMirror = outpostId !== undefined && (identity.kind === "not_outpost" ||
                 (identity.kind === "id" && identity.id !== outpostId));
-            if (!isRemoteMirror)
-                throw err;
             const field = typeof err.details.field === "string" ? err.details.field : "unknown_field";
-            process.stderr.write(`lanes store: skipping malformed mirrored lane ${laneId} field ${field}: ${err.message}\n`);
+            process.stderr.write(isRemoteMirror
+                ? `lanes store: skipping malformed mirrored lane ${laneId} field ${field}: ${err.message}\n`
+                : `lanes store: skipping unreadable lane ${laneId} field ${field}: ${err.message}\n`);
         }
     }
     return records.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
@@ -1631,13 +1646,14 @@ export function createLane(hqRoot, init, deps = defaultStoreDeps()) {
         senior_history: init.senior_history ?? [],
         attribution_history: init.attribution_history ?? [],
     };
-    parseLaneRecord(record, filePath);
+    const createdRecord = withoutStaleQueuedDetails(record);
+    parseLaneRecord(createdRecord, filePath);
     const created = withRecordLock(filePath, deps, () => {
         if (deps.existsSync(filePath)) {
             throw new LanesError("lane_exists", `Lane ${lane_id} already exists`, { lane_id });
         }
-        atomicWriteJson(filePath, record, deps);
-        return record;
+        atomicWriteJson(filePath, createdRecord, deps);
+        return createdRecord;
     });
     return syncStoryLedgerForLane(hqRoot, created, deps);
 }
@@ -1689,30 +1705,30 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
         }
         if (!isTerminalLaneState(current.state) && isTerminalLaneState(updated.state)) {
             const releasedGrant = updated.hire_grant ?? current.hire_grant ?? 0;
-            return {
+            return withoutStaleQueuedDetails({
                 ...updated,
                 released_hire_grant: releasedGrant,
                 hire_grant: 0,
-            };
+            });
         }
         if (isTerminalLaneState(current.state) && !isTerminalLaneState(updated.state) &&
             current.released_hire_grant !== undefined) {
-            return {
+            return withoutStaleQueuedDetails({
                 ...updated,
                 hire_grant: current.released_hire_grant,
                 released_hire_grant: undefined,
-            };
+            });
         }
         if (isTerminalLaneState(updated.state) &&
             (updated.hire_grant !== current.hire_grant ||
                 updated.released_hire_grant !== current.released_hire_grant)) {
-            return {
+            return withoutStaleQueuedDetails({
                 ...updated,
                 hire_grant: 0,
                 released_hire_grant: updated.released_hire_grant ?? updated.hire_grant ?? 0,
-            };
+            });
         }
-        return updated;
+        return withoutStaleQueuedDetails(updated);
     }, deps, {
         beforeWrite: (current) => assertLaneStoreWriteAllowed(current, laneId, writer),
         stamp: (current) => ({ written_by_version: newestLaneStoreVersion(current.written_by_version) }),

package/package.json

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