@indigoai-us/hq-cli 5.313.0 → 5.315.0

package/dist/lib/lanes/autopilot.js

@@ -6,20 +6,26 @@ 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 { 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 { 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_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) {
@@ -426,21 +432,39 @@ export function planLeadAutopilotWakes(input) {
     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`;
+        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: 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}.`,
+                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))
@@ -580,7 +604,9 @@ function readState(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.deadline_misses !== undefined && !isRecord(value.deadline_misses))) {
+        (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)) {
@@ -591,7 +617,8 @@ function readState(file) {
             (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.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 });
         }
     }
@@ -605,7 +632,46 @@ function readState(file) {
             throw new LanesError("lead_autopilot_state_invalid", `Invalid missed-deadline state entry ${key}`, { path: file, key });
         }
     }
-    return value;
+    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 });
@@ -668,6 +734,8 @@ async function runLeadAutopilotPassUnlocked(input) {
             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 });
@@ -675,8 +743,11 @@ async function runLeadAutopilotPassUnlocked(input) {
                 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) => ({
@@ -693,9 +764,14 @@ async function runLeadAutopilotPassUnlocked(input) {
             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,
@@ -703,19 +779,72 @@ async function runLeadAutopilotPassUnlocked(input) {
                 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}:`) && !activeKeys.has(key)) {
-                    delete state.sent[key];
+                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;
@@ -761,19 +890,21 @@ async function runLeadAutopilotPassUnlocked(input) {
                     // 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 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) {
-                            appendDropboxMessage(hqRoot, lead.lane_id, {
-                                at: now.toISOString(),
-                                message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
-                                kind: "system_notice",
-                                text: wake.prompt,
-                            });
+                            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;
-                            result.sent.push(wake);
+                            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 };
@@ -787,12 +918,12 @@ async function runLeadAutopilotPassUnlocked(input) {
                     continue;
                 }
                 if (!input.dryRun) {
-                    appendDropboxMessage(hqRoot, lead.lane_id, {
-                        at: now.toISOString(),
-                        message_id: `lead-autopilot:${wake.fingerprint}`,
-                        kind: "system_notice",
-                        text: wake.prompt,
-                    });
+                    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(),
@@ -801,6 +932,8 @@ async function runLeadAutopilotPassUnlocked(input) {
                         last_wake_at: now.toISOString(),
                     };
                     stateChanged = true;
+                    if (!delivered)
+                        continue;
                 }
                 result.sent.push(wake);
             }
@@ -867,14 +1000,15 @@ async function runLeadAutopilotPassUnlocked(input) {
                                 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,
-                            });
+                            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;
-                            result.sent.push(wake);
+                            if (delivered)
+                                result.sent.push(wake);
                             deadlineState[key] = firstMiss;
                         }
                         else {
@@ -933,6 +1067,24 @@ async function runLeadAutopilotPassUnlocked(input) {
         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 });
@@ -947,6 +1099,15 @@ const LEAD_AUTOPILOT_PASS_FATAL_ERRORS = new Set([
     "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 {

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

@@ -6,10 +6,17 @@ export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair
 export declare const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-count-live-only";
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export declare const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
+export declare const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
 /** 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;
+/** Skips malformed lead inputs individually instead of aborting the pass. */
+export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = "lanes.autopilot-per-lead-errors";
+export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
+/** Batches stale manager-status KPI notices into one lead message per pass. */
+export declare const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG = "lanes.autopilot-kpi-staleness-batch";
+export declare const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.d.ts.map

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

@@ -6,10 +6,17 @@ export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continu
 export const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-count-live-only";
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
+export const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
 /** 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;
+/** Skips malformed lead inputs individually instead of aborting the pass. */
+export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = "lanes.autopilot-per-lead-errors";
+export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
+/** Batches stale manager-status KPI notices into one lead message per pass. */
+export const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG = "lanes.autopilot-kpi-staleness-batch";
+export const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.js.map

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

@@ -0,0 +1,46 @@
+export type KeepAliveAuditVerdict = "on_time" | "late" | "early_wake" | "message_wake" | "self_wake" | "early_by_keep_alive" | "not_restarted" | "waiting";
+export interface KeepAliveAuditRestart {
+    at: string;
+    trigger: string;
+    caller: string | null;
+}
+export interface KeepAliveAuditRow {
+    lane: string;
+    project: string;
+    profile: string | null;
+    stopped_at: string;
+    next_check_at: string | null;
+    due_at: string;
+    due_reason: "next_check_at" | "backoff";
+    restart: KeepAliveAuditRestart | null;
+    verdict: KeepAliveAuditVerdict;
+}
+export interface KeepAliveAuditSummary {
+    by_verdict: Record<KeepAliveAuditVerdict, number>;
+    not_restarted: number;
+    late_over_10m: number;
+    early_wake_by_others: number;
+    self_wake: number;
+    stopped_and_not_restarted_on_their_own: number;
+}
+export interface KeepAliveAuditError {
+    lane: string;
+    error: string;
+    path: string;
+    message: string;
+}
+export interface KeepAliveAuditResult {
+    ok: true;
+    since: string;
+    rows: KeepAliveAuditRow[];
+    errors: KeepAliveAuditError[];
+    summary: KeepAliveAuditSummary;
+}
+export declare function buildKeepAliveAudit(input: {
+    hqRoot: string;
+    now: Date;
+    since?: string;
+    laneId?: string;
+}): KeepAliveAuditResult;
+export declare function formatKeepAliveAuditText(result: KeepAliveAuditResult): string;
+//# sourceMappingURL=keep-alive-audit.d.ts.map