@indigoai-us/hq-cli 5.198.0 → 5.199.0

package/dist/lib/flag-registry-endpoint.d.ts

@@ -0,0 +1,5 @@
+export declare const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export declare const FLAG_REGISTRY_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+/** Resolve one shared endpoint from an explicit option, environment, or service default. */
+export declare function resolveFlagRegistryEndpoint(explicitEndpoint?: string, env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=flag-registry-endpoint.d.ts.map

package/dist/lib/flag-registry-endpoint.js

@@ -0,0 +1,9 @@
+export const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export const FLAG_REGISTRY_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+/** Resolve one shared endpoint from an explicit option, environment, or service default. */
+export function resolveFlagRegistryEndpoint(explicitEndpoint, env = process.env) {
+    return explicitEndpoint?.trim()
+        || env[FLAG_REGISTRY_ENDPOINT_ENV]?.trim()
+        || FLAG_REGISTRY_DEFAULT_ENDPOINT;
+}
+//# sourceMappingURL=flag-registry-endpoint.js.map

package/dist/lib/flag-registry.d.ts

@@ -7,8 +7,7 @@
  */
 import { type WorkerOptions } from "node:worker_threads";
 import { type FlagClient, type FlagLookupOptions, type FlagSnapshot } from "@indigoai-us/hq-flags-client";
-/** Dedicated endpoint configuration; this is intentionally not HQ_PRO_API_URL. */
-export declare const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 /** The synchronous capability that command gate call sites need. */
 export type FlagReader = Pick<FlagClient, "isEnabled">;
 interface WorkerLike {
@@ -20,6 +19,12 @@ export interface FlagRegistryDependencies {
     endpoint?: string;
     createWorker?: (filename: URL, options: WorkerOptions) => WorkerLike;
 }
+export interface ProcessFlagCompanyContext {
+    companyUid?: string;
+    companySlug?: string;
+}
+/** Resolve the same company identity used by the process-wide flag reader. */
+export declare function resolveProcessFlagCompanyContext(env?: NodeJS.ProcessEnv): ProcessFlagCompanyContext;
 /**
  * Begin one registry refresh without awaiting it or retaining the CLI process.
  *
@@ -46,5 +51,4 @@ export declare function resolveProcessFlagGate(flagKey: string, lookup: FlagLook
 export declare function currentFlagSnapshot(): FlagSnapshot | null;
 /** Test-only reset for process-global readiness state. */
 export declare function _resetFlagRegistryForTests(): void;
-export {};
 //# sourceMappingURL=flag-registry.d.ts.map

package/dist/lib/flag-registry.js

@@ -12,8 +12,8 @@ import { readSessionState } from "./work-context/state.js";
 import { workContextRoot } from "./work-context/paths.js";
 import { readCompaniesManifestMap } from "./work-context/repo-remote.js";
 import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
-/** Dedicated endpoint configuration; this is intentionally not HQ_PRO_API_URL. */
-export const FLAG_REGISTRY_ENDPOINT_ENV = "HQ_FLAGS_API_URL";
+import { resolveFlagRegistryEndpoint, } from "./flag-registry-endpoint.js";
+export { FLAG_REGISTRY_ENDPOINT_ENV } from "./flag-registry-endpoint.js";
 const COMPANY_UID_RE = /^cmp_[A-Za-z0-9]{3,128}$/;
 const COMPANY_SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 let heldSnapshot = null;
@@ -76,6 +76,15 @@ function companyUidForContext(context, env = process.env) {
     const manifestUid = readCompaniesManifestMap(hqRoot)?.[context.companySlug]?.cloud_uid;
     return typeof manifestUid === "string" ? normalizedCompanyUid(manifestUid) : undefined;
 }
+/** Resolve the same company identity used by the process-wide flag reader. */
+export function resolveProcessFlagCompanyContext(env = process.env) {
+    const context = processCompanyContext(env);
+    const companyUid = companyUidForContext(context, env);
+    return {
+        ...(companyUid ? { companyUid } : {}),
+        ...(context.companySlug ? { companySlug: context.companySlug } : {}),
+    };
+}
 function processSnapshotReader(companyIdentifiers) {
     return {
         isEnabled(flagKey, lookup = {}) {
@@ -101,11 +110,9 @@ function processSnapshotReader(companyIdentifiers) {
 export function kickFlagRegistryReadiness(dependencies = {}) {
     if (processReader)
         return processReader;
-    const endpoint = (dependencies.endpoint ?? process.env[FLAG_REGISTRY_ENDPOINT_ENV] ?? "").trim();
-    if (!endpoint)
-        return null;
-    const company = processCompanyContext();
-    const companyUid = companyUidForContext(company);
+    const endpoint = resolveFlagRegistryEndpoint(dependencies.endpoint, process.env);
+    const company = resolveProcessFlagCompanyContext();
+    const companyUid = company.companyUid;
     const companyIdentifiers = [companyUid, company.companySlug].filter((value) => Boolean(value));
     processReader = processSnapshotReader(companyIdentifiers);
     try {
@@ -149,6 +156,11 @@ export function resolveFlagGate(reader, flagKey, lookup, legacyFallback) {
 }
 /** Resolve a process gate against the shared snapshot reader, when configured. */
 export function resolveProcessFlagGate(flagKey, lookup, legacyFallback) {
+    // The endpoint refresh is deliberately asynchronous. Until a validated
+    // snapshot arrives, preserve each caller's exact legacy fallback.
+    if (!processReader || !heldSnapshot) {
+        return localOverrideOrFallback(flagKey, legacyFallback);
+    }
     return resolveFlagGate(processReader, flagKey, lookup, legacyFallback);
 }
 /**

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

@@ -37,6 +37,8 @@ export declare const DEFAULT_LIVE_WITHIN_MS: number;
 export declare const DEFAULT_TURN_START_LOST_MS: number;
 /** Spec §9: no event for 12 hours (and no session_end) → lost. */
 export declare const DEFAULT_SILENT_LOST_MS: number;
+/** Unanswered session questions move to the next audience after 10 minutes. */
+export declare const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS: number;
 export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
 export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;
 export declare const DEFAULT_ACCOUNT_HOMES: Record<LaneProvider, string>;

package/dist/lib/lanes/config.js

@@ -41,6 +41,8 @@ export const DEFAULT_LIVE_WITHIN_MS = 10 * 60 * 1000;
 export const DEFAULT_TURN_START_LOST_MS = 2 * 60 * 60 * 1000;
 /** Spec §9: no event for 12 hours (and no session_end) → lost. */
 export const DEFAULT_SILENT_LOST_MS = 12 * 60 * 60 * 1000;
+/** Unanswered session questions move to the next audience after 10 minutes. */
+export const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS = 10 * 60;
 export const DEFAULT_LIVENESS_WINDOWS = {
     live_within_ms: DEFAULT_LIVE_WITHIN_MS,
     turn_start_lost_ms: DEFAULT_TURN_START_LOST_MS,
@@ -340,6 +342,7 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
             min_available_mem_mb: DEFAULT_MIN_AVAILABLE_MEM_MB,
         },
         liveness: { ...DEFAULT_LIVENESS_WINDOWS },
+        session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
     };
 }
 export function parseLanesConfig(raw, deps = defaultDeps()) {
@@ -380,6 +383,7 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         providers,
         throttle: parseThrottle(raw.throttle),
         liveness: parseLiveness(raw.liveness),
+        session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),
     };
 }
 export function lanesConfigPath(hqRoot) {

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

@@ -40,6 +40,10 @@ export interface LivenessDeps {
     existsSync: (file: string) => boolean;
     mkdirSync: typeof fs.mkdirSync;
     statSync: (file: string) => fs.Stats;
+    lstatSync: (file: string) => fs.Stats;
+    readdirSync: (dir: string, options: {
+        withFileTypes: true;
+    }) => fs.Dirent[];
 }
 export declare function defaultLivenessDeps(): LivenessDeps;
 export declare function defaultSpoolPath(deps?: LivenessDeps): string;
@@ -53,6 +57,14 @@ export declare function livenessIndexPath(hqRoot: string): string;
  * `session_end` as the last event is `ended` even when recent (fast path).
  */
 export declare function classifySessionLiveness(entry: SessionIndexEntry, nowMs: number, presenceConnected?: boolean, windows?: LivenessWindows): LivenessState;
+/**
+ * Use recent Claude transcript file activity when a session has no mesh event
+ * entry. This reads file metadata only; transcript contents are never opened.
+ * If a session transcript exists in more than one configured home, the newest
+ * mtime is the activity signal. A stale or absent transcript remains unknown
+ * and is not evidence of an end.
+ */
+export declare function unindexedClaudeSessionLiveness(sessionId: string, nowMs: number, windows: LivenessWindows, deps?: LivenessDeps, configuredHomes?: readonly string[]): LivenessState | null;
 export declare function ingestSpoolLine(line: string, sessions: Record<string, SessionIndexEntry>, lineNo: number): void;
 export declare function buildLivenessIndexFromSpool(spoolContents: string, meta: {
     spool_path: string;

package/dist/lib/lanes/liveness.js

@@ -37,6 +37,8 @@ export function defaultLivenessDeps() {
         existsSync: (file) => fs.existsSync(file),
         mkdirSync: fs.mkdirSync.bind(fs),
         statSync: (file) => fs.statSync(file),
+        lstatSync: (file) => fs.lstatSync(file),
+        readdirSync: fs.readdirSync.bind(fs),
     };
 }
 export function defaultSpoolPath(deps = defaultLivenessDeps()) {
@@ -81,6 +83,64 @@ export function classifySessionLiveness(entry, nowMs, presenceConnected = false,
         return "idle";
     return "idle";
 }
+/**
+ * Use recent Claude transcript file activity when a session has no mesh event
+ * entry. This reads file metadata only; transcript contents are never opened.
+ * If a session transcript exists in more than one configured home, the newest
+ * mtime is the activity signal. A stale or absent transcript remains unknown
+ * and is not evidence of an end.
+ */
+export function unindexedClaudeSessionLiveness(sessionId, nowMs, windows, deps = defaultLivenessDeps(), configuredHomes = []) {
+    if (sessionId.length === 0 ||
+        sessionId.trim() !== sessionId ||
+        sessionId === "." ||
+        sessionId === ".." ||
+        /[\\/\0]/.test(sessionId)) {
+        throw new LanesError("session_activity_invalid_id", "Cannot inspect Claude activity for an invalid session id", { session_id: sessionId });
+    }
+    const homes = [
+        deps.env.CLAUDE_CONFIG_DIR?.trim(),
+        path.join(deps.homedir(), ".claude"),
+        ...configuredHomes,
+    ].filter((home) => typeof home === "string" && home.trim() !== "");
+    const projectsDirs = [...new Set(homes.map((home) => path.resolve(home, "projects")))];
+    let activityAt = null;
+    for (const projectsDir of projectsDirs) {
+        let projects;
+        try {
+            projects = deps.readdirSync(projectsDir, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw new LanesError("session_activity_unreadable", `Cannot inspect Claude project activity: ${err instanceof Error ? err.message : String(err)}`, { path: projectsDir });
+        }
+        for (const project of projects) {
+            if (!project.isDirectory() || project.isSymbolicLink())
+                continue;
+            const transcriptPath = path.join(projectsDir, project.name, `${sessionId}.jsonl`);
+            let transcript;
+            try {
+                transcript = deps.lstatSync(transcriptPath);
+            }
+            catch (err) {
+                if (err.code === "ENOENT")
+                    continue;
+                throw new LanesError("session_activity_unreadable", `Cannot inspect Claude session activity: ${err instanceof Error ? err.message : String(err)}`, { path: transcriptPath });
+            }
+            if (!transcript.isFile() || transcript.isSymbolicLink())
+                continue;
+            if (!Number.isFinite(transcript.mtimeMs)) {
+                throw new LanesError("session_activity_unreadable", `Cannot inspect Claude session activity: invalid modification time`, { path: transcriptPath });
+            }
+            activityAt = Math.max(activityAt ?? Number.NEGATIVE_INFINITY, transcript.mtimeMs);
+        }
+    }
+    if (activityAt === null)
+        return null;
+    const ageMs = nowMs - activityAt;
+    return ageMs >= 0 && ageMs <= windows.live_within_ms ? "live" : null;
+}
 export function ingestSpoolLine(line, sessions, lineNo) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -310,9 +370,11 @@ export function sessionLiveness(hqRoot, sessionId, opts = {}) {
     const deps = opts.deps ?? defaultLivenessDeps();
     const index = loadLivenessIndex(hqRoot, opts.spoolPath, deps);
     const entry = index.sessions[sessionId];
-    if (!entry)
-        return null;
-    const windows = opts.windows ?? loadLanesConfig(hqRoot).liveness;
+    const config = loadLanesConfig(hqRoot);
+    const windows = opts.windows ?? config.liveness;
+    if (!entry) {
+        return unindexedClaudeSessionLiveness(sessionId, opts.nowMs ?? deps.now(), windows, deps, Object.values(config.providers.claude.accounts).map((account) => account.home));
+    }
     const presenceConnected = opts.presenceConnected ?? readDaemonPresenceConnected(deps);
     return classifySessionLiveness(entry, opts.nowMs ?? deps.now(), presenceConnected, windows);
 }

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -46,6 +46,7 @@ export declare function buildOutpostQuestionAnswerCommand(input: {
     choice?: string;
     freeform?: string;
     notes?: string;
+    company?: string;
     hqBinary?: string;
 }): string;
 export interface OutpostExecPort {
@@ -73,6 +74,12 @@ export declare function buildOutpostPickupCommand(payloadUrl: string): string;
 export declare function buildOutpostCapacityCommand(): string;
 /** Read the lane records owned by an Outpost for exact per-account state counts. */
 export declare function buildOutpostLaneListCommand(): string;
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export declare function buildOutpostQuestionListCommand(input?: {
+    company?: string;
+}): string;
+/** Read one question's body and owner-computed audience from its Outpost. */
+export declare function buildOutpostQuestionShowCommand(questionId: string): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -22,6 +22,7 @@ export function buildOutpostQuestionAnswerCommand(input) {
         ["--choice", input.choice],
         ["--freeform", input.freeform],
         ["--notes", input.notes],
+        ["--company", input.company],
     ]) {
         if (value !== undefined)
             args.push(flag, value);
@@ -68,6 +69,24 @@ export function buildOutpostCapacityCommand() {
 export function buildOutpostLaneListCommand() {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "list", "--json"]));
 }
+/** Read questions on one Outpost, scoped to a company when supplied. */
+export function buildOutpostQuestionListCommand(input = {}) {
+    const args = ["hq", "lanes", "questions", "list"];
+    const company = input.company?.trim();
+    if (company)
+        args.push("--company", company);
+    return withRemoteHqDir(joinCommandParts(args));
+}
+/** Read one question's body and owner-computed audience from its Outpost. */
+export function buildOutpostQuestionShowCommand(questionId) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "show",
+        questionId,
+    ]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([

package/dist/lib/lanes/outpost-pruner-install.js

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { resolveHqBinary, resolveNodeBinary } from "../mesh/live/daemon/install.js";
 import { SYSTEMD_PATH_ENV } from "../service-manager/systemd.js";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const OUTPOST_PRUNER_PRESSURE_SERVICE = "hq-outpost-worktree-pruner-pressure.service";
 export const OUTPOST_PRUNER_PRESSURE_TIMER = "hq-outpost-worktree-pruner-pressure.timer";
 export const OUTPOST_PRUNER_DAILY_SERVICE = "hq-outpost-worktree-pruner-daily.service";
@@ -160,10 +161,10 @@ export function installOutpostPrunerTimers(options) {
     const nodeBinary = options.nodeBinary ?? resolveNodeBinary();
     const hqBinary = options.hqBinary ?? resolveHqBinary();
     const home = options.home ?? os.homedir();
-    const flagApiUrl = (options.flagApiUrl ?? process.env.HQ_FLAGS_API_URL ?? "").trim();
+    const flagApiUrl = resolveFlagRegistryEndpoint(options.flagApiUrl);
     const companyUid = (options.companyUid ?? process.env.HQ_COMPANY_UID ?? "").trim();
-    if (!flagApiUrl || !companyUid) {
-        throw new TypeError("install requires HQ_FLAGS_API_URL and HQ_COMPANY_UID for the timer services");
+    if (!companyUid) {
+        throw new TypeError("install requires HQ_COMPANY_UID for the timer services");
     }
     const flagEnvironment = [
         systemdEnvironment("HQ_FLAGS_API_URL", flagApiUrl),

package/dist/lib/lanes/outpost-worktree-pruner-flag.js

@@ -1,5 +1,6 @@
 import { loadCachedTokens } from "@indigoai-us/hq-cloud";
 import { createFlagClient } from "@indigoai-us/hq-flags-client";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
 export const OUTPOST_WORKTREE_PRUNER_FLAG = "outpost.worktree-pruner";
 export const OUTPOST_WORKTREE_PRUNER_FLAG_FALLBACK = false;
 export const OUTPOST_WORKTREE_PRUNER_FLAG_TIMEOUT_MS = 5_000;
@@ -21,14 +22,13 @@ function reportFlagFailure(error) {
 }
 export async function outpostWorktreePrunerEnabled(dependencies = {}) {
     const env = dependencies.env ?? process.env;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!endpoint || !companyUid) {
+    if (!companyUid) {
         process.stderr.write(`${JSON.stringify({
             event: "outpost.worktree_pruner.flag_config_missing",
             flag: OUTPOST_WORKTREE_PRUNER_FLAG,
             missing: [
-                ...(!endpoint ? ["HQ_FLAGS_API_URL"] : []),
                 ...(!companyUid ? ["HQ_COMPANY_UID"] : []),
             ],
             fallback: OUTPOST_WORKTREE_PRUNER_FLAG_FALLBACK,

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

@@ -86,7 +86,7 @@ export declare function timeoutPath(hqRoot: string, laneId: string): string;
 export declare function laneRunsHere(lane: LaneRecord, host: ReconcileHost): boolean;
 export declare function agedAdvanceCount(question: QuestionRecord): number;
 export declare function currentHopStartedAtMs(question: QuestionRecord): number;
-export declare function shouldAgeQuestion(question: QuestionRecord, audience: SeniorRef, nowMs: number): boolean;
+export declare function shouldAgeQuestion(question: QuestionRecord, audience: SeniorRef, nowMs: number, ageWindowMs?: number): boolean;
 export declare function shouldAdvanceAudienceEnded(audience: SeniorRef, liveness: LivenessState | null): boolean;
 export declare function readTimeoutDeadline(hqRoot: string, laneId: string): {
     deadline_at: string;

package/dist/lib/lanes/reconcile.js

@@ -14,7 +14,7 @@ import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { loadWorkerProfile } from "./profile.js";
-import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, } from "./liveness.js";
+import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
@@ -106,7 +106,7 @@ export function currentHopStartedAtMs(question) {
     const ms = Date.parse(raw);
     return Number.isFinite(ms) ? ms : Number.NEGATIVE_INFINITY;
 }
-export function shouldAgeQuestion(question, audience, nowMs) {
+export function shouldAgeQuestion(question, audience, nowMs, ageWindowMs = QUESTION_AGE_MS) {
     if (question.status !== "pending")
         return false;
     if (audience.kind === "user")
@@ -116,14 +116,14 @@ export function shouldAgeQuestion(question, audience, nowMs) {
     const started = currentHopStartedAtMs(question);
     if (started === Number.NEGATIVE_INFINITY)
         return false;
-    return nowMs - started >= QUESTION_AGE_MS;
+    return nowMs - started >= ageWindowMs;
 }
 export function shouldAdvanceAudienceEnded(audience, liveness) {
     if (audience.kind === "user")
         return false;
     if (audience.kind !== "session")
         return false;
-    return liveness === "ended" || liveness === "lost" || liveness === null;
+    return liveness === "ended";
 }
 export function readTimeoutDeadline(hqRoot, laneId) {
     const filePath = timeoutPath(hqRoot, laneId);
@@ -655,12 +655,25 @@ export async function runPassBody(hqRoot, deps) {
     };
     const readSessionSenior = deps.readSessionSenior ??
         ((sessionId) => defaultReadSessionSenior(hqRoot, sessionId));
+    const configuredClaudeHomes = Object.values(config.providers.claude.accounts).map((account) => account.home);
+    const sessionStateCache = new Map();
     const sessionState = (sessionId) => {
+        if (sessionStateCache.has(sessionId)) {
+            return sessionStateCache.get(sessionId) ?? null;
+        }
         const entry = livenessIndex.sessions[sessionId];
-        if (!entry)
-            return null;
-        return classifySessionLiveness(entry, nowMs, presenceConnected, config.liveness);
+        if (!entry) {
+            const state = unindexedClaudeSessionLiveness(sessionId, nowMs, config.liveness, livenessDeps, configuredClaudeHomes);
+            sessionStateCache.set(sessionId, state);
+            return state;
+        }
+        const state = classifySessionLiveness(entry, nowMs, presenceConnected, config.liveness);
+        sessionStateCache.set(sessionId, state);
+        return state;
     };
+    const questionAgeWindowMs = (audience) => audience.kind === "session"
+        ? config.session_question_timeout_secs * 1000
+        : QUESTION_AGE_MS;
     if (deps.afterLoad)
         await deps.afterLoad();
     markOverdueLanes(hqRoot, lanes, summary, deps, now);
@@ -680,12 +693,22 @@ export async function runPassBody(hqRoot, deps) {
             });
             continue;
         }
-        const liveness = audience.kind === "session" && audience.id
-            ? sessionState(audience.id)
-            : audience.kind === "user"
-                ? "live"
-                : null;
         try {
+            let liveness;
+            try {
+                liveness =
+                    audience.kind === "session" && audience.id
+                        ? sessionState(audience.id)
+                        : audience.kind === "user"
+                            ? "live"
+                            : null;
+            }
+            catch (err) {
+                // A failed metadata probe cannot prove that the session ended, but it
+                // must not suppress the independent unanswered-timeout rule below.
+                markError(summary, err);
+                liveness = null;
+            }
             if (shouldAdvanceAudienceEnded(audience, liveness)) {
                 const nextHop = question.hop + 1;
                 const nextAudience = resolveQuestionAudience({ ...question, hop: nextHop }, readLaneSenior, readSessionSenior);
@@ -712,12 +735,17 @@ export async function runPassBody(hqRoot, deps) {
                 }
                 continue;
             }
-            if (shouldAgeQuestion(question, audience, nowMs)) {
+            if (shouldAgeQuestion(question, audience, nowMs, questionAgeWindowMs(audience))) {
                 const nextHop = question.hop + 1;
                 const nextAudience = resolveQuestionAudience({ ...question, hop: nextHop }, readLaneSenior, readSessionSenior);
-                const result = casQuestionIf(hqRoot, question.question_id, (current) => current.status === "pending" &&
-                    agedAdvanceCount(current) < MAX_AGED_ADVANCES &&
-                    shouldAgeQuestion(current, resolveQuestionAudience(current, readLaneSenior, readSessionSenior), nowMs), (current) => {
+                const result = casQuestionIf(hqRoot, question.question_id, (current) => {
+                    if (current.status !== "pending" ||
+                        agedAdvanceCount(current) >= MAX_AGED_ADVANCES) {
+                        return false;
+                    }
+                    const currentAudience = resolveQuestionAudience(current, readLaneSenior, readSessionSenior);
+                    return shouldAgeQuestion(current, currentAudience, nowMs, questionAgeWindowMs(currentAudience));
+                }, (current) => {
                     const entry = {
                         hop: current.hop + 1,
                         audience: nextAudience,
@@ -748,7 +776,7 @@ export async function runPassBody(hqRoot, deps) {
             markDirty(summary, {
                 kind: "question",
                 id: question.question_id,
-                why: `advance failed: ${err instanceof Error ? err.message : String(err)}`,
+                why: `advance failed: ${err instanceof LanesError ? `${err.error}: ` : ""}${err instanceof Error ? err.message : String(err)}`,
             });
         }
     }

package/dist/lib/lanes/registry-flag.js

@@ -1,6 +1,7 @@
 import { createFlagClient, readLocalOverride, } from "@indigoai-us/hq-flags-client";
 import { ensureCognitoIdToken } from "../../utils/cognito-session.js";
-export const LANES_FLAG_API_DEFAULT_ENDPOINT = "https://hqapi.hq.computer";
+import { FLAG_REGISTRY_DEFAULT_ENDPOINT, resolveFlagRegistryEndpoint, } from "../flag-registry-endpoint.js";
+export const LANES_FLAG_API_DEFAULT_ENDPOINT = FLAG_REGISTRY_DEFAULT_ENDPOINT;
 export const LANES_FLAG_READ_TIMEOUT_MS = 5_000;
 const registryReads = new Map();
 class MissingFlagTokenError extends Error {
@@ -45,7 +46,7 @@ export async function readLanesRegistryFlag(flagKey, options = {}) {
     const localOverride = readLocalOverride(flagKey, env);
     if (localOverride !== null)
         return localOverride;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || LANES_FLAG_API_DEFAULT_ENDPOINT;
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const key = cacheKey(flagKey, options.company, endpoint);
     const cached = registryReads.get(key);
     if (cached)

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

@@ -706,6 +706,8 @@ export interface LanesConfig {
     providers: Record<LaneProvider, ProviderConfig>;
     throttle: ThrottleConfig;
     liveness: LivenessWindows;
+    /** Seconds an unanswered question waits at a session audience before advancing. */
+    session_question_timeout_secs: number;
 }
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;

package/dist/node-network-compat-flag.js

@@ -1,4 +1,5 @@
 import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
+import { resolveFlagRegistryEndpoint } from "./lib/flag-registry-endpoint.js";
 export const NODE_NETWORK_FORCE_IPV4_FLAG = "cli.network.force-ipv4";
 export const NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK = false;
 // Node waits up to 1s before trying the next address family. Keep this request
@@ -29,10 +30,9 @@ export async function nodeNetworkForceIpv4Enabled(dependencies = {}) {
     const localOverride = readLocalOverride(NODE_NETWORK_FORCE_IPV4_FLAG, env);
     if (localOverride !== null)
         return localOverride;
-    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
     const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!endpoint ||
-        !/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
         return NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK;
     }
     const companySlug = env.HQ_COMPANY_SLUG?.trim() || "";

package/package.json

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