@indigoai-us/hq-cli 5.259.0 → 5.260.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.260.0] — 2026-09-28
+
+### Added
+
+- The `lanes.blocker-freshness` flag checks manager blockers after each turn.
+  It resumes once for stale blockers, then alerts the senior on a repeated
+  stale set. The window defaults to four hours and can be set with
+  `blocker_freshness_hours` in the lanes config.
+
+### Fixed
+
+- Blocker-freshness escalations now reach session seniors through the existing
+  monitor-session inbox. Work Mesh is an optional signal, not delivery, and a
+  failed delivery is retried on a later stale turn.
+
 ## [5.259.0] — 2026-09-28
 
 ### Fixed

package/dist/commands/lanes-message.js

@@ -92,6 +92,9 @@ export function createLaneMessageHandlers(deps) {
                     readStarttime: ctx.readStarttime ?? readProcStarttime,
                     mesh: null,
                     resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
+                    deliverLaneSeniorMessage: async (seniorLaneId, seniorText) => {
+                        await runMessage(ctx, seniorLaneId, { text: seniorText, silent: true });
+                    },
                 });
                 lane = readLane(hqRoot, laneId);
                 // This invocation won the race to classify the dead worker, so the

package/dist/commands/lanes.js

@@ -59,6 +59,7 @@ import { LanesError } from "../lib/lanes/errors.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
 import { managerStatusGateEnabledForLane, resolveManagerStatusGateForLane, } from "../lib/lanes/manager-status-gate.js";
+import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "../lib/lanes/blocker-freshness.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
 import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
