@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/lib/lanes/autopilot.js

@@ -0,0 +1,1222 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { laneRunsOnHost } from "./admission.js";
+import { isControllerAliasOutpostId } from "./admission-host.js";
+import { LEAD_REGISTRY_REL, validateOutpostLeadRegistry } from "./autopilot-registry.js";
+import { appendDropboxMessage } from "./dropbox.js";
+import { LanesError } from "./errors.js";
+import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
+import { resolveLaneCompany } from "./lane-company.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { readAllLanes } from "./store.js";
+export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+export const LEAD_AUTOPILOT_DEFAULT_ENABLED = false;
+export const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG;
+export const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DEFAULT_ENABLED = false;
+export const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DELAY_MS = 60 * 60_000;
+export const LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG = LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG;
+export const LEAD_AUTOPILOT_NUDGE_DEDUPE_DEFAULT_ENABLED = false;
+export const LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS = 30 * 60_000;
+export const LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS = 24 * 60 * 60_000;
+const LEAD_AUTOPILOT_DELIVERED_ID_RETENTION_MS = 7 * 24 * 60 * 60_000;
+export const LEAD_AUTOPILOT_REVIEW_DELAY_MS = 15 * 60_000;
+export const LEAD_AUTOPILOT_FILL_DELAY_MS = 15 * 60_000;
+export const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
+export const LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES = 55;
+export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = PER_LEAD_ERRORS_FLAG;
+export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
+const LIVE_STATES = new Set(["running", "queued", "awaiting_input", "blocked"]);
+const OPEN_STORY_STATES = new Set(["todo", "queued", "in_progress", "review", "blocked"]);
+function isOpenProjectStory(story) {
+    return story.passes !== true && OPEN_STORY_STATES.has(story.status);
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonFile(filePath, code) {
+    let text;
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected a regular file");
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new LanesError(code, `Cannot read ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new LanesError(code, `Cannot parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
+    }
+}
+function parseRegistry(hqRoot, outpostId, now) {
+    const file = path.join(hqRoot, LEAD_REGISTRY_REL);
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            // An Outpost without a delivered registry reports it; it does not fail reconcile.
+            // The primary delivers nothing when it has no registry or every company is flagged off.
+            if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+                return null;
+            return [];
+        }
+        throw new LanesError("lead_autopilot_registry_invalid", `Cannot inspect ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: expected a regular file`, { path: file });
+    }
+    const raw = readJsonFile(file, "lead_autopilot_registry_invalid");
+    if (outpostId !== null && !isControllerAliasOutpostId(outpostId, { kind: "outpost", id: outpostId }))
+        return validateOutpostLeadRegistry({ registry: raw, outpostId, now }).juniors;
+    if (isRecord(raw) && raw.juniors === undefined && Array.isArray(raw.retired))
+        return [];
+    if (!isRecord(raw) || !Array.isArray(raw.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: juniors must be an array`, { path: file });
+    }
+    const rows = [];
+    for (const [index, value] of raw.juniors.entries()) {
+        if (!isRecord(value) || ["team", "lane", "host", "status", "prd"].some((key) => typeof value[key] !== "string" || !value[key].trim())) {
+            throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: juniors[${index}] must name team, lane, host, status, and prd`, { path: file, index });
+        }
+        rows.push(value);
+    }
+    return rows;
+}
+function registeredFilePath(hqRoot, relativePath, errorCode) {
+    const root = path.resolve(hqRoot);
+    const file = path.resolve(root, relativePath);
+    if (file === root || !file.startsWith(`${root}${path.sep}`)) {
+        throw new LanesError(errorCode, `Registered path escapes HQ root: ${relativePath}`, { path: relativePath });
+    }
+    try {
+        const realRoot = fs.realpathSync(root);
+        const realFile = fs.realpathSync(file);
+        if (realFile === realRoot || !realFile.startsWith(`${realRoot}${path.sep}`)) {
+            throw new LanesError(errorCode, `Registered path resolves outside HQ root: ${relativePath}`, { path: relativePath });
+        }
+    }
+    catch (error) {
+        if (error instanceof LanesError)
+            throw error;
+        throw new LanesError(errorCode, `Cannot resolve registered path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`, { path: relativePath });
+    }
+    return file;
+}
+function projectStories(hqRoot, relativePath, companySlug, projectId) {
+    if (companySlug !== undefined) {
+        const expected = path.join("companies", companySlug, "projects", projectId, "prd.json");
+        if (path.normalize(relativePath) !== expected) {
+            throw new LanesError("lead_autopilot_tenant_mismatch", `Project registry path does not match lead ${companySlug}/${projectId}`, { path: relativePath, company: companySlug, project_id: projectId });
+        }
+    }
+    const file = registeredFilePath(hqRoot, relativePath, "lead_autopilot_project_path_invalid");
+    const raw = readJsonFile(file, "lead_autopilot_project_invalid");
+    const rows = isRecord(raw) ? raw.userStories ?? raw.stories : undefined;
+    if (!Array.isArray(rows)) {
+        throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: userStories or stories must be an array`, { path: file });
+    }
+    return rows.map((story, index) => {
+        const rawStatus = isRecord(story) ? story.status ?? story.state : undefined;
+        const status = isRecord(story) && story.passes === true ? "done" : rawStatus;
+        if (!isRecord(story) || typeof story.id !== "string" || typeof status !== "string") {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] needs string id and status/state`, { path: file, index });
+        }
+        const sourceRef = isRecord(story.source) ? story.source.ref : undefined;
+        const rawBrief = story.brief_path ?? story.brief_file ?? sourceRef;
+        if (story.lanes !== undefined && (!Array.isArray(story.lanes) || story.lanes.some((lane) => typeof lane === "string" ? !lane.trim() : !isRecord(lane) || typeof lane.lane_id !== "string" || !lane.lane_id.trim()))) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] lanes must contain lane IDs or lane_id objects`, { path: file, index });
+        }
+        if (story.updated_at !== undefined && (typeof story.updated_at !== "string" || !Number.isFinite(Date.parse(story.updated_at)))) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] updated_at must be a valid timestamp`, { path: file, index });
+        }
+        if (story.lane !== undefined && story.lane !== null && typeof story.lane !== "string") {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] lane must be a string`, { path: file, index });
+        }
+        if (story.external_blocker !== undefined && (typeof story.external_blocker !== "string" || !story.external_blocker.trim())) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] external_blocker must be a non-empty string`, { path: file, index });
+        }
+        if (rawBrief !== undefined && (typeof rawBrief !== "string" || !rawBrief.trim())) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] brief path must be a non-empty string`, { path: file, index });
+        }
+        if (typeof rawBrief === "string" && companySlug !== undefined) {
+            const normalizedBrief = path.normalize(rawBrief);
+            if (normalizedBrief.startsWith(`companies${path.sep}`) && !normalizedBrief.startsWith(path.join("companies", companySlug) + path.sep)) {
+                throw new LanesError("lead_autopilot_tenant_mismatch", `Story brief path does not match lead ${companySlug}/${projectId}`, { path: rawBrief, company: companySlug, project_id: projectId });
+            }
+        }
+        let briefPath;
+        if (typeof rawBrief === "string") {
+            briefPath = registeredFilePath(hqRoot, rawBrief, "lead_autopilot_story_brief_path_invalid");
+            try {
+                const briefStat = fs.lstatSync(briefPath);
+                if (!briefStat.isFile() || briefStat.isSymbolicLink())
+                    throw new Error("expected a regular file");
+            }
+            catch (error) {
+                throw new LanesError("lead_autopilot_story_brief_invalid", `Cannot read story brief ${rawBrief}: ${error instanceof Error ? error.message : String(error)}`, { path: rawBrief, story_id: story.id });
+            }
+        }
+        return {
+            id: story.id,
+            status,
+            ...(story.passes === true ? { passes: true } : {}),
+            ...(briefPath ? { briefPath } : {}),
+            ...storyLaneIds(story),
+            ...(typeof story.updated_at === "string" ? { updatedAt: story.updated_at } : {}),
+            ...(typeof story.external_blocker === "string" ? { externalBlocker: story.external_blocker } : {}),
+            deadlineFields: story,
+        };
+    });
+}
+const DEADLINE_FIELDS = ["deadline", "due_at", "unblock_by", "unblock_at", "eta"];
+const CLOSED_COMMITMENT_STATES = new Set(["done", "resolved", "closed", "cancelled", "canceled", "dropped", "complete", "completed"]);
+const COMMITMENT_SECTIONS = ["open_blockers", "waiting", "open_decisions", "decisions", "slot_requests", "blockers"];
+function hasDeadlineField(value) {
+    return DEADLINE_FIELDS.some((field) => value[field] !== undefined && value[field] !== null && value[field] !== "");
+}
+function commitmentDue(value, context) {
+    const dates = [];
+    const errors = [];
+    for (const field of DEADLINE_FIELDS) {
+        const raw = value[field];
+        if (raw === undefined || raw === null || raw === "")
+            continue;
+        if (typeof raw !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d{1,9})?)?(?:Z|[+-]\d\d:\d\d)$/.test(raw) || !Number.isFinite(Date.parse(raw))) {
+            // `eta` is also used as free-text planning context in manager and story
+            // records. It is a deadline only when it is already a valid ISO instant.
+            if (field === "eta")
+                continue;
+            errors.push({ field, reason: `${context}.${field} must be a valid date-time` });
+            continue;
+        }
+        dates.push({ field, iso: new Date(Date.parse(raw)).toISOString() });
+    }
+    if (errors.length > 0)
+        return { due: null, errors };
+    if (dates.length === 0)
+        return { due: null, errors };
+    if (new Set(dates.map((date) => date.iso)).size > 1) {
+        return { due: null, errors: [{ field: "deadline_fields", reason: `${context} has conflicting deadline fields` }] };
+    }
+    return { due: dates[0].iso, errors };
+}
+function isResolvedCommitment(value, status) {
+    return value.passes === true || value.resolved === true || value.open === false ||
+        value.resolved_at !== undefined && value.resolved_at !== null ||
+        value.completed_at !== undefined && value.completed_at !== null ||
+        (typeof status === "string" && CLOSED_COMMITMENT_STATES.has(status.toLowerCase()));
+}
+function optionalLabel(value, fields, fallback) {
+    for (const field of fields) {
+        const candidate = value[field];
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate.trim();
+    }
+    return fallback;
+}
+function deadlineCommitments(status, stories, leadLane) {
+    const commitments = [];
+    const errors = [];
+    for (const section of COMMITMENT_SECTIONS) {
+        const rows = status[section];
+        if (rows === undefined)
+            continue;
+        if (!Array.isArray(rows)) {
+            errors.push({ lead_lane: leadLane, item_ref: `manager:${section}`, field: section, reason: `Manager status ${section} must be an array` });
+            continue;
+        }
+        rows.forEach((row, index) => {
+            if (!isRecord(row) || !hasDeadlineField(row))
+                return;
+            const itemRef = `manager:${section}[${index}]`;
+            const dueResult = commitmentDue(row, `Manager status ${section}[${index}]`);
+            errors.push(...dueResult.errors.map((error) => ({ lead_lane: leadLane, item_ref: itemRef, ...error })));
+            if (dueResult.errors.length > 0 || !dueResult.due)
+                return;
+            const id = row.id;
+            if (typeof id !== "string" || !id.trim()) {
+                errors.push({ lead_lane: leadLane, item_ref: itemRef, field: "id", reason: `Manager status ${section}[${index}] with a deadline needs a non-empty id` });
+                return;
+            }
+            const owner = optionalLabel(row, ["owner", "unblock_owner", "waiting_on", "assigned_to"], "unassigned");
+            const state = typeof row.status === "string" ? row.status : typeof row.state === "string" ? row.state : undefined;
+            commitments.push({
+                key: `manager:${section}:${id}`,
+                item: id,
+                owner,
+                due: dueResult.due,
+                description: optionalLabel(row, ["what", "question", "request", "title", "line"], id),
+                resolved: isResolvedCommitment(row, state),
+            });
+        });
+    }
+    for (const story of stories) {
+        const raw = story.deadlineFields;
+        if (!raw || !hasDeadlineField(raw))
+            continue;
+        const dueResult = commitmentDue(raw, `Project story ${story.id}`);
+        errors.push(...dueResult.errors.map((error) => ({ lead_lane: leadLane, item_ref: `story:${story.id}`, ...error })));
+        if (dueResult.errors.length > 0 || !dueResult.due)
+            continue;
+        const state = typeof raw.status === "string" ? raw.status : typeof raw.state === "string" ? raw.state : story.status;
+        commitments.push({
+            key: `story:${story.id}`,
+            item: story.id,
+            owner: optionalLabel(raw, ["owner", "assigned_to"], "lead"),
+            due: dueResult.due,
+            description: optionalLabel(raw, ["title", "name", "what"], story.id),
+            resolved: isResolvedCommitment(raw, state),
+        });
+    }
+    return { commitments: commitments.sort((a, b) => a.key.localeCompare(b.key)), errors };
+}
+function readStatus(hqRoot, relativePath, companySlug) {
+    if (path.isAbsolute(relativePath)) {
+        throw new LanesError("lead_autopilot_status_path_invalid", `Registered status path must be relative to the HQ root: ${relativePath}`, { path: relativePath });
+    }
+    const root = path.resolve(hqRoot);
+    const file = registeredFilePath(root, relativePath, "lead_autopilot_status_path_invalid");
+    const assertCompanyBoundary = (candidate) => {
+        const relative = path.relative(root, candidate).split(path.sep);
+        if (relative[0] === "companies" && relative[1] !== companySlug) {
+            throw new LanesError("lead_autopilot_tenant_mismatch", `Manager status path does not match lead company ${companySlug}`, { path: relativePath, company: companySlug });
+        }
+    };
+    assertCompanyBoundary(path.resolve(root, relativePath));
+    assertCompanyBoundary(fs.realpathSync(file));
+    const status = readJsonFile(file, "lead_autopilot_status_invalid");
+    if (!isRecord(status))
+        throw new LanesError("lead_autopilot_status_invalid", `Invalid manager status ${file}: expected an object`, { path: file });
+    return status;
+}
+function parseOkrReports(status) {
+    const raw = status.okr_reports;
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw)) {
+        throw new LanesError("lead_autopilot_okr_reports_invalid", "Manager status okr_reports must be an array");
+    }
+    return raw.map((value, index) => {
+        if (!isRecord(value) || typeof value.at !== "string" || !Number.isFinite(Date.parse(value.at)) || !Array.isArray(value.kpis) || !Array.isArray(value.okrs)) {
+            throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}] must include at, kpis, and okrs`);
+        }
+        const parseLines = (rows, kind) => rows.map((row, lineIndex) => {
+            if (!isRecord(row) || typeof row.id !== "string" || !row.id.trim()) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] needs an id`);
+            }
+            const text = typeof row.line === "string" ? row.line : typeof row.name === "string" ? row.name : typeof row.objective === "string" ? row.objective : "";
+            if (!text.trim()) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] needs a line, name, or objective`);
+            }
+            if ((row.value !== undefined && (typeof row.value !== "number" || !Number.isFinite(row.value))) ||
+                (row.moved !== undefined && (typeof row.moved !== "number" || !Number.isFinite(row.moved)))) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] has invalid numeric progress`);
+            }
+            return { id: row.id, line: text, ...(typeof row.value === "number" ? { value: row.value } : {}), ...(typeof row.moved === "number" ? { moved: row.moved } : {}) };
+        });
+        return { at: value.at, kpis: parseLines(value.kpis, "KPI"), okrs: parseLines(value.okrs, "OKR") };
+    }).sort((a, b) => a.at.localeCompare(b.at));
+}
+// A story's current `lane` counts alongside its `lanes` history, so `lanes: []` with `lane: X` is assigned to X.
+function storyLaneIds(story) {
+    const history = Array.isArray(story.lanes)
+        ? story.lanes.map((lane) => typeof lane === "string" ? lane : lane.lane_id)
+        : undefined;
+    const current = typeof story.lane === "string" && story.lane.trim() ? story.lane : undefined;
+    if (history)
+        return { laneIds: current && !history.includes(current) ? [...history, current] : history };
+    if (current)
+        return { laneIds: [current] };
+    return story.lane === "" ? { laneIds: [] } : {};
+}
+function statusBlockers(status) {
+    const raw = status.blockers;
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw))
+        throw new LanesError("lead_autopilot_status_invalid", "Manager status blockers must be an array");
+    return raw.map((value, index) => {
+        if (!isRecord(value) || typeof value.id !== "string" || !value.id.trim()) {
+            throw new LanesError("lead_autopilot_status_invalid", `Manager status blockers[${index}] needs a non-empty id`);
+        }
+        return value;
+    });
+}
+function managerKpiFreshness(status, now) {
+    const rawKpis = status.kpis;
+    if (rawKpis === undefined)
+        return [];
+    if (!Array.isArray(rawKpis)) {
+        return [{
+                name: "kpis",
+                measuredAt: null,
+                ageMinutes: null,
+                stale: false,
+                staleAfterMinutes: LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES,
+                fingerprint: "",
+                error: "invalid_kpi",
+            }];
+    }
+    return rawKpis.map((value, index) => {
+        const invalid = () => {
+            let name = `KPI ${index + 1}`;
+            if (isRecord(value)) {
+                const rawName = typeof value.name === "string" ? value.name : value.id;
+                if (typeof rawName === "string" && rawName.trim())
+                    name = rawName.trim();
+            }
+            return {
+                name,
+                measuredAt: null,
+                ageMinutes: null,
+                stale: false,
+                staleAfterMinutes: LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES,
+                fingerprint: "",
+                ...(isRecord(value) && typeof value.status === "string" ? { status: value.status } : {}),
+                error: "invalid_kpi",
+            };
+        };
+        if (!isRecord(value)) {
+            return invalid();
+        }
+        const rawName = typeof value.name === "string" ? value.name : value.id;
+        if (typeof rawName !== "string" || !rawName.trim()) {
+            return invalid();
+        }
+        const staleAfterMinutes = value.stale_after_minutes === undefined
+            ? LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES
+            : value.stale_after_minutes;
+        if (typeof staleAfterMinutes !== "number" || !Number.isSafeInteger(staleAfterMinutes) || staleAfterMinutes < 1 || staleAfterMinutes > 525_600) {
+            return invalid();
+        }
+        const measuredAt = typeof value.measured_at === "string" && Number.isFinite(Date.parse(value.measured_at))
+            ? new Date(Date.parse(value.measured_at)).toISOString()
+            : null;
+        const elapsedMs = measuredAt === null ? null : Math.max(0, now.getTime() - Date.parse(measuredAt));
+        const ageMinutes = elapsedMs === null ? null : Math.floor(elapsedMs / 60_000);
+        const terminalStatus = typeof value.status === "string" && ["superseded", "retired", "dropped"].includes(value.status.toLowerCase());
+        const stale = !terminalStatus && (elapsedMs === null || elapsedMs > staleAfterMinutes * 60_000);
+        const fingerprint = `stale-kpi:${createHash("sha256").update(JSON.stringify([rawName.trim(), measuredAt, value.value ?? null])).digest("hex")}`;
+        return {
+            name: rawName.trim(),
+            measuredAt,
+            ageMinutes,
+            stale,
+            staleAfterMinutes,
+            fingerprint,
+            ...(typeof value.status === "string" ? { status: value.status } : {}),
+        };
+    });
+}
+function leastMoved(lines, priorLines = []) {
+    const priorById = new Map(priorLines.map((line) => [line.id, line]));
+    return [...lines].sort((a, b) => {
+        const moved = (line) => line.moved !== undefined ? Math.abs(line.moved) :
+            line.value !== undefined && priorById.get(line.id)?.value !== undefined ? Math.abs(line.value - priorById.get(line.id).value) : 0;
+        return moved(a) - moved(b) || a.id.localeCompare(b.id);
+    })[0];
+}
+export function planLeadAutopilotWakes(input) {
+    const { lead, children, stories, now } = input;
+    if (input.keepAliveResumed)
+        return [];
+    const status = input.managerStatus ?? {};
+    const reports = parseOkrReports(status);
+    const blockers = statusBlockers(status);
+    const byStory = new Map(stories.map((story) => [story.id, story]));
+    const wakes = [];
+    if (input.kpiStalenessEnabled) {
+        const staleKpis = managerKpiFreshness(status, now).filter((kpi) => kpi.stale);
+        if (input.kpiStalenessBatchEnabled && staleKpis.length > 0) {
+            const byOldest = [...staleKpis].sort((a, b) => (b.ageMinutes ?? Number.MAX_SAFE_INTEGER) - (a.ageMinutes ?? Number.MAX_SAFE_INTEGER) ||
+                a.name.localeCompare(b.name));
+            const identity = staleKpis
+                .map(({ name, measuredAt }) => [name, measuredAt])
+                .sort(([nameA, measuredAtA], [nameB, measuredAtB]) => nameA.localeCompare(nameB) || String(measuredAtA).localeCompare(String(measuredAtB)));
+            const fingerprint = `stale-kpi-batch:${createHash("sha256").update(JSON.stringify(identity)).digest("hex")}`;
+            const details = byOldest.map((kpi) => `- ${kpi.name}: age ${kpi.ageMinutes === null ? "unknown" : kpi.ageMinutes} minutes (stale after ${kpi.staleAfterMinutes} minutes)`).join("\n");
+            wakes.push({
+                condition: "stale_kpi",
+                lead_lane: lead.lane_id,
+                story_id: "kpi-staleness",
+                kpi_id: "batch",
+                fingerprint,
+                prompt: `Re-measure these stale KPIs, oldest first:\n${details}\nUpdate measured_at in manager-status.json. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+            });
+        }
+        else {
+            for (const kpi of staleKpis) {
+                const age = kpi.ageMinutes === null
+                    ? "its measurement age is unknown"
+                    : `its latest measurement is ${kpi.ageMinutes} minutes old`;
+                wakes.push({
+                    condition: "stale_kpi",
+                    lead_lane: lead.lane_id,
+                    story_id: "kpi-staleness",
+                    kpi_id: kpi.name,
+                    fingerprint: kpi.fingerprint,
+                    prompt: `Re-measure KPI ${kpi.name}: ${age} (stale after ${kpi.staleAfterMinutes} minutes). Update measured_at in manager-status.json. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+                });
+            }
+        }
+    }
+    const finishedReviews = children.flatMap((child) => {
+        if (!["done", "blocked", "failed", "interrupted"].includes(child.state))
+            return [];
+        const story = byStory.get(child.story_id);
+        if (!story || !isOpenProjectStory(story))
+            return [];
+        const finishedAt = child.ended_at ?? child.updated_at;
+        const finishedMs = Date.parse(finishedAt);
+        if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
+            return [];
+        return [{ laneId: child.lane_id, story, finishedAt }];
+    });
+    const knownChildIds = new Set(children.map((child) => child.lane_id));
+    const missingReviews = stories.flatMap((story) => {
+        if (!isOpenProjectStory(story) || !story.updatedAt || !story.laneIds)
+            return [];
+        const finishedMs = Date.parse(story.updatedAt);
+        if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
+            return [];
+        // The lead's own lane is never a finished worker of itself.
+        return story.laneIds.filter((laneId) => laneId !== lead.lane_id && !knownChildIds.has(laneId))
+            .map((laneId) => ({ laneId, story, finishedAt: story.updatedAt }));
+    });
+    const overdueReviews = [...finishedReviews, ...missingReviews].sort((a, b) => a.laneId.localeCompare(b.laneId));
+    if (overdueReviews.length > 0) {
+        const fingerprint = `review:${overdueReviews.map(({ laneId, story, finishedAt }) => `${laneId}:${story.id}:${story.status}:${finishedAt}`).join(",")}`;
+        const reviewList = overdueReviews.map(({ laneId, story }) => `lane ${laneId} (story ${story.id}, status ${story.status})`).join("; ");
+        wakes.push({
+            condition: "review_finished_worker",
+            lead_lane: lead.lane_id,
+            story_id: overdueReviews.map(({ story }) => story.id).join(","),
+            ...(overdueReviews.length === 1 ? { worker_lane: overdueReviews[0].laneId } : {}),
+            fingerprint,
+            prompt: `Review finished worker ${overdueReviews.length === 1 ? "lane" : "lanes"}: ${reviewList}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+        });
+    }
+    const liveChildren = children.filter((child) => LIVE_STATES.has(child.state));
+    const liveCount = liveChildren.length;
+    const assigned = new Set(liveChildren.flatMap((child) => [child.story_id, ...(child.stories ?? []).map((story) => story.story_id)]));
+    const readyStory = stories.find((story) => story.status === "todo" && !story.passes && !assigned.has(story.id));
+    if (readyStory && liveCount < (lead.hire_grant ?? 0)) {
+        const fingerprint = `fill:${readyStory.id}:${liveCount}:${lead.hire_grant ?? 0}`;
+        wakes.push({
+            condition: "fill_grant",
+            lead_lane: lead.lane_id,
+            story_id: readyStory.id,
+            fingerprint,
+            prompt: `Start a worker for ready story ${readyStory.id}. You have ${liveCount} live workers against a grant of ${lead.hire_grant ?? 0}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+        });
+    }
+    const hasFreeSlots = liveCount < (lead.hire_grant ?? 0);
+    if (hasFreeSlots && !readyStory) {
+        const latest = reports.at(-1);
+        const previous = reports.at(-2);
+        const kpiLine = latest ? leastMoved(latest.kpis, previous?.kpis) : undefined;
+        const okrLine = latest ? leastMoved(latest.okrs, previous?.okrs) : undefined;
+        const kpiText = kpiLine?.line ?? "no KPI line in the latest OKR report";
+        const okrText = okrLine?.line ?? "no OKR line in the latest OKR report";
+        const fingerprint = `plan:${latest?.at ?? "no-report"}:${kpiLine?.id ?? "no-kpi"}:${okrLine?.id ?? "no-okr"}:${stories.map((story) => `${story.id}:${story.status}`).sort().join(",")}`;
+        wakes.push({ condition: "plan_free_slots", lead_lane: lead.lane_id, story_id: "planning", fingerprint,
+            prompt: `You have ${liveCount} live workers against a grant of ${lead.hire_grant ?? 0} and no ready stories. Plan work against the least-moved KPI line: ${kpiText}; and OKR line: ${okrText}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    if (reports.length >= 2) {
+        const latest = reports.at(-1);
+        const prior = new Map(reports.at(-2).kpis.filter((line) => line.value !== undefined).map((line) => [line.id, line]));
+        const flat = latest.kpis.filter((line) => line.value !== undefined && prior.get(line.id)?.value === line.value);
+        if (flat.length > 0) {
+            const line = flat.map((item) => `${item.line} (${item.value})`).join("; ");
+            const fingerprint = `flat-kpi:${latest.at}:${flat.map((item) => `${item.id}:${item.value}`).join(",")}`;
+            wakes.push({ condition: "flat_kpi", lead_lane: lead.lane_id, story_id: flat.map((item) => item.id).join(","), fingerprint,
+                prompt: `KPI line(s) remained flat across the two latest OKR reports: ${line}. Re-plan the affected line(s). Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+        }
+    }
+    const staleBlockers = blockers.filter((blocker) => {
+        const blockerStatus = blocker.status ?? blocker.state;
+        const resolved = blockerStatus === "resolved" || blocker.resolved_at !== undefined && blocker.resolved_at !== null;
+        const owner = typeof blocker.unblock_owner === "string" ? blocker.unblock_owner : blocker.owner;
+        const due = blocker.unblock_by ?? blocker.unblock_at ?? blocker.due_at;
+        const ownerMissing = typeof owner !== "string" || !owner.trim();
+        const dueMissing = typeof due !== "string" || !Number.isFinite(Date.parse(due));
+        return resolved || ownerMissing || dueMissing;
+    });
+    if (staleBlockers.length > 0) {
+        const labels = staleBlockers.map((blocker) => `${String(blocker.id)}${typeof blocker.what === "string" ? ` (${blocker.what})` : ""}`).join("; ");
+        const fingerprint = `blockers:${staleBlockers.map((blocker) => `${String(blocker.id)}:${String(blocker.status ?? blocker.state ?? "")}:${String(blocker.resolved_at ?? "")}:${String(blocker.unblock_owner ?? blocker.owner ?? "")}:${String(blocker.unblock_by ?? blocker.unblock_at ?? blocker.due_at ?? "")}`).join(",")}`;
+        wakes.push({ condition: "blocker_record_needs_update", lead_lane: lead.lane_id, story_id: staleBlockers.map((blocker) => String(blocker.id)).join(","), fingerprint,
+            prompt: `Fix blocker records still listed as resolved or missing an unblock owner/time: ${labels}. Move resolved blockers out of blockers, and give every open blocker an owner and time. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    if (stories.length > 0 && stories.every((story) => story.passes === true || story.status === "done" || story.status === "dropped" ||
+        ((story.status === "parked" || story.status === "blocked") && Boolean(story.externalBlocker)))) {
+        const fingerprint = `project-close:${stories.map((story) => `${story.id}:${story.status}:${story.externalBlocker ?? ""}`).sort().join(",")}`;
+        wakes.push({ condition: "project_ready_to_close", lead_lane: lead.lane_id, story_id: stories.map((story) => story.id).join(","), fingerprint,
+            prompt: `Every story is done, dropped, or parked on a named external blocker. Write the final report and mark the project complete. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    const staleLedger = stories.flatMap((story) => {
+        if (story.status !== "in_progress" || !story.updatedAt || !story.laneIds)
+            return [];
+        const updated = Date.parse(story.updatedAt);
+        if (!Number.isFinite(updated) || now.getTime() - updated <= 30 * 60_000)
+            return [];
+        return story.laneIds.flatMap((laneId) => {
+            const worker = children.find((child) => child.lane_id === laneId && child.state === "running" &&
+                (child.story_id === story.id || (child.stories ?? []).some((carried) => carried.story_id === story.id)));
+            return worker ? [{ story, worker }] : [];
+        });
+    }).sort((a, b) => a.story.id.localeCompare(b.story.id) || a.worker.lane_id.localeCompare(b.worker.lane_id));
+    if (staleLedger.length > 0) {
+        const labels = staleLedger.map(({ story, worker }) => `${story.id} (lane ${worker.lane_id}, ledger updated ${story.updatedAt})`).join("; ");
+        const fingerprint = `stale-ledger:${staleLedger.map(({ story, worker }) => `${story.id}:${worker.lane_id}:${story.updatedAt}`).join(",")}`;
+        wakes.push({ condition: "stale_worker_ledger", lead_lane: lead.lane_id, story_id: staleLedger.map(({ story }) => story.id).join(","), worker_lane: staleLedger.length === 1 ? staleLedger[0].worker.lane_id : undefined, fingerprint,
+            prompt: `A running worker has made no ledger update in over 30 minutes: ${labels}. Check the worker and update the story ledger. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    const withoutLiveLane = stories.flatMap((story) => {
+        if (story.status !== "in_progress")
+            return [];
+        const laneIds = story.laneIds ?? [];
+        // A story assigned to the lead itself is worked by the lead, which is the lane being woken.
+        if (laneIds.includes(lead.lane_id))
+            return [];
+        const live = laneIds.filter((laneId) => children.some((child) => child.lane_id === laneId && LIVE_STATES.has(child.state)));
+        if (live.length > 0)
+            return [];
+        const detail = laneIds.length === 0 ? "empty lane assignment" : `no live lane among ${laneIds.join(", ")}`;
+        return [{ story, laneIds, detail }];
+    }).sort((a, b) => a.story.id.localeCompare(b.story.id));
+    if (withoutLiveLane.length > 0) {
+        const labels = withoutLiveLane.map(({ story, detail }) => `${story.id} (${detail})`).join("; ");
+        const fingerprint = `missing-worker:${withoutLiveLane.map(({ story, detail }) => `${story.id}:${story.updatedAt ?? ""}:${detail}`).join(",")}`;
+        wakes.push({ condition: "story_without_live_lane", lead_lane: lead.lane_id, story_id: withoutLiveLane.map(({ story }) => story.id).join(","), fingerprint,
+            prompt: `In-progress story has no live worker lane: ${labels}. Relaunch a worker or set the story to waiting/blocked with its wake. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    return wakes;
+}
+function readState(file) {
+    if (!fs.existsSync(file))
+        return { schema_version: "hq-lanes-autopilot-state.v1", sent: {}, deadline_misses: {} };
+    const value = readJsonFile(file, "lead_autopilot_state_invalid");
+    if (!isRecord(value) || value.schema_version !== "hq-lanes-autopilot-state.v1" || !isRecord(value.sent) ||
+        (value.delivered_ids !== undefined && !isRecord(value.delivered_ids)) ||
+        (value.deadline_misses !== undefined && !isRecord(value.deadline_misses)) ||
+        (value.per_lead_error_notices !== undefined && (!isRecord(value.per_lead_error_notices) || Object.values(value.per_lead_error_notices).some((id) => typeof id !== "string")))) {
+        throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state ${file}`, { path: file });
+    }
+    for (const [key, row] of Object.entries(value.sent)) {
+        if (!isRecord(row) || typeof row.fingerprint !== "string" || typeof row.at !== "string" ||
+            (row.status_updated_at !== undefined && typeof row.status_updated_at !== "string") ||
+            (row.acted !== undefined && typeof row.acted !== "boolean") ||
+            (row.auto_started !== undefined && typeof row.auto_started !== "boolean") ||
+            (row.worker_lane !== undefined && typeof row.worker_lane !== "string") ||
+            (row.wake_count !== undefined && (!Number.isSafeInteger(row.wake_count) || row.wake_count < 1)) ||
+            (row.last_wake_at !== undefined && typeof row.last_wake_at !== "string") ||
+            (row.escalated_at !== undefined && typeof row.escalated_at !== "string") ||
+            (row.inactive_since !== undefined && (typeof row.inactive_since !== "string" || !Number.isFinite(Date.parse(row.inactive_since))))) {
+            throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state entry ${key}`, { path: file, key });
+        }
+    }
+    for (const [key, row] of Object.entries(value.deadline_misses ?? {})) {
+        if (!isRecord(row) || typeof row.item !== "string" || typeof row.owner !== "string" ||
+            typeof row.due_at !== "string" || !Number.isFinite(Date.parse(row.due_at)) ||
+            !Number.isSafeInteger(row.miss_count) || row.miss_count < 1 ||
+            typeof row.first_missed_at !== "string" || !Number.isFinite(Date.parse(row.first_missed_at)) ||
+            typeof row.currently_missed !== "boolean" ||
+            (row.escalated_at !== undefined && (typeof row.escalated_at !== "string" || !Number.isFinite(Date.parse(row.escalated_at))))) {
+            throw new LanesError("lead_autopilot_state_invalid", `Invalid missed-deadline state entry ${key}`, { path: file, key });
+        }
+    }
+    for (const [messageId, deliveredAt] of Object.entries(value.delivered_ids ?? {})) {
+        if (!messageId.trim() || typeof deliveredAt !== "string" || !Number.isFinite(Date.parse(deliveredAt))) {
+            throw new LanesError("lead_autopilot_state_invalid", `Invalid delivered message id ${messageId}`, { path: file, message_id: messageId });
+        }
+    }
+    return {
+        ...value,
+        per_lead_error_notices: (value.per_lead_error_notices ?? {}),
+    };
+}
+function appendAutopilotMessage(input) {
+    if (input.dedupeEnabled && input.state.delivered_ids?.[input.message.message_id])
+        return false;
+    appendDropboxMessage(input.hqRoot, input.leadLane, input.message);
+    if (input.dedupeEnabled) {
+        input.state.delivered_ids ??= {};
+        input.state.delivered_ids[input.message.message_id] = input.message.at;
+    }
+    return true;
+}
+function removeDeliveredIdsForFingerprint(state, fingerprint) {
+    const prefix = `lead-autopilot:${fingerprint}`;
+    let removed = false;
+    for (const messageId of Object.keys(state.delivered_ids ?? {})) {
+        if (messageId.startsWith(prefix)) {
+            delete state.delivered_ids[messageId];
+            removed = true;
+        }
+    }
+    return removed;
+}
+function pruneDeliveredIds(state, now) {
+    let pruned = false;
+    for (const [messageId, deliveredAt] of Object.entries(state.delivered_ids ?? {})) {
+        if (now.getTime() - Date.parse(deliveredAt) > LEAD_AUTOPILOT_DELIVERED_ID_RETENTION_MS) {
+            delete state.delivered_ids[messageId];
+            pruned = true;
+        }
+    }
+    return pruned;
+}
+function writeState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+function recordOperatorEscalation(hqRoot, record) {
+    const file = path.join(hqRoot, "workspace", "lane-briefs", "ops-board-state.json");
+    let state = {};
+    if (fs.existsSync(file)) {
+        const value = readJsonFile(file, "lead_autopilot_escalation_record_invalid");
+        if (!isRecord(value))
+            throw new LanesError("lead_autopilot_escalation_record_invalid", `Invalid operator board state ${file}`);
+        state = value;
+    }
+    const current = state.autopilot_escalations;
+    if (current !== undefined && (!Array.isArray(current) || current.some((item) => !isRecord(item)))) {
+        throw new LanesError("lead_autopilot_escalation_record_invalid", `Invalid autopilot escalations in ${file}`);
+    }
+    const rows = (current ?? []);
+    if (rows.some((item) => item.lead_lane === record.lead_lane && item.fingerprint === record.fingerprint))
+        return;
+    const next = { ...state, autopilot_escalations: [...rows, record] };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+async function runLeadAutopilotPassUnlocked(input) {
+    const { hqRoot, host, now } = input;
+    const effectiveOutpostId = input.outpostId !== null && isControllerAliasOutpostId(input.outpostId, { kind: "outpost", id: input.outpostId }) ? null : input.outpostId;
+    const result = { ok: true, host, evaluated: 0, sent: [], started: [], escalated: [], skipped: [] };
+    const registered = parseRegistry(hqRoot, input.outpostId, now);
+    if (registered === null)
+        result.registry = "missing";
+    const leads = registered ?? [];
+    const lanes = readAllLanes(hqRoot);
+    const byId = new Map(lanes.map((lane) => [lane.lane_id, lane]));
+    const stateFile = path.join(hqRoot, "workspace", "lane-briefs", "autopilot-state.json");
+    const state = readState(stateFile);
+    for (const registered of leads) {
+        const lead = byId.get(registered.lane) ?? lanes.find((candidate) => candidate.lane_id.startsWith(`${registered.lane}_`));
+        if (!lead) {
+            result.skipped.push({ lead_lane: registered.lane, reason: "lead_lane_missing" });
+            continue;
+        }
+        const company = resolveLaneCompany(hqRoot, lead).company;
+        if (!company) {
+            result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_company_unresolved" });
+            continue;
+        }
+        const registeredLocalHost = registered.host === "local" || registered.host === input.hostname;
+        const hostMatchesRegistry = registeredLocalHost
+            ? lead.host.kind === "local"
+            : lead.host.kind === "outpost" && lead.host.id === registered.host && input.outpostId === registered.host;
+        if (!hostMatchesRegistry ||
+            !laneRunsOnHost(lead, { hostname: input.hostname, outpostId: effectiveOutpostId })) {
+            result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });
+            continue;
+        }
+        let stateChanged = false;
+        let perLeadErrorsEnabled = false;
+        let currentInputPath = registered.status;
+        try {
+            const readFlag = input.readFlag ?? readLanesRegistryFlag;
+            const enabled = await readFlag(LEAD_AUTOPILOT_FLAG, { company });
+            if (!enabled) {
+                result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
+                continue;
+            }
+            perLeadErrorsEnabled = await readFlag(PER_LEAD_ERRORS_FLAG, { company });
+            currentInputPath = registered.status;
+            const status = readStatus(hqRoot, registered.status, company.slug);
+            const kpiStalenessEnabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_KPI_STALENESS_FLAG, { company });
+            const kpiStalenessBatchEnabled = kpiStalenessEnabled && await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, { company });
+            if (kpiStalenessEnabled) {
+                result.kpi_status ??= [];
+                result.kpi_status.push(...managerKpiFreshness(status, now).map((kpi) => ({
+                    lead_lane: lead.lane_id,
+                    team: registered.team,
+                    kpi: kpi.name,
+                    age_minutes: kpi.ageMinutes,
+                    stale: kpi.stale,
+                    stale_after_minutes: kpi.staleAfterMinutes,
+                    ...(kpi.status === undefined ? {} : { status: kpi.status }),
+                    ...(kpi.error === undefined ? {} : { error: kpi.error }),
+                })));
+            }
+            const statusUpdatedAt = typeof status.updated_at === "string" && Number.isFinite(Date.parse(status.updated_at))
+                ? new Date(Date.parse(status.updated_at)).toISOString()
+                : undefined;
+            currentInputPath = registered.prd;
+            const stories = projectStories(hqRoot, registered.prd, company.slug, lead.project_id);
+            const children = lanes.filter((lane) => lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
+            const deadlineEscalationEnabled = await (input.readDeadlineFlag ?? readFlag)(LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, { company });
+            const nudgeDedupeEnabled = await (input.readNudgeDedupeFlag ?? readFlag)(LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG, { company });
+            if (nudgeDedupeEnabled && pruneDeliveredIds(state, now))
+                stateChanged = true;
+            currentInputPath = registered.status;
+            const planned = planLeadAutopilotWakes({
+                lead,
+                children,
+                stories,
+                now,
+                managerStatus: status,
+                kpiStalenessEnabled,
+                kpiStalenessBatchEnabled,
+                keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
+            });
+            const stateKey = (wake) => `${lead.lane_id}:${wake.condition}${wake.condition === "stale_kpi" ? `:${wake.kpi_id}` : ""}`;
+            const activeKeys = new Set(planned.map(stateKey));
+            const suppressedKeys = new Set();
+            for (const key of Object.keys(state.sent)) {
+                if (!key.startsWith(`${lead.lane_id}:`))
+                    continue;
+                const entry = state.sent[key];
+                const isActive = activeKeys.has(key);
+                if (!nudgeDedupeEnabled) {
+                    if (!isActive) {
+                        delete state.sent[key];
+                        stateChanged = true;
+                    }
+                    continue;
+                }
+                if (!isActive && entry.inactive_since === undefined) {
+                    state.sent[key] = { ...entry, inactive_since: now.toISOString() };
+                    stateChanged = true;
+                    continue;
+                }
+                if (isActive && entry.inactive_since !== undefined) {
+                    const inactiveAt = Date.parse(entry.inactive_since);
+                    if (now.getTime() - inactiveAt < LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS) {
+                        suppressedKeys.add(key);
+                    }
+                    else {
+                        delete state.sent[key];
+                        if (removeDeliveredIdsForFingerprint(state, entry.fingerprint))
+                            stateChanged = true;
+                        stateChanged = true;
+                    }
+                }
+                else if (!isActive) {
+                    const inactiveSince = entry.inactive_since ?? now.toISOString();
+                    if (now.getTime() - Date.parse(inactiveSince) >= LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS) {
+                        delete state.sent[key];
+                        if (removeDeliveredIdsForFingerprint(state, entry.fingerprint))
+                            stateChanged = true;
+                        stateChanged = true;
+                    }
+                    else if (entry.inactive_since === undefined) {
+                        state.sent[key] = { ...entry, inactive_since: inactiveSince };
+                        stateChanged = true;
+                    }
+                }
+            }
+            for (const wake of planned) {
+                const key = stateKey(wake);
+                if (suppressedKeys.has(key))
+                    continue;
+                const prior = state.sent[key];
+                if (nudgeDedupeEnabled && prior && prior.fingerprint !== wake.fingerprint && !prior.acted) {
+                    const leadActedSincePrior = statusUpdatedAt !== undefined && prior.status_updated_at !== undefined &&
+                        Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at);
+                    if (!leadActedSincePrior) {
+                        const lastWakeAt = Date.parse(prior.last_wake_at ?? prior.at);
+                        if (!Number.isFinite(lastWakeAt)) {
+                            throw new LanesError("lead_autopilot_state_invalid", `Invalid wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                        }
+                        if (now.getTime() - lastWakeAt < LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS)
+                            continue;
+                    }
+                }
+                if (prior?.fingerprint === wake.fingerprint) {
+                    if (input.dryRun)
+                        continue;
+                    let current = prior;
+                    const lastWakeAt = Date.parse(prior.last_wake_at ?? prior.at);
+                    if (!Number.isFinite(lastWakeAt)) {
+                        throw new LanesError("lead_autopilot_state_invalid", `Invalid wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                    }
+                    if (statusUpdatedAt === undefined || prior.status_updated_at === undefined) {
+                        throw new LanesError("lead_autopilot_status_activity_unverifiable", `Cannot verify whether lead ${lead.lane_id} acted after its autopilot wake`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                    }
+                    if (!prior.acted && Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at)) {
+                        current = { ...prior, acted: true };
+                        state.sent[key] = current;
+                        stateChanged = true;
+                    }
+                    if (wake.condition === "fill_grant" && input.startWorker && !current.acted && !current.auto_started) {
+                        const firstWakeAt = Date.parse(current.at);
+                        if (!Number.isFinite(firstWakeAt)) {
+                            throw new LanesError("lead_autopilot_state_invalid", `Invalid fill-grant wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                        }
+                        if (now.getTime() - firstWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
+                            const story = stories.find((candidate) => candidate.id === wake.story_id && candidate.status === "todo");
+                            if (!story?.briefPath) {
+                                throw new LanesError("lead_autopilot_story_brief_missing", `Cannot auto-start story ${wake.story_id}: its project record has no valid brief path`, { lead_lane: lead.lane_id, story_id: wake.story_id, project_id: lead.project_id });
+                            }
+                            if (lead.state !== "running" && lead.state !== "queued") {
+                                current = { ...current, acted: true };
+                                state.sent[key] = current;
+                                stateChanged = true;
+                                result.skipped.push({ lead_lane: lead.lane_id, reason: "auto_start_lead_not_active" });
+                            }
+                            else {
+                                const started = await input.startWorker({ lead, story });
+                                current = { ...current, auto_started: true, worker_lane: started.lane_id };
+                                state.sent[key] = current;
+                                stateChanged = true;
+                                result.started.push({ lead_lane: lead.lane_id, story_id: story.id, worker_lane: started.lane_id });
+                            }
+                        }
+                    }
+                    // Stale KPIs get one notice per measurement fingerprint, not the
+                    // repeated wake/escalation cadence used by other conditions.
+                    if (wake.condition === "stale_kpi")
+                        continue;
+                    const redeliveryDelay = nudgeDedupeEnabled ? LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS : LEAD_AUTOPILOT_FILL_DELAY_MS;
+                    if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= redeliveryDelay) {
+                        const wakeCount = current.wake_count ?? 1;
+                        if (wakeCount < 2) {
+                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                                    at: now.toISOString(),
+                                    message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
+                                    kind: "system_notice",
+                                    text: wake.prompt,
+                                } });
+                            current = { ...current, wake_count: 2, last_wake_at: now.toISOString() };
+                            state.sent[key] = current;
+                            stateChanged = true;
+                            if (delivered)
+                                result.sent.push(wake);
+                        }
+                        else {
+                            const escalation = { team: registered.team, lead_lane: lead.lane_id, condition: wake.condition, story_id: wake.story_id, at: now.toISOString(), fingerprint: wake.fingerprint };
+                            recordOperatorEscalation(hqRoot, escalation);
+                            current = { ...current, escalated_at: now.toISOString() };
+                            state.sent[key] = current;
+                            stateChanged = true;
+                            result.escalated.push(escalation);
+                        }
+                    }
+                    continue;
+                }
+                if (!input.dryRun) {
+                    const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                            at: now.toISOString(),
+                            message_id: `lead-autopilot:${wake.fingerprint}`,
+                            kind: "system_notice",
+                            text: wake.prompt,
+                        } });
+                    state.sent[key] = {
+                        fingerprint: wake.fingerprint,
+                        at: now.toISOString(),
+                        ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
+                        wake_count: 1,
+                        last_wake_at: now.toISOString(),
+                    };
+                    stateChanged = true;
+                    if (!delivered)
+                        continue;
+                }
+                result.sent.push(wake);
+            }
+            // Planned wakes have already been delivered. Persist their dedupe state
+            // before deadline parsing/recording so an unexpected deadline failure
+            // cannot make those wakes repeat on the next pass.
+            if (!input.dryRun && stateChanged) {
+                writeState(stateFile, state);
+                stateChanged = false;
+            }
+            if (deadlineEscalationEnabled) {
+                result.missed_deadlines ??= [];
+                const parsedCommitments = deadlineCommitments(status, stories, lead.lane_id);
+                if (parsedCommitments.errors.length > 0) {
+                    result.deadline_errors ??= [];
+                    result.deadline_errors.push(...parsedCommitments.errors);
+                }
+                const commitments = parsedCommitments.commitments;
+                const currentCommitmentKeys = new Set(commitments.map((item) => `${lead.lane_id}:${item.key}`));
+                const deadlineState = state.deadline_misses ?? (state.deadline_misses = {});
+                for (const key of Object.keys(deadlineState)) {
+                    if (key.startsWith(`${lead.lane_id}:`) && !currentCommitmentKeys.has(key)) {
+                        delete deadlineState[key];
+                        stateChanged = true;
+                    }
+                }
+                const escalationDelay = input.missedDeadlineEscalationDelayMs ?? LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DELAY_MS;
+                if (!Number.isFinite(escalationDelay) || escalationDelay < 0) {
+                    throw new LanesError("lead_autopilot_deadline_config_invalid", "Missed-deadline escalation delay must be a non-negative number");
+                }
+                for (const commitment of commitments) {
+                    const key = `${lead.lane_id}:${commitment.key}`;
+                    const prior = deadlineState[key];
+                    if (commitment.resolved) {
+                        if (prior) {
+                            delete deadlineState[key];
+                            stateChanged = true;
+                        }
+                        continue;
+                    }
+                    const isMissed = now.getTime() > Date.parse(commitment.due);
+                    if (!isMissed) {
+                        if (prior && (prior.due_at !== commitment.due || prior.owner !== commitment.owner || prior.currently_missed)) {
+                            deadlineState[key] = { ...prior, due_at: commitment.due, owner: commitment.owner, currently_missed: false };
+                            stateChanged = true;
+                        }
+                        continue;
+                    }
+                    if (!prior || prior.miss_count === 0) {
+                        const firstMiss = {
+                            item: commitment.item,
+                            owner: commitment.owner,
+                            due_at: commitment.due,
+                            miss_count: 1,
+                            first_missed_at: now.toISOString(),
+                            currently_missed: true,
+                        };
+                        if (!input.dryRun) {
+                            const fingerprint = `missed-deadline:${commitment.key}:${commitment.owner}:${commitment.due}`;
+                            const wake = {
+                                condition: "missed_deadline",
+                                lead_lane: lead.lane_id,
+                                story_id: commitment.item,
+                                fingerprint,
+                                prompt: `Deadline missed for ${commitment.item} (${commitment.description}), owner ${commitment.owner}, due ${commitment.due}. Deliver it or re-date with a reason. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+                            };
+                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                                    at: now.toISOString(),
+                                    message_id: `lead-autopilot:${fingerprint}`,
+                                    kind: "system_notice",
+                                    text: wake.prompt,
+                                } });
+                            stateChanged = true;
+                            if (delivered)
+                                result.sent.push(wake);
+                            deadlineState[key] = firstMiss;
+                        }
+                        else {
+                            deadlineState[key] = firstMiss;
+                        }
+                    }
+                    else {
+                        const dueChanged = prior.due_at !== commitment.due || prior.owner !== commitment.owner;
+                        const reMissed = !prior.currently_missed;
+                        const firstMissAt = Date.parse(prior.first_missed_at);
+                        if (!Number.isFinite(firstMissAt)) {
+                            throw new LanesError("lead_autopilot_state_invalid", `Invalid first missed-deadline time for ${commitment.item}`, { lead_lane: lead.lane_id, item: commitment.item });
+                        }
+                        const stillLateAgain = now.getTime() - firstMissAt >= escalationDelay;
+                        const secondMiss = !prior.escalated_at && (dueChanged || reMissed || stillLateAgain);
+                        const next = {
+                            ...prior,
+                            item: commitment.item,
+                            owner: commitment.owner,
+                            due_at: commitment.due,
+                            miss_count: secondMiss ? prior.miss_count + 1 : prior.miss_count,
+                            currently_missed: true,
+                            ...(secondMiss ? { escalated_at: now.toISOString() } : {}),
+                        };
+                        if (secondMiss) {
+                            const fingerprint = `missed-deadline:${commitment.key}:${commitment.owner}:${commitment.due}:miss-${next.miss_count}`;
+                            const escalation = {
+                                team: registered.team,
+                                lead_lane: lead.lane_id,
+                                condition: "missed_deadline",
+                                story_id: commitment.item,
+                                at: now.toISOString(),
+                                fingerprint,
+                                owner: commitment.owner,
+                                due: commitment.due,
+                                miss_count: next.miss_count,
+                            };
+                            if (!input.dryRun)
+                                recordOperatorEscalation(hqRoot, escalation);
+                            if (!input.dryRun)
+                                stateChanged = true;
+                            result.escalated.push(escalation);
+                        }
+                        if (!input.dryRun && JSON.stringify(prior) !== JSON.stringify(next))
+                            stateChanged = true;
+                        deadlineState[key] = next;
+                    }
+                    const current = deadlineState[key] ?? prior;
+                    result.missed_deadlines.push({ lead_lane: lead.lane_id, item: commitment.item, owner: commitment.owner, due: commitment.due, miss_count: current?.miss_count ?? 1 });
+                }
+            }
+            if (!input.dryRun && stateChanged)
+                writeState(stateFile, state);
+            result.evaluated += 1;
+        }
+        catch (error) {
+            if (!input.dryRun && stateChanged)
+                writeState(stateFile, state);
+            if (perLeadErrorsEnabled && error instanceof LanesError && LEAD_AUTOPILOT_PER_LEAD_ERROR_CODES.has(error.error)) {
+                const errorPath = typeof error.details.path === "string" ? error.details.path : currentInputPath;
+                const messageId = `lead-autopilot-error:${error.error}:${createHash("sha256").update(`${error.error}\0${errorPath}`).digest("hex")}`;
+                result.skipped.push({ lane_id: lead.lane_id, error: error.error, path: errorPath, message: error.message });
+                const noticeKey = `${lead.lane_id}:${error.error}:${errorPath}`;
+                if (!input.dryRun && state.per_lead_error_notices?.[noticeKey] !== messageId) {
+                    appendDropboxMessage(hqRoot, lead.lane_id, {
+                        at: now.toISOString(),
+                        message_id: messageId,
+                        kind: "system_notice",
+                        text: `Lead autopilot skipped this lead because ${error.error}: ${error.message}. Fix the registry row for lane ${registered.lane} (team ${registered.team}) in ${LEAD_REGISTRY_REL} (registered path: ${errorPath}).`,
+                    });
+                    state.per_lead_error_notices ??= {};
+                    state.per_lead_error_notices[noticeKey] = messageId;
+                    writeState(stateFile, state);
+                }
+                continue;
+            }
+            if (!(error instanceof LanesError) || LEAD_AUTOPILOT_PASS_FATAL_ERRORS.has(error.error))
+                throw error;
+            result.skipped.push({ lead_lane: lead.lane_id, reason: error.error });
+        }
+    }
+    return result;
+}
+// Tenant-boundary and path-safety failures stop the whole pass; other per-lead
+// data errors skip only that lead.
+const LEAD_AUTOPILOT_PASS_FATAL_ERRORS = new Set([
+    "lead_autopilot_tenant_mismatch",
+    "lead_autopilot_status_path_invalid",
+    "lead_autopilot_escalation_record_invalid",
+]);
+const LEAD_AUTOPILOT_PER_LEAD_ERROR_CODES = new Set([
+    "lead_autopilot_tenant_mismatch",
+    "lead_autopilot_project_path_invalid",
+    "lead_autopilot_project_invalid",
+    "lead_autopilot_story_brief_path_invalid",
+    "lead_autopilot_story_brief_invalid",
+    "lead_autopilot_status_path_invalid",
+    "lead_autopilot_status_invalid",
+]);
+const LEAD_AUTOPILOT_STALE_LOCK_MAX_AGE_MS = 60 * 60_000;
+function processStartIdentity(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+        return fields[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function reclaimStaleLock(lockPath) {
+    let before;
+    let text;
+    let after;
+    try {
+        before = fs.lstatSync(lockPath);
+        text = fs.readFileSync(lockPath, "utf8");
+        after = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        return false;
+    }
+    if (!before.isFile() || before.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino)
+        return false;
+    const [pidText, createdAt, recordedStartIdentity] = text.split("\n");
+    const pid = Number(pidText);
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    let dead = false;
+    try {
+        process.kill(pid, 0);
+        const currentStartIdentity = processStartIdentity(pid);
+        if (recordedStartIdentity && currentStartIdentity) {
+            if (recordedStartIdentity !== currentStartIdentity)
+                dead = true;
+            else
+                return false;
+        }
+        else {
+            const createdMs = Date.parse(createdAt ?? "");
+            if (!Number.isFinite(createdMs) || Date.now() - createdMs < LEAD_AUTOPILOT_STALE_LOCK_MAX_AGE_MS)
+                return false;
+            dead = true;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            return false;
+        dead = true;
+    }
+    if (!dead)
+        return false;
+    try {
+        const current = fs.lstatSync(lockPath);
+        if (current.dev !== before.dev || current.ino !== before.ino)
+            return false;
+        fs.unlinkSync(lockPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        return false;
+    }
+}
+export async function runLeadAutopilotPass(input) {
+    if (input.dryRun)
+        return runLeadAutopilotPassUnlocked(input);
+    const lockPath = path.join(input.hqRoot, "workspace", "lane-briefs", "autopilot.lock");
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    let lockFd;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            lockFd = fs.openSync(lockPath, "wx", 0o600);
+            fs.writeFileSync(lockFd, `${process.pid}\n${input.now.toISOString()}\n${processStartIdentity(process.pid) ?? ""}\n`, "utf8");
+            break;
+        }
+        catch (error) {
+            if (error.code === "EEXIST" && attempt === 0 && reclaimStaleLock(lockPath))
+                continue;
+            if (error.code === "EEXIST") {
+                throw new LanesError("lead_autopilot_lock_busy", `Another autopilot pass owns ${lockPath}`, { path: lockPath });
+            }
+            throw new LanesError("lead_autopilot_lock_failed", `Cannot lock autopilot state: ${error instanceof Error ? error.message : String(error)}`, { path: lockPath });
+        }
+    }
+    if (lockFd === undefined)
+        throw new LanesError("lead_autopilot_lock_busy", `Another autopilot pass owns ${lockPath}`, { path: lockPath });
+    try {
+        return await runLeadAutopilotPassUnlocked(input);
+    }
+    finally {
+        try {
+            fs.closeSync(lockFd);
+        }
+        catch (error) {
+            process.stderr.write(`hq lanes autopilot: lock close failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                process.stderr.write(`hq lanes autopilot: lock removal failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=autopilot.js.map