@indigoai-us/hq-cli 5.157.0 → 5.159.0

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

@@ -27,7 +27,7 @@ export declare const MAX_SENTRY_REPORT_METADATA_VALUE_BYTES = 256;
  * is owner-approved telemetry for the exact hook script and may include a
  * company directory; it is never a substitute for hook input or a transcript.
  */
-export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence"];
+export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence"];
 export declare const MAX_SENTRY_REPORT_METADATA_KEYS: number;
 export type HookSequenceEntry = {
     script: string;

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

@@ -45,11 +45,26 @@ const HOOK_TIMEOUT_WARNING_METRIC = "hq.hook_timeout_warning";
 const HOOK_TIMEOUT_EXCEEDED_METRIC = "hq.hook_timeout_exceeded";
 const HOOK_TIMEOUT_EXCEEDED_FINGERPRINT = "hook-timeout-exceeded";
 const HOOK_TIMEOUT_WARNING_FINGERPRINT = "hook-timeout";
+const HOOK_TIMEOUT_MACHINE_WIDE_FINGERPRINT = "hq-hook-slow";
 const MAX_HOOK_SEQUENCE_ENTRIES = 20;
 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;
 const RATE_LIMIT_LOCK_STALE_MS = 5_000;
+const KNOWN_HOOK_SCRIPTS = new Set([
+    "master-hook.sh",
+    "hook-gate.sh",
+    "hook-timeout-watchdog.sh",
+    "check-hq-update.sh",
+    "block-core-writes-bash.sh",
+    "block-core-writes.sh",
+    "block-hq-worktree-session.sh",
+    "inject-policy-on-trigger.sh",
+    "inject-local-context.sh",
+    "session-title.sh",
+    "45-lanes-senior-monitor.sh",
+    "lanes-senior-monitor-stop-gate.sh",
+]);
 /**
  * The only hook diagnostics that can be attached as metadata. The list omits
  * command text, prompts, payloads, company names, and repositories. `hook_path`
@@ -71,6 +86,9 @@ export const ALLOWED_SENTRY_REPORT_METADATA_KEYS = [
     "hq_version",
     "platform",
     "load_average",
+    "spawn_ms",
+    "slow_child",
+    "slow_child_ms",
     "exit_code",
     "final_elapsed_ms",
     "bash_env_set",
@@ -223,6 +241,9 @@ export function parseSentryReportEvent(stdin) {
                 ? boundedHookSequence(rawMetadata[key])
                 : rawMetadata[key];
     }
+    if (typeof metadata.slow_child === "string") {
+        metadata.slow_child = safeSlowChild(metadata);
+    }
     return {
         code: 0,
         event: {
@@ -311,6 +332,63 @@ function loadBucket(loadAverage) {
         return "10-20";
     return ">=20";
 }
+function parsedLoadAverage(metadata) {
+    const value = metadata.load_average;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    if (value === "unavailable")
+        return "unavailable";
+    const match = /^\s*\{?\s*([0-9]+(?:\.[0-9]+)?)/.exec(value);
+    if (!match)
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function operatingSystemName(metadata) {
+    const platform = stringMetadata(metadata, "platform", "").toLowerCase();
+    if (/windows|win32|mingw|msys|cygwin/.test(platform))
+        return "windows";
+    if (/darwin|macos|mac os/.test(platform))
+        return "macos";
+    if (/linux/.test(platform))
+        return "linux";
+    return "other";
+}
+function spawnMsBucket(metadata) {
+    const value = metadata.spawn_ms;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return "unavailable";
+    if (value < 100)
+        return "<100ms";
+    if (value < 500)
+        return "100-499ms";
+    if (value < 1_000)
+        return "500-999ms";
+    return ">=1000ms";
+}
+function safeSlowChild(metadata) {
+    const value = metadata.slow_child;
+    if (typeof value !== "string" || value.length === 0)
+        return "other";
+    const script = basenameFromPath(value);
+    return KNOWN_HOOK_SCRIPTS.has(script) ? script : "other";
+}
+function isMachineWideHookSlowness(metadata) {
+    const spawnMs = metadata.spawn_ms;
+    if (typeof spawnMs === "number" && Number.isFinite(spawnMs) && spawnMs >= 500)
+        return true;
+    if (!Array.isArray(metadata.hook_sequence))
+        return false;
+    const slowScripts = new Set();
+    for (const entry of metadata.hook_sequence) {
+        if (entry.ms < 20_000 || !SAFE_HOOK_SCRIPT.test(entry.script))
+            continue;
+        slowScripts.add(entry.script);
+    }
+    return slowScripts.size >= 3;
+}
 function bashEnvTag(metadata) {
     const value = metadata.bash_env_set;
     if (value === true || value === "set")
@@ -330,7 +408,8 @@ function hookTimeoutTags(event) {
         : undefined;
     const shell = stringMetadata(metadata, "shell");
     const nproc = metadata.nproc;
-    const loadAverage = metadata.load_average;
+    const loadAverage = parsedLoadAverage(metadata);
+    const slowChildMs = metadata.slow_child_ms;
     return {
         hook_event: hookEvent(metadata),
         hook_script: hookScript(metadata),
@@ -346,7 +425,14 @@ function hookTimeoutTags(event) {
         shell: safeTagValue(shell),
         bash_env: bashEnvTag(metadata),
         cwd_kind: safeMetadataTag(metadata, "cwd_kind"),
-        load_bucket: typeof loadAverage === "number" ? loadBucket(loadAverage) : "unknown",
+        os_name: operatingSystemName(metadata),
+        load_bucket: loadAverage === "unavailable" ? "unavailable" : loadBucket(loadAverage),
+        spawn_ms_bucket: spawnMsBucket(metadata),
+        slow_child: safeSlowChild(metadata),
+        slow_child_ms_bucket: typeof slowChildMs === "number" && Number.isFinite(slowChildMs)
+            ? elapsedBucket(slowChildMs)
+            : "unknown",
+        machine_wide: isMachineWideHookSlowness(metadata) ? "true" : "false",
         nproc: typeof nproc === "number" || typeof nproc === "string"
             ? safeTagValue(String(nproc), SAFE_NPROC)
             : "unknown",
@@ -393,7 +479,20 @@ function hookTimeoutExceededOverrides(event) {
     const eventName = hookEvent(event.metadata);
     if (!isHookTimeoutEvent(event))
         return undefined;
-    if (hookTimeoutKind(event) === "warning") {
+    const kind = hookTimeoutKind(event);
+    if (isMachineWideHookSlowness(event.metadata)) {
+        return {
+            level: "warning",
+            fingerprint: [
+                HOOK_TIMEOUT_MACHINE_WIDE_FINGERPRINT,
+                "machine-wide",
+                operatingSystemName(event.metadata),
+                eventName,
+                kind,
+            ],
+        };
+    }
+    if (kind === "warning") {
         return {
             level: "warning",
             fingerprint: [HOOK_TIMEOUT_WARNING_FINGERPRINT, eventName, hookScript(event.metadata)],
@@ -536,7 +635,11 @@ function pruneExpiredRateLimitState(directory, now, protectedStatePath) {
 }
 function timeoutRateLimitLease(event, kind, options, dependencies) {
     const sessionId = stringMetadata(event.metadata, "session_id");
-    const key = `${sessionId}\0${hookEvent(event.metadata)}\0${hookScript(event.metadata)}\0${kind}`;
+    const machineWide = isMachineWideHookSlowness(event.metadata);
+    const classification = machineWide
+        ? `machine-wide\0${operatingSystemName(event.metadata)}`
+        : `per-script\0${hookScript(event.metadata)}`;
+    const key = `${sessionId}\0${hookEvent(event.metadata)}\0${kind}\0${classification}`;
     const directory = rateLimitDirectory(options, dependencies);
     const statePath = rateLimitStatePath(directory, key);
     const releaseLock = acquireRateLimitLock(directory);

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

@@ -13,6 +13,8 @@ export declare function laneRunsOnHost(lane: LaneRecord, host: AdmissionHost): b
 export declare function compareLaneQueueOrder(a: LaneRecord, b: LaneRecord): number;
 export declare function hasActiveAdmissionReservation(lane: LaneRecord, nowMs: number): boolean;
 export declare function hasActivePendingResume(lane: LaneRecord, nowMs: number): boolean;
+/** Whether a lane currently owns a running slot for its host/provider caps. */
+export declare function laneOccupiesRunningSlot(lane: LaneRecord, nowMs?: number): boolean;
 /** Return the first capacity limit that currently prevents this lane from starting. */
 export declare function laneAdmissionCapReason(lanes: LaneRecord[], candidate: LaneRecord, config: LanesConfig, host: AdmissionHost, profileMaxConcurrent?: number, nowMs?: number): AdmissionCapReason | undefined;
 /**

package/dist/lib/lanes/admission.js

@@ -139,12 +139,16 @@ export function hasActivePendingResume(lane, nowMs) {
     const ageMs = nowMs - reservedAt;
     return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;
 }
+/** Whether a lane currently owns a running slot for its host/provider caps. */
+export function laneOccupiesRunningSlot(lane, nowMs = Date.now()) {
+    return lane.state === "running" ||
+        hasActiveAdmissionReservation(lane, nowMs) ||
+        hasActivePendingResume(lane, nowMs);
+}
 /** Return the first capacity limit that currently prevents this lane from starting. */
 export function laneAdmissionCapReason(lanes, candidate, config, host, profileMaxConcurrent, nowMs = Date.now()) {
     const running = lanes.filter((lane) => lane.lane_id !== candidate.lane_id &&
-        (lane.state === "running" ||
-            hasActiveAdmissionReservation(lane, nowMs) ||
-            hasActivePendingResume(lane, nowMs)) &&
+        laneOccupiesRunningSlot(lane, nowMs) &&
         laneRunsOnHost(lane, host));
     const providerCfg = config.providers[candidate.provider];
     const providerRunning = running.filter((lane) => lane.provider === candidate.provider);

package/dist/lib/lanes/host-capacity.d.ts

@@ -0,0 +1,46 @@
+import type { LaneHost, LaneProvider, LaneRecord, LanesConfig } from "./types.js";
+export interface HostCapacityAccount {
+    enabled: boolean;
+    logged_in: boolean | null;
+    max_running: number;
+    running: number;
+    queued: number;
+}
+export interface HostCapacityProvider {
+    max_running: number;
+    max_queued: number;
+    running: number;
+    queued: number;
+    accounts: Record<string, HostCapacityAccount>;
+}
+export interface HostCapacitySnapshot {
+    schema_version: "hq-lanes-host-capacity.v1";
+    host: LaneHost;
+    sampled_at: string;
+    providers: Record<LaneProvider, HostCapacityProvider>;
+}
+export interface HostPlacementChoice {
+    host: LaneHost;
+    account: string;
+    queued: boolean;
+}
+/** Snapshot the same per-host running-slot predicate used by lane admission. */
+export declare function buildHostCapacitySnapshot(input: {
+    host: LaneHost;
+    lanes: readonly LaneRecord[];
+    config: LanesConfig;
+    existsSync: (path: string) => boolean;
+    now: Date;
+}): HostCapacitySnapshot;
+/** Reject malformed remote snapshots before they can influence host selection. */
+export declare function parseHostCapacitySnapshot(raw: unknown): HostCapacitySnapshot;
+/**
+ * Choose the least-loaded eligible host/account from advisory snapshots. The
+ * selected host still runs the shared admission check under its own lock.
+ */
+export declare function chooseHostForLane(snapshots: readonly HostCapacitySnapshot[], request: {
+    provider: LaneProvider;
+    account?: string;
+    allowedAccounts?: readonly string[];
+}): HostPlacementChoice;
+//# sourceMappingURL=host-capacity.d.ts.map

package/dist/lib/lanes/host-capacity.js

@@ -0,0 +1,173 @@
+import { accountStatus } from "./accounts.js";
+import { accountMaxRunning } from "./config.js";
+import { laneOccupiesRunningSlot, laneRunsOnHost, } from "./admission.js";
+import { LanesError } from "./errors.js";
+function admissionHost(host) {
+    return host.kind === "outpost"
+        ? { hostname: "", outpostId: host.id }
+        : { hostname: host.id, outpostId: null };
+}
+/** Snapshot the same per-host running-slot predicate used by lane admission. */
+export function buildHostCapacitySnapshot(input) {
+    const at = input.now.getTime();
+    const onHost = input.lanes.filter((lane) => laneRunsOnHost(lane, admissionHost(input.host)));
+    const providers = {};
+    for (const provider of ["claude", "codex", "grok"]) {
+        const providerConfig = input.config.providers[provider];
+        const providerLanes = onHost.filter((lane) => lane.provider === provider);
+        const running = providerLanes.filter((lane) => laneOccupiesRunningSlot(lane, at));
+        const queued = providerLanes.filter((lane) => lane.state === "queued");
+        const accounts = {};
+        for (const [id, account] of Object.entries(providerConfig.accounts)) {
+            const status = accountStatus(provider, id, input.config, {
+                existsSync: input.existsSync,
+            });
+            accounts[id] = {
+                enabled: account.enabled,
+                logged_in: status.logged_in,
+                max_running: accountMaxRunning(providerConfig, id),
+                running: running.filter((lane) => lane.account === id).length,
+                queued: queued.filter((lane) => lane.account === id).length,
+            };
+        }
+        providers[provider] = {
+            max_running: providerConfig.max_running,
+            max_queued: providerConfig.max_queued,
+            running: running.length,
+            queued: queued.length,
+            accounts,
+        };
+    }
+    return {
+        schema_version: "hq-lanes-host-capacity.v1",
+        host: input.host,
+        sampled_at: input.now.toISOString(),
+        providers,
+    };
+}
+function objectValue(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function requireCount(value, field, positive = false) {
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < (positive ? 1 : 0)) {
+        throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}`, {
+            field,
+            value: value ?? null,
+        });
+    }
+    return value;
+}
+/** Reject malformed remote snapshots before they can influence host selection. */
+export function parseHostCapacitySnapshot(raw) {
+    const root = objectValue(raw);
+    const hostRaw = objectValue(root?.host);
+    const providersRaw = objectValue(root?.providers);
+    if (root?.schema_version !== "hq-lanes-host-capacity.v1" ||
+        typeof root.sampled_at !== "string" ||
+        !Number.isFinite(Date.parse(root.sampled_at)) ||
+        (hostRaw?.kind !== "local" && hostRaw?.kind !== "outpost") ||
+        typeof hostRaw.id !== "string" ||
+        hostRaw.id.trim() === "" ||
+        providersRaw === undefined) {
+        throw new LanesError("host_capacity_invalid", "Malformed host capacity snapshot", {});
+    }
+    const providers = {};
+    for (const provider of ["claude", "codex", "grok"]) {
+        const row = objectValue(providersRaw[provider]);
+        const accountsRaw = objectValue(row?.accounts);
+        if (row === undefined || accountsRaw === undefined) {
+            throw new LanesError("host_capacity_invalid", `Missing capacity for ${provider}`, {
+                provider,
+            });
+        }
+        const accounts = {};
+        for (const [id, accountValue] of Object.entries(accountsRaw)) {
+            const account = objectValue(accountValue);
+            if (id.trim() === "" || account === undefined ||
+                typeof account.enabled !== "boolean" ||
+                !(account.logged_in === null || typeof account.logged_in === "boolean")) {
+                throw new LanesError("host_capacity_invalid", `Malformed ${provider} account capacity`, {
+                    provider,
+                    account: id,
+                });
+            }
+            accounts[id] = {
+                enabled: account.enabled,
+                logged_in: account.logged_in,
+                max_running: requireCount(account.max_running, `${provider}.${id}.max_running`, true),
+                running: requireCount(account.running, `${provider}.${id}.running`),
+                queued: requireCount(account.queued, `${provider}.${id}.queued`),
+            };
+        }
+        providers[provider] = {
+            max_running: requireCount(row.max_running, `${provider}.max_running`, true),
+            max_queued: requireCount(row.max_queued, `${provider}.max_queued`, true),
+            running: requireCount(row.running, `${provider}.running`),
+            queued: requireCount(row.queued, `${provider}.queued`),
+            accounts,
+        };
+    }
+    return {
+        schema_version: "hq-lanes-host-capacity.v1",
+        host: { kind: hostRaw.kind, id: hostRaw.id },
+        sampled_at: root.sampled_at,
+        providers,
+    };
+}
+/**
+ * Choose the least-loaded eligible host/account from advisory snapshots. The
+ * selected host still runs the shared admission check under its own lock.
+ */
+export function chooseHostForLane(snapshots, request) {
+    const candidates = [];
+    const allowed = request.account === undefined
+        ? request.allowedAccounts
+        : request.allowedAccounts === undefined
+            ? [request.account]
+            : request.allowedAccounts.filter((account) => account === request.account);
+    for (const snapshot of snapshots) {
+        const provider = snapshot.providers[request.provider];
+        if (!provider)
+            continue;
+        const accounts = Object.entries(provider.accounts)
+            .filter(([id, account]) => (allowed === undefined || allowed.includes(id)) &&
+            account.enabled &&
+            account.logged_in === true);
+        for (const [accountId, account] of accounts) {
+            const hasRunningSlot = provider.running < provider.max_running &&
+                account.running < account.max_running;
+            const hasQueueSlot = provider.queued < provider.max_queued;
+            if (!hasRunningSlot && !hasQueueSlot)
+                continue;
+            candidates.push({
+                host: snapshot.host,
+                account: accountId,
+                queued: !hasRunningSlot,
+                score: provider.running / provider.max_running +
+                    provider.queued / provider.max_queued +
+                    account.running / account.max_running,
+            });
+        }
+    }
+    candidates.sort((a, b) => Number(a.queued) - Number(b.queued) ||
+        a.score - b.score ||
+        `${a.host.kind}:${a.host.id}`.localeCompare(`${b.host.kind}:${b.host.id}`) ||
+        a.account.localeCompare(b.account));
+    const selected = candidates[0];
+    if (!selected) {
+        throw new LanesError("lane_placement_no_capacity", `No host has logged-in account capacity for ${request.provider}${request.account ? ` account ${request.account}` : ""}`, {
+            provider: request.provider,
+            ...(request.account !== undefined ? { account: request.account } : {}),
+            hosts: snapshots.map((snapshot) => ({
+                kind: snapshot.host.kind,
+                id: snapshot.host.id,
+            })),
+        });
+    }
+    return { host: selected.host, account: selected.account, queued: selected.queued };
+}
+//# sourceMappingURL=host-capacity.js.map

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

@@ -3,10 +3,12 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
+export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
+export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
+export type { HostCapacityAccount, HostCapacityProvider, HostCapacitySnapshot, HostPlacementChoice, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,8 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
+export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
+export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -7,7 +7,7 @@
  * `outpost_dispatch_failed`, never a queued lane nobody will pick up.
  */
 import { OutpostsClient } from "@indigoai-us/hq-cloud/outposts";
-import type { LaneRecord } from "./types.js";
+import type { LaneHost, LaneRecord } from "./types.js";
 export declare const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
 export declare const PICKUP_WAIT_MS: number;
 export interface OutpostPickupPayload {
@@ -57,6 +57,16 @@ export interface OutpostExecPort {
 export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPayload;
 /** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
+/** Bounded, read-only capacity query executed by the target Outpost CLI. */
+export declare function buildOutpostCapacityCommand(): string;
+/** Commit a queued lane move on the host that currently owns its state. */
+export declare function buildOutpostMoveTargetCommand(input: {
+    laneId: string;
+    host: LaneHost;
+    account: string;
+}): string;
+/** Idempotently backfill the marker on the selected Outpost. */
+export declare function buildOutpostIdentityBackfillCommand(expectedId: string): string;
 /** Build the same `hq outposts exec` remote command used by lane pickup. */
 export declare function buildOutpostLaneCommand(input: OutpostLaneCommand): string;
 export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{

package/dist/lib/lanes/outpost-dispatch.js

@@ -42,6 +42,35 @@ export function parseOutpostPickupPayload(raw) {
 export function buildOutpostPickupCommand(payloadUrl) {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "pickup", "--payload-url", payloadUrl]));
 }
+/** Bounded, read-only capacity query executed by the target Outpost CLI. */
+export function buildOutpostCapacityCommand() {
+    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "capacity", "--json"]));
+}
+/** Commit a queued lane move on the host that currently owns its state. */
+export function buildOutpostMoveTargetCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "move-target",
+        input.laneId,
+        "--host-kind",
+        input.host.kind,
+        "--host-id",
+        input.host.id,
+        "--account",
+        input.account,
+    ]));
+}
+/** Idempotently backfill the marker on the selected Outpost. */
+export function buildOutpostIdentityBackfillCommand(expectedId) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "outpost-identity-backfill-target",
+        "--expected-id",
+        expectedId,
+    ]));
+}
 /** Build the same `hq outposts exec` remote command used by lane pickup. */
 export function buildOutpostLaneCommand(input) {
     const args = ["hq", "lanes", input.action, input.laneId];
@@ -88,10 +117,17 @@ export async function dispatchOutpostPickup(port, input) {
         };
     }
     catch (err) {
+        const outcomeDetails = {
+            outpost_id: input.outpostId,
+            command_id: submitted.commandId,
+            done: false,
+            outcome_unknown: true,
+        };
         if (ac.signal.aborted) {
-            throw new LanesError("outpost_dispatch_failed", `Timed out waiting for Outpost pickup (${waitMs}ms)`, { outpost_id: input.outpostId, command_id: submitted.commandId });
+            throw new LanesError("outpost_dispatch_failed", `Timed out waiting for Outpost pickup (${waitMs}ms)`, outcomeDetails);
         }
-        throw err;
+        const message = dispatchErrorMessage(err);
+        throw new LanesError("outpost_dispatch_failed", `Failed waiting for Outpost pickup: ${message}`, { ...outcomeDetails, message });
     }
     finally {
         clearTimeout(timer);

package/dist/lib/lanes/outpost-identity.d.ts

@@ -0,0 +1,33 @@
+export declare const OUTPOST_ID_MARKER_PATH = "/etc/outpost/outpost-id";
+export declare const OUTPOST_ID_MARKER_DIR = "/etc/outpost";
+export type OutpostIdentityValue = {
+    kind: "id";
+    id: string;
+} | {
+    kind: "unknown";
+} | {
+    kind: "not_outpost";
+};
+export interface OutpostIdentityMarkerStore {
+    read(): OutpostIdentityValue;
+    /** Return false if another writer already created the marker. */
+    createIfMissing(id: string): boolean;
+}
+export interface OutpostIdentityMarkerWriterOptions {
+    markerDir?: string;
+    markerPath?: string;
+    run?: (input: {
+        id: string;
+        markerDir: string;
+        markerPath: string;
+        script: string;
+    }) => {
+        status: number | null;
+        error?: Error;
+        stderr?: string;
+    };
+}
+export declare function validateOutpostIdentityId(id: string): void;
+export declare function backfillOutpostIdentityMarker(expectedId: string, store: OutpostIdentityMarkerStore): "created" | "unchanged";
+export declare function createOutpostIdentityMarkerIfMissing(id: string, options?: OutpostIdentityMarkerWriterOptions): boolean;
+//# sourceMappingURL=outpost-identity.d.ts.map

package/dist/lib/lanes/outpost-identity.js

@@ -0,0 +1,59 @@
+import { spawnSync } from "node:child_process";
+import { LanesError } from "./errors.js";
+export const OUTPOST_ID_MARKER_PATH = "/etc/outpost/outpost-id";
+export const OUTPOST_ID_MARKER_DIR = "/etc/outpost";
+const SAFE_OUTPOST_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+export function validateOutpostIdentityId(id) {
+    if (id !== id.trim() || !SAFE_OUTPOST_ID.test(id)) {
+        throw new LanesError("outpost_identity_id_invalid", "Outpost identity must be a single-line id containing only letters, numbers, hyphens, or underscores", { value: id });
+    }
+}
+export function backfillOutpostIdentityMarker(expectedId, store) {
+    validateOutpostIdentityId(expectedId);
+    const current = store.read();
+    if (current.kind === "id") {
+        if (current.id !== expectedId) {
+            throw outpostIdentityMismatch(expectedId, current.id);
+        }
+        return "unchanged";
+    }
+    if (current.kind === "not_outpost") {
+        throw new LanesError("outpost_identity_not_host", `This host has no ${OUTPOST_ID_MARKER_DIR} directory; identity backfill only runs on an Outpost`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    let created;
+    try {
+        created = store.createIfMissing(expectedId);
+    }
+    catch (err) {
+        const after = store.read();
+        if (after.kind === "id" && after.id === expectedId)
+            return "unchanged";
+        if (after.kind === "id")
+            throw outpostIdentityMismatch(expectedId, after.id);
+        throw new LanesError("outpost_identity_backfill_failed", `Could not write ${OUTPOST_ID_MARKER_PATH}: ${err instanceof Error ? err.message : String(err)}`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    const after = store.read();
+    if (after.kind === "id") {
+        if (after.id !== expectedId)
+            throw outpostIdentityMismatch(expectedId, after.id);
+        return created ? "created" : "unchanged";
+    }
+    throw new LanesError("outpost_identity_backfill_failed", `Backfill did not create ${OUTPOST_ID_MARKER_PATH} with expected value ${expectedId}`, { expected_id: expectedId, marker_path: OUTPOST_ID_MARKER_PATH });
+}
+export function createOutpostIdentityMarkerIfMissing(id, options = {}) {
+    validateOutpostIdentityId(id);
+    const markerDir = options.markerDir ?? OUTPOST_ID_MARKER_DIR;
+    const markerPath = options.markerPath ?? OUTPOST_ID_MARKER_PATH;
+    const script = `umask 022; install -d -m 0755 "$2" && set -C && printf '%s\\n' "$1" > "$3"`;
+    const result = options.run?.({ id, markerDir, markerPath, script }) ?? spawnSync("sudo", ["-n", "sh", "-c", script, "hq-outpost-identity", id, markerDir, markerPath], { encoding: "utf8" });
+    if (result.error) {
+        throw new LanesError("outpost_identity_backfill_failed", `Could not run sudo to write ${OUTPOST_ID_MARKER_PATH}: ${result.error.message}`, { expected_id: id, marker_path: OUTPOST_ID_MARKER_PATH });
+    }
+    if (result.status === 0)
+        return true;
+    return false;
+}
+function outpostIdentityMismatch(expectedId, actualId) {
+    return new LanesError("outpost_identity_mismatch", `Refusing to replace ${OUTPOST_ID_MARKER_PATH}: it contains ${actualId}, expected ${expectedId}`, { expected_id: expectedId, actual_id: actualId, marker_path: OUTPOST_ID_MARKER_PATH });
+}
+//# sourceMappingURL=outpost-identity.js.map

package/dist/lib/lanes/spawn.js

@@ -1496,6 +1496,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const profile = existing.worker_profile
         ? loadWorkerProfile(hqRoot, existing.worker_profile)
         : undefined;
+    if (existing.host.kind === "outpost" &&
+        profile !== undefined &&
+        existing.worker_profile_hash !== profile.contentHash) {
+        throw new LanesError("worker_profile_hash_mismatch", `Worker profile ${JSON.stringify(existing.worker_profile)} on Outpost ${existing.host.id} changed after pickup validation`, {
+            lane_id: existing.lane_id,
+            worker: existing.worker_profile,
+            outpost: existing.host.id,
+            expected_hash: existing.worker_profile_hash ?? null,
+            actual_hash: profile.contentHash,
+        });
+    }
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === existing.provider;
     const profileModel = profileDefaultsApply ? profile.meta.model : undefined;
     const profileEffort = profileDefaultsApply ? profile.meta.effort : undefined;