@@ -4525,6 +4526,10 @@ async function runShow(ctx, laneId) {
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
     const managerStatusGate = await resolveManagerStatusGateForLane(hqRoot, storedLane, { env: ctx.env });
     const managerStatusTarget = managerStatusGate.target;
+    const blockerFreshness = await resolveBlockerFreshnessForLane(hqRoot, storedLane, {
+        env: ctx.env,
+        now: ctx.now().getTime(),
+    });
     printJson({
         ok: true,
         action: "show",
@@ -4579,6 +4584,15 @@ async function runShow(ctx, laneId) {
                     consecutive_misses: storedLane.status_gate?.consecutive_misses ?? 0,
                 }
                 : null,
+        blocker_freshness: blockerFreshness.flagEnabled
+            ? {
+                enabled: blockerFreshness.enabled,
+                stale: blockerFreshness.stale.map((blocker) => blocker.label),
+                escalated: blockerFreshness.stale.length > 0 &&
+                    storedLane.blocker_freshness_state?.escalated_fingerprint ===
+                        blockerFreshnessFingerprint(blockerFreshness.stale),
+            }
+            : null,
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
             ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }

package/dist/lib/lanes/blocker-freshness.d.ts

@@ -0,0 +1,31 @@
+import { type ManagerStatusTarget } from "./manager-status-gate.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import type { LaneRecord } from "./types.js";
+export declare const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
+export declare const BLOCKER_FRESHNESS_DEFAULT_HOURS = 4;
+export declare const BLOCKER_FRESHNESS_FUTURE_GRACE_MS: number;
+export interface StaleBlocker {
+    key: string;
+    label: string;
+}
+export interface BlockerFreshnessResolution {
+    /** The company-scoped flag value, kept separate from manager applicability. */
+    flagEnabled: boolean;
+    /** True only when the flag is on and this lane has a valid manager target. */
+    enabled: boolean;
+    target?: ManagerStatusTarget;
+    statusPath?: string;
+    windowHours: number;
+    stale: StaleBlocker[];
+    error?: string;
+}
+export interface BlockerFreshnessResolutionOptions {
+    env?: NodeJS.ProcessEnv;
+    now?: number;
+    readFlag?: typeof readLanesRegistryFlag;
+    onError?: (error: unknown) => void;
+}
+export declare function blockerFreshnessFingerprint(stale: readonly StaleBlocker[]): string;
+/** Resolve the flag before touching the manager mapping or status artifact. */
+export declare function resolveBlockerFreshnessForLane(root: string, lane: LaneRecord, options?: BlockerFreshnessResolutionOptions): Promise<BlockerFreshnessResolution>;
+//# sourceMappingURL=blocker-freshness.d.ts.map

package/dist/lib/lanes/blocker-freshness.js

@@ -0,0 +1,167 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { LanesError } from "./errors.js";
+import { DEFAULT_BLOCKER_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
+import { resolveManagerStatusTarget } from "./manager-status-gate.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { assertNoSecretText } from "./text-scan.js";
+export const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
+export const BLOCKER_FRESHNESS_DEFAULT_HOURS = DEFAULT_BLOCKER_FRESHNESS_HOURS;
+export const BLOCKER_FRESHNESS_FUTURE_GRACE_MS = 5 * 60 * 1000;
+const TERMINAL_BLOCKER_STATUSES = new Set([
+    "closed",
+    "resolved",
+    "done",
+    "superseded",
+    "cancelled",
+]);
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorCode(error) {
+    return error instanceof LanesError ? error.error : "blocker_freshness_unavailable";
+}
+function reportError(lane, error) {
+    process.stderr.write(`hq lanes: blocker freshness disabled for ${lane.lane_id}: ${errorCode(error)}\n`);
+}
+function failedResolution(flagEnabled, error, onError) {
+    onError(error);
+    return {
+        flagEnabled,
+        enabled: false,
+        windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
+        stale: [],
+        error: errorCode(error),
+    };
+}
+function identityFor(blocker, index) {
+    for (const field of ["id", "item", "what", "reason"]) {
+        const candidate = blocker[field];
+        if (typeof candidate === "string" && candidate.trim().length > 0) {
+            const identity = candidate.trim();
+            assertNoSecretText(`blocker ${field}`, identity);
+            return {
+                key: blockerKey(`${field}:${identity}`),
+                label: identity.slice(0, 120),
+            };
+        }
+    }
+    const identity = `index:${index + 1}`;
+    const label = `blocker ${index + 1}`;
+    assertNoSecretText("blocker label", label);
+    return { key: blockerKey(identity), label };
+}
+function hasClosingTimestamp(blocker) {
+    return [blocker.closed_at, blocker.resolved_at].some((value) => value !== undefined && value !== null && value !== "");
+}
+function blockerKey(label) {
+    return createHash("sha256").update(label, "utf8").digest("hex");
+}
+function readBlockers(statusPath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(statusPath);
+    }
+    catch (error) {
+        throw new LanesError("blocker_freshness_status_unreadable", `Cannot inspect manager status ${statusPath}: ${error instanceof Error ? error.message : String(error)}`, { path: statusPath });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new LanesError("blocker_freshness_status_invalid", `Manager status must be a regular file: ${statusPath}`, { path: statusPath });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(statusPath, "utf8"));
+    }
+    catch (error) {
+        throw new LanesError("blocker_freshness_status_invalid", `Manager status contains invalid JSON: ${statusPath}`, { path: statusPath, cause: error instanceof Error ? error.name : "UnknownError" });
+    }
+    if (!isObject(parsed) || !Array.isArray(parsed.blockers)) {
+        throw new LanesError("blocker_freshness_status_invalid", `Manager status must contain a top-level blockers array: ${statusPath}`, { path: statusPath });
+    }
+    return parsed.blockers.filter(isObject);
+}
+function isStale(verifiedAt, now, windowHours) {
+    if (typeof verifiedAt !== "string")
+        return true;
+    const verifiedAtMs = Date.parse(verifiedAt);
+    if (!Number.isFinite(verifiedAtMs))
+        return true;
+    if (verifiedAtMs - now > BLOCKER_FRESHNESS_FUTURE_GRACE_MS)
+        return true;
+    return now - verifiedAtMs > windowHours * 60 * 60 * 1000;
+}
+export function blockerFreshnessFingerprint(stale) {
+    const keys = stale.map((item) => item.key).sort();
+    return createHash("sha256").update(JSON.stringify(keys), "utf8").digest("hex");
+}
+/** Resolve the flag before touching the manager mapping or status artifact. */
+export async function resolveBlockerFreshnessForLane(root, lane, options = {}) {
+    const onError = options.onError ?? ((error) => reportError(lane, error));
+    let flagEnabled;
+    try {
+        flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(BLOCKER_FRESHNESS_FLAG, {
+            company: lane.company ?? lane.mesh_company ?? undefined,
+            env: options.env,
+        });
+    }
+    catch (error) {
+        return failedResolution(false, error, onError);
+    }
+    if (!flagEnabled) {
+        return {
+            flagEnabled: false,
+            enabled: false,
+            windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
+            stale: [],
+        };
+    }
+    let target;
+    try {
+        target = resolveManagerStatusTarget(root, lane);
+    }
+    catch (error) {
+        return failedResolution(true, error, onError);
+    }
+    if (!target.manager || target.statusPath === undefined) {
+        return {
+            flagEnabled: true,
+            enabled: false,
+            target,
+            windowHours: BLOCKER_FRESHNESS_DEFAULT_HOURS,
+            stale: [],
+        };
+    }
+    let windowHours;
+    let blockers;
+    try {
+        windowHours = loadLanesConfig(root).blocker_freshness_hours;
+        blockers = readBlockers(target.statusPath);
+    }
+    catch (error) {
+        return failedResolution(true, error, onError);
+    }
+    const now = options.now ?? Date.now();
+    const stale = [];
+    try {
+        for (const [index, blocker] of blockers.entries()) {
+            const status = typeof blocker.status === "string" ? blocker.status.trim().toLowerCase() : "";
+            if (TERMINAL_BLOCKER_STATUSES.has(status) || hasClosingTimestamp(blocker))
+                continue;
+            if (!isStale(blocker.verified_at, now, windowHours))
+                continue;
+            stale.push(identityFor(blocker, index));
+        }
+    }
+    catch (error) {
+        return failedResolution(true, error, onError);
+    }
+    return {
+        flagEnabled: true,
+        enabled: true,
+        target,
+        statusPath: target.statusPath,
+        windowHours,
+        stale,
+    };
+}
+//# sourceMappingURL=blocker-freshness.js.map

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

@@ -39,6 +39,8 @@ export declare const DEFAULT_TURN_START_LOST_MS: number;
 export declare const DEFAULT_SILENT_LOST_MS: number;
 /** Unanswered session questions move to the next audience after 10 minutes. */
 export declare const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS: number;
+/** Open manager blockers are re-verified every four hours by default. */
+export declare const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
 export declare const DEFAULT_TRACKER_CHECKS: TrackerChecksConfig;
 export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
 export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;

package/dist/lib/lanes/config.js

@@ -43,6 +43,8 @@ export const DEFAULT_TURN_START_LOST_MS = 2 * 60 * 60 * 1000;
 export const DEFAULT_SILENT_LOST_MS = 12 * 60 * 60 * 1000;
 /** Unanswered session questions move to the next audience after 10 minutes. */
 export const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS = 10 * 60;
+/** Open manager blockers are re-verified every four hours by default. */
+export const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
 export const DEFAULT_TRACKER_CHECKS = {
     owner_question_surface_ms: 10 * 60 * 1000,
     open_question_age_ms: 2 * 60 * 60 * 1000,
@@ -141,6 +143,14 @@ function positiveInt(value, field, fallback) {
     }
     return value;
 }
+function positiveNumber(value, field, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new LanesConfigError("invalid_config", `${field} must be a positive finite number`, { field, value });
+    }
+    return value;
+}
 function unitInterval(value, field, fallback) {
     if (value === undefined)
         return fallback;
@@ -414,6 +424,7 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
         liveness: { ...DEFAULT_LIVENESS_WINDOWS },
         tracker: { checks: { ...DEFAULT_TRACKER_CHECKS } },
         session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
+        blocker_freshness_hours: DEFAULT_BLOCKER_FRESHNESS_HOURS,
     };
 }
 export function parseLanesConfig(raw, deps = defaultDeps()) {
@@ -456,6 +467,7 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         liveness: parseLiveness(raw.liveness),
         tracker: { checks: parseTrackerChecks(raw.tracker) },
         session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),
+        blocker_freshness_hours: positiveNumber(raw.blocker_freshness_hours, "blocker_freshness_hours", DEFAULT_BLOCKER_FRESHNESS_HOURS),
     };
 }
 export function lanesConfigPath(hqRoot) {

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

@@ -7,6 +7,16 @@ export declare const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
 export declare const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
+export interface LaneTerminalResumeResult {
+    lane: LaneRecord;
+    resumeQueued: boolean;
+    resumeSkippedReason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
+}
+/** Shared resume transition for terminal gate follow-ups. */
+export declare function queueLaneTerminalResume(current: LaneRecord, at: string, resumeText: string, options?: {
+    allowResume?: boolean;
+    mergeExisting?: boolean;
+}): 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;
 export declare 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.";

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

@@ -11,6 +11,53 @@ export const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
 export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
+/** Shared resume transition for terminal gate follow-ups. */
+export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
+    if (options.mergeExisting && current.pending_resume !== undefined) {
+        return {
+            lane: {
+                ...current,
+                pending_resume: {
+                    ...current.pending_resume,
+                    text: `${current.pending_resume.text}\n\n${resumeText}`,
+                },
+            },
+            resumeQueued: true,
+        };
+    }
+    if (current.state === "blocked")
+        return { lane: current, resumeQueued: false, resumeSkippedReason: "blocked" };
+    if (current.state === "awaiting_input")
+        return { lane: current, resumeQueued: false, resumeSkippedReason: "open_question" };
+    if (options.allowResume === false)
+        return { lane: current, resumeQueued: false, resumeSkippedReason: "miss_limit" };
+    if (current.state !== "done" && current.state !== "interrupted" && current.state !== "failed") {
+        return { lane: current, resumeQueued: false };
+    }
+    if (!current.provider_session_id) {
+        return { lane: current, resumeQueued: false, resumeSkippedReason: "no_provider_session" };
+    }
+    return {
+        lane: {
+            ...current,
+            state: "queued",
+            queued_reason: undefined,
+            queued_at: at,
+            admission_reserved_at: undefined,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            pending_resume: {
+                session_id: current.provider_session_id,
+                trigger: "resume",
+                resumed_from: current.state,
+                text: resumeText,
+                compact: true,
+                at,
+            },
+        },
+        resumeQueued: true,
+    };
+}
 /** Persist a manager status miss and queue its one bounded follow-up turn. */
 export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText) {
     return retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
@@ -22,47 +69,21 @@ export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText)
             return current;
         }
         const consecutiveMisses = gate.consecutive_misses + 1;
-        let resumeSkippedReason;
-        if (current.state === "blocked")
-            resumeSkippedReason = "blocked";
-        else if (current.state === "awaiting_input")
-            resumeSkippedReason = "open_question";
-        else if (consecutiveMisses > 1)
-            resumeSkippedReason = "miss_limit";
-        else if (!current.provider_session_id)
-            resumeSkippedReason = "no_provider_session";
-        const resumeQueued = resumeSkippedReason === undefined &&
-            (current.state === "done" || current.state === "interrupted" || current.state === "failed");
+        const transitioned = queueLaneTerminalResume({
+            ...current,
+            status_gate: { ...gate, consecutive_misses: consecutiveMisses },
+        }, entry.at, resumeText, { allowResume: consecutiveMisses <= 1 });
         const missed = {
             event: "status_missed",
             ...entry,
-            ...(resumeQueued ? { resume_queued: true } : {}),
-            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
+            ...(transitioned.resumeQueued ? { resume_queued: true } : {}),
+            ...(transitioned.resumeSkippedReason !== undefined
+                ? { resume_skipped_reason: transitioned.resumeSkippedReason }
+                : {}),
         };
-        const next = {
-            ...current,
-            status_gate: { ...gate, consecutive_misses: consecutiveMisses },
-            status_gate_history: appendCappedHistory(history, missed),
-        };
-        if (!resumeQueued || !current.provider_session_id)
-            return next;
-        const resumedFrom = current.state;
         return {
-            ...next,
-            state: "queued",
-            queued_reason: undefined,
-            queued_at: entry.at,
-            admission_reserved_at: undefined,
-            terminal_reason: undefined,
-            terminal_details: undefined,
-            pending_resume: {
-                session_id: current.provider_session_id,
-                trigger: "resume",
-                resumed_from: resumedFrom,
-                text: resumeText,
-                compact: true,
-                at: entry.at,
-            },
+            ...transitioned.lane,
+            status_gate_history: appendCappedHistory(history, missed),
         };
     });
 }

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

@@ -351,6 +351,26 @@ export interface ManagerStatusGateHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
+export interface BlockerFreshnessState {
+    /** Stable hashes of the stale blocker labels seen at the last completed turn. */
+    stale_keys: string[];
+    stale_labels: string[];
+    /** Hash of the last stale set already escalated to the senior. */
+    escalated_fingerprint?: string;
+}
+export interface BlockerFreshnessHistoryEntry {
+    event: "blocker_stale" | "blocker_stale_escalated";
+    turn_id: string;
+    path: string;
+    at: string;
+    labels: string[];
+    count: number;
+    fingerprint: string;
+    resume_queued?: boolean;
+    resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
+    delivery_failed?: true;
+}
+export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry;
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -493,7 +513,9 @@ export interface LaneRecord {
     /** Turn-start baseline used by the optional manager status gate. */
     status_gate?: ManagerStatusGate;
     /** Bounded audit history of manager turns that missed their declared status artifact. */
-    status_gate_history?: ManagerStatusGateHistoryEntry[];
+    status_gate_history?: LaneGateHistoryEntry[];
+    /** Last blocker-freshness state used to detect consecutive stale turns. */
+    blocker_freshness_state?: BlockerFreshnessState;
     /** Last automatic compaction of a resumed session (compaction.ts). */
     last_compaction?: LaneCompactionRecord;
     /**
@@ -833,6 +855,8 @@ export interface LanesConfig {
     };
     /** Seconds an unanswered question waits at a session audience before advancing. */
     session_question_timeout_secs: number;
+    /** Age in hours after which an open manager blocker must be re-verified. */
+    blocker_freshness_hours: number;
 }
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;

package/dist/lib/lanes/types.js

@@ -228,7 +228,7 @@ export const LANE_FIELD_WRITERS = {
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
-    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], blocker_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command"], interrupted_at: ["watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],

package/dist/lib/lanes/watcher-main.js

