@indigoai-us/hq-cli 5.263.0 → 5.265.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [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
+
+- The `checkpoint.ontology.entity-hints` flag and its per-input `known_entities`
+  list. It was never turned on outside measurement runs.
+
 ## [5.263.0] — 2026-09-28
 
 ### Fixed

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/checkpoint-ontology/plan.d.ts

@@ -10,7 +10,6 @@
 import { type CompanyBriefResult } from "./company-brief.js";
 import { type OntologyCompany } from "./company.js";
 import { type MultiWriterStart } from "./multi-writer.js";
-import { type EntityHint } from "./hints.js";
 import { type SyncClientVersions } from "./sync-client.js";
 export declare const ONTOLOGY_FLAG = "checkpoint.ontology";
 /**
@@ -41,13 +40,6 @@ export declare const GROK_BACKEND_FLAG = "checkpoint.ontology.grok-backend";
  * duplicate entities.
  */
 export declare const MULTI_WRITER_FLAG = "checkpoint.ontology.multi-writer";
-/**
- * Each knowledge input lists the existing entities its text names
- * (`known_entities`), and the model is told to use those names and to skip
- * table rows, paths and slugs. CO-41: 11 of 93 creates in the CO-39 grok-4.6
- * runs were model errors, 5 of them duplicates of an existing entity.
- */
-export declare const ENTITY_HINTS_FLAG = "checkpoint.ontology.entity-hints";
 /**
  * A candidate that links to an existing entity adds no aliases to it; the plan
  * carries `link_aliases: false` and apply honours it. CO-42: most aliases
@@ -138,8 +130,6 @@ export interface PlanInput {
     missing_refs?: string[];
     /** Run-directory-relative copy of `path` with annotator entity lists removed; same line numbers. */
     read_path?: string;
-    /** Existing entities this input's text names; only when `checkpoint.ontology.entity-hints` is on. */
-    known_entities?: EntityHint[];
 }
 export interface OntologyPlan {
     schema: typeof PLAN_SCHEMA;
@@ -208,7 +198,6 @@ export type PlanOutcome = {
     companyBrief?: CompanyBriefResult;
 };
 export declare const READ_PATH_INSTRUCTION = "When an input has read_path, read that file (relative to the run directory) instead of path, with the same line range. It is the same text with an older annotator's entity lists and entity links removed.";
-export declare const ENTITY_HINTS_INSTRUCTIONS: string[];
 export declare const PERSON_NAME_INSTRUCTION = "Name a person by the full name the input or the company's entities give, not a first name alone.";
 export declare const FIRST_NAME_PEOPLE_INSTRUCTION = "Name a person by the full name the input or the company's entities give. When neither gives more than a first name, name the person by that first name; do not leave them out.";
 export declare function ledgerPath(hqRoot: string, company: OntologyCompany): string;

package/dist/lib/checkpoint-ontology/plan.js

@@ -13,7 +13,6 @@ import * as path from "node:path";
 import { writeCompanyBrief } from "./company-brief.js";
 import { resolveOntologyCompany, safeWriteFile, stateRoot } from "./company.js";
 import { startMultiWriterRun } from "./multi-writer.js";
-import { entityHints, wordWeights } from "./hints.js";
 import { checkSyncClient, readSyncClientVersions } from "./sync-client.js";
 import { buildEntityIndex, listKnowledgeFiles, listSignalFiles, readSignal } from "./tree.js";
 export const ONTOLOGY_FLAG = "checkpoint.ontology";
@@ -45,13 +44,6 @@ export const GROK_BACKEND_FLAG = "checkpoint.ontology.grok-backend";
  * duplicate entities.
  */
 export const MULTI_WRITER_FLAG = "checkpoint.ontology.multi-writer";
-/**
- * Each knowledge input lists the existing entities its text names
- * (`known_entities`), and the model is told to use those names and to skip
- * table rows, paths and slugs. CO-41: 11 of 93 creates in the CO-39 grok-4.6
- * runs were model errors, 5 of them duplicates of an existing entity.
- */
-export const ENTITY_HINTS_FLAG = "checkpoint.ontology.entity-hints";
 /**
  * A candidate that links to an existing entity adds no aliases to it; the plan
  * carries `link_aliases: false` and apply honours it. CO-42: most aliases
@@ -105,10 +97,6 @@ export const BUDGET = {
     chunkTokens: 12_000,
 };
 export const READ_PATH_INSTRUCTION = "When an input has read_path, read that file (relative to the run directory) instead of path, with the same line range. It is the same text with an older annotator's entity lists and entity links removed.";
-export const ENTITY_HINTS_INSTRUCTIONS = [
-    "A knowledge input's known_entities lists entities that already exist in the company and whose names appear in its text. When the input refers to one of them, under that name or another, use that entity's name and type exactly and do not name a new entity for it.",
-    "Skip rows of a glossary or translation table, file and directory paths, and names built from tags or slugs.",
-];
 export const PERSON_NAME_INSTRUCTION = "Name a person by the full name the input or the company's entities give, not a first name alone.";
 export const FIRST_NAME_PEOPLE_INSTRUCTION = "Name a person by the full name the input or the company's entities give. When neither gives more than a first name, name the person by that first name; do not leave them out.";
 const CANDIDATE_INSTRUCTIONS = [
@@ -272,7 +260,6 @@ export async function planOntologyRun(options) {
     const ignoreAnnotations = (await options.readFlag(IGNORE_ANNOTATIONS_FLAG, company)) && payload.backend === "grok";
     recordBackendPreference(hqRoot, company, await options.readFlag(GROK_BACKEND_FLAG, company));
     const multiWriterOn = await options.readFlag(MULTI_WRITER_FLAG, company);
-    const hintsOn = await options.readFlag(ENTITY_HINTS_FLAG, company);
     const noLinkAliases = await options.readFlag(NO_LINK_ALIASES_FLAG, company);
     const firstNamePeople = await options.readFlag(FIRST_NAME_PEOPLE_FLAG, company);
     const skipAmbiguousConceptLinks = await options.readFlag(SKIP_AMBIGUOUS_CONCEPT_LINKS_FLAG, company);
@@ -289,15 +276,6 @@ export async function planOntologyRun(options) {
     const pending = Object.entries(ledger.entries)
         .filter(([, entry]) => entry.state === "pending" && entry.reason === "session-touched")
         .sort(([aRel, a], [bRel, b]) => a.mtime_ms - b.mtime_ms || aRel.localeCompare(bRel));
-    // Built after merge-back, so merged entities are hinted too.
-    let hintIndex = null;
-    const hintsFor = (text) => {
-        if (!hintIndex) {
-            const index = buildEntityIndex(company.dir);
-            hintIndex = { index, weights: wordWeights(index) };
-        }
-        return entityHints(hintIndex.index, hintIndex.weights, text);
-    };
     const inputs = [];
     let tokens = 0;
     let remaining = 0;
@@ -322,10 +300,6 @@ export async function planOntologyRun(options) {
             const cost = estTokens(Buffer.byteLength(lines.slice(start - 1, end).join("\n"), "utf8"));
             if (inputs.length >= BUDGET.maxInputs || tokens + cost > BUDGET.maxTokens)
                 break;
-            // The model reads the stripped copy when there is one; its line numbers match.
-            const knownEntities = hintsOn && kind === "knowledge"
-                ? hintsFor((cleaned ?? text).split("\n").slice(start - 1, end).join("\n"))
-                : null;
             inputs.push({
                 id: chunks.length > 1 ? `${rel}#${index}` : rel,
                 kind,
@@ -338,7 +312,6 @@ export async function planOntologyRun(options) {
                 chunk: chunks.length > 1 ? { index, count: chunks.length } : null,
                 ...(kind === "signal" ? { missing_refs: missingRefs(company.dir, rel) } : {}),
                 ...(readPath !== null ? { read_path: readPath } : {}),
-                ...(knownEntities !== null ? { known_entities: knownEntities } : {}),
             });
             tokens += cost;
         }
@@ -407,7 +380,6 @@ export async function planOntologyRun(options) {
             ...CANDIDATE_INSTRUCTIONS.slice(0, 3),
             ...(inputs.some((input) => input.read_path) ? [READ_PATH_INSTRUCTION] : []),
             `${CANDIDATE_INSTRUCTIONS[3]} ${firstNamePeople ? FIRST_NAME_PEOPLE_INSTRUCTION : PERSON_NAME_INSTRUCTION}`,
-            ...(inputs.some((input) => input.known_entities) ? ENTITY_HINTS_INSTRUCTIONS : []),
             ...CANDIDATE_INSTRUCTIONS.slice(4),
         ],
     };

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