@indigoai-us/hq-cli 5.176.0 → 5.178.0

package/dist/commands/lanes.js

@@ -16,6 +16,7 @@ import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { resolveProcessFlagGate } from "../lib/flag-registry.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
+export { LANE_HIRE_GRANTS_FLAG };
 import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -24,7 +25,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -51,6 +52,9 @@ export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
+function defaultLaneHireGrantsEnabled() {
+    return resolveProcessFlagGate(LANE_HIRE_GRANTS_FLAG, { fallback: false }, () => false);
+}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -242,6 +246,7 @@ function resolveDeps(deps = {}) {
         })),
         fetchText: deps.fetchText ?? defaultFetchText,
         lanePlacementEnabled: deps.lanePlacementEnabled ?? defaultLanePlacementEnabled,
+        laneHireGrantsEnabled: deps.laneHireGrantsEnabled ?? defaultLaneHireGrantsEnabled,
     };
 }
 function livenessDepsFromCtx(ctx) {
@@ -286,6 +291,16 @@ export function parseSeniorRef(raw) {
     }
     return { kind, id };
 }
+function parseHireGrant(raw) {
+    if (!/^(0|[1-9][0-9]*)$/.test(raw)) {
+        throw new LanesError("hire_grant_invalid", `Hire grant must be a non-negative safe integer; received ${JSON.stringify(raw)}`, { value: raw });
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value)) {
+        throw new LanesError("hire_grant_invalid", `Hire grant must be a non-negative safe integer; received ${JSON.stringify(raw)}`, { value: raw });
+    }
+    return value;
+}
 function seniorKey(ref) {
     return ref.kind === "user" ? "user" : `${ref.kind}:${ref.id ?? ""}`;
 }
@@ -416,6 +431,174 @@ function requireQuestionBody(hqRoot, question) {
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
+function laneHireFields(lane, lanes) {
+    const aliveChildren = aliveDirectChildren(lanes, lane.lane_id);
+    const hireGrant = lane.hire_grant ?? 0;
+    const hireSummary = `hire ${aliveChildren.length}/${hireGrant}`;
+    return {
+        hire_grant: hireGrant,
+        hire_alive_children: aliveChildren.length,
+        hire: `${aliveChildren.length}/${hireGrant}`,
+        hire_summary: hireSummary,
+    };
+}
+async function ownerLaneHireFields(ctx, lane) {
+    if (lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_lane_hire_summary_invalid", "Owner summary requires an Outpost-hosted lane", {
+            lane_id: lane.lane_id,
+        });
+    }
+    const outpostId = lane.host.id;
+    const outpostCliEnvKey = `HQ_LANES_OUTPOST_CLI_${outpostId.toUpperCase().replace(/[^A-Z0-9_]/g, "_")}`;
+    const configuredHqBinary = ctx.env[outpostCliEnvKey];
+    const hqBinary = configuredHqBinary === undefined ? undefined : configuredHqBinary.trim();
+    if (configuredHqBinary !== undefined &&
+        (!hqBinary ||
+            !path.posix.isAbsolute(hqBinary) ||
+            hqBinary.includes("\0") ||
+            hqBinary.includes("\r") ||
+            hqBinary.includes("\n"))) {
+        throw new LanesError("outpost_lane_cli_invalid", `${outpostCliEnvKey} must be an absolute remote executable path`, { outpost_id: outpostId });
+    }
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneCommand({
+                action: "show",
+                laneId: lane.lane_id,
+                hqBinary,
+            }),
+            timeoutSeconds: OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS,
+            waitMs: OUTPOST_HIRE_SUMMARY_WAIT_MS,
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_lane_hire_summary_unavailable", `Could not read hire summary for lane ${lane.lane_id} from Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, outpost_id: outpostId });
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        throw new LanesError("outpost_lane_hire_summary_unavailable", `Outpost ${outpostId} did not confirm the hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost lane hire summary");
+    if (!remote || remote.ok !== true || remote.action !== "show") {
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
+    }
+    let ownerLane;
+    try {
+        ownerLane = parseLaneRecord(remote.lane);
+    }
+    catch (err) {
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an invalid lane snapshot for ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, cause: dispatchErrorMessage(err) });
+    }
+    const grant = remote.hire_grant;
+    const alive = remote.hire_alive_children;
+    if (ownerLane.lane_id !== lane.lane_id ||
+        ownerLane.host.kind !== "outpost" ||
+        ownerLane.host.id !== outpostId ||
+        !Number.isSafeInteger(grant) ||
+        grant < 0 ||
+        !Number.isSafeInteger(alive) ||
+        alive < 0 ||
+        remote.hire !== `${String(alive)}/${String(grant)}` ||
+        remote.hire_summary !== `hire ${String(alive)}/${String(grant)}`) {
+        throw new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned an inconsistent hire summary for lane ${lane.lane_id}`, { lane_id: lane.lane_id, outpost_id: outpostId, command_id: dispatched.commandId });
+    }
+    return {
+        hire_grant: grant,
+        hire_alive_children: alive,
+        hire: `${alive}/${grant}`,
+        hire_summary: `hire ${alive}/${grant}`,
+    };
+}
+const OUTPOST_HIRE_SUMMARY_TIMEOUT_SECONDS = 20;
+const OUTPOST_HIRE_SUMMARY_WAIT_MS = 15_000;
+const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
+async function laneHirePresentation(ctx, lane, lanes) {
+    const local = laneHireFields(lane, lanes);
+    if (!ctx.laneHireGrantsEnabled() ||
+        lane.host.kind !== "outpost" ||
+        isTerminalLaneState(lane.state) ||
+        laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
+        return { ...local, hire_source: "local" };
+    }
+    try {
+        return { ...(await ownerLaneHireFields(ctx, lane)), hire_source: "owner" };
+    }
+    catch (err) {
+        const detail = isLanesError(err)
+            ? `${err.error}: ${err.message}`
+            : `outpost_lane_hire_summary_unavailable: ${dispatchErrorMessage(err)}`;
+        return {
+            ...local,
+            hire_source: "local",
+            hire_warning: detail,
+        };
+    }
+}
+async function mapWithConcurrency(values, concurrency, map) {
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, values.length);
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (nextIndex < values.length) {
+            const index = nextIndex++;
+            results[index] = await map(values[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+function withResumeHireAdmission(ctx, lane, fn) {
+    const hqRoot = ctx.hqRoot();
+    if (!ctx.laneHireGrantsEnabled() ||
+        !isTerminalLaneState(lane.state) ||
+        lane.senior.kind !== "lane" ||
+        !lane.senior.id) {
+        return fn();
+    }
+    return withHireGrantAdmission(hqRoot, lane.senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
+        const current = readLane(hqRoot, lane.lane_id);
+        // A different resume already reactivated this lane; it occupies the slot
+        // in the shared snapshot and is not a second hire.
+        if (!isTerminalLaneState(current.state))
+            return fn();
+        if (isTerminalLaneState(parent.state)) {
+            throw 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 >= (parent.hire_grant ?? 0)) {
+            throw hireGrantCapacityError(parent, children);
+        }
+        const requestedGrant = current.hire_grant ?? 0;
+        if (requestedGrant > availableChildGrant) {
+            throw 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 fn();
+    });
+}
+function hireGrantCapacityError(parent, children) {
+    const grant = parent.hire_grant ?? 0;
+    return new LanesError("hire_grant_exhausted", `Senior lane ${parent.lane_id} has hire grant ${grant} and ${children.length} alive direct children (${children.map((child) => child.lane_id).join(", ") || "none"}). 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: grant,
+        alive_children: children.map((child) => child.lane_id),
+        alive_child_count: children.length,
+        ask_guidance: {
+            envelope: "decision=ask; include the desired total grant and the reason",
+            senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
+        },
+    });
+}
 const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
 const MAX_PLACEMENT_OUTPOSTS = 16;
 function outpostIdentityUnknownError(message, expectedId, details = {}) {
@@ -1229,6 +1412,13 @@ export function composeWorkerBrief(worker, taskBrief) {
     ]
         .filter(Boolean)
         .join("\n");
+    const laneHiringGuidance = worker.profile?.id === "hq-lanes-manager"
+        ? [
+            "",
+            "## Lane hiring grants",
+            "A child lane may hire only within its assigned grant. If you need more direct child lanes than your current grant allows, stop before creating them and write a decision=ask envelope. Include the total grant you want and why in the question and context. Use your lane id from HQ_LANE_ID so your senior can run `hq lanes grant <lane-id> --hire <n>`.",
+        ]
+        : [];
     return [
         `# ${name}`,
         description,
@@ -1257,6 +1447,7 @@ export function composeWorkerBrief(worker, taskBrief) {
         "## Verification checkpoints",
         checkpoints || "(none)",
         ...(checkpoints ? ["", checkpointInstruction(worker)] : []),
+        ...laneHiringGuidance,
         "",
         "## Task",
         taskBrief.replace(/\s+$/, ""),
@@ -1602,6 +1793,9 @@ function mintMessageId() {
 }
 async function runCreate(ctx, opts) {
     const hqRoot = ctx.hqRoot();
+    const requestedHireGrant = opts.hireGrant === undefined
+        ? undefined
+        : parseHireGrant(opts.hireGrant);
     const requestedPlacement = opts.placement !== undefined
         ? parsePlacementPolicy(opts.placement)
         : undefined;
@@ -1664,6 +1858,17 @@ async function runCreate(ctx, opts) {
     }
     const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
     assertSeniorExists(hqRoot, senior, ctx);
+    const hireGrantsEnabled = ctx.laneHireGrantsEnabled();
+    if (requestedHireGrant !== undefined &&
+        !callerMatchesSenior(ctx, senior)) {
+        throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(senior)} may set a lane's hire grant`, { senior, hire_grant: requestedHireGrant });
+    }
+    if (hireGrantsEnabled &&
+        ctx.env.HQ_LANE_ID?.trim() &&
+        !callerMatchesSenior(ctx, senior)) {
+        throw new LanesError("hire_grant_unauthorized", `Only senior lane ${senior.id} may create a direct child lane`, { senior_lane_id: senior.id });
+    }
+    const hireGrant = requestedHireGrant ?? 0;
     const laneDepth = derivedLaneDepth(hqRoot, senior, ctx);
     if (laneDepth > MAX_LANE_DEPTH) {
         throw new LanesError("max_lane_depth", `Lane depth ${laneDepth} exceeds cap ${MAX_LANE_DEPTH}`, { depth: laneDepth, max: MAX_LANE_DEPTH });
@@ -2065,7 +2270,7 @@ async function runCreate(ctx, opts) {
             : { kind: "local", id: ctx.hostname() });
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
         const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
-        const lane = createLane(hqRoot, {
+        const laneInit = {
             company,
             ...(company === null && meshCompany
                 ? { mesh_company: meshCompany }
@@ -2081,6 +2286,7 @@ async function runCreate(ctx, opts) {
             })),
             depth: laneDepth,
             senior,
+            hire_grant: hireGrant,
             senior_history: [],
             state: "queued",
             queued_reason: queuedReason,
@@ -2124,7 +2330,29 @@ async function runCreate(ctx, opts) {
                 ? { origin_host_source: originHostSource }
                 : {}),
             attribution_history: [],
-        });
+        };
+        const lane = senior.kind === "lane"
+            ? withHireGrantAdmission(hqRoot, senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
+                if (hireGrantsEnabled && isTerminalLaneState(parent.state)) {
+                    throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot hire lanes`, { senior_lane_id: parent.lane_id, state: parent.state });
+                }
+                if (hireGrantsEnabled && children.length >= parentGrant) {
+                    throw hireGrantCapacityError(parent, children);
+                }
+                if (hireGrantsEnabled && hireGrant > availableChildGrant) {
+                    throw new LanesError("hire_grant_carve_exceeded", `Lane ${parent.lane_id} has ${availableChildGrant} unassigned hire grant remaining after its other alive children. Ask its senior to raise its grant before assigning ${hireGrant}.`, {
+                        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: hireGrant,
+                        available_hire_grant: availableChildGrant,
+                        ask_guidance: `Write an ask envelope with the desired total grant and reason; the senior runs hq lanes grant ${parent.lane_id} --hire <n>.`,
+                    });
+                }
+                return createLane(hqRoot, laneInit);
+            })
+            : createLane(hqRoot, laneInit);
         return { lane, admission, validation };
     };
     let persisted;
@@ -2478,6 +2706,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
                 story: options.story,
                 account: options.account,
                 model: options.model,
+                hire: options.hire,
                 compact: options.compact,
             }),
         });
@@ -2514,8 +2743,10 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         remote.lane_id === lane.lane_id &&
         (action === "message"
             ? remote.accepted === true
-            : remote.delivery_status === "worker_spawned" ||
-                remote.delivery_status === "queued_on_target_account");
+            : action === "grant"
+                ? remote.hire_grant === Number(options.hire)
+                : remote.delivery_status === "worker_spawned" ||
+                    remote.delivery_status === "queued_on_target_account");
     if (!resultConfirmed) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without a confirmed ${action} result for lane ${lane.lane_id}`, {
             lane_id: lane.lane_id,
@@ -2523,6 +2754,18 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
             command_id: dispatched.commandId,
         });
     }
+    if (action === "grant") {
+        const ownerLane = syncLaneRecordFromOwner(ctx.hqRoot(), lane.lane_id, outpostId, remote.lane, undefined, { allowNonTerminal: true });
+        printJson({
+            ...remote,
+            lane_id: ownerLane.lane_id,
+            lane: ownerLane,
+            outpost_id: outpostId,
+            outpost_command_id: dispatched.commandId,
+            outpost_transport: "outposts_exec",
+        });
+        return;
+    }
     printJson({
         ...remote,
         outpost_id: outpostId,
@@ -2763,7 +3006,8 @@ async function runList(ctx, opts) {
     }
     const now = ctx.now();
     const host = reconcileHostFromCtx(ctx);
-    const lanes = loadAllLanes(hqRoot)
+    const allLanes = loadAllLanes(hqRoot);
+    const selectedLanes = allLanes
         .filter((lane) => {
         if (state && lane.state !== state)
             return false;
@@ -2779,13 +3023,18 @@ async function runList(ctx, opts) {
             return false;
         return true;
     })
-        .sort(compareLaneQueueOrder)
-        .map((lane) => {
+        .sort(compareLaneQueueOrder);
+    const hireByLane = new Map(await mapWithConcurrency(selectedLanes, OUTPOST_HIRE_SUMMARY_CONCURRENCY, async (lane) => [
+        lane.lane_id,
+        await laneHirePresentation(ctx, lane, allLanes),
+    ]));
+    const lanes = selectedLanes.map((lane) => {
         const remoteQueued = lane.state === "queued" &&
             lane.host.kind === "outpost" &&
             !laneRunsHere(lane, host);
         return {
             ...lane,
+            ...hireByLane.get(lane.lane_id),
             ...(remoteQueued
                 ? { state: "remote", remote_state: lane.state, queued_reason: undefined }
                 : {}),
@@ -3220,6 +3469,8 @@ async function runMoveTarget(ctx, laneId, opts) {
 async function runShow(ctx, laneId) {
     const hqRoot = ctx.hqRoot();
     const storedLane = readLane(hqRoot, laneId);
+    const allLanes = loadAllLanes(hqRoot);
+    const hire = await laneHirePresentation(ctx, storedLane, allLanes);
     const remoteQueued = storedLane.state === "queued" &&
         storedLane.host.kind === "outpost" &&
         !laneRunsHere(storedLane, reconcileHostFromCtx(ctx));
@@ -3231,6 +3482,7 @@ async function runShow(ctx, laneId) {
         ok: true,
         action: "show",
         lane,
+        ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
         stalled: Boolean(lane.stalled),
         stalled_at: lane.stalled_at ?? null,
@@ -3256,17 +3508,17 @@ async function runShow(ctx, laneId) {
             : null,
     });
 }
-function forceAdmissionAuthorized(ctx, lane) {
+function callerMatchesSenior(ctx, seniorRef) {
     const sessionId = sessionIdFromEnv(ctx.env);
     const callerLaneId = ctx.env.HQ_LANE_ID?.trim() || undefined;
-    if (lane.senior.kind === "lane") {
-        return callerLaneId !== undefined && callerLaneId === lane.senior.id;
+    if (seniorRef.kind === "lane") {
+        return callerLaneId !== undefined && callerLaneId === seniorRef.id;
     }
     if (!sessionId || callerLaneId !== undefined)
         return false;
-    if (lane.senior.kind === "session")
-        return sessionId === lane.senior.id;
-    if (lane.senior.kind !== "user")
+    if (seniorRef.kind === "session")
+        return sessionId === seniorRef.id;
+    if (seniorRef.kind !== "user")
         return false;
     const loaded = loadSessionMeta(ctx.hqRoot(), sessionId, ctx);
     if (loaded.status !== "ok")
@@ -3276,6 +3528,173 @@ function forceAdmissionAuthorized(ctx, lane) {
         (senior !== null && typeof senior === "object" && !Array.isArray(senior) &&
             senior.kind === "user");
 }
+function forceAdmissionAuthorized(ctx, lane) {
+    return callerMatchesSenior(ctx, lane.senior);
+}
+async function runGrant(ctx, laneId, opts) {
+    if (opts.hire === undefined) {
+        throw new LanesError("missing_hire_grant", "--hire is required", {});
+    }
+    const hireGrant = parseHireGrant(opts.hire);
+    const hqRoot = ctx.hqRoot();
+    const initial = readLane(hqRoot, laneId);
+    if (!callerMatchesSenior(ctx, initial.senior)) {
+        throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(initial.senior)} may change lane ${laneId}'s hire grant`, { lane_id: laneId, senior: initial.senior });
+    }
+    if (initial.host.kind === "outpost" && !laneRunsHere(initial, reconcileHostFromCtx(ctx))) {
+        await dispatchOutpostLaneCommand(ctx, initial, "grant", { hire: String(hireGrant) });
+        return;
+    }
+    const lockedLaneIds = [
+        laneId,
+        ...(initial.senior.kind === "lane" && initial.senior.id
+            ? [initial.senior.id]
+            : []),
+    ];
+    const updated = withLaneHireLocks(hqRoot, lockedLaneIds, () => {
+        const current = readLane(hqRoot, laneId);
+        if (!callerMatchesSenior(ctx, current.senior)) {
+            throw new LanesError("hire_grant_unauthorized", `Only senior ${seniorKey(current.senior)} may change lane ${laneId}'s hire grant`, { lane_id: laneId, senior: current.senior });
+        }
+        const hierarchy = loadAllLanes(hqRoot);
+        const enforce = ctx.laneHireGrantsEnabled();
+        if (enforce && current.senior.kind === "lane") {
+            if (!current.senior.id) {
+                throw new LanesError("hire_grant_senior_invalid", `Lane ${laneId} has a lane senior without an id`, {
+                    lane_id: laneId,
+                });
+            }
+            const parent = readLane(hqRoot, current.senior.id);
+            if (isTerminalLaneState(parent.state)) {
+                throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot change grants`, { senior_lane_id: parent.lane_id, state: parent.state });
+            }
+            const siblings = aliveDirectChildren(hierarchy, parent.lane_id);
+            const parentGrant = parent.hire_grant ?? 0;
+            const assigned = assignedChildHireGrants(siblings, current.lane_id);
+            const available = Math.max(0, parentGrant - assigned);
+            if (hireGrant > available) {
+                throw new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${available} unassigned hire grant remaining for lane ${laneId}`, {
+                    senior_lane_id: parent.lane_id,
+                    parent_grant: parentGrant,
+                    alive_children: siblings.map((child) => child.lane_id),
+                    assigned_other_child_grants: assigned,
+                    requested_hire_grant: hireGrant,
+                    available_hire_grant: available,
+                });
+            }
+        }
+        if (enforce) {
+            const children = aliveDirectChildren(hierarchy, current.lane_id);
+            const allocated = assignedChildHireGrants(children);
+            const minimumGrant = Math.max(allocated, children.length);
+            if (hireGrant < minimumGrant) {
+                throw new LanesError(allocated > children.length ? "hire_grant_below_allocated" : "hire_grant_below_occupancy", `Lane ${laneId} cannot lower its grant to ${hireGrant}; it has ${children.length} alive children and ${allocated} grant allocated to them`, {
+                    lane_id: laneId,
+                    requested_hire_grant: hireGrant,
+                    alive_children: children.map((child) => child.lane_id),
+                    alive_child_count: children.length,
+                    assigned_child_grants: allocated,
+                });
+            }
+        }
+        return retryUpdateLane(hqRoot, laneId, "command", (record) => ({
+            ...record,
+            hire_grant: hireGrant,
+        }));
+    });
+    const fields = laneHireFields(updated, loadAllLanes(hqRoot));
+    printJson({ ok: true, action: "grant", lane_id: updated.lane_id, lane: updated, ...fields });
+}
+async function runBackfillGrants(ctx, opts) {
+    if (opts.apply && opts.dryRun) {
+        throw new LanesError("hire_grant_backfill_mode_conflict", "Pass either --dry-run or --apply, not both", {});
+    }
+    const apply = Boolean(opts.apply);
+    const hqRoot = ctx.hqRoot();
+    if (apply && ctx.laneHireGrantsEnabled()) {
+        throw new LanesError("hire_grant_backfill_gate_enabled", "Backfill must be applied and verified before lanes.hire-grants is enabled", { flag: LANE_HIRE_GRANTS_FLAG });
+    }
+    if (apply && ctx.env.HQ_LANE_ID?.trim()) {
+        throw new LanesError("hire_grant_backfill_unauthorized", "A lane cannot apply the hire-grant backfill; run it from an operator session", {});
+    }
+    const allLanes = loadAllLanes(hqRoot);
+    const profileIds = new Set(allLanes
+        .filter((lane) => !isTerminalLaneState(lane.state) &&
+        (aliveDirectChildren(allLanes, lane.lane_id).length > 0 ||
+            lane.worker_profile === "hq-lanes-manager"))
+        .map((lane) => lane.worker_profile)
+        .filter((id) => Boolean(id)));
+    const profileMaxConcurrent = new Map();
+    for (const profileId of profileIds) {
+        let profile;
+        try {
+            profile = loadWorkerProfile(hqRoot, profileId);
+        }
+        catch (err) {
+            throw new LanesError("hire_grant_backfill_profile_unavailable", `Cannot calculate a hire-grant backfill for worker profile ${profileId}: ${err instanceof Error ? err.message : String(err)}`, { worker_profile: profileId });
+        }
+        const maxConcurrent = profile.meta.max_concurrent;
+        if (maxConcurrent !== undefined && !Number.isSafeInteger(maxConcurrent)) {
+            throw new LanesError("hire_grant_backfill_profile_invalid", `Worker profile ${profileId} has max_concurrent outside the safe integer range`, { worker_profile: profileId, max_concurrent: maxConcurrent });
+        }
+        if (maxConcurrent !== undefined)
+            profileMaxConcurrent.set(profileId, maxConcurrent);
+    }
+    let rows = planHireGrantBackfill(allLanes, profileMaxConcurrent);
+    if (apply) {
+        const shortfalls = rows.filter((row) => row.grant_shortfall > 0);
+        if (shortfalls.length > 0) {
+            throw new LanesError("hire_grant_backfill_allocation_shortfall", "Existing parent grants do not cover the grants allocated to alive children; resolve these rows before applying the backfill", { lanes: shortfalls });
+        }
+        rows = rows.map((row) => {
+            if (row.action === "unchanged")
+                return row;
+            const lane = readLane(hqRoot, row.lane_id);
+            const lockIds = [
+                lane.lane_id,
+                ...(lane.senior.kind === "lane" && lane.senior.id ? [lane.senior.id] : []),
+            ];
+            return withLaneHireLocks(hqRoot, lockIds, () => {
+                const current = readLane(hqRoot, row.lane_id);
+                if (current.hire_grant !== undefined) {
+                    return {
+                        ...row,
+                        existing_grant: current.hire_grant,
+                        proposed_grant: current.hire_grant,
+                        action: "unchanged",
+                    };
+                }
+                const latestLanes = loadAllLanes(hqRoot);
+                const latestRow = planHireGrantBackfill(latestLanes, profileMaxConcurrent)
+                    .find((candidate) => candidate.lane_id === current.lane_id);
+                if (!latestRow) {
+                    throw new LanesError("hire_grant_backfill_target_changed", `Lane ${current.lane_id} no longer qualifies for the hire-grant backfill`, { lane_id: current.lane_id });
+                }
+                if (latestRow.grant_shortfall > 0) {
+                    throw new LanesError("hire_grant_backfill_allocation_shortfall", `Lane ${current.lane_id}'s existing grant does not cover grants allocated to its alive children`, { lane: latestRow });
+                }
+                const proposed = latestRow.proposed_grant;
+                const written = retryUpdateLane(hqRoot, current.lane_id, "command", (record) => ({
+                    ...record,
+                    ...(record.hire_grant === undefined ? { hire_grant: proposed } : {}),
+                }));
+                const value = written.hire_grant ?? 0;
+                return {
+                    ...row,
+                    existing_grant: value,
+                    proposed_grant: value,
+                    action: value === proposed ? "set" : "unchanged",
+                };
+            });
+        });
+    }
+    printJson({
+        ok: true,
+        action: "backfill-grants",
+        mode: apply ? "apply" : "dry-run",
+        lanes: rows,
+    });
+}
 async function runAdmit(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     let lane = readLane(hqRoot, laneId);
@@ -3590,7 +4009,7 @@ async function prepareAccountMove(ctx, lane, input) {
         if (admission.action === "refuse" && admission.error)
             throw admission.error;
         const queued = admission.action === "queue";
-        const moved = casUpdateLane(hqRoot, laneId, (current) => {
+        const moved = withResumeHireAdmission(ctx, lane, () => casUpdateLane(hqRoot, laneId, (current) => {
             // The copy and every check above were made from `lane`; a record
             // that moved on since (another move, a spawn, a cancel) invalidates
             // them, so the write is refused rather than applied to a state it
@@ -3624,7 +4043,7 @@ async function prepareAccountMove(ctx, lane, input) {
                 next.queued_at = undefined;
             }
             return next;
-        });
+        }));
         return { lane: moved, from, to: target, copy, queued };
     }, ctx.sleep);
 }
@@ -3640,6 +4059,9 @@ async function runMessage(ctx, laneId, opts) {
         return;
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
+    // Check before transcript recovery, account probing, or message writes.
+    // The final state transition repeats this check under the senior lock.
+    withResumeHireAdmission(ctx, lane, () => undefined);
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
     // An account move is refused on its own terms first: a running lane and a
     // provider without session resume get the move's named errors, not the
@@ -3725,62 +4147,64 @@ async function runMessage(ctx, laneId, opts) {
             const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
             if (admission.action === "refuse" && admission.error)
                 throw admission.error;
-            if (admission.action === "queue") {
-                const sessionId = lane.provider_session_id;
-                if (!sessionId) {
-                    throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
-                        lane_id: laneId,
-                        provider: lane.provider,
-                    });
-                }
-                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                queuedOnAdmission = true;
-                return casUpdateLane(hqRoot, laneId, (current) => {
-                    if (current.version !== lane.version || current.state !== lane.state) {
-                        throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
+            return withResumeHireAdmission(ctx, lane, () => {
+                if (admission.action === "queue") {
+                    const sessionId = lane.provider_session_id;
+                    if (!sessionId) {
+                        throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
                             lane_id: laneId,
-                            prepared_version: lane.version,
-                            version: current.version,
-                            state: current.state,
+                            provider: lane.provider,
                         });
                     }
-                    return {
-                        ...current,
-                        state: "queued",
-                        queued_reason: admission.reason ?? "throttle",
-                        queued_at: at,
-                        pending_resume: {
-                            session_id: sessionId,
-                            trigger: "message",
-                            text,
-                            message_id: messageId,
-                            compact: opts.compact !== false,
-                            at,
-                        },
-                    };
-                });
-            }
-            const started = spawnLaneWorker(hqRoot, lane, {
-                env: ctx.env,
-                modelDeps: {
-                    readFileSync: ctx.readFileSync,
-                    probe: ctx.probeProvider,
+                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                    queuedOnAdmission = true;
+                    return casUpdateLane(hqRoot, laneId, (current) => {
+                        if (current.version !== lane.version || current.state !== lane.state) {
+                            throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
+                                lane_id: laneId,
+                                prepared_version: lane.version,
+                                version: current.version,
+                                state: current.state,
+                            });
+                        }
+                        return {
+                            ...current,
+                            state: "queued",
+                            queued_reason: admission.reason ?? "throttle",
+                            queued_at: at,
+                            pending_resume: {
+                                session_id: sessionId,
+                                trigger: "message",
+                                text,
+                                message_id: messageId,
+                                compact: opts.compact !== false,
+                                at,
+                            },
+                        };
+                    });
+                }
+                const started = spawnLaneWorker(hqRoot, lane, {
                     env: ctx.env,
-                },
-                existsSync: ctx.existsSync,
-                spawnProcess: ctx.spawnProcess,
-                proveDetached: ctx.proveDetached,
-                killProcess: ctx.killProcess,
-                now: ctx.now,
-                resolveMachineIdentity: ctx.resolveMachineIdentity,
-                runCompaction: ctx.runCompaction,
-                locateTranscript: ctx.locateTranscript,
-            }, {
-                trigger: { kind: "message", text, message_id: messageId },
-                compact: opts.compact !== false,
+                    modelDeps: {
+                        readFileSync: ctx.readFileSync,
+                        probe: ctx.probeProvider,
+                        env: ctx.env,
+                    },
+                    existsSync: ctx.existsSync,
+                    spawnProcess: ctx.spawnProcess,
+                    proveDetached: ctx.proveDetached,
+                    killProcess: ctx.killProcess,
+                    now: ctx.now,
+                    resolveMachineIdentity: ctx.resolveMachineIdentity,
+                    runCompaction: ctx.runCompaction,
+                    locateTranscript: ctx.locateTranscript,
+                }, {
+                    trigger: { kind: "message", text, message_id: messageId },
+                    compact: opts.compact !== false,
+                });
+                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                return started;
             });
-            archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-            return started;
         }, ctx.sleep);
     }
     // Every accepted message moves the compaction reference forward.
@@ -3915,6 +4339,9 @@ async function runResume(ctx, laneId, opts) {
         await dispatchOutpostLaneCommand(ctx, lane, "resume", opts);
         return;
     }
+    // Fail before provider/session work if a terminal child would consume a
+    // slot that its senior has already assigned elsewhere.
+    withResumeHireAdmission(ctx, lane, () => undefined);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "resume");
     lane = laneWithRecoveredProviderSession(hqRoot, lane);
     if (opts.model !== undefined && opts.account === undefined) {
@@ -4001,64 +4428,66 @@ async function runResume(ctx, laneId, opts) {
             const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
             if (admission.action === "refuse" && admission.error)
                 throw admission.error;
-            if (admission.action === "queue") {
-                const sessionId = lane.provider_session_id;
-                if (!sessionId) {
-                    throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this resume`, {
-                        lane_id: laneId,
-                        provider: lane.provider,
-                    });
-                }
-                queuedOnAdmission = true;
-                return casUpdateLane(hqRoot, laneId, (current) => {
-                    if (current.version !== lane.version || current.state !== lane.state) {
-                        throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while resume admission was checked`, {
+            return withResumeHireAdmission(ctx, lane, () => {
+                if (admission.action === "queue") {
+                    const sessionId = lane.provider_session_id;
+                    if (!sessionId) {
+                        throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this resume`, {
                             lane_id: laneId,
-                            prepared_version: lane.version,
-                            version: current.version,
-                            state: current.state,
+                            provider: lane.provider,
                         });
                     }
-                    return {
-                        ...current,
-                        state: "queued",
-                        queued_reason: admission.reason ?? "throttle",
-                        queued_at: at,
-                        pending_resume: {
-                            session_id: sessionId,
-                            trigger: "resume",
-                            resumed_from: resumedFrom,
-                            ...(text !== undefined ? { text } : {}),
-                            ...(messageId !== undefined ? { message_id: messageId } : {}),
-                            compact: opts.compact !== false,
-                            at,
-                        },
-                    };
-                });
-            }
-            return spawnLaneWorker(hqRoot, lane, {
-                env: ctx.env,
-                modelDeps: {
-                    readFileSync: ctx.readFileSync,
-                    probe: ctx.probeProvider,
+                    queuedOnAdmission = true;
+                    return casUpdateLane(hqRoot, laneId, (current) => {
+                        if (current.version !== lane.version || current.state !== lane.state) {
+                            throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while resume admission was checked`, {
+                                lane_id: laneId,
+                                prepared_version: lane.version,
+                                version: current.version,
+                                state: current.state,
+                            });
+                        }
+                        return {
+                            ...current,
+                            state: "queued",
+                            queued_reason: admission.reason ?? "throttle",
+                            queued_at: at,
+                            pending_resume: {
+                                session_id: sessionId,
+                                trigger: "resume",
+                                resumed_from: resumedFrom,
+                                ...(text !== undefined ? { text } : {}),
+                                ...(messageId !== undefined ? { message_id: messageId } : {}),
+                                compact: opts.compact !== false,
+                                at,
+                            },
+                        };
+                    });
+                }
+                return spawnLaneWorker(hqRoot, lane, {
                     env: ctx.env,
-                },
-                existsSync: ctx.existsSync,
-                spawnProcess: ctx.spawnProcess,
-                proveDetached: ctx.proveDetached,
-                killProcess: ctx.killProcess,
-                now: ctx.now,
-                resolveMachineIdentity: ctx.resolveMachineIdentity,
-                runCompaction: ctx.runCompaction,
-                locateTranscript: ctx.locateTranscript,
-            }, {
-                trigger: {
-                    kind: "resume",
-                    from: resumedFrom,
-                    ...(text !== undefined ? { text } : {}),
-                    ...(messageId !== undefined ? { message_id: messageId } : {}),
-                },
-                compact: opts.compact !== false,
+                    modelDeps: {
+                        readFileSync: ctx.readFileSync,
+                        probe: ctx.probeProvider,
+                        env: ctx.env,
+                    },
+                    existsSync: ctx.existsSync,
+                    spawnProcess: ctx.spawnProcess,
+                    proveDetached: ctx.proveDetached,
+                    killProcess: ctx.killProcess,
+                    now: ctx.now,
+                    resolveMachineIdentity: ctx.resolveMachineIdentity,
+                    runCompaction: ctx.runCompaction,
+                    locateTranscript: ctx.locateTranscript,
+                }, {
+                    trigger: {
+                        kind: "resume",
+                        from: resumedFrom,
+                        ...(text !== undefined ? { text } : {}),
+                        ...(messageId !== undefined ? { message_id: messageId } : {}),
+                    },
+                    compact: opts.compact !== false,
+                });
             });
         }, ctx.sleep);
     }
@@ -4477,6 +4906,21 @@ function archiveResumeMessage(hqRoot, laneId, message) {
     fs.writeFileSync(path.join(dir, `${message.message_id}.resume.jsonl`), `${JSON.stringify(message)}\n`, "utf8");
 }
 async function runReparent(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    if (!opts.senior) {
+        throw new LanesError("missing_senior", "--senior is required", {});
+    }
+    const nextSenior = parseSeniorRef(opts.senior);
+    assertSeniorExists(hqRoot, nextSenior, ctx);
+    const initial = readLane(hqRoot, laneId);
+    const lockIds = [
+        laneId,
+        ...(initial.senior.kind === "lane" && initial.senior.id ? [initial.senior.id] : []),
+        ...(nextSenior.kind === "lane" && nextSenior.id ? [nextSenior.id] : []),
+    ];
+    withLaneHireLocks(hqRoot, lockIds, () => runReparentLocked(ctx, laneId, opts));
+}
+function runReparentLocked(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     if (!opts.senior) {
         throw new LanesError("missing_senior", "--senior is required", {});
@@ -4490,6 +4934,29 @@ async function runReparent(ctx, laneId, opts) {
     }
     const seniorCompany = companyOfSenior(hqRoot, nextSenior, ctx);
     assertSameTenant(lane.company, nextSenior, seniorCompany, { lane_id: laneId });
+    if (ctx.laneHireGrantsEnabled() &&
+        nextSenior.kind === "lane" &&
+        seniorKey(lane.senior) !== seniorKey(nextSenior)) {
+        const parent = readLane(hqRoot, nextSenior.id);
+        if (isTerminalLaneState(parent.state)) {
+            throw new LanesError("hire_grant_senior_inactive", `Senior lane ${parent.lane_id} is ${parent.state} and cannot accept lane children`, { senior_lane_id: parent.lane_id, state: parent.state });
+        }
+        const children = aliveDirectChildren(loadAllLanes(hqRoot), parent.lane_id);
+        if (children.length >= (parent.hire_grant ?? 0)) {
+            throw hireGrantCapacityError(parent, children);
+        }
+        const available = Math.max(0, (parent.hire_grant ?? 0) - assignedChildHireGrants(children));
+        const requested = lane.hire_grant ?? 0;
+        if (requested > available) {
+            throw new LanesError("hire_grant_carve_exceeded", `Senior lane ${parent.lane_id} has ${available} unassigned hire grant remaining for lane ${laneId}`, {
+                senior_lane_id: parent.lane_id,
+                parent_grant: parent.hire_grant ?? 0,
+                assigned_child_grants: assignedChildHireGrants(children),
+                requested_hire_grant: requested,
+                available_hire_grant: available,
+            });
+        }
+    }
     if (walkHitsLane(hqRoot, nextSenior, laneId, ctx)) {
         throw new LanesError("senior_cycle", `Re-parent would create a cycle through ${laneId}`, { lane_id: laneId, senior: nextSenior });
     }
@@ -5515,6 +5982,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--model <id>", "Model id for the provider CLI")
         .option("--effort <level>", "Effort level; claude: low|medium|high|xhigh|max, codex: minimal|low|medium|high|xhigh|max|ultra, grok: low|medium|high|xhigh")
         .option("--senior <ref>", "session:<id> | lane:<id> | user")
+        .option("--hire-grant <n>", "Maximum alive direct child lanes assigned to this lane; set by its senior")
         .option("--timeout <secs>", "Deadline in seconds (warns, does not kill)")
         .option("--priority <n>", "Queue priority; higher runs first", "1")
         .option("--outpost <id>", "Run on this Outpost instead of the local host")
@@ -5523,6 +5991,22 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runCreate(ctx, opts);
     }));
+    lanes
+        .command("grant")
+        .description("Set a lane's alive child-lane grant as its senior")
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--hire <n>", "Non-negative safe integer hire grant")
+        .action(wrap(async (laneId, opts) => {
+        await runGrant(ctx, laneId, opts);
+    }));
+    lanes
+        .command("backfill-grants")
+        .description("Preview or apply missing hire grants for alive manager lanes")
+        .option("--dry-run", "Print proposed values without writing (default)")
+        .option("--apply", "Write missing hire grants; only run before enforcement is enabled")
+        .action(wrap(async (opts) => {
+        await runBackfillGrants(ctx, opts);
+    }));
     lanes
         .command("list")
         .description("List lanes")