@indigoai-us/hq-cli 5.345.129 → 5.345.131

package/dist/lib/lanes/config.js

@@ -13,10 +13,14 @@ import { parseConfigEffort } from "./effort.js";
 import { LanesConfigError } from "./errors.js";
 import { CONFIG_SCHEMA_VERSION, LANE_PROVIDERS, isLaneProvider, parseMajorSchema, } from "./types.js";
 export const LANES_CONFIG_REL = path.join("personal", "lanes", "config.json");
-export const DEFAULT_MAX_QUEUED = 3;
-export const DEFAULT_CPU_BUSY_PAUSE = 0.85;
-export const DEFAULT_CPU_BUSY_RESUME = 0.7;
-export const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
+/**
+ * Owner directive 2026-10-14: no default lane caps or CPU/memory admission
+ * gates. A provider has no running or queued limit unless the operator sets
+ * `max_running` / `max_queued` explicitly; this value stands for "no limit"
+ * and stays a finite integer so it survives JSON output.
+ */
+export const UNLIMITED_LANES = Number.MAX_SAFE_INTEGER;
+export const DEFAULT_MAX_QUEUED = UNLIMITED_LANES;
 /**
  * Owner directive 2026-09-22: "if it's been an hour since last msg, always
  * run compact". Override per provider with `compact_after_ms`.
@@ -69,9 +73,9 @@ export const DEFAULT_LIVENESS_WINDOWS = {
     silent_lost_ms: DEFAULT_SILENT_LOST_MS,
 };
 export const DEFAULT_PROVIDER_MAX_RUNNING = {
-    claude: 2,
-    codex: 4,
-    grok: 4,
+    claude: UNLIMITED_LANES,
+    codex: UNLIMITED_LANES,
+    grok: UNLIMITED_LANES,
 };
 export const DEFAULT_ACCOUNT_HOMES = {
     claude: "~/.claude",
@@ -152,14 +156,6 @@ function positiveInt(value, field, fallback) {
     }
     return value;
 }
-function nonNegativeInt(value, field, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
-        throw new LanesConfigError("invalid_config", `${field} must be a non-negative integer`, { field, value });
-    }
-    return value;
-}
 function positiveNumber(value, field, fallback) {
     if (value === undefined)
         return fallback;
@@ -168,9 +164,9 @@ function positiveNumber(value, field, fallback) {
     }
     return value;
 }
-function unitInterval(value, field, fallback) {
+function optionalUnitInterval(value, field) {
     if (value === undefined)
-        return fallback;
+        return undefined;
     if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
         throw new LanesConfigError("invalid_config", `${field} must be a number in [0, 1]`, { field, value });
     }
@@ -377,30 +373,35 @@ function parseProvider(provider, raw, deps) {
     }
     return parsed;
 }
+/**
+ * CPU and memory admission gates are opt-in. With no `throttle` keys set,
+ * admission never waits on CPU load or free memory.
+ */
 function parseThrottle(raw) {
     const obj = raw === undefined ? {} : raw;
     if (!isPlainObject(obj)) {
         throw new LanesConfigError("invalid_config", "throttle must be an object");
     }
-    const pause = unitInterval(obj.cpu_busy_pause, "throttle.cpu_busy_pause", DEFAULT_CPU_BUSY_PAUSE);
-    const resume = unitInterval(obj.cpu_busy_resume, "throttle.cpu_busy_resume", DEFAULT_CPU_BUSY_RESUME);
-    if (resume > pause) {
-        throw new LanesConfigError("invalid_config", "throttle.cpu_busy_resume must be <= throttle.cpu_busy_pause", { cpu_busy_pause: pause, cpu_busy_resume: resume });
+    const result = {};
+    const pause = optionalUnitInterval(obj.cpu_busy_pause, "throttle.cpu_busy_pause");
+    const resumeRaw = optionalUnitInterval(obj.cpu_busy_resume, "throttle.cpu_busy_resume");
+    if (pause !== undefined) {
+        const resume = resumeRaw ?? pause;
+        if (resume > pause) {
+            throw new LanesConfigError("invalid_config", "throttle.cpu_busy_resume must be <= throttle.cpu_busy_pause", { cpu_busy_pause: pause, cpu_busy_resume: resume });
+        }
+        result.cpu_busy_pause = pause;
+        result.cpu_busy_resume = resume;
     }
-    let minMem = DEFAULT_MIN_AVAILABLE_MEM_MB;
     if (obj.min_available_mem_mb !== undefined) {
         if (typeof obj.min_available_mem_mb !== "number" ||
             !Number.isFinite(obj.min_available_mem_mb) ||
             obj.min_available_mem_mb < 0) {
             throw new LanesConfigError("invalid_config", "throttle.min_available_mem_mb must be a non-negative number", { value: obj.min_available_mem_mb });
         }
-        minMem = obj.min_available_mem_mb;
+        result.min_available_mem_mb = obj.min_available_mem_mb;
     }
-    return {
-        cpu_busy_pause: pause,
-        cpu_busy_resume: resume,
-        min_available_mem_mb: minMem,
-    };
+    return result;
 }
 function parseLiveness(raw) {
     const obj = raw === undefined ? {} : raw;
@@ -458,16 +459,11 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
     return {
         schema_version: CONFIG_SCHEMA_VERSION,
         providers,
-        throttle: {
-            cpu_busy_pause: DEFAULT_CPU_BUSY_PAUSE,
-            cpu_busy_resume: DEFAULT_CPU_BUSY_RESUME,
-            min_available_mem_mb: DEFAULT_MIN_AVAILABLE_MEM_MB,
-        },
+        throttle: {},
         liveness: { ...DEFAULT_LIVENESS_WINDOWS },
         tracker: { checks: { ...DEFAULT_TRACKER_CHECKS } },
         runaway_search_guard: { ...DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG },
         low_disk_min_free_bytes: DEFAULT_LOW_DISK_MIN_FREE_BYTES,
-        lead_reserve_per_host: 1,
         codex_rollout_compress_after_hours: DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS,
         codex_rollout_delete_after_days: DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS,
         session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
@@ -508,7 +504,6 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
     }
     const compressAfterHours = positiveInt(raw.codex_rollout_compress_after_hours, "codex_rollout_compress_after_hours", DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS);
     const deleteAfterDays = positiveInt(raw.codex_rollout_delete_after_days, "codex_rollout_delete_after_days", DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS);
-    const leadReservePerHost = nonNegativeInt(raw.lead_reserve_per_host, "lead_reserve_per_host", 1);
     if (deleteAfterDays * 24 < compressAfterHours) {
         throw new LanesConfigError("invalid_config", "codex_rollout_delete_after_days must be at least codex_rollout_compress_after_hours / 24", { codex_rollout_compress_after_hours: compressAfterHours, codex_rollout_delete_after_days: deleteAfterDays });
     }
@@ -522,7 +517,6 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         tracker: { checks: parseTrackerChecks(raw.tracker) },
         runaway_search_guard: parseRunawaySearchGuard(raw.runaway_search_guard),
         low_disk_min_free_bytes: positiveInt(raw.low_disk_min_free_bytes, "low_disk_min_free_bytes", DEFAULT_LOW_DISK_MIN_FREE_BYTES),
-        lead_reserve_per_host: leadReservePerHost,
         codex_rollout_compress_after_hours: compressAfterHours,
         codex_rollout_delete_after_days: deleteAfterDays,
         session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),

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

@@ -12,7 +12,7 @@ export type { HostCapacityAccount, HostCapacityProvider, HostCapacitySnapshot, H
 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 { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, 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";

package/dist/lib/lanes/index.js

@@ -8,7 +8,7 @@ export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingR
 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 { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, 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, removeLaneFromProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";

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

@@ -188,6 +188,11 @@ export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
 export declare function commitIdleLoopStop(runDir: string, laneId: string, now?: () => Date): boolean;
 export declare function setLoopControllerPid(runDir: string, laneId: string, pid: number | undefined): void;
 export declare function clearLoopControllerPid(runDir: string, laneId: string, pid: number): void;
+/**
+ * True when a loop lane's controller is alive with no phase active: the lane
+ * finished its last phase and is waiting for the next envelope.
+ */
+export declare function loopLaneIsIdle(runDir: string, laneId: string): boolean;
 export declare function loopControllerIsAlive(runDir: string): boolean;
 /** Run queued phases serially. Sessions are isolated by story and provider. */
 export declare function runLoopLane(options: LoopRunnerOptions): Promise<LoopRunSummary>;

package/dist/lib/lanes/loop.js

@@ -648,6 +648,14 @@ export function clearLoopControllerPid(runDir, laneId, pid) {
     if (currentPid === pid)
         persistStatus(runDir, laneId, { pid: undefined });
 }
+/**
+ * True when a loop lane's controller is alive with no phase active: the lane
+ * finished its last phase and is waiting for the next envelope.
+ */
+export function loopLaneIsIdle(runDir, laneId) {
+    const status = loopStatus(runDir, laneId);
+    return status.state === "waiting" && status.active_envelope_id === null && loopControllerIsAlive(runDir);
+}
 export function loopControllerIsAlive(runDir) {
     let pid;
     try {

package/dist/lib/lanes/reconcile.js

@@ -8,11 +8,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parseUserYaml } from "../../utils/user-yaml-error.js";
-import { compareLaneQueueOrder, compareLaneQueueOrderWithLeads, freeClaudeAccountSlots, leadLaneIds, hasActiveAdmissionReservation, hasActivePendingResume, laneAdmissionCapReason, laneOccupiesRunningSlot, laneRunsOnHost, withAllLaneAdmissionLocks, } from "./admission.js";
+import { compareLaneQueueOrder, compareLaneQueueOrderWithLeads, leadLaneIds, hasActiveAdmissionReservation, hasActivePendingResume, laneAdmissionCapReason, laneOccupiesRunningSlot, laneRunsOnHost, withAllLaneAdmissionLocks, } from "./admission.js";
 import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
-import { loopStatus } from "./loop.js";
+import { loopLaneIsIdle, loopStatus } from "./loop.js";
 import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { laneDepthCap } from "./depth-cap.js";
@@ -33,7 +33,7 @@ import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolG
 import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, dueKeepAliveNextCheckMs, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { isFailedQuotaKeepAliveLane, providerSupportsSessionResume } from "./delivery.js";
 import { LANE_PROVIDERS, isIsoDateTime, isTerminalLaneState } from "./types.js";
-import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, loadQuotaState, readQuotaSignal, recordAccountQuota, } from "./quota.js";
+import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { deliverQuotaNotice, quotaLaneNotice } from "./quota-notice.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
@@ -1641,6 +1641,23 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 // Watcher owns terminal classification of a process that has just exited.
                 continue;
             }
+            if (lane.loop_mode === true && loopLaneIsIdle(runDir, lane.lane_id)) {
+                // An idle loop lane has no worker between phases. Its controller is
+                // alive and waiting for the next envelope, so the lane is not finished.
+                try {
+                    const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running" && current.last_host_report_at !== nowIso, (current) => ({ ...current, last_host_report_at: nowIso }), deps.dryRun);
+                    if (result.changed)
+                        summary.heartbeats.push(lane.lane_id);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `heartbeat CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+                continue;
+            }
             const hadPids = workerPid !== null || watcherPid !== null;
             if (!hadPids && nowMs - lastHostReportMs(lane) < DEAD_HOST_MS) {
                 try {
@@ -2045,7 +2062,6 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
     if (localQueued.length === 0 || deps.skipAdmissionWithoutCpuSample === true)
         return;
     const config = loadLanesConfig(hqRoot);
-    const admissionQuotaState = loadQuotaState(hqRoot);
     const candidateLeadIds = leadLaneIds(lanes);
     const flagReader = deps.readRegistryFlag ?? readLanesRegistryFlag;
     const leadAdmissionEnabledById = new Map();
@@ -2140,25 +2156,6 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
             }
         }
         const projected = [...running, ...spawned];
-        const laneResolution = lane.provider === "claude" ? resolveLaneCompany(hqRoot, lane) : undefined;
-        const laneCompany = laneResolution?.company ?? undefined;
-        const laneCompanyKey = laneCompany?.uid ?? laneCompany?.slug ?? lane.company?.uid ?? lane.company?.slug;
-        let reserveEnabled = false;
-        if (lane.provider === "claude" && laneCompanyKey) {
-            let enabled = leadFlagByCompany.get(laneCompanyKey);
-            if (!enabled) {
-                enabled = readLanesRegistryFlagFailOff(LANE_LEAD_ADMISSION_PRIORITY_FLAG, {
-                    company: laneCompany,
-                    ...(laneCompany && laneResolution ? { companyUidSource: laneCompanyUidSource(laneResolution.source) } : {}),
-                    env: deps.env,
-                }, flagReader);
-                leadFlagByCompany.set(laneCompanyKey, enabled);
-            }
-            reserveEnabled = await enabled;
-        }
-        const reserveBlocked = reserveEnabled && lane.provider === "claude" &&
-            !priorityLeads.has(lane.lane_id) &&
-            freeClaudeAccountSlots(projected, config, deps.host, now.getTime(), admissionQuotaState) <= config.lead_reserve_per_host;
         const alternateAccount = availableBalancedAccount(hqRoot, lane, projected, config, deps.host, profileMaxConcurrent, now.getTime());
         const admittedLane = alternateAccount !== undefined
             ? writeAdmissionAccount(hqRoot, lane, alternateAccount, deps.dryRun)
@@ -2166,10 +2163,7 @@ async function admitQueued(hqRoot, lanes, summary, deps, now, onlyLaneIds, exclu
         const baseCap = laneAdmissionCapReason(running, admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
         const currentCap = laneAdmissionCapReason([...running, ...spawned], admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
         let blockedBy;
-        if (reserveBlocked) {
-            blockedBy = "lead_reserve";
-        }
-        else if (currentCap !== undefined) {
+        if (currentCap !== undefined) {
             blockedBy = baseCap ?? "queue_position";
         }
         if (!blockedBy && !decision.admit)

package/dist/lib/lanes/throttle.js

@@ -13,7 +13,6 @@ import { execFileSync as nodeExecFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_MIN_AVAILABLE_MEM_MB, } from "./config.js";
 // Reconcile normally measures the interval between cumulative CPU snapshots.
 // A five-second window establishes a baseline or recovers from stale counters.
 export const CPU_SAMPLE_MS = 5_000;
@@ -294,17 +293,18 @@ export function evaluateThrottle(input) {
     const pause = input.throttle.cpu_busy_pause;
     const resume = input.throttle.cpu_busy_resume;
     const minMem = input.throttle.min_available_mem_mb;
+    // Each gate is opt-in: an unset threshold never blocks admission.
     let cpuBlocks = false;
-    if (input.cpuCheckEnabled && input.busy !== null) {
+    if (pause !== undefined && input.cpuCheckEnabled && input.busy !== null) {
         if (input.state.cpuPaused) {
-            cpuBlocks = input.busy > resume;
+            cpuBlocks = input.busy > (resume ?? pause);
         }
         else {
             cpuBlocks = input.busy >= pause;
         }
     }
     let memBlocks = false;
-    if (input.availableMemMb !== null) {
+    if (minMem !== undefined && input.availableMemMb !== null) {
         memBlocks = input.availableMemMb < minMem;
     }
     if (!cpuBlocks && !memBlocks) {
@@ -448,11 +448,7 @@ export function writeThrottleState(filePath, state, deps = defaultThrottleDeps()
         throw err;
     }
 }
-export async function decideAdmission(hqRoot, throttle = {
-    cpu_busy_pause: DEFAULT_CPU_BUSY_PAUSE,
-    cpu_busy_resume: DEFAULT_CPU_BUSY_RESUME,
-    min_available_mem_mb: DEFAULT_MIN_AVAILABLE_MEM_MB,
-}, deps = defaultThrottleDeps(), cpuBusyFraction, cpuObservation) {
+export async function decideAdmission(hqRoot, throttle = {}, deps = defaultThrottleDeps(), cpuBusyFraction, cpuObservation) {
     const filePath = throttleStatePath(hqRoot);
     const loaded = readThrottleState(filePath, deps);
     if (loaded === "unreadable") {

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

@@ -1055,10 +1055,11 @@ export interface ProviderConfig {
     quota_default_hold_ms?: number;
     accounts: Record<string, AccountConfig>;
 }
+/** Opt-in admission gates. An unset key means that gate is off. */
 export interface ThrottleConfig {
-    cpu_busy_pause: number;
-    cpu_busy_resume: number;
-    min_available_mem_mb: number;
+    cpu_busy_pause?: number;
+    cpu_busy_resume?: number;
+    min_available_mem_mb?: number;
 }
 /** Session liveness windows from spec §9. Missing keys keep these documented defaults. */
 export interface LivenessWindows {
@@ -1096,8 +1097,6 @@ export interface LanesConfig {
     runaway_search_guard?: RunawaySearchGuardConfig;
     /** Optional free-space threshold override for the low-disk admission gate. */
     low_disk_min_free_bytes?: number;
-    /** Claude account slots kept available per host for senior lead lanes. */
-    lead_reserve_per_host: number;
     /** Retention ages for Codex session rollout maintenance. */
     codex_rollout_compress_after_hours?: number;
     codex_rollout_delete_after_days?: number;

package/dist/lib/lanes/types.js

@@ -111,6 +111,7 @@ export const QUEUED_REASONS = [
     "throttle",
     "provider_binary_missing",
     "account_retry",
+    // Retired with lead_reserve_per_host; kept so older lane records still parse.
     "lead_reserve",
     "worker_profile_changed",
     "low_disk",

package/dist/lib/lanes/worker-continuity.d.ts

@@ -9,10 +9,22 @@ export interface WorkerContinuityLookup {
 export interface WorkerContinuityResult {
     previous?: LaneRecord;
     resumable: boolean;
-    fallbackReason?: "provider_unsupported" | "session_id_missing" | "state_unsafe" | "host_mismatch";
+    fallbackReason?: "provider_unsupported" | "session_id_missing" | "state_unsafe" | "host_mismatch" | "settings_mismatch";
 }
 export declare function sameLaneHost(left: LaneRecord["host"], right: LaneRecord["host"]): boolean;
 /** Select the prior worker lane within exactly one senior/company/provider scope. */
 export declare function findWorkerContinuityLane(lanes: readonly LaneRecord[], lookup: WorkerContinuityLookup): WorkerContinuityResult;
+export interface WorkerContinuitySettings {
+    project: LaneRecord["project_id"];
+    /** Resolved model for the new lane; undefined when the provider chooses. */
+    model?: string;
+    /** Resolved effort for the new lane; undefined when none is passed. */
+    effort?: string;
+}
+/**
+ * Refuse reuse when the earlier session ran under a different project, model,
+ * or effort. A prior lane that recorded no model does not match a pinned one.
+ */
+export declare function applyContinuitySettings(result: WorkerContinuityResult, settings: WorkerContinuitySettings): WorkerContinuityResult;
 export declare function workerContinuityPrompt(previous: LaneRecord, resultSummary?: string, resultRef?: string): string;
 //# sourceMappingURL=worker-continuity.d.ts.map

package/dist/lib/lanes/worker-continuity.js

@@ -65,6 +65,20 @@ export function findWorkerContinuityLane(lanes, lookup) {
     }
     return { previous, resumable: true };
 }
+/**
+ * Refuse reuse when the earlier session ran under a different project, model,
+ * or effort. A prior lane that recorded no model does not match a pinned one.
+ */
+export function applyContinuitySettings(result, settings) {
+    const previous = result.previous;
+    if (!result.resumable || !previous)
+        return result;
+    if (previous.project_id === settings.project && previous.model === settings.model &&
+        previous.effort === settings.effort) {
+        return result;
+    }
+    return { previous, resumable: false, fallbackReason: "settings_mismatch" };
+}
 export function workerContinuityPrompt(previous, resultSummary, resultRef) {
     const summary = resultSummary?.trim();
     const resultPath = resultRef?.trim()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.129",
+  "version": "5.345.131",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {