@indigoai-us/hq-cli 5.301.0 → 5.303.0

package/dist/lib/lanes/spawn.js

@@ -333,17 +333,25 @@ function archivedResumeMessageText(hqRoot, laneId, messageId) {
             return undefined;
         throw new LanesError("account_retry_context_unreadable", `Could not read the archived message needed to resume lane ${laneId}`, { lane_id: laneId, message_id: messageId });
     }
-    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
-    if (lines.length !== 1) {
-        throw new LanesError("account_retry_context_invalid", `The archived message needed to resume lane ${laneId} is malformed`, { lane_id: laneId, message_id: messageId });
-    }
-    let value;
-    try {
-        value = JSON.parse(lines[0]);
+    const records = [];
+    for (const line of raw.split(/\r?\n/)) {
+        if (line.trim().length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        records.push(parsed);
     }
-    catch {
+    if (records.length !== 1) {
         throw new LanesError("account_retry_context_invalid", `The archived message needed to resume lane ${laneId} is malformed`, { lane_id: laneId, message_id: messageId });
     }
+    const value = records[0];
     if (value === null ||
         typeof value !== "object" ||
         value.message_id !== messageId ||
@@ -972,7 +980,7 @@ export function nextEnvelopePath(runDir) {
 }
 export function envelopeInstruction(envelopePath) {
     return (`When finished, write a JSON object to ${envelopePath} using these key names exactly: ` +
-        `schema_version, decision, summary, story_status, artifacts, story_complete, story_complete_reason, questions, blocked_reason. ` +
+        `schema_version, decision, summary, story_status, artifacts, story_complete, story_complete_reason, questions, blocked_reason, next_check_at. ` +
         `schema_version must be the exact string "hq-lane-envelope.v1". ` +
         `decision must be one of "done", "ask", "blocked". ` +
         `summary is a string. ` +
@@ -982,7 +990,8 @@ export function envelopeInstruction(envelopePath) {
         `story_complete true requires story_status done and a reason stating what was delivered and how it was verified. ` +
         `story_complete false requires story_status other than done and a reason stating what is still missing. ` +
         `questions is present and non-empty exactly when decision is "ask". ` +
-        `blocked_reason is present exactly when decision is "blocked".`);
+        `blocked_reason is present exactly when decision is "blocked". ` +
+        `next_check_at is optional; when present, use an ISO date-time for the next time-based keep-alive check.`);
 }
 /**
  * Standing authorization carried by every brief and every resume turn. A
@@ -1382,6 +1391,7 @@ function spawnDetached(spawnProcess, command, args, env, cwd, stdoutPath, stderr
         errFd = openLog(stderrPath);
         const child = spawnProcess(command, args, {
             detached: true,
+            windowsHide: true,
             stdio: ["ignore", outFd, errFd],
             env,
             cwd,

package/dist/lib/lanes/store.js

@@ -536,6 +536,30 @@ export function parseLaneRecord(raw, filePath) {
         raw.envelope_validation_errors.some((error) => typeof error !== "string" || error.trim() === ""))) {
         throw new LaneSchemaError("envelope_validation_errors must be a non-empty array of non-empty strings", { path: filePath, field: "envelope_validation_errors" });
     }
+    if (raw.fallback_question_cancellation_failures !== undefined) {
+        if (!Array.isArray(raw.fallback_question_cancellation_failures)) {
+            throw new LaneSchemaError("fallback_question_cancellation_failures must be an array", {
+                path: filePath,
+                field: "fallback_question_cancellation_failures",
+            });
+        }
+        for (const [index, entry] of raw.fallback_question_cancellation_failures.entries()) {
+            const field = `fallback_question_cancellation_failures[${index}]`;
+            if (!isPlainObject(entry) ||
+                Object.keys(entry).some((key) => !["at", "caller", "trigger", "question_ids", "error"].includes(key)) ||
+                (entry.trigger !== "message" && entry.trigger !== "resume") ||
+                !Array.isArray(entry.question_ids) ||
+                entry.question_ids.some((id) => typeof id !== "string" || id.trim() === "")) {
+                throw new LaneSchemaError(`${field} must be a fallback question-cancellation failure`, {
+                    path: filePath,
+                    field,
+                });
+            }
+            requireTimestamp(entry.at, `${field}.at`, filePath);
+            requireString(entry.caller, `${field}.caller`);
+            requireString(entry.error, `${field}.error`);
+        }
+    }
     requireTimestamp(raw.created_at, "created_at", filePath);
     requireTimestamp(raw.updated_at, "updated_at", filePath);
     if (raw.queued_reason !== undefined && !isQueuedReason(raw.queued_reason)) {

package/dist/lib/lanes/story-ledger.d.ts

@@ -64,6 +64,8 @@ export declare function laneStoryLedgerEnabled(): boolean;
 export declare function resolveProjectStoryLedger(hqRoot: string, projectId: string, companySlug?: string): ProjectStoryLedger;
 export declare function validateProjectStories(hqRoot: string, projectId: string, storyIds: readonly string[], companySlug?: string): ProjectStoryLedger;
 export declare function syncLaneToProjectStoryLedger(hqRoot: string, lane: LaneRecord, questionRefs?: readonly StoryLedgerQuestionRef[], deps?: StoryLedgerWriteDeps): void;
+/** Read canonical ledger states for the story ids currently carried by a lane. */
+export declare function readProjectStoryStates(hqRoot: string, projectId: string, storyIds: readonly string[], companySlug?: string): Map<string, string>;
 export declare function buildLaneStatusSnapshot(input: {
     hqRoot: string;
     projectId: string;

package/dist/lib/lanes/story-ledger.js

@@ -667,6 +667,14 @@ function storyState(story) {
     }
     return story.passes === true ? "done" : "todo";
 }
+/** Read canonical ledger states for the story ids currently carried by a lane. */
+export function readProjectStoryStates(hqRoot, projectId, storyIds, companySlug) {
+    const parsed = readLedger(resolveProjectStoryLedger(hqRoot, projectId, companySlug));
+    const wanted = new Set(storyIds);
+    return new Map(parsed.userStories
+        .filter((story) => wanted.has(story.id.trim()))
+        .map((story) => [story.id.trim(), storyState(story)]));
+}
 function laneStoryRefs(lane, projectId) {
     return laneStoriesForLedger(lane)
         .filter((story) => story.project_id === projectId)

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

@@ -31,6 +31,10 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
             readonly type: "string";
             readonly minLength: 1;
         };
+        readonly next_check_at: {
+            readonly type: "string";
+            readonly description: "Optional ISO date-time for a clock-based keep-alive check; invalid values are ignored.";
+        };
         readonly questions: {
             readonly type: "array";
             readonly items: {
@@ -380,6 +384,7 @@ export interface LastEnvelopeRef {
     /** PR and merge references carried by the worker envelope. */
     artifacts?: unknown[];
     blocked_reason?: string;
+    next_check_at?: string;
 }
 export interface ManagerStatusGate {
     turn_started_at: string;
@@ -404,9 +409,12 @@ export interface BlockerFreshnessState {
     stale_labels: string[];
     /** Hash of the last stale set already escalated to the senior. */
     escalated_fingerprint?: string;
+    /** The same escalation was recorded locally because a session inbox was unavailable. */
+    undeliverable_fingerprint?: string;
+    undeliverable_reason?: string;
 }
 export interface BlockerFreshnessHistoryEntry {
-    event: "blocker_stale" | "blocker_stale_escalated";
+    event: "blocker_stale" | "blocker_stale_escalated" | "blocker_stale_escalation_undeliverable";
     turn_id: string;
     path: string;
     at: string;
@@ -416,6 +424,8 @@ export interface BlockerFreshnessHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
     delivery_failed?: true;
+    reason?: string;
+    delivery_recovered?: true;
 }
 export interface KrFreshnessState {
     /** Stable fingerprint of the last stalled KPI set, which is resumed once. */
@@ -441,6 +451,13 @@ export interface LaneResumeHistoryEntry {
     /** HQ lane id for an agent caller, or `user` for an explicit human CLI action. */
     caller?: string;
 }
+export interface FallbackQuestionCancellationFailure {
+    at: string;
+    caller: string;
+    trigger: "message" | "resume";
+    question_ids: string[];
+    error: string;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -694,6 +711,8 @@ export interface LaneRecord {
     last_resume?: LaneResumeRecord;
     /** Last 50 lane worker starts after the initial start, including actor provenance. */
     resume_history?: LaneResumeHistoryEntry[];
+    /** Bounded failures while closing escalated questions after a fallback resume. */
+    fallback_question_cancellation_failures?: FallbackQuestionCancellationFailure[];
     /** Cache counters from the last exited run's result. Nothing else from the payload. */
     last_run_usage?: LaneRunUsage;
     /** Completion time paired with last_run_usage; written by the watcher. */
@@ -750,7 +769,7 @@ export interface PendingResume {
     trigger: "answered_questions" | "message" | "resume";
     /** True when this queued resume was initiated automatically by keep-alive. */
     keep_alive?: true;
-    resumed_from?: "interrupted" | "done" | "blocked" | "failed";
+    resumed_from?: "interrupted" | "done" | "blocked" | "failed" | "awaiting_input";
     from_failed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
     expected_senior?: SeniorRef;
@@ -785,9 +804,10 @@ export interface LaneResumeRecord {
     monitor_event?: true;
     /**
      * `hq lanes resume` only: the state the lane was in when the operator
-     * resumed it (`interrupted`, `done` or `blocked`) and the text they sent.
+     * resumed it (`interrupted`, `done`, `blocked`, `failed` or `awaiting_input`)
+     * and the text they sent.
      */
-    resumed_from?: "interrupted" | "done" | "blocked" | "failed";
+    resumed_from?: "interrupted" | "done" | "blocked" | "failed" | "awaiting_input";
     from_failed?: true;
     text?: string;
     /** False when the continued turn explicitly skipped compaction. */
@@ -888,6 +908,7 @@ export interface LaneEnvelope {
     schema_version: typeof ENVELOPE_SCHEMA_VERSION;
     decision: EnvelopeDecision;
     summary: string;
+    next_check_at?: string;
     questions?: EnvelopeQuestion[];
     story_status: StoryStatus;
     artifacts: unknown[];
@@ -993,6 +1014,7 @@ export interface LanesConfig {
     /** Age in hours after which a manager KPI is considered stalled. */
     kr_freshness_hours: number;
 }
+export declare function isIsoDateTime(value: string): boolean;
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;
 //# sourceMappingURL=types.d.ts.map

package/dist/lib/lanes/types.js

@@ -25,6 +25,10 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
         schema_version: { const: "hq-lane-envelope.v1" },
         decision: { enum: ["done", "ask", "blocked"] },
         summary: { type: "string", minLength: 1 },
+        next_check_at: {
+            type: "string",
+            description: "Optional ISO date-time for a clock-based keep-alive check; invalid values are ignored.",
+        },
         questions: {
             type: "array",
             items: {
@@ -226,7 +230,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
-    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"],
+    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"], fallback_question_cancellation_failures: ["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"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     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", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
@@ -246,6 +250,24 @@ function requireString(value, field) {
     }
     return value;
 }
+export function isIsoDateTime(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-](\d{2}):(\d{2}))$/.exec(value);
+    if (!match)
+        return false;
+    const [, yearText, monthText, dayText, hourText, minuteText, secondText, , offsetHourText, offsetMinuteText] = match;
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const hour = Number(hourText);
+    const minute = Number(minuteText);
+    const second = Number(secondText);
+    const offsetHour = offsetHourText === undefined ? 0 : Number(offsetHourText);
+    const offsetMinute = offsetMinuteText === undefined ? 0 : Number(offsetMinuteText);
+    const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth &&
+        hour <= 23 && minute <= 59 && second <= 59 && offsetHour <= 23 && offsetMinute <= 59 &&
+        Number.isFinite(Date.parse(value));
+}
 export function parseMajorSchema(schemaVersion, expectedPrefix, expectedMajor) {
     const match = new RegExp(`^${expectedPrefix}\\.v(\\d+)$`).exec(schemaVersion);
     if (!match) {
@@ -264,6 +286,7 @@ export function parseLaneEnvelope(raw) {
         "schema_version",
         "decision",
         "summary",
+        "next_check_at",
         "questions",
         "story_status",
         "artifacts",
@@ -280,6 +303,13 @@ export function parseLaneEnvelope(raw) {
         throw new LaneSchemaError(`Unknown envelope decision ${JSON.stringify(raw.decision)}. Accepted: ${ENVELOPE_DECISIONS.join(", ")}`, { accepted: [...ENVELOPE_DECISIONS], value: raw.decision });
     }
     const summary = requireString(raw.summary, "summary");
+    let nextCheckAt;
+    if (raw.next_check_at !== undefined) {
+        if (typeof raw.next_check_at !== "string") {
+            throw new LaneSchemaError("next_check_at must be a string", { field: "next_check_at" });
+        }
+        nextCheckAt = raw.next_check_at;
+    }
     if (typeof raw.story_status !== "string" ||
         !STORY_STATUSES.includes(raw.story_status)) {
         throw new LaneSchemaError(`Unknown story_status ${JSON.stringify(raw.story_status)}. Accepted: ${STORY_STATUSES.join(", ")}`, { accepted: [...STORY_STATUSES], value: raw.story_status });
@@ -344,6 +374,8 @@ export function parseLaneEnvelope(raw) {
         story_status: storyStatus,
         artifacts: raw.artifacts,
     };
+    if (nextCheckAt !== undefined)
+        envelope.next_check_at = nextCheckAt;
     if (storyComplete !== undefined) {
         envelope.story_complete = storyComplete;
         envelope.story_complete_reason = storyCompleteReason;

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

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

package/dist/lib/lanes/watch.js

@@ -1,7 +1,7 @@
 import { listQuestionIds, readLane, readQuestion, } from "./store.js";
 import { LaneNotFoundError, LanesError } from "./errors.js";
 import { providerSupportsSessionResume } from "./delivery.js";
-import { canResumeDoneKeepAliveLane, hasPendingKeepAliveWork, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, } from "./keep-alive.js";
+import { canResumeDoneKeepAliveLane, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, } from "./keep-alive.js";
 import { isTerminalLaneState, } from "./types.js";
 export const DEFAULT_LANE_WATCH_INTERVAL_MS = 5_000;
 export const MAX_LANE_WATCH_INTERVAL_MS = 30_000;
@@ -32,7 +32,7 @@ function validateLaneIds(laneIds) {
     }
     return unique;
 }
-function canResumeKeepAliveLane(hqRoot, lane) {
+function canResumeKeepAliveLane(hqRoot, lane, nextCheckAtEnabled = false, nowMs = Date.now()) {
     if (lane.keep_alive !== true ||
         lane.keep_alive_opted_in_at === undefined ||
         !Number.isFinite(Date.parse(lane.keep_alive_opted_in_at)) ||
@@ -49,7 +49,15 @@ function canResumeKeepAliveLane(hqRoot, lane) {
         return lane.terminal_reason === "exited_with_partial_output";
     }
     if (lane.state === "done") {
-        return canResumeDoneKeepAliveLane(lane, { decision: lane.last_envelope?.decision, story_complete: lane.story_complete }, lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane)) &&
+        const hasPendingWork = lane.keep_alive_standing === true || nextCheckAtEnabled
+            ? hasPendingKeepAliveWork(hqRoot, lane)
+            : false;
+        const nextCheckAtMs = nextCheckAtEnabled && !hasPendingWork
+            ? keepAliveNextCheckAtMs(lane.last_envelope?.next_check_at, nowMs, Date.parse(lane.last_envelope?.at ?? lane.updated_at))
+            : undefined;
+        if (nextCheckAtMs !== undefined && nowMs < nextCheckAtMs)
+            return false;
+        return canResumeDoneKeepAliveLane(lane, { decision: lane.last_envelope?.decision, story_complete: lane.story_complete, next_check_at: lane.last_envelope?.next_check_at }, lane.keep_alive_standing === true && hasPendingWork) &&
             lane.terminal_reason !== "provider_rejected" &&
             lane.terminal_reason !== "account_not_logged_in";
     }
@@ -131,9 +139,14 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
         const keepAliveWaiting = new Set();
         if (deps.keepAliveEnabled !== undefined) {
             for (const record of records) {
-                if (isTerminalLaneState(record.state) &&
-                    canResumeKeepAliveLane(hqRoot, record) &&
-                    await deps.keepAliveEnabled(record))
+                if (!isTerminalLaneState(record.state) || !canResumeKeepAliveLane(hqRoot, record))
+                    continue;
+                if (!await deps.keepAliveEnabled(record))
+                    continue;
+                const nextCheckAtEnabled = deps.keepAliveNextCheckAtEnabled === undefined
+                    ? false
+                    : await deps.keepAliveNextCheckAtEnabled(record);
+                if (canResumeKeepAliveLane(hqRoot, record, nextCheckAtEnabled))
                     keepAliveWaiting.add(record.lane_id);
             }
         }

package/dist/lib/lanes/watcher.js

@@ -424,6 +424,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
                 at,
                 artifacts: envelope.artifacts,
                 ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
+                ...(envelope.next_check_at !== undefined ? { next_check_at: envelope.next_check_at } : {}),
             };
             if (storySwitch.clearPending) {
                 next.story_switch_pending = undefined;
@@ -769,15 +770,30 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
     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 deliverFallback = false;
+    let retryUndeliverable = false;
+    let undeliverableReason;
     let escalationText = "";
+    const sessionInbox = lane.senior.kind === "session"
+        ? lane.senior.id
+            ? findBlockerFreshnessSessionInbox(hqRoot, lane.senior.id)
+            : { reason: "The session senior has no session id" }
+        : undefined;
     let updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
         deliverEscalation = false;
+        deliverFallback = false;
+        retryUndeliverable = false;
+        undeliverableReason = undefined;
         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 pendingUndeliverable = prior?.undeliverable_fingerprint === fingerprint;
+        const failedFallback = history.find((entry) => entry.event === "blocker_stale_escalation_undeliverable" &&
+            entry.fingerprint === fingerprint && entry.delivery_failed === true &&
+            entry.delivery_recovered !== true);
         const statusResumeQueued = history.some((entry) => entry.event === "status_missed" && entry.turn_id === turnId && entry.resume_queued === true);
         let resumeQueued = false;
         let resumeSkippedReason;
@@ -819,6 +835,37 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
             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}.`;
+            if (lane.senior.kind === "session" && sessionInbox !== undefined && !("inbox" in sessionInbox)) {
+                deliverFallback = true;
+                undeliverableReason = sessionInbox.reason;
+                nextHistory = appendCappedHistory(nextHistory, {
+                    event: "blocker_stale_escalation_undeliverable",
+                    turn_id: turnId,
+                    path: resolution.statusPath,
+                    at,
+                    labels: staleLabels,
+                    count: resolution.stale.length,
+                    fingerprint,
+                    reason: sessionInbox.reason,
+                });
+            }
+        }
+        else if (pendingUndeliverable && sessionInbox !== undefined && "inbox" in sessionInbox) {
+            // A monitor inbox registered after the local fallback appeared; retry delivery once.
+            deliverEscalation = true;
+            retryUndeliverable = true;
+            escalationText = `Blocker freshness escalation for ${current.lane_id}: these blockers remain stale after consecutive turns: ${staleLabels.join(", ")}. Status file: ${resolution.statusPath}.`;
+        }
+        else if (failedFallback !== undefined && sessionInbox !== undefined && "inbox" in sessionInbox) {
+            // Prefer the newly available senior inbox over retrying a failed local fallback.
+            deliverEscalation = true;
+            retryUndeliverable = true;
+            escalationText = `Blocker freshness escalation for ${current.lane_id}: these blockers remain stale after consecutive turns: ${staleLabels.join(", ")}. Status file: ${resolution.statusPath}.`;
+        }
+        else if (failedFallback !== undefined) {
+            deliverFallback = true;
+            undeliverableReason = failedFallback.reason ?? prior?.undeliverable_reason ?? "The session senior inbox is unavailable";
+            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;
@@ -829,13 +876,68 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
                 stale_keys: staleKeys,
                 stale_labels: staleLabels,
                 ...(escalatedFingerprint !== undefined ? { escalated_fingerprint: escalatedFingerprint } : {}),
+                ...(undeliverableReason !== undefined
+                    ? { undeliverable_fingerprint: fingerprint, undeliverable_reason: undeliverableReason }
+                    : prior?.undeliverable_fingerprint === fingerprint
+                        ? { undeliverable_fingerprint: fingerprint, undeliverable_reason: prior.undeliverable_reason }
+                        : {}),
             },
             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) {
+    const escalated = updated.status_gate_history?.find((entry) => entry.event === "blocker_stale_escalated" && entry.fingerprint === fingerprint &&
+        (entry.turn_id === turnId || retryUndeliverable || deliverFallback));
+    if (escalated && deliverFallback) {
+        const reason = undeliverableReason ?? "The session senior has no unique monitor-session inbox";
+        try {
+            appendDropboxMessageAtPath(path.join(laneRunDir(hqRoot, lane.lane_id), "dropbox"), {
+                at,
+                message_id: `blocker-freshness-undeliverable:${lane.lane_id}:${fingerprint}`,
+                kind: "blocker_stale_escalation_undeliverable",
+                text: `${escalationText} The session senior inbox is unavailable (${reason}); this escalation is recorded in the lane inbox for its next turn.`,
+            });
+            updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+                const state = current.blocker_freshness_state;
+                if (state === undefined)
+                    return current;
+                return {
+                    ...current,
+                    blocker_freshness_state: {
+                        ...state,
+                        undeliverable_fingerprint: fingerprint,
+                        undeliverable_reason: reason,
+                    },
+                    status_gate_history: (current.status_gate_history ?? []).map((entry) => entry.event === "blocker_stale_escalation_undeliverable" &&
+                        entry.fingerprint === fingerprint && entry.delivery_failed === true
+                        ? { ...entry, delivery_recovered: true }
+                        : entry),
+                };
+            });
+            logDecision({ event: "blocker_stale_escalation_undeliverable", at, turn_id: turnId, fingerprint, reason, fallback: "lane_dropbox" });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`hq lanes watcher: blocker freshness fallback delivery failed for ${lane.lane_id}: ${message}\n`);
+            logDecision({ event: "blocker_stale_escalation_fallback_failed", at, turn_id: turnId, fingerprint, error: message });
+            updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+                const state = current.blocker_freshness_state;
+                const retryableState = state === undefined ? undefined : { ...state };
+                if (retryableState !== undefined) {
+                    delete retryableState.undeliverable_fingerprint;
+                    delete retryableState.undeliverable_reason;
+                }
+                return {
+                    ...current,
+                    ...(retryableState !== undefined ? { blocker_freshness_state: retryableState } : {}),
+                    status_gate_history: (current.status_gate_history ?? []).map((entry) => entry.event === "blocker_stale_escalation_undeliverable" && entry.fingerprint === fingerprint
+                        ? { ...entry, delivery_failed: true }
+                        : entry),
+                };
+            });
+        }
+    }
+    if ((escalated || retryUndeliverable) && deliverEscalation && !deliverFallback) {
         try {
             if (lane.senior.kind === "lane" && lane.senior.id) {
                 if (deps.deliverLaneSeniorMessage === undefined) {
@@ -844,7 +946,9 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
                 await deps.deliverLaneSeniorMessage(lane.senior.id, escalationText);
             }
             else if (lane.senior.kind === "session" && lane.senior.id) {
-                const inbox = resolveBlockerFreshnessSessionInbox(hqRoot, lane.senior.id);
+                const inbox = sessionInbox !== undefined && "inbox" in sessionInbox
+                    ? sessionInbox.inbox
+                    : resolveBlockerFreshnessSessionInbox(hqRoot, lane.senior.id);
                 appendDropboxMessageAtPath(inbox, {
                     at,
                     message_id: `blocker-freshness:${lane.lane_id}:${fingerprint}:${turnId}`,
@@ -856,6 +960,26 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
                 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 });
+            if (retryUndeliverable) {
+                updated = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+                    const state = current.blocker_freshness_state;
+                    const failedFallbackStillOpen = (current.status_gate_history ?? []).some((entry) => entry.event === "blocker_stale_escalation_undeliverable" &&
+                        entry.fingerprint === fingerprint && entry.delivery_failed === true &&
+                        entry.delivery_recovered !== true);
+                    if (state?.undeliverable_fingerprint !== fingerprint && !failedFallbackStillOpen)
+                        return current;
+                    const recoveredHistory = (current.status_gate_history ?? []).map((entry) => entry.event === "blocker_stale_escalation_undeliverable" && entry.fingerprint === fingerprint
+                        ? { ...entry, delivery_recovered: true }
+                        : entry);
+                    if (state?.undeliverable_fingerprint === fingerprint) {
+                        const recoveredState = { ...state };
+                        delete recoveredState.undeliverable_fingerprint;
+                        delete recoveredState.undeliverable_reason;
+                        return { ...current, blocker_freshness_state: recoveredState, status_gate_history: recoveredHistory };
+                    }
+                    return { ...current, status_gate_history: recoveredHistory };
+                });
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -950,7 +1074,7 @@ async function settleKrFreshness(hqRoot, lane, manifestTurnId, at, deps, logDeci
         };
     });
 }
-function resolveBlockerFreshnessSessionInbox(hqRoot, sessionId) {
+function findBlockerFreshnessSessionInbox(hqRoot, sessionId) {
     let candidates;
     try {
         candidates = LANE_PROVIDERS
@@ -958,14 +1082,20 @@ function resolveBlockerFreshnessSessionInbox(hqRoot, 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 });
+        return { reason: `Could not resolve the monitor inbox for session senior: ${error instanceof Error ? error.message : String(error)}` };
     }
     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 { reason: candidates.length === 0
+                ? "No monitor-session inbox is registered for the session senior"
+                : "The session senior matches more than one monitor-session inbox" };
     }
-    return path.join(candidates[0], "dropbox");
+    return { inbox: path.join(candidates[0], "dropbox") };
+}
+function resolveBlockerFreshnessSessionInbox(hqRoot, sessionId) {
+    const result = findBlockerFreshnessSessionInbox(hqRoot, sessionId);
+    if ("inbox" in result)
+        return result.inbox;
+    throw new LanesError("blocker_freshness_session_inbox_unavailable", result.reason, { session_id: sessionId });
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/mesh/live/daemon/run.js

@@ -449,6 +449,40 @@ export async function runMeshDaemon(deps = {}) {
                 })).status === "authorized",
             });
         });
+    let boardRefreshFailureActive = false;
+    const refreshBoardsWithDiagnostics = async () => {
+        try {
+            const result = await refreshFn();
+            if (boardRefreshFailureActive) {
+                log(dir, "mesh-board-refresh.recovered");
+                boardRefreshFailureActive = false;
+            }
+            return result;
+        }
+        catch (error) {
+            if (!boardRefreshFailureActive) {
+                const rawName = error instanceof Error ? error.name : typeof error;
+                const errorName = rawName.replace(/[^A-Za-z0-9_.-]/g, "").slice(0, 80) || "Error";
+                const rawMessage = error instanceof Error
+                    ? error.message
+                    : typeof error === "string"
+                        ? error
+                        : "non-Error rejection";
+                const message = rawMessage
+                    .replace(/[\r\n\t]+/g, " ")
+                    .replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]")
+                    .replace(/op:\/\/[^\s"]+/gi, "op://[REDACTED]")
+                    .replace(/https?:\/\/[^\s"<>]+/gi, "[URL]")
+                    .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]+|AKIA[0-9A-Z]{16}|eyJ[A-Za-z0-9_.-]{10,})\b/gi, "[REDACTED]")
+                    .replace(/\b(?:access[_-]?token|refresh[_-]?token|id[_-]?token|token|cookie|authorization)\b\s*[:=]\s*[^\s,;&]+/gi, "credential=[REDACTED]")
+                    .replace(/\b(?:cmp|prs|prj|sess?)_[A-Za-z0-9_-]+\b/gi, "[ID]")
+                    .slice(0, 160);
+                log(dir, `mesh-board-refresh.failed errorName=${errorName} message=${message || "[empty]"}`);
+            }
+            boardRefreshFailureActive = true;
+            throw error;
+        }
+    };
     let presence = null;
     let workCache = null;
     if (deps.enablePresence !== false) {
@@ -743,7 +777,7 @@ export async function runMeshDaemon(deps = {}) {
     boardIntervalHandle = timers.setTimeout(function boardTick() {
         if (stopped)
             return;
-        void refreshFn()
+        void refreshBoardsWithDiagnostics()
             .catch(() => undefined)
             .finally(() => {
             if (stopped)
@@ -810,7 +844,7 @@ export async function runMeshDaemon(deps = {}) {
     else {
         void activateDefaultCompany();
     }
-    void refreshFn().catch(() => undefined);
+    void refreshBoardsWithDiagnostics().catch(() => undefined);
     if (emitPath) {
         void runTranscriptTick();
     }