@indigoai-us/hq-cli 5.345.55 → 5.345.57

package/dist/lib/lanes/reconcile.js

@@ -20,17 +20,18 @@ import { loadWorkerProfile } from "./profile.js";
 import { terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, nextEnvelopePath, readPidRecord, readProcStarttime, readSpawnManifest, markSpawnFailure, stopLaneProcesses, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
-import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
+import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, retryUpdateLane, readQuestion, listQuestionIds, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyObservation, recordCpuBusyObservation, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "./registry-flag.js";
-import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, } from "./flag-keys.js";
+import { LANE_BLOCKED_ESCALATION_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_KEEP_ALIVE_DUE_WAKE_PRECISE_FLAG, LANE_LEAD_ADMISSION_PRIORITY_FLAG, LANE_QUOTA_ACCOUNT_FAILOVER_FLAG, } from "./flag-keys.js";
 import { checkLaneDiskSpace, configuredCodexRolloutHomes, laneDiskAccount, retainCodexRollouts } from "./disk-guard.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
-import { appendDropboxMessage } from "./dropbox.js";
+import { appendDropboxMessageOnce, appendDropboxMessageOnceAtPath } from "./dropbox.js";
+import { monitorSessionDir } from "../monitor.js";
 import { DEFAULT_RUNAWAY_SEARCH_GUARD_CONFIG, listHostProcesses, runRunawayToolGuard, RUNAWAY_TOOL_GUARD_FLAG, } from "./runaway-tool-guard.js";
 import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG, LEAD_LANE_KEEP_ALIVE_IMMEDIATE_FIRST_RESUME_FLAG, LEAD_LANE_KEEP_ALIVE_FIRST_RESUME_SETTLE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS, LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT, queueLaneTerminalResume, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, doneKeepAliveVerdict, dueKeepAliveNextCheckMs, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { isFailedQuotaKeepAliveLane, providerSupportsSessionResume } from "./delivery.js";
-import { isIsoDateTime } from "./types.js";
+import { LANE_PROVIDERS, isIsoDateTime, isTerminalLaneState } from "./types.js";
 import { applyDefaultQuotaHold, clearAccountQuotaAfterSuccessfulTurnBestEffort, loadQuotaState, readQuotaSignal, recordAccountQuota, } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
@@ -120,6 +121,7 @@ function emptySummary(dryRun) {
         heartbeats: [],
         skipped: [],
         keep_alive_blocked: [],
+        blocked_escalations: [],
         errors: [],
         heartbeat_at: null,
     };
@@ -193,6 +195,161 @@ export function currentHopStartedAtMs(question) {
     const ms = Date.parse(raw);
     return Number.isFinite(ms) ? ms : Number.NEGATIVE_INFINITY;
 }
+const BLOCKED_ESCALATION_WINDOW_MS = 6 * 60 * 60 * 1000;
+const BLOCKED_ESCALATION_OPERATOR_SESSION = "fad349d4-38a6-4ae0-b8cc-e5dfd1bc3e9a";
+function seniorKey(senior) {
+    return senior.id ? `${senior.kind}:${senior.id}` : senior.kind;
+}
+function recipientIsOnCurrentHost(recipientHost, currentHost) {
+    if (!recipientHost)
+        return false;
+    if (recipientHost.kind === "outpost")
+        return currentHost.outpostId === recipientHost.id;
+    return currentHost.outpostId === null;
+}
+async function reconcileBlockedEscalations(hqRoot, lanes, summary, deps, now) {
+    const env = deps.env ?? process.env;
+    const flagReader = deps.readRegistryFlag ?? readLanesRegistryFlagFailOpen;
+    const nowMs = now.getTime();
+    const findLane = async (laneId) => lanes.find((candidate) => candidate.lane_id === laneId) ??
+        (await deps.resolveEscalationLane?.(laneId)) ??
+        undefined;
+    for (const snapshot of lanes) {
+        if (snapshot.state !== "blocked" || !laneRunsHere(snapshot, deps.host))
+            continue;
+        if (lanes.some((child) => child.senior.kind === "lane" && child.senior.id === snapshot.lane_id && !isTerminalLaneState(child.state)))
+            continue;
+        let enabled;
+        try {
+            enabled = await flagReader(LANE_BLOCKED_ESCALATION_FLAG, {
+                company: resolveLaneCompany(hqRoot, snapshot).company,
+                env,
+                defaultValue: true,
+            });
+        }
+        catch (error) {
+            markError(summary, error);
+            continue;
+        }
+        if (!enabled)
+            continue;
+        let lane = readLane(hqRoot, snapshot.lane_id);
+        if (!lane.blocked_since) {
+            if (!deps.dryRun) {
+                lane = retryUpdateLane(hqRoot, lane.lane_id, "reconcile", (current) => current.state === "blocked" && !current.blocked_since
+                    ? { ...current, blocked_since: now.toISOString() }
+                    : current);
+            }
+            continue;
+        }
+        const blockedSinceMs = Date.parse(lane.blocked_since);
+        if (!Number.isFinite(blockedSinceMs) || nowMs - blockedSinceMs < BLOCKED_ESCALATION_WINDOW_MS)
+            continue;
+        const last = lane.escalations?.at(-1);
+        if (last && nowMs - Date.parse(last.at) < BLOCKED_ESCALATION_WINDOW_MS)
+            continue;
+        const directSenior = lane.senior;
+        let recipient = { kind: "session", id: BLOCKED_ESCALATION_OPERATOR_SESSION };
+        let recipientHost;
+        if (directSenior.kind === "lane" && directSenior.id) {
+            let seniorLane;
+            try {
+                seniorLane = await findLane(directSenior.id);
+            }
+            catch (error) {
+                markError(summary, error);
+                continue;
+            }
+            if (!seniorLane) {
+                markError(summary, new LanesError("blocked_escalation_ancestor_unavailable", `Could not resolve direct senior lane ${directSenior.id}`, {
+                    lane_id: lane.lane_id,
+                    senior_lane_id: directSenior.id,
+                }));
+                continue;
+            }
+            recipient = seniorLane.senior;
+            if (recipient.kind === "lane" && recipient.id) {
+                try {
+                    recipientHost = (await findLane(recipient.id))?.host;
+                }
+                catch (error) {
+                    markError(summary, error);
+                    continue;
+                }
+                if (!recipientHost) {
+                    markError(summary, new LanesError("blocked_escalation_ancestor_unavailable", `Could not resolve escalation recipient lane ${recipient.id}`, {
+                        lane_id: lane.lane_id,
+                        recipient_lane_id: recipient.id,
+                    }));
+                    continue;
+                }
+            }
+            else if (recipient.kind !== "session") {
+                recipient = { kind: "session", id: BLOCKED_ESCALATION_OPERATOR_SESSION };
+            }
+        }
+        if (recipient.kind === "session")
+            recipientHost = { kind: "local", id: "primary" };
+        const hours = Math.round(((nowMs - blockedSinceMs) / 3600000) * 100) / 100;
+        const blockedReason = lane.last_envelope?.blocked_reason ?? lane.terminal_reason ?? "not recorded";
+        const messageId = `blocked-escalation-${lane.lane_id}-${Math.floor((nowMs - blockedSinceMs) / BLOCKED_ESCALATION_WINDOW_MS)}`;
+        const text = `Blocked lane escalation\nLane: ${lane.lane_id}\nStory: ${lane.story_id}\nDirect senior: ${seniorKey(directSenior)}\nBlocked since: ${lane.blocked_since}\nHours blocked: ${hours}\nLast blocked_reason: ${blockedReason}`;
+        const delivery = {
+            lane_id: lane.lane_id,
+            project_id: lane.project_id,
+            story_id: lane.story_id,
+            direct_senior: directSenior,
+            recipient,
+            recipient_host: recipientHost,
+            blocked_since: lane.blocked_since,
+            at: now.toISOString(),
+            hours,
+            blocked_reason: blockedReason,
+            message_id: messageId,
+            text,
+        };
+        summary.blocked_escalations.push(delivery);
+        if (deps.dryRun)
+            continue;
+        try {
+            const current = readLane(hqRoot, lane.lane_id);
+            if (current.state !== "blocked" ||
+                current.blocked_since !== lane.blocked_since ||
+                (current.escalations?.at(-1) !== undefined &&
+                    nowMs - Date.parse(current.escalations.at(-1).at) < BLOCKED_ESCALATION_WINDOW_MS))
+                continue;
+            if (deps.deliverBlockedEscalation && !recipientIsOnCurrentHost(recipientHost, deps.host)) {
+                await deps.deliverBlockedEscalation(delivery);
+            }
+            else if (recipient.kind === "lane" && recipient.id) {
+                appendDropboxMessageOnce(hqRoot, recipient.id, { at: delivery.at, message_id: messageId, kind: "blocked_escalation", text });
+            }
+            else if (recipient.kind === "session" && recipient.id) {
+                const dirs = LANE_PROVIDERS.map((provider) => monitorSessionDir(hqRoot, provider, recipient.id))
+                    .filter((dir) => fs.existsSync(dir));
+                if (dirs.length !== 1)
+                    throw new LanesError("blocked_escalation_recipient_unavailable", `Expected one durable inbox for ${recipient.id}; found ${dirs.length}`);
+                appendDropboxMessageOnceAtPath(path.join(dirs[0], "dropbox"), { at: delivery.at, message_id: messageId, kind: "blocked_escalation", text });
+            }
+            else {
+                throw new LanesError("blocked_escalation_recipient_invalid", `Cannot resolve escalation recipient ${seniorKey(recipient)}`);
+            }
+            retryUpdateLane(hqRoot, lane.lane_id, "reconcile", (latest) => {
+                if (latest.state !== "blocked" ||
+                    latest.blocked_since !== lane.blocked_since ||
+                    latest.escalations?.some((entry) => entry.at === delivery.at) ||
+                    (latest.escalations?.at(-1) !== undefined &&
+                        nowMs - Date.parse(latest.escalations.at(-1).at) < BLOCKED_ESCALATION_WINDOW_MS))
+                    return latest;
+                const entry = { at: delivery.at, to: seniorKey(recipient), hours };
+                return { ...latest, escalations: [...(latest.escalations ?? []), entry] };
+            });
+        }
+        catch (error) {
+            markError(summary, error);
+        }
+    }
+}
 export function shouldAgeQuestion(question, audience, nowMs, ageWindowMs = QUESTION_AGE_MS, maxAgedAdvances = MAX_AGED_ADVANCES) {
     if (question.status !== "pending")
         return false;
@@ -203,6 +360,12 @@ export function shouldAgeQuestion(question, audience, nowMs, ageWindowMs = QUEST
     const started = currentHopStartedAtMs(question);
     if (started === Number.NEGATIVE_INFINITY)
         return false;
+    if (question.hop === 1 && audience.kind === "session") {
+        const seenAt = question.seen_at ? Date.parse(question.seen_at) : Number.NaN;
+        if (!Number.isFinite(seenAt) || question.seen_session_id !== audience.id)
+            return false;
+        return nowMs - Math.max(started, seenAt) >= ageWindowMs;
+    }
     return nowMs - started >= ageWindowMs;
 }
 export function shouldAdvanceAudienceEnded(audience, liveness) {
@@ -932,7 +1095,7 @@ async function runRunawayToolGuardPass(hqRoot, lanes, config, deps, now, summary
                 ((pid, expectedStarttime) => readProcStarttime(pid) === expectedStarttime),
             signal: deps.runawayToolProcessSignal ?? ((pid, signal) => process.kill(pid, signal)),
             recordEvent: (laneId, event) => appendWatcherEvent(watcherEventsPath(hqRoot, laneId), event, deps.runawayToolEventAppend),
-            notifyLane: (laneId, text) => appendDropboxMessage(hqRoot, laneId, {
+            notifyLane: (laneId, text) => appendDropboxMessageOnce(hqRoot, laneId, {
                 at: now.toISOString(),
                 message_id: `runaway-search-guard:${laneId}:${now.getTime()}`,
                 kind: "system_notice",
@@ -977,6 +1140,7 @@ export async function runPassBody(hqRoot, deps) {
     if (deps.terminalKeepAliveCandidate) {
         return runTerminalKeepAliveCandidatePass(hqRoot, lanes, summary, deps, now, deps.terminalKeepAliveCandidate);
     }
+    await reconcileBlockedEscalations(hqRoot, lanes, summary, deps, now);
     await resumeDueQuotaHeldLanes(hqRoot, lanes, summary, deps, now);
     let presenceConnected;
     try {
@@ -1134,7 +1298,8 @@ export async function runPassBody(hqRoot, deps) {
                 markError(summary, err);
                 liveness = null;
             }
-            if (shouldAdvanceAudienceEnded(audience, liveness)) {
+            const mustWaitForOperatorDelivery = question.hop === 1 && audience.kind === "session";
+            if (!mustWaitForOperatorDelivery && shouldAdvanceAudienceEnded(audience, liveness)) {
                 const nextHop = question.hop + 1;
                 const nextAudience = resolveQuestionAudience({ ...question, hop: nextHop }, readLaneSenior, readSessionSenior);
                 const result = casQuestionIf(hqRoot, question.question_id, (current) => current.status === "pending" && current.hop === question.hop, (current) => {
@@ -1147,6 +1312,7 @@ export async function runPassBody(hqRoot, deps) {
                     return {
                         ...current,
                         hop: nextHop,
+                        delivered_at: null,
                         routing_history: appendCappedHistory(current.routing_history, entry),
                     };
                 }, deps.dryRun);
@@ -1190,6 +1356,7 @@ export async function runPassBody(hqRoot, deps) {
                     return {
                         ...current,
                         hop: current.hop + 1,
+                        delivered_at: null,
                         routing_history: appendCappedHistory(current.routing_history, entry),
                     };
                 }, deps.dryRun);

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

@@ -92,6 +92,8 @@ export interface SpawnLaneDeps {
     runCompaction?: RunCompactionFn;
     /** Finds a session transcript under an account home. Injected in tests. */
     locateTranscript?: (home: string, sessionId: string) => string | null;
+    /** Internal loop-lane override for the single provider turn's working directory. */
+    workingDirectory?: string;
 }
 export interface ProviderLaunch {
     command: string;
@@ -128,6 +130,8 @@ export declare function readProcStarttimeDetailed(pid: number): {
     starttime: number | null;
     error: string | null;
 };
+/** macOS has no /proc; use ps's process start time as the PID identity token. */
+export declare function parsePsStarttime(value: string): number | null;
 export declare function readProcStarttime(pid: number): number | null;
 export declare function parsePidRecord(text: string): PidRecord | null;
 export declare function readPidRecord(filePath: string): PidRecord | null;

package/dist/lib/lanes/spawn.js

@@ -31,6 +31,7 @@ import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./s
 import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
 import { LANE_QUOTA_ACCOUNT_FAILOVER_FLAG } from "./flag-keys.js";
 import { readLanesRegistryFlagFailOff } from "./registry-flag.js";
+import { LANE_WORKER_EXIT_PATH_ENV } from "./worker-process.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT } from "./keep-alive.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
@@ -932,6 +933,16 @@ export function readProcStarttimeDetailed(pid) {
     }
     catch (err) {
         const code = err.code;
+        if (code === "ENOENT" && process.platform === "darwin") {
+            const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart="], {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            const starttime = parsePsStarttime(result.status === 0 ? result.stdout : "");
+            return starttime === null
+                ? { starttime: null, error: result.status === 0 ? "invalid_ps_starttime" : "ENOENT" }
+                : { starttime, error: null };
+        }
         if (code === "ENOENT")
             return { starttime: null, error: "ENOENT" };
         process.stderr.write(`hq lanes: failed to read starttime for pid ${pid}: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -941,6 +952,14 @@ export function readProcStarttimeDetailed(pid) {
         };
     }
 }
+/** macOS has no /proc; use ps's process start time as the PID identity token. */
+export function parsePsStarttime(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const parsed = Date.parse(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+}
 export function readProcStarttime(pid) {
     return readProcStarttimeDetailed(pid).starttime;
 }
@@ -1698,6 +1717,17 @@ function spawnDetached(spawnProcess, command, args, env, cwd, stdoutPath, stderr
             closeFd(errFd, stderrPath);
     }
 }
+function spawnTrackedWorker(spawnProcess, command, args, env, cwd, stdoutPath, stderrPath, exitPath) {
+    try {
+        fs.unlinkSync(exitPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const runnerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../dist/lib/lanes/worker-process.js");
+    return spawnDetached(spawnProcess, process.execPath, [runnerPath, command, ...args], { ...env, [LANE_WORKER_EXIT_PATH_ENV]: exitPath }, cwd, stdoutPath, stderrPath);
+}
 function requireDetached(proveDetached, pid, kind) {
     const proof = proveDetached(pid);
     if (proof.detached)
@@ -1963,13 +1993,15 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // state and the caller sees the error. Admission and question resume keep
     // today's behaviour of naming the terminal reason on the record.
     const markPreSpawnFailure = trigger.kind !== "message" && trigger.kind !== "resume";
-    const plan = pendingResume?.trigger === "answered_questions"
-        ? pendingResume.session_id !== undefined && providerSupportsSessionResume(existing.provider)
-            ? { mode: "resume", session_id: pendingResume.session_id }
-            : planLaneLaunch(existing, { kind: "answered_questions" })
-        : pendingResume?.session_id !== undefined && providerSupportsSessionResume(existing.provider)
-            ? { mode: "resume", session_id: pendingResume.session_id }
-            : planLaneLaunch(existing, trigger);
+    const plan = pendingResume?.fresh_thread === true
+        ? { mode: "fresh" }
+        : pendingResume?.trigger === "answered_questions"
+            ? pendingResume.session_id !== undefined && providerSupportsSessionResume(existing.provider)
+                ? { mode: "resume", session_id: pendingResume.session_id }
+                : planLaneLaunch(existing, { kind: "answered_questions" })
+            : pendingResume?.session_id !== undefined && providerSupportsSessionResume(existing.provider)
+                ? { mode: "resume", session_id: pendingResume.session_id }
+                : planLaneLaunch(existing, trigger);
     if (existing.host.kind === "outpost") {
         refuseOutpostSelfTarget(hqRoot, existing, deps);
     }
@@ -2572,7 +2604,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let workerPid;
     let watcherPid;
     try {
-        workerPid = spawnDetached(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, deps.workingDirectory ?? pendingResume?.working_directory ?? hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,
@@ -2881,7 +2913,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const previous = readSpawnManifest(runDir);
     let workerPid;
     try {
-        workerPid = spawnDetached(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,

package/dist/lib/lanes/status-fields.d.ts

@@ -0,0 +1,12 @@
+import { type LaneRecord } from "./types.js";
+export interface LaneStatusRowFields {
+    last_line: string | null;
+    pr: string | null;
+    inbox_pending: number | null;
+    elapsed_s: number | null;
+    exit: number | null;
+}
+export type LaneStatusRow = LaneRecord & Partial<LaneStatusRowFields>;
+/** Bounded, local-only status data. Remote-owned lanes report null for file-backed fields. */
+export declare function readLaneStatusRowFields(hqRoot: string, lane: LaneRecord, nowMs?: number, local?: boolean): LaneStatusRowFields;
+//# sourceMappingURL=status-fields.d.ts.map

package/dist/lib/lanes/status-fields.js

@@ -0,0 +1,189 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { assertNoSecretText } from "./text-scan.js";
+import { compareEnvelopeNames } from "./envelope-sequence.js";
+import { isTerminalLaneState } from "./types.js";
+const OUTPUT_TAIL_BYTES = 64 * 1024;
+const INBOX_TAIL_BYTES = 32 * 1024;
+const PR_URL = /https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+/g;
+function readTail(filePath, maxBytes) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const stat = fs.fstatSync(fd);
+        const size = stat.size;
+        const start = Math.max(0, size - maxBytes);
+        const buffer = Buffer.alloc(size - start);
+        fs.readSync(fd, buffer, 0, buffer.length, start);
+        return { text: buffer.toString("utf8"), size, mtimeMs: stat.mtimeMs };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            process.stderr.write(`hq lanes: could not read status tail ${filePath}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+function candidateLines(value, depth = 0) {
+    if (depth > 4 || value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return value.split(/\r?\n/);
+    if (Array.isArray(value))
+        return value.flatMap((item) => candidateLines(item, depth + 1));
+    if (typeof value !== "object")
+        return [];
+    const record = value;
+    const direct = ["text", "content", "message", "last_assistant_message", "lastAssistantMessage"]
+        .flatMap((key) => candidateLines(record[key], depth + 1));
+    return direct.length > 0 ? direct : ["item", "message", "response", "result"]
+        .flatMap((key) => candidateLines(record[key], depth + 1));
+}
+function meaningfulLines(text) {
+    const lines = [];
+    for (const raw of text.split(/\r?\n/)) {
+        // eslint-disable-next-line no-control-regex
+        const line = raw.replace(/\x1b\[[0-9;]*m/g, "").trim();
+        if (!line || line.startsWith("{") || line.startsWith("[") || line.includes("cache_read_input_tokens"))
+            continue;
+        lines.push(line);
+    }
+    return lines;
+}
+function linesFromOutput(text) {
+    const output = [];
+    for (const raw of text.split(/\r?\n/)) {
+        if (!raw.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            output.push(...meaningfulLines(candidateLines(parsed).join("\n")));
+        }
+        catch {
+            output.push(...meaningfulLines(raw));
+        }
+    }
+    return output;
+}
+function safeLastLine(lines) {
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const clipped = line.length > 160 ? `${line.slice(0, 157)}…` : line;
+        try {
+            // Same secret detector used by the lane question flow. Drop unsafe output.
+            assertNoSecretText("last_line", clipped);
+            return clipped;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function lastPr(text) {
+    const matches = [...text.matchAll(PR_URL)];
+    return matches.length ? matches[matches.length - 1][0] : null;
+}
+function terminalExit(lane, runDir) {
+    if (!isTerminalLaneState(lane.state))
+        return null;
+    const exitRecord = readTail(path.join(runDir, "logs", "worker-exit.json"), 4 * 1024);
+    if (exitRecord !== null) {
+        try {
+            const parsed = JSON.parse(exitRecord.text);
+            if (typeof parsed.exit_code === "number" && Number.isInteger(parsed.exit_code))
+                return parsed.exit_code;
+        }
+        catch {
+            process.stderr.write(`hq lanes: worker exit record is invalid for ${lane.lane_id}\n`);
+        }
+    }
+    const row = lane;
+    const candidates = [row.worker_exit_code, row.exit_code, row.terminal_details?.exit_code];
+    return candidates.find((value) => Number.isInteger(value)) ?? null;
+}
+function startTimeMs(lane, runDir) {
+    const row = lane;
+    for (const value of [row.worker_started_at, row.started_at]) {
+        const parsed = typeof value === "number" ? value * 1000 : typeof value === "string" ? Date.parse(value) : NaN;
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    try {
+        return fs.statSync(path.join(runDir, "worker.pid")).mtimeMs;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            process.stderr.write(`hq lanes: could not read worker start time ${runDir}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        return null;
+    }
+}
+/** Bounded, local-only status data. Remote-owned lanes report null for file-backed fields. */
+export function readLaneStatusRowFields(hqRoot, lane, nowMs = Date.now(), local = true) {
+    if (!local)
+        return { last_line: null, pr: null, inbox_pending: null, elapsed_s: null, exit: null };
+    const runDir = path.join(hqRoot, "workspace", "lanes-runs", lane.lane_id);
+    const logsDir = path.join(runDir, "logs");
+    const outTail = readTail(path.join(logsDir, "worker.out"), OUTPUT_TAIL_BYTES);
+    const messageTail = readTail(path.join(logsDir, "last-message.txt"), OUTPUT_TAIL_BYTES);
+    const outputTails = [outTail, messageTail]
+        .filter((value) => value !== null)
+        .sort((left, right) => left.mtimeMs - right.mtimeMs);
+    const lines = outputTails.flatMap(({ text }) => linesFromOutput(text));
+    let envelopeTail = null;
+    try {
+        const names = fs.readdirSync(path.join(runDir, "envelopes"))
+            .filter((name) => name.endsWith(".json"))
+            .sort(compareEnvelopeNames);
+        const latest = names.at(-1);
+        if (latest)
+            envelopeTail = readTail(path.join(runDir, "envelopes", latest), OUTPUT_TAIL_BYTES);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            process.stderr.write(`hq lanes: could not read status envelopes for ${lane.lane_id}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    const prSources = [
+        ...outputTails.map(({ text, mtimeMs }) => ({ text, mtimeMs })),
+        ...(envelopeTail ? [{ text: envelopeTail.text, mtimeMs: envelopeTail.mtimeMs }] : []),
+    ].sort((left, right) => left.mtimeMs - right.mtimeMs);
+    const pr = lastPr(prSources.map(({ text }) => text).join("\n"));
+    const inboxTail = readTail(path.join(runDir, "dropbox", "inbox.jsonl"), INBOX_TAIL_BYTES);
+    const inboxPending = inboxTail === null ? 0
+        : inboxTail.size > INBOX_TAIL_BYTES ? null
+            : inboxTail.text.split(/\r?\n/).filter((line) => {
+                if (!line.trim())
+                    return false;
+                try {
+                    return JSON.parse(line) !== null;
+                }
+                catch {
+                    return false;
+                }
+            }).length;
+    const startedAt = startTimeMs(lane, runDir);
+    const terminal = isTerminalLaneState(lane.state);
+    const terminalEndAt = [lane.ended_at, lane.updated_at]
+        .map((value) => typeof value === "string" ? Date.parse(value) : NaN)
+        .find(Number.isFinite);
+    const endedAt = terminal ? terminalEndAt ?? nowMs : nowMs;
+    const elapsed = startedAt === null || !Number.isFinite(endedAt)
+        ? null
+        : Math.max(0, Math.floor((endedAt - startedAt) / 1000));
+    return {
+        last_line: safeLastLine(lines),
+        pr,
+        inbox_pending: inboxPending,
+        elapsed_s: elapsed,
+        exit: terminalExit(lane, runDir),
+    };
+}
+//# sourceMappingURL=status-fields.js.map