@indigoai-us/hq-cli 5.259.0 → 5.261.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [5.261.0] — 2026-09-28
+
+### Fixed
+
+- Standing keep-alive leads now resume stories that remain open. Completed
+  stories resume only on standing leads with queued work, and reconcile reports
+  why other completed lanes stay idle.
+
+## [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

@@ -50,7 +50,7 @@ import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
-import { keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
+import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.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";
@@ -4523,8 +4524,15 @@ async function runShow(ctx, laneId) {
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
+    const doneStateVerdict = storedLane.state === "done" && storedLane.keep_alive === true
+        ? doneKeepAliveVerdict(storedLane, { decision: storedLane.last_envelope?.decision, story_complete: storedLane.story_complete }, storedLane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, storedLane))
+        : null;
     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",
@@ -4555,6 +4563,7 @@ async function runShow(ctx, laneId) {
             enabled: keepAliveState.enabled,
             source: keepAliveState.source,
             standing: storedLane.keep_alive_standing === true,
+            done_state_verdict: doneStateVerdict,
             opted_in_at: storedLane.keep_alive_opted_in_at ?? null,
             blocked_reason: storedLane.keep_alive_blocked_reason ??
                 (storedLane.keep_alive === true ? null : "not_opted_in"),
@@ -4579,6 +4588,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.";
@@ -17,11 +27,9 @@ export interface KeepAliveDoneEnvelope {
     decision?: string;
     story_complete?: boolean;
 }
-/**
- * Shared done-state policy: ordinary opted-in lanes resume open stories;
- * standing leads wait for queued work, even when each turn marks the story
- * complete. Watch and reconcile both use this decision.
- */
+export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complete";
+/** 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 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

@@ -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,63 +69,38 @@ 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 } : {}),
-        };
-        const next = {
-            ...current,
-            status_gate: { ...gate, consecutive_misses: consecutiveMisses },
-            status_gate_history: appendCappedHistory(history, missed),
+            ...(transitioned.resumeQueued ? { resume_queued: true } : {}),
+            ...(transitioned.resumeSkippedReason !== undefined
+                ? { resume_skipped_reason: transitioned.resumeSkippedReason }
+                : {}),
         };
-        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),
         };
     });
 }
 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_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.";
-/**
- * Shared done-state policy: ordinary opted-in lanes resume open stories;
- * standing leads wait for queued work, even when each turn marks the story
- * complete. Watch and reconcile both use this decision.
- */
-export function canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork) {
+/** Shared done-state policy used by watch, reconcile, and the show command. */
+export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork) {
     if (envelope.decision !== "done")
-        return false;
-    return lane.keep_alive_standing === true
-        ? hasQueuedWork
-        : envelope.story_complete !== true;
+        return null;
+    if (envelope.story_complete !== true)
+        return "eligible";
+    if (lane.keep_alive_standing !== true)
+        return "story_complete";
+    return hasQueuedWork ? "eligible" : "standing_idle";
+}
+export function canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork) {
+    return doneKeepAliveVerdict(lane, envelope, hasQueuedWork) === "eligible";
 }
 /** Work signals already persisted for a lane that ended its turn. */
 export function hasPendingKeepAliveWork(hqRoot, lane, questionRecords) {

package/dist/lib/lanes/reconcile.js

@@ -22,7 +22,7 @@ import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecor
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, canResumeDoneKeepAliveLane, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, 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, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -848,7 +848,7 @@ export async function runPassBody(hqRoot, deps) {
             if (!envelope || envelope.decision !== "done")
                 continue;
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
-            if (!canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork))
+            if (doneKeepAliveVerdict(lane, envelope, hasQueuedWork) !== "eligible")
                 continue;
         }
         const key = keepAliveCompanyKey(lane.company);
