@indigoai-us/hq-cli 5.345.49 → 5.345.50

package/dist/lib/lanes/keep-alive-audit.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS, doneKeepAliveVerdict, hasPendingKeepAliveWork, undeliveredAnsweredQuestions } from "./keep-alive.js";
+import { dropboxDir, dropboxInboxPath } from "./dropbox.js";
 import { LanesError } from "./errors.js";
 import { laneRunDir } from "./spawn.js";
 import { compareEnvelopeNames } from "./envelope-sequence.js";
@@ -63,6 +64,8 @@ const VERDICTS = [
     "keep_alive_off",
     "not_restarted",
     "stranded",
+    "finished_story",
+    "idle_no_queued_work",
     "waiting",
 ];
 function parseTime(value) {
@@ -174,7 +177,7 @@ export function readStopEnvelopes(hqRoot, laneId) {
         if (!isRecord(raw) || raw.schema_version !== "hq-lane-envelope.v1") {
             throw new LanesError("keep_alive_audit_envelope_invalid", `Lane envelope is not hq-lane-envelope.v1: ${file}`, { lane_id: laneId, path: file });
         }
-        const doneStop = raw.decision === "done" && raw.story_complete === false;
+        const doneStop = raw.decision === "done";
         const blockedStop = raw.decision === "blocked" && typeof raw.next_check_at === "string" &&
             isIsoDateTime(raw.next_check_at) && Date.parse(raw.next_check_at) > stat.mtimeMs;
         if (!doneStop && !blockedStop)
@@ -183,6 +186,7 @@ export function readStopEnvelopes(hqRoot, laneId) {
             name,
             mtimeMs: stat.mtimeMs,
             decision: blockedStop ? "blocked" : "done",
+            storyComplete: raw.story_complete === true,
             ...(typeof raw.next_check_at === "string" ? { nextCheckAt: raw.next_check_at } : {}),
         });
     }
@@ -428,6 +432,48 @@ function firstRestartAfter(lane, stop, nextEnvelopeMs, workerResumeEvents) {
     // untimed instead of using the lane's mutable current state as a proxy.
     return nextEnvelopeMs === undefined ? null : { at: null, trigger: "unknown", caller: null };
 }
