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

package/dist/commands/lanes-message.js

@@ -12,6 +12,7 @@ import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
+import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, callerMatchesSessionSenior, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneMessageHandlers(deps) {
@@ -666,6 +667,7 @@ export function createLaneMessageHandlers(deps) {
                             const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
                             if (admission.action === "refuse" && admission.error)
                                 throw admission.error;
+                            const guardEnabled = admission.action === "queue" ? false : await lowDiskGuardEnabledForLane(hqRoot, lane);
                             return withResumeHireAdmission(ctx, lane, () => {
                                 if (admission.action === "queue") {
                                     const sessionId = lane.provider_session_id;
@@ -709,6 +711,7 @@ export function createLaneMessageHandlers(deps) {
                                     return queued;
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
+                                    lowDiskGuardEnabled: guardEnabled,
                                     env: ctx.env,
                                     modelDeps: {
                                         readFileSync: ctx.readFileSync,

package/dist/commands/lanes-questions.js

@@ -134,7 +134,8 @@ export function createLaneQuestionsHandlers(deps) {
         const awaitingWakeConfirmed = lane.state !== "awaiting_input" ||
             (remote?.wake_status === "resumed" && remote.lane_state === "running") ||
             (remote?.wake_status === "queued" && remote.lane_state === "queued") ||
-            (remote?.wake_status === "awaiting_answers" && remote.lane_state === "awaiting_input");
+            ((remote?.wake_status === "awaiting_answers" || remote?.wake_status === "deferred") &&
+                remote.lane_state === "awaiting_input");
         if (remote?.ok !== true ||
             remote.action !== "questions.answer" ||
             remoteQuestion?.question_id !== questionId ||

package/dist/commands/lanes-resume.js

@@ -7,6 +7,7 @@ import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice } from "../lib/lanes/story-switch.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
+import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneResumeHandlers(deps) {
     const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, automaticBalanceMoveHistoryReason, authorizeFailedResume, authorizeResumeProfileRepin, casUpdateLane, dispatchOutpostLaneCommand, laneIsHostedHere, laneWithRecoveredProviderSession, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
@@ -396,6 +397,7 @@ export function createLaneResumeHandlers(deps) {
                     const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
                     if (admission.action === "refuse" && admission.error)
                         throw admission.error;
+                    const guardEnabled = admission.action === "queue" ? false : await lowDiskGuardEnabledForLane(hqRoot, lane);
                     return withResumeHireAdmission(ctx, lane, () => {
                         if (admission.action === "queue") {
                             const sessionId = lane.provider_session_id;
@@ -439,6 +441,7 @@ export function createLaneResumeHandlers(deps) {
                             });
                         }
                         const started = spawnLaneWorker(hqRoot, lane, {
+                            lowDiskGuardEnabled: guardEnabled,
                             env: ctx.env,
                             modelDeps: {
                                 readFileSync: ctx.readFileSync,

package/dist/commands/lanes.js

@@ -32,8 +32,9 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
-import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
+import { readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
+import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
+import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
@@ -58,10 +59,10 @@ import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, lan
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, DEAD_HOST_MS, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, isFinishedResumableHireChild, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, DEAD_HOST_MS, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { laneStories, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
-import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
@@ -475,10 +476,10 @@ function readQuestionBody(hqRoot, question) {
 function loadAllLanes(hqRoot) {
     return readAllLanes(hqRoot);
 }
-function laneHireFields(lane, lanes, aliveChildrenByParent) {
+function laneHireFields(lane, lanes, aliveChildrenByParent, finishedChildrenDoNotCount = false) {
     const aliveChildCount = aliveChildrenByParent
         ? aliveChildrenByParent.get(lane.lane_id) ?? 0
-        : aliveDirectChildren(lanes, lane.lane_id).length;
+        : aliveDirectChildren(lanes, lane.lane_id, finishedChildrenDoNotCount).length;
     const hireGrant = lane.hire_grant ?? 0;
     const hireSummary = `hire ${aliveChildCount}/${hireGrant}`;
     return {
@@ -488,6 +489,15 @@ function laneHireFields(lane, lanes, aliveChildrenByParent) {
         hire_summary: hireSummary,
     };
 }
+function hireGrantFinishedChildrenDoNotCount(ctx, lane) {
+    const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+    const company = resolution.company ?? undefined;
+    return readLanesRegistryFlagFailOff(LANE_HIRE_GRANT_FINISHED_LANES_FLAG, {
+        company,
+        ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+        env: ctx.env,
+    }, readLanesRegistryFlag);
+}
 function mergeOwnerLaneHierarchy(supplied, ownerLanes) {
     const byId = new Map();
     for (const lane of supplied)
@@ -861,6 +871,18 @@ async function fetchOutpostListHireSummaries(ctx, outpostId, lanes, localLanes)
         }
     }
     const hierarchy = mergeOwnerLaneHierarchy(localLanes, ownerLanes);
+    const finishedChildrenDoNotCountByCompany = new Map();
+    const companyByLaneId = new Map();
+    for (const lane of lanes) {
+        const company = resolveLaneCompany(ctx.hqRoot(), lane).company;
+        companyByLaneId.set(lane.lane_id, company);
+        if (!company)
+            continue;
+        const key = `${company.uid}\0${company.slug}`;
+        if (!finishedChildrenDoNotCountByCompany.has(key)) {
+            finishedChildrenDoNotCountByCompany.set(key, await hireGrantFinishedChildrenDoNotCount(ctx, lane));
+        }
+    }
     const outcomes = new Map();
     for (const lane of lanes) {
         const matchingLanes = ownerLanes.filter((ownerLane) => ownerLane.lane_id === lane.lane_id);
@@ -878,7 +900,13 @@ async function fetchOutpostListHireSummaries(ctx, outpostId, lanes, localLanes)
             outcomes.set(lane.lane_id, { error: new LanesError("outpost_lane_hire_summary_invalid", `Outpost ${outpostId} returned a lane owned by a different host`, { outpost_id: outpostId, lane_id: lane.lane_id }) });
             continue;
         }
-        outcomes.set(lane.lane_id, { fields: laneHireFields(ownerLane, hierarchy) });
+        const company = companyByLaneId.get(lane.lane_id) ?? resolveLaneCompany(ctx.hqRoot(), ownerLane).company;
+        const companyKey = company
+            ? `${company.uid}\0${company.slug}`
+            : undefined;
+        outcomes.set(lane.lane_id, {
+            fields: laneHireFields(ownerLane, hierarchy, undefined, companyKey === undefined ? false : finishedChildrenDoNotCountByCompany.get(companyKey) ?? false),
+        });
     }
     return outcomes;
 }
@@ -925,7 +953,14 @@ async function batchOwnerLaneHireFields(ctx, lanes, localLanes, options = {}) {
 }
 const OUTPOST_HIRE_SUMMARY_CONCURRENCY = 4;
 async function laneHirePresentation(ctx, lane, lanes) {
-    const local = laneHireFields(lane, lanes);
+    // The flag only changes the count when a direct child is finished but resumable.
+    const hasFinishedChild = lanes.some((child) => child.senior.kind === "lane" &&
+        child.senior.id === lane.lane_id &&
+        isFinishedResumableHireChild(child.state));
+    const finishedChildrenDoNotCount = hasFinishedChild
+        ? await hireGrantFinishedChildrenDoNotCount(ctx, lane)
+        : false;
+    const local = laneHireFields(lane, lanes, undefined, finishedChildrenDoNotCount);
     if (lane.host.kind !== "outpost" ||
         isTerminalLaneState(lane.state) ||
         laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
@@ -966,7 +1001,12 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         !sameHireGrantSenior(lane.senior, grantContext.expected_senior))) {
         throw new LanesError("hire_grant_senior_changed", `Lane ${lane.lane_id}'s senior changed after the primary authorized its Outpost dispatch`, { lane_id: lane.lane_id, expected_senior: grantContext.expected_senior, current_senior: lane.senior });
     }
-    if (!isTerminalLaneState(lane.state) ||
+    const finishedChildrenDoNotCount = isFinishedResumableHireChild(lane.state)
+        ? await hireGrantFinishedChildrenDoNotCount(ctx, lane)
+        : false;
+    const shouldCheckGrant = isTerminalLaneState(lane.state) ||
+        (finishedChildrenDoNotCount && isFinishedResumableHireChild(lane.state));
+    if (!shouldCheckGrant ||
         lane.senior.kind !== "lane" ||
         !lane.senior.id) {
         return fn();
@@ -1000,13 +1040,15 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         }
         // 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))
+        const currentNeedsGrantCheck = isTerminalLaneState(current.state) ||
+            (finishedChildrenDoNotCount && isFinishedResumableHireChild(current.state));
+        if (!currentNeedsGrantCheck)
             return fn();
-        const refusal = terminalChildResumeHireGrantError(current, snapshot);
+        const refusal = terminalChildResumeHireGrantError(current, snapshot, finishedChildrenDoNotCount);
         if (refusal !== null)
             throw refusal;
         return fn();
-    }, suppliedHierarchy, remoteSenior === undefined ? undefined : new Set([remoteSenior.lane_id]));
+    }, suppliedHierarchy, remoteSenior === undefined ? undefined : new Set([remoteSenior.lane_id]), finishedChildrenDoNotCount);
 }
 const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
 const MAX_PLACEMENT_OUTPOSTS = 16;
@@ -3520,6 +3562,10 @@ async function runCreate(ctx, opts) {
         if (senior.kind === "lane" && senior.id) {
             await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), new Set([senior.id]));
         }
+        const seniorLane = senior.kind === "lane" ? readLane(hqRoot, senior.id) : undefined;
+        const finishedChildrenDoNotCount = seniorLane
+            ? await hireGrantFinishedChildrenDoNotCount(ctx, seniorLane)
+            : false;
         const lane = senior.kind === "lane"
             ? withHireGrantAdmission(hqRoot, senior.id, ({ parent, children, parentGrant, availableChildGrant }) => {
                 if (isTerminalLaneState(parent.state)) {
@@ -3540,7 +3586,7 @@ async function runCreate(ctx, opts) {
                     });
                 }
                 return createLane(hqRoot, laneInit);
-            })
+            }, undefined, new Set(), finishedChildrenDoNotCount)
             : createLane(hqRoot, laneInit);
         return { lane, admission, validation };
     };
@@ -3606,6 +3652,7 @@ async function runCreate(ctx, opts) {
     let started = lane;
     if (admission.action === "start") {
         started = spawnLaneWorker(hqRoot, lane, {
+            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, lane),
             env: ctx.env,
             modelDeps: {
                 readFileSync: ctx.readFileSync,
@@ -4360,11 +4407,12 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     }
     if (action === "grant") {
         const ownerLane = dispatchedOwnerLane(ctx, lane.lane_id, outpostId, remote.lane, behavior);
+        const finishedChildrenDoNotCount = await hireGrantFinishedChildrenDoNotCount(ctx, ownerLane);
         printJson({
             ...remote,
             lane_id: ownerLane.lane_id,
             lane: ownerLane,
-            ...laneHireFields(ownerLane, grantHierarchy ?? []),
+            ...laneHireFields(ownerLane, grantHierarchy ?? [], undefined, finishedChildrenDoNotCount),
             outpost_id: outpostId,
             outpost_command_id: dispatched.commandId,
             outpost_transport: "outposts_exec",
@@ -4729,6 +4777,7 @@ async function runPickup(ctx, opts) {
         }
         try {
             return spawnLaneWorker(hqRoot, current, {
+                lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, current),
                 env: ctx.env,
                 modelDeps: {
                     readFileSync: ctx.readFileSync,
@@ -4874,10 +4923,28 @@ async function runList(ctx, opts) {
     const now = ctx.now();
     const host = reconcileHostFromCtx(ctx);
     const allLanes = laneSource;
+    const lanesById = new Map(allLanes.map((lane) => [lane.lane_id, lane]));
+    const companiesForHireFlags = new Map();
+    const resolvedCompanyByLaneId = new Map();
+    for (const lane of allLanes) {
+        const company = resolveLaneCompany(hqRoot, lane).company;
+        resolvedCompanyByLaneId.set(lane.lane_id, company);
+        if (company)
+            companiesForHireFlags.set(`${company.uid}\0${company.slug}`, lane);
+    }
+    const finishedChildrenFlagByCompany = new Map();
+    await Promise.all([...companiesForHireFlags].map(async ([key, lane]) => {
+        finishedChildrenFlagByCompany.set(key, await hireGrantFinishedChildrenDoNotCount(ctx, lane));
+    }));
     const aliveChildrenByParent = new Map();
     for (const child of allLanes) {
         if (child.senior.kind !== "lane" || !child.senior.id || isTerminalLaneState(child.state))
             continue;
+        const parent = lanesById.get(child.senior.id);
+        const parentCompany = parent ? resolvedCompanyByLaneId.get(parent.lane_id) : undefined;
+        const flagKey = parentCompany ? `${parentCompany.uid}\0${parentCompany.slug}` : undefined;
+        if (flagKey !== undefined && finishedChildrenFlagByCompany.get(flagKey) && isFinishedResumableHireChild(child.state))
+            continue;
         aliveChildrenByParent.set(child.senior.id, (aliveChildrenByParent.get(child.senior.id) ?? 0) + 1);
     }
     const ownerEligibleLaneIds = new Set();
@@ -4933,7 +5000,12 @@ async function runList(ctx, opts) {
             story_ids: laneStories(lane).map((story) => story.story_id),
             no_story_reason: lane.no_story_reason ?? null,
             ...(remoteQueued
-                ? { state: "remote", remote_state: lane.state, queued_reason: undefined, queued_details: undefined }
+                ? {
+                    state: "remote",
+                    remote_state: lane.state,
+                    queued_reason: lane.queued_reason === "low_disk" ? lane.queued_reason : undefined,
+                    queued_details: lane.queued_reason === "low_disk" ? lane.queued_details : undefined,
+                }
                 : {}),
             overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
             stalled: Boolean(lane.stalled),
@@ -4982,8 +5054,11 @@ function formatLaneListHuman(lanes) {
         const storyLabel = ids.length > 0
             ? "stories: " + ids.join(", ")
             : "no story: " + (lane.no_story_reason ?? "reason not recorded");
+        const queueLabel = (lane.state === "queued" || lane.remote_state === "queued") && lane.queued_reason === "low_disk"
+            ? `  queued: low_disk (HQ ${lane.queued_details?.reason === "low_disk" ? lane.queued_details.hq_free_bytes : "?"} bytes; provider ${lane.queued_details?.reason === "low_disk" ? lane.queued_details.provider_free_bytes : "?"} bytes free)`
+            : "";
         return lane.lane_id + "  " + lane.state + "  " + lane.provider + "  " + lane.project_id +
-            "  " + storyLabel;
+            "  " + storyLabel + queueLabel;
     });
     if (rows.length === 0)
         rows.push("No lanes.");
@@ -5050,6 +5125,45 @@ async function runCapacity(ctx) {
     });
     printJson(snapshot);
 }
+async function runGcRollouts(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const lanes = readAllLanes(hqRoot);
+    const companies = new Map();
+    for (const lane of lanes) {
+        const company = resolveLaneCompany(hqRoot, lane).company;
+        if (company)
+            companies.set(company.uid ?? company.slug, company);
+    }
+    if (companies.size === 0) {
+        const company = await ctx.resolveCompany();
+        companies.set(company.uid ?? company.slug, company);
+    }
+    let enabled = false;
+    for (const company of companies.values()) {
+        enabled ||= await readLanesRegistryFlag(CODEX_ROLLOUT_RETENTION_FLAG, {
+            company,
+            companyUidSource: "resolved_lane_company",
+            env: ctx.env,
+        });
+        if (enabled)
+            break;
+    }
+    if (!enabled) {
+        printJson({ ok: true, action: "gc-rollouts", enabled: false, dry_run: Boolean(opts.dryRun), scanned: 0, compressed: [], deleted: [], bytes_freed: 0 });
+        return;
+    }
+    const config = loadLanesConfig(hqRoot);
+    const homes = configuredCodexRolloutHomes(hqRoot, config, ctx.hostname());
+    const result = await retainCodexRollouts({
+        homes,
+        lanes,
+        nowMs: ctx.now().getTime(),
+        compressAfterMs: config.codex_rollout_compress_after_hours * 60 * 60 * 1000,
+        deleteAfterMs: config.codex_rollout_delete_after_days * 24 * 60 * 60 * 1000,
+        dryRun: opts.dryRun,
+    });
+    printJson({ ok: true, action: "gc-rollouts", enabled: true, dry_run: Boolean(opts.dryRun), ...result });
+}
 async function runOutpostIdentityBackfill(ctx, opts) {
     const id = opts.id?.trim();
     if (!id) {
@@ -5191,7 +5305,13 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane) {
         storedLane.host.kind === "outpost" &&
         !laneRunsHere(storedLane, reconcileHostFromCtx(ctx));
     const lane = remoteQueued
-        ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined, queued_details: undefined }
+        ? {
+            ...storedLane,
+            state: "remote",
+            remote_state: storedLane.state,
+            queued_reason: storedLane.queued_reason === "low_disk" ? storedLane.queued_reason : undefined,
+            queued_details: storedLane.queued_reason === "low_disk" ? storedLane.queued_details : undefined,
+        }
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     const delivery = storedLane.state === "awaiting_input" &&
@@ -5535,8 +5655,9 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
     });
     return updated;
 }
-function printGrantResult(hqRoot, updated, hierarchy) {
-    const fields = laneHireFields(updated, hierarchy ?? loadAllLanes(hqRoot));
+async function printGrantResult(ctx, hqRoot, updated, hierarchy) {
+    const finishedChildrenDoNotCount = await hireGrantFinishedChildrenDoNotCount(ctx, updated);
+    const fields = laneHireFields(updated, hierarchy ?? loadAllLanes(hqRoot), undefined, finishedChildrenDoNotCount);
     printJson({ ok: true, action: "grant", lane_id: updated.lane_id, lane: updated, ...fields });
 }
 /**
@@ -5739,7 +5860,7 @@ async function runGrant(ctx, laneId, opts) {
         return;
     }
     const updated = await applyHireGrant(ctx, initial.lane_id, hireGrant, "senior");
-    printGrantResult(hqRoot, updated);
+    await printGrantResult(ctx, hqRoot, updated);
 }
 async function runApprove(ctx, laneId, opts) {
     const checkpoint = opts.checkpoint?.trim();
@@ -5892,7 +6013,7 @@ async function runGrantOwnerTarget(ctx, laneId, opts) {
     const grantContext = parseOutpostHireGrantContext(opts.grantContext, laneId);
     const hqRoot = ctx.hqRoot();
     const updated = await applyHireGrant(ctx, laneId, hireGrant, "ssm-owner-dispatch", grantContext);
-    printGrantResult(hqRoot, updated, mergeOwnerLaneHierarchy(grantContext.hierarchy, loadAllLanes(hqRoot)));
+    await printGrantResult(ctx, hqRoot, updated, mergeOwnerLaneHierarchy(grantContext.hierarchy, loadAllLanes(hqRoot)));
 }
 async function runBackfillGrants(ctx, opts) {
     if (opts.apply && opts.dryRun) {
@@ -6020,6 +6141,7 @@ async function runAdmit(ctx, laneId, opts) {
             return;
         }
         const started = spawnLaneWorker(hqRoot, lane, {
+            lowDiskGuardEnabled: await lowDiskGuardEnabledForLane(hqRoot, lane),
             env: ctx.env,
             modelDeps: {
                 readFileSync: ctx.readFileSync,
@@ -8797,6 +8919,14 @@ export function registerLanesCommand(parent, deps = {}) {
             await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
         });
     }));
+    lanes
+        .command("gc-rollouts")
+        .description("Compress or remove unreferenced old Codex session rollouts")
+        .option("--dry-run", "Report changes without modifying rollout files")
+        .option("--json", "Emit JSON on stdout (default)")
+        .action(wrap(async (opts) => {
+        await runGcRollouts(ctx, opts);
+    }));
     lanes
         .command("_keep-alive-terminal-trigger <laneId> <version> <dueAt>", { hidden: true })
         .action(wrap(async (laneId, versionText, dueAt) => {

package/dist/fast-core.js

@@ -59,12 +59,13 @@ export async function runFastCore(argv) {
         if (typeof handler !== "function") {
             throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
+        const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const chunks = [];
-        if (entry.readsStdin) {
+        if (readsStdin) {
             for await (const chunk of process.stdin)
                 chunks.push(chunk);
         }
-        const code = await handler(parsed.args, entry.readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        const code = await handler(parsed.args, readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;
@@ -80,12 +81,18 @@ export async function runFastCore(argv) {
         : process.cwd();
     const injectRoot = entry.kind === "shell" || entry.kind === "native" &&
         (entry.shellHqRoot === "live" || entry.shellHqRoot === "reconcile-default" && shouldInjectRoot);
+    const childEnv = {
+        ...(entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : {}),
+        ...(entry.name === "migrate-policy-triggers"
+            ? { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() }
+            : {}),
+    };
     const { code } = runBundledScript({
         asset,
         args: parsed.args,
         cwd,
         ...(injectRoot ? { hqRoot } : {}),
-        env: entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
+        ...(Object.keys(childEnv).length ? { env: childEnv } : {}),
     });
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);

package/dist/fast-scaffold.d.ts

@@ -40,6 +40,8 @@ export type FastScaffoldScript = {
     shellHqRoot?: "none" | "live" | "reconcile-default";
     /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
     readsStdin?: boolean;
+    /** Per-invocation stdin policy for handlers whose shell reads conditionally. */
+    readsStdinFor?: (args: readonly string[]) => boolean;
     /** Whether the bundled fast-route module closure needs Node's network timeout patch. */
     requiresNodeNetworkCompatibility?: boolean;
 };

package/dist/fast-scaffold.js

@@ -184,6 +184,17 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "live",
         shellHqRoot: "live",
     },
+    ...[
+        { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
+        { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "register-project", modulePath: "./commands/core-register-project-native.js", exportName: "runRegisterProjectFast", asset: "core/scripts/register-project.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "work-mesh-live-rebind", modulePath: "./commands/core-work-mesh-live-rebind-native.js", exportName: "runWorkMeshLiveRebindFast", asset: "core/scripts/work-mesh-live-rebind.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+    ].map((entry) => ({
+        ...entry,
+        kind: "native",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+    })),
     ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
         name: `delegate ${name}`,
         kind: "native",

package/dist/lib/doctor/checks/work-context.js

@@ -89,12 +89,20 @@ function runChecks(deps) {
         message: `Outbox queued depth=${stats.depth} (acked=${stats.acked}).`,
     });
     const showQuarantineReason = stats.quarantined > 0 && outboxQuarantineStatusEnabled();
+    const quarantineDetails = [
+        stats.lastQuarantineHttpStatus !== null
+            ? `HTTP ${stats.lastQuarantineHttpStatus}`
+            : "",
+        stats.lastQuarantineServerCode ?? "",
+    ]
+        .filter(Boolean)
+        .join(" ");
     results.push({
         status: stats.quarantined > 0 ? "WARN" : "PASS",
         checkId: "work-context.outbox-quarantined",
         target: path.join(root, "outbox"),
         message: `Outbox quarantined count=${stats.quarantined}${showQuarantineReason
-            ? ` (last reason=${stats.lastQuarantineReason ?? "unknown"})`
+            ? ` (last reason=${stats.lastQuarantineReason ?? "unknown"}${quarantineDetails ? `; ${quarantineDetails}` : ""})`
             : ""}.`,
     });
     // Default-company mode + migration capability (US-017B)

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

@@ -43,6 +43,9 @@ export declare const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS: number;
 export declare const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
 /** Manager key results must be re-measured within six hours by default. */
 export declare const DEFAULT_KR_FRESHNESS_HOURS = 6;
+export declare const DEFAULT_LOW_DISK_MIN_FREE_BYTES: number;
+export declare const DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS = 24;
+export declare const DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS = 7;
 export declare const DEFAULT_TRACKER_CHECKS: TrackerChecksConfig;
 export declare const DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG: RunawaySearchGuardConfig;
 export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;

package/dist/lib/lanes/config.js

@@ -47,6 +47,9 @@ export const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS = 10 * 60;
 export const DEFAULT_BLOCKER_FRESHNESS_HOURS = 4;
 /** Manager key results must be re-measured within six hours by default. */
 export const DEFAULT_KR_FRESHNESS_HOURS = 6;
+export const DEFAULT_LOW_DISK_MIN_FREE_BYTES = 5 * 1024 ** 3;
+export const DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS = 24;
+export const DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS = 7;
 export const DEFAULT_TRACKER_CHECKS = {
     owner_question_surface_ms: 10 * 60 * 1000,
     open_question_age_ms: 2 * 60 * 60 * 1000,
@@ -455,6 +458,9 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
         liveness: { ...DEFAULT_LIVENESS_WINDOWS },
         tracker: { checks: { ...DEFAULT_TRACKER_CHECKS } },
         runaway_search_guard: { ...DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG },
+        low_disk_min_free_bytes: DEFAULT_LOW_DISK_MIN_FREE_BYTES,
+        codex_rollout_compress_after_hours: DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS,
+        codex_rollout_delete_after_days: DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS,
         session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
         blocker_freshness_hours: DEFAULT_BLOCKER_FRESHNESS_HOURS,
         kr_freshness_hours: DEFAULT_KR_FRESHNESS_HOURS,
@@ -491,6 +497,11 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
                 ? documentedDefaultConfig(deps).providers[provider]
                 : parseProvider(provider, entry, deps);
     }
+    const compressAfterHours = positiveInt(raw.codex_rollout_compress_after_hours, "codex_rollout_compress_after_hours", DEFAULT_CODEX_ROLLOUT_COMPRESS_AFTER_HOURS);
+    const deleteAfterDays = positiveInt(raw.codex_rollout_delete_after_days, "codex_rollout_delete_after_days", DEFAULT_CODEX_ROLLOUT_DELETE_AFTER_DAYS);
+    if (deleteAfterDays * 24 < compressAfterHours) {
+        throw new LanesConfigError("invalid_config", "codex_rollout_delete_after_days must be at least codex_rollout_compress_after_hours / 24", { codex_rollout_compress_after_hours: compressAfterHours, codex_rollout_delete_after_days: deleteAfterDays });
+    }
     return {
         schema_version: typeof raw.schema_version === "string"
             ? raw.schema_version
@@ -500,6 +511,9 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         liveness: parseLiveness(raw.liveness),
         tracker: { checks: parseTrackerChecks(raw.tracker) },
         runaway_search_guard: parseRunawaySearchGuard(raw.runaway_search_guard),
+        low_disk_min_free_bytes: positiveInt(raw.low_disk_min_free_bytes, "low_disk_min_free_bytes", DEFAULT_LOW_DISK_MIN_FREE_BYTES),
+        codex_rollout_compress_after_hours: compressAfterHours,
+        codex_rollout_delete_after_days: deleteAfterDays,
         session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),
         blocker_freshness_hours: positiveNumber(raw.blocker_freshness_hours, "blocker_freshness_hours", DEFAULT_BLOCKER_FRESHNESS_HOURS),
         kr_freshness_hours: positiveNumber(raw.kr_freshness_hours, "kr_freshness_hours", DEFAULT_KR_FRESHNESS_HOURS),

package/dist/lib/lanes/disk-guard.d.ts

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import { type ReadLanesFlagOptions } from "./registry-flag.js";
+import type { LaneRecord, LanesConfig } from "./types.js";
+export declare const LOW_DISK_GUARD_FLAG = "lanes.low-disk-guard";
+export declare const CODEX_ROLLOUT_RETENTION_FLAG = "lanes.codex-rollout-retention";
+export declare const DEFAULT_LOW_DISK_FREE_BYTES: number;
+export declare const DEFAULT_LOW_DISK_FRACTION = 0.02;
+export declare function lowDiskGuardEnabledForLane(hqRoot: string, lane: LaneRecord, readFlag?: (key: string, options: ReadLanesFlagOptions) => Promise<boolean>): Promise<boolean>;
+export interface DiskStats {
+    bsize: number;
+    blocks: number;
+    bavail: number;
+}
+export type StatFs = (target: string) => DiskStats;
+export interface DiskSpaceMeasurement {
+    path: string;
+    free_bytes: number;
+    total_bytes: number;
+    threshold_bytes: number;
+    low: boolean;
+}
+export declare function measureDiskSpace(target: string, statfs?: StatFs, minFreeBytes?: number): DiskSpaceMeasurement;
+export declare function checkLaneDiskSpace(hqRoot: string, providerHome: string, statfs?: StatFs, minFreeBytes?: number): {
+    low: boolean;
+    hq: DiskSpaceMeasurement;
+    provider: DiskSpaceMeasurement;
+};
+export interface RolloutLane {
+    provider: string;
+    state: string;
+    provider_session_id?: string;
+    last_resume?: {
+        session_id?: string;
+    };
+}
+export interface RolloutRetentionOptions {
+    homes: string[];
+    lanes: RolloutLane[];
+    nowMs?: number;
+    compressAfterMs?: number;
+    deleteAfterMs?: number;
+    dryRun?: boolean;
+    readdirSync?: typeof fs.readdirSync;
+    statSync?: typeof fs.statSync;
+    readFileSync?: typeof fs.readFileSync;
+    writeFileSync?: typeof fs.writeFileSync;
+    renameSync?: typeof fs.renameSync;
+    unlinkSync?: typeof fs.unlinkSync;
+    utimesSync?: typeof fs.utimesSync;
+    compressFile?: (source: string, target: string) => Promise<number>;
+}
+export interface RolloutRetentionResult {
+    scanned: number;
+    compressed: string[];
+    deleted: string[];
+    bytes_freed: number;
+}
+/**
+ * Codex homes that rollout retention may touch: enabled accounts in the
+ * operator's lanes config file. Without that file the documented defaults
+ * point at the real `~/.codex`, so retention gets no homes at all.
+ */
+export declare function configuredCodexRolloutHomes(hqRoot: string, config: LanesConfig, hostname: string): string[];
+/** Operates only on rollout files under configured Codex `sessions/` trees. */
+export declare function retainCodexRollouts(options: RolloutRetentionOptions): Promise<RolloutRetentionResult>;
+//# sourceMappingURL=disk-guard.d.ts.map