@indigoai-us/hq-cli 5.345.129 → 5.345.131

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/commands/lanes-loop.d.ts

@@ -1,5 +1,19 @@
 import type { Ctx, LaneResumeOptions } from "./lanes-shared.js";
 import type { LaneRecord } from "../lib/lanes/types.js";
+/**
+ * A loop lane that finished a phase and is waiting for its next envelope is
+ * alive, not finished. The watcher still writes `done` when the phase's worker
+ * exits (the controller reads that as the phase-complete signal); this moves
+ * the lane back to `running`, the same state an admitted loop lane holds
+ * before its first phase. Only a stop makes a loop lane `done`.
+ */
+export declare function settleLoopLaneIdle(hqRoot: string, laneId: string): LaneRecord;
+/**
+ * The next phase resumes the provider session, which `hq lanes resume` only
+ * accepts from a resumable state. An idle loop lane sits in `running` with no
+ * worker, so it is handed to resume as the `done` lane the phase left.
+ */
+export declare function prepareIdleLoopLaneForResume(hqRoot: string, laneId: string): LaneRecord;
 export interface LoopControllerDeps {
     resumeLane(laneId: string, options: LaneResumeOptions): Promise<unknown>;
     interruptLane(laneId: string, reason: string, options: {

package/dist/commands/lanes-loop.js

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { LanesError } from "../lib/lanes/errors.js";
-import { readLane, retryUpdateLane } from "../lib/lanes/store.js";
+import { readLane, retryUpdateLane, updateLane } from "../lib/lanes/store.js";
+import { LanesError, isLaneVersionConflict } from "../lib/lanes/errors.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { raiseLaneQuestion } from "../lib/lanes/questions.js";
@@ -15,6 +15,43 @@ const LOOP_RUNS_REL = path.join("workspace", "lanes-runs");
 function loopRunDir(hqRoot, laneId) {
     return path.join(hqRoot, LOOP_RUNS_REL, laneId);
 }
+/**
+ * A loop lane that finished a phase and is waiting for its next envelope is
+ * alive, not finished. The watcher still writes `done` when the phase's worker
+ * exits (the controller reads that as the phase-complete signal); this moves
+ * the lane back to `running`, the same state an admitted loop lane holds
+ * before its first phase. Only a stop makes a loop lane `done`.
+ */
+export function settleLoopLaneIdle(hqRoot, laneId) {
+    return casLoopLaneState(hqRoot, laneId, "done", "running");
+}
+/**
+ * The next phase resumes the provider session, which `hq lanes resume` only
+ * accepts from a resumable state. An idle loop lane sits in `running` with no
+ * worker, so it is handed to resume as the `done` lane the phase left.
+ */
+export function prepareIdleLoopLaneForResume(hqRoot, laneId) {
+    return casLoopLaneState(hqRoot, laneId, "running", "done");
+}
+function casLoopLaneState(hqRoot, laneId, from, to) {
+    for (let attempt = 0;; attempt += 1) {
+        const current = readLane(hqRoot, laneId);
+        if (current.loop_mode !== true || current.state !== from)
+            return current;
+        try {
+            return updateLane(hqRoot, laneId, current.version, "command", (record) => ({
+                ...record,
+                state: to,
+                terminal_reason: undefined,
+                terminal_details: undefined,
+            }));
+        }
+        catch (error) {
+            if (!isLaneVersionConflict(error) || attempt >= 4)
+                throw error;
+        }
+    }
+}
 export function startLaneLoopController(ctx, laneId, initialAdmission = false) {
     const entry = process.argv[1];
     if (!entry)
@@ -151,6 +188,8 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                     }));
                 }
                 else {
+                    if (current.state === "running")
+                        current = prepareIdleLoopLaneForResume(hqRoot, laneId);
                     await deps.resumeLane(laneId, {
                         text: `Read ${briefPath} and follow it as the complete instruction for this phase.`,
                         project: current.project_id,
@@ -187,6 +226,8 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                             if (data.schema === "hq-phase-envelope/v1" && !handoff) {
                                 throw new Error("section 8 phase requires an hq-phase-handoff/v1 object in the lane envelope artifacts");
                             }
+                            if (latest.state === "done")
+                                settleLoopLaneIdle(hqRoot, laneId);
                             return { output: JSON.stringify(handoff ?? envelopeRecord.envelope), ...(latest.provider_session_id ? { sessionId: latest.provider_session_id } : {}) };
                         }
                         await new Promise((resolve) => setTimeout(resolve, 250));

package/dist/commands/lanes.js

@@ -46,8 +46,8 @@ import { registerDaemonLanesReconcileHandler } from "../lib/lanes/daemon-reconci
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
 import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, LANE_CONDUCT_LOOP_FLAG, LANE_ENVELOPE_REPAIR_GUIDANCE_FLAG, } from "../lib/lanes/flag-keys.js";
-import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
-import { commitIdleLoopStop, enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
+import { applyContinuitySettings, findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
+import { commitIdleLoopStop, enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopLaneIsIdle, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
 import { runLaneLoopController, startLaneLoopController } from "./lanes-loop.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
@@ -89,8 +89,9 @@ import { writeQuestionBody } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
-import { LedgerCorrupt, capacityOptionsFromEnv, readNow, rebuildNow, } from "../lib/capacity/ledger.js";
+import { LedgerCorrupt, capacityOptionsFromEnv, readCollectorMark, readNow, rebuildNow, } from "../lib/capacity/ledger.js";
 import { pickAccount } from "../lib/capacity/route.js";
+import { capacityViewAge } from "../lib/capacity/freshness.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
@@ -3436,6 +3437,8 @@ async function runCreate(ctx, opts) {
             ...(explicitProvider ? { providers: [explicitProvider] } : {}),
             model: opts.model ?? null,
             now: ctx.now(),
+            collectorEnabled: readCollectorMark(ledgerOptions)?.enabled ?? null,
+            capacityStale: capacityViewAge(view.generatedAt, ctx.now().getTime()).stale,
             lanesError: routeLanesError,
         });
         if (!result.ok || !result.pick) {
@@ -4102,6 +4105,7 @@ async function runCreate(ctx, opts) {
             providerEffort: config.providers[provider].effort,
             model,
         });
+        workerContinuity = applyContinuitySettings(workerContinuity, { project, model, effort: effort.effort });
         if (outpostId) {
             admission = { action: "queue" };
             validation = "pending";
@@ -8914,7 +8918,7 @@ async function runInterrupt(ctx, laneId, reason, options = {}) {
     const queueInterrupt = lane.loop_mode === true && options.preserveLoopQueue !== true
         ? interruptLoopQueue(runDir(hqRoot, lane.lane_id))
         : undefined;
-    if (lane.loop_mode === true && lane.state !== "running") {
+    if (lane.loop_mode === true && (lane.state !== "running" || loopLaneIsIdle(runDir(hqRoot, lane.lane_id), lane.lane_id))) {
         if (!options.quiet)
             printJson({ ok: true, action: "interrupt", lane_id: lane.lane_id, terminal: false, resumable: true, ...queueInterrupt });
         return;

package/dist/lib/capacity/freshness.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Capacity view freshness. Kept in lib (not commands/capacity.ts) so resident
+ * paths such as `hq lanes` can check staleness without pulling in the capacity
+ * command module and its lazy collector imports.
+ */
+/** now.json older than this is stale: the collector is not keeping the view current. */
+export declare const CAPACITY_STALE_MS: number;
+export interface CapacityViewAge {
+    stale: boolean;
+    /** Milliseconds since generatedAt; 0 when generatedAt is missing or unparseable. */
+    ageMs: number;
+    /** False when generatedAt is missing or unparseable. */
+    known: boolean;
+}
+/** Stale when generatedAt is missing or older than CAPACITY_STALE_MS. */
+export declare function capacityViewAge(generatedAt: string, nowMs: number): CapacityViewAge;
+//# sourceMappingURL=freshness.d.ts.map

package/dist/lib/capacity/freshness.js

@@ -0,0 +1,16 @@
+/**
+ * Capacity view freshness. Kept in lib (not commands/capacity.ts) so resident
+ * paths such as `hq lanes` can check staleness without pulling in the capacity
+ * command module and its lazy collector imports.
+ */
+/** now.json older than this is stale: the collector is not keeping the view current. */
+export const CAPACITY_STALE_MS = 5 * 60 * 1000;
+/** Stale when generatedAt is missing or older than CAPACITY_STALE_MS. */
+export function capacityViewAge(generatedAt, nowMs) {
+    const at = Date.parse(generatedAt);
+    if (Number.isNaN(at))
+        return { stale: true, ageMs: 0, known: false };
+    const ageMs = Math.max(0, nowMs - at);
+    return { stale: ageMs > CAPACITY_STALE_MS, ageMs, known: true };
+}
+//# sourceMappingURL=freshness.js.map

package/dist/lib/capacity/route.d.ts

@@ -23,6 +23,11 @@ export declare const LIMIT_STALE_MS: number;
 export declare const FRESH_MS: number;
 /** Score penalty for an account whose binding limit reading is not fresh. */
 export declare const OLD_READING_PENALTY = 10;
+/**
+ * Score for an account ranked with unknown usage (collector off or capacity
+ * view stale). Sits below any account with fresh known headroom.
+ */
+export declare const UNKNOWN_USAGE_SCORE = -100;
 /** Default --floor applied by the CLI (percent headroom to clear). */
 export declare const DEFAULT_FLOOR = 15;
 /** Default --prefer order applied by the CLI. */
@@ -78,6 +83,8 @@ export interface RouteRanked {
     weekly_resets_at: string | null;
     why: string;
     lane_flags: string;
+    /** True when no usable reading exists and the account is ranked as unknown. */
+    usage_unknown: boolean;
 }
 /** Live lane on an account the router would avoid; command names a replacement. */
 export interface RouteMove {

package/dist/lib/capacity/route.js

@@ -42,6 +42,11 @@ export const LIMIT_STALE_MS = 24 * 36e5;
 export const FRESH_MS = 60 * 6e4;
 /** Score penalty for an account whose binding limit reading is not fresh. */
 export const OLD_READING_PENALTY = 10;
+/**
+ * Score for an account ranked with unknown usage (collector off or capacity
+ * view stale). Sits below any account with fresh known headroom.
+ */
+export const UNKNOWN_USAGE_SCORE = -100;
 /** Default --floor applied by the CLI (percent headroom to clear). */
 export const DEFAULT_FLOOR = 15;
 /** Default --prefer order applied by the CLI. */
@@ -197,6 +202,37 @@ export function pickAccount(input) {
     const lanes = input.lanes ?? [];
     const ranked = [];
     const skipped = [];
+    // With the collector off (or its mark missing) or the view stale, readings
+    // never refresh. Missing or old readings then say nothing about the account,
+    // so a signed-in, enabled account is ranked as unknown instead of skipped.
+    const readingsUnreliable = input.collectorEnabled === false
+        || input.collectorEnabled === null
+        || input.capacityStale === true;
+    const rankUnknown = (base, accountId, tokenExpired) => {
+        const live = liveLaneCount(lanes, base.provider, accountId);
+        const whyParts = ["usage unknown, capacity readings are stale or the collector is off"];
+        if (live)
+            whyParts.push(`${live} live lane${live === 1 ? "" : "s"} already on it`);
+        if (tokenExpired)
+            whyParts.push("sign-in renews when the lane starts");
+        ranked.push({
+            provider: base.provider,
+            account: accountId,
+            label: base.label,
+            organization: base.organization,
+            headroom: 0,
+            score: UNKNOWN_USAGE_SCORE - live * LANE_PENALTY,
+            live_lanes: live,
+            reset_soon: false,
+            token_expired: tokenExpired,
+            reading_age_h: 0,
+            binding: { limit: "unknown", used_percent: 0, resets_at: null },
+            weekly_resets_at: null,
+            why: whyParts.join("; "),
+            lane_flags: `--provider ${base.provider} --account ${accountId}`,
+            usage_unknown: true,
+        });
+    };
     for (const provider of input.view.providers) {
         const providerId = provider.provider;
         if (!isLaneProvider(providerId))
@@ -247,6 +283,10 @@ export function pickAccount(input) {
                 ? Math.max(0, nowMs - observedMs)
                 : Infinity;
             if (accountAge > STALE_SKIP_MS) {
+                if (readingsUnreliable) {
+                    rankUnknown(base, laneMatch.id, tokenExpired);
+                    continue;
+                }
                 skipped.push({
                     ...base,
                     reason: "no reading in the last 24 hours",
@@ -313,6 +353,10 @@ export function pickAccount(input) {
             }
             const known = viewRows.filter((row) => typeof row.used === "number");
             if (known.length === 0) {
+                if (readingsUnreliable) {
+                    rankUnknown(base, laneMatch.id, tokenExpired);
+                    continue;
+                }
                 skipped.push({
                     ...base,
                     reason: "no usage numbers for this account in the last day",
@@ -376,6 +420,7 @@ export function pickAccount(input) {
                 weekly_resets_at: weekly?.resetsAt ?? null,
                 why: whyParts.join("; "),
                 lane_flags: `--provider ${providerId} --account ${laneMatch.id}`,
+                usage_unknown: false,
             });
         }
     }
@@ -401,7 +446,7 @@ export function pickAccount(input) {
             bad.set(`${row.provider}:${row.account}`, row.reason);
     }
     for (const row of ranked) {
-        if (row.headroom < floor) {
+        if (!row.usage_unknown && row.headroom < floor) {
             bad.set(`${row.provider}:${row.account}`, `${row.binding.limit} has ${row.headroom}% left`);
         }
     }

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`.