+/**
+ * When the work a finished standing lane is now waiting on first appeared.
+ * The earliest signal wins: if work was queued at 10:05 and more arrived at
+ * 11:59, keep-alive has owed a launch since 10:05. Returns undefined when no
+ * signal carries a time, which leaves the caller unable to open a window.
+ */
+function keepAliveQueuedWorkAt(hqRoot, lane) {
+    const candidates = [];
+    const pendingAt = parseTime(lane.pending_resume?.at);
+    if (pendingAt !== undefined)
+        candidates.push(pendingAt);
+    for (const candidate of [dropboxInboxPath(hqRoot, lane.lane_id), dropboxDir(hqRoot, lane.lane_id)]) {
+        try {
+            candidates.push(fs.statSync(candidate).mtimeMs);
+            break;
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    const questions = [];
+    for (const questionId of listQuestionIds(hqRoot)) {
+        try {
+            const question = tryReadQuestion(hqRoot, questionId);
+            if (question)
+                questions.push(question);
+        }
+        catch {
+            // One unreadable question file must not fail the whole audit.
+            continue;
+        }
+    }
+    for (const question of undeliveredAnsweredQuestions(lane, questions)) {
+        const answeredAt = parseTime(question.answer?.answered_at);
+        if (answeredAt !== undefined)
+            candidates.push(answeredAt);
+    }
+    if (candidates.length === 0)
+        return undefined;
+    return Math.min(...candidates);
+}
 function classifyVerdict(input) {
     const { dueAt, restart, lane, nowMs } = input;
     if (restart?.trigger === "unknown" && laneWasKeepAliveOffAtStop(lane, input.stoppedAt))
@@ -478,6 +524,34 @@ function classifyVerdict(input) {
     }
     if (laneWasKeepAliveOffAtStop(lane, input.stoppedAt))
         return "keep_alive_off";
+    // Split the unrestarted stops by whether keep-alive owes this lane a wake at
+    // all. The discriminator is the shared done-state policy, not whether the
+    // envelope declared a next_check_at: a stop with story_complete false is owed
+    // a wake with or without one. Only done stops with no later envelope reach
+    // this branch, because a later envelope means the lane carried on.
+    if (input.decision === "done" && input.nextEnvelopeAt === undefined) {
+        const eligibility = doneKeepAliveVerdict(lane, {
+            decision: "done",
+            story_complete: input.storyComplete,
+            ...(input.nextCheckAt === undefined ? {} : { next_check_at: input.nextCheckAt }),
+        }, input.hasQueuedWork, { nowMs });
+        // Keep-alive is specified not to wake either case, so neither is a
+        // keep-alive liveness failure and neither counts against the KPI.
+        if (eligibility === "story_complete")
+            return "finished_story";
+        if (eligibility === "standing_idle")
+            return "idle_no_queued_work";
+        // A finished story becomes eligible again only once work is queued, which
+        // can be long after the stop. Open the failure window when that work
+        // appeared, not at the stop's own due time, or every normal exit from
+        // idle_no_queued_work reads as a liveness failure the moment it happens.
+        if (input.storyComplete) {
+            if (input.queuedWorkAt === undefined)
+                return "waiting";
+            const anchor = Math.max(dueAt, input.queuedWorkAt);
+            return nowMs > anchor + KEEP_ALIVE_NOT_RESTARTED_GRACE_MS ? "not_restarted" : "waiting";
+        }
+    }
     if (nowMs > dueAt + KEEP_ALIVE_NOT_RESTARTED_GRACE_MS)
         return "not_restarted";
     return "waiting";
@@ -546,6 +620,10 @@ export function buildKeepAliveAudit(input) {
         try {
             const { allMtimes, stops } = readStopEnvelopes(input.hqRoot, lane.lane_id);
             const keepAliveResumeEvents = readKeepAliveResumeEvents(input.hqRoot, lane.lane_id);
+            // Read at audit time, not stop time: for a stop with no restart the
+            // question is whether anything is going to resume the lane now.
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(input.hqRoot, lane);
+            const queuedWorkAt = hasQueuedWork ? keepAliveQueuedWorkAt(input.hqRoot, lane) : undefined;
             const laneWorkerResumeEvents = readLaneWorkerResumeEvents(input.hqRoot, lane.lane_id);
             const terminalClassifications = readTerminalClassifications(input.hqRoot, lane.lane_id);
             for (const stop of stops) {
@@ -572,7 +650,8 @@ export function buildKeepAliveAudit(input) {
                         blocked_outcome: blockedOutcome.status,
                         ...(blockedOutcome.reason === undefined ? {} : { blocked_outcome_reason: blockedOutcome.reason }),
                     } : {}),
-                    verdict: classifyVerdict({ dueAt: due.at, stoppedAt: stop.mtimeMs, nextCheckAt: stop.nextCheckAt, restart, lane, nowMs, resumeEvents: keepAliveResumeEvents, ...(nextEnvelopeMs === undefined ? {} : { nextEnvelopeAt: nextEnvelopeMs }), hqRoot: input.hqRoot }),
+                    verdict: classifyVerdict({ dueAt: due.at, stoppedAt: stop.mtimeMs, nextCheckAt: stop.nextCheckAt, restart, decision: stop.decision, storyComplete: stop.storyComplete, hasQueuedWork, ...(queuedWorkAt === undefined ? {} : { queuedWorkAt }), lane, nowMs, resumeEvents: keepAliveResumeEvents, ...(nextEnvelopeMs === undefined ? {} : { nextEnvelopeAt: nextEnvelopeMs }), hqRoot: input.hqRoot }),
+                    ...(stop.decision === "done" ? { queued_work_at_audit_time: hasQueuedWork } : {}),
                 });
             }
         }
@@ -611,6 +690,8 @@ export function buildKeepAliveAudit(input) {
             not_restarted: byVerdict.not_restarted,
             stranded: byVerdict.stranded,
             restarted_untimed: byVerdict.restarted_untimed,
+            finished_story: byVerdict.finished_story,
+            idle_no_queued_work: byVerdict.idle_no_queued_work,
             late_restarts_after_window: lateRestartsAfterWindow,
             late_over_10m: lateOverTenMinutes,
             early_wake_by_others: byVerdict.early_wake,
@@ -642,6 +723,7 @@ export function formatKeepAliveAuditText(result) {
         "",
         `Since ${result.since}; ${counts}`,
         `not_restarted=${result.summary.not_restarted}, stranded=${result.summary.stranded}, late_restarts_after_window=${result.summary.late_restarts_after_window}, late_over_10m=${result.summary.late_over_10m}, early_wake_by_others=${result.summary.early_wake_by_others}, self_wake=${result.summary.self_wake}`,
+        `finished_story=${result.summary.finished_story}, idle_no_queued_work=${result.summary.idle_no_queued_work} (neither counts against the keep-alive KPI)`,
         `Stopped and not restarted on their own: ${result.summary.stopped_and_not_restarted_on_their_own}`,
         ...result.rows.filter((row) => row.remediation).map((row) => `Stranded ${row.lane}: ${row.remediation}`),
         ...result.companyless_lead_lanes.map((lane) => `Company-less lead ${lane.lane} (${lane.project}): ${lane.reason}; repair with hq lanes repair-company ${lane.lane} --company <slug>`),

package/package.json

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