@indigoai-us/hq-cli 5.198.0 → 5.198.1

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## [Unreleased]
 
+## [5.198.1] — 2026-09-25
+
 ## [5.198.0] — 2026-09-25
 
 ### Added
@@ -25,6 +27,13 @@
   `result` / `error.message` / `subtype` — instead of the last characters of
   the JSON tail (`"costUsdTicks" | } | "numTurns" | }`). Log only; never
   posted to a person.
+- Session questions stay with live or unknown sessions until their configured
+  unanswered timeout; only a positive `session_end` advances immediately. When
+  there is no Work Mesh entry, hq-cli checks Claude transcript metadata in
+  configured account homes without opening transcript contents, using the
+  newest matching mtime. Metadata errors remain visible and do not block the
+  independent timeout. The timeout defaults to 600 seconds. A running-lane
+  answer reports `awaiting_next_tool_call` after its durable dropbox append.
 
 ## [5.197.0] — 2026-09-25
 

package/dist/commands/lanes.js

@@ -6771,7 +6771,7 @@ function deliverAnswerToAskingLane(ctx, question, choice, at) {
         }
         assertLaneRunsHereForOperatorMutation(ctx, lane, "deliver an answer to");
         appendDropboxMessage(hqRoot, laneId, answerDropboxMessage(question, choice, at, mintMessageId()));
-        return { status: "dropped" };
+        return { status: "awaiting_next_tool_call" };
     }
     catch (err) {
         writeAnswerDeliveryFailed(hqRoot, laneId, question.question_id, err, at);

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/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/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/package.json

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