@indigoai-us/hq-cli 5.311.3 → 5.312.0

package/dist/commands/lanes.js

@@ -33,6 +33,7 @@ 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 } from "../lib/lanes/registry-flag.js";
+import { LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
@@ -1197,14 +1198,20 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
         throw new LanesError("outpost_lane_list_unavailable", `Could not read lanes from Outpost ${outpostId}: ${message}`, { outpost_id: outpostId });
     }
     if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
-        throw new LanesError("outpost_lane_list_unavailable", `Outpost ${outpostId} did not return a successful lane list`, { outpost_id: outpostId, status: result.status, done: result.done ?? false, exit_code: result.exitCode });
+        throw new LanesError("outpost_lane_list_unavailable", `Outpost ${outpostId} did not return a successful lane list`, {
+            outpost_id: outpostId,
+            command_id: result.commandId,
+            status: result.status,
+            done: result.done ?? false,
+            exit_code: result.exitCode,
+        });
     }
     let body;
     try {
         body = JSON.parse(result.stdout);
     }
     catch (err) {
-        throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned invalid lane-list JSON: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId });
+        throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned invalid lane-list JSON: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId, command_id: result.commandId });
     }
     if (body === null || typeof body !== "object" || Array.isArray(body) ||
         body.ok !== true ||
@@ -1212,6 +1219,7 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
         !Array.isArray(body.lanes)) {
         throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned a malformed lane list`, {
             outpost_id: outpostId,
+            command_id: result.commandId,
         });
     }
     const listed = body.lanes;
@@ -1499,7 +1507,12 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     }
     const separator = laneId.lastIndexOf("_");
     const hostSuffix = separator < 0 ? "" : laneId.slice(separator + 1);
-    if (!hostSuffix || sanitizeHostComponent(hostSuffix) !== hostSuffix) {
+    const ownerCompany = !hostSuffix && requestedUlid !== undefined && options.allowHostlessOwnerLookup
+        ? await options.allowHostlessOwnerLookup()
+        : undefined;
+    const hostlessUlidLookup = ownerCompany !== undefined;
+    if ((!hostSuffix && !hostlessUlidLookup) ||
+        (hostSuffix && sanitizeHostComponent(hostSuffix) !== hostSuffix)) {
         throw commandLaneNotFound(laneId, options.outpostHint === true);
     }
     let rawOutpostRoutes;
@@ -1542,7 +1555,9 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     if (requestedOutpostId !== undefined && !outpostIds.includes(requestedOutpostId)) {
         throw new LanesError("outpost_not_registered", `Outpost ${requestedOutpostId} is not registered`, { lane_id: laneId, outpost_id: requestedOutpostId });
     }
-    const hostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, hostSuffix));
+    const hostRoutes = hostlessUlidLookup
+        ? []
+        : outpostRoutes.filter((route) => outpostRouteMatchesHost(route, hostSuffix));
     const identity = ctx.readOutpostIdentity();
     const localHostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, ctx.hostname()));
     if (localHostRoutes.length > 1 || (identity.kind === "id" && localHostRoutes.some((route) => route.outpostId !== identity.id))) {
@@ -1553,20 +1568,22 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     const hostOutpostIdSet = new Set(hostOutpostIds);
     const matches = [];
     const failedOutpostIds = [];
+    const failedOutpostCommands = [];
     const probedOutpostIds = [];
     const lookupOutpostIds = requestedOutpostId !== undefined
         ? [requestedOutpostId]
-        : [
-            ...hostOutpostIds.filter((id) => id !== localOutpostId),
-            ...outpostIds.filter((id) => id !== localOutpostId && !hostOutpostIdSet.has(id)),
-        ];
+        : hostlessUlidLookup
+            ? outpostIds.filter((id) => id !== localOutpostId)
+            : [
+                ...hostOutpostIds.filter((id) => id !== localOutpostId),
+                ...outpostIds.filter((id) => id !== localOutpostId && !hostOutpostIdSet.has(id)),
+            ];
     for (const outpostId of lookupOutpostIds) {
         let ownerLanes;
         try {
-            ownerLanes = await readOutpostLaneRecords(ctx, outpostId, {
-                hierarchy: [laneId],
-                snapshot: true,
-            });
+            ownerLanes = await readOutpostLaneRecords(ctx, outpostId, hostlessUlidLookup
+                ? { snapshot: true }
+                : { hierarchy: [laneId], snapshot: true });
             probedOutpostIds.push(outpostId);
         }
         catch (err) {
@@ -1575,16 +1592,38 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
             if (isLanesError(err) && err.error === "outpost_wait_invalid")
                 throw err;
             failedOutpostIds.push(outpostId);
+            failedOutpostCommands.push({
+                outpost_id: outpostId,
+                ...(isLanesError(err) && typeof err.details.command_id === "string"
+                    ? { command_id: err.details.command_id }
+                    : {}),
+            });
             continue;
         }
         for (const lane of ownerLanes) {
-            if (lane.lane_id === laneId &&
-                lane.host.kind === "local" &&
-                sanitizeHostComponent(lane.host.id) === hostSuffix) {
+            const recordedSuffix = lane.lane_id.slice(lane.lane_id.lastIndexOf("_") + 1);
+            const laneCompany = hostlessUlidLookup
+                ? resolveLaneCompany(ctx.hqRoot(), lane).company
+                : undefined;
+            const companyMatches = !hostlessUlidLookup || (ownerCompany !== undefined &&
+                laneCompany?.uid === ownerCompany.uid &&
+                laneCompany.slug === ownerCompany.slug);
+            if (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
+                sanitizeHostComponent(lane.host.id) === hostSuffix) ||
+                (hostlessUlidLookup && laneUlidPart(lane.lane_id) === requestedUlid &&
+                    sanitizeHostComponent(lane.host.id) === recordedSuffix &&
+                    companyMatches))) {
                 matches.push({ outpostId, lane });
             }
         }
     }
+    if (hostlessUlidLookup && failedOutpostIds.length > 0) {
+        throw new LanesError("lane_owner_lookup_unavailable", `Could not verify whether lane ${laneId} is registered on every Outpost`, {
+            lane_id: laneId,
+            failed_outpost_ids: failedOutpostIds,
+            remote_commands: failedOutpostCommands,
+        });
+    }
     if (matches.length === 0) {
         throw commandLaneNotFound(laneId, options.outpostHint === true, {
             ...(failedOutpostIds.length > 0 ? { failed_outpost_ids: failedOutpostIds } : {}),
@@ -1604,9 +1643,9 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
 }
 function laneUlidPart(laneId) {
     const separator = laneId.indexOf("_");
-    if (separator !== 26)
+    if (separator !== -1 && separator !== 26)
         return undefined;
-    const ulid = laneId.slice(0, separator);
+    const ulid = separator === -1 ? laneId : laneId.slice(0, separator);
     return /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(ulid) ? ulid.toUpperCase() : undefined;
 }
 function commandLaneNotFound(laneId, outpostHint, details = {}) {
@@ -7660,7 +7699,7 @@ function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
 async function runReconcile(ctx, opts, recoverQueuedMessages) {
     const fromEnv = ctx.env.HQ_ROOT?.trim();
     const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
-    const mirrorRefresh = opts.dryRun
+    const mirrorRefresh = opts.dryRun || opts.terminalKeepAliveCandidate
         ? {
             updated: new Map(),
             unverifiedRemote: new Map(),
@@ -7724,6 +7763,9 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
         recoverQueuedMessages,
         mesh: ctx.mesh,
         env: ctx.env,
+        ...(opts.terminalKeepAliveCandidate !== undefined
+            ? { terminalKeepAliveCandidate: opts.terminalKeepAliveCandidate }
+            : {}),
         prepareKeepAliveClaudeResume: async (lane) => {
             const recoveredLane = laneWithRecoveredProviderSession(hqRoot, lane);
             const pendingModel = recoveredLane.pending_settings?.model;
@@ -8041,7 +8083,16 @@ export function registerLanesCommand(parent, deps = {}) {
         persistClaudeAccountSelection,
         printJson,
         recordResumeSetup,
-        resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId),
+        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;
+            },
+        }),
         resolveActiveQuestionCompany,
         hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
         cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
@@ -8406,7 +8457,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("message")
         .description("Send a follow-up message to a lane")
         .argument("<lane-id>", "Lane id")
-        .requiredOption("--text <msg>", "Message text")
+        .option("--text <msg>", "Message text")
+        .option("--text-file <path>", "Read message text from a file")
         .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
         .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
@@ -8745,6 +8797,30 @@ export function registerLanesCommand(parent, deps = {}) {
             await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
         });
     }));
+    lanes
+        .command("_keep-alive-terminal-trigger <laneId> <version> <dueAt>", { hidden: true })
+        .action(wrap(async (laneId, versionText, dueAt) => {
+        const version = Number.parseInt(versionText, 10);
+        if (!Number.isSafeInteger(version) || version < 1 || String(version) !== versionText) {
+            throw new LanesError("invalid_lane_version", "Terminal keep-alive trigger requires a positive lane version", {
+                lane_id: laneId,
+                version: versionText,
+            });
+        }
+        const dueAtMs = Date.parse(dueAt);
+        if (!Number.isFinite(dueAtMs)) {
+            throw new LanesError("invalid_terminal_trigger_time", "Terminal keep-alive trigger requires a valid due time", {
+                lane_id: laneId,
+                due_at: dueAt,
+            });
+        }
+        const delayMs = dueAtMs - Date.now();
+        if (delayMs > 0)
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await runReconcile(ctx, { terminalKeepAliveCandidate: { laneId, version } }, async (lane) => {
+            await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
+        });
+    }));
     reconcile
         .command("install")
         .description("Write systemd user unit and timer files (idempotent)")

package/dist/commands/vault-retention-flag.d.ts

@@ -0,0 +1,3 @@
+export declare const VAULT_RETENTION_SETTINGS_FLAG = "cli.vault-retention-settings";
+export declare function vaultRetentionSettingsEnabled(companyUid?: string, idToken?: string): boolean | Promise<boolean>;
+//# sourceMappingURL=vault-retention-flag.d.ts.map

package/dist/commands/vault-retention-flag.js

@@ -0,0 +1,9 @@
+import { resolveCompanyFlagGate, resolveProcessFlagGate } from "../lib/flag-registry.js";
+export const VAULT_RETENTION_SETTINGS_FLAG = "cli.vault-retention-settings";
+export function vaultRetentionSettingsEnabled(companyUid, idToken) {
+    if (companyUid && idToken) {
+        return resolveCompanyFlagGate(companyUid, idToken, VAULT_RETENTION_SETTINGS_FLAG, { fallback: false }, () => false);
+    }
+    return resolveProcessFlagGate(VAULT_RETENTION_SETTINGS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=vault-retention-flag.js.map

package/dist/commands/vault-retention.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { vaultApiFetch } from "../utils/vault-api.js";
+type Dependencies = {
+    enabled: (companyUid?: string, token?: string) => boolean | Promise<boolean>;
+    token: () => Promise<string>;
+    companyUid: (token: string, slug: string | undefined) => Promise<string>;
+    request: typeof vaultApiFetch;
+};
+export declare function registerVaultRetentionCommand(program: Command, deps?: Dependencies): void;
+export {};
+//# sourceMappingURL=vault-retention.d.ts.map

package/dist/commands/vault-retention.js

@@ -0,0 +1,69 @@
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { markExpectedUserError } from "../utils/expected-cli-error.js";
+import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
+import { vaultRetentionSettingsEnabled } from "./vault-retention-flag.js";
+const defaultDependencies = {
+    enabled: vaultRetentionSettingsEnabled,
+    token: ensureCognitoToken,
+    companyUid: getCompanyUid,
+    request: vaultApiFetch,
+};
+export function registerVaultRetentionCommand(program, deps = defaultDependencies) {
+    const vault = program.command("vault").description("Manage HQ vault settings");
+    const retention = vault
+        .command("retention")
+        .description("Get or set the default retention for future vault object versions")
+        .option("--company <slug>", "Company vault slug (omit for your personal vault)");
+    const companyOf = (command) => command.opts().company ??
+        retention.opts().company;
+    retention
+        .command("get")
+        .description("Show the vault's default retention in days")
+        .action(async function () {
+        await execute(this, "GET");
+    });
+    retention
+        .command("set")
+        .description("Set the vault's default retention in days (1-30)")
+        .argument("<days>")
+        .action(async function (rawDays) {
+        const days = Number(rawDays);
+        if (!Number.isInteger(days) || days < 1 || days > 30) {
+            throw new Error("days must be an integer from 1 through 30");
+        }
+        await execute(this, "PUT", days);
+    });
+    async function execute(command, method, days) {
+        const slug = companyOf(command);
+        let token;
+        let companyUid;
+        if (slug) {
+            token = await deps.token();
+            companyUid = await deps.companyUid(token, slug);
+            if (!(await deps.enabled(companyUid, token))) {
+                throw markExpectedUserError(new Error("Vault retention settings are not enabled for this company."));
+            }
+        }
+        else {
+            if (!(await deps.enabled())) {
+                throw markExpectedUserError(new Error("Vault retention settings are not enabled for this company."));
+            }
+            token = await deps.token();
+        }
+        const query = companyUid ? { companyUid } : undefined;
+        const response = await deps.request({
+            token,
+            path: "/vault/retention",
+            method,
+            ...(query ? { query } : {}),
+            ...(days === undefined ? {} : { body: { days } }),
+        });
+        if (!response.ok) {
+            const body = (await response.json().catch(() => ({})));
+            throw new Error(body.error ?? body.message ?? response.statusText);
+        }
+        const body = (await response.json());
+        process.stdout.write(`${body.days} days\n`);
+    }
+}
+//# sourceMappingURL=vault-retention.js.map

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

@@ -20,6 +20,7 @@ import { mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync,
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import * as Sentry from "@sentry/node";
+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";
@@ -47,6 +48,10 @@ const HOOK_TIMEOUT_EXCEEDED_METRIC = "hq.hook_timeout_exceeded";
 const MAX_HOOK_SEQUENCE_ENTRIES = 20;
 const MAX_HOOK_TIMEOUT_DEBUG_PHASES = 24;
 const MAX_HOOK_TIMEOUT_DEBUG_MS = 86_400_000;
+// This is the hqVersion embedded in the first hq-core tag whose master-hook
+// replaces BASH_ENV with /dev/null before reading it (tag v15.0.157-beta.2).
+// Earlier cores only report whether BASH_ENV is non-empty, which is ambiguous.
+const BASH_ENV_NEUTRALIZED_CORE_VERSION = "15.0.157-beta.2";
 const HOOK_TIMEOUT_RATE_LIMIT_WINDOW_MS = 10 * 60 * 1_000;
 const RATE_LIMIT_LOCK_WAIT_MS = 500;
 const RATE_LIMIT_LOCK_POLL_MS = 5;
@@ -578,9 +583,10 @@ function hookTimeoutDebugContextTags(context) {
 function safeSlowChild(metadata) {
     const value = metadata.slow_child;
     const slowChildMs = metadata.slow_child_ms;
+    const bashEnv = bashEnvTag(metadata);
     const hasMeasuredChild = typeof slowChildMs === "number" && Number.isFinite(slowChildMs) && slowChildMs >= 0;
     if (metadata.hook_event === "SessionStart" &&
-        (metadata.bash_env_set === true || metadata.bash_env_set === "set") &&
+        (bashEnv === "profile" || bashEnv === "set") &&
         !hasMeasuredChild &&
         (typeof value !== "string" || value.length === 0 || value === "other")) {
         return "entry-bash-startup";
@@ -605,8 +611,15 @@ function isMachineWideHookSlowness(metadata) {
 }
 function bashEnvTag(metadata) {
     const value = metadata.bash_env_set;
-    if (value === true || value === "set")
-        return "set";
+    if (value === "profile" || value === "devnull")
+        return value;
+    if (value === true || value === "set") {
+        const coreVersion = metadata.hq_version;
+        const parsedCoreVersion = typeof coreVersion === "string" ? validSemver(coreVersion) : null;
+        if (!parsedCoreVersion)
+            return "unknown";
+        return semverGte(parsedCoreVersion, BASH_ENV_NEUTRALIZED_CORE_VERSION) ? "devnull" : "set";
+    }
     if (value === false || value === "unset")
         return "unset";
     return "unknown";
@@ -882,9 +895,13 @@ function timeoutRateLimitLease(event, kind, options, dependencies) {
     }
 }
 function metricAttributes(metadata) {
-    return Object.fromEntries(Object.entries(metadata)
+    const attributes = Object.fromEntries(Object.entries(metadata)
         .filter(([, value]) => isScalarMetadataValue(value))
         .map(([key, value]) => [key, typeof value === "string" ? safeTagValue(value) : value]));
+    if (Object.hasOwn(metadata, "bash_env_set")) {
+        attributes.bash_env_set = bashEnvTag(metadata);
+    }
+    return attributes;
 }
 function addHookSequenceBreadcrumbs(event, dependencies) {
     const sequence = event.metadata.hook_sequence;

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

@@ -79,6 +79,8 @@ export interface PlanContext {
     sessionHostRunnerPath: string | null;
     /** Environment retained from legacy outpost sync systemd drop-ins. */
     legacySyncEnv: Record<string, string>;
+    /** Keep the sync runner's event-driven instant-sync watcher enabled. */
+    instantSyncEnabled?: boolean;
     /** Keep the local sync runner stopped until the operator resumes it. */
     syncPaused: boolean;
     /** Persisted/effective owner selected for this machine. */

package/dist/lib/daemon/catalog.js

@@ -128,7 +128,19 @@ function planService(service, ctx) {
                 command: {
                     type: "node",
                     script: ctx.syncRunnerPath,
-                    args: ["--companies", "--direction", "both", "--on-conflict", "keep", "--hq-root", ctx.hqRoot ?? "", "--watch", "--event-push", "--owner", SYNC_RUNNER_OWNER],
+                    args: [
+                        "--companies",
+                        "--direction",
+                        "both",
+                        "--on-conflict",
+                        "keep",
+                        "--hq-root",
+                        ctx.hqRoot ?? "",
+                        "--watch",
+                        ...(ctx.instantSyncEnabled === false ? [] : ["--event-push"]),
+                        "--owner",
+                        SYNC_RUNNER_OWNER,
+                    ],
                 },
                 env: { ...ctx.legacySyncEnv },
                 heartbeatTimeoutMs: ctx.syncHeartbeatTimeoutMs,

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

@@ -14,6 +14,8 @@ export interface DaemonConfig {
     hqCloudVersion?: string;
     /** Persisted machine-local sync pause. */
     syncPaused?: boolean;
+    /** Desktop Instant Sync preference, applied when the sync unit is planned. */
+    instantSyncEnabled?: boolean;
     /** Explicit desktop handoff; absent values preserve the legacy per-machine owner. */
     syncOwner?: SyncOwner;
     /** Services turned on here beyond the machine type's defaults. */

package/dist/lib/daemon/config.js

@@ -45,6 +45,8 @@ export function readDaemonConfig(file) {
         enable: stringList(obj.enable),
         disable: stringList(obj.disable),
     };
+    if (typeof obj.instantSyncEnabled === "boolean")
+        config.instantSyncEnabled = obj.instantSyncEnabled;
     if (isMachineType(obj.machineType))
         config.machineType = obj.machineType;
     if (obj.syncOwner === "daemon" || obj.syncOwner === "desktop-app")
@@ -67,6 +69,8 @@ export function writeDaemonConfig(file, config) {
     if (config.hqCloudVersion)
         ordered.hqCloudVersion = config.hqCloudVersion;
     ordered.syncPaused = config.syncPaused === true;
+    if (typeof config.instantSyncEnabled === "boolean")
+        ordered.instantSyncEnabled = config.instantSyncEnabled;
     if (config.syncOwner)
         ordered.syncOwner = config.syncOwner;
     ordered.enable = config.enable;

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

@@ -24,6 +24,8 @@ export interface RunDaemonOptions {
     hqBinary: string;
 }
 export declare function resolveSyncRunnerPath(): string | null;
+/** The hosted desktop app uses this env value when planning daemon services. */
+export declare function daemonInstantSyncEnabled(env: NodeJS.ProcessEnv, configured?: boolean): boolean;
 export declare function listLocalBots(root?: string): string[];
 export declare function windowsTaskExists(taskName: string): boolean;
 export declare function probeLegacyUnits(platform: NodeJS.Platform, home: string): LegacyUnit[];

package/dist/lib/daemon/run.js

@@ -53,6 +53,10 @@ export function resolveSyncRunnerPath() {
         return null;
     }
 }
+/** The hosted desktop app uses this env value when planning daemon services. */
+export function daemonInstantSyncEnabled(env, configured) {
+    return configured ?? env.HQ_DAEMON_INSTANT_SYNC !== "0";
+}
 export function listLocalBots(root = botsRoot()) {
     if (!fs.existsSync(root))
         return [];
@@ -447,6 +451,7 @@ export async function runDaemon(opts) {
             heartbeatRunnerPath: runners.heartbeat,
             sessionHostRunnerPath: runners.sessionHost,
             legacySyncEnv: readLegacySyncEnv(platform),
+            instantSyncEnabled: daemonInstantSyncEnabled(env, config.instantSyncEnabled),
             signedIn: isSignedIn,
             kitConfigured: fs.existsSync(agentKitPaths(home, env).kitConfigPath),
             syncPaused: config.syncPaused === true,

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

@@ -2,9 +2,13 @@ import { readLanesRegistryFlag } from "./registry-flag.js";
 import type { LaneRecord } from "./types.js";
 export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
 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_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 interface RegisteredLead {
     team: string;
     lane: string;
@@ -12,7 +16,7 @@ export interface RegisteredLead {
     status: string;
     prd: string;
 }
-export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane";
+export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "stale_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane" | "missed_deadline";
 export interface AutopilotWake {
     condition: AutopilotCondition;
     lead_lane: string;
@@ -20,6 +24,23 @@ export interface AutopilotWake {
     worker_lane?: string;
     prompt: string;
     fingerprint: string;
+    kpi_id?: string;
+}
+export interface AutopilotKpiStatus {
+    lead_lane: string;
+    team: string;
+    kpi: string;
+    age_minutes: number | null;
+    stale: boolean;
+    stale_after_minutes: number;
+    status?: string;
+    error?: "invalid_kpi";
+}
+interface AutopilotDeadlineError {
+    lead_lane: string;
+    item_ref: string;
+    field: string;
+    reason: string;
 }
 export interface AutopilotPassResult {
     ok: true;
@@ -38,11 +59,23 @@ export interface AutopilotPassResult {
         story_id: string;
         at: string;
         fingerprint: string;
+        owner?: string;
+        due?: string;
+        miss_count?: number;
+    }>;
+    missed_deadlines?: Array<{
+        lead_lane: string;
+        item: string;
+        owner: string;
+        due: string;
+        miss_count: number;
     }>;
+    deadline_errors?: AutopilotDeadlineError[];
     skipped: Array<{
         lead_lane: string;
         reason: string;
     }>;
+    kpi_status?: AutopilotKpiStatus[];
     /** Set on an Outpost that has not received a lead registry from the primary yet. */
     registry?: "missing";
 }
@@ -54,6 +87,7 @@ interface ProjectStory {
     laneIds?: string[];
     updatedAt?: string;
     externalBlocker?: string;
+    deadlineFields?: Record<string, unknown>;
 }
 export declare function planLeadAutopilotWakes(input: {
     lead: LaneRecord;
@@ -62,6 +96,7 @@ export declare function planLeadAutopilotWakes(input: {
     now: Date;
     managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
+    kpiStalenessEnabled?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {
     hqRoot: string;
@@ -71,7 +106,9 @@ export declare function runLeadAutopilotPass(input: {
     now: Date;
     dryRun?: boolean;
     readFlag?: typeof readLanesRegistryFlag;
+    readDeadlineFlag?: typeof readLanesRegistryFlag;
     keepAliveResumedLeads?: ReadonlySet<string>;
+    missedDeadlineEscalationDelayMs?: number;
     startWorker?: (input: {
         lead: LaneRecord;
         story: ProjectStory;