@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/lanes/watcher.js

@@ -1,1972 +0,0 @@
-/**
- * Per-lane watcher (spec §5.7).
- *
- * Armed at spawn, detached from the caller. Emits on progress, terminal, and
- * silence (20 minutes with the process still alive). Terminal classification
- * follows spec §5: an envelope decides done/ask/blocked; a process that exits
- * with partial output and no envelope is `interrupted`; silence is never
- * success.
- *
- * Progress has two sources. Output files (worker.out, worker.err,
- * last-message.txt) cover codex and grok, which stream as they work. They do
- * not cover Claude: `claude -p --output-format json` writes nothing until it
- * exits, so a healthy Claude lane used to hit the silence deadline at exactly
- * 20 minutes every time, and a hung one looked identical. The second source
- * is logs/tool-activity.json, which the drain hook rewrites on every
- * PreToolUse call (dropbox.ts). A worker that is working calls tools; a
- * worker that has not called a tool or written output for the whole window
- * is `stalled`, and the watcher says so on the lane record.
- *
- * What this cannot tell apart: a worker hung inside one tool call from a
- * worker running one legitimately long tool call (a 25-minute build); a
- * worker looping on tool calls without making progress from a working one;
- * a model stuck mid-generation with no tool call from one that is writing a
- * long answer. It also depends on the drain hook being registered in the
- * provider home (hooks-install.ts): with no hook there is no touch, and the
- * lane reads as stalled every window, which is the pre-existing behaviour.
- * Distinguishing a hung tool from a slow one needs the provider to report
- * per-call state, which none of the three CLIs expose today. `stalled` is
- * therefore a flag for the senior to look at, never a kill.
- *
- * Queue admission of the next lane when a slot frees is owned by the
- * periodic reconcile pass and is out of scope here.
- */
-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, LANE_PROVIDERS, } from "./types.js";
-import { laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
-import { applyStorySwitchEnvelope } from "./story-switch.js";
-import { appendCappedHistory, listQuestionIds, readLane, readQuestion, retryUpdateLane, withLaneHireLocks } from "./store.js";
-import { enforceRegistryApprovalGate } from "./approval-gate.js";
-import { readWorkerRunResult } from "./delivery.js";
-import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
-import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.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 { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
-import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
-import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
-import { managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, } from "./manager-status-gate.js";
-import { LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_FLAG, queueLaneTerminalResume, queueManagerStatusGateResume, } from "./keep-alive.js";
-import { LANE_ENVELOPE_REPAIR_CONTINUE_FLAG } from "./flag-keys.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;
-export const WATCHER_POLL_MS = 5_000;
-export const ENVELOPE_REPAIR_CONTINUE_TEXT = "continue the task; the previous turn ended without an envelope.";
-/** Synced last_host_report_at cadence. Reconcile dead-host TTL is 20 minutes. */
-export const WATCHER_HEARTBEAT_MS = 60 * 1000;
-/**
- * Cap on logs/watcher.out. A decision line is typically under 300 bytes, so
- * 256 KiB holds hundreds of transitions. A stuck lane cannot fill the disk:
- * once the file would exceed this, the oldest complete lines are dropped.
- */
-export const WATCHER_OUT_MAX_BYTES = 256 * 1024;
-export const WATCHER_DECISION_EVENTS = [
-    "liveness_transition",
-    "silence_deadline",
-    "envelope_observed",
-    "envelope_invalid",
-    "envelope_repair",
-    "envelope_repair_continue",
-    "classification",
-    "terminal_write",
-    "message_recovery",
-    "message_recovery_failed",
-    "message_undeliverable",
-    "mesh_event",
-    "mesh_event_failed",
-];
-/** Terminal reason when the envelope failed to parse after the repair turn (spec §4). */
-export { ENVELOPE_INVALID_REASON };
-export const WATCHER_SIGNAL_KINDS = ["progress", "terminal", "silence"];
-export function parseWatcherSignalKind(value) {
-    if (typeof value === "string" &&
-        WATCHER_SIGNAL_KINDS.includes(value)) {
-        return value;
-    }
-    throw new LanesError("unknown_watcher_signal", `Unknown watcher signal ${JSON.stringify(value)}. Accepted: ${WATCHER_SIGNAL_KINDS.join(", ")}`, { accepted: [...WATCHER_SIGNAL_KINDS], value });
-}
-export function classifyLaneExit(input) {
-    if (input.envelope) {
-        if (input.envelope.decision === "done")
-            return { state: "done" };
-        if (input.envelope.decision === "ask")
-            return { state: "awaiting_input" };
-        if (input.envelope.decision === "blocked")
-            return { state: "blocked" };
-        throw new LanesError("unknown_envelope_decision", `Unknown envelope decision ${JSON.stringify(input.envelope.decision)}. Accepted: done, ask, blocked`, { accepted: ["done", "ask", "blocked"], value: input.envelope.decision });
-    }
-    if (input.providerRejection) {
-        return {
-            state: "failed",
-            reason: isProviderLoginFailure(input.providerRejection)
-                ? "account_not_logged_in"
-                : PROVIDER_REJECTED_REASON,
-        };
-    }
-    if (input.invalidEnvelope) {
-        return { state: "failed", reason: ENVELOPE_INVALID_REASON };
-    }
-    if (input.quota) {
-        return {
-            state: input.hasPartialOutput ? "interrupted" : "failed",
-            reason: input.quota.reason,
-        };
-    }
-    if (input.hasPartialOutput) {
-        return { state: "interrupted", reason: "exited_with_partial_output" };
-    }
-    return { state: "failed", reason: "exited_without_envelope" };
-}
-/**
- * One decision for an exited worker's output. An explicit provider status
- * wins over the quota text heuristics: a 429 from any provider (including
- * codex `turn.failed` and grok error objects, which the claude-shaped quota
- * reader never sees) becomes a quota signal; any other explicit status is a
- * rejection even when its text sounds like a quota message (a 402 "requires
- * usage credits" is a rejection, not a hold). A failure with no status at
- * all is matched against the quota text heuristics first: a status-less
- * "usage limit" / "rate limit" turn.failed still creates the account hold;
- * any other status-less message is a rejection. Only when the stream
- * carries no failure object does the quota reader's own read apply.
- */
-export function routeProviderFailure(failure, readQuota, model, now) {
-    if (failure && failure.status === QUOTA_STATUS) {
-        return {
-            quota: quotaSignalFromFields({ api_error_status: QUOTA_STATUS, is_error: true, result: failure.message }, model, now),
-            rejection: null,
-        };
-    }
-    if (failure && failure.status === null) {
-        const quota = quotaSignalFromFields({ api_error_status: undefined, is_error: true, result: failure.message }, model, now);
-        if (quota)
-            return { quota, rejection: null };
-    }
-    if (failure)
-        return { quota: null, rejection: failure };
-    return { quota: readQuota(), rejection: null };
-}
-export function tickWatcher(input) {
-    const silenceMs = input.silenceMs ?? SILENCE_MS;
-    const at = new Date(input.nowMs).toISOString();
-    if (!input.processAlive) {
-        const classification = classifyLaneExit({
-            envelope: input.envelope,
-            hasPartialOutput: input.hasPartialOutput,
-            quota: input.quota,
-            invalidEnvelope: input.invalidEnvelope,
-            providerRejection: input.providerRejection,
-        });
-        return {
-            emit: { kind: "terminal", at, classification },
-            nextLastSignalMs: input.nowMs,
-            done: true,
-        };
-    }
-    if (input.progressed) {
-        return {
-            emit: { kind: "progress", at },
-            nextLastSignalMs: input.nowMs,
-            done: false,
-        };
-    }
-    if (input.nowMs - input.lastSignalMs >= silenceMs) {
-        return {
-            emit: { kind: "silence", at },
-            nextLastSignalMs: input.nowMs,
-            done: false,
-        };
-    }
-    return { nextLastSignalMs: input.lastSignalMs, done: false };
-}
-export function watcherEventsPath(hqRoot, laneId) {
-    return path.join(laneRunDir(hqRoot, laneId), "watcher", "events.jsonl");
-}
-export function watcherOutLogPath(hqRoot, laneId) {
-    return path.join(laneRunDir(hqRoot, laneId), "logs", "watcher.out");
-}
-export function appendCappedLog(filePath, line, maxBytes = WATCHER_OUT_MAX_BYTES) {
-    const payload = line.endsWith("\n") ? line : `${line}\n`;
-    const payloadBytes = Buffer.byteLength(payload, "utf8");
-    if (payloadBytes > maxBytes)
-        return;
-    let existing = "";
-    try {
-        existing = fs.readFileSync(filePath, "utf8");
-    }
-    catch (err) {
-        const code = err.code;
-        if (code !== "ENOENT")
-            throw err;
-    }
-    let body = existing;
-    while (Buffer.byteLength(body, "utf8") + payloadBytes > maxBytes) {
-        const nl = body.indexOf("\n");
-        if (nl === -1) {
-            body = "";
-            break;
-        }
-        body = body.slice(nl + 1);
-    }
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, body + payload, "utf8");
-}
-export function writeWatcherDecision(filePath, record, maxBytes = WATCHER_OUT_MAX_BYTES) {
-    const compact = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (value !== undefined)
-            compact[key] = value;
-    }
-    appendCappedLog(filePath, JSON.stringify(compact), maxBytes);
-}
-/** Append a decision to the shared event stream without a read-modify-write. */
-export function appendWatcherEvent(filePath, record, appendLine = (target, line) => fs.appendFileSync(target, line, "utf8")) {
-    const compact = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (value !== undefined)
-            compact[key] = value;
-    }
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    appendLine(filePath, `${JSON.stringify(compact)}\n`);
-}
-export function watcherLastSignalPath(hqRoot, laneId) {
-    return path.join(laneRunDir(hqRoot, laneId), "watcher", "last-signal.json");
-}
-export function appendWatcherSignal(hqRoot, laneId, signal) {
-    const eventsPath = watcherEventsPath(hqRoot, laneId);
-    fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
-    fs.appendFileSync(eventsPath, `${JSON.stringify(signal)}\n`, "utf8");
-    fs.writeFileSync(watcherLastSignalPath(hqRoot, laneId), `${JSON.stringify(signal, null, 2)}\n`, "utf8");
-}
-/**
- * Slot-free notification. The periodic reconcile pass admits the next queued
- * lane; this watcher must not do it. Intentionally empty.
- */
-export function notifySlotFreed(_input) {
-    // Reconcile lane owns admission when a running slot frees (spec §5.7).
-}
-/**
- * On exit, read the worker's own result for a resumable provider and copy
- * only the session id and the two cache counters onto the record. A missing
- * or unparseable id is recorded as absent with its reason, never invented.
- * Non-resumable providers return null and the record is left as it was.
- */
-function runResultFields(hqRoot, lane, at) {
-    const runDir = laneRunDir(hqRoot, lane.lane_id);
-    const result = readWorkerRunResult(runDir, lane.provider, readSpawnManifest(runDir).worker_out_offset ?? 0);
-    if (result === null)
-        return {};
-    const fields = {
-        last_run_usage: {
-            cache_read_input_tokens: result.cache_read_input_tokens,
-            cache_creation_input_tokens: result.cache_creation_input_tokens,
-        },
-        last_run_usage_at: at,
-    };
-    if (result.session_id !== null) {
-        fields.provider_session_id = result.session_id;
-        fields.provider_session_id_absent = undefined;
-    }
-    else {
-        // A resumed provider may exit before it emits a new result object. Keep
-        // the prior session id so the lane remains resumable; only describe an
-        // absent id when no earlier run recorded one.
-        if (lane.provider_session_id || lane.last_resume?.session_id) {
-            fields.provider_session_id_absent = undefined;
-        }
-        else {
-            fields.provider_session_id_absent = result.session_id_absent ?? "no_result_json";
-        }
-    }
-    return fields;
-}
-function maybeHeartbeatLane(hqRoot, laneId, nowMs) {
-    try {
-        retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
-            if (current.state !== "running")
-                return current;
-            const last = Date.parse(current.last_host_report_at ?? "");
-            if (Number.isFinite(last) && nowMs - last < WATCHER_HEARTBEAT_MS) {
-                return current;
-            }
-            return { ...current, last_host_report_at: new Date(nowMs).toISOString() };
-        });
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: heartbeat failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-}
-export function stalledReason(silenceMs) {
-    return `no_tool_call_or_output_for_${Math.round(silenceMs / 1000)}s`;
-}
-/**
- * The consumer of the silence signal. A silence emit on a running lane sets
- * `stalled` on the record so `hq lanes list` and `show` surface it; the next
- * progress emit clears it. Nothing here changes `state`.
- */
-export function markLaneStalled(hqRoot, laneId, at, reason) {
-    return retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
-        if (current.state !== "running")
-            return current;
-        if (current.stalled === true && current.stalled_reason === reason)
-            return current;
-        return { ...current, stalled: true, stalled_at: at, stalled_reason: reason };
-    });
-}
-export function clearLaneStalled(hqRoot, laneId) {
-    return retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
-        if (current.stalled === undefined && current.stalled_at === undefined)
-            return current;
-        return { ...current, stalled: undefined, stalled_at: undefined, stalled_reason: undefined };
-    });
-}
-export function applyTerminalToLane(hqRoot, laneId, classification, opts = {}) {
-    return applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts).record;
-}
-/** Terminal write outcome for emitters: only the CAS winner may publish mesh effects. */
-export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}) {
-    const at = opts.at ?? new Date().toISOString();
-    const envelopeRef = opts.envelopeRef ?? "envelopes/unknown.json";
-    const existing = readLane(hqRoot, laneId);
-    let questionRefusalCode = null;
-    if (!isTerminalLaneState(existing.state) &&
-        classification.state === "awaiting_input" &&
-        opts.envelope &&
-        (opts.envelope.questions?.length ?? 0) > 0) {
-        try {
-            raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes, opts.activeCompany);
-        }
-        catch (err) {
-            questionRefusalCode = questionRecordRefusalCode(err);
-            if (questionRefusalCode === null)
-                throw err;
-            process.stderr.write(`hq lanes watcher: terminal ask refused for ${laneId}: ${questionRefusalCode}\n`);
-        }
-    }
-    const terminalClassification = questionRefusalCode === null
-        ? classification
-        : {
-            state: "failed",
-            reason: `question_record_refused:${questionRefusalCode}`,
-        };
-    let changed = false;
-    let effectiveEnvelope = opts.envelope ?? undefined;
-    let effectiveClassification = terminalClassification;
-    const updated = retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
-        const approvalGate = opts.envelope !== undefined && opts.envelope !== null
-            ? enforceRegistryApprovalGate(current, opts.envelope)
-            : undefined;
-        effectiveEnvelope = approvalGate?.envelope ?? opts.envelope ?? undefined;
-        effectiveClassification = approvalGate?.violation
-            ? { state: "blocked", reason: "approval_gate_violated" }
-            : terminalClassification;
-        const terminal = current.state === "done" ||
-            current.state === "failed" ||
-            current.state === "interrupted" ||
-            current.state === "cancelled" ||
-            current.state === "killed";
-        if (terminal)
-            return current;
-        if (current.state === "awaiting_input" || current.state === "blocked") {
-            if (current.state === effectiveClassification.state)
-                return current;
-        }
-        const next = {
-            ...current,
-            ...runResultFields(hqRoot, current, at),
-            state: effectiveClassification.state,
-            queued_reason: undefined,
-            queued_details: undefined,
-            stalled: undefined,
-            stalled_at: undefined,
-            stalled_reason: undefined,
-            interrupted_at: effectiveClassification.state === "interrupted" ? at : undefined,
-            envelope_validation_errors: opts.envelopeValidationErrors,
-        };
-        changed = true;
-        if (effectiveClassification.reason) {
-            next.terminal_reason =
-                effectiveClassification.reason;
-        }
-        if (opts.quota?.quota_reset_at) {
-            next.quota_reset_at = opts.quota.quota_reset_at;
-        }
-        if (opts.quota?.marker) {
-            next.model_quota_marker = opts.quota.marker;
-        }
-        if (opts.providerRejection) {
-            next.terminal_details = providerRejectionDetails(opts.providerRejection, current);
-        }
-        const envelope = effectiveEnvelope;
-        if (approvalGate && !approvalGate.violation && approvalGate.approvedIdsToConsume.length > 0) {
-            next.registry_worker_approval_history = approvalGate.approvedIdsToConsume.reduce((history, approvalId) => appendCappedHistory(history, {
-                event: "consumed",
-                approval_id: approvalId,
-                envelope_ref: envelopeRef,
-                at,
-            }), current.registry_worker_approval_history ?? []);
-        }
-        if (envelope) {
-            const storySwitch = applyStorySwitchEnvelope(current, envelope, at, envelopeRef);
-            if (envelope.decision !== "blocked")
-                next.keep_alive_blocked_resume_streak = 0;
-            next.last_envelope = {
-                ref: envelopeRef,
-                decision: envelope.decision,
-                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;
-            }
-            if (storySwitch.storySwitchUnacknowledged !== undefined) {
-                next.story_switch_unacknowledged = storySwitch.storySwitchUnacknowledged;
-                next.attribution_history = storySwitch.attributionHistory ?? current.attribution_history;
-            }
-            const storyStatus = storySwitch.suppressCompletion
-                ? "in_progress"
-                : terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
-            if (storyStatus !== undefined) {
-                next.story_status = storySwitch.suppressCompletion ? "in_progress" : envelope.story_status;
-                next.story_complete = storySwitch.suppressCompletion ? false : envelope.story_complete;
-                next.story_complete_reason = storySwitch.suppressCompletion ? undefined : envelope.story_complete_reason;
-                const currentProject = current.project_id;
-                const currentStory = current.story_id;
-                const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
-                    ? {
-                        ...story,
-                        status: storyStatus,
-                        updated_at: at,
-                        ...(envelope.decision === "blocked"
-                            ? { blocked_reason: envelope.blocked_reason ?? "" }
-                            : { blocked_reason: undefined }),
-                    }
-                    : story);
-                next.stories = updatedStories;
-            }
-        }
-        return next;
-    });
-    if (updated.state === "done" &&
-        effectiveClassification.state === "done" &&
-        effectiveEnvelope?.decision === "done" &&
-        opts.quota == null &&
-        opts.providerRejection == null &&
-        updated.account &&
-        updated.model) {
-        clearAccountQuotaAfterSuccessfulTurnBestEffort(hqRoot, updated.provider, updated.account, updated.model, new Date(at));
-    }
-    notifySlotFreed({
-        hqRoot,
-        provider: updated.provider,
-        account: updated.account,
-    });
-    return {
-        record: updated,
-        changed,
-        ...(effectiveEnvelope !== undefined ? { envelope: effectiveEnvelope } : {}),
-        classification: effectiveClassification,
-    };
-}
-export function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ESRCH")
-            return false;
-        if (code === "EPERM")
-            return true;
-        process.stderr.write(`hq lanes watcher: liveness probe for pid ${pid} failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-}
-function fileMtimeMs(filePath) {
-    try {
-        return fs.statSync(filePath).mtimeMs;
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            return null;
-        process.stderr.write(`hq lanes watcher: failed to stat ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-}
-function fileNonEmpty(filePath) {
-    try {
-        return fs.statSync(filePath).size > 0;
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            return false;
-        process.stderr.write(`hq lanes watcher: failed to stat ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-}
-function isPlainObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** Keep only questions that the normal envelope parser accepts. */
-function recoverAskEnvelope(text, validationErrors) {
-    const raw = JSON.parse(text);
-    if (!isPlainObject(raw) || raw.decision !== "ask" || !Array.isArray(raw.questions)) {
-        return null;
-    }
-    const validQuestions = [];
-    const questionIndexes = [];
-    const questionErrors = [];
-    for (let index = 0; index < raw.questions.length; index += 1) {
-        const question = raw.questions[index];
-        try {
-            const parsed = parseLaneEnvelope({
-                schema_version: "hq-lane-envelope.v1",
-                decision: "ask",
-                summary: "Recovered operator question",
-                story_status: "in_progress",
-                artifacts: [],
-                questions: [question],
-            });
-            const item = parsed.questions?.[0];
-            if (item === undefined) {
-                throw new Error("question parser returned no question");
-            }
-            validQuestions.push(item);
-            questionIndexes.push(index);
-        }
-        catch (err) {
-            questionErrors.push(`questions[${index}] is invalid: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    if (validQuestions.length === 0) {
-        return {
-            envelope: {
-                schema_version: "hq-lane-envelope.v1",
-                decision: "ask",
-                summary: "The worker needs operator input after envelope validation failed.",
-                story_status: STORY_STATUSES.includes(raw.story_status)
-                    ? raw.story_status
-                    : "in_progress",
-                artifacts: [],
-                questions: [],
-            },
-            questionIndexes,
-            questionErrors,
-            sourceQuestionCount: raw.questions.length,
-        };
-    }
-    const contextErrors = [...new Set([...validationErrors, ...questionErrors])];
-    const storyStatus = STORY_STATUSES.includes(raw.story_status) && raw.story_status !== "done"
-        ? raw.story_status
-        : "in_progress";
-    const questions = validQuestions.map((question) => ({
-        ...question,
-        context: `${question.context}\n\nEnvelope validation errors:\n${contextErrors.map((error) => `- ${error}`).join("\n")}`,
-    }));
-    return {
-        envelope: {
-            schema_version: "hq-lane-envelope.v1",
-            decision: "ask",
-            summary: typeof raw.summary === "string" && raw.summary.length > 0
-                ? raw.summary
-                : "The worker needs operator input after envelope validation failed.",
-            story_status: storyStatus,
-            artifacts: [],
-            questions,
-        },
-        questionIndexes,
-        questionErrors,
-        sourceQuestionCount: raw.questions.length,
-    };
-}
-export function readLatestEnvelope(hqRoot, laneId, minName) {
-    return readLatestEnvelopeRecord(hqRoot, laneId, minName)?.envelope ?? null;
-}
-/** Valid-only view over `readLatestEnvelopeFile`; an unparseable file reads as absent. */
-export function readLatestEnvelopeRecord(hqRoot, laneId, minName) {
-    const latest = readLatestEnvelopeFile(hqRoot, laneId, minName);
-    if (latest === null)
-        return null;
-    if (latest.envelope === null) {
-        process.stderr.write(`hq lanes watcher: envelope ${latest.path} is not a valid hq-lane-envelope.v1: ${latest.error}\n`);
-        return null;
-    }
-    return { envelope: latest.envelope, ref: latest.ref };
-}
-/**
- * `minName` is this run's envelope slot (basename from spawn.json). Envelopes
- * that sort before it belong to an earlier run of the same lane and must not
- * classify this exit: a resumed run that dies before writing its own envelope
- * would otherwise be marked done again from the previous one.
- */
-export function readLatestEnvelopeFile(hqRoot, laneId, minName) {
-    const dir = path.join(laneRunDir(hqRoot, laneId), "envelopes");
-    let names;
-    try {
-        names = fs
-            .readdirSync(dir)
-            .filter((name) => name.endsWith(".json"))
-            .filter((name) => minName === undefined || name >= minName)
-            .sort();
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
-            return null;
-        process.stderr.write(`hq lanes watcher: failed to list envelopes for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-    if (names.length === 0)
-        return null;
-    const latest = names[names.length - 1];
-    const filePath = path.join(dir, latest);
-    let text;
-    try {
-        text = fs.readFileSync(filePath, "utf8");
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: failed to read envelope ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-    const ref = path.posix.join("envelopes", latest);
-    try {
-        return {
-            ref,
-            path: filePath,
-            text,
-            envelope: parseLaneEnvelope(JSON.parse(text)),
-            error: null,
-        };
-    }
-    catch (err) {
-        return {
-            ref,
-            path: filePath,
-            text,
-            envelope: null,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-/** A descriptor for this run's manifest slot when no envelope file was written. */
-export function missingExpectedEnvelopeFile(hqRoot, laneId, envelopePath) {
-    if (!envelopePath || !path.isAbsolute(envelopePath))
-        return null;
-    const runDir = laneRunDir(hqRoot, laneId);
-    const expectedPath = path.resolve(envelopePath);
-    const expectedDir = path.resolve(runDir, "envelopes");
-    const filename = path.basename(expectedPath);
-    if (path.dirname(expectedPath) !== expectedDir || !filename.endsWith(".json"))
-        return null;
-    return {
-        ref: path.posix.join("envelopes", filename),
-        path: expectedPath,
-        text: "",
-        envelope: null,
-        error: `Missing expected envelope file: ${expectedPath}`,
-        missing: true,
-    };
-}
-async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
-    let target;
-    try {
-        resolveLaneCompany(hqRoot, lane);
-        target = resolveManagerStatusTarget(hqRoot, lane);
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: manager status mapping failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
-        logDecision({ event: "status_gate_mapping_failed", at, error: err instanceof Error ? err.message : String(err) });
-        return lane;
-    }
-    const gate = lane.status_gate;
-    if (!target.manager || target.statusPath === undefined || gate === undefined)
-        return lane;
-    if (manifestTurnId !== undefined && manifestTurnId !== gate.turn_id ||
-        target.statusPath !== gate.status_path) {
-        logDecision({ event: "status_gate_baseline_mismatch", at, turn_id: gate.turn_id });
-        return lane;
-    }
-    let written;
-    try {
-        written = managerStatusWasWritten(gate, readStatusSnapshot(gate.status_path));
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: manager status read failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
-        logDecision({ event: "status_gate_status_read_failed", at, error: err instanceof Error ? err.message : String(err) });
-        written = false;
-    }
-    if (written) {
-        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
-            if (current.status_gate?.turn_id !== gate.turn_id || current.status_gate.consecutive_misses === 0)
-                return current;
-            return { ...current, status_gate: { ...current.status_gate, consecutive_misses: 0 } };
-        });
-    }
-    const resumeText = `Your turn ended without updating ${gate.status_path}. Write your status now: update updated_at, kpis and current_work, then end the turn.`;
-    const updated = queueManagerStatusGateResume(hqRoot, lane.lane_id, {
-        turn_id: gate.turn_id,
-        path: gate.status_path,
-        at,
-        identified_by: target.identified_by ?? "juniors",
-    }, resumeText);
-    const miss = updated.status_gate_history?.find((entry) => entry.event === "status_missed" && entry.turn_id === gate.turn_id);
-    if (miss) {
-        logDecision({
-            event: "status_missed",
-            at,
-            turn_id: gate.turn_id,
-            path: gate.status_path,
-            consecutive_misses: updated.status_gate?.consecutive_misses ?? 0,
-            resume_queued: "resume_queued" in miss && miss.resume_queued === true,
-            resume_skipped_reason: "resume_skipped_reason" in miss ? miss.resume_skipped_reason : undefined,
-            state: updated.state,
-        });
-    }
-    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 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;
-        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}.`;
-            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;
-        }
-        return {
-            ...nextLane,
-            blocker_freshness_state: {
-                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.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) {
-                    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 = sessionInbox !== undefined && "inbox" in sessionInbox
-                    ? sessionInbox.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 });
-            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);
-            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;
-}
-async function settleKrFreshness(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
-    if (manifestTurnId !== undefined && lane.status_gate !== undefined && lane.status_gate.turn_id !== manifestTurnId) {
-        logDecision({ event: "kr_freshness_baseline_mismatch", at, turn_id: lane.status_gate.turn_id });
-        return lane;
-    }
-    let errorLogged = false;
-    const resolution = await resolveKrFreshnessForLane(hqRoot, lane, {
-        readFlag: deps.readKrFreshnessFlag ?? readLanesRegistryFlag,
-        now: Date.parse(at),
-        onError: (error) => {
-            if (errorLogged)
-                return;
-            errorLogged = true;
-            const code = error instanceof LanesError ? error.error : "kr_freshness_unavailable";
-            process.stderr.write(`hq lanes watcher: KR freshness disabled for ${lane.lane_id}: ${code}\n`);
-            logDecision({ event: "kr_freshness_disabled", at, error: code });
-        },
-    });
-    if (!resolution.enabled || resolution.statusPath === undefined || resolution.error !== undefined)
-        return lane;
-    const stalled = resolution.kpis.filter((kpi) => kpi.verdict === "stalled");
-    if (stalled.length === 0) {
-        if (lane.kr_freshness_state === undefined)
-            return lane;
-        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => current.kr_freshness_state === undefined
-            ? current
-            : { ...current, kr_freshness_state: undefined });
-    }
-    const fingerprint = krFreshnessFingerprint(resolution.stalledKeys);
-    const names = stalled.map((kpi) => kpi.name);
-    const turnId = manifestTurnId ?? lane.status_gate?.turn_id ?? `unknown-${at}`;
-    const resumeText = `These KPIs in ${resolution.statusPath} were not re-measured in the last ${resolution.windowHours}h: ${names.join(", ")}. Measure each one now, update value and measured_at, then end the turn.`;
-    return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
-        const history = current.status_gate_history ?? [];
-        if (history.some((entry) => entry.event === "kr_stalled" && entry.turn_id === turnId))
-            return current;
-        const sameStalledSet = current.kr_freshness_state?.stalled_fingerprint === fingerprint;
-        let nextLane = current;
-        let resumeQueued = false;
-        let resumeSkippedReason;
-        if (!sameStalledSet) {
-            const mergeExisting = current.pending_resume !== undefined &&
-                current.state !== "blocked" && current.state !== "awaiting_input";
-            const resume = queueLaneTerminalResume(current, at, resumeText, { mergeExisting });
-            nextLane = resume.lane;
-            resumeQueued = resume.resumeQueued;
-            resumeSkippedReason = resume.resumeSkippedReason;
-        }
-        const entry = {
-            event: "kr_stalled",
-            turn_id: turnId,
-            path: resolution.statusPath,
-            at,
-            names,
-            count: stalled.length,
-            fingerprint,
-            ...(resumeQueued ? { resume_queued: true } : {}),
-            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
-        };
-        return {
-            ...nextLane,
-            kr_freshness_state: { stalled_fingerprint: fingerprint },
-            status_gate_history: appendCappedHistory(history, entry),
-        };
-    });
-}
-function findBlockerFreshnessSessionInbox(hqRoot, sessionId) {
-    let candidates;
-    try {
-        candidates = LANE_PROVIDERS
-            .map((provider) => monitorSessionDir(hqRoot, provider, sessionId))
-            .filter((sessionDir) => fs.existsSync(sessionDir));
-    }
-    catch (error) {
-        return { reason: `Could not resolve the monitor inbox for session senior: ${error instanceof Error ? error.message : String(error)}` };
-    }
-    if (candidates.length !== 1) {
-        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 { 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
- * the event name and the error message, and never propagates: the lane's
- * state is decided by the envelope and the process, not by the network.
- */
-export async function emitMeshSoft(event, logDecision, at, fn, timeoutMs = 10_000) {
-    let timer;
-    try {
-        const controller = new AbortController();
-        await Promise.race([
-            fn(controller.signal),
-            new Promise((_resolve, reject) => {
-                timer = setTimeout(() => { controller.abort(); reject(new Error(`mesh request timed out after ${timeoutMs}ms`)); }, timeoutMs);
-            }),
-        ]);
-        logDecision({ event: "mesh_event", at, mesh_event: event });
-        return true;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logDecision({ event: "mesh_event_failed", at, mesh_event: event, error: message });
-        process.stderr.write(`hq lanes watcher: mesh_event_failed ${event}: ${message}\n`);
-        return false;
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-function readProgressIntervalMs(hqRoot, lane) {
-    try {
-        const config = loadLanesConfig(hqRoot);
-        if (lane)
-            return providerProgressEventMinIntervalMs(config.providers[lane.provider]);
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: lanes config unreadable, using default progress interval: ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-    return providerProgressEventMinIntervalMs({ max_running: 1, max_queued: 1, accounts: {} });
-}
-function readLaneSoft(hqRoot, laneId) {
-    try {
-        return readLane(hqRoot, laneId);
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: lane read failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-        return null;
-    }
-}
-/** Question ids an ask envelope raised, as `raiseEnvelopeQuestions` mints them. */
-export function envelopeQuestionIds(laneId, envelopeRef, envelope, questionIndexes) {
-    return (envelope.questions ?? []).map((_q, i) => envelopeQuestionId(laneId, envelopeRef, questionIndexes?.[i] ?? i));
-}
-function defaultSleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-const WATCHER_LOOP_OWNER_FILE = "watcher-loop.pid";
-function claimWatcherLoop(hqRoot, laneId, deps) {
-    const runDir = laneRunDir(hqRoot, laneId);
-    const ownerPath = path.join(runDir, WATCHER_LOOP_OWNER_FILE);
-    const isAlive = deps.isAlive ?? isPidAlive;
-    const readStarttime = deps.readStarttime ?? readProcStarttime;
-    const owner = withLaneHireLocks(hqRoot, [laneId], () => {
-        fs.mkdirSync(runDir, { recursive: true });
-        const existing = readPidRecord(ownerPath);
-        if (existing !== null && probePidRecord(existing, isAlive, readStarttime).alive) {
-            return null;
-        }
-        if (existing !== null)
-            fs.unlinkSync(ownerPath);
-        writePidRecord(ownerPath, {
-            pid: process.pid,
-            starttime: readStarttime(process.pid) ?? readProcStarttime(process.pid) ?? undefined,
-        });
-        const stat = fs.statSync(ownerPath);
-        return { dev: stat.dev, ino: stat.ino };
-    });
-    if (owner === null)
-        return null;
-    return () => {
-        withLaneHireLocks(hqRoot, [laneId], () => {
-            try {
-                const current = fs.statSync(ownerPath);
-                if (current.dev === owner.dev && current.ino === owner.ino)
-                    fs.unlinkSync(ownerPath);
-            }
-            catch (err) {
-                if (err.code !== "ENOENT")
-                    throw err;
-            }
-        });
-    };
-}
-async function maybeContinueAfterMissingEnvelopeRepair(hqRoot, lane, envelope, envelopeRef, at, deps, logDecision) {
-    const repair = lane.envelope_repair;
-    const missingRepair = repair?.attempted === true &&
-        repair.succeeded === true &&
-        repair.envelope_ref === envelopeRef &&
-        repair.first_error.startsWith("Missing expected envelope file:");
-    if (!missingRepair || envelope === null || envelopeRef === undefined) {
-        if (envelope?.decision === "blocked")
-            logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "not_a_successful_missing_repair", missing_repair: missingRepair, envelope_ref: envelopeRef, repair_ref: repair?.envelope_ref, first_error: repair?.first_error, succeeded: repair?.succeeded });
-        return lane;
-    }
-    const incompleteDone = envelope.decision === "done" && envelope.story_complete === false;
-    const repairInstructionBlock = envelope.decision === "blocked" &&
-        (envelope.questions?.length ?? 0) === 0 &&
-        /(?:not to resume|do not resume|don't resume)(?: the)? task/i.test(envelope.blocked_reason ?? "");
-    if (!incompleteDone && !repairInstructionBlock) {
-        if (envelope.decision === "blocked")
-            logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "blocked_reason_not_repair_instruction", blocked_reason: envelope.blocked_reason });
-        return lane;
-    }
-    if (lane.last_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT) {
-        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "continue_already_used" });
-        return lane;
-    }
-    let pendingQuestion = false;
-    try {
-        for (const id of listQuestionIds(hqRoot)) {
-            const question = readQuestion(hqRoot, id);
-            if (question.lane_id === lane.lane_id && question.status === "pending") {
-                pendingQuestion = true;
-                break;
-            }
-        }
-    }
-    catch (error) {
-        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "question_check_failed", error: error instanceof Error ? error.message : String(error) });
-        return lane;
-    }
-    if (pendingQuestion) {
-        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "pending_question" });
-        return lane;
-    }
-    const readFlag = deps.readEnvelopeRepairContinueFlag ?? readLanesRegistryFlag;
-    let enabled = false;
-    try {
-        const resolution = resolveLaneCompany(hqRoot, lane);
-        const company = resolution.company ?? undefined;
-        enabled = await readFlag(LANE_ENVELOPE_REPAIR_CONTINUE_FLAG, {
-            company,
-            ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
-        });
-    }
-    catch (error) {
-        logDecision({ event: "envelope_repair_continue", at, outcome: "skipped", reason: "flag_read_failed", error: error instanceof Error ? error.message : String(error) });
-        return lane;
-    }
-    if (!enabled)
-        return lane;
-    const queued = retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
-        if (current.version !== lane.version ||
-            (current.state !== "done" && current.state !== "blocked") ||
-            current.last_envelope?.ref !== envelopeRef ||
-            current.envelope_repair?.attempted !== true ||
-            current.envelope_repair.succeeded !== true ||
-            current.envelope_repair.envelope_ref !== envelopeRef ||
-            current.envelope_repair.first_error !== repair.first_error ||
-            current.last_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT)
-            return current;
-        const result = queueLaneTerminalResume(current, at, ENVELOPE_REPAIR_CONTINUE_TEXT, { allowBlockedResume: true });
-        if (!result.resumeQueued || result.lane.pending_resume?.session_id === undefined)
-            return current;
-        return {
-            ...result.lane,
-            status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
-                event: "envelope_repair_continued",
-                at,
-                envelope_ref: envelopeRef,
-                session_id: result.lane.pending_resume.session_id,
-            }),
-        };
-    });
-    if (queued.state === "queued" && queued.pending_resume?.text === ENVELOPE_REPAIR_CONTINUE_TEXT) {
-        logDecision({ event: "envelope_repair_continue", at, outcome: "queued", envelope_ref: envelopeRef, session_id: queued.pending_resume.session_id });
-    }
-    return queued;
-}
-/** Detached and synchronous classifiers share one process-identity claim. */
-export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
-    const release = claimWatcherLoop(hqRoot, laneId, deps);
-    if (release === null)
-        return;
-    try {
-        await runWatcherLoopOwned(hqRoot, laneId, deps);
-    }
-    finally {
-        release();
-    }
-}
-async function runWatcherLoopOwned(hqRoot, laneId, deps) {
-    const sleep = deps.sleep ?? defaultSleep;
-    const now = deps.now ?? (() => Date.now());
-    const isAlive = deps.isAlive ?? isPidAlive;
-    const readStarttime = deps.readStarttime ?? readProcStarttime;
-    const pollMs = deps.pollMs ?? WATCHER_POLL_MS;
-    const silenceMs = deps.silenceMs ?? SILENCE_MS;
-    const runDir = laneRunDir(hqRoot, laneId);
-    const outPath = deps.watcherOutPath ?? watcherOutLogPath(hqRoot, laneId);
-    const outMax = deps.watcherOutMaxBytes ?? WATCHER_OUT_MAX_BYTES;
-    const workerPidPath = path.join(runDir, "worker.pid");
-    const manifest = readSpawnManifest(runDir);
-    const minEnvelopeName = manifest.envelope_path !== undefined
-        ? path.basename(manifest.envelope_path)
-        : undefined;
-    const logFiles = [
-        path.join(runDir, "logs", "worker.out"),
-        path.join(runDir, "logs", "worker.err"),
-        path.join(runDir, "logs", "last-message.txt"),
-    ];
-    // Progress only. A tool call is not partial output: a worker that called
-    // tools and exited with no envelope and no output is still `failed`.
-    const activityFiles = [toolActivityPath(hqRoot, laneId)];
-    const progressFiles = [...logFiles, ...activityFiles];
-    // Mesh seam (spec §8). Non-interactive: nobody is at this process's tty.
-    const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
-    const storyStatusSuppressions = new Set();
-    const meshRequestTimeoutMs = deps.meshRequestTimeoutMs ?? 10_000;
-    const initialLane = readLaneSoft(hqRoot, laneId);
-    if (mesh && initialLane) {
-        // Every armed watcher refreshes the server descriptor. This migrates old
-        // shared project threads and picks up account/model changes after resume.
-        const company = initialLane.mesh_company ?? initialLane.company ?? undefined;
-        if (company &&
-            (mesh.ensureLaneThread || !initialLane.thread_id || initialLane.thread_id.startsWith("proj-"))) {
-            let timer;
-            try {
-                const threadId = await Promise.race([
-                    mesh.ensureLaneThread
-                        ? mesh.ensureLaneThread(company, initialLane)
-                        : mesh.ensureProjectThread(company, initialLane.project_id),
-                    new Promise((_resolve, reject) => {
-                        timer = setTimeout(() => reject(new Error(`mesh thread ensure timed out after ${meshRequestTimeoutMs}ms`)), meshRequestTimeoutMs);
-                    }),
-                ]);
-                const updated = initialLane.thread_id === threadId
-                    ? initialLane
-                    : retryUpdateLane(hqRoot, laneId, "spawn", (current) => current.thread_id === threadId ? current : { ...current, thread_id: threadId });
-                if (mesh.ensureLaneThread && updated.version !== initialLane.version) {
-                    await mesh.ensureLaneThread(company, updated);
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                if (company && initialLane.story_id &&
-                    err instanceof LanesError && err.error === "story_not_on_board") {
-                    storyStatusSuppressions.add(laneStoryStatusSuppressionKey(company, initialLane.project_id, initialLane.story_id));
-                }
-                process.stderr.write(`hq lanes watcher: mesh thread ensure failed for ${laneId}: ${message}\n`);
-                writeWatcherDecision(outPath, {
-                    event: "mesh_event_failed",
-                    at: new Date(now()).toISOString(),
-                    mesh_event: "ensure_lane_thread",
-                    error: message,
-                }, outMax);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-        }
-    }
-    const progressIntervalMs = deps.progressEventMinIntervalMs ?? readProgressIntervalMs(hqRoot, readLaneSoft(hqRoot, laneId));
-    const spawnRepair = deps.spawnRepair ?? spawnEnvelopeRepair;
-    const retryAccount = deps.retryAccount ?? ((root, lane, reason) => retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
-        ...deps.retrySpawnDeps,
-        admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
-    }));
-    let lastSignalMs = now();
-    let lastSeenMtime = 0;
-    let lastAlive = null;
-    let lastEnvelopeRef = null;
-    let lastInvalidRef = null;
-    let lastProgressEmitMs = (() => {
-        const stamp = readLaneSoft(hqRoot, laneId)?.last_progress_event_at;
-        return stamp ? Date.parse(stamp) || null : null;
-    })();
-    for (const file of progressFiles) {
-        const mtime = fileMtimeMs(file);
-        if (mtime !== null && mtime > lastSeenMtime)
-            lastSeenMtime = mtime;
-    }
-    const logDecision = (record) => {
-        writeWatcherDecision(outPath, record, outMax);
-    };
-    while (true) {
-        const worker = readPidRecord(workerPidPath);
-        const probe = worker === null
-            ? missingPidProbe()
-            : probePidRecord(worker, isAlive, readStarttime);
-        const processAlive = probe.alive;
-        if (lastAlive !== false && !processAlive) {
-            logDecision({
-                event: "liveness_transition",
-                at: new Date(now()).toISOString(),
-                pid: probe.pid,
-                recorded_starttime: probe.recorded_starttime,
-                live_starttime: probe.live_starttime,
-                starttime_error: probe.starttime_error,
-                decided_by: probe.decided_by,
-            });
-        }
-        lastAlive = processAlive;
-        let progressed = false;
-        let newestMtime = lastSeenMtime;
-        let newestFile = null;
-        for (const file of progressFiles) {
-            const mtime = fileMtimeMs(file);
-            if (mtime !== null && mtime > newestMtime) {
-                newestMtime = mtime;
-                newestFile = file;
-                progressed = true;
-            }
-        }
-        const latestFile = readLatestEnvelopeFile(hqRoot, laneId, minEnvelopeName);
-        const missingExpected = !processAlive && latestFile === null
-            ? missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)
-            : null;
-        let latest = latestFile && latestFile.envelope
-            ? { envelope: latestFile.envelope, ref: latestFile.ref }
-            : null;
-        let envelope = latest?.envelope ?? null;
-        if (latest && latest.ref !== lastEnvelopeRef) {
-            logDecision({
-                event: "envelope_observed",
-                at: new Date(now()).toISOString(),
-                filename: path.posix.basename(latest.ref),
-                decision: latest.envelope.decision,
-            });
-            lastEnvelopeRef = latest.ref;
-        }
-        if (latestFile && latestFile.envelope === null && latestFile.ref !== lastInvalidRef) {
-            logDecision({
-                event: "envelope_invalid",
-                at: new Date(now()).toISOString(),
-                filename: path.posix.basename(latestFile.ref),
-                error: latestFile.error,
-            });
-            lastInvalidRef = latestFile.ref;
-        }
-        const hasPartialOutput = logFiles.some((file) => fileNonEmpty(file));
-        let quota = null;
-        let quotaLane = null;
-        let providerRejection = null;
-        if (!processAlive && !envelope) {
-            try {
-                quotaLane = readLane(hqRoot, laneId);
-                const workerOutOffset = readSpawnManifest(runDir).worker_out_offset ?? 0;
-                const routed = routeProviderFailure(readProviderRejection(runDir, quotaLane.provider, workerOutOffset), () => readQuotaSignal(runDir, quotaLane.model, new Date(now()), workerOutOffset), quotaLane.model, new Date(now()));
-                // A reset-less 429 still holds the account: the configured default
-                // hold becomes its reset, recorded as such.
-                quota = routed.quota
-                    ? applyDefaultQuotaHold(routed.quota, providerQuotaDefaultHoldMs(loadLanesConfig(hqRoot).providers[quotaLane.provider]), new Date(now()))
-                    : null;
-                providerRejection = routed.rejection;
-            }
-            catch (err) {
-                process.stderr.write(`hq lanes watcher: quota read failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-            }
-        }
-        // Spec §4: the process exited and its envelope file does not parse, or
-        // this run never wrote its expected slot. Exactly one repair turn. A provider
-        // rejection skips the repair: the provider refused the turn, so a
-        // second turn on the same model and account would be refused the same
-        // way. A quota signal skips it too: a repair turn on an exhausted account
-        // fails the same way, and would end the lane envelope_invalid without
-        // ever recording the hold. The quota result applies immediately instead.
-        let invalidEnvelope = null;
-        let envelopeValidationErrors;
-        let questionIndexes;
-        let recoveredAsk = false;
-        const repairCandidate = latestFile ?? missingExpected;
-        if (!processAlive &&
-            !envelope &&
-            !providerRejection &&
-            !quota &&
-            repairCandidate &&
-            repairCandidate.envelope === null) {
-            const lane = repairCandidate.missing ? readLaneSoft(hqRoot, laneId) : null;
-            const missingRepairAllowed = !repairCandidate.missing ||
-                (lane !== null && envelopeRepairMode(lane.provider) === "resume");
-            if (missingRepairAllowed) {
-                const repair = decideEnvelopeRepair(hqRoot, laneId, repairCandidate, now(), spawnRepair, logDecision);
-                if (repair.action === "spawned") {
-                    lastSignalMs = now();
-                    lastAlive = null;
-                    if (progressed)
-                        lastSeenMtime = newestMtime;
-                    await sleep(pollMs);
-                    continue;
-                }
-                if (!repairCandidate.missing) {
-                    const validationErrors = repair.errors.filter((error) => !error.startsWith("repair_spawn_failed:"));
-                    let recovery = null;
-                    try {
-                        recovery = recoverAskEnvelope(repairCandidate.text, validationErrors);
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        process.stderr.write(`hq lanes watcher: invalid ask fallback could not parse ${repairCandidate.path} for ${laneId}: ${message}\n`);
-                        logDecision({
-                            event: "envelope_repair",
-                            at: new Date(now()).toISOString(),
-                            outcome: "ask_fallback_skipped",
-                            reason: "invalid_json",
-                            error: message,
-                            validation_errors: validationErrors,
-                        });
-                    }
-                    if (recovery !== null && (recovery.envelope.questions?.length ?? 0) > 0) {
-                        const errors = [...new Set([...validationErrors, ...recovery.questionErrors])];
-                        envelopeValidationErrors = errors;
-                        questionIndexes = recovery.questionIndexes;
-                        latest = { envelope: recovery.envelope, ref: repairCandidate.ref };
-                        envelope = recovery.envelope;
-                        recoveredAsk = true;
-                        const message = `hq lanes watcher: routing invalid ask envelope for ${laneId} to awaiting_input ` +
-                            `with ${recovery.envelope.questions?.length ?? 0} validated question(s); errors: ${errors.join("; ")}`;
-                        process.stderr.write(`${message}\n`);
-                        logDecision({
-                            event: "envelope_repair",
-                            at: new Date(now()).toISOString(),
-                            outcome: "ask_fallback_routed",
-                            state: "awaiting_input",
-                            questions: recovery.envelope.questions?.length ?? 0,
-                            validation_errors: errors,
-                        });
-                    }
-                    else {
-                        const errors = recovery === null
-                            ? repair.errors
-                            : [...new Set([...repair.errors, ...recovery.questionErrors])];
-                        invalidEnvelope = { errors };
-                        if (recovery !== null) {
-                            const message = `hq lanes watcher: invalid ask envelope for ${laneId} remains failed; ` +
-                                `0 of ${recovery.sourceQuestionCount} questions passed validation`;
-                            process.stderr.write(`${message}\n`);
-                            logDecision({
-                                event: "envelope_repair",
-                                at: new Date(now()).toISOString(),
-                                outcome: "ask_fallback_skipped",
-                                reason: "no_valid_questions",
-                                questions: 0,
-                                validation_errors: errors,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        if (processAlive === false &&
-            envelope &&
-            latestFile !== null &&
-            latestFile.envelope !== null &&
-            !recoveredAsk) {
-            markRepairSucceeded(hqRoot, laneId, latestFile.ref);
-        }
-        const tick = tickWatcher({
-            nowMs: now(),
-            processAlive,
-            progressed,
-            lastSignalMs,
-            envelope,
-            hasPartialOutput,
-            silenceMs,
-            quota,
-            invalidEnvelope,
-            providerRejection,
-        });
-        if (processAlive) {
-            maybeHeartbeatLane(hqRoot, laneId, now());
-        }
-        if (tick.emit) {
-            parseWatcherSignalKind(tick.emit.kind);
-            appendWatcherSignal(hqRoot, laneId, tick.emit);
-            if (tick.emit.kind === "silence") {
-                const reason = stalledReason(silenceMs);
-                logDecision({
-                    event: "silence_deadline",
-                    at: tick.emit.at,
-                    last_activity_at: new Date(lastSignalMs).toISOString(),
-                    last_tool_call_at: readToolActivity(hqRoot, laneId)?.at ?? null,
-                    deadline_at: new Date(lastSignalMs + silenceMs).toISOString(),
-                    silence_ms: silenceMs,
-                    stalled_reason: reason,
-                });
-                try {
-                    markLaneStalled(hqRoot, laneId, tick.emit.at, reason);
-                }
-                catch (err) {
-                    process.stderr.write(`hq lanes watcher: stalled write failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-                }
-            }
-            if (tick.emit.kind === "progress") {
-                const progressEmitAt = tick.emit.at;
-                try {
-                    clearLaneStalled(hqRoot, laneId);
-                }
-                catch (err) {
-                    process.stderr.write(`hq lanes watcher: stalled clear failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-                }
-                // Spec §8 progress row. Only a tick that saw new tool activity or
-                // new output gets here (tickWatcher emits progress on `progressed`
-                // alone), and the throttle bounds the rate. Silence never reaches
-                // this branch.
-                if (mesh &&
-                    progressEventDue({
-                        lastEmitMs: lastProgressEmitMs,
-                        nowMs: progressEmitAt ? Date.parse(progressEmitAt) : now(),
-                        minIntervalMs: progressIntervalMs,
-                    })) {
-                    const lane = readLaneSoft(hqRoot, laneId);
-                    if (lane) {
-                        const detail = newestFile && activityFiles.includes(newestFile)
-                            ? `tool call at ${readToolActivity(hqRoot, laneId)?.at ?? tick.emit.at}`
-                            : envelope
-                                ? "envelope written"
-                                : "new output";
-                        const sent = await emitMeshSoft("lane_progress", logDecision, progressEmitAt, (signal) => emitLaneProgressEvent(mesh, lane, detail, signal), meshRequestTimeoutMs);
-                        if (sent) {
-                            lastProgressEmitMs = Date.parse(progressEmitAt);
-                            try {
-                                retryUpdateLane(hqRoot, laneId, "watcher", (current) => ({
-                                    ...current,
-                                    last_progress_event_at: progressEmitAt,
-                                }));
-                            }
-                            catch (err) {
-                                process.stderr.write(`hq lanes watcher: progress timestamp write failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-                            }
-                        }
-                    }
-                }
-            }
-            if (tick.emit.kind === "terminal" && tick.emit.classification) {
-                const classification = tick.emit.classification;
-                logDecision({
-                    event: "classification",
-                    at: tick.emit.at,
-                    envelope_present: envelope !== null,
-                    has_partial_output: hasPartialOutput,
-                    state: classification.state,
-                    reason: classification.reason,
-                    ...(invalidEnvelope ? { envelope_errors: invalidEnvelope.errors } : {}),
-                    ...(providerRejection
-                        ? {
-                            provider_status: providerRejection.status,
-                            provider_message: providerRejection.message,
-                            retryable: providerRejection.retryable,
-                        }
-                        : {}),
-                });
-                if (quota &&
-                    quotaLane?.account &&
-                    (classification.reason === "account_quota_exhausted" ||
-                        classification.reason === "account_model_unavailable")) {
-                    try {
-                        recordAccountQuota(hqRoot, quotaLane.provider, quotaLane.account, quota);
-                    }
-                    catch (err) {
-                        process.stderr.write(`hq lanes watcher: quota record failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-                    }
-                }
-                const accountRetryReason = quota
-                    ? "usage_limit"
-                    : isProviderLoginFailure(providerRejection)
-                        ? "account_unavailable"
-                        : null;
-                if (accountRetryReason && quotaLane?.account) {
-                    try {
-                        const retry = await retryAccount(hqRoot, quotaLane, accountRetryReason);
-                        logDecision({
-                            event: "account_failover",
-                            at: tick.emit.at,
-                            from: quotaLane.account,
-                            to: retry.account ?? null,
-                            reason: accountRetryReason,
-                            state: retry.state,
-                        });
-                        return;
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        process.stderr.write(`hq lanes watcher: account failover failed for ${laneId}: ${message}\n`);
-                        logDecision({ event: "account_failover_failed", at: tick.emit.at, reason: accountRetryReason, error: message });
-                        if (readLane(hqRoot, laneId).state !== "running")
-                            return;
-                    }
-                }
-                const terminalLane = readLane(hqRoot, laneId);
-                let activeQuestionCompany;
-                if (envelope?.decision === "ask" && (envelope.questions?.length ?? 0) > 0) {
-                    try {
-                        activeQuestionCompany = await resolveQuestionCompanyWithFallback(hqRoot, terminalLane, deps.resolveQuestionActiveCompany);
-                    }
-                    catch (err) {
-                        if (questionRecordRefusalCode(err) !== "question_company_unavailable")
-                            throw err;
-                        // applyTerminalToLaneWithResult repeats the synchronous lane and
-                        // project checks, then terminalizes this ask with the named refusal.
-                    }
-                }
-                const terminalWrite = applyTerminalToLaneWithResult(hqRoot, laneId, classification, {
-                    envelope,
-                    envelopeRef: latest?.ref,
-                    envelopeValidationErrors,
-                    questionIndexes,
-                    activeCompany: activeQuestionCompany,
-                    at: tick.emit.at,
-                    quota,
-                    providerRejection,
-                });
-                let updated = terminalWrite.record;
-                const effectiveEnvelope = terminalWrite.envelope ?? envelope;
-                const effectiveClassification = terminalWrite.classification;
-                logDecision({
-                    event: "terminal_write",
-                    at: tick.emit.at,
-                    state: updated.state,
-                    version: updated.version,
-                });
-                // Spec §8 terminal rows: done → lane_done + story review; blocked →
-                // lane_blocked; ask → lane_ask with the queue ids. After the state
-                // write, so a mesh failure can never leave the lane unclassified.
-                if (mesh && terminalWrite.changed) {
-                    const envelopeState = effectiveEnvelope?.decision === "ask"
-                        ? "awaiting_input"
-                        : effectiveEnvelope?.decision === "blocked"
-                            ? "blocked"
-                            : "done";
-                    if (effectiveEnvelope && latest && updated.state === envelopeState) {
-                        const questionIds = effectiveEnvelope.decision === "ask"
-                            ? envelopeQuestionIds(laneId, latest.ref, effectiveEnvelope, questionIndexes)
-                            : undefined;
-                        await emitMeshSoft(`lane_${effectiveEnvelope.decision}`, logDecision, tick.emit.at, (signal) => emitLaneDecisionEvents(mesh, updated, effectiveEnvelope, {
-                            questionIds,
-                            signal,
-                            storyStatusSuppressions,
-                        }), meshRequestTimeoutMs);
-                    }
-                    else if (updated.state === "failed" || updated.state === "interrupted" ||
-                        updated.state === "cancelled" || updated.state === "killed") {
-                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, updated.terminal_reason ?? effectiveClassification.reason, signal), meshRequestTimeoutMs);
-                    }
-                }
-                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);
-                    updated = await settleKrFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
-                }
-                const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
-                    updated.status_gate_history?.some((entry) => "turn_id" in entry && entry.turn_id === manifest.turn_id &&
-                        ((entry.event === "status_missed" && entry.resume_queued === true) ||
-                            (entry.event === "blocker_stale" && entry.resume_queued === true) ||
-                            (entry.event === "kr_stalled" && entry.resume_queued === true))) === true;
-                if (terminalWrite.changed && !managerStatusFollowupQueued) {
-                    updated = await maybeContinueAfterMissingEnvelopeRepair(hqRoot, updated, effectiveEnvelope ?? null, latest?.ref, tick.emit.at, deps, logDecision);
-                }
-                if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued && updated.state !== "queued") {
-                    try {
-                        if (dropboxInboxHasMessages(hqRoot, laneId)) {
-                            await deps.recoverQueuedMessages(updated);
-                            logDecision({
-                                event: "message_recovery",
-                                at: tick.emit.at,
-                                state: updated.state,
-                            });
-                        }
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        process.stderr.write(`hq lanes watcher: queued message recovery failed for ${laneId}: ${message}\n`);
-                        logDecision({
-                            event: "message_recovery_failed",
-                            at: tick.emit.at,
-                            state: updated.state,
-                            error: message,
-                        });
-                    }
-                }
-                const terminalEnvelopeNextCheckMs = effectiveEnvelope?.next_check_at === undefined
-                    ? undefined
-                    : Date.parse(effectiveEnvelope.next_check_at);
-                const hasFutureTerminalNextCheck = terminalEnvelopeNextCheckMs !== undefined &&
-                    Number.isFinite(terminalEnvelopeNextCheckMs) &&
-                    terminalEnvelopeNextCheckMs > Date.parse(tick.emit.at);
-                if (terminalWrite.changed &&
-                    updated.keep_alive === true &&
-                    effectiveEnvelope?.decision === "done" &&
-                    effectiveEnvelope.story_complete === false &&
-                    !hasFutureTerminalNextCheck &&
-                    updated.state === "done" &&
-                    deps.scheduleTerminalKeepAlive) {
-                    try {
-                        const current = readLane(hqRoot, laneId);
-                        if (current.state === "done" && current.version === updated.version && current.keep_alive === true) {
-                            const resolution = resolveLaneCompany(hqRoot, current);
-                            const company = resolution.company;
-                            if (company) {
-                                const readFlag = deps.readTerminalKeepAliveFlag ?? readLanesRegistryFlag;
-                                const flagOptions = { company, companyUidSource: laneCompanyUidSource(resolution.source) };
-                                const [triggerEnabled, keepAliveEnabled, immediateFirstResumeEnabled] = await Promise.all([
-                                    readFlag(LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_FLAG, flagOptions),
-                                    readFlag(LEAD_LANE_KEEP_ALIVE_FLAG, flagOptions),
-                                    readFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, flagOptions),
-                                ]);
-                                if (triggerEnabled && keepAliveEnabled && immediateFirstResumeEnabled) {
-                                    const terminalAtMs = Date.parse(tick.emit.at);
-                                    const dueAt = new Date(terminalAtMs + LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS).toISOString();
-                                    logDecision({ event: "keep_alive_terminal_trigger_scheduled", at: tick.emit.at, due_at: dueAt, version: current.version });
-                                    await deps.scheduleTerminalKeepAlive({
-                                        laneId,
-                                        version: current.version,
-                                        terminalAt: tick.emit.at,
-                                        dueAt,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        process.stderr.write(`hq lanes watcher: terminal keep-alive trigger failed for ${laneId}: ${message}\n`);
-                        logDecision({ event: "keep_alive_terminal_trigger_failed", at: tick.emit.at, error: message });
-                    }
-                }
-            }
-        }
-        lastSignalMs = tick.nextLastSignalMs;
-        if (progressed)
-            lastSeenMtime = newestMtime;
-        if (tick.done)
-            return;
-        await sleep(pollMs);
-    }
-}
-/**
- * Spec §4 repair decision for an exited worker whose expected envelope is
- * invalid or missing. First failure on a resumable provider with a recorded
- * session id: record `envelope_repair` on the lane and spawn the repair turn.
- * A provider with no session resume gets the same single attempt as a fresh
- * turn for invalid files. Anything else (already attempted, no session id on a
- * resumable provider, non-running lane, spawn failure): give up with every
- * error collected. The caller preserves the normal interrupted classification
- * for a missing file and uses `envelope_invalid` only for an existing invalid
- * file.
- */
-export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair, logDecision) {
-    const at = new Date(nowMs).toISOString();
-    const error = latest.error ?? "unparseable envelope";
-    const lane = readLaneSoft(hqRoot, laneId);
-    if (!lane)
-        return { action: "give_up", errors: [error] };
-    if (lane.state !== "running") {
-        logDecision({ event: "envelope_repair", at, outcome: "skipped", skipped_reason: "lane_not_running", error });
-        return { action: "give_up", errors: [error] };
-    }
-    const runDir = laneRunDir(hqRoot, laneId);
-    const manifest = readSpawnManifest(runDir);
-    const prior = lane.envelope_repair;
-    // A resumed worker can write its next envelope before spawn.json points to
-    // that slot. Use the newest of the manifest's expected slot and the actual
-    // latest file so an older manifest or repair record cannot spend its budget.
-    const expectedRef = missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)?.ref;
-    const repairRef = expectedRef !== undefined && expectedRef > latest.ref ? expectedRef : latest.ref;
-    const priorAppliesToSlot = prior?.envelope_ref === undefined || prior.envelope_ref === repairRef;
-    if (prior && prior.attempted && priorAppliesToSlot) {
-        // The repair turn ran and its output does not parse either.
-        if (prior.attempted) {
-            const errors = [prior.first_error, error];
-            try {
-                retryUpdateLane(hqRoot, laneId, "watcher", (current) => ({
-                    ...current,
-                    envelope_repair: { ...prior, succeeded: false, second_error: error },
-                }));
-            }
-            catch (err) {
-                process.stderr.write(`hq lanes watcher: envelope_repair write failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-            }
-            logDecision({ event: "envelope_repair", at, outcome: "second_failure", errors });
-            return { action: "give_up", errors };
-        }
-        return { action: "give_up", errors: [prior.first_error] };
-    }
-    // `resume` (claude, codex) continues the recorded session; `fresh_turn`
-    // (grok) runs the repair prompt as a new single turn on the same account.
-    const mode = envelopeRepairMode(lane.provider);
-    let skipped;
-    let sessionId = null;
-    if (mode === "resume") {
-        const result = readWorkerRunResult(runDir, lane.provider, manifest.worker_out_offset ?? 0);
-        sessionId = result?.session_id ??
-            [manifest.resume?.session_id, lane.provider_session_id, lane.last_resume?.session_id].find((candidate) => typeof candidate === "string" && candidate.trim().length > 0) ?? null;
-        if (sessionId === null)
-            skipped = result?.session_id_absent ?? "no_result_json";
-    }
-    const base = {
-        first_error: error,
-        envelope_ref: repairRef,
-        at,
-    };
-    if (skipped !== undefined) {
-        writeRepairRecord(hqRoot, laneId, { ...base, attempted: false, succeeded: false, skipped_reason: skipped });
-        logDecision({ event: "envelope_repair", at, outcome: "skipped", skipped_reason: skipped, error });
-        return { action: "give_up", errors: [error] };
-    }
-    writeRepairRecord(hqRoot, laneId, { ...base, mode, attempted: true, succeeded: false });
-    try {
-        const pid = spawnRepair(hqRoot, lane, {
-            session_id: sessionId,
-            envelopePath: latest.path,
-            error,
-            rawText: latest.text,
-            missing: latest.missing,
-            onProfileWarning: (fields) => {
-                logDecision({
-                    event: "envelope_repair",
-                    at,
-                    outcome: "profile_unknown_meta_fields_ignored",
-                    fields: [...fields],
-                });
-            },
-        });
-        logDecision({ event: "envelope_repair", at, outcome: "spawned", mode, pid, session_id: sessionId, error });
-        return { action: "spawned" };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`hq lanes watcher: envelope repair spawn failed for ${laneId}: ${message}\n`);
-        writeRepairRecord(hqRoot, laneId, {
-            ...base,
-            mode,
-            attempted: true,
-            succeeded: false,
-            second_error: `repair_spawn_failed: ${message}`,
-        });
-        logDecision({ event: "envelope_repair", at, outcome: "spawn_failed", error: message });
-        return { action: "give_up", errors: [error, `repair_spawn_failed: ${message}`] };
-    }
-}
-function writeRepairRecord(hqRoot, laneId, record) {
-    retryUpdateLane(hqRoot, laneId, "watcher", (current) => ({ ...current, envelope_repair: record }));
-}
-/** The repair run wrote a parseable envelope: close the record as succeeded. */
-function markRepairSucceeded(hqRoot, laneId, _envelopeRef) {
-    try {
-        retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
-            const prior = current.envelope_repair;
-            if (!prior || !prior.attempted || prior.succeeded) {
-                return current;
-            }
-            return { ...current, envelope_repair: { ...prior, succeeded: true, second_error: undefined } };
-        });
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes watcher: envelope_repair success write failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-}
-/** Exported so tests can prove the watcher reads the live record, not spawn env. */
-export function laneIdentityFromRecord(hqRoot, laneId) {
-    const lane = readLane(hqRoot, laneId);
-    return {
-        lane_id: lane.lane_id,
-        company: lane.company,
-        project_id: lane.project_id,
-        story_id: lane.story_id,
-        senior: lane.senior,
-    };
-}
-//# sourceMappingURL=watcher.js.map