@indigoai-us/hq-cli 5.301.0 → 5.303.0

package/dist/lib/lanes/keep-alive.d.ts

@@ -1,6 +1,9 @@
-import type { LaneRecord, ManagerStatusGateHistoryEntry, QuestionRecord } from "./types.js";
+import { type LaneRecord, type ManagerStatusGateHistoryEntry, type QuestionRecord } from "./types.js";
 export declare const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export declare const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG = "lanes.keep-alive-next-check-at";
+export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
@@ -35,10 +38,17 @@ export type KeepAliveBlockedReason = NonNullable<LaneRecord["keep_alive_blocked_
 export interface KeepAliveDoneEnvelope {
     decision?: string;
     story_complete?: boolean;
+    next_check_at?: string;
 }
-export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complete";
+export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complete" | "next_check_at";
+export declare function keepAliveNextCheckAtMs(value: unknown, nowMs: number, anchorMs?: number): number | undefined;
 /** Shared done-state policy used by watch, reconcile, and the show command. */
-export declare function doneKeepAliveVerdict(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean): DoneKeepAliveVerdict | null;
+export declare function doneKeepAliveVerdict(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean, options?: {
+    nextCheckAtEnabled?: boolean;
+    hasPendingWork?: boolean;
+    nowMs?: number;
+    nextCheckAnchorMs?: number;
+}): DoneKeepAliveVerdict | null;
 export declare function canResumeDoneKeepAliveLane(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean): boolean;
 /** Work signals already persisted for a lane that ended its turn. */
 export declare function hasPendingKeepAliveWork(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "pending_resume">, questionRecords?: readonly QuestionRecord[]): boolean;

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

@@ -3,8 +3,12 @@ import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { dropboxInboxHasMessages } from "./dropbox.js";
 import { appendCappedHistory, listQuestionIds, readQuestion, retryUpdateLane } from "./store.js";
+import { isIsoDateTime } from "./types.js";
 export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG = "lanes.keep-alive-next-check-at";
+export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS = 24 * 60 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
@@ -98,15 +102,35 @@ export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText)
 export const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT = "You ended blocked with no pending question. Record the event you wait on in waiting_on, re-check each blocker, and continue the next unblocked story.";
 export const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export function keepAliveNextCheckAtMs(value, nowMs, anchorMs = nowMs) {
+    if (typeof value !== "string" || !isIsoDateTime(value))
+        return undefined;
+    const parsed = Date.parse(value);
+    if (parsed <= nowMs)
+        return undefined;
+    const stableAnchorMs = Number.isFinite(anchorMs) ? anchorMs : nowMs;
+    const capped = Math.min(parsed, stableAnchorMs + LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS);
+    return capped > nowMs ? capped : undefined;
+}
 /** Shared done-state policy used by watch, reconcile, and the show command. */
-export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork) {
+export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork, options = {}) {
     if (envelope.decision !== "done")
         return null;
+    let verdict;
     if (envelope.story_complete !== true)
-        return "eligible";
-    if (lane.keep_alive_standing !== true)
-        return "story_complete";
-    return hasQueuedWork ? "eligible" : "standing_idle";
+        verdict = "eligible";
+    else if (lane.keep_alive_standing !== true)
+        verdict = "story_complete";
+    else
+        verdict = hasQueuedWork ? "eligible" : "standing_idle";
+    if (verdict === "eligible" && options.nextCheckAtEnabled === true && options.hasPendingWork !== true) {
+        const nowMs = options.nowMs ?? Date.now();
+        const anchorMs = options.nextCheckAnchorMs ?? nowMs;
+        const nextCheckAtMs = keepAliveNextCheckAtMs(envelope.next_check_at, nowMs, anchorMs);
+        if (nextCheckAtMs !== undefined)
+            return "next_check_at";
+    }
+    return verdict;
 }
 export function canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork) {
     return doneKeepAliveVerdict(lane, envelope, hasQueuedWork) === "eligible";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -105,6 +105,11 @@ export declare function buildOutpostQuestionListCommand(input?: {
 }): string;
 /** Read one question's body and owner-computed audience from its Outpost. */
 export declare function buildOutpostQuestionShowCommand(questionId: string): string;
+/** Cancel an owner-hosted question through the existing questions command. */
+export declare function buildOutpostQuestionCancelCommand(input: {
+    questionId: string;
+    reason: string;
+}): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -113,6 +113,18 @@ export function buildOutpostQuestionShowCommand(questionId) {
         questionId,
     ]));
 }
+/** Cancel an owner-hosted question through the existing questions command. */
+export function buildOutpostQuestionCancelCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "cancel",
+        input.questionId,
+        "--reason",
+        input.reason,
+    ]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([

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

@@ -24,6 +24,7 @@ export declare const RECONCILE_LOCK_TIMEOUT_MS = 5000;
 /** A pickup probe that has not cleared its marker within this window is abandoned. */
 export declare const PICKUP_VALIDATION_MAX_AGE_MS: number;
 export declare const PICKUP_VALIDATION_TIMEOUT_REASON: "pickup_validation_timeout";
+export declare const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 export declare const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export declare const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
 export interface ReconcileSkip {