@indigoai-us/hq-cli 5.264.0 → 5.266.0

package/dist/lib/lanes/watcher.js

@@ -49,6 +49,7 @@ import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLane
 import { envelopeQuestionId } from "./questions.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
+import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
 import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
 import { queueLaneTerminalResume, queueManagerStatusGateResume } from "./keep-alive.js";
 import { monitorSessionDir } from "../monitor.js";
@@ -863,6 +864,72 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
     }
     return updated;
 }
+async function settleKrFreshness(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
+    if (manifestTurnId !== undefined && lane.status_gate !== undefined && lane.status_gate.turn_id !== manifestTurnId) {
+        logDecision({ event: "kr_freshness_baseline_mismatch", at, turn_id: lane.status_gate.turn_id });
+        return lane;
+    }
+    let errorLogged = false;
+    const resolution = await resolveKrFreshnessForLane(hqRoot, lane, {
+        readFlag: deps.readKrFreshnessFlag ?? readLanesRegistryFlag,
+        now: Date.parse(at),
+        onError: (error) => {
+            if (errorLogged)
+                return;
+            errorLogged = true;
+            const code = error instanceof LanesError ? error.error : "kr_freshness_unavailable";
+            process.stderr.write(`hq lanes watcher: KR freshness disabled for ${lane.lane_id}: ${code}\n`);
+            logDecision({ event: "kr_freshness_disabled", at, error: code });
+        },
+    });
+    if (!resolution.enabled || resolution.statusPath === undefined || resolution.error !== undefined)
+        return lane;
+    const stalled = resolution.kpis.filter((kpi) => kpi.verdict === "stalled");
+    if (stalled.length === 0) {
+        if (lane.kr_freshness_state === undefined)
+            return lane;
+        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => current.kr_freshness_state === undefined
+            ? current
+            : { ...current, kr_freshness_state: undefined });
+    }
+    const fingerprint = krFreshnessFingerprint(resolution.stalledKeys);
+    const names = stalled.map((kpi) => kpi.name);
+    const turnId = manifestTurnId ?? lane.status_gate?.turn_id ?? `unknown-${at}`;
+    const resumeText = `These KPIs in ${resolution.statusPath} were not re-measured in the last ${resolution.windowHours}h: ${names.join(", ")}. Measure each one now, update value and measured_at, then end the turn.`;
+    return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+        const history = current.status_gate_history ?? [];
+        if (history.some((entry) => entry.event === "kr_stalled" && entry.turn_id === turnId))
+            return current;
+        const sameStalledSet = current.kr_freshness_state?.stalled_fingerprint === fingerprint;
+        let nextLane = current;
+        let resumeQueued = false;
+        let resumeSkippedReason;
+        if (!sameStalledSet) {
+            const mergeExisting = current.pending_resume !== undefined &&
+                current.state !== "blocked" && current.state !== "awaiting_input";
+            const resume = queueLaneTerminalResume(current, at, resumeText, { mergeExisting });
+            nextLane = resume.lane;
+            resumeQueued = resume.resumeQueued;
+            resumeSkippedReason = resume.resumeSkippedReason;
+        }
+        const entry = {
+            event: "kr_stalled",
+            turn_id: turnId,
+            path: resolution.statusPath,
+            at,
+            names,
+            count: stalled.length,
+            fingerprint,
+            ...(resumeQueued ? { resume_queued: true } : {}),
+            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
+        };
+        return {
+            ...nextLane,
+            kr_freshness_state: { stalled_fingerprint: fingerprint },
+            status_gate_history: appendCappedHistory(history, entry),
+        };
+    });
+}
 function resolveBlockerFreshnessSessionInbox(hqRoot, sessionId) {
     let candidates;
     try {
@@ -1452,11 +1519,13 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                 if (terminalWrite.changed) {
                     updated = await settleManagerStatusGate(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
                     updated = await settleBlockerFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, mesh, logDecision);
+                    updated = await settleKrFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
                 }
                 const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
                     updated.status_gate_history?.some((entry) => entry.turn_id === manifest.turn_id &&
                         ((entry.event === "status_missed" && entry.resume_queued === true) ||
-                            (entry.event === "blocker_stale" && entry.resume_queued === true))) === true;
+                            (entry.event === "blocker_stale" && entry.resume_queued === true) ||
+                            (entry.event === "kr_stalled" && entry.resume_queued === true))) === true;
                 if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued) {
                     try {
                         if (dropboxInboxHasMessages(hqRoot, laneId)) {

package/package.json

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