@indigoai-us/hq-cli 5.345.126 → 5.345.128

package/dist/commands/lanes.js

@@ -45,7 +45,7 @@ import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFoc
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
 import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, LANE_CONDUCT_LOOP_FLAG, LANE_ENVELOPE_REPAIR_GUIDANCE_FLAG, } from "../lib/lanes/flag-keys.js";
 import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
-import { enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
+import { commitIdleLoopStop, enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
 import { runLaneLoopController, startLaneLoopController } from "./lanes-loop.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
@@ -76,6 +76,7 @@ import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { remoteControlSelectionConfig, remoteControlSessionHome } from "../lib/lanes/remote-control-lane.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, childrenHoldingHireGrantCarve, laneHoldsHireGrantCarve, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, syncLaneToProjectStoryLedger, removeLaneFromProjectStoryLedger, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, isLaneProvider, 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, isFailedQuotaKeepAliveLane, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { admitQueuedNow } from "../lib/lanes/reconcile.js";
 import { laneStories, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "../lib/lanes/lane-company.js";
@@ -490,6 +491,82 @@ function livenessDepsFromCtx(ctx) {
         hostname: ctx.hostname,
     };
 }
+/**
+ * Admit queued lanes in-process after a command frees or adds capacity, so
+ * the queue drains without `hq daemon`. Best effort: an admission failure is
+ * reported on stderr and never fails the command that freed the slot.
+ */
+async function admitQueuedFromCtx(ctx) {
+    try {
+        const result = await admitQueuedNow(ctx.hqRoot(), {
+            now: ctx.now,
+            host: reconcileHostFromCtx(ctx),
+            dryRun: false,
+            spawnLaneDeps: {
+                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,
+            },
+            throttleDeps: ctx.throttleDeps,
+            livenessDeps: livenessDepsFromCtx(ctx),
+            presenceConnected: ctx.presenceConnected,
+            mesh: ctx.mesh,
+            env: ctx.env,
+        });
+        for (const error of result.errors) {
+            process.stderr.write(`hq lanes: queue admission: ${error.message}\n`);
+        }
+        return result.admitted;
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: queue admission failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        return [];
+    }
+}
+/**
+ * End a queued loop lane whose queue holds only a stop envelope and whose
+ * controller is not running. Without this the lane waits for admission just
+ * to read the stop, and counts as busy for its worker until then.
+ */
+async function finalizeIdleLoopStop(ctx, lane) {
+    if (lane.loop_mode !== true || lane.state !== "queued")
+        return undefined;
+    const hqRoot = ctx.hqRoot();
+    const runDirPath = runDir(hqRoot, lane.lane_id);
+    if (loopControllerIsAlive(runDirPath))
+        return undefined;
+    if (!commitIdleLoopStop(runDirPath, lane.lane_id, ctx.now))
+        return undefined;
+    let stopped;
+    try {
+        stopped = casUpdateLane(hqRoot, lane.lane_id, (current) => {
+            if (current.state !== "queued") {
+                throw new LanesError("lane_state_changed", `Lane ${lane.lane_id} left the queue while its stop was committed`, { lane_id: lane.lane_id, state: current.state });
+            }
+            return {
+                ...current,
+                state: "done",
+                queued_reason: undefined,
+                queued_details: undefined,
+                admission_reserved_at: undefined,
+                terminal_reason: "loop_stopped",
+            };
+        });
+    }
+    catch (err) {
+        if (err instanceof LanesError && err.error === "lane_state_changed")
+            return undefined;
+        throw err;
+    }
+    await emitLaneTerminalStateSoft(ctx, stopped);
+    return stopped;
+}
 function reconcileHostFromCtx(ctx) {
     return resolveAdmissionHost({
         hostname: ctx.hostname,
@@ -3522,6 +3599,17 @@ async function runCreate(ctx, opts) {
         throw new LanesError("lane_title_requires_remote_control", "--title is only supported with --remote-control", {});
     }
     const continuityEnabled = opts.remoteControl !== true && opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env, defaultValue: true });
+    // A lane that waits only on the admitter (a queued loop lane holding just a
+    // stop, or a queued lane with free capacity) is not busy: finish it here.
+    const preCreateAdmitted = [];
+    if (continuityEnabled) {
+        const workerId = resolvedWorker?.id ?? opts.worker;
+        const waiting = loadAllLanes(hqRoot).filter((lane) => lane.worker === workerId && lane.provider === provider && lane.state === "queued");
+        for (const lane of waiting)
+            await finalizeIdleLoopStop(ctx, lane);
+        if (waiting.length > 0)
+            preCreateAdmitted.push(...await admitQueuedFromCtx(ctx));
+    }
     let workerContinuity = continuityEnabled
         ? findWorkerContinuityLane(loadAllLanes(hqRoot), {
             senior,
@@ -4337,10 +4425,19 @@ async function runCreate(ctx, opts) {
                 : undefined,
         });
     }
+    // Admit queued lanes (older ones first) now that this create has settled.
+    // Outpost lanes are admitted on their Outpost.
+    const admitted = [...preCreateAdmitted];
+    if (!outpostId) {
+        admitted.push(...await admitQueuedFromCtx(ctx));
+        if (admitted.some((entry) => entry.id === started.lane_id))
+            started = readLane(hqRoot, started.lane_id);
+    }
     if (!opts.quiet)
         printJson({
             ok: true,
             action: "create",
+            admitted,
             lane_id: started.lane_id,
             state: started.state,
             queued_reason: started.queued_reason ?? null,
@@ -7410,7 +7507,7 @@ async function prepareAccountMove(ctx, lane, input) {
     });
     const block = quotaBlockFor(loadQuotaState(hqRoot), lane.provider, target, model, now);
     if (block.blocked) {
-        throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} is held${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}${block.marker ? ` (${block.marker})` : ""}. Clear the hold with: hq lanes accounts clear-quota ${lane.provider} ${target}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null, clear_command: `hq lanes accounts clear-quota ${lane.provider} ${target}` });
+        throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} cannot run model ${model ?? "(default)"}: the account's model needs credits${block.marker ? ` (${block.marker})` : ""}. Once credits are added, clear the marker with: hq lanes accounts clear-quota ${lane.provider} ${target}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null, clear_command: `hq lanes accounts clear-quota ${lane.provider} ${target}` });
     }
     if (model !== undefined) {
         validateLaneModel(lane.provider, model, targetHome, {
@@ -8705,8 +8802,18 @@ async function runStop(ctx, laneId, reason, quiet = false) {
         const queued = enqueueLoopEnvelope({ runDir: runDirPath, laneId: lane.lane_id, envelope: { kind: "stop" }, now: ctx.now });
         if (!controllerAlive && lane.state !== "queued")
             startLaneLoopController(ctx, lane.lane_id);
+        const finalized = !controllerAlive ? await finalizeIdleLoopStop(ctx, readLane(hqRoot, lane.lane_id)) : undefined;
+        const admitted = await admitQueuedFromCtx(ctx);
         if (!quiet)
-            printJson({ ok: true, action: "stop", lane_id: lane.lane_id, terminal: false, queued_stop: queued });
+            printJson({
+                ok: true,
+                action: "stop",
+                lane_id: lane.lane_id,
+                terminal: finalized !== undefined,
+                queued_stop: queued,
+                ...(finalized ? { lane: finalized } : {}),
+                admitted,
+            });
         return;
     }
     if (isTerminalLaneState(lane.state)) {
@@ -8744,6 +8851,7 @@ async function runStop(ctx, laneId, reason, quiet = false) {
     }
     await emitLaneTerminalStateSoft(ctx, updated);
     const cancelled = cancelPendingQuestionsForLane(hqRoot, laneId, at);
+    const admitted = await admitQueuedFromCtx(ctx);
     if (!quiet)
         printJson({
             ok: true,
@@ -8752,6 +8860,7 @@ async function runStop(ctx, laneId, reason, quiet = false) {
             terminal: true,
             resumable: false,
             cancelled_questions: cancelled.map((q) => q.question_id),
+            admitted,
         });
 }
 /** Stderr notice that `stop` ends a lane for good, naming the resumable path. */
@@ -9540,6 +9649,7 @@ export function registerLanesCommand(parent, deps = {}) {
         readClaudeAccountBalanceSignalsEnabled,
         reconcileHostFromCtx,
         resolveCallerPath,
+        admitQueuedFromCtx,
     });
     const questionHandlers = createLaneQuestionsHandlers({
         CAPACITY_PROBE_TIMEOUT_MS,

package/dist/commands/skill.js

@@ -190,16 +190,21 @@ function displayNameFromSlug(slug) {
         .join(" ");
 }
 export function makeSkillTemplate(input) {
-    const name = input.name?.trim() || displayNameFromSlug(input.slug);
+    // Frontmatter `name` is the slash-command name in Claude Code and Codex, so it
+    // must be the slug. A spaced display title there breaks command entry in the
+    // Claude desktop app. The display title goes in frontmatter `title` (which
+    // HQ Pro shows in the console) and in the heading.
+    const title = input.name?.trim() || displayNameFromSlug(input.slug);
     const description = input.description?.trim() ?? "";
     return [
         "---",
-        `name: ${JSON.stringify(name)}`,
+        `name: ${JSON.stringify(input.slug)}`,
+        `title: ${JSON.stringify(title)}`,
         `description: ${JSON.stringify(description)}`,
         "tags: []",
         "---",
         "",
-        `# ${name}`,
+        `# ${title}`,
         "",
         "Describe when and how to use this skill.",
         "",
@@ -466,7 +471,7 @@ export function registerSkillCommand(program, deps = {}) {
     skill
         .command("create <slug>")
         .description("Register, stamp, surface, and sync a company skill")
-        .option("--name <name>", "Display name when creating a new template")
+        .option("--name <name>", "Display title for a new template, written as frontmatter title (frontmatter name is always the slug)")
         .option("--description <text>", "Description when creating a new template")
         .option("--no-sync", "Register locally without uploading the stamped file")
         .option("--surface-only", "Refresh local skill discovery without registration or sync")

package/dist/fast-scaffold.js

@@ -160,6 +160,30 @@ export function isDefaultOnFastFamily(flagKey) {
 }
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
+    {
+        name: "hq-detach",
+        kind: "native",
+        modulePath: "./commands/core-bucket-c-hq-detach-fast.js",
+        exportName: "runHqDetachFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-bucket-c",
+        asset: "core/scripts/hq-detach.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "handoff-knowledge-commit",
+        kind: "native",
+        modulePath: "./commands/core-bucket-c-handoff-knowledge-fast.js",
+        exportName: "runHandoffKnowledgeCommitFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-bucket-c",
+        asset: "core/scripts/handoff-knowledge-commit.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
     {
         name: "work-mesh-project-registration-offer",
         kind: "native",
@@ -897,6 +921,10 @@ export function isFastCoreRequest(argv) {
 }
 /** Metadata-only help can render without importing the selected command graph. */
 export function isCommandHelpRequest(argv) {
+    // `core` owns the argument parser even when global options appear before
+    // its subcommand; its child commands pass --help through to their handlers.
+    if (argv[2] === "core" || argv[2] === "run")
+        return false;
     const args = argv.slice(2);
     const delimiter = args.indexOf("--");
     const beforeDelimiter = delimiter === -1 ? args : args.slice(0, delimiter);

package/dist/lib/capacity/lane-login.js

@@ -82,6 +82,7 @@ function canonicalHome(home, homedir) {
 }
 function handlerDeps(printJson) {
     return {
+        admitQueuedFromCtx: async () => [],
         automaticBalanceMoveHistoryReason: () => unused("automaticBalanceMoveHistoryReason"),
         ensureDir: (dir) => {
             fs.mkdirSync(dir, { recursive: true });

package/dist/lib/lanes/accounts.js

@@ -280,7 +280,7 @@ function throwIfQuotaBlocked(block, provider, accountId, identity) {
     const label = accountLabel(accountId, identity);
     const identityFields = identity ? { identity } : {};
     if (block.reason === "account_model_unavailable") {
-        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
+        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}. The account's model needs credits; once they are added, clear the marker with: ${clearQuotaCommand(provider, accountId)}`, {
             provider,
             account: accountId,
             model: block.model ?? null,
@@ -289,7 +289,7 @@ function throwIfQuotaBlocked(block, provider, accountId, identity) {
         });
     }
     const clear = clearQuotaCommand(provider, accountId);
-    throw new AccountResolutionError("account_quota_exhausted", `${label} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}. Clear the hold with: ${clear}`, {
+    throw new AccountResolutionError("account_quota_exhausted", `${label} is marked unavailable for model ${model} (the account's model needs credits). Clear the marker with: ${clear}`, {
         provider,
         account: accountId,
         model: block.model ?? null,

package/dist/lib/lanes/host-capacity.d.ts

@@ -12,6 +12,10 @@ export interface HostCapacityAccount {
     /** Account-wide quota status when this snapshot is produced on its host. */
     quota_held?: boolean;
     quota_reset_at?: string;
+    /** Last recorded provider usage limit on this account. Informational only. */
+    last_quota_hit_at?: string;
+    /** The provider's reset time from that limit, when it named one. Informational only. */
+    provider_reset_at?: string;
     /** Exact lane states used for Claude account balancing; absent on older Outposts. */
     lane_counts?: {
         running: number;

package/dist/lib/lanes/host-capacity.js

@@ -2,7 +2,7 @@ import { accountStatus } from "./accounts.js";
 import { accountMaxRunning } from "./config.js";
 import { laneOccupiesRunningSlot, laneRunsOnHost, } from "./admission.js";
 import { LanesError } from "./errors.js";
-import { quotaBlockFor } from "./quota.js";
+import { quotaBlockFor, quotaHitInfo } from "./quota.js";
 function admissionHost(host) {
     return host.kind === "outpost"
         ? { hostname: "", outpostId: host.id }
@@ -38,6 +38,7 @@ export function buildHostCapacitySnapshot(input) {
                 ? quotaBlockFor(input.quotaState, provider, id, undefined, input.now)
                 : undefined;
             const quotaResetAt = input.quotaState?.providers[provider]?.[id]?.all_models_quota_reset_at;
+            const hit = input.quotaState ? quotaHitInfo(input.quotaState, provider, id, input.now) : undefined;
             accounts[id] = {
                 enabled: account.enabled,
                 logged_in: status.logged_in,
@@ -51,6 +52,8 @@ export function buildHostCapacitySnapshot(input) {
                         ...(quotaResetAt ? { quota_reset_at: quotaResetAt } : {}),
                     }
                     : {}),
+                ...(hit?.last_quota_hit_at ? { last_quota_hit_at: hit.last_quota_hit_at } : {}),
+                ...(hit?.provider_reset_at ? { provider_reset_at: hit.provider_reset_at } : {}),
                 lane_counts: {
                     running: liveLanes.filter((lane) => lane.state === "running").length,
                     queued: liveLanes.filter((lane) => lane.state === "queued").length,
@@ -142,6 +145,12 @@ export function parseHostCapacitySnapshot(raw) {
                 ...(account.quota_reset_at !== undefined
                     ? { quota_reset_at: account.quota_reset_at }
                     : {}),
+                ...(typeof account.last_quota_hit_at === "string" && Number.isFinite(Date.parse(account.last_quota_hit_at))
+                    ? { last_quota_hit_at: account.last_quota_hit_at }
+                    : {}),
+                ...(typeof account.provider_reset_at === "string" && Number.isFinite(Date.parse(account.provider_reset_at))
+                    ? { provider_reset_at: account.provider_reset_at }
+                    : {}),
                 ...(account.lane_counts !== undefined
                     ? { lane_counts: parseLaneCounts(account.lane_counts, `${provider}.${id}.lane_counts`) }
                     : {}),

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

@@ -44,8 +44,8 @@ export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PRO
 export type { AccountResolveContext, AccountStatus, AuthState, ClaudeIdentity, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
-export type { AnsweredLaneWakeResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, admitQueuedNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export type { AnsweredLaneWakeResult, AdmitQueuedNowResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export type { ProviderPathEnv, ReconcileInstallOpts, ReconcileInstallResult, RunCommand, RunCommandResult, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";

package/dist/lib/lanes/index.js

@@ -24,7 +24,7 @@ export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO,
 export { effectiveAccountHome, } from "./account-home.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, admitQueuedNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";
 export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeResultRejection, parseCodexTurnFailed, parseGrokErrorOutput, parseProviderRejection, readProviderRejection, retryableFromStatus, } from "./provider-rejection.js";

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

@@ -178,6 +178,14 @@ export declare function applyLoopStallAnswer(input: {
     action: "requeued" | "parked" | "already_applied";
 } | undefined;
 export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
+/**
+ * Commit a stop envelope that is the only thing left in an idle loop lane's
+ * queue: no phase is active and the stop is the FIFO head. The loop
+ * controller would do exactly this on its next claim; doing it in-process
+ * lets a queued loop lane end without waiting for admission. Returns false
+ * and changes nothing when the queue holds anything ahead of the stop.
+ */
+export declare function commitIdleLoopStop(runDir: string, laneId: string, now?: () => Date): boolean;
 export declare function setLoopControllerPid(runDir: string, laneId: string, pid: number | undefined): void;
 export declare function clearLoopControllerPid(runDir: string, laneId: string, pid: number): void;
 export declare function loopControllerIsAlive(runDir: string): boolean;

package/dist/lib/lanes/loop.js

@@ -596,6 +596,41 @@ export function loopStatus(runDir, laneId) {
         updated_at: typeof loop.updated_at === "string" ? loop.updated_at : new Date(0).toISOString(),
     };
 }
+/**
+ * Commit a stop envelope that is the only thing left in an idle loop lane's
+ * queue: no phase is active and the stop is the FIFO head. The loop
+ * controller would do exactly this on its next claim; doing it in-process
+ * lets a queued loop lane end without waiting for admission. Returns false
+ * and changes nothing when the queue holds anything ahead of the stop.
+ */
+export function commitIdleLoopStop(runDir, laneId, now = () => new Date()) {
+    if (envelopeFiles(activeDir(runDir)).length > 0)
+        return false;
+    const head = envelopeFiles(pendingDir(runDir))[0];
+    if (!head)
+        return false;
+    let headRecord;
+    try {
+        headRecord = fileEnvelope(head);
+    }
+    catch {
+        return false;
+    }
+    if (headRecord.envelope.kind !== "stop")
+        return false;
+    const claimed = claimNextLoopEnvelope(runDir);
+    if (!claimed)
+        return false;
+    if (claimed.record.envelope.kind !== "stop") {
+        // Another claimer moved the queue between the check and the claim; put it back.
+        fs.renameSync(claimed.file, path.join(pendingDir(runDir), path.basename(claimed.file)));
+        return false;
+    }
+    const stopped = { schema_version: LOOP_SCHEMA, envelope_id: claimed.record.envelope_id, status: "stopped", started_at: claimed.record.queued_at, finished_at: now().toISOString() };
+    writeResultAt(runDir, claimed.file, claimed.record, stopped);
+    persistStatus(runDir, laneId, { state: "stopped", queue_depth: listLoopQueue(runDir).length, active_envelope_id: null, active_phase: null });
+    return true;
+}
 export function setLoopControllerPid(runDir, laneId, pid) {
     persistStatus(runDir, laneId, { pid });
 }

package/dist/lib/lanes/quota-notice.d.ts

@@ -1,24 +1,24 @@
 /**
- * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ * Tell a lane's senior that a provider usage limit ended that lane.
  *
- * An account-wide hold stops every lane on that account, so the senior needs
- * to see it with the provider's own words and the command that lifts it. One
- * message per (provider, account, hold), so several lanes failing on the same
- * hold produce one notice.
+ * A 429 never holds the account (owner decision 2026-10-14): the lane that
+ * hit it ends resumable and the senior decides. One message per lane exit,
+ * keyed by lane id and record version, so a re-read of the same exit or a
+ * retried append does not send it twice.
  */
-import type { QuotaState } from "./quota.js";
-import { type LaneProvider, type LaneRecord } from "./types.js";
-export interface QuotaHoldNotice {
+import type { QuotaSignal } from "./quota.js";
+import { type LaneRecord } from "./types.js";
+export interface QuotaNotice {
     message_id: string;
     text: string;
 }
-/** Build the notice for the account's current hold, or null when there is none. */
-export declare function quotaHoldNotice(state: QuotaState, provider: LaneProvider, accountId: string, laneId: string): QuotaHoldNotice | null;
+/** The notice for a lane that ended on a usage limit or a needs-credits refusal. */
+export declare function quotaLaneNotice(lane: Pick<LaneRecord, "lane_id" | "version" | "provider" | "account" | "model" | "state" | "terminal_reason" | "quota_reset_at">, quota: QuotaSignal | null): QuotaNotice;
 /**
  * Deliver the notice to the lane's senior inbox. A session senior gets it in
  * its monitor-session inbox, a lane senior in that lane's dropbox. The notice
  * is always written to stderr as well, so a senior with no inbox still has it
  * in the watcher log. Returns where it was delivered.
  */
-export declare function deliverQuotaHoldNotice(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "senior">, notice: QuotaHoldNotice, at: string): "session_inbox" | "lane_inbox" | "stderr_only";
+export declare function deliverQuotaNotice(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "senior">, notice: QuotaNotice, at: string): "session_inbox" | "lane_inbox" | "stderr_only";
 //# sourceMappingURL=quota-notice.d.ts.map

package/dist/lib/lanes/quota-notice.js

@@ -1,39 +1,30 @@
 /**
- * Tell a lane's senior when a provider 429 put an account on a quota hold.
+ * Tell a lane's senior that a provider usage limit ended that lane.
  *
- * An account-wide hold stops every lane on that account, so the senior needs
- * to see it with the provider's own words and the command that lifts it. One
- * message per (provider, account, hold), so several lanes failing on the same
- * hold produce one notice.
+ * A 429 never holds the account (owner decision 2026-10-14): the lane that
+ * hit it ends resumable and the senior decides. One message per lane exit,
+ * keyed by lane id and record version, so a re-read of the same exit or a
+ * retried append does not send it twice.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { monitorSessionDir } from "../monitor.js";
 import { appendDropboxMessageOnce, appendDropboxMessageOnceAtPath } from "./dropbox.js";
 import { LANE_PROVIDERS } from "./types.js";
-/** Build the notice for the account's current hold, or null when there is none. */
-export function quotaHoldNotice(state, provider, accountId, laneId) {
-    const account = state.providers[provider]?.[accountId];
-    const holdUntil = account?.all_models_quota_reset_at;
-    if (!account || !holdUntil)
-        return null;
-    const said = account.provider_text ? `Provider said: "${account.provider_text}".` : "Provider gave no message text.";
-    const clear = `If the account is not actually exhausted (check /usage), clear the hold with: hq lanes accounts clear-quota ${provider} ${accountId}`;
+/** The notice for a lane that ended on a usage limit or a needs-credits refusal. */
+export function quotaLaneNotice(lane, quota) {
+    const providerReset = quota?.provider_reset_at ?? quota?.quota_reset_at ?? lane.quota_reset_at;
+    const what = lane.terminal_reason === "account_model_unavailable"
+        ? `cannot run model ${lane.model ?? "(unknown)"}${quota?.marker ? ` (${quota.marker})` : ""}`
+        : "hit the provider usage limit";
     const lines = [
-        `Quota hold: ${provider} account ${accountId} is held until ${holdUntil}; no lane will run on it until then. Set by lane ${laneId}.`,
-        said,
+        `Lane ${lane.lane_id} ${what} on ${lane.provider} account ${lane.account ?? "(none)"} and stopped as ${lane.state}.`,
+        providerReset ? `The provider says the limit resets at ${providerReset}.` : "The provider did not name a reset time.",
     ];
-    if (account.reset_source === "unconfirmed" && account.unconfirmed_reset_at) {
-        lines.push(`The provider named a reset at ${account.unconfirmed_reset_at}. That is more than a day away, so this is a short hold; the account gets the full hold only if the next lane after it also gets a 429.`);
-    }
-    else if (account.reset_source === "derived") {
-        lines.push("The provider named no reset time, so this is the default hold.");
-    }
-    lines.push(clear);
-    return {
-        message_id: `quota-hold:${provider}:${accountId}:${holdUntil}`,
-        text: lines.join("\n"),
-    };
+    if (quota?.provider_text)
+        lines.push(`Provider said: "${quota.provider_text}".`);
+    lines.push("No account hold was set; other lanes keep using this account.", `To continue this lane: hq lanes resume ${lane.lane_id} (pass --account <id> to use another account).`);
+    return { message_id: `quota-limit:${lane.lane_id}:${lane.version}`, text: lines.join(" ") };
 }
 /**
  * Deliver the notice to the lane's senior inbox. A session senior gets it in
@@ -41,9 +32,9 @@ export function quotaHoldNotice(state, provider, accountId, laneId) {
  * is always written to stderr as well, so a senior with no inbox still has it
  * in the watcher log. Returns where it was delivered.
  */
-export function deliverQuotaHoldNotice(hqRoot, lane, notice, at) {
-    process.stderr.write(`hq lanes: ${notice.text.replace(/\n/g, " ")}\n`);
-    const message = { at, message_id: notice.message_id, kind: "quota_hold", text: notice.text };
+export function deliverQuotaNotice(hqRoot, lane, notice, at) {
+    process.stderr.write(`hq lanes: ${notice.text}\n`);
+    const message = { at, message_id: notice.message_id, kind: "quota_limit", text: notice.text };
     if (lane.senior.kind === "lane" && lane.senior.id) {
         appendDropboxMessageOnce(hqRoot, lane.senior.id, message);
         return "lane_inbox";