@indigoai-us/hq-cli 5.314.0 → 5.316.0

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

@@ -0,0 +1,254 @@
+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 localHostname = input.hostname?.trim();
+    const onHost = input.lanes.filter((lane) => laneRunsOnHost(lane, admissionHost(input.host)) ||
+        (input.host.kind === "outpost" &&
+            localHostname !== undefined &&
+            localHostname !== "" &&
+            lane.host.kind === "local" &&
+            lane.host.id === localHostname));
+    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,
+                ...(input.probe !== undefined ? { probe: input.probe } : {}),
+                ...(input.env !== undefined ? { env: input.env } : {}),
+                ...(input.hostname !== undefined ? { hostname: input.hostname } : {}),
+            });
+            const accountLanes = providerLanes.filter((lane) => lane.account === id);
+            const liveLanes = accountLanes.filter((lane) => lane.state === "running" || lane.state === "queued" || lane.state === "awaiting_input");
+            accounts[id] = {
+                enabled: account.enabled,
+                logged_in: status.logged_in,
+                auth_state: status.auth_state,
+                max_running: accountMaxRunning(providerConfig, id),
+                running: running.filter((lane) => lane.account === id).length,
+                queued: queued.filter((lane) => lane.account === id).length,
+                lane_counts: {
+                    running: liveLanes.filter((lane) => lane.state === "running").length,
+                    queued: liveLanes.filter((lane) => lane.state === "queued").length,
+                    awaiting_input: liveLanes.filter((lane) => lane.state === "awaiting_input").length,
+                    live: liveLanes.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") ||
+                (account.auth_state !== undefined &&
+                    !["file", "status", "absent", "unknown", "home_missing"].includes(account.auth_state))) {
+                throw new LanesError("host_capacity_invalid", `Malformed ${provider} account capacity`, {
+                    provider,
+                    account: id,
+                });
+            }
+            accounts[id] = {
+                enabled: account.enabled,
+                logged_in: account.logged_in,
+                ...(account.auth_state !== undefined
+                    ? { auth_state: account.auth_state }
+                    : {}),
+                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`),
+                ...(account.lane_counts !== undefined
+                    ? { lane_counts: parseLaneCounts(account.lane_counts, `${provider}.${id}.lane_counts`) }
+                    : {}),
+                ...(account.usage !== undefined
+                    ? { usage: parseUsage(account.usage, `${provider}.${id}.usage`) }
+                    : {}),
+            };
+        }
+        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,
+    };
+}
+function parseLaneCounts(value, field) {
+    const counts = objectValue(value);
+    if (counts === undefined) {
+        throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}`, { field });
+    }
+    const running = requireCount(counts.running, `${field}.running`);
+    const queued = requireCount(counts.queued, `${field}.queued`);
+    const awaiting_input = requireCount(counts.awaiting_input, `${field}.awaiting_input`);
+    const live = requireCount(counts.live, `${field}.live`);
+    if (running + queued + awaiting_input !== live) {
+        throw new LanesError("host_capacity_invalid", `Inconsistent host capacity field ${field}`, {
+            field,
+            running,
+            queued,
+            awaiting_input,
+            live,
+        });
+    }
+    return { running, queued, awaiting_input, live };
+}
+function parseUsage(value, field) {
+    const usage = objectValue(value);
+    if (usage === undefined) {
+        throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}`, { field });
+    }
+    const parsed = {};
+    for (const key of ["five_hour_percent", "weekly_percent"]) {
+        const percentage = usage[key];
+        if (percentage !== undefined) {
+            if (typeof percentage !== "number" || !Number.isFinite(percentage) || percentage < 0 || percentage > 100) {
+                throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}.${key}`, {
+                    field: `${field}.${key}`,
+                    value: percentage ?? null,
+                });
+            }
+            parsed[key] = percentage;
+        }
+    }
+    if (Object.keys(parsed).length === 0) {
+        throw new LanesError("host_capacity_invalid", `Empty host capacity field ${field}`, { field });
+    }
+    if (usage.sampled_at !== undefined) {
+        if (typeof usage.sampled_at !== "string" || !Number.isFinite(Date.parse(usage.sampled_at))) {
+            throw new LanesError("host_capacity_invalid", `Invalid host capacity field ${field}.sampled_at`, {
+                field: `${field}.sampled_at`,
+                value: usage.sampled_at ?? null,
+            });
+        }
+        parsed.sampled_at = usage.sampled_at;
+    }
+    return parsed;
+}
+/**
+ * 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/hq-root.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HQ-root resolution for `hq lanes` only (not a global findHqRoot change).
+ *
+ * `findHqRoot` walks for `.claude` or `workers` and ignores `$HQ_ROOT`. Every
+ * git worktree under `workspace/worktrees/` has its own `.claude`, so a
+ * `lanes` command run from a worktree silently operates on an empty store.
+ * The drain hook, watcher, and reconcile timer already read `$HQ_ROOT`.
+ *
+ * Precedence: `$HQ_ROOT` → `$CLAUDE_PROJECT_DIR` → walk up with `isHqRoot`
+ * (`companies/` plus `.claude`|`core`|`personal`). A `.claude`-only worktree
+ * is never a match. Missing both an explicit root and a real HQ tree is an
+ * error — never an empty successful list against the wrong directory.
+ */
+export interface LanesHqRootOpts {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}
+export declare function resolveLanesHqRoot(opts?: LanesHqRootOpts): string;
+//# sourceMappingURL=hq-root.d.ts.map

package/dist/lib/lanes/hq-root.js

@@ -0,0 +1,28 @@
+/**
+ * HQ-root resolution for `hq lanes` only (not a global findHqRoot change).
+ *
+ * `findHqRoot` walks for `.claude` or `workers` and ignores `$HQ_ROOT`. Every
+ * git worktree under `workspace/worktrees/` has its own `.claude`, so a
+ * `lanes` command run from a worktree silently operates on an empty store.
+ * The drain hook, watcher, and reconcile timer already read `$HQ_ROOT`.
+ *
+ * Precedence: `$HQ_ROOT` → `$CLAUDE_PROJECT_DIR` → walk up with `isHqRoot`
+ * (`companies/` plus `.claude`|`core`|`personal`). A `.claude`-only worktree
+ * is never a match. Missing both an explicit root and a real HQ tree is an
+ * error — never an empty successful list against the wrong directory.
+ */
+import { resolveLiveRoot } from "../../utils/hq-roots.js";
+import { LanesError } from "./errors.js";
+export function resolveLanesHqRoot(opts = {}) {
+    try {
+        return resolveLiveRoot({
+            env: opts.env ?? process.env,
+            cwd: opts.cwd,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new LanesError("hq_root_unresolved", message, {});
+    }
+}
+//# sourceMappingURL=hq-root.js.map

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

@@ -0,0 +1,76 @@
+/**
+ * Library layer for `hq lanes`. The command module should import from here.
+ */
+export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
+export { MAX_LANE_DEPTH } from "./constants.js";
+export { assignedChildHireGrants, aliveDirectChildren, isFinishedResumableHireChild, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
+export type { HireGrantBackfillRow } from "./grants.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, LaneAccountSelection, LaneAccountSelectionConsidered, LaneAccountSelectionHostCount, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionPriority, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, WorkerProfileRepinHistoryEntry, LaneSettingsHistoryEntry, 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";
+export { resolveLanesHqRoot } from "./hq-root.js";
+export type { LanesHqRootOpts } from "./hq-root.js";
+export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
+export type { LaneStatusSnapshot, ProjectStoryLedger, StoryLedgerWriteDeps } from "./story-ledger.js";
+export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
+export type { OutpostDispatchResult, OutpostPickupPayload, } from "./outpost-dispatch.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readAllLanes, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
+export type { StoreDeps } from "./store.js";
+export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
+export type { LaneWatchDeps, LaneWatchResult } from "./watch.js";
+export { MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_TASK_OUTPUT_MAX_BYTES, MONITOR_TRANSCRIPT_MAX_BYTES, MONITOR_UNCOVERED_EXIT_CODE, coveredLaneIds, isMonitorTaskLive, monitorReminderText, parseCanonicalWatchCommand, parseMonitorTranscript, readLiveMonitorEvidence, } from "./monitor.js";
+export type { LiveMonitorEvidenceOptions, MonitorEngine, MonitorEvidence, MonitorEvidenceReader, MonitorTaskEvidence, } from "./monitor.js";
+export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
+export type { MachineIdentity, MachineIdentityDeps } from "./machine-identity.js";
+export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";
+export type { DetachProof, DetachedSpawnOptions, KillProcessFn, PidLivenessDecision, PidLivenessProbe, PidRecord, ProveDetachedDeps, ProveDetachedFn, SpawnLaneDeps, SpawnProcessFn, SpawnTerminalReason, StopLaneDeps, StopLaneResult, } from "./spawn.js";
+export { SILENCE_MS, WATCHER_DECISION_EVENTS, WATCHER_OUT_MAX_BYTES, WATCHER_POLL_MS, WATCHER_SIGNAL_KINDS, appendCappedLog, appendWatcherSignal, applyTerminalToLane, classifyLaneExit, clearLaneStalled, isPidAlive, laneIdentityFromRecord, markLaneStalled, notifySlotFreed, parseWatcherSignalKind, readLatestEnvelope, runWatcherLoop, stalledReason, tickWatcher, watcherEventsPath, watcherLastSignalPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
+export type { TerminalClassification, WatcherDecisionEvent, WatcherLoopDeps, WatcherSignal, WatcherSignalKind, WatcherTickInput, WatcherTickResult, } from "./watcher.js";
+export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQuestionIds, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
+export type { EnvelopeRepairDecision, LatestEnvelopeFile } from "./watcher.js";
+export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
+export type { CreateLaneMeshOptions, LaneMesh, LaneMeshEvent, WireEventKind, WireThreadEvent, } from "./mesh-events.js";
+export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
+export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
+export { effectiveAccountHome, } from "./account-home.js";
+export type { EffectiveAccountHome, } from "./account-home.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } from "./accounts.js";
+export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
+export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export type { AnsweredLaneWakeResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
+export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
+export type { ProviderPathEnv, ReconcileInstallOpts, ReconcileInstallResult, RunCommand, RunCommandResult, } from "./reconcile-install.js";
+export { unitPathEnv } from "./reconcile-install.js";
+export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeResultRejection, parseCodexTurnFailed, parseGrokErrorOutput, parseProviderRejection, readProviderRejection, retryableFromStatus, } from "./provider-rejection.js";
+export type { ProviderRejection } from "./provider-rejection.js";
+export { CODEX_MODELS_CACHE_NAME, MODEL_PROBE_TIMEOUT_MS, claudeKnownModels, codexKnownModels, defaultProbe, grokKnownModels, knownModels, modelIsKnown, parseClaudeHelpModels, parseGrokModelsOutput, validateLaneModel, } from "./models.js";
+export type { KnownModels, KnownModelsDeps, ProbeCommand, ProbeResult } from "./models.js";
+export { SESSION_MOVE_REASON, copySessionFiles, encodeClaudeProjectDir, findCodexRollout, planClaudeSessionCopy, planCodexSessionCopy, planSessionCopy, } from "./move-account.js";
+export type { SessionCopyPlan, SessionCopyResult } from "./move-account.js";
+export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
+export { ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, materializeWorkerProfile, personalWorkerProfileDir, REGISTRY_PERSONA_PROMPT_MAX_CHARS, workerProfileMarker, workerProfilePrompt, } from "./profile.js";
+export { loadRegistryPersonaFromRecord, registryWorkerRecord, resolveRegistryPersona, } from "./registry-persona.js";
+export type { WorkerProfile, WorkerProfileMeta, WorkerProfileRuntime, } from "./profile.js";
+export type { RegistryPersona } from "./registry-persona.js";
+export type { RegistryWorkerEntry, ResolvedLaneWorker, WorkerTenancy, WorkerYaml, } from "./registry.js";
+export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
+export type { QuestionBody, RaiseLaneQuestionInput } from "./questions.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export type { DeliveryLane, LaneDeliveryMechanism, LaneShowDeliveryMechanism, LaunchPlan, LaunchTrigger, LaunchTriggerKind, ResumableLaneState, ResumeCommandState, SessionIdAbsentReason, WorkerRunResult, } from "./delivery.js";
+export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
+export type { DrainDeps, DrainHookResult, DropboxMessage, ToolActivityRecord, } from "./dropbox.js";
+export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";
+export type { DrainHookInstallResult, DrainHookRegistration, DrainHookRegistrationKind, DrainHookRegistrationProbe, MergeResult, } from "./hooks-install.js";
+export { EFFORT_SOURCES, PROVIDER_EFFORT_LEVELS, appendEffortFlag, defaultEffortForModel, parseCliEffort, parseConfigEffort, resolveLaneEffort, } from "./effort.js";
+export type { EffortSource, ResolvedEffort } from "./effort.js";
+export { COMPACTION_MECHANISM, COMPACTION_PROMPT, COMPACTION_TIMEOUT_MS, compactLaneSession, compactionAfterUsage, compactionDue, defaultRunCompaction, findSessionTranscript, probeCompactBoundaries, } from "./compaction.js";
+export type { CompactBoundaryProbe, CompactionDecision, CompactLaneSessionInput, RunCompactionFn, } from "./compaction.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/lanes/index.js

@@ -0,0 +1,42 @@
+/**
+ * Library layer for `hq lanes`. The command module should import from here.
+ */
+export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
+export { MAX_LANE_DEPTH } from "./constants.js";
+export { assignedChildHireGrants, aliveDirectChildren, isFinishedResumableHireChild, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.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";
+export { resolveLanesHqRoot } from "./hq-root.js";
+export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
+export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
+export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readAllLanes, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
+export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";
+export { MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_TASK_OUTPUT_MAX_BYTES, MONITOR_TRANSCRIPT_MAX_BYTES, MONITOR_UNCOVERED_EXIT_CODE, coveredLaneIds, isMonitorTaskLive, monitorReminderText, parseCanonicalWatchCommand, parseMonitorTranscript, readLiveMonitorEvidence, } from "./monitor.js";
+export { IMDS_HOST, IMDS_INSTANCE_ID_URL, IMDS_TIMEOUT_MS, IMDS_TOKEN_URL, defaultReadImdsInstanceId, resolveMachineIdentity, } from "./machine-identity.js";
+export { LANES_RUNS_REL as SPAWN_LANES_RUNS_REL, PID_LIVENESS_DECISIONS, PROVIDER_COMMAND, PROVIDER_MODEL_FLAG, SPAWN_TERMINAL_REASONS, ANSWERED_QUESTIONS_FILE, appendModelFlag, armLaneWatcher, buildProviderCommand, parseCliModel, resolveLaneModel, defaultProveDetached, isPidRecordAlive, laneRunDir, missingPidProbe, nextEnvelopePath, markSpawnFailure, parsePidRecord, parseProcStat, parseSpawnTerminalReason, probePidRecord, readPidRecord, readProcStarttime, readProcStarttimeDetailed, readSpawnManifest, resumePrompt, envelopeInstruction, spawnLaneWorker, stopLaneProcesses, watcherMainPath, workerEnv, } from "./spawn.js";
+export { SILENCE_MS, WATCHER_DECISION_EVENTS, WATCHER_OUT_MAX_BYTES, WATCHER_POLL_MS, WATCHER_SIGNAL_KINDS, appendCappedLog, appendWatcherSignal, applyTerminalToLane, classifyLaneExit, clearLaneStalled, isPidAlive, laneIdentityFromRecord, markLaneStalled, notifySlotFreed, parseWatcherSignalKind, readLatestEnvelope, runWatcherLoop, stalledReason, tickWatcher, watcherEventsPath, watcherLastSignalPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
+export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQuestionIds, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
+export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
+export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
+export { effectiveAccountHome, } from "./account-home.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
+export { unitPathEnv } from "./reconcile-install.js";
+export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeResultRejection, parseCodexTurnFailed, parseGrokErrorOutput, parseProviderRejection, readProviderRejection, retryableFromStatus, } from "./provider-rejection.js";
+export { CODEX_MODELS_CACHE_NAME, MODEL_PROBE_TIMEOUT_MS, claudeKnownModels, codexKnownModels, defaultProbe, grokKnownModels, knownModels, modelIsKnown, parseClaudeHelpModels, parseGrokModelsOutput, validateLaneModel, } from "./models.js";
+export { SESSION_MOVE_REASON, copySessionFiles, encodeClaudeProjectDir, findCodexRollout, planClaudeSessionCopy, planCodexSessionCopy, planSessionCopy, } from "./move-account.js";
+export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorkerRegistryFile, registryPath, resolveContextBasePaths, resolveLaneWorker, resolveSkillFiles, tenancyFromRegistryPath, } from "./registry.js";
+export { ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, materializeWorkerProfile, personalWorkerProfileDir, REGISTRY_PERSONA_PROMPT_MAX_CHARS, workerProfileMarker, workerProfilePrompt, } from "./profile.js";
+export { loadRegistryPersonaFromRecord, registryWorkerRecord, resolveRegistryPersona, } from "./registry-persona.js";
+export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
+export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";
+export { EFFORT_SOURCES, PROVIDER_EFFORT_LEVELS, appendEffortFlag, defaultEffortForModel, parseCliEffort, parseConfigEffort, resolveLaneEffort, } from "./effort.js";
+export { COMPACTION_MECHANISM, COMPACTION_PROMPT, COMPACTION_TIMEOUT_MS, compactLaneSession, compactionAfterUsage, compactionDue, defaultRunCompaction, findSessionTranscript, probeCompactBoundaries, } from "./compaction.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,47 @@
+type KeepAliveAuditVerdict = "on_time" | "late" | "early_wake" | "message_wake" | "self_wake" | "early_by_keep_alive" | "not_restarted" | "waiting";
+interface KeepAliveAuditRestart {
+    at: string;
+    trigger: string;
+    caller: string | null;
+}
+interface KeepAliveAuditRow {
+    lane: string;
+    project: string;
+    profile: string | null;
+    stopped_at: string;
+    next_check_at: string | null;
+    due_at: string;
+    due_reason: "next_check_at" | "backoff";
+    restart: KeepAliveAuditRestart | null;
+    verdict: KeepAliveAuditVerdict;
+}
+interface KeepAliveAuditSummary {
+    by_verdict: Record<KeepAliveAuditVerdict, number>;
+    not_restarted: number;
+    late_over_10m: number;
+    early_wake_by_others: number;
+    self_wake: number;
+    stopped_and_not_restarted_on_their_own: number;
+}
+interface KeepAliveAuditError {
+    lane: string;
+    error: string;
+    path: string;
+    message: string;
+}
+export interface KeepAliveAuditResult {
+    ok: true;
+    since: string;
+    rows: KeepAliveAuditRow[];
+    errors: KeepAliveAuditError[];
+    summary: KeepAliveAuditSummary;
+}
+export declare function buildKeepAliveAudit(input: {
+    hqRoot: string;
+    now: Date;
+    since?: string;
+    laneId?: string;
+}): KeepAliveAuditResult;
+export declare function formatKeepAliveAuditText(result: KeepAliveAuditResult): string;
+export {};
+//# sourceMappingURL=keep-alive-audit.d.ts.map