@indigoai-us/hq-cli 5.345.132 → 5.345.134

package/CHANGELOG.md

@@ -2,12 +2,20 @@
 
 ## [Unreleased]
 
+## [5.345.134] — 2026-10-15
+- `hq access --as <member>` now honors the most specific ACL row covering a path, so an empty folder lock reports no access instead of the write access of a broader grant. `hq access` also reports "no access" rather than "never created" when a caller cannot list a path that an ACL lock denies them.
+
+## [5.345.133] — 2026-10-15
+- Pipeline loop lanes no longer hang after their first phase. 5.345.132 kept the lane running while its next phase resumed, which left the previous phase's watcher holding the lane, so the next phase's result was never recorded. That change is reverted; a loop lane may again show as done for a few seconds while its next phase starts.
+
 ## [5.345.132] — 2026-10-14
+- 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.
+- 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.131] — 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/dist/commands/access.d.ts

@@ -48,6 +48,8 @@ export interface AccessAclTree {
         updatedAt: string;
     } | null;
     effectivePermission: string | null;
+    /** Most-specific ACL row covering this prefix, including empty lock rows. */
+    coveringAclPath?: string | null;
 }
 export interface AccessMember {
     personUid: string;

package/dist/commands/access.js

@@ -91,6 +91,27 @@ function fileGrantCoversPath(grantPath, targetPath) {
     return classifyAclSource(targetPath, [grantPath]) !== "role-bypass";
 }
 const FILE_PERMISSION_RANK = { read: 1, write: 2, admin: 3 };
+function aclPatternSpecificity(pattern) {
+    if (pattern === "*" || pattern === "")
+        return [0, 0];
+    const glob = pattern.endsWith("/*");
+    const body = glob ? pattern.slice(0, -2) : pattern;
+    const segs = body.split("/").filter(Boolean).length;
+    return [segs, glob ? 0 : 1];
+}
+function pickMostSpecificCoveringRow(rows, targetPath, company) {
+    const covering = rows.filter((row) => fileGrantCoversPath(toBucketRelative(row.path, company), targetPath));
+    if (covering.length === 0)
+        return null;
+    covering.sort((a, b) => {
+        const [aSegs, aExact] = aclPatternSpecificity(toBucketRelative(a.path, company));
+        const [bSegs, bExact] = aclPatternSpecificity(toBucketRelative(b.path, company));
+        if (aSegs !== bSegs)
+            return bSegs - aSegs;
+        return bExact - aExact;
+    });
+    return covering[0] ?? null;
+}
 function httpStatusOf(err) {
     if (!err || typeof err !== "object")
         return undefined;
@@ -146,10 +167,13 @@ function treeIsEmpty(tree) {
 function aclDenied(tree) {
     if (!tree)
         return false;
+    const perm = tree.effectivePermission;
+    const denied = perm === null || perm === "none" || perm === "deny";
+    if (tree.coveringAclPath && denied)
+        return true;
     if (treeIsEmpty(tree))
         return false;
-    const perm = tree.effectivePermission;
-    return perm === null || perm === "none" || perm === "deny";
+    return denied;
 }
 /**
  * Build the result and record one cause-mix telemetry line. Every exit path
@@ -289,6 +313,18 @@ export async function runAccess(input) {
             }
             else if (fuzzy.length === 0) {
                 steps.push("list: 0 hits");
+                const tree = await deps.fetchAclTree(relative);
+                if (aclDenied(tree)) {
+                    steps.push("acl: deny");
+                    const result = finish("no-access", {
+                        path: anchored(relative) || input.target,
+                        company: slug,
+                        exists: true,
+                        steps,
+                    }, finishCtx);
+                    emit(input, result, log);
+                    return result;
+                }
                 const result = finish("never-existed", {
                     path: anchored(relative) || input.target,
                     company: slug,
@@ -632,7 +668,7 @@ async function promptPick(candidates) {
 function treeFromBody(body) {
     if (!body)
         return null;
-    if (treeIsEmpty(body))
+    if (treeIsEmpty(body) && !body.coveringAclPath)
         return null;
     return body;
 }
@@ -730,12 +766,25 @@ export async function runAccessForPerson(rawPath, personUid, opts) {
     }
     const roleBypass = projection.files.roleBypass === true;
     const grants = Array.isArray(projection.files.grants) ? projection.files.grants : [];
-    const matchingPermissions = grants
-        .filter((grant) => typeof grant.path === "string" && typeof grant.permission === "string" &&
-        grant.permission in FILE_PERMISSION_RANK &&
-        fileGrantCoversPath(toBucketRelative(grant.path, company), relativePath))
-        .map((grant) => grant.permission);
-    const permission = roleBypass ? "admin" : matchingPermissions.reduce((best, candidate) => best === null || FILE_PERMISSION_RANK[candidate] > FILE_PERMISSION_RANK[best] ? candidate : best, null);
+    const locks = Array.isArray(projection.files.locks) ? projection.files.locks : [];
+    const coveringRows = [];
+    for (const grant of grants) {
+        if (typeof grant.path === "string" &&
+            typeof grant.permission === "string" &&
+            grant.permission in FILE_PERMISSION_RANK) {
+            coveringRows.push({
+                path: grant.path,
+                permission: grant.permission,
+            });
+        }
+    }
+    for (const lock of locks) {
+        if (typeof lock.path === "string") {
+            coveringRows.push({ path: lock.path, permission: null });
+        }
+    }
+    const winner = pickMostSpecificCoveringRow(coveringRows, relativePath, company);
+    const permission = roleBypass ? "admin" : (winner?.permission ?? null);
     return {
         personUid: uid,
         company,

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

@@ -5,11 +5,15 @@ 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`. The next
- * phase resumes the lane from `running` (`loopIdle`), so it is not written
- * `done` again while the loop is active.
+ * before its first phase. Only a stop makes a loop lane `done`.
  */
 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,19 +20,28 @@ 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`. The next
- * phase resumes the lane from `running` (`loopIdle`), so it is not written
- * `done` again while the loop is active.
+ * before its first phase. Only a stop makes a loop lane `done`.
  */
 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 !== "done")
+        if (current.loop_mode !== true || current.state !== from)
             return current;
         try {
             return updateLane(hqRoot, laneId, current.version, "command", (record) => ({
                 ...record,
-                state: "running",
+                state: to,
                 terminal_reason: undefined,
                 terminal_details: undefined,
             }));
@@ -179,6 +188,8 @@ 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,
@@ -186,7 +197,6 @@ 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, isLoopIdleResumeLane, providerSessionPortable, providerSupportsSessionResume, readLane, resumeCommandRefusal, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
+import { appendCappedHistory, isFailedQuotaKeepAliveLane, 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,7 +164,6 @@ 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 });
         }
@@ -251,11 +250,7 @@ export function createLaneResumeHandlers(deps) {
         }
         const refusal = queuedProfileRecovery || lane.state === "awaiting_input"
             ? null
-            : resumeCommandRefusal(lane, {
-                allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane),
-                allowFresh: opts.freshThread === true,
-                allowLoopIdle: loopIdle,
-            });
+            : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane), allowFresh: opts.freshThread === true });
         if (refusal !== null) {
             throw new LanesError(refusal.error, refusal.message, {
                 lane_id: laneId,
@@ -265,10 +260,7 @@ export function createLaneResumeHandlers(deps) {
             });
         }
         assertLaneRunsHereForAdmission(ctx, lane);
-        // An idle loop lane resumes from the phase that finished; it stays `running`.
-        const resumedFrom = loopIdle
-            ? "done"
-            : lane.state;
+        const resumedFrom = lane.state;
         const text = opts.text?.trim() ? opts.text : undefined;
         const at = ctx.now().toISOString();
         const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
@@ -450,7 +442,6 @@ export function createLaneResumeHandlers(deps) {
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                    ...(loopIdle ? { loopIdle: true } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,
@@ -487,7 +478,6 @@ export function createLaneResumeHandlers(deps) {
                         ...(profileRepin !== undefined ? { profileRepin } : {}),
                         ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                         ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                        ...(loopIdle ? { loopIdle: true } : {}),
                         pending: {
                             trigger: "resume",
                             resumed_from: resumedFrom,
@@ -519,7 +509,6 @@ export function createLaneResumeHandlers(deps) {
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                    ...(loopIdle ? { loopIdle: true } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,
@@ -654,7 +643,6 @@ 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,11 +83,6 @@ 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;
@@ -126,8 +121,6 @@ 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, isLoopIdleResumeLane, 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, 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,9 +7418,7 @@ async function prepareAccountMove(ctx, lane, input) {
     const now = ctx.now();
     const laneId = lane.lane_id;
     assertLaneRunsHereForAdmission(ctx, lane);
-    // 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)) {
+    if (lane.state === "running") {
         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,12 +68,7 @@ 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"> & 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 type DeliveryLane = Pick<LaneRecord, "state" | "provider" | "provider_session_id" | "terminal_reason" | "envelope_repair" | "keep_alive" | "quota_reset_at" | "terminal_details">;
 export declare function isFailedQuotaKeepAliveLane(lane: DeliveryLane): boolean;
 /**
  * `dropbox`: a process is (or is about to be) alive to drain the inbox.
@@ -152,12 +147,6 @@ 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;
@@ -178,7 +167,6 @@ 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,13 +87,6 @@ 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" &&
@@ -363,7 +356,6 @@ 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) &&
@@ -422,7 +414,6 @@ 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" };
@@ -455,8 +446,6 @@ 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, isLoopIdleResumeLane, 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, 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, isLoopIdleResumeLane, 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, 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, isLoopIdleResumeLane, planLaneLaunch, providerSupportsSessionResume, } from "./delivery.js";
+import { claimableStatesFor, 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,17 +2143,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             ? { provider_home_at_spawn: previousSpawn.provider_home_at_spawn }
             : {}),
     };
-    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 (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 });
         }
@@ -2653,7 +2643,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 && !loopIdleResume) {
+        if (current.state === "running" && current.account === resolved.id) {
             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/package.json

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