@@ -1137,10 +1137,8 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     if (terminalEnvelope && latest) {
                         const envelope = terminalEnvelope;
                         next.story_status = envelope.story_status;
-                        if (envelope.story_complete !== undefined) {
-                            next.story_complete = envelope.story_complete;
-                            next.story_complete_reason = envelope.story_complete_reason;
-                        }
+                        next.story_complete = envelope.story_complete;
+                        next.story_complete_reason = envelope.story_complete_reason;
                         const storyStatus = envelope.decision === "blocked"
                             ? "blocked"
                             : envelope.decision === "done"
@@ -1550,6 +1548,13 @@ function recordKeepAliveSkip(hqRoot, lane, reason, summary, deps, detail) {
         });
     }
 }
+function recordDoneKeepAlivePolicySkip(summary, lane, verdict) {
+    summary.skipped.push({
+        kind: "lane",
+        id: lane.lane_id,
+        why: `keep_alive_${verdict}`,
+    });
+}
 function readLatestInterruptedClassificationAt(hqRoot, lane) {
     const logPath = watcherOutLogPath(hqRoot, lane.lane_id);
     let body;
@@ -1624,7 +1629,10 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             if (!envelope || envelope.decision !== "done")
                 continue;
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
-            if (!canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork)) {
+            const verdict = doneKeepAliveVerdict(lane, envelope, hasQueuedWork);
+            if (verdict !== "eligible") {
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(summary, lane, verdict);
                 if (envelope.story_complete === true && lane.keep_alive_standing !== true && hasKeepAliveProgress(lane)) {
                     casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
                         current.state === "done" &&
@@ -1713,8 +1721,15 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             if (!latest || latest.envelope.decision !== "done")
                 continue;
             const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
-            if (!canResumeDoneKeepAliveLane(lane, latest.envelope, hasQueuedWork))
+            const verdict = doneKeepAliveVerdict(lane, latest.envelope, hasQueuedWork);
+            if (verdict !== "eligible") {
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(summary, lane, verdict);
+                if (latest.envelope.story_complete === true && lane.keep_alive_standing !== true && hasKeepAliveProgress(lane)) {
+                    casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === "done", (current) => ({ ...clearedKeepAliveProgress(current), keep_alive_blocked_reason: undefined }), deps.dryRun);
+                }
                 continue;
+            }
             try {
                 eligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, lane, latest.ref);
             }
@@ -1788,7 +1803,10 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             if (!currentEnvelope || currentEnvelope.envelope.decision !== "done")
                 continue;
             const hasQueuedWork = current.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, current, questions);
-            if (!canResumeDoneKeepAliveLane(current, currentEnvelope.envelope, hasQueuedWork)) {
+            const verdict = doneKeepAliveVerdict(current, currentEnvelope.envelope, hasQueuedWork);
+            if (verdict !== "eligible") {
+                if (verdict !== null)
+                    recordDoneKeepAlivePolicySkip(summary, current, verdict);
                 if (currentEnvelope.envelope.story_complete === true && current.keep_alive_standing !== true && hasKeepAliveProgress(current)) {
                     casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                         latestLane.state === "done" &&

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;
@@ -414,7 +434,7 @@ export interface LaneRecord {
     worker_profile?: string;
     /** Whether this lead lane should resume completed turns while its story is open. */
     keep_alive?: boolean;
-    /** Whether a keep-alive lead waits for queued work after every done turn. */
+    /** Whether completed keep-alive stories wait for queued work after a done turn. */
     keep_alive_standing?: boolean;
     /** Time this lane most recently explicitly opted into keep-alive. */
     keep_alive_opted_in_at?: 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;
@@ -403,10 +405,8 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
                 ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
             };
             next.story_status = envelope.story_status;
-            if (envelope.story_complete !== undefined) {
-                next.story_complete = envelope.story_complete;
-                next.story_complete_reason = envelope.story_complete_reason;
-            }
+            next.story_complete = envelope.story_complete;
+            next.story_complete_reason = envelope.story_complete_reason;
             const currentProject = current.project_id;
             const currentStory = current.story_id;
             const storyStatus = envelope.decision === "blocked"
@@ -711,6 +711,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 +1447,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.261.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {