@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/lanes/effort.js

@@ -1,113 +0,0 @@
-/**
- * Effort (reasoning depth) per lane provider.
- *
- * Every provider CLI here tolerates or ignores a bad value in some way:
- * `claude --effort bogus` warns and runs at the default, and
- * `codex -c model_reasoning_effort=bogus` loads without complaint. hq-cli
- * therefore validates the value against each provider's own set before any
- * spawn, and refuses anything else with `invalid_effort`.
- *
- * Measured 2026-09-22:
- * - claude: `--effort <level>`; the CLI's own warning lists
- *   low, medium, high, xhigh, max.
- * - codex 0.155.1: `exec` has no effort flag. The config key
- *   `model_reasoning_effort` is set with `-c`. The value set is the
- *   binary's ReasoningEffort enum (minimal, low, medium, high, xhigh, max,
- *   ultra); per-model support is in ~/.codex/models_cache.json.
- * - grok 1.0.34: `--reasoning-effort <level>` (alias `--effort`); an unknown
- *   value is rejected with "use one of: xhigh, high, medium, low".
- */
-import { LanesConfigError, LanesError } from "./errors.js";
-export const PROVIDER_EFFORT_LEVELS = {
-    claude: ["low", "medium", "high", "xhigh", "max"],
-    codex: ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
-    grok: ["low", "medium", "high", "xhigh"],
-};
-export const EFFORT_SOURCES = [
-    "cli",
-    "profile",
-    "account",
-    "provider",
-    "default_rule",
-    "none",
-];
-function acceptedList(provider) {
-    return PROVIDER_EFFORT_LEVELS[provider].join(", ");
-}
-/** Validate `--effort` for a provider. Undefined in, undefined out. */
-export function parseCliEffort(provider, raw) {
-    if (raw === undefined)
-        return undefined;
-    const value = raw.trim();
-    const accepted = PROVIDER_EFFORT_LEVELS[provider];
-    if (!accepted.includes(value)) {
-        throw new LanesError("invalid_effort", `Invalid --effort ${JSON.stringify(raw)} for ${provider}. Accepted: ${acceptedList(provider)}`, { provider, value: raw, accepted: [...accepted] });
-    }
-    return value;
-}
-/** Validate an `effort` field from personal/lanes/config.json. */
-export function parseConfigEffort(provider, raw, field) {
-    const accepted = PROVIDER_EFFORT_LEVELS[provider];
-    if (typeof raw !== "string" || !accepted.includes(raw.trim())) {
-        throw new LanesConfigError("invalid_effort", `${field} must be one of ${acceptedList(provider)}`, { field, provider, value: raw, accepted: [...accepted] });
-    }
-    return raw.trim();
-}
-/**
- * Effort applied when nothing sets one. Owner directive 2026-09-22,
- * verbatim: "make sure opus and fable are used on low by default".
- * Keyed on the model already chosen for the lane; it does not pick a model.
- */
-export function defaultEffortForModel(model) {
-    if (model === undefined)
-        return undefined;
-    if (model.startsWith("claude-opus-") || model.startsWith("claude-fable-")) {
-        return "low";
-    }
-    return undefined;
-}
-/** Precedence: `--effort`, profile, account, provider, then the default rule. */
-export function resolveLaneEffort(input) {
-    if (input.cliEffort !== undefined)
-        return { effort: input.cliEffort, source: "cli" };
-    if (input.profileEffort !== undefined) {
-        return { effort: input.profileEffort, source: "profile" };
-    }
-    if (input.accountEffort !== undefined) {
-        return { effort: input.accountEffort, source: "account" };
-    }
-    if (input.providerEffort !== undefined) {
-        return { effort: input.providerEffort, source: "provider" };
-    }
-    const fallback = defaultEffortForModel(input.model);
-    if (fallback !== undefined)
-        return { effort: fallback, source: "default_rule" };
-    return { source: "none" };
-}
-/**
- * Add the provider's effort argument. Codex takes it as a config override,
- * which must precede the `--` that ends its options.
- */
-export function appendEffortFlag(provider, args, effort) {
-    if (effort === undefined)
-        return args;
-    const value = parseCliEffort(provider, effort);
-    switch (provider) {
-        case "claude":
-            return [...args, "--effort", value];
-        case "grok":
-            return [...args, "--reasoning-effort", value];
-        case "codex": {
-            const flag = ["-c", `model_reasoning_effort="${value}"`];
-            const end = args.indexOf("--");
-            if (end === -1)
-                return [...args, ...flag];
-            return [...args.slice(0, end), ...flag, ...args.slice(end)];
-        }
-        default: {
-            const _exhaustive = provider;
-            return _exhaustive;
-        }
-    }
-}
-//# sourceMappingURL=effort.js.map

package/dist/lib/lanes/envelope-repair-dispatch.d.ts

@@ -1,26 +0,0 @@
-import type { LaneRecord } from "./types.js";
-import type { EnvelopeRepairSpawnInput } from "./spawn.js";
-interface EnvelopeRepairDispatchResult {
-    error?: Error;
-    status: number | null;
-    signal: NodeJS.Signals | null;
-    stdout: string;
-    stderr: string;
-}
-interface EnvelopeRepairDispatchOptions {
-    encoding: "utf8";
-    timeout: number;
-    input: string;
-    env: NodeJS.ProcessEnv;
-}
-export interface EnvelopeRepairDispatchDeps {
-    env?: NodeJS.ProcessEnv;
-    spawnSync?: (command: string, args: string[], options: EnvelopeRepairDispatchOptions) => EnvelopeRepairDispatchResult;
-}
-/**
- * Dispatch repair into the currently installed CLI. A watcher can stay alive
- * across upgrades, so repair must not call its in-memory spawn implementation.
- */
-export declare function spawnEnvelopeRepairViaCurrentCli(hqRoot: string, lane: LaneRecord, input: EnvelopeRepairSpawnInput, deps?: EnvelopeRepairDispatchDeps): number;
-export {};
-//# sourceMappingURL=envelope-repair-dispatch.d.ts.map

package/dist/lib/lanes/envelope-repair-dispatch.js

@@ -1,74 +0,0 @@
-import { spawnSync as nodeSpawnSync } from "node:child_process";
-import * as path from "node:path";
-import { LanesError } from "./errors.js";
-/**
- * Dispatch repair into the currently installed CLI. A watcher can stay alive
- * across upgrades, so repair must not call its in-memory spawn implementation.
- */
-export function spawnEnvelopeRepairViaCurrentCli(hqRoot, lane, input, deps = {}) {
-    const request = {
-        lane_id: lane.lane_id,
-        input: {
-            ...(input.session_id !== undefined ? { session_id: input.session_id } : {}),
-            envelopePath: input.envelopePath,
-            error: input.error,
-            rawText: input.rawText,
-            ...(input.missing !== undefined ? { missing: input.missing } : {}),
-        },
-    };
-    const run = deps.spawnSync ?? ((command, args, options) => {
-        const result = nodeSpawnSync(command, args, options);
-        return {
-            ...(result.error !== undefined ? { error: result.error } : {}),
-            status: result.status,
-            signal: result.signal,
-            stdout: result.stdout ?? "",
-            stderr: result.stderr ?? "",
-        };
-    });
-    const env = deps.env ?? process.env;
-    const cliEntry = env.HQ_LANE_CLI_ENTRY?.trim();
-    if (!cliEntry || !path.isAbsolute(cliEntry) || path.resolve(cliEntry) !== cliEntry) {
-        throw new LanesError("repair_cli_entry_invalid", "Lane watcher has no valid absolute hq CLI entrypoint for envelope repair", { lane_id: lane.lane_id });
-    }
-    const result = run(process.execPath, [cliEntry, "lanes", "_spawn-envelope-repair"], {
-        encoding: "utf8",
-        timeout: 120_000,
-        input: JSON.stringify(request),
-        env: {
-            ...env,
-            HQ_ROOT: hqRoot,
-            HQ_NO_UPDATE_CHECK: "1",
-            HQ_TELEMETRY: "0",
-        },
-    });
-    if (result.error) {
-        throw new LanesError("repair_cli_spawn_failed", `Current hq CLI could not start the envelope repair: ${result.error.message}`, { lane_id: lane.lane_id });
-    }
-    if (result.status !== 0) {
-        const detail = result.stderr.trim() || `exit ${result.status ?? result.signal ?? "without status"}`;
-        throw new LanesError("repair_cli_failed", `Current hq CLI envelope repair failed: ${detail}`, { lane_id: lane.lane_id, status: result.status, signal: result.signal });
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(result.stdout);
-    }
-    catch (err) {
-        throw new LanesError("repair_cli_result_invalid", `Current hq CLI returned invalid envelope repair JSON: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id });
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        throw new LanesError("repair_cli_result_invalid", "Current hq CLI returned an invalid envelope repair result", { lane_id: lane.lane_id });
-    }
-    const response = parsed;
-    if (!Number.isInteger(response.pid) ||
-        Number(response.pid) <= 0 ||
-        !Array.isArray(response.profile_warnings) ||
-        !response.profile_warnings.every((warning) => Array.isArray(warning) && warning.every((field) => typeof field === "string"))) {
-        throw new LanesError("repair_cli_result_invalid", "Current hq CLI returned an invalid envelope repair result", { lane_id: lane.lane_id });
-    }
-    for (const warning of response.profile_warnings) {
-        input.onProfileWarning?.(warning);
-    }
-    return Number(response.pid);
-}
-//# sourceMappingURL=envelope-repair-dispatch.js.map

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

@@ -1,39 +0,0 @@
-/**
- * Distinguishable errors for the lanes library. `error` matches the spec's
- * JSON `error` field so the command layer can print `err.toJSON()` as-is.
- */
-export declare class LanesError extends Error {
-    readonly error: string;
-    readonly details: Record<string, unknown>;
-    constructor(error: string, message: string, details?: Record<string, unknown>);
-    toJSON(): Record<string, unknown>;
-}
-export declare function isLanesError(err: unknown): err is LanesError;
-/** Compare-and-set miss. Callers retry after re-reading the record. */
-export declare class LaneVersionConflict extends LanesError {
-    readonly expectedVersion: number;
-    readonly actualVersion: number;
-    readonly recordPath: string;
-    constructor(opts: {
-        path: string;
-        expectedVersion: number;
-        actualVersion: number;
-    });
-}
-export declare function isLaneVersionConflict(err: unknown): err is LaneVersionConflict;
-export declare class LaneNotFoundError extends LanesError {
-    constructor(kind: "lane" | "question", id: string);
-}
-export declare class LaneSchemaError extends LanesError {
-    constructor(message: string, details?: Record<string, unknown>);
-}
-export declare class LanesConfigError extends LanesError {
-    constructor(error: string, message: string, details?: Record<string, unknown>);
-}
-export declare class AccountResolutionError extends LanesError {
-    constructor(error: "unknown_account" | "account_disabled" | "no_enabled_account" | "account_model_unavailable" | "account_quota_exhausted", message: string, details?: Record<string, unknown>);
-}
-export declare class WorkerResolutionError extends LanesError {
-    constructor(error: "worker_not_found" | "worker_tenancy_unresolved" | "worker_not_available" | "worker_not_active" | "worker_id_conflict" | "worker_profile_invalid" | "worker_policy_invalid" | "worker_profile_ambiguous" | "package_workers_unmounted" | "worker_registry_unreadable" | "registry_worker_not_found" | "registry_worker_company_mismatch" | "registry_worker_inactive" | "registry_worker_invalid" | "registry_worker_unreadable" | "registry_worker_ambiguous", message: string, details?: Record<string, unknown>);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/lib/lanes/errors.js

@@ -1,72 +0,0 @@
-/**
- * Distinguishable errors for the lanes library. `error` matches the spec's
- * JSON `error` field so the command layer can print `err.toJSON()` as-is.
- */
-export class LanesError extends Error {
-    error;
-    details;
-    constructor(error, message, details = {}) {
-        super(message);
-        this.name = "LanesError";
-        this.error = error;
-        this.details = details;
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-    toJSON() {
-        return { error: this.error, ...this.details };
-    }
-}
-export function isLanesError(err) {
-    return err instanceof LanesError;
-}
-/** Compare-and-set miss. Callers retry after re-reading the record. */
-export class LaneVersionConflict extends LanesError {
-    expectedVersion;
-    actualVersion;
-    recordPath;
-    constructor(opts) {
-        super("version_conflict", `Lane record version conflict at ${opts.path}: expected ${opts.expectedVersion}, found ${opts.actualVersion}`, {
-            path: opts.path,
-            expected: opts.expectedVersion,
-            actual: opts.actualVersion,
-        });
-        this.name = "LaneVersionConflict";
-        this.expectedVersion = opts.expectedVersion;
-        this.actualVersion = opts.actualVersion;
-        this.recordPath = opts.path;
-    }
-}
-export function isLaneVersionConflict(err) {
-    return err instanceof LaneVersionConflict;
-}
-export class LaneNotFoundError extends LanesError {
-    constructor(kind, id) {
-        super(kind === "lane" ? "lane_not_found" : "question_not_found", `${kind} ${id} not found`, { [`${kind}_id`]: id });
-        this.name = "LaneNotFoundError";
-    }
-}
-export class LaneSchemaError extends LanesError {
-    constructor(message, details = {}) {
-        super("schema_error", message, details);
-        this.name = "LaneSchemaError";
-    }
-}
-export class LanesConfigError extends LanesError {
-    constructor(error, message, details = {}) {
-        super(error, message, details);
-        this.name = "LanesConfigError";
-    }
-}
-export class AccountResolutionError extends LanesError {
-    constructor(error, message, details = {}) {
-        super(error, message, details);
-        this.name = "AccountResolutionError";
-    }
-}
-export class WorkerResolutionError extends LanesError {
-    constructor(error, message, details = {}) {
-        super(error, message, details);
-        this.name = "WorkerResolutionError";
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/lib/lanes/flag-keys.d.ts

@@ -1,13 +0,0 @@
-/** hq-flags keys used by lane command behavior. */
-export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
-/** Enables one automatic continuation after a missing-envelope repair. */
-export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
-/** Enables missed-deadline lead nudges and second-miss operator escalation. */
-export declare const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
-/** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
-export declare const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
-export declare const LANE_MESSAGE_ROUTE_OWNER_HOST_DEFAULT_ENABLED = false;
-/** Enables stale manager-status KPI reporting and one-time lead nudges. */
-export declare const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
-export declare const LEAD_AUTOPILOT_KPI_STALENESS_DEFAULT_ENABLED = false;
-//# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -1,13 +0,0 @@
-/** hq-flags keys used by lane command behavior. */
-export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
-/** Enables one automatic continuation after a missing-envelope repair. */
-export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
-/** Enables missed-deadline lead nudges and second-miss operator escalation. */
-export const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
-/** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
-export const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
-export const LANE_MESSAGE_ROUTE_OWNER_HOST_DEFAULT_ENABLED = false;
-/** Enables stale manager-status KPI reporting and one-time lead nudges. */
-export const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
-export const LEAD_AUTOPILOT_KPI_STALENESS_DEFAULT_ENABLED = false;
-//# sourceMappingURL=flag-keys.js.map

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

@@ -1,29 +0,0 @@
-import { type LaneRecord } from "./types.js";
-import { LanesError } from "./errors.js";
-export type LaneHireGrantRow = Pick<LaneRecord, "lane_id" | "state" | "senior" | "hire_grant">;
-export declare function aliveDirectChildren<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string): T[];
-export declare function assignedChildHireGrants(children: readonly LaneHireGrantRow[], exceptLaneId?: string): number;
-export interface HireGrantAdmissionSnapshot {
-    parent: LaneHireGrantRow;
-    children: LaneHireGrantRow[];
-    parentGrant: number;
-    availableChildGrant: number;
-}
-/** Shared refusal logic for resuming a terminal lane under an active senior. */
-export declare function terminalChildResumeHireGrantError(current: LaneRecord, snapshot: HireGrantAdmissionSnapshot): LanesError | null;
-export declare function hireGrantCapacityError(parent: LaneHireGrantRow, children: readonly LaneHireGrantRow[]): LanesError;
-/** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
-export declare function withHireGrantAdmission<T>(hqRoot: string, parentLaneId: string, fn: (snapshot: HireGrantAdmissionSnapshot) => T, suppliedHierarchy?: readonly LaneHireGrantRow[], preferSuppliedLaneIds?: ReadonlySet<string>): T;
-export interface HireGrantBackfillRow {
-    lane_id: string;
-    existing_grant: number | null;
-    alive_children: number;
-    profile_max_concurrent: number | null;
-    allocated_child_grants: number;
-    proposed_grant: number;
-    grant_shortfall: number;
-    action: "set" | "unchanged";
-}
-/** Select alive manager lanes and calculate the non-destructive one-time backfill. */
-export declare function planHireGrantBackfill(lanes: readonly LaneRecord[], profileMaxConcurrent: ReadonlyMap<string, number>): HireGrantBackfillRow[];
-//# sourceMappingURL=grants.d.ts.map

package/dist/lib/lanes/grants.js

@@ -1,166 +0,0 @@
-import { isTerminalLaneState } from "./types.js";
-import { listLaneIds, readLane, withLaneHireLocks } from "./store.js";
-import { LanesError } from "./errors.js";
-export function aliveDirectChildren(lanes, parentLaneId) {
-    return lanes.filter((lane) => lane.senior.kind === "lane" &&
-        lane.senior.id === parentLaneId &&
-        !isTerminalLaneState(lane.state));
-}
-export function assignedChildHireGrants(children, exceptLaneId) {
-    return children.reduce((sum, child) => child.lane_id === exceptLaneId ? sum : sum + (child.hire_grant ?? 0), 0);
-}
-/** Shared refusal logic for resuming a terminal lane under an active senior. */
-export function terminalChildResumeHireGrantError(current, snapshot) {
-    if (!isTerminalLaneState(current.state))
-        return null;
-    const { parent, children, parentGrant, availableChildGrant } = snapshot;
-    if (isTerminalLaneState(parent.state)) {
-        return new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot resume child lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
-    }
-    if (children.length >= parentGrant)
-        return hireGrantCapacityError(parent, children);
-    const requestedGrant = current.hire_grant ?? 0;
-    if (requestedGrant > availableChildGrant) {
-        return new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining, but terminal child ${current.lane_id} needs ${requestedGrant} to resume. Ask its senior for more: write an ask envelope with the desired total grant and why; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`, {
-            senior_lane_id: parent.lane_id,
-            parent_grant: parentGrant,
-            alive_children: children.map((child) => child.lane_id),
-            assigned_child_grants: assignedChildHireGrants(children),
-            requested_hire_grant: requestedGrant,
-            available_hire_grant: availableChildGrant,
-            ask_guidance: {
-                envelope: "decision=ask; include the desired total grant and the reason",
-                senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
-            },
-        });
-    }
-    return null;
-}
-export function hireGrantCapacityError(parent, children) {
-    const grant = parent.hire_grant ?? 0;
-    const grantor = (parent.senior.kind === "lane" || parent.senior.kind === "session") &&
-        parent.senior.id
-        ? { kind: parent.senior.kind, id: parent.senior.id }
-        : null;
-    const grantorReason = grantor
-        ? undefined
-        : parent.senior.kind === "user"
-            ? "senior_is_user"
-            : "parent_senior_missing_id";
-    const capacity = children.length === grant
-        ? `is at its hire grant (${children.length} of ${grant} alive children)`
-        : `has exhausted its hire grant (${children.length} alive children; grant ${grant})`;
-    const grantCommand = `hq lanes grant ${parent.lane_id} --hire <n>`;
-    const authorityGuidance = grantor
-        ? `Its senior ${grantor.kind} ${grantor.id} can raise it with: ${grantCommand}`
-        : parent.senior.kind === "user"
-            ? `Its senior is the user and can raise it with: ${grantCommand}`
-            : `No senior is recorded, so an operator must resolve ownership before running: ${grantCommand}`;
-    const message = `Lane ${parent.lane_id} ${capacity}. ${authorityGuidance}`;
-    return new LanesError("hire_grant_exhausted", message, {
-        senior_lane_id: parent.lane_id,
-        parent_grant: grant,
-        alive_children: children.map((child) => child.lane_id),
-        alive_child_count: children.length,
-        grantor,
-        ...(grantorReason ? { grantor_reason: grantorReason } : {}),
-        message,
-        ask_guidance: {
-            envelope: "decision=ask; include the desired total grant and the reason",
-            senior_command: grantCommand,
-        },
-    });
-}
-/** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
-export function withHireGrantAdmission(hqRoot, parentLaneId, fn, suppliedHierarchy, preferSuppliedLaneIds = new Set()) {
-    return withLaneHireLocks(hqRoot, [parentLaneId], () => {
-        const ownerLanes = listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
-        let allLanes;
-        let parent;
-        if (suppliedHierarchy === undefined) {
-            parent = readLane(hqRoot, parentLaneId);
-            allLanes = ownerLanes;
-        }
-        else {
-            const byId = new Map(suppliedHierarchy.map((lane) => [lane.lane_id, lane]));
-            // The owner copy is authoritative for every lane it stores unless the
-            // caller supplied a freshly verified owner snapshot for that lane.
-            for (const lane of ownerLanes) {
-                if (!preferSuppliedLaneIds.has(lane.lane_id))
-                    byId.set(lane.lane_id, lane);
-            }
-            allLanes = [...byId.values()];
-            const suppliedParent = byId.get(parentLaneId);
-            if (!suppliedParent) {
-                throw new LanesError("hire_grant_context_invalid", `The dispatched hierarchy is missing senior lane ${parentLaneId}`, { senior_lane_id: parentLaneId });
-            }
-            parent = suppliedParent;
-        }
-        const children = aliveDirectChildren(allLanes, parentLaneId);
-        const parentGrant = parent.hire_grant ?? 0;
-        const availableChildGrant = Math.max(0, parentGrant - assignedChildHireGrants(children));
-        return fn({ parent, children, parentGrant, availableChildGrant });
-    });
-}
-/** Select alive manager lanes and calculate the non-destructive one-time backfill. */
-export function planHireGrantBackfill(lanes, profileMaxConcurrent) {
-    const candidates = lanes.filter((lane) => {
-        if (isTerminalLaneState(lane.state))
-            return false;
-        return aliveDirectChildren(lanes, lane.lane_id).length > 0 ||
-            lane.worker_profile === "hq-lanes-manager";
-    });
-    const candidateIds = new Set(candidates.map((lane) => lane.lane_id));
-    const proposed = new Map();
-    const active = new Set();
-    const proposalFor = (lane) => {
-        const cached = proposed.get(lane.lane_id);
-        if (cached !== undefined)
-            return cached;
-        if (active.has(lane.lane_id)) {
-            throw new LanesError("hire_grant_backfill_cycle", `Cannot plan hire grants for cyclic lane hierarchy at ${lane.lane_id}`, { lane_id: lane.lane_id });
-        }
-        active.add(lane.lane_id);
-        const children = aliveDirectChildren(lanes, lane.lane_id);
-        const allocated = children.reduce((sum, child) => {
-            if (child.hire_grant !== undefined)
-                return sum + child.hire_grant;
-            return sum + (candidateIds.has(child.lane_id) ? proposalFor(child) : 0);
-        }, 0);
-        const profileMax = lane.worker_profile
-            ? profileMaxConcurrent.get(lane.worker_profile) ?? 0
-            : 0;
-        const value = lane.hire_grant ?? Math.max(children.length, profileMax, allocated);
-        active.delete(lane.lane_id);
-        proposed.set(lane.lane_id, value);
-        return value;
-    };
-    for (const lane of candidates)
-        proposalFor(lane);
-    return candidates
-        .map((lane) => {
-        const children = aliveDirectChildren(lanes, lane.lane_id);
-        const profileMax = lane.worker_profile
-            ? profileMaxConcurrent.get(lane.worker_profile) ?? null
-            : null;
-        const existing = lane.hire_grant ?? null;
-        const allocatedChildGrants = children.reduce((sum, child) => {
-            if (child.hire_grant !== undefined)
-                return sum + child.hire_grant;
-            return sum + (candidateIds.has(child.lane_id) ? proposalFor(child) : 0);
-        }, 0);
-        const proposedGrant = proposalFor(lane);
-        return {
-            lane_id: lane.lane_id,
-            existing_grant: existing,
-            alive_children: children.length,
-            profile_max_concurrent: profileMax,
-            allocated_child_grants: allocatedChildGrants,
-            proposed_grant: proposedGrant,
-            grant_shortfall: Math.max(0, allocatedChildGrants - proposedGrant),
-            action: existing === null ? "set" : "unchanged",
-        };
-    })
-        .sort((a, b) => a.lane_id.localeCompare(b.lane_id));
-}
-//# sourceMappingURL=grants.js.map

package/dist/lib/lanes/hire-grant-dispatch.d.ts

@@ -1,29 +0,0 @@
-import { type LaneRecord, type LaneState, type SeniorRef } from "./types.js";
-declare const HIRE_GRANT_CONTEXT_SCHEMA: "hq-lane-hire-grant-context.v1";
-export interface HireGrantLaneSnapshot {
-    lane_id: string;
-    state: LaneState;
-    senior: SeniorRef;
-    hire_grant?: number;
-    created_at?: string;
-    company?: LaneRecord["company"];
-    project_id?: string;
-    worker_profile?: string;
-}
-export interface OutpostHireGrantContext {
-    schema_version: typeof HIRE_GRANT_CONTEXT_SCHEMA;
-    enforcement_enabled: boolean;
-    expected_senior: SeniorRef;
-    hierarchy: HireGrantLaneSnapshot[];
-    superseded_message_caller_id?: string;
-    superseded_message_session_id?: string;
-}
-/** Select the owner records needed to reproduce the primary's grant hierarchy. */
-export declare function selectOutpostHireGrantHierarchy(targetLaneId: string, lanes: readonly LaneRecord[]): LaneRecord[];
-/** Encode only the owner-relevant hierarchy from the primary's complete store. */
-export declare function createOutpostHireGrantContext(target: LaneRecord, lanes: readonly LaneRecord[], supersededMessageCallerId?: string, supersededMessageSessionId?: string): string;
-/** Decode and validate an owner grant context, binding it to the target lane. */
-export declare function parseOutpostHireGrantContext(encoded: string, targetLaneId: string): OutpostHireGrantContext;
-export declare function sameHireGrantSenior(a: SeniorRef, b: SeniorRef): boolean;
-export {};
-//# sourceMappingURL=hire-grant-dispatch.d.ts.map