@indigoai-us/hq-cli 5.311.0 → 5.311.2

package/dist/lib/bot/runtime/windows.js

@@ -8,7 +8,7 @@ function envValue(env, name) {
     return key ? env[key] : undefined;
 }
 /** Resolve an npm-installed provider command using Windows PATH and PATHEXT. */
-function resolveWindowsExecutable(name, env, existsSync = fs.existsSync, cwd = process.cwd()) {
+export function resolveWindowsExecutable(name, env, existsSync = fs.existsSync, cwd = process.cwd()) {
     const pathValue = envValue(env, "PATH") ?? "";
     const rawExtensions = (envValue(env, "PATHEXT") || DEFAULT_PATHEXT)
         .split(";")

package/dist/lib/flag-registry.d.ts

@@ -7,6 +7,7 @@
  */
 import { type WorkerOptions } from "node:worker_threads";
 import { createFlagClient, type FlagClient, type FlagLookupOptions, type FlagSnapshot } from "@indigoai-us/hq-flags-client";
+type FlagRegistrySentry = Pick<typeof import("@sentry/node"), "captureException" | "withScope">;
 export { resolveProcessFlagCompanyContext } from "./process-flag-company-context.js";
 export type { ProcessFlagCompanyContext } from "./process-flag-company-context.js";
 export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
@@ -20,6 +21,7 @@ interface WorkerLike {
 export interface FlagRegistryDependencies {
     endpoint?: string;
     createWorker?: (filename: string | URL, options: WorkerOptions) => WorkerLike;
+    sentry?: FlagRegistrySentry;
     /** Test seam for exercising the no-source fail-open path. */
     workerSource?: string;
     captureWorkerFailure?: (error: Error, tags: Record<string, string>) => void;

package/dist/lib/flag-registry.js

@@ -6,12 +6,16 @@
  * keep a short-lived, offline CLI alive until the client's network deadline.
  */
 import { Worker } from "node:worker_threads";
-import * as Sentry from "@sentry/node";
 import { createFlagClient, isFlagSnapshot, readLocalOverride, resolveFlag, } from "@indigoai-us/hq-flags-client";
 import { resolveFlagRegistryEndpoint, } from "./flag-registry-endpoint.js";
 import { FLAG_REGISTRY_WORKER_SOURCE } from "./flag-registry-worker-source.generated.js";
 import { resolveProcessFlagCompanyContext } from "./process-flag-company-context.js";
 import { writeFlagSnapshotFile } from "./flag-snapshot-file.js";
+function captureFlagRegistryException(error, tags, sentry) {
+    if (!sentry)
+        return;
+    sentry.captureException(error, { tags });
+}
 export { resolveProcessFlagCompanyContext } from "./process-flag-company-context.js";
 export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
@@ -58,6 +62,7 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
         return processReader;
     const endpoint = resolveFlagRegistryEndpoint(dependencies.endpoint, process.env);
     const company = resolveProcessFlagCompanyContext();
+    const sentry = dependencies.sentry;
     const companyUid = company.companyUid;
     const companyIdentifiers = [companyUid, company.companySlug].filter((value) => Boolean(value));
     processReader = processSnapshotReader(companyIdentifiers);
@@ -65,7 +70,7 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
         const embeddedSource = dependencies.workerSource ?? FLAG_REGISTRY_WORKER_SOURCE;
         if (embeddedSource.length === 0) {
             (dependencies.captureWorkerFailure ?? ((error, tags) => {
-                Sentry.captureException(error, { tags });
+                captureFlagRegistryException(error, tags, sentry);
             }))(new Error("Self-contained flag-registry worker source is unavailable"), {
                 component: "flag-registry-worker-startup",
                 worker: "flag-registry",
@@ -87,10 +92,14 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
         // its process-wide captureWorkerErrors option is disabled. Scope only this
         // worker so the reporting boundary can classify its startup errors without
         // changing capture for unrelated workers.
-        const worker = Sentry.withScope((scope) => {
-            scope.setTag("worker", "flag-registry");
-            return (dependencies.createWorker ?? ((filename, options) => new Worker(filename, options)))(embeddedSource, workerOptions);
-        });
+        const createWorker = dependencies.createWorker ??
+            ((filename, options) => new Worker(filename, options));
+        const worker = sentry
+            ? sentry.withScope((scope) => {
+                scope.setTag("worker", "flag-registry");
+                return createWorker(embeddedSource, workerOptions);
+            })
+            : createWorker(embeddedSource, workerOptions);
         worker.on("message", (value) => {
             if (isFlagSnapshot(value)) {
                 heldSnapshot = value;
@@ -99,12 +108,10 @@ export function kickFlagRegistryReadiness(dependencies = {}) {
                         writeFlagSnapshotFile(companyUid, value.flags);
                     }
                     catch (error) {
-                        Sentry.captureException(error, {
-                            tags: {
-                                component: "flag-snapshot-cache-write",
-                                company_uid_present: "true",
-                            },
-                        });
+                        captureFlagRegistryException(error instanceof Error ? error : new Error(String(error)), {
+                            component: "flag-snapshot-cache-write",
+                            company_uid_present: "true",
+                        }, sentry);
                     }
                 }
             }

package/dist/lib/lanes/autopilot.js

@@ -154,7 +154,7 @@ function projectStories(hqRoot, relativePath, companySlug, projectId) {
             status,
             ...(story.passes === true ? { passes: true } : {}),
             ...(briefPath ? { briefPath } : {}),
-            ...(Array.isArray(story.lanes) ? { laneIds: story.lanes.map((lane) => typeof lane === "string" ? lane : lane.lane_id) } : typeof story.lane === "string" && story.lane.trim() ? { laneIds: [story.lane] } : story.lane === "" ? { laneIds: [] } : {}),
+            ...storyLaneIds(story),
             ...(typeof story.updated_at === "string" ? { updatedAt: story.updated_at } : {}),
             ...(typeof story.external_blocker === "string" ? { externalBlocker: story.external_blocker } : {}),
         };
@@ -207,6 +207,18 @@ function parseOkrReports(status) {
         return { at: value.at, kpis: parseLines(value.kpis, "KPI"), okrs: parseLines(value.okrs, "OKR") };
     }).sort((a, b) => a.at.localeCompare(b.at));
 }
+// A story's current `lane` counts alongside its `lanes` history, so `lanes: []` with `lane: X` is assigned to X.
+function storyLaneIds(story) {
+    const history = Array.isArray(story.lanes)
+        ? story.lanes.map((lane) => typeof lane === "string" ? lane : lane.lane_id)
+        : undefined;
+    const current = typeof story.lane === "string" && story.lane.trim() ? story.lane : undefined;
+    if (history)
+        return { laneIds: current && !history.includes(current) ? [...history, current] : history };
+    if (current)
+        return { laneIds: [current] };
+    return story.lane === "" ? { laneIds: [] } : {};
+}
 function statusBlockers(status) {
     const raw = status.blockers;
     if (raw === undefined)
@@ -256,7 +268,9 @@ export function planLeadAutopilotWakes(input) {
         const finishedMs = Date.parse(story.updatedAt);
         if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
             return [];
-        return story.laneIds.filter((laneId) => !knownChildIds.has(laneId)).map((laneId) => ({ laneId, story, finishedAt: story.updatedAt }));
+        // The lead's own lane is never a finished worker of itself.
+        return story.laneIds.filter((laneId) => laneId !== lead.lane_id && !knownChildIds.has(laneId))
+            .map((laneId) => ({ laneId, story, finishedAt: story.updatedAt }));
     });
     const overdueReviews = [...finishedReviews, ...missingReviews].sort((a, b) => a.laneId.localeCompare(b.laneId));
     if (overdueReviews.length > 0) {
@@ -351,6 +365,9 @@ export function planLeadAutopilotWakes(input) {
         if (story.status !== "in_progress")
             return [];
         const laneIds = story.laneIds ?? [];
+        // A story assigned to the lead itself is worked by the lead, which is the lane being woken.
+        if (laneIds.includes(lead.lane_id))
+            return [];
         const live = laneIds.filter((laneId) => children.some((child) => child.lane_id === laneId && LIVE_STATES.has(child.state)));
         if (live.length > 0)
             return [];

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

@@ -137,6 +137,7 @@ export type LaunchTrigger = {
     text: string;
     message_id: string;
     monitor_event?: true;
+    system_notice?: true;
 } | {
     /** `hq lanes resume`: the operator's explicit opt-in to continue an exited lane. */
     kind: "resume";

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

@@ -1,8 +1,6 @@
 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;
@@ -30,6 +28,7 @@ export declare function queueLaneTerminalResume(current: LaneRecord, at: string,
     allowResume?: boolean;
     mergeExisting?: boolean;
     allowBlockedResume?: boolean;
+    trigger?: "resume" | "watcher";
 }): LaneTerminalResumeResult;
 /** Persist a manager status miss and queue its one bounded follow-up turn. */
 export declare function queueManagerStatusGateResume(hqRoot: string, laneId: string, entry: Omit<ManagerStatusGateHistoryEntry, "event" | "resume_queued" | "resume_skipped_reason">, resumeText: string): LaneRecord;
@@ -47,7 +46,6 @@ export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complet
 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, options?: {
-    nextCheckAtEnabled?: boolean;
     hasPendingWork?: boolean;
     nowMs?: number;
     nextCheckAnchorMs?: number;

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

@@ -6,8 +6,6 @@ import { appendCappedHistory, listQuestionIds, readQuestion, retryUpdateLane } f
 import { isTerminalLaneState, 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;
@@ -63,7 +61,7 @@ export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
             terminal_details: undefined,
             pending_resume: {
                 session_id: sessionId,
-                trigger: "resume",
+                trigger: options.trigger ?? "watcher",
                 resumed_from: current.state,
                 text: resumeText,
                 compact: true,
@@ -126,7 +124,7 @@ export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork, options = {}
         verdict = "story_complete";
     else
         verdict = hasQueuedWork ? "eligible" : "standing_idle";
-    if (verdict === "eligible" && options.nextCheckAtEnabled === true && options.hasPendingWork !== true) {
+    if (verdict === "eligible" && options.hasPendingWork !== true) {
         const nowMs = options.nowMs ?? Date.now();
         const anchorMs = options.nextCheckAnchorMs ?? nowMs;
         const nextCheckAtMs = keepAliveNextCheckAtMs(envelope.next_check_at, nowMs, anchorMs);

package/dist/lib/lanes/reconcile.js

@@ -25,7 +25,7 @@ import { readLanesRegistryFlag } from "./registry-flag.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -1087,7 +1087,6 @@ export async function runPassBody(hqRoot, deps) {
         }
     }));
     const keepAliveFlagCompanies = new Map();
-    const nextCheckAtFlagCompanyKeys = new Set();
     for (const lane of lanes) {
         if (!(lane.state === "done" || lane.state === "interrupted" || lane.state === "blocked" || lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") ||
             (lane.keep_alive !== true && lane.worker_profile === undefined) ||
@@ -1098,26 +1097,25 @@ export async function runPassBody(hqRoot, deps) {
                 !providerSupportsSessionResume(lane.provider) ||
                 !(lane.provider_session_id ?? lane.last_resume?.session_id))))
             continue;
-        let hasNextCheckAt = false;
         if (lane.state === "done") {
             const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
             if (!envelope || envelope.decision !== "done")
                 continue;
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
-            if (doneKeepAliveVerdict(lane, envelope, hasQueuedWork) !== "eligible")
+            if (doneKeepAliveVerdict(lane, envelope, hasQueuedWork, {
+                hasPendingWork: hasPendingKeepAliveWork(hqRoot, lane, questions),
+                nowMs: now.getTime(),
+                nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
+            }) !== "eligible")
                 continue;
-            hasNextCheckAt = envelope.next_check_at !== undefined;
         }
         const company = resolveLaneCompany(hqRoot, lane).company;
         if (company === null)
             continue;
         const key = keepAliveCompanyKey(company);
         keepAliveFlagCompanies.set(key, company);
-        if (hasNextCheckAt)
-            nextCheckAtFlagCompanyKeys.add(key);
     }
     const keepAliveFlagByCompany = new Map();
-    const nextCheckAtFlagByCompany = new Map();
     const blockedResumeFlagByCompany = new Map();
     const immediateFirstResumeFlagByCompany = new Map();
     const supersessionLineageAwareByCompany = new Map();
@@ -1130,11 +1128,8 @@ export async function runPassBody(hqRoot, deps) {
             lane.keep_alive === true &&
             laneRunsHere(lane, startDeps.host) &&
             keepAliveCompanyKey(resolveLaneCompany(hqRoot, lane).company) === key);
-        const [keepAliveEnabled, nextCheckAtEnabled, lineageAware, blockedResumeEnabled, immediateFirstResumeEnabled] = await Promise.all([
+        const [keepAliveEnabled, lineageAware, blockedResumeEnabled, immediateFirstResumeEnabled] = await Promise.all([
             readRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
-            nextCheckAtFlagCompanyKeys.has(key)
-                ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, options)
-                : Promise.resolve(false),
             readRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, options),
             hasBlockedKeepAliveLane
                 ? readRegistryFlag(LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, options)
@@ -1142,7 +1137,6 @@ export async function runPassBody(hqRoot, deps) {
             readRegistryFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
         ]);
         keepAliveFlagByCompany.set(key, keepAliveEnabled);
-        nextCheckAtFlagByCompany.set(key, nextCheckAtEnabled);
         blockedResumeFlagByCompany.set(key, blockedResumeEnabled);
         immediateFirstResumeFlagByCompany.set(key, immediateFirstResumeEnabled);
         supersessionLineageAwareByCompany.set(key, lineageAware);
@@ -1165,7 +1159,7 @@ export async function runPassBody(hqRoot, deps) {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
         await closeInterruptedDoneStoryWorkers(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, storyCloseEnabledByCompany);
-        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
@@ -2188,7 +2182,7 @@ async function resumeBlockedKeepAlive(hqRoot, lane, questions, summary, deps, no
         current = afterPreparation;
     }
     const expectedVersion = current.version;
-    const result = queueLaneTerminalResume(current, now.toISOString(), LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, { allowBlockedResume: true });
+    const result = queueLaneTerminalResume(current, now.toISOString(), LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, { allowBlockedResume: true, trigger: "resume" });
     if (!result.resumeQueued) {
         if (result.resumeSkippedReason !== undefined) {
             summary.skipped.push({ kind: "lane", id: lane.lane_id, why: "keep_alive_" + result.resumeSkippedReason });
@@ -2244,7 +2238,7 @@ function appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, at, reason, dep
         }),
     }), false);
 }
-async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, nextCheckAtFlagByCompany, immediateFirstResumeFlagByCompany) {
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -2291,13 +2285,9 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
             if (!envelope || envelope.decision !== "done")
                 continue;
-            const nextCheckAtEnabled = nextCheckAtFlagByCompany.get(keepAliveCompanyKey(companyForLane(lane))) === true;
-            const hasPendingWork = lane.keep_alive_standing === true || nextCheckAtEnabled
-                ? hasPendingKeepAliveWork(hqRoot, lane, questions)
-                : false;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, lane, questions);
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingWork;
             const verdict = doneKeepAliveVerdict(lane, envelope, hasQueuedWork, {
-                nextCheckAtEnabled,
                 hasPendingWork,
                 nowMs,
                 nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
@@ -2415,13 +2405,9 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
             if (!latest || latest.envelope.decision !== "done")
                 continue;
-            const nextCheckAtEnabled = nextCheckAtFlagByCompany.get(keepAliveCompanyKey(companyForLane(lane))) === true;
-            const hasPendingWork = lane.keep_alive_standing === true || nextCheckAtEnabled
-                ? hasPendingKeepAliveWork(hqRoot, lane, questions)
-                : false;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, lane, questions);
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingWork;
             const verdict = doneKeepAliveVerdict(lane, latest.envelope, hasQueuedWork, {
-                nextCheckAtEnabled,
                 hasPendingWork,
                 nowMs,
                 nextCheckAnchorMs: Date.parse(lane.last_envelope?.at ?? lane.updated_at),
@@ -2507,13 +2493,9 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id);
             if (!currentEnvelope || currentEnvelope.envelope.decision !== "done")
                 continue;
-            const nextCheckAtEnabled = nextCheckAtFlagByCompany.get(keepAliveCompanyKey(companyForLane(current))) === true;
-            const hasPendingWork = current.keep_alive_standing === true || nextCheckAtEnabled
-                ? hasPendingKeepAliveWork(hqRoot, current, questions)
-                : false;
+            const hasPendingWork = hasPendingKeepAliveWork(hqRoot, current, questions);
             const hasQueuedWork = current.keep_alive_standing === true && hasPendingWork;
             const verdict = doneKeepAliveVerdict(current, currentEnvelope.envelope, hasQueuedWork, {
-                nextCheckAtEnabled,
                 hasPendingWork,
                 nowMs,
                 nextCheckAnchorMs: Date.parse(current.last_envelope?.at ?? current.updated_at),
@@ -2794,12 +2776,8 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
                 const envelope = readLatestEnvelopeRecord(hqRoot, latest.lane_id);
                 if (!envelope || envelope.envelope.decision !== "done")
                     continue;
-                const nextCheckAtEnabled = nextCheckAtFlagByCompany.get(keepAliveCompanyKey(companyForLane(latest))) === true;
-                const hasPendingWork = latest.keep_alive_standing === true || nextCheckAtEnabled
-                    ? hasPendingKeepAliveWork(hqRoot, latest, questions)
-                    : false;
+                const hasPendingWork = hasPendingKeepAliveWork(hqRoot, latest, questions);
                 const finalDoneVerdict = doneKeepAliveVerdict(latest, envelope.envelope, latest.keep_alive_standing === true && hasPendingWork, {
-                    nextCheckAtEnabled,
                     hasPendingWork,
                     nowMs,
                     nextCheckAnchorMs: Date.parse(latest.last_envelope?.at ?? latest.updated_at),

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

@@ -198,6 +198,8 @@ export declare function resumePrompt(input: {
     answers?: AnsweredQuestionLine[];
     /** `hq lanes resume`: the state the operator resumed the lane from. */
     resumedFrom?: string;
+    /** Automatic continuation initiated by the lane watcher. */
+    resumeSource?: "watcher";
     /** Exact validator errors recorded after the prior envelope repair failed. */
     envelopeRepairErrors?: {
         first_error: string;

package/dist/lib/lanes/spawn.js

@@ -372,7 +372,18 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
     if (last.trigger === "answered_questions") {
         return { session_id: sessionId, trigger: "answered_questions", at, ...compact, ...keepAlive };
     }
-    if (last.trigger === "message") {
+    if (last.trigger === "watcher") {
+        return {
+            session_id: sessionId,
+            trigger: "watcher",
+            resumed_from: last.resumed_from ?? "interrupted",
+            ...(last.text !== undefined ? { text: last.text } : {}),
+            at,
+            ...compact,
+            ...keepAlive,
+        };
+    }
+    if (last.trigger === "message" || last.trigger === "monitor_event" || last.trigger === "system_notice") {
         if (last.message_id === undefined) {
             throw new LanesError("account_retry_context_missing", `The message id needed to resume lane ${lane.lane_id} is missing`, { lane_id: lane.lane_id, trigger: last.trigger });
         }
@@ -382,9 +393,10 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
         }
         return {
             session_id: sessionId,
-            trigger: "message",
+            trigger: last.trigger === "message" && last.monitor_event === true ? "monitor_event" : last.trigger,
             text,
             message_id: last.message_id,
+            ...(last.monitor_event === true || last.trigger === "monitor_event" ? { monitor_event: true } : {}),
             at,
             ...compact,
             ...keepAlive,
@@ -1071,7 +1083,7 @@ export function readAnsweredQuestionLines(answersPath) {
 export function resumePrompt(input) {
     const parts = [];
     if (input.resumedFrom !== undefined) {
-        parts.push(`The operator resumed this lane from state ${input.resumedFrom}. ` +
+        parts.push(`${input.resumeSource === "watcher" ? "The lane watcher" : "The operator"} resumed this lane from state ${input.resumedFrom}. ` +
             (input.resumedFrom === "interrupted"
                 ? "The previous run ended without writing its envelope; continue the work from where it stopped."
                 : "Continue the work from where the previous run stopped."));
@@ -1743,7 +1755,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const profileChanged = profile !== undefined && existing.worker_profile_hash !== profile.contentHash;
     const config = loadLanesConfig(hqRoot);
     const repairRecordedAccount = plan.mode === "resume" &&
-        (trigger.kind === "resume" || pendingResume?.trigger === "resume");
+        (trigger.kind === "resume" || pendingResume?.trigger === "resume" || pendingResume?.trigger === "watcher");
     const recordedModel = repairRecordedAccount && existing.model_source === "account"
         ? existing.model
         : undefined;
@@ -1919,6 +1931,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                         ? pendingResume.text
                         : undefined,
                 resumedFrom: trigger.kind === "resume" ? trigger.from : pendingResume?.resumed_from,
+                resumeSource: pendingResume?.trigger === "watcher" ? "watcher" : undefined,
                 answersPath: answeredLines !== undefined ? answersPath : undefined,
                 answers: answeredLines,
                 envelopeRepairErrors: lane.terminal_reason === ENVELOPE_INVALID_REASON &&
@@ -2019,14 +2032,24 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const nowIso = (deps.now ?? (() => new Date()))().toISOString();
     const resumeHistoryTrigger = pendingResume?.keep_alive === true
         ? "keep_alive"
-        : pendingResume?.trigger === "message" || trigger.kind === "message"
-            ? "message"
-            : pendingResume?.trigger === "resume" || trigger.kind === "resume"
-                ? "resume_cli"
-                : "reconcile";
+        : pendingResume?.trigger === "monitor_event" || pendingResume?.monitor_event === true ||
+            (trigger.kind === "message" && trigger.monitor_event === true)
+            ? "monitor_event"
+            : pendingResume?.trigger === "system_notice" ||
+                (trigger.kind === "message" && trigger.system_notice === true)
+                ? "system_notice"
+                : pendingResume?.trigger === "watcher"
+                    ? "watcher"
+                    : pendingResume?.trigger === "message" || trigger.kind === "message"
+                        ? "message"
+                        : pendingResume?.trigger === "resume" || trigger.kind === "resume"
+                            ? "resume_cli"
+                            : "reconcile";
     const resumeHistoryCaller = pendingResume?.caller ||
-        (typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "") ||
-        (trigger.kind === "answered_questions" || trigger.kind === "resume" || trigger.kind === "message"
+        (pendingResume?.trigger !== "watcher" && typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "") ||
+        (pendingResume?.trigger === "message" || pendingResume?.trigger === "monitor_event" ||
+            pendingResume?.trigger === "system_notice" || trigger.kind === "answered_questions" ||
+            trigger.kind === "resume" || trigger.kind === "message"
             ? "user"
             : undefined);
     let statusGateHeartbeat;
@@ -2159,7 +2182,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 session_id: resume.session_id,
                 at: nowIso,
                 account: resolved.id,
-                trigger: trigger.kind,
+                trigger: trigger.kind === "message" && trigger.system_notice === true ? "system_notice" : trigger.kind,
                 ...(trigger.kind === "message"
                     ? {
                         message_id: trigger.message_id,

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

@@ -766,7 +766,7 @@ export interface FailedResumeHistoryEntry {
 export interface PendingResume {
     /** Fresh answered-question launches need no previous session id. */
     session_id?: string;
-    trigger: "answered_questions" | "message" | "resume";
+    trigger: "answered_questions" | "message" | "monitor_event" | "system_notice" | "resume" | "watcher";
     /** True when this queued resume was initiated automatically by keep-alive. */
     keep_alive?: true;
     resumed_from?: "interrupted" | "done" | "blocked" | "failed" | "awaiting_input";
@@ -797,7 +797,7 @@ export interface LaneResumeRecord {
     at: string;
     /** Account the resumed run was bound to. */
     account?: string;
-    trigger: "answered_questions" | "message" | "resume";
+    trigger: "answered_questions" | "message" | "monitor_event" | "system_notice" | "resume" | "watcher";
     /** True when this was an automatic keep-alive resume. */
     keep_alive?: true;
     message_id?: string;

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

@@ -23,7 +23,6 @@ export interface LaneWatchDeps {
     readQuestion?: (hqRoot: string, questionId: string) => QuestionRecord | null;
     readAccountStatuses?: (lanes: readonly LaneRecord[]) => Promise<readonly LaneWatchAccountStatus[]>;
     keepAliveEnabled?: (lane: LaneRecord) => boolean | Promise<boolean>;
-    keepAliveNextCheckAtEnabled?: (lane: LaneRecord) => boolean | Promise<boolean>;
     sleep?: (ms: number) => Promise<void>;
     intervalMs?: number;
     maxOutputLines?: number;

package/dist/lib/lanes/watch.js

@@ -32,7 +32,7 @@ function validateLaneIds(laneIds) {
     }
     return unique;
 }
-function canResumeKeepAliveLane(hqRoot, lane, nextCheckAtEnabled = false, nowMs = Date.now()) {
+function canResumeKeepAliveLane(hqRoot, lane, nowMs = Date.now()) {
     if (lane.keep_alive !== true ||
         lane.keep_alive_opted_in_at === undefined ||
         !Number.isFinite(Date.parse(lane.keep_alive_opted_in_at)) ||
@@ -49,10 +49,8 @@ function canResumeKeepAliveLane(hqRoot, lane, nextCheckAtEnabled = false, nowMs
         return lane.terminal_reason === "exited_with_partial_output";
     }
     if (lane.state === "done") {
-        const hasPendingWork = lane.keep_alive_standing === true || nextCheckAtEnabled
-            ? hasPendingKeepAliveWork(hqRoot, lane)
-            : false;
-        const nextCheckAtMs = nextCheckAtEnabled && !hasPendingWork
+        const hasPendingWork = hasPendingKeepAliveWork(hqRoot, lane);
+        const nextCheckAtMs = !hasPendingWork
             ? keepAliveNextCheckAtMs(lane.last_envelope?.next_check_at, nowMs, Date.parse(lane.last_envelope?.at ?? lane.updated_at))
             : undefined;
         if (nextCheckAtMs !== undefined && nowMs < nextCheckAtMs)
@@ -143,10 +141,7 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
                     continue;
                 if (!await deps.keepAliveEnabled(record))
                     continue;
-                const nextCheckAtEnabled = deps.keepAliveNextCheckAtEnabled === undefined
-                    ? false
-                    : await deps.keepAliveNextCheckAtEnabled(record);
-                if (canResumeKeepAliveLane(hqRoot, record, nextCheckAtEnabled))
+                if (canResumeKeepAliveLane(hqRoot, record))
                     keepAliveWaiting.add(record.lane_id);
             }
         }

package/dist/main.js

@@ -201,7 +201,7 @@ export async function runCli() {
     const isAuthLogin = process.argv[2] === "auth" && process.argv[3] === "login";
     if (!isAuthLogin) {
         runGlobalNetworkLifecycle(process.argv, () => {
-            void kickFlagRegistryReadiness();
+            void kickFlagRegistryReadiness({ sentry: Sentry });
         });
     }
     // Set when a self-update re-exec'd this command on a newer CLI: the child

package/dist/node-network-compat-core.d.ts

@@ -0,0 +1,12 @@
+/** Node network defaults shared by the full graph and the selective fast path. */
+export declare const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
+export interface NodeNetworkCompatibilityOptions {
+    nodeOptions?: string;
+    execArgv?: readonly string[];
+    /** Inject the net timeout setter (tests). Pass null to simulate a runtime without it. */
+    setAttemptTimeout?: ((milliseconds: number) => void) | null;
+}
+export declare function configureNodeNetworkCompatibility(options?: NodeNetworkCompatibilityOptions): boolean;
+/** Apply at most once when both entrypoint routing layers import this module. */
+export declare function configureNodeNetworkCompatibilityOnce(): boolean;
+//# sourceMappingURL=node-network-compat-core.d.ts.map

package/dist/node-network-compat-core.js

@@ -0,0 +1,41 @@
+/** Node network defaults shared by the full graph and the selective fast path. */
+import * as nodeNet from "node:net";
+export const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
+const ATTEMPT_TIMEOUT_OPTION = "--network-family-autoselection-attempt-timeout";
+function hasExplicitAttemptTimeout(nodeOptions, execArgv) {
+    const optionPattern = new RegExp("(?:^|\\s)" + ATTEMPT_TIMEOUT_OPTION + "(?:=|\\s|$)");
+    return (optionPattern.test(nodeOptions) ||
+        execArgv.some((argument) => argument === ATTEMPT_TIMEOUT_OPTION ||
+            argument.startsWith(ATTEMPT_TIMEOUT_OPTION + "=")));
+}
+function resolveSetAttemptTimeout(override) {
+    if (override === null)
+        return undefined;
+    if (override)
+        return override;
+    const fn = nodeNet.setDefaultAutoSelectFamilyAttemptTimeout;
+    return typeof fn === "function" ? fn.bind(nodeNet) : undefined;
+}
+export function configureNodeNetworkCompatibility(options = {}) {
+    const nodeOptions = options.nodeOptions ?? process.env.NODE_OPTIONS ?? "";
+    const execArgv = options.execArgv ?? process.execArgv;
+    if (hasExplicitAttemptTimeout(nodeOptions, execArgv)) {
+        return false;
+    }
+    const setAttemptTimeout = resolveSetAttemptTimeout(options.setAttemptTimeout);
+    if (!setAttemptTimeout) {
+        // Runtime lacks the API; the Node preflight should already have exited.
+        return false;
+    }
+    setAttemptTimeout(HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS);
+    return true;
+}
+let configurationAttempted = false;
+/** Apply at most once when both entrypoint routing layers import this module. */
+export function configureNodeNetworkCompatibilityOnce() {
+    if (configurationAttempted)
+        return false;
+    configurationAttempted = true;
+    return configureNodeNetworkCompatibility();
+}
+//# sourceMappingURL=node-network-compat-core.js.map

package/dist/node-network-compat-fast.d.ts

@@ -0,0 +1,7 @@
+/** Selective Node network setup for the entrypoint's fast routes. */
+/**
+ * Full-graph invocations keep the historical unconditional network patch.
+ * Fast routes opt in only when their direct implementation uses Node networking.
+ */
+export declare function shouldConfigureNodeNetworkCompatibility(argv: readonly string[]): boolean;
+//# sourceMappingURL=node-network-compat-fast.d.ts.map

package/dist/node-network-compat-fast.js

@@ -0,0 +1,23 @@
+/** Selective Node network setup for the entrypoint's fast routes. */
+import { parseFastCore, parseSecretsEnvFastRequest } from "./fast-scaffold.js";
+import { isVersionRequest, wantsLabelledVersionReport } from "./version-request.js";
+/**
+ * Full-graph invocations keep the historical unconditional network patch.
+ * Fast routes opt in only when their direct implementation uses Node networking.
+ */
+export function shouldConfigureNodeNetworkCompatibility(argv) {
+    if (isVersionRequest(argv))
+        return wantsLabelledVersionReport(argv);
+    const fastCore = parseFastCore(argv);
+    if (fastCore)
+        return fastCore.entry.requiresNodeNetworkCompatibility === true;
+    // The lightweight secrets route still makes vault API requests.
+    if (parseSecretsEnvFastRequest(argv))
+        return true;
+    return true;
+}
+if (shouldConfigureNodeNetworkCompatibility(process.argv)) {
+    const { configureNodeNetworkCompatibilityOnce } = await import("./node-network-compat-core.js");
+    configureNodeNetworkCompatibilityOnce();
+}
+//# sourceMappingURL=node-network-compat-fast.js.map