@indigoai-us/hq-cli 5.264.0 → 5.266.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [5.266.0] — 2026-09-28
+
+### Added
+
+- `hq daemon run --host desktop` lets the HQ desktop app run the daemon as its
+  own child process. The daemon then runs sync even though the app is open, and
+  records the app as its host in `state.json`. Older per-service installers
+  such as `hq mesh daemon install` treat a hosted daemon as installed and hand
+  their service to it.
+
+## [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";
@@ -8962,6 +8978,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--managed";
             readonly description: "Started by the OS unit, which starts the daemon again whenever it exits";
+        }, {
+            readonly flags: "--host <app>";
+            readonly description: "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon";
         }];
         readonly subcommands: readonly [];
     }, {

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",
@@ -11590,6 +11611,10 @@ export const COMMAND_CATALOG = [
                     {
                         "flags": "--managed",
                         "description": "Started by the OS unit, which starts the daemon again whenever it exits"
+                    },
+                    {
+                        "flags": "--host <app>",
+                        "description": "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon"
                     }
                 ],
                 "subcommands": []

package/dist/commands/daemon.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Command } from "commander";
 import { type LegacyUnit } from "../lib/daemon/legacy.js";
+import type { HostApp } from "../lib/daemon/supervisor.js";
 import type { RunCommand } from "../lib/service-manager/launchd.js";
 export interface DaemonCommandDeps {
     env: NodeJS.ProcessEnv;
@@ -46,6 +47,8 @@ export interface DaemonCommandDeps {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export declare function parseDaemonHost(value: string | undefined): HostApp | undefined;
 export declare function resolveDaemonHqRoot(flag: string | undefined, where: {
     env: NodeJS.ProcessEnv;
     cwd: string;

package/dist/commands/daemon.js

@@ -36,6 +36,14 @@ class DaemonCommandError extends Error {
  * (HQ_ROOT, the tree around the current folder, the folder the installer or
  * menubar recorded, the well-known locations). Undefined when none resolves.
  */
+/** Validate `hq daemon run --host`; the desktop app is the only host. */
+export function parseDaemonHost(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "desktop")
+        return value;
+    throw new Error(`--host must be "desktop" (got "${value}")`);
+}
 export function resolveDaemonHqRoot(flag, where) {
     if (flag)
         return path.resolve(flag);
@@ -574,13 +582,16 @@ export function registerDaemonCommand(program, over = {}) {
         .option("--foreground", "Also print the supervisor log to the terminal")
         .option("--daemon-dir <path>", "Use this folder instead of ~/.hq/daemon (how the Windows task passes HQ_DAEMON_DIR)")
         .option("--managed", "Started by the OS unit, which starts the daemon again whenever it exits")
+        .option("--host <app>", "Run as a child of this app (only \"desktop\"), which has handed sync over to the daemon")
         .action(wrap(async (d, opts) => {
+        const host = parseDaemonHost(opts.host);
         const { runDaemon } = await import("../lib/daemon/run.js");
         // Services inherit this environment, so they see the same folder.
         const env = opts.daemonDir ? { ...d.env, HQ_DAEMON_DIR: opts.daemonDir } : d.env;
         process.exitCode = await runDaemon({
             foreground: opts.foreground,
             managed: opts.managed,
+            host,
             home: d.home,
             env,
             nodeBinary: d.nodeBinary,

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/daemon/handoff.d.ts

@@ -24,6 +24,8 @@ export declare function daemonRunsService(paths: DaemonPaths, service: ServiceNa
 export declare function askDaemonToStart(paths: DaemonPaths, unitId: string): void;
 /** Ask the running daemon to stop a unit and keep it down until it is started again. */
 export declare function askDaemonToStop(paths: DaemonPaths, unitId: string): void;
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export declare function hostedDaemonRunning(paths: DaemonPaths, alive?: (pid: number) => boolean): boolean;
 export interface DaemonUnitHost {
     platform: NodeJS.Platform;
     home: string;

package/dist/lib/daemon/handoff.js

@@ -67,6 +67,15 @@ export function askDaemonToStart(paths, unitId) {
 export function askDaemonToStop(paths, unitId) {
     writeControlRequest(paths.requestsDir, { action: "stop", unit: unitId });
 }
+/** A live daemon runs as the desktop app's child, which counts as installed even though no OS unit exists. */
+export function hostedDaemonRunning(paths, alive = (pid) => isDaemonProcess(pid)) {
+    try {
+        return liveState(paths, alive)?.host === "desktop";
+    }
+    catch {
+        return false;
+    }
+}
 /** The `hq daemon` OS unit is installed on this machine (for this user, or as the box's system unit). */
 export function daemonUnitInstalled(host) {
     switch (host.platform) {
@@ -114,14 +123,14 @@ export function handOffInstall(opts) {
 /** handOffInstall for this machine and user, for the older install commands. */
 export function handOffInstallHere(services, env = process.env, opts = {}) {
     const home = os.homedir();
+    const paths = daemonPaths(home, env);
     const installed = daemonUnitInstalled({
         platform: process.platform,
         home,
         windowsTaskExists: (task) => spawnSync("schtasks.exe", ["/Query", "/TN", task], { encoding: "utf8", windowsHide: true }).status === 0,
-    });
+    }) || hostedDaemonRunning(paths);
     if (!installed)
         return null;
-    const paths = daemonPaths(home, env);
     const config = readDaemonConfig(paths.configPath);
     const machineType = detectMachineType(undefined, {
         platform: process.platform,

package/dist/lib/daemon/run.d.ts

@@ -7,6 +7,8 @@
  */
 import { type UnitPlan } from "./catalog.js";
 import { type LegacyUnit } from "./legacy.js";
+import { type MachineType } from "./machine-type.js";
+import { type HostApp } from "./supervisor.js";
 export declare const LOG_ROTATE_BYTES: number;
 /** Exit code for "restart me": non-zero so every service manager relaunches (Windows tasks only restart on failure). */
 export declare const RESTART_EXIT_CODE = 75;
@@ -14,6 +16,8 @@ export interface RunDaemonOptions {
     foreground?: boolean;
     /** Started by the OS unit, which relaunches the daemon whenever it exits. */
     managed?: boolean;
+    /** The app that runs this daemon as its child (it relaunches the daemon on RESTART_EXIT_CODE when also managed). */
+    host?: HostApp;
     home?: string;
     env?: NodeJS.ProcessEnv;
     nodeBinary: string;
@@ -35,6 +39,21 @@ export declare function findUserBinary(name: string, env: NodeJS.ProcessEnv, hom
 export declare function cliSelfUpdatable(): boolean;
 /** The HQ desktop app process is running here (it runs its own sync). */
 export declare function desktopAppRunning(platform: NodeJS.Platform): boolean;
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export declare function restartsForParent(opts: {
+    managed?: boolean;
+    host?: HostApp;
+}): boolean;
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export declare function desktopAppManagesSync(opts: {
+    machineType: MachineType;
+    host?: HostApp;
+    legacy: readonly LegacyUnit[];
+    appRunning: () => boolean;
+}): boolean;
 /** Copy-and-truncate, so children appending with O_APPEND keep writing to the live file. */
 export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
 /**

package/dist/lib/daemon/run.js

@@ -133,6 +133,19 @@ export function desktopAppRunning(platform) {
     const r = spawnSync("pgrep", ["-x", "hq-sync-menubar"], { encoding: "utf8" });
     return r.status === 0;
 }
+/** A parent (the OS unit, or the app hosting the daemon) starts the daemon again after it exits with RESTART_EXIT_CODE. */
+export function restartsForParent(opts) {
+    return opts.managed === true || opts.host !== undefined;
+}
+/**
+ * The desktop app runs sync itself, so the daemon's sync unit waits. When the
+ * app hosts the daemon it has handed sync over, and the daemon runs it.
+ */
+export function desktopAppManagesSync(opts) {
+    if (opts.machineType !== "desktop" || opts.host === "desktop")
+        return false;
+    return opts.legacy.some((u) => u.service === "sync" && !u.migratable) || opts.appRunning();
+}
 function jobsReconcileScript(hqRoot) {
     if (!hqRoot)
         return null;
@@ -231,7 +244,8 @@ export async function runDaemon(opts) {
         releaseDaemonLock(paths.lockPath);
         return 1;
     }
-    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})`);
+    const hostNote = opts.host ? `, hosted by the ${opts.host} app` : "";
+    log("info", `starting hq daemon (pid ${process.pid}) as ${machineType} (${detected.detail})${hostNote}`);
     if (!resolveSyncRunnerPath())
         log("warn", "the hq-cloud sync runner was not found in this CLI install; sync is unavailable");
     const updatable = cliSelfUpdatable();
@@ -270,8 +284,12 @@ export async function runDaemon(opts) {
             legacySyncEnv: readLegacySyncEnv(platform),
             signedIn: signedIn(env, home, log),
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
-            desktopAppManagesSync: machineType === "desktop" &&
-                (legacy.some((u) => u.service === "sync" && !u.migratable) || desktopAppRunning(platform)),
+            desktopAppManagesSync: desktopAppManagesSync({
+                machineType,
+                host: opts.host,
+                legacy,
+                appRunning: () => desktopAppRunning(platform),
+            }),
             bots: listLocalBots(),
             legacyOwner: legacyOwnerLookup(legacy),
             cliSelfUpdatable: updatable,
@@ -312,6 +330,7 @@ export async function runDaemon(opts) {
     let restartDaemon = () => { };
     const supervisor = createSupervisor({
         machineType,
+        host: opts.host,
         pid: process.pid,
         plan,
         spawn: spawnUnit,
@@ -352,7 +371,7 @@ export async function runDaemon(opts) {
             });
         };
         restartDaemon = () => {
-            if (!opts.managed) {
+            if (!restartsForParent(opts)) {
                 log("warn", "a restart was requested, but no service manager would start this daemon again; restart it yourself");
                 return;
             }

package/dist/lib/daemon/supervisor.d.ts

@@ -50,16 +50,21 @@ export interface UnitState {
     nextRunAt?: number;
     lastResult?: "ok" | "failed";
 }
+/** An app that runs the daemon as its own child process instead of an OS unit. */
+export type HostApp = "desktop";
 export interface DaemonState {
     version: 1;
     pid: number;
     startedAt: number;
     updatedAt: number;
     machineType: MachineType;
+    /** Set when an app runs the daemon as its child; absent under the OS unit. */
+    host?: HostApp;
     units: UnitState[];
 }
 export interface SupervisorDeps {
     machineType: MachineType;
+    host?: HostApp;
     pid: number;
     plan: () => UnitPlan[];
     spawn: (unit: UnitPlan) => SupervisedChild;

package/dist/lib/daemon/supervisor.js

@@ -52,6 +52,7 @@ export function createSupervisor(deps) {
         startedAt,
         updatedAt: now(),
         machineType: deps.machineType,
+        ...(deps.host ? { host: deps.host } : {}),
         units: [...slots.values()].map((s) => ({ ...s.state })),
     });
     const emit = () => {

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