@indigoai-us/hq-cli 5.264.0 → 5.265.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [5.265.0] — 2026-09-28
+
+### Added
+
+- The `lanes.kr-freshness` flag tracks each manager KPI in a runtime-owned
+  ledger and queues one corrective resume for each stalled KPI set. The
+  freshness window defaults to six hours and can be set with
+  `kr_freshness_hours` in the lanes config.
+
+### Fixed
+
+- Reconcile resolves a missing lane company for keep-alive and supersession
+  flag reads, and watch applies the same resolution to keep-alive checks.
+  Unusable project ownership remains unresolved; reconcile reports
+  `keep_alive_company_unresolved` or `keep_alive_flag_off` instead of silently
+  skipping those candidates.
+
 ## [5.264.0] — 2026-09-28
 
 ### Removed

package/dist/command-catalog.generated.d.ts

@@ -7537,6 +7537,22 @@ export declare const COMMAND_CATALOG: readonly [{
             }];
             readonly subcommands: readonly [];
         }];
+    }, {
+        readonly name: "kpis";
+        readonly description: "Show runtime freshness for a manager lane's key results";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options] <lane>";
+        readonly arguments: readonly [{
+            readonly name: "lane";
+            readonly required: true;
+            readonly variadic: false;
+        }];
+        readonly options: readonly [{
+            readonly flags: "--json";
+            readonly description: "Print the KR freshness report as JSON";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "create";
         readonly description: "Register a lane, run admission, and return immediately";

package/dist/command-catalog.generated.js

@@ -9742,6 +9742,27 @@ export const COMMAND_CATALOG = [
                     }
                 ]
             },
+            {
+                "name": "kpis",
+                "description": "Show runtime freshness for a manager lane's key results",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options] <lane>",
+                "arguments": [
+                    {
+                        "name": "lane",
+                        "required": true,
+                        "variadic": false
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--json",
+                        "description": "Print the KR freshness report as JSON"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "create",
                 "description": "Register a lane, run admission, and return immediately",

package/dist/commands/lanes-kpis.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+export interface LaneKpisCommandDeps {
+    hqRoot: () => string;
+    now: () => Date;
+    wrap: WrapHandler;
+}
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+/** Register the operator report command without depending on the large lanes registrar. */
+export declare function registerLaneKpisCommand(parent: Command, deps: LaneKpisCommandDeps): void;
+export {};
+//# sourceMappingURL=lanes-kpis.d.ts.map

package/dist/commands/lanes-kpis.js

@@ -0,0 +1,34 @@
+import { readKrFreshnessReport } from "../lib/lanes/kr-freshness.js";
+/** Register the operator report command without depending on the large lanes registrar. */
+export function registerLaneKpisCommand(parent, deps) {
+    parent
+        .command("kpis")
+        .description("Show runtime freshness for a manager lane's key results")
+        .argument("<lane>")
+        .option("--json", "Print the KR freshness report as JSON")
+        .action(deps.wrap(async (laneId, options) => {
+        const report = readKrFreshnessReport(deps.hqRoot(), laneId, deps.now().getTime());
+        const result = {
+            ok: true,
+            action: "kpis",
+            lane_id: laneId,
+            ledger_available: report.available,
+            ledger_path: report.ledger_path,
+            kr_freshness_hours: report.kr_freshness_hours,
+            kpis: report.kpis,
+        };
+        if (options.json) {
+            console.log(JSON.stringify(result));
+            return;
+        }
+        if (!report.available) {
+            console.log(`No KR freshness ledger exists for ${laneId}. Expected ${report.ledger_path}.`);
+            return;
+        }
+        console.log(`KR freshness for ${laneId} (window ${report.kr_freshness_hours}h):`);
+        for (const kpi of report.kpis) {
+            console.log(`${kpi.name}: ${JSON.stringify(kpi.value)} — ${kpi.verdict}; measured ${kpi.measured_at}; value changed ${kpi.value_changed_at}`);
+        }
+    }));
+}
+//# sourceMappingURL=lanes-kpis.js.map

package/dist/commands/lanes-watch.js

@@ -1,5 +1,6 @@
 import { accountStatus, coveredLaneIds, loadLanesConfig, MAX_WATCHED_LANES, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, monitorReminderText, runLaneWatch, } from "../lib/lanes/index.js";
 import { LEAD_LANE_KEEP_ALIVE_FLAG } from "../lib/lanes/keep-alive.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { isLanesError, LanesError } from "../lib/lanes/errors.js";
 import { LANE_WAIT_INVALID_INPUT_EXIT_CODE, LANE_WAIT_TIMEOUT_EXIT_CODE, runLaneWait, } from "../lib/lanes/wait.js";
@@ -46,7 +47,7 @@ export function createLaneWatchHandlers(deps) {
             intervalMs: rawInterval,
             sleep: ctx.sleep,
             keepAliveEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
-                company: lane.company,
+                company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
                 env: ctx.env,
             }),
             readAccountStatuses: async (lanes) => {

package/dist/commands/lanes.js

@@ -18,6 +18,7 @@ import { createLaneResumeHandlers } from "./lanes-resume.js";
 import { createLaneWatchHandlers } from "./lanes-watch.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
+import { registerLaneKpisCommand } from "./lanes-kpis.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
@@ -50,6 +51,7 @@ import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
@@ -60,6 +62,7 @@ import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
 import { managerStatusGateEnabledForLane, resolveManagerStatusGateForLane, } from "../lib/lanes/manager-status-gate.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "../lib/lanes/blocker-freshness.js";
+import { resolveKrFreshnessForShow } from "../lib/lanes/kr-freshness.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
 import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, spawnEnvelopeRepairRequest, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
@@ -4524,6 +4527,7 @@ async function runShow(ctx, laneId) {
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
+    const keepAliveCompany = resolveLaneCompany(hqRoot, storedLane);
     const doneStateVerdict = storedLane.state === "done" && storedLane.keep_alive === true
         ? doneKeepAliveVerdict(storedLane, { decision: storedLane.last_envelope?.decision, story_complete: storedLane.story_complete }, storedLane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, storedLane))
         : null;
@@ -4533,6 +4537,10 @@ async function runShow(ctx, laneId) {
         env: ctx.env,
         now: ctx.now().getTime(),
     });
+    const krFreshness = await resolveKrFreshnessForShow(hqRoot, storedLane, {
+        env: ctx.env,
+        now: ctx.now().getTime(),
+    });
     printJson({
         ok: true,
         action: "show",
@@ -4562,6 +4570,8 @@ async function runShow(ctx, laneId) {
         keep_alive_state: {
             enabled: keepAliveState.enabled,
             source: keepAliveState.source,
+            company_source: keepAliveCompany.source,
+            company_slug: keepAliveCompany.company?.slug ?? null,
             standing: storedLane.keep_alive_standing === true,
             done_state_verdict: doneStateVerdict,
             opted_in_at: storedLane.keep_alive_opted_in_at ?? null,
@@ -4597,6 +4607,7 @@ async function runShow(ctx, laneId) {
                         blockerFreshnessFingerprint(blockerFreshness.stale),
             }
             : null,
+        kr_freshness: krFreshness,
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
             ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }
@@ -6918,6 +6929,7 @@ export function registerLanesCommand(parent, deps = {}) {
         env: ctx.env,
     }, wrap);
     registerOutpostPrunerCommand(lanes);
+    registerLaneKpisCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";
     lanes

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

@@ -41,6 +41,8 @@ export declare const DEFAULT_SILENT_LOST_MS: number;
 export declare const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS: number;
 /** Open manager blockers are re-verified every four hours by default. */
 export declare const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
+/** Manager key results must be re-measured within six hours by default. */
+export declare const DEFAULT_KR_FRESHNESS_HOURS = 6;
 export declare const DEFAULT_TRACKER_CHECKS: TrackerChecksConfig;
 export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
 export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;

package/dist/lib/lanes/config.js

@@ -45,6 +45,8 @@ export const DEFAULT_SILENT_LOST_MS = 12 * 60 * 60 * 1000;
 export const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS = 10 * 60;
 /** Open manager blockers are re-verified every four hours by default. */
 export const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
+/** Manager key results must be re-measured within six hours by default. */
+export const DEFAULT_KR_FRESHNESS_HOURS = 6;
 export const DEFAULT_TRACKER_CHECKS = {
     owner_question_surface_ms: 10 * 60 * 1000,
     open_question_age_ms: 2 * 60 * 60 * 1000,
@@ -425,6 +427,7 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
         tracker: { checks: { ...DEFAULT_TRACKER_CHECKS } },
         session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
         blocker_freshness_hours: DEFAULT_BLOCKER_FRESHNESS_HOURS,
+        kr_freshness_hours: DEFAULT_KR_FRESHNESS_HOURS,
     };
 }
 export function parseLanesConfig(raw, deps = defaultDeps()) {
@@ -468,6 +471,7 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         tracker: { checks: parseTrackerChecks(raw.tracker) },
         session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),
         blocker_freshness_hours: positiveNumber(raw.blocker_freshness_hours, "blocker_freshness_hours", DEFAULT_BLOCKER_FRESHNESS_HOURS),
+        kr_freshness_hours: positiveNumber(raw.kr_freshness_hours, "kr_freshness_hours", DEFAULT_KR_FRESHNESS_HOURS),
     };
 }
 export function lanesConfigPath(hqRoot) {

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

@@ -40,7 +40,7 @@ export declare function retiredLaneRegistryPath(hqRoot: string): string;
 export declare function loadRetiredLaneIds(hqRoot: string): ReadonlySet<string>;
 /** IDs may be stored bare or with an owner-host suffix after an underscore. */
 export declare function isRetiredLaneId(laneId: string, retiredLaneIds: ReadonlySet<string>): boolean;
-export declare function keepAliveSupersededBy(lane: LaneRecord, lanes: readonly LaneRecord[], lineageAware?: boolean): LaneRecord | undefined;
-export declare function keepAliveExclusion(lane: LaneRecord, lanes: readonly LaneRecord[], retiredLaneIds: ReadonlySet<string>, lineageAware?: boolean): "retired" | "superseded" | undefined;
+export declare function keepAliveSupersededBy(lane: LaneRecord, lanes: readonly LaneRecord[], lineageAware?: boolean, companyForLane?: (lane: LaneRecord) => LaneRecord["company"]): LaneRecord | undefined;
+export declare function keepAliveExclusion(lane: LaneRecord, lanes: readonly LaneRecord[], retiredLaneIds: ReadonlySet<string>, lineageAware?: boolean, companyForLane?: (lane: LaneRecord) => LaneRecord["company"]): "retired" | "superseded" | undefined;
 export declare function leadLaneKeepAliveBackoffMs(attempt: number): number;
 //# sourceMappingURL=keep-alive.d.ts.map

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

@@ -199,10 +199,12 @@ export function isRetiredLaneId(laneId, retiredLaneIds) {
     }
     return false;
 }
-export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED) {
+export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED, companyForLane) {
     const createdAt = Date.parse(lane.created_at);
     if (!Number.isFinite(createdAt))
         return undefined;
+    const companyOf = companyForLane ?? ((candidate) => candidate.company);
+    const laneCompany = companyOf(lane);
     const lanesById = new Map(lanes.map((candidate) => [candidate.lane_id, candidate]));
     const targetAncestorIds = new Set();
     if (lineageAware) {
@@ -218,9 +220,10 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
     return lanes.find((candidate) => {
         if (candidate.lane_id === lane.lane_id || Date.parse(candidate.created_at) <= createdAt)
             return false;
-        const sameCompany = lane.company === null
-            ? candidate.company === null
-            : candidate.company?.uid === lane.company.uid;
+        const candidateCompany = companyOf(candidate);
+        const sameCompany = laneCompany === null
+            ? candidateCompany === null
+            : candidateCompany?.uid === laneCompany.uid;
         if (!sameCompany)
             return false;
         if (lineageAware && targetAncestorIds.has(candidate.lane_id))
@@ -249,10 +252,10 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
         return sameProfile || projectLead;
     });
 }
-export function keepAliveExclusion(lane, lanes, retiredLaneIds, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED) {
+export function keepAliveExclusion(lane, lanes, retiredLaneIds, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED, companyForLane) {
     if (isRetiredLaneId(lane.lane_id, retiredLaneIds))
         return "retired";
-    return keepAliveSupersededBy(lane, lanes, lineageAware) === undefined ? undefined : "superseded";
+    return keepAliveSupersededBy(lane, lanes, lineageAware, companyForLane) === undefined ? undefined : "superseded";
 }
 export function leadLaneKeepAliveBackoffMs(attempt) {
     if (!Number.isSafeInteger(attempt) || attempt < 1) {

package/dist/lib/lanes/kr-freshness.d.ts

@@ -0,0 +1,76 @@
+import { type ManagerStatusTarget } from "./manager-status-gate.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import type { LaneRecord } from "./types.js";
+export declare const KR_FRESHNESS_FLAG = "lanes.kr-freshness";
+export declare const KR_FRESHNESS_DEFAULT_HOURS = 6;
+export declare const KR_FRESHNESS_LEDGER_REL: string;
+export declare const KR_FRESHNESS_LEDGER_SCHEMA = "kr-freshness-ledger.v1";
+export declare const KR_FRESHNESS_HISTORY_LIMIT = 50;
+export type KrFreshnessVerdict = "moving" | "flat" | "stalled";
+export interface KrFreshnessKpi {
+    name: string;
+    value: number | string;
+    entry_measured_at: string | null;
+    first_seen_at: string;
+    measured_at: string;
+    value_changed_at: string;
+    removed_at?: string;
+}
+export interface KrFreshnessLedger {
+    schema_version: typeof KR_FRESHNESS_LEDGER_SCHEMA;
+    lane_id: string;
+    updated_at: string;
+    kpis: Record<string, KrFreshnessKpi>;
+}
+export interface KrFreshnessView {
+    name: string;
+    value: number | string;
+    verdict: KrFreshnessVerdict;
+    measured_at: string;
+    value_changed_at: string;
+}
+export interface KrFreshnessResolution {
+    flagEnabled: boolean;
+    enabled: boolean;
+    target?: ManagerStatusTarget;
+    statusPath?: string;
+    windowHours: number;
+    kpis: KrFreshnessView[];
+    stalledKeys: string[];
+    error?: string;
+}
+export interface KrFreshnessResolutionOptions {
+    env?: NodeJS.ProcessEnv;
+    now?: number;
+    readFlag?: typeof readLanesRegistryFlag;
+    onError?: (error: unknown) => void;
+}
+export interface KrFreshnessStatusKpi {
+    key: string;
+    fullName: string;
+    name: string;
+    value: number | string;
+    entryMeasuredAt: string | null;
+}
+export declare function readKrFreshnessStatus(statusPath: string): KrFreshnessStatusKpi[];
+export declare function krFreshnessLedgerPath(root: string, laneId: string): string;
+export declare function readKrFreshnessLedger(root: string, laneId: string): KrFreshnessLedger | null;
+export declare function writeKrFreshnessLedger(root: string, ledger: KrFreshnessLedger): void;
+export declare function updateKrFreshnessLedger(laneId: string, prior: KrFreshnessLedger | null, statusKpis: readonly KrFreshnessStatusKpi[], now: number): KrFreshnessLedger;
+export declare function krFreshnessVerdict(kpi: Pick<KrFreshnessKpi, "measured_at" | "value_changed_at">, now: number, windowHours: number): KrFreshnessVerdict;
+export declare function krFreshnessFingerprint(keys: readonly string[]): string;
+/** Read the flag before manager mapping, status, configuration or ledger files. */
+export declare function resolveKrFreshnessForLane(root: string, lane: LaneRecord, options?: KrFreshnessResolutionOptions): Promise<KrFreshnessResolution>;
+/** Read a previously written ledger for `lanes show`; this never reads status. */
+export declare function resolveKrFreshnessForShow(root: string, lane: LaneRecord, options?: KrFreshnessResolutionOptions): Promise<{
+    enabled: true;
+    kpis: KrFreshnessView[];
+} | null>;
+/** Operator report path: the ledger remains readable while runtime enforcement is off. */
+export declare function readKrFreshnessReport(root: string, laneId: string, now: number): {
+    ledger_path: string;
+    available: boolean;
+    kr_freshness_hours: number;
+    kpis: KrFreshnessView[];
+};
+//# sourceMappingURL=kr-freshness.d.ts.map

package/dist/lib/lanes/kr-freshness.js

@@ -0,0 +1,412 @@
+import { createHash, randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_KR_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
+import { LanesError } from "./errors.js";
+import { resolveManagerStatusTarget } from "./manager-status-gate.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { assertNoSecretText } from "./text-scan.js";
+export const KR_FRESHNESS_FLAG = "lanes.kr-freshness";
+export const KR_FRESHNESS_DEFAULT_HOURS = DEFAULT_KR_FRESHNESS_HOURS;
+export const KR_FRESHNESS_LEDGER_REL = path.join("workspace", "lanes", "kpi-ledger");
+export const KR_FRESHNESS_LEDGER_SCHEMA = "kr-freshness-ledger.v1";
+export const KR_FRESHNESS_HISTORY_LIMIT = 50;
+const MAX_STATUS_BYTES = 1024 * 1024;
+const MAX_LEDGER_BYTES = 1024 * 1024;
+const MAX_KPIS = 1000;
+const REMOVED_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fail(code, message, details = {}) {
+    throw new LanesError(code, message, details);
+}
+function errorCode(error) {
+    return error instanceof LanesError ? error.error : "kr_freshness_unavailable";
+}
+function sha256(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function displayName(name) {
+    const chars = Array.from(name);
+    return chars.length <= 120 ? name : `${chars.slice(0, 119).join("")}…`;
+}
+function safeLaneId(laneId) {
+    return /^[A-Za-z0-9._-]{1,200}$/.test(laneId) && laneId !== "." && laneId !== "..";
+}
+function ensureLedgerDirectory(root, create) {
+    let current = path.resolve(root);
+    const parts = [current];
+    for (const segment of ["workspace", "lanes", "kpi-ledger"]) {
+        current = path.join(current, segment);
+        parts.push(current);
+    }
+    for (const [index, directory] of parts.entries()) {
+        if (create && index > 0) {
+            try {
+                fs.mkdirSync(directory, { mode: 0o700 });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST") {
+                    fail("kr_freshness_ledger_write_failed", `Cannot create KR freshness ledger directory: ${directory}`, { path: directory });
+                }
+            }
+        }
+        let stat;
+        try {
+            stat = fs.lstatSync(directory);
+        }
+        catch (error) {
+            if (!create && error.code === "ENOENT")
+                return false;
+            fail("kr_freshness_ledger_unavailable", `Cannot inspect KR freshness ledger directory: ${directory}`, { path: directory });
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            fail("kr_freshness_ledger_invalid", `KR freshness ledger path must not be a symlink: ${directory}`, { path: directory });
+        }
+    }
+    return true;
+}
+function ledgerFilePath(root, laneId) {
+    if (!safeLaneId(laneId))
+        fail("kr_freshness_lane_id_invalid", "Lane id cannot be used as a KR freshness ledger filename");
+    return path.join(root, KR_FRESHNESS_LEDGER_REL, `${laneId}.json`);
+}
+function validDate(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function validateLedger(value, laneId, filePath) {
+    if (!isObject(value) || value.schema_version !== KR_FRESHNESS_LEDGER_SCHEMA || value.lane_id !== laneId ||
+        !validDate(value.updated_at) || !isObject(value.kpis)) {
+        fail("kr_freshness_ledger_invalid", `KR freshness ledger has an invalid shape: ${filePath}`, { path: filePath });
+    }
+    const keys = Object.keys(value.kpis);
+    if (keys.length > MAX_KPIS)
+        fail("kr_freshness_ledger_invalid", `KR freshness ledger exceeds ${MAX_KPIS} entries`, { path: filePath });
+    const kpis = {};
+    for (const key of keys) {
+        const row = value.kpis[key];
+        if (!/^[a-f0-9]{64}$/.test(key) || !isObject(row) || typeof row.name !== "string" || row.name.trim() === "" ||
+            !(typeof row.value === "string" || (typeof row.value === "number" && Number.isFinite(row.value))) ||
+            !(row.entry_measured_at === null || typeof row.entry_measured_at === "string") ||
+            !validDate(row.first_seen_at) || !validDate(row.measured_at) || !validDate(row.value_changed_at) ||
+            (row.removed_at !== undefined && !validDate(row.removed_at))) {
+            fail("kr_freshness_ledger_invalid", `KR freshness ledger contains an invalid KPI record: ${filePath}`, { path: filePath });
+        }
+        assertNoSecretText("KR name", row.name);
+        if (typeof row.value === "string")
+            assertNoSecretText("KR value", row.value);
+        if (typeof row.entry_measured_at === "string")
+            assertNoSecretText("KR measured_at", row.entry_measured_at);
+        kpis[key] = {
+            name: row.name,
+            value: row.value,
+            entry_measured_at: row.entry_measured_at,
+            first_seen_at: row.first_seen_at,
+            measured_at: row.measured_at,
+            value_changed_at: row.value_changed_at,
+            ...(typeof row.removed_at === "string" ? { removed_at: row.removed_at } : {}),
+        };
+    }
+    return {
+        schema_version: KR_FRESHNESS_LEDGER_SCHEMA,
+        lane_id: laneId,
+        updated_at: value.updated_at,
+        kpis,
+    };
+}
+export function readKrFreshnessStatus(statusPath) {
+    let stat;
+    try {
+        stat = fs.lstatSync(statusPath);
+    }
+    catch (error) {
+        fail("kr_freshness_status_unreadable", `Cannot inspect manager status for KR freshness: ${statusPath}`, {
+            path: statusPath,
+            cause: error.code ?? "unknown",
+        });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_STATUS_BYTES) {
+        fail("kr_freshness_status_invalid", `Manager status is not a bounded regular file: ${statusPath}`, { path: statusPath });
+    }
+    let text;
+    try {
+        text = fs.readFileSync(statusPath, "utf8");
+    }
+    catch (error) {
+        fail("kr_freshness_status_unreadable", `Cannot read manager status for KR freshness: ${statusPath}`, {
+            path: statusPath,
+            cause: error.code ?? "unknown",
+        });
+    }
+    if (Buffer.byteLength(text, "utf8") > MAX_STATUS_BYTES) {
+        fail("kr_freshness_status_invalid", `Manager status exceeds the KR freshness size limit: ${statusPath}`, { path: statusPath });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        fail("kr_freshness_status_invalid", `Manager status contains invalid JSON: ${statusPath}`, { path: statusPath });
+    }
+    if (!isObject(parsed) || !Array.isArray(parsed.kpis)) {
+        fail("kr_freshness_status_invalid", `Manager status must contain a top-level kpis array: ${statusPath}`, { path: statusPath });
+    }
+    if (parsed.kpis.length > MAX_KPIS) {
+        fail("kr_freshness_status_invalid", `Manager status exceeds ${MAX_KPIS} KPIs: ${statusPath}`, { path: statusPath });
+    }
+    const found = new Map();
+    for (const [index, candidate] of parsed.kpis.entries()) {
+        if (!isObject(candidate) || typeof candidate.name !== "string" || candidate.name.trim() === "")
+            continue;
+        const fullName = candidate.name.trim();
+        if (Array.from(fullName).some((char) => {
+            const codePoint = char.codePointAt(0) ?? 0;
+            return codePoint <= 0x1f || codePoint === 0x7f;
+        })) {
+            fail("kr_freshness_status_invalid", `Manager KPI ${index + 1} name contains control characters: ${statusPath}`, { path: statusPath, index });
+        }
+        if (!(typeof candidate.value === "string" || (typeof candidate.value === "number" && Number.isFinite(candidate.value)))) {
+            fail("kr_freshness_status_invalid", `Manager KPI ${index + 1} needs a string or finite number value: ${statusPath}`, { path: statusPath, index });
+        }
+        if (candidate.measured_at !== undefined && typeof candidate.measured_at !== "string") {
+            fail("kr_freshness_status_invalid", `Manager KPI ${index + 1} measured_at must be a string when present: ${statusPath}`, { path: statusPath, index });
+        }
+        assertNoSecretText("KR name", fullName);
+        if (typeof candidate.value === "string")
+            assertNoSecretText("KR value", candidate.value);
+        if (typeof candidate.measured_at === "string")
+            assertNoSecretText("KR measured_at", candidate.measured_at);
+        const key = sha256(fullName);
+        if (found.has(key))
+            fail("kr_freshness_status_invalid", `Manager status contains duplicate KPI names: ${statusPath}`, { path: statusPath, index });
+        found.set(key, {
+            key,
+            fullName,
+            name: displayName(fullName),
+            value: candidate.value,
+            entryMeasuredAt: typeof candidate.measured_at === "string" ? candidate.measured_at : null,
+        });
+    }
+    return [...found.values()];
+}
+export function krFreshnessLedgerPath(root, laneId) {
+    return ledgerFilePath(root, laneId);
+}
+export function readKrFreshnessLedger(root, laneId) {
+    const filePath = ledgerFilePath(root, laneId);
+    if (!ensureLedgerDirectory(root, false))
+        return null;
+    let stat;
+    try {
+        stat = fs.lstatSync(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        fail("kr_freshness_ledger_unreadable", `Cannot inspect KR freshness ledger: ${filePath}`, { path: filePath });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_LEDGER_BYTES) {
+        fail("kr_freshness_ledger_invalid", `KR freshness ledger is not a bounded regular file: ${filePath}`, { path: filePath });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        fail("kr_freshness_ledger_invalid", `KR freshness ledger contains invalid JSON: ${filePath}`, { path: filePath });
+    }
+    return validateLedger(parsed, laneId, filePath);
+}
+export function writeKrFreshnessLedger(root, ledger) {
+    const filePath = ledgerFilePath(root, ledger.lane_id);
+    const directory = path.dirname(filePath);
+    let tempPath;
+    try {
+        ensureLedgerDirectory(root, true);
+        const data = `${JSON.stringify(ledger, null, 2)}\n`;
+        if (Buffer.byteLength(data, "utf8") > MAX_LEDGER_BYTES) {
+            fail("kr_freshness_ledger_invalid", `KR freshness ledger exceeds ${MAX_LEDGER_BYTES} bytes`, { path: filePath });
+        }
+        tempPath = path.join(directory, `.${ledger.lane_id}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+        fs.writeFileSync(tempPath, data, { encoding: "utf8", flag: "wx", mode: 0o600 });
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        if (tempPath !== undefined) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch { /* preserve the original write failure */ }
+        }
+        if (error instanceof LanesError)
+            throw error;
+        fail("kr_freshness_ledger_write_failed", `Cannot write KR freshness ledger: ${filePath}`, { path: filePath });
+    }
+}
+export function updateKrFreshnessLedger(laneId, prior, statusKpis, now) {
+    const at = new Date(now).toISOString();
+    const next = {};
+    const seen = new Set();
+    for (const item of statusKpis) {
+        const { key, fullName } = item;
+        seen.add(key);
+        const old = prior?.kpis[key];
+        const changed = old === undefined || JSON.stringify(old.value) !== JSON.stringify(item.value);
+        const remeasured = old === undefined || old.removed_at !== undefined || old.entry_measured_at !== item.entryMeasuredAt;
+        next[key] = {
+            name: item.name,
+            value: item.value,
+            entry_measured_at: item.entryMeasuredAt,
+            first_seen_at: old?.first_seen_at ?? at,
+            measured_at: changed || remeasured ? at : old.measured_at,
+            value_changed_at: changed ? at : old.value_changed_at,
+        };
+        assertNoSecretText("KR name", fullName);
+    }
+    for (const [key, old] of Object.entries(prior?.kpis ?? {})) {
+        if (seen.has(key))
+            continue;
+        const removedAt = old.removed_at ?? at;
+        if (now - Date.parse(removedAt) >= REMOVED_RETENTION_MS)
+            continue;
+        next[key] = { ...old, removed_at: removedAt };
+    }
+    if (Object.keys(next).length > MAX_KPIS) {
+        fail("kr_freshness_ledger_invalid", `KR freshness ledger exceeds ${MAX_KPIS} retained entries`);
+    }
+    return {
+        schema_version: KR_FRESHNESS_LEDGER_SCHEMA,
+        lane_id: laneId,
+        updated_at: at,
+        kpis: next,
+    };
+}
+export function krFreshnessVerdict(kpi, now, windowHours) {
+    const cutoff = now - windowHours * 60 * 60 * 1000;
+    if (Date.parse(kpi.value_changed_at) >= cutoff)
+        return "moving";
+    if (Date.parse(kpi.measured_at) >= cutoff)
+        return "flat";
+    return "stalled";
+}
+export function krFreshnessFingerprint(keys) {
+    return sha256(JSON.stringify([...keys].sort()));
+}
+function viewsFromLedger(ledger, now, windowHours) {
+    if (!ledger)
+        return [];
+    return Object.entries(ledger.kpis)
+        .filter(([, kpi]) => kpi.removed_at === undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, kpi]) => ({
+        name: kpi.name,
+        value: kpi.value,
+        verdict: krFreshnessVerdict(kpi, now, windowHours),
+        measured_at: kpi.measured_at,
+        value_changed_at: kpi.value_changed_at,
+    }));
+}
+function reportFailure(lane, error) {
+    process.stderr.write(`hq lanes: KR freshness disabled for ${lane.lane_id}: ${errorCode(error)}\n`);
+}
+function failedResolution(error, onError) {
+    onError(error);
+    return {
+        flagEnabled: false,
+        enabled: false,
+        windowHours: KR_FRESHNESS_DEFAULT_HOURS,
+        kpis: [],
+        stalledKeys: [],
+        error: errorCode(error),
+    };
+}
+/** Read the flag before manager mapping, status, configuration or ledger files. */
+export async function resolveKrFreshnessForLane(root, lane, options = {}) {
+    const onError = options.onError ?? ((error) => reportFailure(lane, error));
+    let flagEnabled;
+    try {
+        flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
+            company: lane.company ?? lane.mesh_company ?? undefined,
+            env: options.env,
+        });
+    }
+    catch (error) {
+        return failedResolution(error, onError);
+    }
+    if (!flagEnabled) {
+        return { flagEnabled: false, enabled: false, windowHours: KR_FRESHNESS_DEFAULT_HOURS, kpis: [], stalledKeys: [] };
+    }
+    try {
+        const target = resolveManagerStatusTarget(root, lane);
+        if (!target.manager || target.statusPath === undefined) {
+            return {
+                flagEnabled: true,
+                enabled: true,
+                target,
+                windowHours: KR_FRESHNESS_DEFAULT_HOURS,
+                kpis: [],
+                stalledKeys: [],
+            };
+        }
+        const windowHours = loadLanesConfig(root).kr_freshness_hours;
+        const statusKpis = readKrFreshnessStatus(target.statusPath);
+        const prior = readKrFreshnessLedger(root, lane.lane_id);
+        const ledger = updateKrFreshnessLedger(lane.lane_id, prior, statusKpis, options.now ?? Date.now());
+        writeKrFreshnessLedger(root, ledger);
+        const effectiveNow = options.now ?? Date.now();
+        return {
+            flagEnabled: true,
+            enabled: true,
+            target,
+            statusPath: target.statusPath,
+            windowHours,
+            kpis: viewsFromLedger(ledger, effectiveNow, windowHours),
+            stalledKeys: Object.entries(ledger.kpis)
+                .filter(([, kpi]) => kpi.removed_at === undefined && krFreshnessVerdict(kpi, effectiveNow, windowHours) === "stalled")
+                .map(([key]) => key)
+                .sort(),
+        };
+    }
+    catch (error) {
+        return failedResolution(error, onError);
+    }
+}
+/** Read a previously written ledger for `lanes show`; this never reads status. */
+export async function resolveKrFreshnessForShow(root, lane, options = {}) {
+    const onError = options.onError ?? ((error) => reportFailure(lane, error));
+    let enabled;
+    try {
+        enabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
+            company: lane.company ?? lane.mesh_company ?? undefined,
+            env: options.env,
+        });
+    }
+    catch (error) {
+        onError(error);
+        return null;
+    }
+    if (!enabled)
+        return null;
+    try {
+        const windowHours = loadLanesConfig(root).kr_freshness_hours;
+        const ledger = readKrFreshnessLedger(root, lane.lane_id);
+        return { enabled: true, kpis: viewsFromLedger(ledger, options.now ?? Date.now(), windowHours) };
+    }
+    catch (error) {
+        onError(error);
+        return null;
+    }
+}
+/** Operator report path: the ledger remains readable while runtime enforcement is off. */
+export function readKrFreshnessReport(root, laneId, now) {
+    const ledger = readKrFreshnessLedger(root, laneId);
+    const windowHours = loadLanesConfig(root).kr_freshness_hours;
+    return {
+        ledger_path: krFreshnessLedgerPath(root, laneId),
+        available: ledger !== null,
+        kr_freshness_hours: windowHours,
+        kpis: viewsFromLedger(ledger, now, windowHours),
+    };
+}
+//# sourceMappingURL=kr-freshness.js.map

package/dist/lib/lanes/lane-company.d.ts

@@ -0,0 +1,9 @@
+import type { LaneCompanyRef, LaneRecord } from "./types.js";
+export type LaneCompanySource = "lane" | "project" | "unresolved";
+export interface LaneCompanyResolution {
+    company: LaneCompanyRef | null;
+    source: LaneCompanySource;
+}
+/** Resolve a lane's company without inferring ownership from its worker or caller. */
+export declare function resolveLaneCompany(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "project_id">): LaneCompanyResolution;
+//# sourceMappingURL=lane-company.d.ts.map

package/dist/lib/lanes/lane-company.js

@@ -0,0 +1,24 @@
+import { resolveProjectQuestionCompany } from "./questions.js";
+import { LanesError } from "./errors.js";
+/** Resolve a lane's company without inferring ownership from its worker or caller. */
+export function resolveLaneCompany(hqRoot, lane) {
+    const slug = typeof lane.company?.slug === "string" ? lane.company.slug.trim() : "";
+    const uid = typeof lane.company?.uid === "string" ? lane.company.uid.trim() : "";
+    if (slug && uid) {
+        return { company: { slug, uid }, source: "lane" };
+    }
+    let projectCompany;
+    try {
+        projectCompany = resolveProjectQuestionCompany(hqRoot, lane);
+    }
+    catch (err) {
+        if (err instanceof LanesError && err.error === "question_company_unavailable") {
+            return { company: null, source: "unresolved" };
+        }
+        throw err;
+    }
+    return projectCompany
+        ? { company: projectCompany, source: "project" }
+        : { company: null, source: "unresolved" };
+}
+//# sourceMappingURL=lane-company.js.map

package/dist/lib/lanes/reconcile.js

@@ -22,6 +22,7 @@ import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecor
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
@@ -851,8 +852,11 @@ export async function runPassBody(hqRoot, deps) {
             if (doneKeepAliveVerdict(lane, envelope, hasQueuedWork) !== "eligible")
                 continue;
         }
-        const key = keepAliveCompanyKey(lane.company);
-        keepAliveFlagCompanies.set(key, lane.company);
+        const company = resolveLaneCompany(hqRoot, lane).company;
+        if (company === null)
+            continue;
+        const key = keepAliveCompanyKey(company);
+        keepAliveFlagCompanies.set(key, company);
     }
     const keepAliveFlagByCompany = new Map();
     const supersessionLineageAwareByCompany = new Map();
@@ -1598,6 +1602,15 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
+    const resolvedCompanyByLaneVersion = new Map();
+    const companyForLane = (candidate) => {
+        const key = `${candidate.lane_id}\u0000${candidate.version}`;
+        if (resolvedCompanyByLaneVersion.has(key))
+            return resolvedCompanyByLaneVersion.get(key) ?? null;
+        const company = resolveLaneCompany(hqRoot, candidate).company;
+        resolvedCompanyByLaneVersion.set(key, company);
+        return company;
+    };
     const keepAliveEnabled = [...flagByCompany.values()].some((enabled) => enabled);
     let retiredLaneIds = null;
     if (keepAliveEnabled) {
@@ -1615,7 +1628,7 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             originalLane.state === "cancelled" ||
             originalLane.state === "failed") {
             if (originalLane.keep_alive === true &&
-                flagByCompany.get(keepAliveCompanyKey(originalLane.company)) === true)
+                flagByCompany.get(keepAliveCompanyKey(companyForLane(originalLane))) === true)
                 recordKeepAliveSkip(hqRoot, originalLane, "terminal_state", summary, deps);
             continue;
         }
@@ -1641,8 +1654,28 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
                 continue;
             }
         }
-        if (flagByCompany.get(keepAliveCompanyKey(lane.company)) !== true)
+        const company = companyForLane(lane);
+        if (company === null) {
+            if (lane.keep_alive === true) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: "keep_alive_company_unresolved",
+                });
+            }
             continue;
+        }
+        const companyKey = keepAliveCompanyKey(company);
+        if (flagByCompany.get(companyKey) !== true) {
+            if (lane.keep_alive === true) {
+                summary.skipped.push({
+                    kind: "lane",
+                    id: lane.lane_id,
+                    why: "keep_alive_flag_off",
+                });
+            }
+            continue;
+        }
         // Persist a stable timestamp for legacy interrupted rows before a later
         // keep-alive status write can advance their general updated_at clock. The
         // watcher classification is the interruption time; updated_at is only an
@@ -1760,7 +1793,7 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             recordKeepAliveSkip(hqRoot, lane, "retired_list_invalid", summary, deps);
             continue;
         }
-        const exclusion = keepAliveExclusion(lane, lanes, retiredLaneIds, supersessionLineageAwareByCompany.get(keepAliveCompanyKey(lane.company)) === true);
+        const exclusion = keepAliveExclusion(lane, lanes, retiredLaneIds, supersessionLineageAwareByCompany.get(companyKey) === true, companyForLane);
         if (exclusion !== undefined) {
             recordKeepAliveSkip(hqRoot, lane, exclusion, summary, deps);
             continue;
@@ -1851,7 +1884,25 @@ function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCom
             continue;
         }
         const currentLanes = loadLaneRecords(hqRoot, summary);
-        const currentExclusion = keepAliveExclusion(current, currentLanes, retiredLaneIds, supersessionLineageAwareByCompany.get(keepAliveCompanyKey(current.company)) === true);
+        const currentCompany = companyForLane(current);
+        if (currentCompany === null) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: "keep_alive_company_unresolved",
+            });
+            continue;
+        }
+        const currentCompanyKey = keepAliveCompanyKey(currentCompany);
+        if (flagByCompany.get(currentCompanyKey) !== true) {
+            summary.skipped.push({
+                kind: "lane",
+                id: current.lane_id,
+                why: "keep_alive_flag_off",
+            });
+            continue;
+        }
+        const currentExclusion = keepAliveExclusion(current, currentLanes, retiredLaneIds, supersessionLineageAwareByCompany.get(currentCompanyKey) === true, companyForLane);
         if (currentExclusion !== undefined) {
             recordKeepAliveSkip(hqRoot, current, currentExclusion, summary, deps);
             continue;

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

@@ -370,7 +370,22 @@ export interface BlockerFreshnessHistoryEntry {
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
     delivery_failed?: true;
 }
-export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry;
+export interface KrFreshnessState {
+    /** Stable fingerprint of the last stalled KPI set, which is resumed once. */
+    stalled_fingerprint?: string;
+}
+export interface KrFreshnessHistoryEntry {
+    event: "kr_stalled";
+    turn_id: string;
+    path: string;
+    at: string;
+    names: string[];
+    count: number;
+    fingerprint: string;
+    resume_queued?: boolean;
+    resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
+}
+export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry;
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -516,6 +531,8 @@ export interface LaneRecord {
     status_gate_history?: LaneGateHistoryEntry[];
     /** Last blocker-freshness state used to detect consecutive stale turns. */
     blocker_freshness_state?: BlockerFreshnessState;
+    /** Last stalled KR set already offered one automatic resume. */
+    kr_freshness_state?: KrFreshnessState;
     /** Last automatic compaction of a resumed session (compaction.ts). */
     last_compaction?: LaneCompactionRecord;
     /**
@@ -857,6 +874,8 @@ export interface LanesConfig {
     session_question_timeout_secs: number;
     /** Age in hours after which an open manager blocker must be re-verified. */
     blocker_freshness_hours: number;
+    /** Age in hours after which a manager KPI is considered stalled. */
+    kr_freshness_hours: number;
 }
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;

package/dist/lib/lanes/types.js

@@ -228,7 +228,7 @@ export const LANE_FIELD_WRITERS = {
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
-    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], blocker_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command"], interrupted_at: ["watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],

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

@@ -233,6 +233,8 @@ export interface WatcherLoopDeps {
     readManagerStatusGateFlag?: typeof readLanesRegistryFlag;
     /** Test seam; production reads the company-scoped hq-flags row. */
     readBlockerFreshnessFlag?: typeof readLanesRegistryFlag;
+    /** Test seam; production reads the company-scoped hq-flags row. */
+    readKrFreshnessFlag?: typeof readLanesRegistryFlag;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -49,6 +49,7 @@ import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLane
 import { envelopeQuestionId } from "./questions.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "./blocker-freshness.js";
+import { krFreshnessFingerprint, resolveKrFreshnessForLane, } from "./kr-freshness.js";
 import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
 import { queueLaneTerminalResume, queueManagerStatusGateResume } from "./keep-alive.js";
 import { monitorSessionDir } from "../monitor.js";
@@ -863,6 +864,72 @@ async function settleBlockerFreshness(hqRoot, lane, manifestTurnId, at, deps, me
     }
     return updated;
 }
+async function settleKrFreshness(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
+    if (manifestTurnId !== undefined && lane.status_gate !== undefined && lane.status_gate.turn_id !== manifestTurnId) {
+        logDecision({ event: "kr_freshness_baseline_mismatch", at, turn_id: lane.status_gate.turn_id });
+        return lane;
+    }
+    let errorLogged = false;
+    const resolution = await resolveKrFreshnessForLane(hqRoot, lane, {
+        readFlag: deps.readKrFreshnessFlag ?? readLanesRegistryFlag,
+        now: Date.parse(at),
+        onError: (error) => {
+            if (errorLogged)
+                return;
+            errorLogged = true;
+            const code = error instanceof LanesError ? error.error : "kr_freshness_unavailable";
+            process.stderr.write(`hq lanes watcher: KR freshness disabled for ${lane.lane_id}: ${code}\n`);
+            logDecision({ event: "kr_freshness_disabled", at, error: code });
+        },
+    });
+    if (!resolution.enabled || resolution.statusPath === undefined || resolution.error !== undefined)
+        return lane;
+    const stalled = resolution.kpis.filter((kpi) => kpi.verdict === "stalled");
+    if (stalled.length === 0) {
+        if (lane.kr_freshness_state === undefined)
+            return lane;
+        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => current.kr_freshness_state === undefined
+            ? current
+            : { ...current, kr_freshness_state: undefined });
+    }
+    const fingerprint = krFreshnessFingerprint(resolution.stalledKeys);
+    const names = stalled.map((kpi) => kpi.name);
+    const turnId = manifestTurnId ?? lane.status_gate?.turn_id ?? `unknown-${at}`;
+    const resumeText = `These KPIs in ${resolution.statusPath} were not re-measured in the last ${resolution.windowHours}h: ${names.join(", ")}. Measure each one now, update value and measured_at, then end the turn.`;
+    return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+        const history = current.status_gate_history ?? [];
+        if (history.some((entry) => entry.event === "kr_stalled" && entry.turn_id === turnId))
+            return current;
+        const sameStalledSet = current.kr_freshness_state?.stalled_fingerprint === fingerprint;
+        let nextLane = current;
+        let resumeQueued = false;
+        let resumeSkippedReason;
+        if (!sameStalledSet) {
+            const mergeExisting = current.pending_resume !== undefined &&
+                current.state !== "blocked" && current.state !== "awaiting_input";
+            const resume = queueLaneTerminalResume(current, at, resumeText, { mergeExisting });
+            nextLane = resume.lane;
+            resumeQueued = resume.resumeQueued;
+            resumeSkippedReason = resume.resumeSkippedReason;
+        }
+        const entry = {
+            event: "kr_stalled",
+            turn_id: turnId,
+            path: resolution.statusPath,
+            at,
+            names,
+            count: stalled.length,
+            fingerprint,
+            ...(resumeQueued ? { resume_queued: true } : {}),
+            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
+        };
+        return {
+            ...nextLane,
+            kr_freshness_state: { stalled_fingerprint: fingerprint },
+            status_gate_history: appendCappedHistory(history, entry),
+        };
+    });
+}
 function resolveBlockerFreshnessSessionInbox(hqRoot, sessionId) {
     let candidates;
     try {
@@ -1452,11 +1519,13 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                 if (terminalWrite.changed) {
                     updated = await settleManagerStatusGate(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
                     updated = await settleBlockerFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, mesh, logDecision);
+                    updated = await settleKrFreshness(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
                 }
                 const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
                     updated.status_gate_history?.some((entry) => entry.turn_id === manifest.turn_id &&
                         ((entry.event === "status_missed" && entry.resume_queued === true) ||
-                            (entry.event === "blocker_stale" && entry.resume_queued === true))) === true;
+                            (entry.event === "blocker_stale" && entry.resume_queued === true) ||
+                            (entry.event === "kr_stalled" && entry.resume_queued === true))) === true;
                 if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued) {
                     try {
                         if (dropboxInboxHasMessages(hqRoot, laneId)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.264.0",
+  "version": "5.265.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {