@indigoai-us/hq-cli 5.311.4 → 5.312.1

package/dist/lib/lanes/autopilot.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { laneRunsOnHost } from "./admission.js";
@@ -5,14 +6,20 @@ 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 } from "./flag-keys.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { LEAD_AUTOPILOT_KPI_STALENESS_FLAG } from "./flag-keys.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_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;
 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) {
@@ -157,9 +164,112 @@ function projectStories(hqRoot, relativePath, companySlug, projectId) {
             ...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 });
@@ -232,6 +342,72 @@ function statusBlockers(status) {
         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) => {
@@ -249,6 +425,23 @@ export function planLeadAutopilotWakes(input) {
     const blockers = statusBlockers(status);
     const byStory = new Map(stories.map((story) => [story.id, story]));
     const wakes = [];
+    if (input.kpiStalenessEnabled) {
+        for (const kpi of managerKpiFreshness(status, now)) {
+            if (!kpi.stale)
+                continue;
+            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 [];
@@ -384,9 +577,10 @@ export function planLeadAutopilotWakes(input) {
 }
 function readState(file) {
     if (!fs.existsSync(file))
-        return { schema_version: "hq-lanes-autopilot-state.v1", sent: {} };
+        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)) {
+    if (!isRecord(value) || value.schema_version !== "hq-lanes-autopilot-state.v1" || !isRecord(value.sent) ||
+        (value.deadline_misses !== undefined && !isRecord(value.deadline_misses))) {
         throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state ${file}`, { path: file });
     }
     for (const [key, row] of Object.entries(value.sent)) {
@@ -401,6 +595,16 @@ function readState(file) {
             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 });
+        }
+    }
     return value;
 }
 function writeState(file, state) {
@@ -465,26 +669,44 @@ async function runLeadAutopilotPassUnlocked(input) {
         }
         let stateChanged = false;
         try {
-            const enabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_FLAG, { company });
+            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;
             }
             const status = readStatus(hqRoot, registered.status, company.slug);
+            const kpiStalenessEnabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_KPI_STALENESS_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;
             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 planned = planLeadAutopilotWakes({
                 lead,
                 children,
                 stories,
                 now,
                 managerStatus: status,
+                kpiStalenessEnabled,
                 keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
             });
-            const activeKeys = new Set(planned.map((wake) => `${lead.lane_id}:${wake.condition}`));
+            const stateKey = (wake) => `${lead.lane_id}:${wake.condition}${wake.condition === "stale_kpi" ? `:${wake.kpi_id}` : ""}`;
+            const activeKeys = new Set(planned.map(stateKey));
             for (const key of Object.keys(state.sent)) {
                 if (key.startsWith(`${lead.lane_id}:`) && !activeKeys.has(key)) {
                     delete state.sent[key];
@@ -492,7 +714,7 @@ async function runLeadAutopilotPassUnlocked(input) {
                 }
             }
             for (const wake of planned) {
-                const key = `${lead.lane_id}:${wake.condition}`;
+                const key = stateKey(wake);
                 const prior = state.sent[key];
                 if (prior?.fingerprint === wake.fingerprint) {
                     if (input.dryRun)
@@ -535,6 +757,10 @@ async function runLeadAutopilotPassUnlocked(input) {
                             }
                         }
                     }
+                    // Stale KPIs get one notice per measurement fingerprint, not the
+                    // repeated wake/escalation cadence used by other conditions.
+                    if (wake.condition === "stale_kpi")
+                        continue;
                     if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
                         const wakeCount = current.wake_count ?? 1;
                         if (wakeCount < 2) {
@@ -578,6 +804,128 @@ async function runLeadAutopilotPassUnlocked(input) {
                 }
                 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}.`,
+                            };
+                            appendDropboxMessage(hqRoot, lead.lane_id, {
+                                at: now.toISOString(),
+                                message_id: `lead-autopilot:${fingerprint}`,
+                                kind: "system_notice",
+                                text: wake.prompt,
+                            });
+                            stateChanged = true;
+                            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;

package/dist/lib/lanes/flag-keys.d.ts

@@ -1,5 +1,13 @@
-/** hq-flags keys used by lane list and placement behavior. */
+/** hq-flags keys used by lane command behavior. */
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 /** Enables one automatic continuation after a missing-envelope repair. */
 export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
+/** Enables missed-deadline lead nudges and second-miss operator escalation. */
+export declare const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
+/** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
+export declare const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
+export declare const LANE_MESSAGE_ROUTE_OWNER_HOST_DEFAULT_ENABLED = false;
+/** Enables stale manager-status KPI reporting and one-time lead nudges. */
+export declare const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
+export declare const LEAD_AUTOPILOT_KPI_STALENESS_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -1,5 +1,13 @@
-/** hq-flags keys used by lane list and placement behavior. */
+/** hq-flags keys used by lane command behavior. */
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 /** Enables one automatic continuation after a missing-envelope repair. */
 export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
+/** Enables missed-deadline lead nudges and second-miss operator escalation. */
+export const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
+/** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
+export const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
+export const LANE_MESSAGE_ROUTE_OWNER_HOST_DEFAULT_ENABLED = false;
+/** Enables stale manager-status KPI reporting and one-time lead nudges. */
+export const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
+export const LEAD_AUTOPILOT_KPI_STALENESS_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.js.map

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

@@ -7,6 +7,8 @@ export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false
 export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
 export declare const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30000;
+export declare const LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_FLAG = "lanes.keep-alive-terminal-trigger";
+export declare const LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export declare const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

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

@@ -12,6 +12,8 @@ export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG = "lanes.keep-alive-immediate-first-resume";
 export const LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS = 30_000;
+export const LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_FLAG = "lanes.keep-alive-terminal-trigger";
+export const LEAD_LANE_KEEP_ALIVE_TERMINAL_TRIGGER_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";

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

@@ -95,6 +95,11 @@ export interface ReconcileDeps {
     mesh?: LaneMesh | null;
     /** Bound on one terminal mesh emit during dead-host recovery. Default 10 s. */
     meshEmitTimeoutMs?: number;
+    /** Restrict keep-alive execution to the terminal-triggered lane version. */
+    terminalKeepAliveCandidate?: {
+        laneId: string;
+        version: number;
+    };
     /** Fresh keep-alive eligibility read; injected to exercise opt-in changes before queueing. */
     readKeepAliveRecheckLane?: (hqRoot: string, laneId: string) => LaneRecord;
     /** Reuse the command's Claude resume selection and session-move path for keep-alive. */

package/dist/lib/lanes/reconcile.js

@@ -895,6 +895,9 @@ export async function runPassBody(hqRoot, deps) {
         markError(summary, err);
         return summary;
     }
+    if (deps.terminalKeepAliveCandidate) {
+        return runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, deps.terminalKeepAliveCandidate);
+    }
     let presenceConnected;
     try {
         presenceConnected =
@@ -1159,7 +1162,7 @@ export async function runPassBody(hqRoot, deps) {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
         await closeInterruptedDoneStoryWorkers(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, storyCloseEnabledByCompany);
-        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany);
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, admissionDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany, deps.terminalKeepAliveCandidate);
         const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, admissionDeps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, admissionDeps);
@@ -1635,13 +1638,15 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
         }
     }
 }
-async function admitQueued(hqRoot, lanes, summary, deps, now) {
-    expireAbandonedPickupValidation(hqRoot, lanes, summary, deps, now);
+async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds) {
+    if (onlyLaneIds === undefined)
+        expireAbandonedPickupValidation(hqRoot, lanes, summary, deps, now);
     // A lane whose pickup probe is still out is not admitted: its record is
     // about to be bound or failed by the pickup, and a worker spawned now
     // would keep running behind that write.
     const localQueued = lanes
         .filter((lane) => lane.state === "queued" &&
+        (onlyLaneIds === undefined || onlyLaneIds.has(lane.lane_id)) &&
         lane.pickup_validation_pending !== true &&
         laneRunsHere(lane, deps.host))
         .filter((lane) => !hasFreshAdmissionReservation(lane, now.getTime()))
@@ -2238,7 +2243,7 @@ function appendBlockedKeepAliveHistory(hqRoot, lane, terminalAt, at, reason, dep
         }),
     }), false);
 }
-async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany) {
+async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany, supersessionLineageAwareByCompany, blockedResumeFlagByCompany, immediateFirstResumeFlagByCompany, terminalKeepAliveCandidate) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -2262,6 +2267,10 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
         }
     }
     for (const originalLane of lanes) {
+        if (terminalKeepAliveCandidate && (originalLane.lane_id !== terminalKeepAliveCandidate.laneId ||
+            originalLane.version !== terminalKeepAliveCandidate.version ||
+            originalLane.state !== "done"))
+            continue;
         if (!laneRunsHere(originalLane, deps.host))
             continue;
         if (originalLane.state === "killed" ||
@@ -3082,6 +3091,50 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
 export async function runReconcilePass(hqRoot, deps) {
     return withReconcileLock(hqRoot, async () => runPassBody(hqRoot, deps));
 }
+async function runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, candidate) {
+    const lane = lanes.find((row) => row.lane_id === candidate.laneId);
+    if (!lane || lane.version !== candidate.version || lane.state !== "done" ||
+        lane.keep_alive !== true || !laneRunsHere(lane, deps.host))
+        return summary;
+    let company;
+    try {
+        company = resolveLaneCompany(hqRoot, lane).company;
+    }
+    catch (err) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: `keep-alive company lookup failed: ${err instanceof Error ? err.message : String(err)}` });
+        return summary;
+    }
+    if (company === null)
+        return summary;
+    const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
+    const options = { company, env: deps.env ?? process.env };
+    let keepAliveEnabled;
+    let lineageAware;
+    let immediateFirstResumeEnabled;
+    try {
+        [keepAliveEnabled, lineageAware, immediateFirstResumeEnabled] = await Promise.all([
+            readFlag(LEAD_LANE_KEEP_ALIVE_FLAG, options),
+            readFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, options),
+            readFlag(LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, options),
+        ]);
+    }
+    catch (err) {
+        markDirty(summary, { kind: "lane", id: lane.lane_id, why: `keep-alive flag read failed: ${err instanceof Error ? err.message : String(err)}` });
+        return summary;
+    }
+    if (!keepAliveEnabled)
+        return summary;
+    await withAllLaneAdmissionLocks(hqRoot, async () => {
+        const freshLanes = loadLaneRecords(hqRoot, summary);
+        const freshQuestions = loadQuestionRecords(hqRoot, summary);
+        const current = freshLanes.find((row) => row.lane_id === candidate.laneId);
+        if (!current || current.version !== candidate.version || current.state !== "done")
+            return;
+        await resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, deps, now, new Map([[keepAliveCompanyKey(company), true]]), new Map([[keepAliveCompanyKey(company), lineageAware]]), new Map(), new Map([[keepAliveCompanyKey(company), immediateFirstResumeEnabled]]), candidate);
+        await admitQueued(hqRoot, loadLaneRecords(hqRoot, summary), summary, deps, now, new Set([candidate.laneId]));
+    });
+    return summary;
+}
 /** Run the reconcile answer-resume path for one lane before questions answer returns. */
 export async function wakeAnsweredLaneNow(hqRoot, laneId, deps) {
     const summary = emptySummary(deps.dryRun);