@indigoai-us/hq-cli 5.345.130 → 5.345.131

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [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 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.
+
 ## [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/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,19 @@
 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`.
+ */
+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

@@ -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,43 @@ 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`.
+ */
+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)
+            return current;
+        try {
+            return updateLane(hqRoot, laneId, current.version, "command", (record) => ({
+                ...record,
+                state: to,
+                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)
@@ -151,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,
@@ -187,6 +226,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.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";
@@ -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";
@@ -8914,7 +8918,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/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/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/package.json

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