@indigoai-us/hq-cli 5.313.0 → 5.315.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [5.315.0] — 2026-10-02
+- The CLI loads the Sentry error-reporting library only when it first needs it, so commands that report nothing start with fewer imports. Reporting, scrubbing and flushing work as before.
+- Keep first-sync guidance enabled without its rollout gate and remove the obsolete plan-limit fallback flag-off test.
+
+- Gate autopilot nudge deduplication behind a default-off company flag, preserving message IDs and requiring a 30-minute active-condition cooldown for repeat nudges.
+- Let lane autopilot skip malformed lead inputs individually behind a default-off flag and notify the affected lead once.
+- Lead autopilot can batch stale KPI reminders into one oldest-first message per pass when the company enables `lanes.autopilot-kpi-staleness-batch`.
+- Preserve the last policy tag when migrating trigger policies.
+- Add read-only `hq lanes keep-alive-audit` reporting for lead keep-alive timing, early resumes, and missed restarts.
+- Resolve bare lane IDs to their stored lane record before messaging or showing them, preventing messages from being written under unresolved IDs.
+
 ## [5.313.0] — 2026-10-02
 - Gate live-only lane hire-grant counting by company; blocked and awaiting-input children no longer occupy slots when enabled, and their resume is checked against current capacity.
 - Add company-gated lane low-disk admission protection and Codex rollout retention.

package/assets/scaffold/core/scripts/migrate-policy-triggers.sh

@@ -256,13 +256,18 @@ trigger_expr() {
 
 # tag_tokens <raw-tags-line-without-brackets> — normalised, filtered tag tokens
 # (one per line). vendor:x -> x; meta tags dropped; lowercased.
+mpt_process_tag() {
+  local tag="$1"
+  tag="$(printf '%s' "$tag" | tr '[:upper:]' '[:lower:]' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
+  tag="${tag#vendor:}"                       # vendor:linear -> linear
+  [ -n "$tag" ] || return 0
+  case "$TAG_STOP" in *" $tag "*) return 0 ;; esac
+  printf '%s\n' "$tag"
+}
+
 tag_tokens() {
-  printf '%s' "$1" | tr ',' '\n' | while IFS= read -r tag; do
-    tag="$(printf '%s' "$tag" | tr '[:upper:]' '[:lower:]' | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
-    tag="${tag#vendor:}"                       # vendor:linear -> linear
-    [ -n "$tag" ] || continue
-    case "$TAG_STOP" in *" $tag "*) continue ;; esac
-    printf '%s\n' "$tag"
+  printf '%s' "$1" | tr ',' '\n' | while IFS= read -r tag || [ -n "$tag" ]; do
+    mpt_process_tag "$tag"
   done
 }
 
@@ -329,7 +334,7 @@ for dir in "${DIRS[@]}"; do
     if policy_has_when "$f"; then skipped=$((skipped+1)); continue; fi
 
     trig="$(fm trigger "$f")"
-    tags="$(fm tags "$f" | sed 's/^\[//; s/\]$//')"
+    tags="$(fm tags "$f" | sed 's/[[:space:]][[:space:]]*#.*$//; s/^\[//; s/\]$//')"
     enforcement="$(fm enforcement "$f")"
     if ! built="$(build_when "$trig" "$tags" "$enforcement")"; then
       untriggered=$((untriggered+1))

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

@@ -8038,6 +8038,24 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Print the KR freshness report as JSON";
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "keep-alive-audit";
+        readonly description: "Audit lead lane keep-alive timing";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options]";
+        readonly arguments: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--since <iso>";
+            readonly description: "Include stopped turns at or after this ISO date-time";
+        }, {
+            readonly flags: "--lane <id>";
+            readonly description: "Audit one exact lane id";
+        }, {
+            readonly flags: "--json";
+            readonly description: "Print the report as JSON";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "autopilot";
         readonly description: "Run lead autopilot checks and report follow-through metrics";

package/dist/command-catalog.generated.js

@@ -10346,6 +10346,29 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "keep-alive-audit",
+                "description": "Audit lead lane keep-alive timing",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options]",
+                "arguments": [],
+                "options": [
+                    {
+                        "flags": "--since <iso>",
+                        "description": "Include stopped turns at or after this ISO date-time"
+                    },
+                    {
+                        "flags": "--lane <id>",
+                        "description": "Audit one exact lane id"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "Print the report as JSON"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "autopilot",
                 "description": "Run lead autopilot checks and report follow-through metrics",

package/dist/commands/core-migrate-policy-triggers-native.js

@@ -135,14 +135,10 @@ function deriveWhen(trigger, rawTags, enforcementRaw) {
             seen.add(token);
         terms.push(triggerExpr.includes(" ") ? `( ${triggerExpr} )` : triggerExpr);
     }
-    const withoutBrackets = rawTags.replace(/^\[/, "").replace(/\]$/, "");
+    const commentStrippedTags = rawTags.replace(/[ \t\v\f\r]+#.*$/, "");
+    const withoutBrackets = commentStrippedTags.replace(/^\[/, "").replace(/\]$/, "");
     const rawTagParts = withoutBrackets.split(",");
-    for (let index = 0; index < rawTagParts.length; index += 1) {
-        // tag_tokens pipes through `while read`; Bash drops the final tag when
-        // the source has no trailing comma/newline because that read returns EOF.
-        if (index === rawTagParts.length - 1 && !withoutBrackets.endsWith(","))
-            break;
-        const raw = rawTagParts[index];
+    for (const raw of rawTagParts) {
         const tag = raw.toLowerCase().replace(/^\s+|\s+$/g, "").replace(/^vendor:/, "");
         if (!tag || TAG_STOP.has(tag) || seen.has(tag))
             continue;
@@ -174,7 +170,7 @@ function unreadablePolicyDiagnostic(filename, error) {
     const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : "No such file or directory";
     const script = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/scaffold/core/scripts/migrate-policy-triggers.sh");
     const awk = `awk: fatal: cannot open file \`${filename}' for reading: ${message}\n`;
-    return `${script}: line 309: ${filename}: ${message}\n${awk.repeat(3)}`;
+    return `${script}: line 314: ${filename}: ${message}\n${awk.repeat(3)}`;
 }
 function shellGlobMd(fileSystem, directory) {
     try {

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

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface LaneKeepAliveAuditCommandDeps {
+    hqRoot: () => string;
+    now: () => Date;
+    wrap: WrapHandler;
+}
+export declare function registerLaneKeepAliveAuditCommand(parent: Command, deps: LaneKeepAliveAuditCommandDeps): void;
+export {};
+//# sourceMappingURL=lanes-keep-alive-audit.d.ts.map

package/dist/commands/lanes-keep-alive-audit.js

@@ -0,0 +1,19 @@
+import { buildKeepAliveAudit, formatKeepAliveAuditText } from "../lib/lanes/keep-alive-audit.js";
+export function registerLaneKeepAliveAuditCommand(parent, deps) {
+    parent
+        .command("keep-alive-audit")
+        .description("Audit lead lane keep-alive timing")
+        .option("--since <iso>", "Include stopped turns at or after this ISO date-time")
+        .option("--lane <id>", "Audit one exact lane id")
+        .option("--json", "Print the report as JSON")
+        .action(deps.wrap(async (options) => {
+        const result = buildKeepAliveAudit({
+            hqRoot: deps.hqRoot(),
+            now: deps.now(),
+            ...(options.since === undefined ? {} : { since: options.since }),
+            ...(options.lane === undefined ? {} : { laneId: options.lane }),
+        });
+        console.log(options.json ? JSON.stringify(result) : formatKeepAliveAuditText(result));
+    }));
+}
+//# sourceMappingURL=lanes-keep-alive-audit.js.map

package/dist/commands/lanes-message.js

@@ -204,41 +204,37 @@ export function createLaneMessageHandlers(deps) {
     }
     async function runMessage(ctx, laneId, opts) {
         const hqRoot = ctx.hqRoot();
-        const hireGrantContext = opts.grantContext === undefined
-            ? undefined
-            : (() => {
-                if (!ctx.isSsmOwnerDispatch()) {
-                    throw new LanesError("hire_grant_dispatch_unauthorized", "Message grant context is only valid on an Outpost owner dispatch", { lane_id: laneId });
-                }
-                return parseOutpostHireGrantContext(opts.grantContext, laneId);
-            })();
+        const requestedLaneId = laneId;
         let accepted = false;
         let claimedMessages = [];
         let storySwitchRollback;
         let storySwitchDeliveryStarted = false;
+        const readMessageText = (targetLaneId) => {
+            if (opts.text !== undefined && opts.textFile !== undefined) {
+                throw new LanesError("message_text_source_conflict", "Pass either --text or --text-file, not both", { lane_id: targetLaneId });
+            }
+            let messageText = opts.text;
+            if (opts.textFile !== undefined) {
+                const textPath = path.isAbsolute(opts.textFile)
+                    ? opts.textFile
+                    : path.resolve(ctx.callerCwd(), opts.textFile);
+                try {
+                    messageText = ctx.readFileSync(textPath, "utf8");
+                }
+                catch (err) {
+                    throw new LanesError("message_text_file_unreadable", `Could not read message text file ${opts.textFile}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: targetLaneId, path: textPath });
+                }
+            }
+            if (messageText === undefined || messageText.length === 0) {
+                throw new LanesError("missing_text", "Pass non-empty message text with --text or --text-file", { lane_id: targetLaneId });
+            }
+            return messageText;
+        };
         const markAccepted = () => {
             accepted = true;
             storySwitchDeliveryStarted = true;
             opts.onAccepted?.();
         };
-        if (opts.text !== undefined && opts.textFile !== undefined) {
-            throw new LanesError("message_text_source_conflict", "Pass either --text or --text-file, not both", { lane_id: laneId });
-        }
-        let text = opts.text;
-        if (opts.textFile !== undefined) {
-            const textPath = path.isAbsolute(opts.textFile)
-                ? opts.textFile
-                : path.resolve(ctx.callerCwd(), opts.textFile);
-            try {
-                text = ctx.readFileSync(textPath, "utf8");
-            }
-            catch (err) {
-                throw new LanesError("message_text_file_unreadable", `Could not read message text file ${opts.textFile}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: laneId, path: textPath });
-            }
-        }
-        if (text === undefined || text.length === 0) {
-            throw new LanesError("missing_text", "Pass non-empty message text with --text or --text-file", { lane_id: laneId });
-        }
         let resolution;
         try {
             resolution = await deps.resolveCommandLane(ctx, laneId);
@@ -257,9 +253,20 @@ export function createLaneMessageHandlers(deps) {
                 primaryReportedMissing) {
                 throw err;
             }
-            await dispatchPrimaryLaneMessage(ctx, laneId, { ...opts, text });
+            const text = readMessageText(requestedLaneId);
+            await dispatchPrimaryLaneMessage(ctx, requestedLaneId, { ...opts, text });
             return;
         }
+        laneId = resolution.lane.lane_id;
+        let text = readMessageText(laneId);
+        const hireGrantContext = opts.grantContext === undefined
+            ? undefined
+            : (() => {
+                if (!ctx.isSsmOwnerDispatch()) {
+                    throw new LanesError("hire_grant_dispatch_unauthorized", "Message grant context is only valid on an Outpost owner dispatch", { lane_id: laneId });
+                }
+                return parseOutpostHireGrantContext(opts.grantContext, laneId);
+            })();
         let lane = resolution.lane;
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
             const fallbackAt = lane.state === "awaiting_input" ? ctx.now().toISOString() : undefined;
@@ -416,7 +423,9 @@ export function createLaneMessageHandlers(deps) {
             let automaticAccountSelection = undefined;
             if (opts.account === undefined && mechanism === "resume") {
                 try {
-                    automaticAccountSelection = await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile);
+                    automaticAccountSelection = await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, {
+                        tolerateInvalidHostLaneLists: lane.host.kind === "local",
+                    });
                 }
                 catch (err) {
                     const reasons = err instanceof LanesError && err.error === "claude_account_balance_no_eligible_account" &&

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

@@ -194,6 +194,7 @@ export interface LaneMessageHandlerDeps {
     resolveResumeProfile(ctx: Ctx, lane: LaneRecord, workerId: string): ResolvedResumeProfile;
     selectAutomaticClaudeResumeAccount(ctx: Ctx, lane: LaneRecord, workerProfile?: ResolvedResumeProfile, options?: {
         repairUnavailableAccount?: boolean;
+        tolerateInvalidHostLaneLists?: boolean;
     }): Promise<{
         selection: LaneAccountSelection;
         historyReason?: AccountHistoryEntry["reason"];

package/dist/commands/lanes.js

@@ -23,6 +23,7 @@ export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG }
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneKpisCommand } from "./lanes-kpis.js";
+import { registerLaneKeepAliveAuditCommand } from "./lanes-keep-alive-audit.js";
 import { registerLaneAutopilotReportCommand } from "./lanes-autopilot.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
@@ -32,7 +33,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
-import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
+import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
 import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
 import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
@@ -1549,10 +1550,10 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     }
     const separator = laneId.lastIndexOf("_");
     const hostSuffix = separator < 0 ? "" : laneId.slice(separator + 1);
-    const ownerCompany = !hostSuffix && requestedUlid !== undefined && options.allowHostlessOwnerLookup
+    const ownerLookupGate = !hostSuffix && requestedUlid !== undefined && options.allowHostlessOwnerLookup
         ? await options.allowHostlessOwnerLookup()
-        : undefined;
-    const hostlessUlidLookup = ownerCompany !== undefined;
+        : false;
+    const hostlessUlidLookup = ownerLookupGate !== false;
     if ((!hostSuffix && !hostlessUlidLookup) ||
         (hostSuffix && sanitizeHostComponent(hostSuffix) !== hostSuffix)) {
         throw commandLaneNotFound(laneId, options.outpostHint === true);
@@ -1647,9 +1648,9 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
             const laneCompany = hostlessUlidLookup
                 ? resolveLaneCompany(ctx.hqRoot(), lane).company
                 : undefined;
-            const companyMatches = !hostlessUlidLookup || (ownerCompany !== undefined &&
-                laneCompany?.uid === ownerCompany.uid &&
-                laneCompany.slug === ownerCompany.slug);
+            const companyMatches = !hostlessUlidLookup || ownerLookupGate === true || (ownerLookupGate === "check-company" &&
+                laneCompany !== undefined && laneCompany !== null &&
+                await options.allowHostlessOwnerLookup(laneCompany));
             if (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
                 sanitizeHostComponent(lane.host.id) === hostSuffix) ||
                 (hostlessUlidLookup && laneUlidPart(lane.lane_id) === requestedUlid &&
@@ -1683,6 +1684,20 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
         ownerHost: match.lane.host,
     };
 }
+async function resolveMessageLaneTarget(ctx, laneId) {
+    return resolveCommandLaneTarget(ctx, laneId, {
+        allowHostlessOwnerLookup: async (company) => {
+            if (!company) {
+                const localOverride = readLanesFlagLocalOverride(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, ctx.env);
+                return localOverride ?? "check-company";
+            }
+            return readLanesRegistryFlag(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, {
+                company,
+                env: ctx.env,
+            });
+        },
+    });
+}
 function laneUlidPart(laneId) {
     const separator = laneId.indexOf("_");
     if (separator !== -1 && separator !== 26)
@@ -1696,7 +1711,7 @@ function commandLaneNotFound(laneId, outpostHint, details = {}) {
         : "";
     return new LanesError("lane_not_found", `Lane ${laneId} was not found locally or on a registered Outpost with a matching host suffix${hint}`, { lane_id: laneId, ...details });
 }
-async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
+async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config, options = {}) {
     const localHost = laneHostFromCtx(ctx);
     const localLanes = loadAllLanes(hqRoot);
     const local = buildHostCapacitySnapshot({
@@ -1782,7 +1797,8 @@ async function loadClaudeBalanceHostSnapshots(ctx, hqRoot, config) {
             laneListAvailable = true;
         }
         catch (err) {
-            if (isLanesError(err) && err.error === "outpost_lane_list_invalid")
+            if (isLanesError(err) && err.error === "outpost_lane_list_invalid" &&
+                options.tolerateInvalidLaneLists !== true)
                 throw err;
             unavailableHosts.push({
                 host: { kind: "outpost", id },
@@ -5293,9 +5309,9 @@ async function refreshOutpostLaneCopiesForShow(ctx, lane, localLanes) {
     const refreshedLane = refreshed[0] ?? null;
     return { lane: refreshedLane ?? lane };
 }
-async function runShow(ctx, laneId, hasPendingQuestionForLane) {
+async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget) {
     const hqRoot = ctx.hqRoot();
-    const initialLane = readLane(hqRoot, laneId);
+    const initialLane = (await resolveLaneTarget(ctx, laneId)).lane;
     const initialLanes = loadAllLanes(hqRoot);
     const showRefresh = await refreshOutpostLaneCopiesForShow(ctx, initialLane, initialLanes);
     const storedLane = showRefresh.lane;
@@ -6598,7 +6614,9 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     const mayRebalance = BALANCE_MOVABLE_STATES.includes(lane.state);
     if (!accountNeedsRepair && !mayRebalance)
         return undefined;
-    const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+    const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config, {
+        tolerateInvalidLaneLists: options.tolerateInvalidHostLaneLists === true,
+    });
     const targetHost = balanceHosts.snapshots.find((host) => host.capacity.host.kind === lane.host.kind && host.capacity.host.id === lane.host.id);
     const currentTargetAccount = lane.account === undefined
         ? undefined
@@ -8205,16 +8223,7 @@ export function registerLanesCommand(parent, deps = {}) {
         persistClaudeAccountSelection,
         printJson,
         recordResumeSetup,
-        resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId, {
-            allowHostlessOwnerLookup: async () => {
-                const company = await commandCtx.resolveCompany();
-                const enabled = await readLanesRegistryFlag(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, {
-                    company,
-                    env: commandCtx.env,
-                });
-                return enabled ? company : undefined;
-            },
-        }),
+        resolveCommandLane: resolveMessageLaneTarget,
         resolveActiveQuestionCompany,
         hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
         cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
@@ -8310,6 +8319,7 @@ export function registerLanesCommand(parent, deps = {}) {
     }, wrap);
     registerOutpostPrunerCommand(lanes);
     registerLaneKpisCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });
+    registerLaneKeepAliveAuditCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });
     registerLaneAutopilotReportCommand(lanes, {
         hqRoot: ctx.hqRoot,
         now: ctx.now,
@@ -8516,7 +8526,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Show one lane")
         .argument("<lane-id>", "Lane id")
         .action(wrap(async (laneId) => {
-        await runShow(ctx, laneId, questionHandlers.hasPendingQuestionForLane);
+        await runShow(ctx, laneId, questionHandlers.hasPendingQuestionForLane, resolveMessageLaneTarget);
     }));
     const stories = lanes
         .command("story")

package/dist/lib/core-utils/sentry-report.d.ts

@@ -15,8 +15,8 @@
  * scalar metadata is dropped instead: the allowlist, not a caller version
  * match, determines what may leave the machine.
  */
-import * as Sentry from "@sentry/node";
 import type { CaptureContext, SeverityLevel } from "@sentry/node";
+type SentryModule = typeof import("@sentry/node");
 export declare const DEFAULT_SENTRY_REPORT_TIMEOUT_MS = 750;
 export declare const MAX_SENTRY_REPORT_PAYLOAD_BYTES = 2048;
 export declare const MAX_SENTRY_REPORT_METADATA_VALUE_BYTES = 256;
@@ -76,8 +76,8 @@ export type SentryReportOptions = {
 export type SentryReportDependencies = {
     sentry: {
         captureMessage: (message: string, context?: CaptureContext | SeverityLevel) => string;
-        addBreadcrumb: (breadcrumb: Parameters<typeof Sentry.addBreadcrumb>[0]) => void;
-        metrics: Pick<typeof Sentry.metrics, "count">;
+        addBreadcrumb: (breadcrumb: Parameters<SentryModule["addBreadcrumb"]>[0]) => void;
+        metrics: Pick<SentryModule["metrics"], "count">;
         flush: (timeout?: number) => PromiseLike<boolean>;
     };
     stdout: Pick<NodeJS.WriteStream, "write">;

package/dist/lib/core-utils/sentry-report.js

@@ -19,12 +19,18 @@ import { createHash } from "node:crypto";
 import { mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import * as Sentry from "@sentry/node";
+import { createRequire } from "node:module";
 import { gte as semverGte, valid as validSemver } from "semver";
 import { CLI_VERSION } from "../../cli-version.js";
 import { beforeSend } from "../../sentry-before-send.js";
 import { resolveLiveRoot } from "../../utils/hq-roots.js";
 import { hookTimeoutDebugContextEnabled } from "./hook-timeout-debug-context-flag.js";
+const requireSentry = createRequire(import.meta.url);
+let sentryModule;
+function loadSentryModule() {
+    sentryModule ??= requireSentry("@sentry/node");
+    return sentryModule;
+}
 export const DEFAULT_SENTRY_REPORT_TIMEOUT_MS = 750;
 const MAX_SENTRY_REPORT_TIMEOUT_MS = 5_000;
 export const MAX_SENTRY_REPORT_PAYLOAD_BYTES = 2_048;
@@ -176,7 +182,22 @@ const SENTRY_REPORT_METADATA_KEY_HEADROOM = 2;
 // while unknown keys are deliberately dropped.
 export const MAX_SENTRY_REPORT_METADATA_KEYS = ALLOWED_SENTRY_REPORT_METADATA_KEYS.length + SENTRY_REPORT_METADATA_KEY_HEADROOM;
 const defaultDependencies = {
-    sentry: Sentry,
+    sentry: {
+        captureMessage(message, context) {
+            return loadSentryModule().captureMessage(message, context);
+        },
+        addBreadcrumb(breadcrumb) {
+            loadSentryModule().addBreadcrumb(breadcrumb);
+        },
+        metrics: {
+            count(name, value, options) {
+                loadSentryModule().metrics.count(name, value, options);
+            },
+        },
+        flush(timeout) {
+            return loadSentryModule().flush(timeout);
+        },
+    },
     stdout: process.stdout,
     stderr: process.stderr,
     timeoutDebugContextEnabled: (signal) => hookTimeoutDebugContextEnabled({}, signal),

package/dist/lib/first-sync-next-step.d.ts

@@ -3,13 +3,11 @@ export declare const FIRST_SYNC_NEXT_STEP_COPY = "Save a file in your HQ folder,
 export declare const FIRST_SYNC_CONFIRMATION_COPY = "Your first work sync is complete.";
 export type FirstSyncStepOutcome = "shown" | "followed";
 export declare function shouldShowFirstSyncNextStep(input: {
-    flagEnabled: boolean;
     interactive: boolean;
     alreadyShown: boolean;
     alreadyCompleted: boolean;
 }): boolean;
 export declare function shouldConfirmFirstWorkBearingSync(input: {
-    flagEnabled: boolean;
     interactive: boolean;
     alreadyCompleted: boolean;
     workBearing: boolean;
@@ -27,7 +25,6 @@ export declare function firstSyncStepMarkerPaths(identity: string, home?: string
 };
 export declare function claimFirstSyncStepMarker(kind: "shown" | "completed", identity: string, home?: string): boolean;
 export declare function firstSyncStepTelemetryProperties(outcome: FirstSyncStepOutcome): Record<string, unknown>;
-export declare function isFirstSyncNextStepEnabled(): boolean;
 /** Called once after the first completed CLI action, before process finalization. */
 export declare function maybeShowFirstSyncNextStep(): boolean;
 /** Capture the first positive CLI sync result without changing transfer logic. */

package/dist/lib/first-sync-next-step.js

@@ -2,7 +2,6 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { resolveProcessFlagGate } from "./flag-registry.js";
 import { cognitoSubjectKey, isMachineIdentity, loadCachedTokens, } from "../utils/cognito-session.js";
 export const CLI_FIRST_SYNC_NEXT_STEP_FLAG = "cli.first-sync-next-step";
 export const FIRST_SYNC_NEXT_STEP_COPY = "Save a file in your HQ folder, then run `hq sync push`.";
@@ -17,14 +16,12 @@ const AUTOMATION_ENV_MARKERS = [
 ];
 const pendingOutcomes = [];
 export function shouldShowFirstSyncNextStep(input) {
-    return (input.flagEnabled &&
-        input.interactive &&
+    return (input.interactive &&
         !input.alreadyShown &&
         !input.alreadyCompleted);
 }
 export function shouldConfirmFirstWorkBearingSync(input) {
-    return (input.flagEnabled &&
-        input.interactive &&
+    return (input.interactive &&
         !input.alreadyCompleted &&
         input.workBearing);
 }
@@ -111,9 +108,6 @@ export function firstSyncStepTelemetryProperties(outcome) {
         flagKey: CLI_FIRST_SYNC_NEXT_STEP_FLAG,
     };
 }
-export function isFirstSyncNextStepEnabled() {
-    return resolveProcessFlagGate(CLI_FIRST_SYNC_NEXT_STEP_FLAG, { fallback: false }, () => false);
-}
 function currentPersonIdentity() {
     return cognitoSubjectKey(loadCachedTokens());
 }
@@ -131,15 +125,13 @@ function queueOutcome(outcome) {
 }
 /** Called once after the first completed CLI action, before process finalization. */
 export function maybeShowFirstSyncNextStep() {
-    // Keep the cheap eligibility/gate checks ahead of identity and filesystem
-    // reads; neither an automated invocation nor a flag-off session needs state.
-    if (!isCurrentSessionEligible() || !isFirstSyncNextStepEnabled())
+    // Keep the cheap eligibility check ahead of identity and filesystem reads.
+    if (!isCurrentSessionEligible())
         return false;
     const identity = currentPersonIdentity();
     if (!identity)
         return false;
     const shouldShow = shouldShowFirstSyncNextStep({
-        flagEnabled: true,
         interactive: true,
         alreadyShown: firstSyncStepMarkerExists("shown", identity),
         alreadyCompleted: firstSyncStepMarkerExists("completed", identity),
@@ -165,13 +157,11 @@ export function recordFirstWorkBearingSync(result) {
     const alreadyCompleted = firstSyncStepMarkerExists("completed", identity);
     if (alreadyCompleted || !claimFirstSyncStepMarker("completed", identity))
         return false;
-    // Persist completion even while the rollout is off so enabling the flag later
-    // cannot prompt a person who already completed a work-bearing sync. JSON and
-    // other non-interactive human syncs count too; only the message is TTY-gated.
+    // Persist completion for non-interactive human syncs too; only the message is
+    // TTY-gated.
     if (!isCurrentSessionEligible())
         return false;
     if (!shouldConfirmFirstWorkBearingSync({
-        flagEnabled: isFirstSyncNextStepEnabled(),
         interactive: true,
         alreadyCompleted: false,
         workBearing: true,

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

@@ -5,10 +5,16 @@ export declare const LEAD_AUTOPILOT_DEFAULT_ENABLED = false;
 export declare const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
 export declare const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DEFAULT_ENABLED = false;
 export declare const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DELAY_MS: number;
+export declare const LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
+export declare const LEAD_AUTOPILOT_NUDGE_DEDUPE_DEFAULT_ENABLED = false;
+export declare const LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS: number;
+export declare const LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS: number;
 export declare const LEAD_AUTOPILOT_REVIEW_DELAY_MS: number;
 export declare const LEAD_AUTOPILOT_FILL_DELAY_MS: number;
 export declare const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
 export declare const LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES = 55;
+export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = "lanes.autopilot-per-lead-errors";
+export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
 export interface RegisteredLead {
     team: string;
     lane: string;
@@ -74,6 +80,11 @@ export interface AutopilotPassResult {
     skipped: Array<{
         lead_lane: string;
         reason: string;
+    } | {
+        lane_id: string;
+        error: string;
+        path: string;
+        message: string;
     }>;
     kpi_status?: AutopilotKpiStatus[];
     /** Set on an Outpost that has not received a lead registry from the primary yet. */
@@ -97,6 +108,7 @@ export declare function planLeadAutopilotWakes(input: {
     managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
     kpiStalenessEnabled?: boolean;
+    kpiStalenessBatchEnabled?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {
     hqRoot: string;
@@ -106,6 +118,7 @@ export declare function runLeadAutopilotPass(input: {
     now: Date;
     dryRun?: boolean;
     readFlag?: typeof readLanesRegistryFlag;
+    readNudgeDedupeFlag?: typeof readLanesRegistryFlag;
     readDeadlineFlag?: typeof readLanesRegistryFlag;
     keepAliveResumedLeads?: ReadonlySet<string>;
     missedDeadlineEscalationDelayMs?: number;