@@ -19,6 +19,7 @@ export function watcherMainDeps(hqRoot, laneId, env = process.env, repairDispatc
     return {
         resolveQuestionActiveCompany,
         spawnRepair: (root, lane, input) => spawnEnvelopeRepairViaCurrentCli(root, lane, input, { ...repairDispatchDeps, env }),
+        deliverLaneSeniorMessage: async (seniorLaneId, text) => deliverLaneSeniorMessage(cliEntry, seniorLaneId, text),
         recoverQueuedMessages: async () => {
             const result = spawnSync(process.execPath, [cliEntry, "lanes", "_recover-queued-messages", laneId], {
                 env,
@@ -33,6 +34,30 @@ export function watcherMainDeps(hqRoot, laneId, env = process.env, repairDispatc
         },
     };
 }
+function deliverLaneSeniorMessage(cliEntry, laneId, text) {
+    const result = spawnSync(process.execPath, [cliEntry, "lanes", "message", laneId, "--text", text], {
+        env: process.env,
+        encoding: "utf8",
+        timeout: 120_000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        throw new Error(`senior lane message command exited ${result.status ?? result.signal ?? "without status"}`);
+    }
+    let response;
+    try {
+        response = JSON.parse((result.stdout ?? "").trim());
+    }
+    catch {
+        throw new Error("senior lane message command returned invalid JSON");
+    }
+    if (response === null || typeof response !== "object" || Array.isArray(response) ||
+        response.accepted !== true ||
+        response.lane_id !== laneId) {
+        throw new Error("senior lane message command did not confirm acceptance");
+    }
+}
 async function resolveQuestionActiveCompany() {
     try {
         const { company } = await openMeshTransport({});

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

@@ -227,8 +227,12 @@ export interface WatcherLoopDeps {
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume an atomically queued inbox after this watcher wins terminal CAS. */
     recoverQueuedMessages?: (lane: LaneRecord) => Promise<void>;
+    /** Deliver a lane-senior escalation through the normal lane-message router. */
+    deliverLaneSeniorMessage?: (seniorLaneId: string, text: string) => Promise<void>;
     /** Test seam; production reads the company-scoped hq-flags row. */
     readManagerStatusGateFlag?: typeof readLanesRegistryFlag;
+    /** Test seam; production reads the company-scoped hq-flags row. */
+    readBlockerFreshnessFlag?: typeof readLanesRegistryFlag;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -35,21 +35,23 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
-import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, } from "./types.js";
+import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, LANE_PROVIDERS, } from "./types.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { appendCappedHistory, readLane, retryUpdateLane, withLaneHireLocks } from "./store.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
 import { readWorkerRunResult } from "./delivery.js";
 import { applyDefaultQuotaHold, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
-import { dropboxInboxHasMessages, readToolActivity, toolActivityPath } from "./dropbox.js";
+import { appendDropboxMessageAtPath, dropboxInboxHasMessages, readToolActivity, toolActivityPath } from "./dropbox.js";
 import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefaultHoldMs } from "./config.js";
 import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission-host.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, laneStoryStatusSuppressionKey, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
 import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
-import { queueManagerStatusGateResume } from "./keep-alive.js";
+import { queueLaneTerminalResume, queueManagerStatusGateResume } from "./keep-alive.js";
+import { monitorSessionDir } from "../monitor.js";
 import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, writePidRecord, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export const SILENCE_MS = 20 * 60 * 1000;
@@ -711,6 +713,171 @@ async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, l
     }
     return updated;
 }
+async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, mesh, logDecision) {
+    let errorLogged = false;
+    const resolution = await resolveBlockerFreshnessForLane(hqRoot, lane, {
+        readFlag: deps.readBlockerFreshnessFlag ?? readLanesRegistryFlag,
+        now: Date.parse(at),
+        onError: (error) => {
+            if (errorLogged)
+                return;
+            errorLogged = true;
+            const code = error instanceof LanesError ? error.error : "blocker_freshness_unavailable";
+            process.stderr.write(`hq lanes watcher: blocker freshness disabled for ${lane.lane_id}: ${code}\n`);
+            logDecision({ event: "blocker_freshness_disabled", at, error: code });
+        },
+    });
+    if (!resolution.enabled || resolution.statusPath === undefined || resolution.error !== undefined)
+        return lane;
+    if (manifestTurnId !== undefined && lane.status_gate !== undefined && lane.status_gate.turn_id !== manifestTurnId) {
+        logDecision({ event: "blocker_freshness_baseline_mismatch", at, turn_id: lane.status_gate.turn_id });
+        return lane;
+    }
+    if (resolution.stale.length === 0) {
+        if (lane.blocker_freshness_state === undefined)
+            return lane;
+        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => current.blocker_freshness_state === undefined
+            ? current
+            : { ...current, blocker_freshness_state: undefined });
+    }
+    const staleKeys = resolution.stale.map((blocker) => blocker.key).sort();
+    const staleLabels = resolution.stale.map((blocker) => blocker.label);
+    const fingerprint = blockerFreshnessFingerprint(resolution.stale);
+    const turnId = manifestTurnId ?? lane.status_gate?.turn_id ?? `unknown-${at}`;
+    const resumeText = `These open blockers in ${resolution.statusPath} were not re-verified in the last ${resolution.windowHours}h: ${staleLabels.join(", ")}. Check each one now; set verified_at on the ones that still hold and close the rest, then end the turn.`;
+    let deliverEscalation = false;
+    let escalationText = "";
+    let updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+        deliverEscalation = false;
+        const prior = current.blocker_freshness_state;
+        const repeated = prior !== undefined && staleKeys.some((key) => prior.stale_keys.includes(key));
+        const history = current.status_gate_history ?? [];
+        const alreadyEscalatedThisTurn = history.some((entry) => entry.event === "blocker_stale_escalated" && entry.turn_id === turnId && entry.fingerprint === fingerprint);
+        const escalate = repeated && prior?.escalated_fingerprint !== fingerprint && !alreadyEscalatedThisTurn;
+        const alreadyEscalatedSet = prior?.escalated_fingerprint === fingerprint;
+        const statusResumeQueued = history.some((entry) => entry.event === "status_missed" && entry.turn_id === turnId && entry.resume_queued === true);
+        let resumeQueued = false;
+        let resumeSkippedReason;
+        let nextLane = current;
+        if (!escalate && !alreadyEscalatedSet) {
+            const resume = queueLaneTerminalResume(current, at, resumeText, {
+                mergeExisting: statusResumeQueued,
+            });
+            resumeQueued = resume.resumeQueued;
+            resumeSkippedReason = resume.resumeSkippedReason;
+            nextLane = resume.lane;
+        }
+        const staleEntry = {
+            event: "blocker_stale",
+            turn_id: turnId,
+            path: resolution.statusPath,
+            at,
+            labels: staleLabels,
+            count: resolution.stale.length,
+            fingerprint,
+            ...(resumeQueued ? { resume_queued: true } : {}),
+            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
+        };
+        let nextHistory = history.some((entry) => entry.event === "blocker_stale" && entry.turn_id === turnId)
+            ? [...history]
+            : appendCappedHistory(history, staleEntry);
+        let escalatedFingerprint = prior?.escalated_fingerprint;
+        if (escalate) {
+            const escalatedEntry = {
+                event: "blocker_stale_escalated",
+                turn_id: turnId,
+                path: resolution.statusPath,
+                at,
+                labels: staleLabels,
+                count: resolution.stale.length,
+                fingerprint,
+            };
+            nextHistory = appendCappedHistory(nextHistory, escalatedEntry);
+            escalatedFingerprint = fingerprint;
+            deliverEscalation = true;
+            escalationText = `Blocker freshness escalation for ${current.lane_id}: these blockers remain stale after consecutive turns: ${staleLabels.join(", ")}. Status file: ${resolution.statusPath}.`;
+        }
+        else if (prior !== undefined && blockerFreshnessFingerprint(prior.stale_keys.map((key, index) => ({ key, label: prior.stale_labels[index] ?? "" }))) !== fingerprint) {
+            escalatedFingerprint = undefined;
+        }
+        return {
+            ...nextLane,
+            blocker_freshness_state: {
+                stale_keys: staleKeys,
+                stale_labels: staleLabels,
+                ...(escalatedFingerprint !== undefined ? { escalated_fingerprint: escalatedFingerprint } : {}),
+            },
+            status_gate_history: nextHistory,
+        };
+    });
+    logDecision({ event: "blocker_stale", at, turn_id: turnId, path: resolution.statusPath, labels: staleLabels, count: staleLabels.length });
+    const escalated = updated.status_gate_history?.find((entry) => entry.event === "blocker_stale_escalated" && entry.turn_id === turnId && entry.fingerprint === fingerprint);
+    if (escalated && deliverEscalation) {
+        try {
+            if (lane.senior.kind === "lane" && lane.senior.id) {
+                if (deps.deliverLaneSeniorMessage === undefined) {
+                    throw new LanesError("blocker_freshness_delivery_unavailable", "Lane-senior blocker escalations require the lane-message delivery path", { lane_id: lane.lane_id, senior_lane_id: lane.senior.id });
+                }
+                await deps.deliverLaneSeniorMessage(lane.senior.id, escalationText);
+            }
+            else if (lane.senior.kind === "session" && lane.senior.id) {
+                const inbox = resolveBlockerFreshnessSessionInbox(hqRoot, lane.senior.id);
+                appendDropboxMessageAtPath(inbox, {
+                    at,
+                    message_id: `blocker-freshness:${lane.lane_id}:${fingerprint}:${turnId}`,
+                    kind: "blocker_stale_escalation",
+                    text: escalationText,
+                });
+            }
+            else {
+                throw new LanesError("blocker_freshness_delivery_unavailable", "No durable senior inbox is available for this blocker escalation", { lane_id: lane.lane_id, senior_kind: lane.senior.kind });
+            }
+            logDecision({ event: "blocker_stale_escalation_delivered", at, turn_id: turnId, senior_kind: lane.senior.kind });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`hq lanes watcher: blocker freshness escalation delivery failed for ${lane.lane_id}: ${message}\n`);
+            logDecision({ event: "blocker_stale_escalation_delivery_failed", at, turn_id: turnId, error: message });
+            updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+                const state = current.blocker_freshness_state;
+                if (state?.escalated_fingerprint !== fingerprint)
+                    return current;
+                const retryableState = { ...state };
+                delete retryableState.escalated_fingerprint;
+                return {
+                    ...current,
+                    blocker_freshness_state: retryableState,
+                    status_gate_history: (current.status_gate_history ?? []).map((entry) => entry.event === "blocker_stale_escalated"
+                        && entry.turn_id === turnId
+                        && entry.fingerprint === fingerprint
+                        ? { ...entry, delivery_failed: true }
+                        : entry),
+                };
+            });
+        }
+        if (mesh !== null) {
+            await emitMeshSoft("blocker_freshness_escalation_signal", logDecision, at, (signal) => emitLaneProgressEvent(mesh, lane, escalationText, signal));
+        }
+    }
+    return updated;
+}
+function resolveBlockerFreshnessSessionInbox(hqRoot, sessionId) {
+    let candidates;
+    try {
+        candidates = LANE_PROVIDERS
+            .map((provider) => monitorSessionDir(hqRoot, provider, sessionId))
+            .filter((sessionDir) => fs.existsSync(sessionDir));
+    }
+    catch (error) {
+        throw new LanesError("blocker_freshness_session_inbox_unavailable", `Could not resolve the monitor inbox for session senior: ${error instanceof Error ? error.message : String(error)}`, { session_id: sessionId });
+    }
+    if (candidates.length !== 1) {
+        throw new LanesError("blocker_freshness_session_inbox_unavailable", candidates.length === 0
+            ? "No monitor-session inbox is registered for the session senior"
+            : "The session senior matches more than one monitor-session inbox", { session_id: sessionId, matches: candidates.length });
+    }
+    return path.join(candidates[0], "dropbox");
+}
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with
  * the event name and the error message, and never propagates: the lane's
@@ -1282,11 +1449,12 @@ 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);
                 }
                 const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
-                    updated.status_gate_history?.some((entry) => entry.event === "status_missed" &&
-                        entry.turn_id === manifest.turn_id &&
-                        entry.resume_queued === true) === true;
+                    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;
                 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.259.0",
+  "version": "5.260.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {