@indigoai-us/hq-cli 5.345.130 → 5.345.132

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.132] — 2026-10-14
+- `hq lanes --account auto` and `hq capacity route` no longer refuse every signed-in account when the capacity collector is off or its readings are stale; those accounts are picked with unknown usage, below accounts with fresh headroom.
+- `hq lanes create` now resumes an earlier worker session only when the project, model, and effort match, and otherwise starts a fresh thread.
+- A loop lane starting its next phase now stays running in `hq lanes status` and `hq lanes list` while the phase resumes, instead of showing done for several seconds.
+- A loop lane waiting for its next phase now shows as running in `hq lanes status` and `hq lanes list`, and becomes done only after it is stopped.
+- Recognize Git Bash on Git for Windows 2.56+, which reports `MSYSTEM=UCRT64` instead of `MINGW64`, so delegate jq calls keep their byte-exact output and journal titles with newlines get a valid file name on Windows.
+
 ## [5.345.130] — 2026-10-14
 - Add native TypeScript `hq core workflow run` orchestration with the bundled runner as its flag-off fallback.
 

package/assets/scaffold/core/scripts/hq-delegate-grant.sh

@@ -36,8 +36,9 @@ die()   { echo "hq-delegate-grant: $*" >&2; exit 1; }
 command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 
 # jq.exe on MSYS may use CRT text mode unless --binary is supported.
+# Git for Windows 2.56+ reports MSYSTEM=UCRT64; match every MSYS2 environment.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
-  msys*:*|*:MINGW*)
+  msys*:*|*:MINGW*|*:UCRT*|*:CLANG*|*:MSYS)
     # Probe --binary once per script run, in the top-level shell. Most jq
     # calls run inside $(...) subshells, so a cache filled lazily inside jq()
     # would be lost and the probe would repeat on every call.

package/assets/scaffold/core/scripts/hq-delegate-send.sh

@@ -43,8 +43,9 @@ die()   { echo "hq-delegate-send: $*" >&2; exit 1; }
 command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 
 # jq.exe on MSYS may use CRT text mode unless --binary is supported.
+# Git for Windows 2.56+ reports MSYSTEM=UCRT64; match every MSYS2 environment.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
-  msys*:*|*:MINGW*)
+  msys*:*|*:MINGW*|*:UCRT*|*:CLANG*|*:MSYS)
     _hq_jq_binary_supported=""
     jq() {
       local stdout_file stderr_file status binary_supported

package/assets/scaffold/core/scripts/session-journal.sh

@@ -37,7 +37,7 @@ warn() { echo "session-journal: $*" >&2; }
 
 slugify() {
   # Win32 rejects newline file-name bytes; otherwise keep the POSIX slug pipeline.
-  local slug_input="$1"; if [[ "${OSTYPE:-}" == msys* ]] || [[ "${MSYSTEM:-}" == MINGW* ]]; then slug_input="${slug_input//$'\n'/-}"; fi; printf '%s' "$slug_input" \
+  local slug_input="$1"; if [[ "${OSTYPE:-}" == msys* ]] || [[ "${MSYSTEM:-}" =~ ^(MINGW|UCRT|CLANG|MSYS) ]]; then slug_input="${slug_input//$'\n'/-}"; fi; printf '%s' "$slug_input" \
     | tr '[:upper:]' '[:lower:]' \
     | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//' \
     | cut -c1-40

package/dist/commands/capacity.d.ts

@@ -15,8 +15,7 @@ import { type ClaudeRefreshLastEntry } from "../lib/capacity/collectors/claude-o
 export declare const CAPACITY_SCHEMA_VERSION: "hq-capacity-now-view.v1";
 export declare const DOCTOR_SCHEMA_VERSION = "hq-capacity-doctor.v1";
 export declare const PARSER_FAILURE_WINDOW_MS: number;
-/** now.json older than this is stale: the collector is not keeping the view current. */
-export declare const CAPACITY_STALE_MS: number;
+export { CAPACITY_STALE_MS } from "../lib/capacity/freshness.js";
 /** Short versions inside test/fixtures/capacity/cli-versions.json. */
 export declare const PINNED_CLI_VERSIONS: Record<string, string>;
 export interface CapacityJson extends NowView {

package/dist/commands/capacity.js

@@ -7,6 +7,7 @@ import { LedgerCorrupt, LedgerMissing, READING_SOURCES, capacityOptionsFromEnv,
 import { listCapacityAccounts, registryAccountIds } from "../lib/capacity/accounts.js";
 import { claudeIdentityKeys, readClaudeRefreshLast } from "../lib/capacity/collectors/claude-oauth.js";
 import { projectCapacityView } from "../lib/capacity/project.js";
+import { capacityViewAge } from "../lib/capacity/freshness.js";
 import { capacityWidgetTimeZone, renderCapacityWidget } from "../lib/capacity/widget.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { loadLanesConfig } from "../lib/lanes/config.js";
@@ -18,8 +19,7 @@ import { CapacityUsageError, REFUSAL_HELP, ingestRefusal, } from "../lib/capacit
 export const CAPACITY_SCHEMA_VERSION = nowViewJsonSchema.$id;
 export const DOCTOR_SCHEMA_VERSION = "hq-capacity-doctor.v1";
 export const PARSER_FAILURE_WINDOW_MS = 24 * 60 * 60 * 1000;
-/** now.json older than this is stale: the collector is not keeping the view current. */
-export const CAPACITY_STALE_MS = 5 * 60 * 1000;
+export { CAPACITY_STALE_MS } from "../lib/capacity/freshness.js";
 /** Short versions inside test/fixtures/capacity/cli-versions.json. */
 export const PINNED_CLI_VERSIONS = {
     claude: "2.1.152",
@@ -54,20 +54,18 @@ export function withSchemaVersion(view) {
 }
 /** Stale when generatedAt is missing or older than five minutes. */
 export function capacityFreshness(generatedAt, nowMs) {
-    const at = Date.parse(generatedAt);
-    if (Number.isNaN(at)) {
+    const age = capacityViewAge(generatedAt, nowMs);
+    if (!age.known) {
         return {
             stale: true,
             ageMs: 0,
             message: "collector not running, numbers may be stale; last update unknown",
         };
     }
-    const ageMs = Math.max(0, nowMs - at);
-    const stale = ageMs > CAPACITY_STALE_MS;
     return {
-        stale,
-        ageMs,
-        message: stale
+        stale: age.stale,
+        ageMs: age.ageMs,
+        message: age.stale
             ? `collector not running, numbers may be stale; last update ${formatAge(generatedAt, nowMs)}`
             : null,
     };

package/dist/commands/lanes-loop.d.ts

@@ -1,5 +1,15 @@
 import type { Ctx, LaneResumeOptions } from "./lanes-shared.js";
 import type { LaneRecord } from "../lib/lanes/types.js";
+/**
+ * A loop lane that finished a phase and is waiting for its next envelope is
+ * alive, not finished. The watcher still writes `done` when the phase's worker
+ * exits (the controller reads that as the phase-complete signal); this moves
+ * the lane back to `running`, the same state an admitted loop lane holds
+ * before its first phase. Only a stop makes a loop lane `done`. The next
+ * phase resumes the lane from `running` (`loopIdle`), so it is not written
+ * `done` again while the loop is active.
+ */
+export declare function settleLoopLaneIdle(hqRoot: string, laneId: string): LaneRecord;
 export interface LoopControllerDeps {
     resumeLane(laneId: string, options: LaneResumeOptions): Promise<unknown>;
     interruptLane(laneId: string, reason: string, options: {

package/dist/commands/lanes-loop.js

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { LanesError } from "../lib/lanes/errors.js";
-import { readLane, retryUpdateLane } from "../lib/lanes/store.js";
+import { readLane, retryUpdateLane, updateLane } from "../lib/lanes/store.js";
+import { LanesError, isLaneVersionConflict } from "../lib/lanes/errors.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { raiseLaneQuestion } from "../lib/lanes/questions.js";
@@ -15,6 +15,34 @@ const LOOP_RUNS_REL = path.join("workspace", "lanes-runs");
 function loopRunDir(hqRoot, laneId) {
     return path.join(hqRoot, LOOP_RUNS_REL, laneId);
 }
+/**
+ * A loop lane that finished a phase and is waiting for its next envelope is
+ * alive, not finished. The watcher still writes `done` when the phase's worker
+ * exits (the controller reads that as the phase-complete signal); this moves
+ * the lane back to `running`, the same state an admitted loop lane holds
+ * before its first phase. Only a stop makes a loop lane `done`. The next
+ * phase resumes the lane from `running` (`loopIdle`), so it is not written
+ * `done` again while the loop is active.
+ */
+export function settleLoopLaneIdle(hqRoot, laneId) {
+    for (let attempt = 0;; attempt += 1) {
+        const current = readLane(hqRoot, laneId);
+        if (current.loop_mode !== true || current.state !== "done")
+            return current;
+        try {
+            return updateLane(hqRoot, laneId, current.version, "command", (record) => ({
+                ...record,
+                state: "running",
+                terminal_reason: undefined,
+                terminal_details: undefined,
+            }));
+        }
+        catch (error) {
+            if (!isLaneVersionConflict(error) || attempt >= 4)
+                throw error;
+        }
+    }
+}
 export function startLaneLoopController(ctx, laneId, initialAdmission = false) {
     const entry = process.argv[1];
     if (!entry)
@@ -158,6 +186,7 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                         freshThread: fresh,
                         ...(sessionId ? { loopSessionId: sessionId } : {}),
                         ...(repairError !== undefined ? { loopHandoffRepair: true } : {}),
+                        ...(current.state === "running" ? { loopIdle: true } : {}),
                         workingDirectory: worktree,
                     });
                 }
@@ -187,6 +216,8 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                             if (data.schema === "hq-phase-envelope/v1" && !handoff) {
                                 throw new Error("section 8 phase requires an hq-phase-handoff/v1 object in the lane envelope artifacts");
                             }
+                            if (latest.state === "done")
+                                settleLoopLaneIdle(hqRoot, laneId);
                             return { output: JSON.stringify(handoff ?? envelopeRecord.envelope), ...(latest.provider_session_id ? { sessionId: latest.provider_session_id } : {}) };
                         }
                         await new Promise((resolve) => setTimeout(resolve, 250));

package/dist/commands/lanes-resume.js

@@ -1,6 +1,6 @@
 import { BALANCE_MOVABLE_STATES } from "../lib/lanes/claude-balance.js";
 import { LanesError } from "../lib/lanes/errors.js";
-import { appendCappedHistory, isFailedQuotaKeepAliveLane, providerSessionPortable, providerSupportsSessionResume, readLane, resumeCommandRefusal, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
+import { appendCappedHistory, isFailedQuotaKeepAliveLane, isLoopIdleResumeLane, providerSessionPortable, providerSupportsSessionResume, readLane, resumeCommandRefusal, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
 import { parseCliEffort } from "../lib/lanes/effort.js";
 import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
@@ -164,6 +164,7 @@ export function createLaneResumeHandlers(deps) {
         }
         lane = laneWithRecoveredProviderSession(hqRoot, lane);
         const loopHandoffRepair = isLoopHandoffRepairResume(lane, opts);
+        const loopIdle = isLoopIdleResumeLane(lane, opts.loopIdle);
         if (opts.loopHandoffRepair === true && !loopHandoffRepair) {
             throw new LanesError("loop_handoff_repair_session_mismatch", "Loop handoff repair requires the awaiting-input loop lane's current provider session", { lane_id: laneId, state: lane.state });
         }
@@ -250,7 +251,11 @@ export function createLaneResumeHandlers(deps) {
         }
         const refusal = queuedProfileRecovery || lane.state === "awaiting_input"
             ? null
-            : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane), allowFresh: opts.freshThread === true });
+            : resumeCommandRefusal(lane, {
+                allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane),
+                allowFresh: opts.freshThread === true,
+                allowLoopIdle: loopIdle,
+            });
         if (refusal !== null) {
             throw new LanesError(refusal.error, refusal.message, {
                 lane_id: laneId,
@@ -260,7 +265,10 @@ export function createLaneResumeHandlers(deps) {
             });
         }
         assertLaneRunsHereForAdmission(ctx, lane);
-        const resumedFrom = lane.state;
+        // An idle loop lane resumes from the phase that finished; it stays `running`.
+        const resumedFrom = loopIdle
+            ? "done"
+            : lane.state;
         const text = opts.text?.trim() ? opts.text : undefined;
         const at = ctx.now().toISOString();
         const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
@@ -442,6 +450,7 @@ export function createLaneResumeHandlers(deps) {
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                    ...(loopIdle ? { loopIdle: true } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,
@@ -478,6 +487,7 @@ export function createLaneResumeHandlers(deps) {
                         ...(profileRepin !== undefined ? { profileRepin } : {}),
                         ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                         ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                        ...(loopIdle ? { loopIdle: true } : {}),
                         pending: {
                             trigger: "resume",
                             resumed_from: resumedFrom,
@@ -509,6 +519,7 @@ export function createLaneResumeHandlers(deps) {
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                    ...(loopIdle ? { loopIdle: true } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,
@@ -643,6 +654,7 @@ export function createLaneResumeHandlers(deps) {
                                 kind: "resume",
                                 from: resumedFrom,
                                 ...(opts.freshThread === true ? { fresh: true } : {}),
+                                ...(loopIdle ? { loopIdle: true } : {}),
                                 ...(resumedFrom === "awaiting_input" && (pendingQuestions.length === 0 || loopHandoffRepair) ? { allowAwaitingInput: true } : {}),
                                 ...(opts.fromFailed === true ? { fromFailed: true } : {}),
                                 ...(failedResumeExpectedSenior !== undefined

package/dist/commands/lanes-shared.d.ts

@@ -83,6 +83,11 @@ export interface LaneResumeOptions {
     loopSessionId?: string;
     /** Allows only a section 8 handoff repair to continue a loop lane with a pending question. */
     loopHandoffRepair?: boolean;
+    /**
+     * Internal loop runner: start the next phase of a loop lane that is idle in
+     * `running` between phases. The lane is resumed from `running` directly.
+     */
+    loopIdle?: boolean;
     meshCompany?: string;
     profileRepinContext?: string;
     grantContext?: string;
@@ -121,6 +126,8 @@ export interface PrepareAccountMoveInput {
     refreshProfileSettings?: boolean;
     /** Provenance recorded for the account this move selects. */
     accountSource?: "cli" | "balanced" | "profile";
+    /** The loop controller's next-phase resume of a loop lane idle in `running`. */
+    loopIdle?: boolean;
 }
 export interface RecordResumeSetupInput {
     profile?: ResolvedResumeProfile;

package/dist/commands/lanes.js

@@ -46,8 +46,8 @@ import { registerDaemonLanesReconcileHandler } from "../lib/lanes/daemon-reconci
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 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 { commitIdleLoopStop, enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
+import { applyContinuitySettings, findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
+import { commitIdleLoopStop, enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopLaneIsIdle, 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";
@@ -77,7 +77,7 @@ 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 { 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 { 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, isLoopIdleResumeLane, 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";
@@ -89,8 +89,9 @@ import { writeQuestionBody } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
-import { LedgerCorrupt, capacityOptionsFromEnv, readNow, rebuildNow, } from "../lib/capacity/ledger.js";
+import { LedgerCorrupt, capacityOptionsFromEnv, readCollectorMark, readNow, rebuildNow, } from "../lib/capacity/ledger.js";
 import { pickAccount } from "../lib/capacity/route.js";
+import { capacityViewAge } from "../lib/capacity/freshness.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
@@ -3436,6 +3437,8 @@ async function runCreate(ctx, opts) {
             ...(explicitProvider ? { providers: [explicitProvider] } : {}),
             model: opts.model ?? null,
             now: ctx.now(),
+            collectorEnabled: readCollectorMark(ledgerOptions)?.enabled ?? null,
+            capacityStale: capacityViewAge(view.generatedAt, ctx.now().getTime()).stale,
             lanesError: routeLanesError,
         });
         if (!result.ok || !result.pick) {
@@ -4102,6 +4105,7 @@ async function runCreate(ctx, opts) {
             providerEffort: config.providers[provider].effort,
             model,
         });
+        workerContinuity = applyContinuitySettings(workerContinuity, { project, model, effort: effort.effort });
         if (outpostId) {
             admission = { action: "queue" };
             validation = "pending";
@@ -7414,7 +7418,9 @@ async function prepareAccountMove(ctx, lane, input) {
     const now = ctx.now();
     const laneId = lane.lane_id;
     assertLaneRunsHereForAdmission(ctx, lane);
-    if (lane.state === "running") {
+    // An idle loop lane is `running` with no worker between phases, so its
+    // session can move before the next phase starts.
+    if (lane.state === "running" && !isLoopIdleResumeLane(lane, input.loopIdle)) {
         throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
             lane_id: laneId,
             state: lane.state,
@@ -8914,7 +8920,7 @@ async function runInterrupt(ctx, laneId, reason, options = {}) {
     const queueInterrupt = lane.loop_mode === true && options.preserveLoopQueue !== true
         ? interruptLoopQueue(runDir(hqRoot, lane.lane_id))
         : undefined;
-    if (lane.loop_mode === true && lane.state !== "running") {
+    if (lane.loop_mode === true && (lane.state !== "running" || loopLaneIsIdle(runDir(hqRoot, lane.lane_id), lane.lane_id))) {
         if (!options.quiet)
             printJson({ ok: true, action: "interrupt", lane_id: lane.lane_id, terminal: false, resumable: true, ...queueInterrupt });
         return;

package/dist/lib/capacity/freshness.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Capacity view freshness. Kept in lib (not commands/capacity.ts) so resident
+ * paths such as `hq lanes` can check staleness without pulling in the capacity
+ * command module and its lazy collector imports.
+ */
+/** now.json older than this is stale: the collector is not keeping the view current. */
+export declare const CAPACITY_STALE_MS: number;
+export interface CapacityViewAge {
+    stale: boolean;
+    /** Milliseconds since generatedAt; 0 when generatedAt is missing or unparseable. */
+    ageMs: number;
+    /** False when generatedAt is missing or unparseable. */
+    known: boolean;
+}
+/** Stale when generatedAt is missing or older than CAPACITY_STALE_MS. */
+export declare function capacityViewAge(generatedAt: string, nowMs: number): CapacityViewAge;
+//# sourceMappingURL=freshness.d.ts.map

package/dist/lib/capacity/freshness.js

@@ -0,0 +1,16 @@
+/**
+ * Capacity view freshness. Kept in lib (not commands/capacity.ts) so resident
+ * paths such as `hq lanes` can check staleness without pulling in the capacity
+ * command module and its lazy collector imports.
+ */
+/** now.json older than this is stale: the collector is not keeping the view current. */
+export const CAPACITY_STALE_MS = 5 * 60 * 1000;
+/** Stale when generatedAt is missing or older than CAPACITY_STALE_MS. */
+export function capacityViewAge(generatedAt, nowMs) {
+    const at = Date.parse(generatedAt);
+    if (Number.isNaN(at))
+        return { stale: true, ageMs: 0, known: false };
+    const ageMs = Math.max(0, nowMs - at);
+    return { stale: ageMs > CAPACITY_STALE_MS, ageMs, known: true };
+}
+//# sourceMappingURL=freshness.js.map

package/dist/lib/capacity/route.d.ts

@@ -23,6 +23,11 @@ export declare const LIMIT_STALE_MS: number;
 export declare const FRESH_MS: number;
 /** Score penalty for an account whose binding limit reading is not fresh. */
 export declare const OLD_READING_PENALTY = 10;
+/**
+ * Score for an account ranked with unknown usage (collector off or capacity
+ * view stale). Sits below any account with fresh known headroom.
+ */
+export declare const UNKNOWN_USAGE_SCORE = -100;
 /** Default --floor applied by the CLI (percent headroom to clear). */
 export declare const DEFAULT_FLOOR = 15;
 /** Default --prefer order applied by the CLI. */
@@ -78,6 +83,8 @@ export interface RouteRanked {
     weekly_resets_at: string | null;
     why: string;
     lane_flags: string;
+    /** True when no usable reading exists and the account is ranked as unknown. */
+    usage_unknown: boolean;
 }
 /** Live lane on an account the router would avoid; command names a replacement. */
 export interface RouteMove {

package/dist/lib/capacity/route.js

@@ -42,6 +42,11 @@ export const LIMIT_STALE_MS = 24 * 36e5;
 export const FRESH_MS = 60 * 6e4;
 /** Score penalty for an account whose binding limit reading is not fresh. */
 export const OLD_READING_PENALTY = 10;
+/**
+ * Score for an account ranked with unknown usage (collector off or capacity
+ * view stale). Sits below any account with fresh known headroom.
+ */
+export const UNKNOWN_USAGE_SCORE = -100;
 /** Default --floor applied by the CLI (percent headroom to clear). */
 export const DEFAULT_FLOOR = 15;
 /** Default --prefer order applied by the CLI. */
@@ -197,6 +202,37 @@ export function pickAccount(input) {
     const lanes = input.lanes ?? [];
     const ranked = [];
     const skipped = [];
+    // With the collector off (or its mark missing) or the view stale, readings
+    // never refresh. Missing or old readings then say nothing about the account,
+    // so a signed-in, enabled account is ranked as unknown instead of skipped.
+    const readingsUnreliable = input.collectorEnabled === false
+        || input.collectorEnabled === null
+        || input.capacityStale === true;
+    const rankUnknown = (base, accountId, tokenExpired) => {
+        const live = liveLaneCount(lanes, base.provider, accountId);
+        const whyParts = ["usage unknown, capacity readings are stale or the collector is off"];
+        if (live)
+            whyParts.push(`${live} live lane${live === 1 ? "" : "s"} already on it`);
+        if (tokenExpired)
+            whyParts.push("sign-in renews when the lane starts");
+        ranked.push({
+            provider: base.provider,
+            account: accountId,
+            label: base.label,
+            organization: base.organization,
+            headroom: 0,
+            score: UNKNOWN_USAGE_SCORE - live * LANE_PENALTY,
+            live_lanes: live,
+            reset_soon: false,
+            token_expired: tokenExpired,
+            reading_age_h: 0,
+            binding: { limit: "unknown", used_percent: 0, resets_at: null },
+            weekly_resets_at: null,
+            why: whyParts.join("; "),
+            lane_flags: `--provider ${base.provider} --account ${accountId}`,
+            usage_unknown: true,
+        });
+    };
     for (const provider of input.view.providers) {
         const providerId = provider.provider;
         if (!isLaneProvider(providerId))
@@ -247,6 +283,10 @@ export function pickAccount(input) {
                 ? Math.max(0, nowMs - observedMs)
                 : Infinity;
             if (accountAge > STALE_SKIP_MS) {
+                if (readingsUnreliable) {
+                    rankUnknown(base, laneMatch.id, tokenExpired);
+                    continue;
+                }
                 skipped.push({
                     ...base,
                     reason: "no reading in the last 24 hours",
@@ -313,6 +353,10 @@ export function pickAccount(input) {
             }
             const known = viewRows.filter((row) => typeof row.used === "number");
             if (known.length === 0) {
+                if (readingsUnreliable) {
+                    rankUnknown(base, laneMatch.id, tokenExpired);
+                    continue;
+                }
                 skipped.push({
                     ...base,
                     reason: "no usage numbers for this account in the last day",
@@ -376,6 +420,7 @@ export function pickAccount(input) {
                 weekly_resets_at: weekly?.resetsAt ?? null,
                 why: whyParts.join("; "),
                 lane_flags: `--provider ${providerId} --account ${laneMatch.id}`,
+                usage_unknown: false,
             });
         }
     }
@@ -401,7 +446,7 @@ export function pickAccount(input) {
             bad.set(`${row.provider}:${row.account}`, row.reason);
     }
     for (const row of ranked) {
-        if (row.headroom < floor) {
+        if (!row.usage_unknown && row.headroom < floor) {
             bad.set(`${row.provider}:${row.account}`, `${row.binding.limit} has ${row.headroom}% left`);
         }
     }

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

@@ -68,7 +68,12 @@ export declare const LANE_DELIVERY_MECHANISMS: readonly ["dropbox", "resume", "n
 export type LaneDeliveryMechanism = (typeof LANE_DELIVERY_MECHANISMS)[number];
 /** Additional presentation-only result used by `hq lanes show`. */
 export type LaneShowDeliveryMechanism = LaneDeliveryMechanism | "questions";
-export type DeliveryLane = Pick<LaneRecord, "state" | "provider" | "provider_session_id" | "terminal_reason" | "envelope_repair" | "keep_alive" | "quota_reset_at" | "terminal_details">;
+export type DeliveryLane = Pick<LaneRecord, "state" | "provider" | "provider_session_id" | "terminal_reason" | "envelope_repair" | "keep_alive" | "quota_reset_at" | "terminal_details"> & Partial<Pick<LaneRecord, "loop_mode">>;
+/**
+ * A loop lane between phases is `running` with no worker. Only the loop
+ * controller's next-phase resume may continue it from that state.
+ */
+export declare function isLoopIdleResumeLane(lane: DeliveryLane, loopIdle: boolean | undefined): boolean;
 export declare function isFailedQuotaKeepAliveLane(lane: DeliveryLane): boolean;
 /**
  * `dropbox`: a process is (or is about to be) alive to drain the inbox.
@@ -147,6 +152,12 @@ export type LaunchTrigger = {
     /** Loop phases may deliberately start a fresh session at a story boundary. */
     fresh?: true;
     allowAwaitingInput?: true;
+    /**
+     * The loop controller starting the next phase of a loop lane that sits
+     * in `running` with no worker between phases. The lane stays `running`
+     * through the resume; it is never written `done` to get here.
+     */
+    loopIdle?: true;
     fromFailed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
     expectedSenior?: SeniorRef;
@@ -167,6 +178,7 @@ export declare function resumeCommandRefusal(lane: DeliveryLane, options?: {
     allowFailed?: boolean;
     allowAwaitingInput?: boolean;
     allowFresh?: boolean;
+    allowLoopIdle?: boolean;
 }): {
     error: "lane_not_resumable" | "resume_unsupported" | "no_provider_session";
     message: string;

package/dist/lib/lanes/delivery.js

@@ -87,6 +87,13 @@ export function isResumeCommandState(state) {
     return RESUME_COMMAND_STATES.includes(state);
 }
 export const LANE_DELIVERY_MECHANISMS = ["dropbox", "resume", "none"];
+/**
+ * A loop lane between phases is `running` with no worker. Only the loop
+ * controller's next-phase resume may continue it from that state.
+ */
+export function isLoopIdleResumeLane(lane, loopIdle) {
+    return loopIdle === true && lane.loop_mode === true && lane.state === "running";
+}
 /** Only the terminal result of a failed automatic envelope repair is recoverable. */
 function isFailedEnvelopeRepairLane(lane) {
     return (lane.state === "failed" &&
@@ -356,6 +363,7 @@ export const LAUNCH_TRIGGERS = ["admit", "answered_questions", "message", "resum
  */
 export function resumeCommandRefusal(lane, options = {}) {
     if (!isResumeCommandState(lane.state) &&
+        !isLoopIdleResumeLane(lane, options.allowLoopIdle) &&
         !(options.allowAwaitingInput === true && lane.state === "awaiting_input") &&
         !isFailedEnvelopeRepairLane(lane) &&
         !isFailedQuotaKeepAliveLane(lane) &&
@@ -414,6 +422,7 @@ export function planLaneLaunch(lane, trigger) {
                 allowFailed: trigger.fromFailed === true || isFailedQuotaKeepAliveLane(lane),
                 allowAwaitingInput: trigger.allowAwaitingInput === true,
                 allowFresh: trigger.fresh === true,
+                allowLoopIdle: trigger.loopIdle === true,
             });
             if (trigger.fresh === true && refusal === null)
                 return { mode: "fresh" };
@@ -446,6 +455,8 @@ export function claimableStatesFor(trigger, lane) {
             const states = trigger.fromFailed === true || envelopeRepairFailed || (lane !== undefined && isFailedQuotaKeepAliveLane(lane))
                 ? [...RESUME_COMMAND_STATES, "failed"]
                 : [...RESUME_COMMAND_STATES];
+            if (lane !== undefined && isLoopIdleResumeLane(lane, trigger.loopIdle))
+                states.push("running");
             return lane?.state === "awaiting_input" ? [...states, "awaiting_input"] : states;
         }
         default: {

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

@@ -63,7 +63,7 @@ export type { RegistryPersona } from "./registry-persona.js";
 export type { RegistryWorkerEntry, ResolvedLaneWorker, WorkerTenancy, WorkerYaml, } from "./registry.js";
 export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
 export type { QuestionBody, RaiseLaneQuestionInput } from "./questions.js";
-export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isFailedQuotaKeepAliveLane, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, isLoopIdleResumeLane, hasRecordedSessionId, isFailedQuotaKeepAliveLane, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
 export type { DeliveryLane, LaneDeliveryMechanism, LaneShowDeliveryMechanism, LaunchPlan, LaunchTrigger, LaunchTriggerKind, ResumableLaneState, ResumeCommandState, SessionIdAbsentReason, WorkerRunResult, } from "./delivery.js";
 export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
 export type { DrainDeps, DrainHookResult, DropboxMessage, ToolActivityRecord, } from "./dropbox.js";

package/dist/lib/lanes/index.js

@@ -34,7 +34,7 @@ export { WORKER_REGISTRY_REL, personalWorkerDir, personalWorkerExists, readWorke
 export { ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, materializeWorkerProfile, personalWorkerProfileDir, REGISTRY_PERSONA_PROMPT_MAX_CHARS, workerProfileMarker, workerProfilePrompt, } from "./profile.js";
 export { loadRegistryPersonaFromRecord, registryWorkerRecord, resolveRegistryPersona, } from "./registry-persona.js";
 export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
-export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isFailedQuotaKeepAliveLane, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
+export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, isLoopIdleResumeLane, hasRecordedSessionId, isFailedQuotaKeepAliveLane, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
 export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
 export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";
 export { EFFORT_SOURCES, PROVIDER_EFFORT_LEVELS, appendEffortFlag, defaultEffortForModel, parseCliEffort, parseConfigEffort, resolveLaneEffort, } from "./effort.js";

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

@@ -188,6 +188,11 @@ export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
 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;
+/**
+ * True when a loop lane's controller is alive with no phase active: the lane
+ * finished its last phase and is waiting for the next envelope.
+ */
+export declare function loopLaneIsIdle(runDir: string, laneId: string): boolean;
 export declare function loopControllerIsAlive(runDir: string): boolean;
 /** Run queued phases serially. Sessions are isolated by story and provider. */
 export declare function runLoopLane(options: LoopRunnerOptions): Promise<LoopRunSummary>;

package/dist/lib/lanes/loop.js

@@ -648,6 +648,14 @@ export function clearLoopControllerPid(runDir, laneId, pid) {
     if (currentPid === pid)
         persistStatus(runDir, laneId, { pid: undefined });
 }
+/**
+ * True when a loop lane's controller is alive with no phase active: the lane
+ * finished its last phase and is waiting for the next envelope.
+ */
+export function loopLaneIsIdle(runDir, laneId) {
+    const status = loopStatus(runDir, laneId);
+    return status.state === "waiting" && status.active_envelope_id === null && loopControllerIsAlive(runDir);
+}
 export function loopControllerIsAlive(runDir) {
     let pid;
     try {

package/dist/lib/lanes/reconcile.js

@@ -12,7 +12,7 @@ import { compareLaneQueueOrder, compareLaneQueueOrderWithLeads, leadLaneIds, has
 import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
-import { loopStatus } from "./loop.js";
+import { loopLaneIsIdle, loopStatus } from "./loop.js";
 import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { laneDepthCap } from "./depth-cap.js";
@@ -1641,6 +1641,23 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 // Watcher owns terminal classification of a process that has just exited.
                 continue;
             }
+            if (lane.loop_mode === true && loopLaneIsIdle(runDir, lane.lane_id)) {
+                // An idle loop lane has no worker between phases. Its controller is
+                // alive and waiting for the next envelope, so the lane is not finished.
+                try {
+                    const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running" && current.last_host_report_at !== nowIso, (current) => ({ ...current, last_host_report_at: nowIso }), deps.dryRun);
+                    if (result.changed)
+                        summary.heartbeats.push(lane.lane_id);
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `heartbeat CAS failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                }
+                continue;
+            }
             const hadPids = workerPid !== null || watcherPid !== null;
             if (!hadPids && nowMs - lastHostReportMs(lane) < DEAD_HOST_MS) {
                 try {

package/dist/lib/lanes/spawn.js

@@ -23,7 +23,7 @@ import { installDrainHook } from "./hooks-install.js";
 import { loadLanesConfig, providerAutoCompactTokens, providerCompactAfterMs, } from "./config.js";
 import { appendEffortFlag, resolveLaneEffort, } from "./effort.js";
 import { defaultProbe, validateLaneModel, validateProfileLaneModel, } from "./models.js";
-import { claimableStatesFor, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
+import { claimableStatesFor, isLoopIdleResumeLane, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
 import { AccountResolutionError, LanesError } from "./errors.js";
 import { ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, materializeWorkerProfile, workerProfilePrompt, } from "./profile.js";
 import { registryWorkerRecord } from "./registry-persona.js";
@@ -2143,7 +2143,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             ? { provider_home_at_spawn: previousSpawn.provider_home_at_spawn }
             : {}),
     };
-    if (existing.state === "running") {
+    const loopIdleResume = launch.trigger?.kind === "resume" &&
+        isLoopIdleResumeLane(existing, launch.trigger.loopIdle);
+    if (loopIdleResume) {
+        // An idle loop lane has no worker between phases. A live worker pid means
+        // a phase is still running, so this resume would start a second worker.
+        const priorWorker = readPidRecord(path.join(runDir, "worker.pid"));
+        if (priorWorker !== null && isPidRecordAlive(priorWorker)) {
+            throw new LanesError("lane_not_resumable", `Lane ${lane.lane_id} is already running`, { lane_id: lane.lane_id, state: existing.state, worker_pid: priorWorker.pid });
+        }
+    }
+    else if (existing.state === "running") {
         if (launch.trigger?.kind === "resume") {
             throw new LanesError("lane_not_resumable", `Lane ${lane.lane_id} is already running`, { lane_id: lane.lane_id, state: existing.state });
         }
@@ -2643,7 +2653,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let priorStartRecorded = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
-        if (current.state === "running" && current.account === resolved.id) {
+        if (current.state === "running" && current.account === resolved.id && !loopIdleResume) {
             if (trigger.kind === "resume") {
                 throw new LanesError("lane_not_resumable", `Lane ${current.lane_id} is already running`, { lane_id: current.lane_id, state: current.state });
             }

package/dist/lib/lanes/worker-continuity.d.ts

@@ -9,10 +9,22 @@ export interface WorkerContinuityLookup {
 export interface WorkerContinuityResult {
     previous?: LaneRecord;
     resumable: boolean;
-    fallbackReason?: "provider_unsupported" | "session_id_missing" | "state_unsafe" | "host_mismatch";
+    fallbackReason?: "provider_unsupported" | "session_id_missing" | "state_unsafe" | "host_mismatch" | "settings_mismatch";
 }
 export declare function sameLaneHost(left: LaneRecord["host"], right: LaneRecord["host"]): boolean;
 /** Select the prior worker lane within exactly one senior/company/provider scope. */
 export declare function findWorkerContinuityLane(lanes: readonly LaneRecord[], lookup: WorkerContinuityLookup): WorkerContinuityResult;
+export interface WorkerContinuitySettings {
+    project: LaneRecord["project_id"];
+    /** Resolved model for the new lane; undefined when the provider chooses. */
+    model?: string;
+    /** Resolved effort for the new lane; undefined when none is passed. */
+    effort?: string;
+}
+/**
+ * Refuse reuse when the earlier session ran under a different project, model,
+ * or effort. A prior lane that recorded no model does not match a pinned one.
+ */
+export declare function applyContinuitySettings(result: WorkerContinuityResult, settings: WorkerContinuitySettings): WorkerContinuityResult;
 export declare function workerContinuityPrompt(previous: LaneRecord, resultSummary?: string, resultRef?: string): string;
 //# sourceMappingURL=worker-continuity.d.ts.map

package/dist/lib/lanes/worker-continuity.js

@@ -65,6 +65,20 @@ export function findWorkerContinuityLane(lanes, lookup) {
     }
     return { previous, resumable: true };
 }
+/**
+ * Refuse reuse when the earlier session ran under a different project, model,
+ * or effort. A prior lane that recorded no model does not match a pinned one.
+ */
+export function applyContinuitySettings(result, settings) {
+    const previous = result.previous;
+    if (!result.resumable || !previous)
+        return result;
+    if (previous.project_id === settings.project && previous.model === settings.model &&
+        previous.effort === settings.effort) {
+        return result;
+    }
+    return { previous, resumable: false, fallbackReason: "settings_mismatch" };
+}
 export function workerContinuityPrompt(previous, resultSummary, resultRef) {
     const summary = resultSummary?.trim();
     const resultPath = resultRef?.trim()

package/dist/utils/jq-windows-compat.d.ts

@@ -9,5 +9,6 @@ export type JqInvoke = (args: string[], input: Buffer | string | undefined, cwd:
     stdout?: "capture" | "ignore";
     stderr?: "pipe" | "ignore";
 }) => JqResult;
+export declare function isMsys2Environment(msystem: string | undefined): boolean;
 export declare function createShellCompatibleJqInvoker(invoke: JqInvoke, platform: NodeJS.Platform, env: NodeJS.ProcessEnv, resolveShellType: (cwd: string) => string | undefined): JqInvoke;
 //# sourceMappingURL=jq-windows-compat.d.ts.map

package/dist/utils/jq-windows-compat.js

@@ -21,6 +21,10 @@ function normalizeResult(result) {
         stderr: stderrBytes.toString("utf8"),
     };
 }
+// MSYS2 environment names. Git for Windows 2.56+ reports UCRT64 instead of MINGW64.
+export function isMsys2Environment(msystem) {
+    return /^(?:MINGW|UCRT|CLANG|MSYS)/i.test(msystem ?? "");
+}
 export function createShellCompatibleJqInvoker(invoke, platform, env, resolveShellType) {
     let binaryOptionSupported;
     let shellTypeResolved = false;
@@ -32,7 +36,7 @@ export function createShellCompatibleJqInvoker(invoke, platform, env, resolveShe
             shellType = resolveShellType(cwd);
             shellTypeResolved = true;
         }
-        const msysMode = /^msys/i.test(shellType ?? "") || /^MINGW/i.test(env.MSYSTEM ?? "");
+        const msysMode = /^msys/i.test(shellType ?? "") || isMsys2Environment(env.MSYSTEM);
         if (!msysMode)
             return invoke(args, input, cwd, options);
         if (binaryOptionSupported === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.130",
+  "version": "5.345.132",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {