@indigoai-us/hq-cli 5.345.131 → 5.345.132

package/CHANGELOG.md

@@ -2,10 +2,12 @@
 
 ## [Unreleased]
 
-## [5.345.131] — 2026-10-14
+## [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/lanes-loop.d.ts

@@ -5,15 +5,11 @@ import type { LaneRecord } from "../lib/lanes/types.js";
  * 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`.
+ * 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;
-/**
- * The next phase resumes the provider session, which `hq lanes resume` only
- * accepts from a resumable state. An idle loop lane sits in `running` with no
- * worker, so it is handed to resume as the `done` lane the phase left.
- */
-export declare function prepareIdleLoopLaneForResume(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

@@ -20,28 +20,19 @@ function loopRunDir(hqRoot, laneId) {
  * 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`.
+ * 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) {
-    return casLoopLaneState(hqRoot, laneId, "done", "running");
-}
-/**
- * The next phase resumes the provider session, which `hq lanes resume` only
- * accepts from a resumable state. An idle loop lane sits in `running` with no
- * worker, so it is handed to resume as the `done` lane the phase left.
- */
-export function prepareIdleLoopLaneForResume(hqRoot, laneId) {
-    return casLoopLaneState(hqRoot, laneId, "running", "done");
-}
-function casLoopLaneState(hqRoot, laneId, from, to) {
     for (let attempt = 0;; attempt += 1) {
         const current = readLane(hqRoot, laneId);
-        if (current.loop_mode !== true || current.state !== from)
+        if (current.loop_mode !== true || current.state !== "done")
             return current;
         try {
             return updateLane(hqRoot, laneId, current.version, "command", (record) => ({
                 ...record,
-                state: to,
+                state: "running",
                 terminal_reason: undefined,
                 terminal_details: undefined,
             }));
@@ -188,8 +179,6 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                     }));
                 }
                 else {
-                    if (current.state === "running")
-                        current = prepareIdleLoopLaneForResume(hqRoot, laneId);
                     await deps.resumeLane(laneId, {
                         text: `Read ${briefPath} and follow it as the complete instruction for this phase.`,
                         project: current.project_id,
@@ -197,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,
                     });
                 }

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

@@ -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";
@@ -7418,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,

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/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/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.131",
+  "version": "5.345.132",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {