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

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

@@ -14,6 +14,7 @@ import { type KnownModelsDeps } from "./models.js";
 import { type LaunchTrigger } from "./delivery.js";
 import { type MachineIdentity } from "./machine-identity.js";
 import { type AdmissionHost } from "./admission.js";
+import { type StatFs } from "./disk-guard.js";
 import { type LaneCompanyRef, type LaneProvider, type LaneRecord, type AccountHistoryEntry } from "./types.js";
 export declare const LANES_RUNS_REL: string;
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -74,6 +75,10 @@ export interface SpawnLaneDeps {
     hostname?: string;
     /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
     admissionHost?: AdmissionHost;
+    /** Resolved per-company by the async command/reconcile boundary. */
+    lowDiskGuardEnabled?: boolean;
+    /** Injected statfs boundary; production uses node:fs.statfsSync. */
+    statfs?: StatFs;
     /** Provider model catalog dependencies, shared with create in tests. */
     modelDeps?: KnownModelsDeps;
     /** Create validated this exact account/model candidate before its admission lock. */

package/dist/lib/lanes/spawn.js

@@ -36,6 +36,7 @@ import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
 import { markAnsweredQuestionsDelivered } from "./questions.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
 import { resolveAdmissionHost } from "./admission-host.js";
+import { checkLaneDiskSpace, lowDiskGuardEnabledForLane } from "./disk-guard.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, ENVELOPE_INVALID_REASON, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -539,7 +540,10 @@ export async function retryLaneOnAlternateAccount(hqRoot, lane, reason, writer =
         });
         if (capacityReason !== undefined || earlierEligibleLane)
             return moved;
-        return spawnLaneWorker(hqRoot, moved, deps);
+        return spawnLaneWorker(hqRoot, moved, {
+            ...deps,
+            lowDiskGuardEnabled: deps.lowDiskGuardEnabled ?? await lowDiskGuardEnabledForLane(hqRoot, moved),
+        });
     });
 }
 export function appendModelFlag(provider, args, model) {
@@ -1802,6 +1806,27 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     if (preservedAccountModel !== undefined)
         pinnedModel = preservedAccountModel;
     const resolved = selection.account;
+    if (deps.lowDiskGuardEnabled === true) {
+        const free = checkLaneDiskSpace(hqRoot, resolved.home, deps.statfs, config.low_disk_min_free_bytes);
+        if (free.low) {
+            const measuredAt = (deps.now ?? (() => new Date()))().toISOString();
+            return retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+                ...current,
+                state: "queued",
+                queued_reason: "low_disk",
+                queued_details: {
+                    reason: "low_disk",
+                    hq_free_bytes: free.hq.free_bytes,
+                    provider_free_bytes: free.provider.free_bytes,
+                    measured_at: measuredAt,
+                },
+                queued_at: current.queued_at ?? measuredAt,
+                admission_reserved_at: undefined,
+                terminal_reason: undefined,
+                terminal_details: undefined,
+            }));
+        }
+    }
     const status = accountStatus(lane.provider, resolved.id, config, { existsSync, hostname });
     if (isLoggedOut(status)) {
         const failed = markPreSpawnFailure

package/dist/lib/lanes/store.js

@@ -612,6 +612,17 @@ export function parseLaneRecord(raw, filePath) {
                 });
             }
         }
+        else if (detailsRecord.reason === "low_disk") {
+            if (raw.state !== "queued" || raw.queued_reason !== "low_disk" ||
+                !Number.isSafeInteger(detailsRecord.hq_free_bytes) || detailsRecord.hq_free_bytes < 0 ||
+                !Number.isSafeInteger(detailsRecord.provider_free_bytes) || detailsRecord.provider_free_bytes < 0) {
+                throw new LaneSchemaError("queued_details must describe measured low-disk queue state", {
+                    path: filePath,
+                    field: "queued_details",
+                });
+            }
+            requireTimestamp(detailsRecord.measured_at, "queued_details.measured_at", filePath);
+        }
         else {
             throw new LaneSchemaError("queued_details must describe a supported queue condition", {
                 path: filePath,

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

@@ -177,7 +177,7 @@ export declare const TERMINAL_LANE_STATES: readonly ["done", "failed", "interrup
 export type TerminalLaneState = (typeof TERMINAL_LANE_STATES)[number];
 export declare const LANE_PROVIDERS: readonly ["claude", "codex", "grok"];
 export type LaneProvider = (typeof LANE_PROVIDERS)[number];
-export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "worker_profile_changed"];
+export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "worker_profile_changed", "low_disk"];
 export type QueuedReason = (typeof QUEUED_REASONS)[number];
 export type QueuedDetails = {
     reason: "worker_profile_changed";
@@ -188,6 +188,11 @@ export type QueuedDetails = {
     reason: "outpost_dispatch_unknown";
     outcome_unknown: true;
     command_id: string | null;
+} | {
+    reason: "low_disk";
+    hq_free_bytes: number;
+    provider_free_bytes: number;
+    measured_at: string;
 };
 export declare function isQueuedReason(value: unknown): value is QueuedReason;
 export declare const HOST_KINDS: readonly ["local", "outpost"];
@@ -1007,6 +1012,11 @@ export interface LanesConfig {
         checks: TrackerChecksConfig;
     };
     runaway_search_guard?: RunawaySearchGuardConfig;
+    /** Optional free-space threshold override for the low-disk admission gate. */
+    low_disk_min_free_bytes?: number;
+    /** Retention ages for Codex session rollout maintenance. */
+    codex_rollout_compress_after_hours?: number;
+    codex_rollout_delete_after_days?: number;
     /** Seconds an unanswered question waits at a session audience before advancing. */
     session_question_timeout_secs: number;
     /** Age in hours after which an open manager blocker must be re-verified. */

package/dist/lib/lanes/types.js

@@ -112,6 +112,7 @@ export const QUEUED_REASONS = [
     "provider_binary_missing",
     "account_retry",
     "worker_profile_changed",
+    "low_disk",
 ];
 export function isQueuedReason(value) {
     return typeof value === "string" && QUEUED_REASONS.includes(value);

package/dist/lib/mesh/client.js

@@ -4,6 +4,7 @@
  * vault HTTP + receipt-shaped responses (US-007A / US-007B).
  */
 import { listActiveMembershipCompanies, meshJson, requireToken, resolveMeshCompany, } from "./api.js";
+import { isWorkSessionDenialCode } from "./denial-codes.js";
 export { meshJson, requireToken, resolveMeshCompany, listActiveMembershipCompanies };
 export async function openMeshTransport(opts) {
     const token = await requireToken();
@@ -50,11 +51,28 @@ export function createWorkSessionDeliverer(opts) {
             const message = err instanceof Error ? err.message : String(err);
             // meshJson throws on !ok with error text; classify by leading status when present.
             const statusMatch = /^(\d{3})\b/.exec(message);
-            if (statusMatch) {
-                const status = Number(statusMatch[1]);
-                if (status === 401 || status === 403) {
-                    return { ok: false, retryable: false, code: "AUTH_DENIED" };
-                }
+            const errorFields = err && typeof err === "object"
+                ? err
+                : {};
+            const status = typeof errorFields.status === "number" &&
+                Number.isInteger(errorFields.status)
+                ? errorFields.status
+                : statusMatch
+                    ? Number(statusMatch[1])
+                    : undefined;
+            if (status === 401 || status === 403) {
+                const serverCode = isWorkSessionDenialCode(errorFields.code)
+                    ? errorFields.code
+                    : undefined;
+                return {
+                    ok: false,
+                    retryable: false,
+                    code: "AUTH_DENIED",
+                    httpStatus: status,
+                    ...(serverCode ? { serverCode } : {}),
+                };
+            }
+            if (status !== undefined) {
                 if (status === 400 || status === 422) {
                     return { ok: false, retryable: false, code: "VALIDATION_FAILED" };
                 }

package/dist/lib/mesh/denial-codes.d.ts

@@ -0,0 +1,5 @@
+/** Explicit 401/403 codes returned by hq-pro's work-session registration path. */
+export declare const WORK_SESSION_DENIAL_CODES: readonly ["AUTH_REQUIRED", "AGENT_IDENTITY_UNVERIFIED", "IMPERSONATION_FORBIDDEN", "NO_PERSON_ENTITY", "INVALID_COMPANY", "WORK_REGISTRY_DISABLED"];
+export type WorkSessionDenialCode = (typeof WORK_SESSION_DENIAL_CODES)[number];
+export declare function isWorkSessionDenialCode(value: unknown): value is WorkSessionDenialCode;
+//# sourceMappingURL=denial-codes.d.ts.map

package/dist/lib/mesh/denial-codes.js

@@ -0,0 +1,14 @@
+/** Explicit 401/403 codes returned by hq-pro's work-session registration path. */
+export const WORK_SESSION_DENIAL_CODES = [
+    "AUTH_REQUIRED",
+    "AGENT_IDENTITY_UNVERIFIED",
+    "IMPERSONATION_FORBIDDEN",
+    "NO_PERSON_ENTITY",
+    "INVALID_COMPANY",
+    "WORK_REGISTRY_DISABLED",
+];
+export function isWorkSessionDenialCode(value) {
+    return typeof value === "string" &&
+        WORK_SESSION_DENIAL_CODES.includes(value);
+}
+//# sourceMappingURL=denial-codes.js.map

package/dist/lib/mesh/live/daemon/doctor.d.ts

@@ -27,6 +27,8 @@ export interface DaemonDoctorReport {
     outboxDepth: number;
     outboxQuarantined?: number;
     outboxLastQuarantineReason?: string;
+    outboxLastQuarantineHttpStatus?: number;
+    outboxLastQuarantineServerCode?: string;
     lastFlushAt?: string;
     lastFlushResult?: DaemonStateFile["lastFlushResult"];
     unhealthy: boolean;

package/dist/lib/mesh/live/daemon/doctor.js

@@ -263,6 +263,8 @@ export function collectDaemonDoctor(deps = {}) {
             ? {
                 outboxQuarantined: outbox.quarantined,
                 outboxLastQuarantineReason: outbox.lastQuarantineReason ?? undefined,
+                outboxLastQuarantineHttpStatus: outbox.lastQuarantineHttpStatus ?? undefined,
+                outboxLastQuarantineServerCode: outbox.lastQuarantineServerCode ?? undefined,
             }
             : {}),
         lastFlushAt: state?.lastFlushAt,
@@ -310,7 +312,15 @@ export function formatDaemonDoctor(report) {
         lines.push(`spool depth: ${report.spoolDepth}`, `held: ${report.heldCount}${report.heldCount > 0 ? " (needs_company; not sent as NONE)" : ""}`, `held with no local evidence: ${report.heldWithNoLocalEvidence}`, `outbox depth: ${report.outboxDepth}`);
     }
     if (report.outboxQuarantined !== undefined) {
-        lines.push(`outbox quarantined: ${report.outboxQuarantined} (last reason=${report.outboxLastQuarantineReason ?? "unknown"})`);
+        const quarantineDetails = [
+            report.outboxLastQuarantineHttpStatus !== undefined
+                ? `HTTP ${report.outboxLastQuarantineHttpStatus}`
+                : "",
+            report.outboxLastQuarantineServerCode ?? "",
+        ]
+            .filter(Boolean)
+            .join(" ");
+        lines.push(`outbox quarantined: ${report.outboxQuarantined} (last reason=${report.outboxLastQuarantineReason ?? "unknown"}${quarantineDetails ? `; ${quarantineDetails}` : ""})`);
     }
     if (report.emitMode !== "legacy" && report.heldCount > 0) {
         lines.push(`held: ${report.heldCount} (needs_company; not sent as NONE)`);

package/dist/lib/search-index/embed-lock.d.ts

@@ -4,6 +4,8 @@ export type EmbedLockDependencies = {
     pid: number;
     random: () => string;
     isProcessAlive: (pid: number) => boolean;
+    /** Test seam for a contender arriving after mkdir and before owner publication. */
+    beforeOwnerPublish?: (ownerFile: string) => void;
     /** Test seam for simulating a competing owner replacing the atomic record. */
     afterOwnerPublish?: (ownerFile: string) => void;
 };

package/dist/lib/search-index/embed-lock.js

@@ -184,8 +184,13 @@ function createAndPublishLock(home, dependencies) {
         // parity: the script's write_owner_record honored the same variable.
         if (dependencies.env.QMD_FORCE_OWNER_WRITE_FAIL)
             throw new Error('forced owner write failure');
+        dependencies.beforeOwnerPublish?.(ownerFile);
         fs.writeFileSync(temporary, `pid=${dependencies.pid}\nts=${dependencies.now()}\nnonce=${nonce}\n`);
-        fs.renameSync(temporary, ownerFile);
+        // renameSync replaces an existing owner on POSIX. A stale reclaim can
+        // replace this ownerless directory while this publisher is paused, so
+        // publish only if this exact generation still has no owner.
+        fs.linkSync(temporary, ownerFile);
+        fs.unlinkSync(temporary);
         dependencies.afterOwnerPublish?.(ownerFile);
         const verified = readOwner(directory);
         if (!verified || verified.pid !== dependencies.pid || verified.nonce !== nonce)
@@ -196,6 +201,10 @@ function createAndPublishLock(home, dependencies) {
     catch {
         // The marker identifies only the directory this process created. Do not
         // recursively remove the fixed lock path after a failed publication.
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* absent after link or moved with a stale generation */ }
         fs.rmSync(marker, { recursive: true, force: true });
         removeDirectoryIfEmpty(directory);
         return false;

package/dist/lib/work-context/contract.d.ts

@@ -61,6 +61,9 @@ export interface ContextResult {
     bindingEpisodeId?: string;
     clientOperationId: string;
     errorCode?: string;
+    /** Sanitized HTTP denial details; raw response bodies are never included. */
+    httpStatus?: number;
+    serverCode?: string;
     /** Why a project was chosen, or why the session is asking. Local consumers only. */
     projectBindReason?: string;
     /** Ranked alternatives when classification is needs_project. */

package/dist/lib/work-context/contract.schema.json

@@ -100,7 +100,9 @@
         "taskId": { "type": "string", "maxLength": 128 },
         "bindingEpisodeId": { "type": "string", "maxLength": 128 },
         "clientOperationId": { "type": "string", "minLength": 1, "maxLength": 128 },
-        "errorCode": { "type": "string", "maxLength": 64 }
+        "errorCode": { "type": "string", "maxLength": 64 },
+        "httpStatus": { "type": "number" },
+        "serverCode": { "type": "string", "maxLength": 64 }
       }
     }
   }

package/dist/lib/work-context/outbox.d.ts

@@ -5,7 +5,7 @@
 import type { DeliveryState } from "./contract.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
-export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "harness", "companyUid", "companySlug", "projectId", "taskId", "companyConfidence", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
+export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "harness", "companyUid", "companySlug", "projectId", "taskId", "companyConfidence", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "lastErrorHttpStatus", "lastServerErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
 /** Base delay for outbox retry backoff (attempt 1 → 30s). */
 export declare const OUTBOX_RETRY_BASE_MS = 30000;
 /** Cap for outbox retry backoff (6 hours). */
@@ -34,6 +34,8 @@ export interface OutboxOperation {
     updatedAt: string;
     attemptCount: number;
     lastErrorCode?: string;
+    lastErrorHttpStatus?: number;
+    lastServerErrorCode?: string;
     receiptId?: string;
     /** Destination company for kind=migrate (source is companyUid). */
     destinationCompanyUid?: string;
@@ -88,8 +90,13 @@ export declare function markOutboxAcked(operationId: string, root: string, recei
 export declare function writeAckedRegisterState(op: OutboxOperation, root: string, receiptId: string, now?: () => Date): void;
 /** Repair older unresolved session projections from acknowledged registrations. */
 export declare function repairAckedRegisterStates(root: string, sessionIds?: ReadonlySet<string>, now?: () => Date): number;
-export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number): OutboxOperation | null;
-export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date): OutboxOperation | null;
+export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number, details?: OutboxErrorDetails): OutboxOperation | null;
+export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date, details?: OutboxErrorDetails): OutboxOperation | null;
+export interface OutboxErrorDetails {
+    httpStatus?: number;
+    serverCode?: string;
+}
+export declare function sanitizeOutboxErrorDetails(details?: OutboxErrorDetails): OutboxErrorDetails;
 /**
  * Requeue quarantined outbox operations so the daemon's replay picks them up
  * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
@@ -119,16 +126,18 @@ export interface OutboxStats {
     queued: number;
     acked: number;
     lastQuarantineReason: string | null;
+    lastQuarantineHttpStatus: number | null;
+    lastQuarantineServerCode: string | null;
 }
 export declare function outboxStats(root: string): OutboxStats;
 export type DeliverFn = (op: OutboxOperation) => Promise<{
     ok: true;
     receiptId: string;
-} | {
+} | ({
     ok: false;
     retryable: boolean;
     code: string;
-}>;
+} & OutboxErrorDetails)>;
 /**
  * Replay queued (and recover lost-receipt) operations.
  * FIFO per sessionId; bounded parallelism across sessions.

package/dist/lib/work-context/outbox.js

@@ -8,6 +8,7 @@ import * as path from "node:path";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 import { atomicWriteJson, ensureOwnerDir } from "./atomic.js";
 import { NotTrackingError } from "./errors.js";
+import { isWorkSessionDenialCode } from "../mesh/denial-codes.js";
 import { readSessionState, stripRegisterReceiptEpisodes, updateSessionState, writeAcknowledgedRegisterBinding, } from "./state.js";
 import { isSafeWorkContextSegment, workContextOutboxDir, workContextOutboxPath, } from "./paths.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
@@ -29,6 +30,8 @@ export const OUTBOX_ALLOWLIST = [
     "updatedAt",
     "attemptCount",
     "lastErrorCode",
+    "lastErrorHttpStatus",
+    "lastServerErrorCode",
     "receiptId",
     "destinationCompanyUid",
     "destinationCompanySlug",
@@ -101,6 +104,11 @@ function projectOutbox(op) {
         out.companyConfidence = op.companyConfidence;
     if (op.lastErrorCode)
         out.lastErrorCode = op.lastErrorCode;
+    if (op.lastErrorHttpStatus !== undefined) {
+        out.lastErrorHttpStatus = op.lastErrorHttpStatus;
+    }
+    if (op.lastServerErrorCode)
+        out.lastServerErrorCode = op.lastServerErrorCode;
     if (op.receiptId)
         out.receiptId = op.receiptId;
     if (op.destinationCompanyUid) {
@@ -337,12 +345,13 @@ export function repairAckedRegisterStates(root, sessionIds, now = () => new Date
     }
     return repaired;
 }
-export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random) {
+export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random, details) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
         return null;
     op.delivery = "queued";
     op.lastErrorCode = errorCode;
+    applyOutboxErrorDetails(op, details);
     op.attemptCount += 1;
     const at = now();
     op.updatedAt = at.toISOString();
@@ -351,17 +360,40 @@ export function markOutboxQueued(operationId, root, errorCode, now = () => new D
     updateOutboxOperation(op, root);
     return op;
 }
-export function markOutboxQuarantined(operationId, root, errorCode, now = () => new Date()) {
+export function markOutboxQuarantined(operationId, root, errorCode, now = () => new Date(), details) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
         return null;
     op.delivery = "quarantined";
     op.lastErrorCode = errorCode;
+    applyOutboxErrorDetails(op, details);
     op.attemptCount += 1;
     op.updatedAt = now().toISOString();
     updateOutboxOperation(op, root);
     return op;
 }
+function applyOutboxErrorDetails(op, details) {
+    delete op.lastErrorHttpStatus;
+    delete op.lastServerErrorCode;
+    const safe = sanitizeOutboxErrorDetails(details);
+    if (safe.httpStatus !== undefined)
+        op.lastErrorHttpStatus = safe.httpStatus;
+    if (safe.serverCode !== undefined)
+        op.lastServerErrorCode = safe.serverCode;
+}
+export function sanitizeOutboxErrorDetails(details) {
+    const safe = {};
+    if (details?.httpStatus !== undefined &&
+        Number.isInteger(details.httpStatus) &&
+        details.httpStatus >= 100 &&
+        details.httpStatus <= 599) {
+        safe.httpStatus = details.httpStatus;
+    }
+    if (isWorkSessionDenialCode(details?.serverCode)) {
+        safe.serverCode = details.serverCode;
+    }
+    return safe;
+}
 /**
  * Requeue quarantined outbox operations so the daemon's replay picks them up
  * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
@@ -389,6 +421,8 @@ export function requeueQuarantinedOutbox(root, opts = {}) {
         op.delivery = "queued";
         op.attemptCount = 0;
         op.lastErrorCode = undefined;
+        op.lastErrorHttpStatus = undefined;
+        op.lastServerErrorCode = undefined;
         op.nextAttemptAt = undefined;
         op.updatedAt = now().toISOString();
         updateOutboxOperation(op, root);
@@ -469,6 +503,15 @@ export function outboxStats(root) {
         queued: ops.filter((o) => o.delivery === "queued").length,
         acked: ops.filter((o) => o.delivery === "acked").length,
         lastQuarantineReason: latestQuarantine?.lastErrorCode ?? null,
+        lastQuarantineHttpStatus: latestQuarantine &&
+            Number.isInteger(latestQuarantine.lastErrorHttpStatus) &&
+            latestQuarantine.lastErrorHttpStatus >= 100 &&
+            latestQuarantine.lastErrorHttpStatus <= 599
+            ? latestQuarantine.lastErrorHttpStatus
+            : null,
+        lastQuarantineServerCode: isWorkSessionDenialCode(latestQuarantine?.lastServerErrorCode)
+            ? latestQuarantine.lastServerErrorCode
+            : null,
     };
 }
 function isOutboxDue(op, nowIso) {
@@ -551,18 +594,18 @@ export async function replayOutbox(root, deliver, opts = {}) {
             }
             else if (result.retryable) {
                 if (op.attemptCount + 1 >= OUTBOX_MAX_ATTEMPTS) {
-                    markOutboxQuarantined(op.operationId, root, `${result.code}_MAX_ATTEMPTS`, now);
+                    markOutboxQuarantined(op.operationId, root, `${result.code}_MAX_ATTEMPTS`, now, result);
                     quarantined += 1;
                 }
                 else {
-                    markOutboxQueued(op.operationId, root, result.code, now, random);
+                    markOutboxQueued(op.operationId, root, result.code, now, random, result);
                     queued += 1;
                 }
                 // Stop this session's FIFO on transient failure.
                 break;
             }
             else {
-                markOutboxQuarantined(op.operationId, root, result.code, now);
+                markOutboxQuarantined(op.operationId, root, result.code, now, result);
                 quarantined += 1;
                 break;
             }

package/dist/lib/work-context/reconcile.js

@@ -14,7 +14,7 @@ import { refineProjectBinding } from "./bind-best.js";
 import { rebindNeedsProjectOnPrompt } from "./prompt-rebind.js";
 import { resolveProjectTask, shouldAskAfter } from "./project.js";
 import { deriveRemoteOwnerSlug, deriveRepoIdentityKey } from "./repo-remote.js";
-import { enqueueOutbox, listOutboxOperations, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, writeAckedRegisterState, } from "./outbox.js";
+import { enqueueOutbox, listOutboxOperations, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, sanitizeOutboxErrorDetails, writeAckedRegisterState, } from "./outbox.js";
 import { mergeLocalSessionFields, isRegisterReceiptEpisodeId, readSessionState, stripRegisterReceiptEpisodes, writeSessionState, } from "./state.js";
 function resultOf(parts) {
     const out = {
@@ -38,6 +38,10 @@ function resultOf(parts) {
         out.bindingEpisodeId = parts.bindingEpisodeId;
     if (parts.errorCode)
         out.errorCode = parts.errorCode;
+    if (parts.httpStatus !== undefined)
+        out.httpStatus = parts.httpStatus;
+    if (parts.serverCode)
+        out.serverCode = parts.serverCode;
     if (parts.projectBindReason)
         out.projectBindReason = parts.projectBindReason;
     if (parts.projectCandidates)
@@ -974,7 +978,8 @@ export async function reconcileObservation(obs, deps) {
         };
     }
     if (delivered.retryable) {
-        markOutboxQueued(outboxOp.operationId, deps.root, delivered.code, nowFn);
+        const details = sanitizeOutboxErrorDetails(delivered);
+        markOutboxQueued(outboxOp.operationId, deps.root, delivered.code, nowFn, undefined, details);
         return {
             result: resultOf({
                 kind: "queued",
@@ -986,15 +991,20 @@ export async function reconcileObservation(obs, deps) {
                 projectId,
                 taskId,
                 errorCode: delivered.code,
+                ...details,
                 ...bindResultFields,
             }),
             exitCode: EXIT_OK,
-            diagnostics: [...diagnostics, `transient ${delivered.code}; remains queued`],
+            diagnostics: [
+                ...diagnostics,
+                `transient ${delivered.code}${formatDeliveryDetails(details)}; remains queued`,
+            ],
             statePath,
             outboxOperationId: outboxOp.operationId,
         };
     }
-    markOutboxQuarantined(outboxOp.operationId, deps.root, delivered.code, nowFn);
+    const details = sanitizeOutboxErrorDetails(delivered);
+    markOutboxQuarantined(outboxOp.operationId, deps.root, delivered.code, nowFn, details);
     return {
         result: resultOf({
             kind: "error",
@@ -1007,13 +1017,24 @@ export async function reconcileObservation(obs, deps) {
             projectId,
             taskId,
             errorCode: delivered.code,
+            ...details,
             ...bindResultFields,
         }),
         exitCode: EXIT_OK,
-        diagnostics: [...diagnostics, `quarantined: ${delivered.code}`],
+        diagnostics: [
+            ...diagnostics,
+            `quarantined: ${delivered.code}${formatDeliveryDetails(details)}`,
+        ],
         statePath,
         outboxOperationId: outboxOp.operationId,
     };
 }
+function formatDeliveryDetails(details) {
+    const parts = [
+        details.httpStatus !== undefined ? `HTTP ${details.httpStatus}` : "",
+        details.serverCode ?? "",
+    ].filter(Boolean);
+    return parts.length ? ` (${parts.join(" ")})` : "";
+}
 export { replayOutbox };
 //# sourceMappingURL=reconcile.js.map

package/dist/main.d.ts

@@ -12,6 +12,25 @@ import { upgradeToTeam } from "./utils/team-upgrade.js";
  * finalization; command execution itself does not consume this allowance.
  */
 export declare const FOREGROUND_NETWORK_BUDGET_MS = 1500;
+/**
+ * Shared accounting for awaited foreground network work. Each lifecycle phase
+ * debits only the bounded await it performs; ordinary command runtime leaves
+ * the allowance untouched. Earlier phases reserve the finalization floor, so
+ * error flushing cannot disappear after a long command.
+ */
+declare class ForegroundNetworkBudget {
+    private readonly budgetMs;
+    private readonly now;
+    private consumedMs;
+    constructor(budgetMs?: number, now?: () => number);
+    timeoutFor(phaseMaximumMs: number, reservedMs?: number): number;
+    waitFor<T>(phaseMaximumMs: number, reservedMs: number, work: (timeoutMs: number) => Promise<T>): Promise<T | undefined>;
+}
+/** Create a shared invocation budget; exported so the time accounting is directly testable. */
+export declare function createForegroundNetworkBudget(options?: {
+    budgetMs?: number;
+    now?: () => number;
+}): ForegroundNetworkBudget;
 export type StreamErrorDependencies = {
     stderr: Pick<typeof process.stderr, "write">;
     exit: (code: number) => void;
@@ -30,4 +49,5 @@ export type TopLevelErrorDependencies = {
 };
 /** Classify a top-level failure without making the CLI process boundary opaque to tests. */
 export declare function handleTopLevelError(err: unknown, deps?: TopLevelErrorDependencies): Promise<void>;
+export {};
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -108,6 +108,13 @@ class ForegroundNetworkBudget {
         }
     }
 }
+/** Create a shared invocation budget; exported so the time accounting is directly testable. */
+export function createForegroundNetworkBudget(options = {}) {
+    if (options.budgetMs === undefined && options.now === undefined) {
+        return new ForegroundNetworkBudget();
+    }
+    return new ForegroundNetworkBudget(options.budgetMs ?? FOREGROUND_NETWORK_BUDGET_MS, options.now ?? (() => performance.now()));
+}
 let activeForegroundNetworkBudget;
 /**
  * The RUNNING install's own entrypoint (`<pkg>/dist/index.js`), used as the
@@ -193,7 +200,7 @@ program.hook("preAction", async () => {
     });
 });
 export async function runCli() {
-    const foregroundNetworkBudget = new ForegroundNetworkBudget();
+    const foregroundNetworkBudget = createForegroundNetworkBudget();
     activeForegroundNetworkBudget = foregroundNetworkBudget;
     // Login must be usable before any identity or company is available, so do
     // not make a pre-auth feature-flag request on this path. Other commands

package/dist/utils/core-eval-trigger.d.ts

@@ -0,0 +1,4 @@
+/** Return shell-compatible 0/1/2: true, false, or malformed. */
+export declare function evaluateTrigger(expr: string, facts?: string): number;
+export declare function checkTriggerExpressions(stdin: string): string;
+//# sourceMappingURL=core-eval-trigger.d.ts.map