@indigoai-us/hq-cli 5.345.129 → 5.345.130

package/dist/commands/core-workflow-run-command.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+export declare const WORKFLOW_RUNNER_ASSET = "core/scripts/workflow-runner.mjs";
+export declare function registerCoreWorkflowRunCommand(core: Command): void;
+//# sourceMappingURL=core-workflow-run-command.d.ts.map

package/dist/commands/core-workflow-run-command.js

@@ -0,0 +1,41 @@
+import { resolveLiveRoot } from "../utils/hq-roots.js";
+import { runBundledScript } from "../utils/run-bundled-script.js";
+import { describeCoreCommand } from "./core-command-catalog.js";
+import { coreNativePipelineEnabled } from "./core-native-pipeline-flag.js";
+export const WORKFLOW_RUNNER_ASSET = "core/scripts/workflow-runner.mjs";
+export function registerCoreWorkflowRunCommand(core) {
+    const workflow = core.command("workflow").description("Workflow orchestration");
+    const command = workflow.command("run")
+        .description("Run a workflow script or pipeline lane")
+        .helpOption(false)
+        .allowUnknownOption()
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args, _options, current) => {
+        const argv = current.args.length > 0 ? current.args : args;
+        const root = resolveLiveRoot({ hqRoot: core.opts().hqRoot });
+        if (!await coreNativePipelineEnabled()) {
+            const result = runBundledScript({ asset: WORKFLOW_RUNNER_ASSET, args: argv, cwd: process.cwd(), hqRoot: root });
+            if (result.code !== 0)
+                process.exit(result.code);
+            return;
+        }
+        const previousRoot = process.env.HQ_ROOT;
+        process.env.HQ_ROOT = root;
+        try {
+            const native = await import("./core-pipeline-workflow-runner-native.js");
+            const runner = native;
+            const code = await runner.runWorkflowRunnerNative(argv, root);
+            if (code !== 0)
+                process.exit(code);
+        }
+        finally {
+            if (previousRoot === undefined)
+                delete process.env.HQ_ROOT;
+            else
+                process.env.HQ_ROOT = previousRoot;
+        }
+    });
+    describeCoreCommand(command, { execution: "native", asset: WORKFLOW_RUNNER_ASSET, root: "live" });
+}
+//# sourceMappingURL=core-workflow-run-command.js.map

package/dist/commands/core.js

@@ -52,6 +52,7 @@ import { registerCoreHookStateHelpers } from "./core-hook-state-helpers-native.j
 import { registerCoreHookBatchCommand } from "./core-hook-batch-command.js";
 import { registerCorePipelineWorkerTableCommand } from "./core-pipeline-workers-command.js";
 import { registerCorePipelineRuntimeCommands } from "./core-pipeline-conductor-command.js";
+import { registerCoreWorkflowRunCommand } from "./core-workflow-run-command.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";
 import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
@@ -304,6 +305,8 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/session-title.sh", root: "live", summary: "Rollback companion for native session title" },
     { asset: "core/scripts/session-title-config.sh", root: "live", summary: "Rollback companion for native session-title settings" },
     { asset: "core/scripts/pipeline-worker-table.sh", root: "live", summary: "Rollback companion for native pipeline worker-table" },
+    { asset: "core/scripts/workflow-runner.mjs", root: "live", summary: "Rollback companion for native workflow runner" },
+    { asset: "core/scripts/lib/codex-output-schema.mjs", root: "live", summary: "Schema helper required by the bundled workflow-runner rollback companion" },
     { asset: "core/scripts/share-suggestion-state.sh", root: "live", summary: "Rollback shell for native share-suggestion-state" },
     { asset: "core/scripts/repo-run-registry.sh", root: "live", summary: "Rollback shell for native repo-run-registry" },
     { asset: "core/scripts/detect-stale-review-base.sh", root: "live", summary: "Rollback shell for native detect-stale-review-base" },
@@ -456,6 +459,7 @@ export function registerCoreCommands(program) {
     registerCoreHookStateHelpers(core);
     registerCoreHookBatchCommand(core);
     registerCorePipelineRuntimeCommands(core);
+    registerCoreWorkflowRunCommand(core);
     const sessionHelperCommands = [
         {
             name: "session-journal", asset: "core/scripts/session-journal.sh", root: "live",

package/dist/commands/lanes-accounts.js

@@ -290,7 +290,6 @@ export function createLaneAccountsHandlers(deps) {
             balance_gate_enabled: balanceGateEnabled,
             accounts,
             selections,
-            lead_reserve_per_host: config.lead_reserve_per_host,
             queued_leads: loaded.snapshots.flatMap((host) => {
                 const leads = leadLaneIds(host.lanes);
                 return host.lanes

package/dist/lib/core-utils/workflow-runner-schema.d.ts

@@ -0,0 +1,7 @@
+/** Port of pipeline-envelope.sh normalize, including its candidate selection rules. */
+export declare function normalizeWorkflowRunnerEnvelope(raw: string): string;
+/** Makes a copy in Codex's strict structured-output dialect. */
+export declare function strictifySchemaForCodex(schema: unknown): unknown;
+/** Removes nulls that Codex had to add for originally optional properties. */
+export declare function stripStrictNulls(value: unknown, schema: unknown): unknown;
+//# sourceMappingURL=workflow-runner-schema.d.ts.map

package/dist/lib/core-utils/workflow-runner-schema.js

@@ -0,0 +1,259 @@
+function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function jsonDumps(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value))
+        return `[${value.map(jsonDumps).join(", ")}]`;
+    const entries = Object.entries(value);
+    return `{${entries.map(([key, child]) => `${JSON.stringify(key)}: ${jsonDumps(child)}`).join(", ")}}`;
+}
+function balancedJsonEnd(text, start) {
+    let depth = 0;
+    let inString = false;
+    for (let i = start; i < text.length; i += 1) {
+        const char = text[i];
+        if (inString) {
+            if (char === "\\")
+                i += 1;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        else if (char === "{" || char === "[")
+            depth += 1;
+        else if (char === "}" || char === "]") {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+            if (depth < 0)
+                return -1;
+        }
+    }
+    return -1;
+}
+/** Port of pipeline-envelope.sh normalize, including its candidate selection rules. */
+export function normalizeWorkflowRunnerEnvelope(raw) {
+    const text = raw.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+    const candidates = [];
+    const fence = /```[A-Za-z0-9_-]*\s*\n([\s\S]*?)```/g;
+    let match;
+    while ((match = fence.exec(text)) !== null) {
+        try {
+            const parsed = JSON.parse(match[1]?.trim() ?? "");
+            if (isJsonObject(parsed))
+                candidates.push(parsed);
+        }
+        catch { /* malformed fences are skipped by the shell normalizer */ }
+    }
+    if (candidates.length === 0) {
+        let offset = 0;
+        while (offset < text.length) {
+            const start = text.indexOf("{", offset);
+            if (start < 0)
+                break;
+            const end = balancedJsonEnd(text, start);
+            if (end > 0) {
+                try {
+                    const parsed = JSON.parse(text.slice(start, end));
+                    if (isJsonObject(parsed))
+                        candidates.push(parsed);
+                    offset = end;
+                    continue;
+                }
+                catch { /* continue scanning after this opening brace */ }
+            }
+            offset = start + 1;
+        }
+    }
+    if (candidates.length === 0)
+        throw new Error("normalize: no JSON object found");
+    if (candidates.length > 1) {
+        const tagged = candidates.filter((candidate) => candidate.schema === "hq-phase-handoff/v1" || candidate.schema === "hq-phase-envelope/v1");
+        if (tagged.length !== 1)
+            throw new Error(`normalize: ${candidates.length} JSON objects found, expected exactly one`);
+        return `${jsonDumps(tagged[0])}\n`;
+    }
+    return `${jsonDumps(candidates[0])}\n`;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function typesOf(node) {
+    if (node.type === undefined)
+        return [];
+    return Array.isArray(node.type) ? [...node.type] : [node.type];
+}
+function isObjectNode(node) {
+    const types = typesOf(node);
+    return types.length ? types.includes("object") : isRecord(node.properties);
+}
+const MAP_KEYS = ["properties", "$defs", "definitions"];
+const LIST_KEYS = ["anyOf", "oneOf", "allOf", "prefixItems"];
+const SINGLE_KEYS = ["items", "not", "if", "then", "else", "contains", "propertyNames"];
+function schemaError(at, message) {
+    return new Error(`codex output schema at ${at}: ${message}`);
+}
+function widenToNullable(node, at) {
+    if (!isRecord(node))
+        return;
+    const types = typesOf(node);
+    if (types.length) {
+        if (!types.includes("null"))
+            node.type = [...types, "null"];
+        if (Array.isArray(node.enum) && !node.enum.includes(null))
+            node.enum = [...node.enum, null];
+        return;
+    }
+    for (const key of ["anyOf", "oneOf"]) {
+        const branches = node[key];
+        if (!Array.isArray(branches) || branches.length === 0)
+            continue;
+        if (!branches.some((branch) => isRecord(branch) && typesOf(branch).includes("null")))
+            branches.push({ type: "null" });
+        return;
+    }
+    if (typeof node.$ref === "string" || Array.isArray(node.allOf)) {
+        const inner = { ...node };
+        for (const key of Object.keys(node))
+            delete node[key];
+        node.anyOf = [inner, { type: "null" }];
+        return;
+    }
+    if (isRecord(node.properties)) {
+        node.type = ["object", "null"];
+        return;
+    }
+    throw schemaError(at, "this property is optional (absent from `required`) but its schema declares neither a type nor a composition, so there is no way to express \"no answer\" in the strict dialect. Give it a type, or list it in `required`.");
+}
+function strictifyInPlace(node, at) {
+    if (Array.isArray(node)) {
+        node.forEach((child, index) => strictifyInPlace(child, `${at}[${index}]`));
+        return node;
+    }
+    if (!isRecord(node))
+        return node;
+    for (const key of MAP_KEYS) {
+        if (!isRecord(node[key]))
+            continue;
+        for (const [name, child] of Object.entries(node[key]))
+            strictifyInPlace(child, `${at}.${key}.${name}`);
+    }
+    for (const key of LIST_KEYS) {
+        if (Array.isArray(node[key]))
+            node[key].forEach((child, index) => strictifyInPlace(child, `${at}.${key}[${index}]`));
+    }
+    for (const key of SINGLE_KEYS)
+        if (node[key] !== undefined)
+            strictifyInPlace(node[key], `${at}.${key}`);
+    if (!isObjectNode(node))
+        return node;
+    if (node.additionalProperties !== undefined && node.additionalProperties !== false) {
+        throw schemaError(at, "strict structured output permits no dynamic keys, so `additionalProperties` must be false (got "
+            + `${JSON.stringify(node.additionalProperties)}). Model a map as an array of {key, value} entries, or run this agent on the grok or claude engine, which have no strict-schema flag.`);
+    }
+    node.additionalProperties = false;
+    if (typesOf(node).length === 0)
+        node.type = "object";
+    const props = isRecord(node.properties) ? node.properties : null;
+    if (!props)
+        return node;
+    const keys = Object.keys(props);
+    const declared = Array.isArray(node.required) ? node.required.filter((key) => typeof key === "string") : [];
+    const orphans = declared.filter((key) => !keys.includes(key));
+    if (orphans.length)
+        throw schemaError(at, `\`required\` lists ${orphans.map((key) => JSON.stringify(key)).join(", ")} with no matching property. Strict rejects a required name that is not in \`properties\`, and dropping it would leave the result validator demanding a key the model can no longer emit. Add the property, or remove the name from \`required\`.`);
+    const required = [];
+    for (const key of declared)
+        if (!required.includes(key))
+            required.push(key);
+    for (const key of keys) {
+        if (required.includes(key))
+            continue;
+        widenToNullable(props[key], `${at}.properties.${key}`);
+        required.push(key);
+    }
+    node.required = required;
+    return node;
+}
+/** Makes a copy in Codex's strict structured-output dialect. */
+export function strictifySchemaForCodex(schema) {
+    if (!isRecord(schema) && !Array.isArray(schema))
+        return schema;
+    return strictifyInPlace(JSON.parse(JSON.stringify(schema)), "<root>");
+}
+const MAX_REF_DEPTH = 16;
+function resolveRef(node, root, depth = 0) {
+    if (!isRecord(node) || typeof node.$ref !== "string" || depth >= MAX_REF_DEPTH || !isRecord(root))
+        return node;
+    const match = /^#\/(\$defs|definitions)\/([^/]+)$/.exec(node.$ref);
+    if (!match)
+        return node;
+    const bucket = root[match[1] ?? ""];
+    const target = isRecord(bucket) ? bucket[match[2] ?? ""] : undefined;
+    return isRecord(target) ? resolveRef(target, root, depth + 1) : node;
+}
+function allowsNull(node, root, depth = 0) {
+    const resolved = resolveRef(node, root, depth);
+    if (!isRecord(resolved))
+        return true;
+    const types = typesOf(resolved);
+    if (types.length)
+        return types.includes("null");
+    for (const key of ["anyOf", "oneOf"]) {
+        if (Array.isArray(resolved[key]))
+            return resolved[key].some((branch) => depth < MAX_REF_DEPTH && allowsNull(branch, root, depth + 1));
+    }
+    return isRecord(resolved.properties) ? false : true;
+}
+function effectiveSchema(node, root, depth = 0) {
+    const resolved = resolveRef(node, root, depth);
+    if (!isRecord(resolved))
+        return null;
+    for (const key of ["anyOf", "oneOf"]) {
+        if (!Array.isArray(resolved[key]))
+            continue;
+        const branches = resolved[key].map((branch) => resolveRef(branch, root, depth + 1))
+            .filter(isRecord).filter((branch) => !(typesOf(branch).length === 1 && typesOf(branch)[0] === "null"));
+        if (branches.length !== 1 || depth >= MAX_REF_DEPTH)
+            return null;
+        return effectiveSchema(branches[0], root, depth + 1);
+    }
+    return resolved;
+}
+function stripInPlace(value, schema, root, depth = 0) {
+    const effective = effectiveSchema(schema, root, depth);
+    if (!effective)
+        return value;
+    if (Array.isArray(value)) {
+        if (effective.items !== undefined)
+            value.forEach((item) => stripInPlace(item, effective.items, root, depth + 1));
+        return value;
+    }
+    if (!isRecord(value))
+        return value;
+    const props = isRecord(effective.properties) ? effective.properties : null;
+    if (!props)
+        return value;
+    const required = Array.isArray(effective.required) ? effective.required : [];
+    for (const [key, sub] of Object.entries(props)) {
+        if (!(key in value))
+            continue;
+        if (value[key] === null && !required.includes(key) && !allowsNull(sub, root)) {
+            delete value[key];
+            continue;
+        }
+        stripInPlace(value[key], sub, root, depth + 1);
+    }
+    return value;
+}
+/** Removes nulls that Codex had to add for originally optional properties. */
+export function stripStrictNulls(value, schema) {
+    if (!isRecord(schema) || value === null || typeof value !== "object")
+        return value;
+    return stripInPlace(JSON.parse(JSON.stringify(value)), schema, schema);
+}
+//# sourceMappingURL=workflow-runner-schema.js.map

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

@@ -9,10 +9,14 @@
 import * as fs from "node:fs";
 import { type AccountConfig, type LaneProvider, type LanesConfig, type RunawaySearchGuardConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
 export declare const LANES_CONFIG_REL: string;
-export declare const DEFAULT_MAX_QUEUED = 3;
-export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
-export declare const DEFAULT_CPU_BUSY_RESUME = 0.7;
-export declare 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 declare const UNLIMITED_LANES: number;
+export declare const DEFAULT_MAX_QUEUED: number;
 /**
  * Owner directive 2026-09-22: "if it's been an hour since last msg, always
  * run compact". Override per provider with `compact_after_ms`.

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/reconcile.js

@@ -8,7 +8,7 @@
 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";
@@ -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";
@@ -2045,7 +2045,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 +2139,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 +2146,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") {