@indigoai-us/hq-cli 5.268.0 → 5.270.0

package/dist/commands/lanes.js

@@ -23,6 +23,7 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
+import { registerLaneReviewCommand } from "./lanes-review.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -47,6 +48,7 @@ import { CompanySelectionError } from "../utils/company-selection-error.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
+import { listLaneReviews } from "../lib/lanes/reviews.js";
 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";
@@ -291,6 +293,7 @@ function resolveDeps(deps = {}) {
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
+        mergeReviewEnabled: deps.mergeReviewEnabled,
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
     };
 }
@@ -4541,10 +4544,26 @@ async function runShow(ctx, laneId) {
         env: ctx.env,
         now: ctx.now().getTime(),
     });
+    const laneIsSenior = allLanes.some((item) => item.senior.kind === "lane" && item.senior.id === laneId);
+    const now = ctx.now().getTime();
+    const reviewListing = laneIsSenior
+        ? listLaneReviews(hqRoot, laneId)
+        : { reviews: [], skipped: 0 };
+    if (reviewListing.skipped > 0) {
+        console.error(`hq lanes show: skipped ${reviewListing.skipped} invalid or unreadable review item(s)`);
+    }
+    const recentReviews = reviewListing.reviews
+        .filter((item) => {
+        const recordedAt = Date.parse(item.recorded_at);
+        return recordedAt >= now - 24 * 60 * 60 * 1000 && recordedAt <= now;
+    })
+        .slice(0, 20)
+        .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
     printJson({
         ok: true,
         action: "show",
         lane,
+        ...(laneIsSenior ? { reviews: recentReviews, reviews_skipped: reviewListing.skipped } : {}),
         ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
         stalled: Boolean(lane.stalled),
@@ -4741,7 +4760,7 @@ async function runKeepAlive(ctx, laneId, opts) {
         const initialLane = readLane(hqRoot, laneId);
         assertKeepAliveChangeAllowed(ctx, initialLane, laneId);
         lineageAware = await readLanesRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, {
-            company: initialLane.company,
+            company: resolveLaneCompany(hqRoot, initialLane).company ?? undefined,
             env: ctx.env,
         });
     }
@@ -6927,6 +6946,12 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         now: ctx.now,
         env: ctx.env,
+        mergeReviewEnabled: ctx.mergeReviewEnabled,
+    }, wrap);
+    registerLaneReviewCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        env: ctx.env,
+        now: ctx.now,
     }, wrap);
     registerOutpostPrunerCommand(lanes);
     registerLaneKpisCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });
@@ -6977,7 +7002,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("grant-target", { hidden: true })
         .argument("<lane-id>", "Lane id")
         .option("--hire <n>", "Non-negative safe integer hire grant")
-        .option("--grant-context <base64url>", "Primary-authorized hire hierarchy and gate decision")
+        .option("--grant-context <base64url>", "Primary-authorized hire hierarchy context")
         .action(wrap(async (laneId, opts) => {
         await runGrantOwnerTarget(ctx, laneId, opts);
     }));
@@ -7002,9 +7027,9 @@ export function registerLanesCommand(parent, deps = {}) {
     }));
     lanes
         .command("backfill-grants")
-        .description("Preview or apply missing hire grants for alive manager lanes")
+        .description("Preview missing hire grants for alive manager lanes; writes are disabled")
         .option("--dry-run", "Print proposed values without writing (default)")
-        .option("--apply", "Write missing hire grants; only run before enforcement is enabled")
+        .option("--apply", "Retained for compatibility; writes are disabled")
         .action(wrap(async (opts) => {
         await runBackfillGrants(ctx, opts);
     }));

package/dist/lib/billing/plan-limit-upgrade-url.d.ts

@@ -1,14 +1,11 @@
-export declare const PLAN_LIMIT_UPGRADE_FALLBACK_FLAG = "cli.plan-limit-upgrade-fallback";
-export declare const PLAN_LIMIT_UPGRADE_FALLBACK_DEFAULT = false;
 export interface PlanLimitUpgradeUrlChoices {
     topLevelUrl?: string | null;
     nestedUrl?: string | null;
     legacyUrl: string;
 }
-export declare function isPlanLimitUpgradeFallbackEnabled(): boolean;
 /** Resolve and attribute the final selected company billing destination. */
 export declare function selectPlanLimitUpgradeUrl(companySlug: string | undefined, choices: PlanLimitUpgradeUrlChoices): string;
 export declare function withCliLimitEntrySurface(value: string): string;
-/** Keep the existing destination and flag behavior while labeling company limit links. */
+/** Select the standard upgrade destination and label company limit links. */
 export declare function planLimitUpgradeFallbackUrl(companySlug: string | undefined, previousFallbackUrl: string): string;
 //# sourceMappingURL=plan-limit-upgrade-url.d.ts.map

package/dist/lib/billing/plan-limit-upgrade-url.js

@@ -1,11 +1,5 @@
-import { resolveProcessFlagGate } from "../flag-registry.js";
 import { DEFAULT_VAULT_API_URL } from "../../utils/cognito-session.js";
 import { consoleOrigin } from "../../utils/console-origin.js";
-export const PLAN_LIMIT_UPGRADE_FALLBACK_FLAG = "cli.plan-limit-upgrade-fallback";
-export const PLAN_LIMIT_UPGRADE_FALLBACK_DEFAULT = false;
-export function isPlanLimitUpgradeFallbackEnabled() {
-    return resolveProcessFlagGate(PLAN_LIMIT_UPGRADE_FALLBACK_FLAG, { fallback: PLAN_LIMIT_UPGRADE_FALLBACK_DEFAULT }, () => PLAN_LIMIT_UPGRADE_FALLBACK_DEFAULT);
-}
 function companyBillingUrl(companySlug) {
     const controlPlaneUrl = process.env.HQ_VAULT_API_URL?.trim() || DEFAULT_VAULT_API_URL;
     const origin = consoleOrigin(controlPlaneUrl);
@@ -19,20 +13,15 @@ function companyBillingUrl(companySlug) {
 }
 /** Resolve and attribute the final selected company billing destination. */
 export function selectPlanLimitUpgradeUrl(companySlug, choices) {
+    const topLevelUrl = choices.topLevelUrl?.trim() || undefined;
+    const nestedUrl = choices.nestedUrl?.trim() || undefined;
+    const generatedUrl = companyBillingUrl(companySlug);
     let selected;
-    if (!isPlanLimitUpgradeFallbackEnabled()) {
-        selected = choices.legacyUrl;
+    if (companySlug?.trim()) {
+        selected = generatedUrl ?? topLevelUrl ?? nestedUrl ?? choices.legacyUrl;
     }
     else {
-        const topLevelUrl = choices.topLevelUrl?.trim() || undefined;
-        const nestedUrl = choices.nestedUrl?.trim() || undefined;
-        const generatedUrl = companyBillingUrl(companySlug);
-        if (companySlug?.trim()) {
-            selected = generatedUrl ?? topLevelUrl ?? nestedUrl ?? choices.legacyUrl;
-        }
-        else {
-            selected = topLevelUrl ?? nestedUrl ?? generatedUrl ?? choices.legacyUrl;
-        }
+        selected = topLevelUrl ?? nestedUrl ?? generatedUrl ?? choices.legacyUrl;
     }
     return withCliLimitEntrySurface(selected);
 }
@@ -68,7 +57,7 @@ export function withCliLimitEntrySurface(value) {
     }
     return value;
 }
-/** Keep the existing destination and flag behavior while labeling company limit links. */
+/** Select the standard upgrade destination and label company limit links. */
 export function planLimitUpgradeFallbackUrl(companySlug, previousFallbackUrl) {
     return selectPlanLimitUpgradeUrl(companySlug, {
         legacyUrl: previousFallbackUrl,

package/dist/lib/doctor/checks/sync-runtime.d.ts

@@ -7,5 +7,5 @@ export interface SyncRuntimeOptions {
 /** Classify the last hour of sync log lines into privacy-safe results. */
 export declare function analyzeSyncRuntimeLog(lines: readonly string[], options: SyncRuntimeOptions): CheckResult[];
 /** Read the machine's sync logs and client health file. */
-export declare function defaultSyncRuntimeResults(now: Date, hqHome?: string): CheckResult[];
+export declare function defaultSyncRuntimeResults(now: Date, hqHome?: string, env?: NodeJS.ProcessEnv): CheckResult[];
 //# sourceMappingURL=sync-runtime.d.ts.map

package/dist/lib/doctor/checks/sync-runtime.js

@@ -9,6 +9,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { currentSyncLogFamily, SYNC_LOG_GENERATIONS, syncLogBasePaths, syncLogGenerationPath, } from "../../../utils/sync-log-sources.js";
 export const SYNC_RUNTIME_WINDOW_MS = 60 * 60_000;
 const LAG_SECONDS = 15 * 60;
 const LAG_MIN_RECEIPTS = 3;
@@ -32,6 +33,32 @@ function parseRecord(rest) {
         return null;
     }
 }
+function timestampFromRecord(record) {
+    if (!record)
+        return null;
+    for (const key of ["time", "timestamp", "ts"]) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            const millis = value < 100_000_000_000 ? value * 1000 : value;
+            if (Number.isFinite(millis))
+                return millis;
+        }
+        if (typeof value === "string") {
+            const parsed = Date.parse(value);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return null;
+}
+function lineTimestamp(line) {
+    const stamp = TIMESTAMP.exec(line);
+    if (stamp) {
+        const parsed = Date.parse(stamp[1]);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return timestampFromRecord(parseRecord(line));
+}
 /** Classify the last hour of sync log lines into privacy-safe results. */
 export function analyzeSyncRuntimeLog(lines, options) {
     const since = options.now - SYNC_RUNTIME_WINDOW_MS;
@@ -40,13 +67,13 @@ export function analyzeSyncRuntimeLog(lines, options) {
     let starts = 0;
     let deviceLimited = 0;
     for (const line of lines) {
-        const stamp = TIMESTAMP.exec(line);
-        if (!stamp)
+        const time = lineTimestamp(line);
+        if (time === null)
             continue;
-        const time = Date.parse(stamp[1]);
         if (!Number.isFinite(time) || time < since || time > options.now)
             continue;
-        const rest = line.slice(stamp[0].length);
+        const stamp = TIMESTAMP.exec(line);
+        const rest = stamp ? line.slice(stamp[0].length) : line;
         if (DEVICE_LIMIT.test(rest))
             deviceLimited += 1;
         const record = parseRecord(rest);
@@ -61,7 +88,8 @@ export function analyzeSyncRuntimeLog(lines, options) {
         else if (event === "receiver.start") {
             starts += 1;
         }
-        if ((record.type === "receiver" || record.type === "error") &&
+        if ((record.type === "receiver" || record.type === "error" ||
+            (typeof event === "string" && event.startsWith("receiver."))) &&
             PERMISSION.test(JSON.stringify(record.err ?? record.message ?? ""))) {
             denied += 1;
         }
@@ -80,7 +108,7 @@ export function analyzeSyncRuntimeLog(lines, options) {
             checkId: `sync.runtime.${check.id}`,
             reasonCode: check.reasonCode,
             message: `${check.count} ${check.label} in the last hour.`,
-            remediation: "Run `hq sync status` and check ~/.hq/logs/hq-sync.log.",
+            remediation: "Run `hq sync status` and inspect the selected sync log under ~/.hq/logs/, ~/.hq/daemon/logs/, or the configured HQ_DAEMON_DIR/logs/.",
         }
         : {
             status: "PASS",
@@ -88,7 +116,6 @@ export function analyzeSyncRuntimeLog(lines, options) {
             message: `${check.count} ${check.label} in the last hour.`,
         });
 }
-const LOG_GENERATIONS = 4;
 function readLogTail(file) {
     const fd = fs.openSync(file, "r");
     try {
@@ -104,9 +131,9 @@ function readLogTail(file) {
 }
 function firstTimestamp(lines) {
     for (const line of lines) {
-        const stamp = TIMESTAMP.exec(line);
-        if (stamp)
-            return Date.parse(stamp[1]);
+        const timestamp = lineTimestamp(line);
+        if (timestamp !== null)
+            return timestamp;
     }
     return null;
 }
@@ -114,15 +141,21 @@ function firstTimestamp(lines) {
  * Lines from the active log and as many rotated generations as needed to
  * cover the window. Throws when a present log cannot be read.
  */
-function readWindowLines(logFile, since) {
+function readWindowLines(logFile, since, daemonLog) {
     const generations = [];
-    for (let n = 0; n < LOG_GENERATIONS; n += 1) {
-        const file = n === 0 ? logFile : `${logFile}.${n}`;
+    for (let n = 0; n < SYNC_LOG_GENERATIONS; n += 1) {
+        const file = syncLogGenerationPath(logFile, n);
         if (!fs.existsSync(file))
-            break;
+            continue;
         const lines = readLogTail(file);
-        generations.unshift(lines);
-        const first = firstTimestamp(lines);
+        const fallbackTime = daemonLog ? fs.statSync(file).mtimeMs : null;
+        const timestampedLines = fallbackTime === null
+            ? lines
+            : lines.map((line) => lineTimestamp(line) === null
+                ? `${new Date(fallbackTime).toISOString()} ${line}`
+                : line);
+        generations.unshift(timestampedLines);
+        const first = firstTimestamp(timestampedLines);
         if (first !== null && first <= since)
             break;
     }
@@ -139,15 +172,32 @@ function readConflictCount(file) {
     }
 }
 /** Read the machine's sync logs and client health file. */
-export function defaultSyncRuntimeResults(now, hqHome = path.join(os.homedir(), ".hq")) {
+export function defaultSyncRuntimeResults(now, hqHome = path.join(os.homedir(), ".hq"), env = process.env) {
     const options = {
         now: now.getTime(),
         conflictCount: readConflictCount(path.join(hqHome, "client-health.json")),
     };
-    const logFile = path.join(hqHome, "logs", "hq-sync.log");
+    const paths = syncLogBasePaths(hqHome, env);
+    const familyModifiedMs = (family) => {
+        let newest = null;
+        for (let generation = 0; generation < SYNC_LOG_GENERATIONS; generation += 1) {
+            try {
+                const stat = fs.lstatSync(syncLogGenerationPath(paths[family], generation));
+                if (!stat.isFile() && !stat.isDirectory())
+                    continue;
+                newest = newest === null ? stat.mtimeMs : Math.max(newest, stat.mtimeMs);
+            }
+            catch {
+                // Missing or inaccessible generations do not make a source family newer.
+            }
+        }
+        return newest;
+    };
+    const family = currentSyncLogFamily(familyModifiedMs("desktop"), familyModifiedMs("daemon"));
+    const logFile = family === null ? paths.desktop : paths[family];
     let lines;
     try {
-        lines = readWindowLines(logFile, options.now - SYNC_RUNTIME_WINDOW_MS);
+        lines = readWindowLines(logFile, options.now - SYNC_RUNTIME_WINDOW_MS, family === "daemon");
     }
     catch {
         return [

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

@@ -4,6 +4,7 @@ import { LanesError } from "./errors.js";
 import { DEFAULT_BLOCKER_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
 import { resolveManagerStatusTarget } from "./manager-status-gate.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { resolveLaneCompany } from "./lane-company.js";
 import { assertNoSecretText } from "./text-scan.js";
 export const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
 export const BLOCKER_FRESHNESS_DEFAULT_HOURS = DEFAULT_BLOCKER_FRESHNESS_HOURS;
@@ -100,7 +101,7 @@ export async function resolveBlockerFreshnessForLane(root, lane, options = {}) {
     let flagEnabled;
     try {
         flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(BLOCKER_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }

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

@@ -206,20 +206,23 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
     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) {
-        let parentLaneId = lane.senior.kind === "lane" ? lane.senior.id : undefined;
-        while (parentLaneId) {
-            if (targetAncestorIds.has(parentLaneId))
-                break;
-            targetAncestorIds.add(parentLaneId);
-            const parent = lanesById.get(parentLaneId);
-            parentLaneId = parent?.senior.kind === "lane" ? parent.senior.id : undefined;
+    lanesById.set(lane.lane_id, lane);
+    const sessionOwners = new Map();
+    for (const owner of lanesById.values()) {
+        for (const sessionId of recordedLaneSessionIds(owner)) {
+            const owners = sessionOwners.get(sessionId) ?? new Set();
+            owners.add(owner.lane_id);
+            sessionOwners.set(sessionId, owners);
         }
     }
+    const targetAncestorIds = lineageAware
+        ? laneAncestorsFrom(lane.senior, lanesById, sessionOwners)
+        : new Set();
     return lanes.find((candidate) => {
         if (candidate.lane_id === lane.lane_id || Date.parse(candidate.created_at) <= createdAt)
             return false;
+        if (candidate.state === "cancelled" || candidate.state === "killed" || candidate.state === "failed")
+            return false;
         const candidateCompany = companyOf(candidate);
         const sameCompany = laneCompany === null
             ? candidateCompany === null
@@ -229,17 +232,8 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
         if (lineageAware && targetAncestorIds.has(candidate.lane_id))
             return false;
         // Any descendant is part of this lead's work tree, not a replacement lead.
-        let parentLaneId = candidate.senior.kind === "lane" ? candidate.senior.id : undefined;
-        const visitedLaneIds = new Set();
-        while (parentLaneId) {
-            if (parentLaneId === lane.lane_id)
-                return false;
-            if (visitedLaneIds.has(parentLaneId))
-                break;
-            visitedLaneIds.add(parentLaneId);
-            const parent = lanesById.get(parentLaneId);
-            parentLaneId = parent?.senior.kind === "lane" ? parent.senior.id : undefined;
-        }
+        if (laneAncestorsFrom(candidate.senior, lanesById, sessionOwners).has(lane.lane_id))
+            return false;
         const sameLaneSenior = lane.senior.kind === "lane" &&
             candidate.senior.kind === "lane" &&
             candidate.senior.id === lane.senior.id;
@@ -252,6 +246,41 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
         return sameProfile || projectLead;
     });
 }
+/** Session ids durable lane records still identify as spawn/resume sessions. */
+function recordedLaneSessionIds(lane) {
+    return [lane.provider_session_id, lane.last_resume?.session_id].filter((sessionId) => typeof sessionId === "string" && sessionId.trim().length > 0);
+}
+/** Follow both lane seniors and session seniors back to the lane that owns each session. */
+function laneAncestorsFrom(senior, lanesById, sessionOwners) {
+    const laneIds = new Set();
+    const sessionIds = new Set();
+    const pending = [senior];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        if (current.kind === "lane") {
+            const laneId = current.id;
+            if (typeof laneId !== "string" || laneId.trim().length === 0 || laneIds.has(laneId))
+                continue;
+            laneIds.add(laneId);
+            const parent = lanesById.get(laneId);
+            if (parent !== undefined)
+                pending.push(parent.senior);
+            continue;
+        }
+        if (current.kind !== "session")
+            continue;
+        const sessionId = current.id;
+        if (typeof sessionId !== "string" || sessionId.trim().length === 0 || sessionIds.has(sessionId))
+            continue;
+        sessionIds.add(sessionId);
+        for (const ownerLaneId of sessionOwners.get(sessionId) ?? []) {
+            pending.push({ kind: "lane", id: ownerLaneId });
+        }
+    }
+    return laneIds;
+}
 export function keepAliveExclusion(lane, lanes, retiredLaneIds, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED, companyForLane) {
     if (isRetiredLaneId(lane.lane_id, retiredLaneIds))
         return "retired";

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

@@ -5,6 +5,7 @@ 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 { resolveLaneCompany } from "./lane-company.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;
@@ -327,7 +328,7 @@ export async function resolveKrFreshnessForLane(root, lane, options = {}) {
     let flagEnabled;
     try {
         flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }
@@ -378,7 +379,7 @@ export async function resolveKrFreshnessForShow(root, lane, options = {}) {
     let enabled;
     try {
         enabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }

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

@@ -1,9 +1,10 @@
 import type { LaneCompanyRef, LaneRecord } from "./types.js";
-export type LaneCompanySource = "lane" | "project" | "unresolved";
+export type LaneCompanySource = "lane" | "mesh_company" | "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;
+export declare function resolveLaneCompany(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company" | "project_id">): LaneCompanyResolution;
+export declare function laneCompanyUidSource(source: LaneCompanySource): string | undefined;
 //# sourceMappingURL=lane-company.d.ts.map

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

@@ -2,10 +2,15 @@ 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" };
+    const laneCompanySlug = typeof lane.company?.slug === "string" ? lane.company.slug.trim() : "";
+    const laneCompanyUid = typeof lane.company?.uid === "string" ? lane.company.uid.trim() : "";
+    if (laneCompanySlug && laneCompanyUid) {
+        return { company: { slug: laneCompanySlug, uid: laneCompanyUid }, source: "lane" };
+    }
+    const meshCompanySlug = typeof lane.mesh_company?.slug === "string" ? lane.mesh_company.slug.trim() : "";
+    const meshCompanyUid = typeof lane.mesh_company?.uid === "string" ? lane.mesh_company.uid.trim() : "";
+    if (meshCompanySlug && meshCompanyUid) {
+        return { company: { slug: meshCompanySlug, uid: meshCompanyUid }, source: "mesh_company" };
     }
     let projectCompany;
     try {
@@ -21,4 +26,16 @@ export function resolveLaneCompany(hqRoot, lane) {
         ? { company: projectCompany, source: "project" }
         : { company: null, source: "unresolved" };
 }
+export function laneCompanyUidSource(source) {
+    switch (source) {
+        case "lane":
+            return "lane.company.uid";
+        case "mesh_company":
+            return "lane.mesh_company.uid";
+        case "project":
+            return "project.cloud_uid";
+        case "unresolved":
+            return undefined;
+    }
+}
 //# sourceMappingURL=lane-company.js.map

package/dist/lib/lanes/manager-status-gate.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { checkCompanyPath } from "./checked-company-path.js";
 import { LanesError } from "./errors.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 export const MANAGER_STATUS_GATE_FLAG = "lanes.manager-status-gate";
 function isObject(value) {
@@ -84,7 +85,7 @@ export function resolveManagerStatusTarget(root, lane) {
             invalidMapping(`Matched juniors row needs a non-empty ${field}`, registry.filePath, { lane_id: lane.lane_id, field });
         }
     }
-    const company = lane.company?.slug ?? lane.mesh_company?.slug ?? "";
+    const company = resolveLaneCompany(root, lane).company?.slug ?? "";
     const statusPath = checkCompanyPath(root, company, row.status, registry.filePath);
     return {
         manager: true,
@@ -96,11 +97,12 @@ export async function resolveManagerStatusGateForLane(root, lane, options = {})
     const reportError = options.onError ?? ((err) => logManagerStatusGateFailure(lane, err));
     let enabled;
     try {
-        const company = lane.company ?? lane.mesh_company ?? undefined;
+        const resolution = resolveLaneCompany(root, lane);
+        const company = resolution.company ?? undefined;
         enabled = await (options.readFlag ?? readLanesRegistryFlag)(MANAGER_STATUS_GATE_FLAG, {
             company,
             ...(company ? {
-                companyUidSource: lane.company ? "lane.company.uid" : "lane.mesh_company.uid",
+                companyUidSource: laneCompanyUidSource(resolution.source),
             } : {}),
             env: options.env,
         });

package/dist/lib/lanes/merge-command.d.ts

@@ -0,0 +1,14 @@
+export interface MergeCommandTarget {
+    kind: "pr" | "api" | "graphql" | "git";
+    repo: string | null;
+    pr: number | null;
+    pinnedHead: string | null;
+    unresolvedReason: string | null;
+}
+export interface MergeCommandParseResult {
+    targets: MergeCommandTarget[];
+    unresolved: boolean;
+}
+export declare function canonicalRepo(raw: string): string;
+export declare function parseMergeCommands(command: string): MergeCommandParseResult;
+//# sourceMappingURL=merge-command.d.ts.map