@indigoai-us/hq-cli 5.345.56 → 5.345.57

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

@@ -27,7 +27,7 @@ export interface OutpostDispatchResult {
     stderr: string;
 }
 export interface OutpostLaneCommand {
-    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target";
+    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target" | "blocked-escalation-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -53,6 +53,8 @@ export interface OutpostLaneCommand {
     json?: boolean;
     callerLaneId?: string;
     callerSessionId?: string;
+    messageId?: string;
+    recipientKind?: "lane" | "session";
 }
 export declare function buildOutpostQuestionAnswerCommand(input: {
     questionId: string;
@@ -114,6 +116,12 @@ export declare function buildOutpostLegacyLaneUlidListCommand(input: {
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export declare function buildOutpostQuestionListCommand(input?: {
     company?: string;
+    sessionId?: string;
+    for?: string;
+    from?: string;
+    project?: string;
+    story?: string;
+    status?: string;
 }): string;
 /** Read one question's body and owner-computed audience from its Outpost. */
 export declare function buildOutpostQuestionShowCommand(questionId: string): string;

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

@@ -121,10 +121,23 @@ export function buildOutpostLegacyLaneUlidListCommand(input) {
 }
 /** Read questions on one Outpost, scoped to a company when supplied. */
 export function buildOutpostQuestionListCommand(input = {}) {
-    const args = ["hq", "lanes", "questions", "list"];
+    const args = [
+        ...(input.sessionId?.trim() ? ["env", `HQ_SESSION_ID=${input.sessionId.trim()}`] : []),
+        "hq", "lanes", "questions", "list",
+    ];
     const company = input.company?.trim();
     if (company)
         args.push("--company", company);
+    for (const [flag, value] of [
+        ["--for", input.for],
+        ["--from", input.from],
+        ["--project", input.project],
+        ["--story", input.story],
+        ["--status", input.status],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
     return withRemoteHqDir(joinCommandParts(args));
 }
 /** Read one question's body and owner-computed audience from its Outpost. */
@@ -191,12 +204,12 @@ export function buildOutpostIdentityBackfillCommand(expectedId) {
 }
 /** Build the same `hq outposts exec` remote command used by lane pickup. */
 export function buildOutpostLaneCommand(input) {
-    const args = [
-        input.hqBinary?.trim() || "hq",
-        "lanes",
-        input.action,
-        input.laneId,
-    ];
+    const action = input.action === "blocked-escalation-target" ? "_enqueue-blocked-escalation" : input.action;
+    const args = [input.hqBinary?.trim() || "hq", "lanes", action];
+    if (input.action === "blocked-escalation-target")
+        args.push(input.recipientKind ?? "lane", input.laneId);
+    else
+        args.push(input.laneId);
     for (const [flag, value] of [
         ["--text", input.text],
         ["--project", input.project],
@@ -214,6 +227,7 @@ export function buildOutpostLaneCommand(input) {
         ["--senior", input.senior],
         ["--reason", input.reason],
         ["--company", input.company],
+        ["--message-id", input.messageId],
     ]) {
         if (value !== undefined)
             args.push(flag, value);

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

@@ -40,6 +40,20 @@ export interface ReconcileChange {
     /** The attempted provider PATH when admission found no executable. */
     searched_path?: string;
 }
+export interface BlockedLaneEscalationDelivery {
+    lane_id: string;
+    project_id: string;
+    story_id: string;
+    direct_senior: SeniorRef;
+    recipient: SeniorRef;
+    recipient_host?: LaneRecord["host"];
+    blocked_since: string;
+    at: string;
+    hours: number;
+    blocked_reason: string;
+    message_id: string;
+    text: string;
+}
 export interface ReconcileSummary {
     ok: boolean;
     action: "reconcile";
@@ -57,6 +71,7 @@ export interface ReconcileSummary {
         id: string;
         reason: KeepAliveBlockedReason;
     }>;
+    blocked_escalations: Array<Pick<BlockedLaneEscalationDelivery, "lane_id" | "recipient" | "blocked_since" | "at" | "hours" | "blocked_reason" | "message_id" | "text">>;
     errors: Array<{
         message: string;
         code?: string;
@@ -94,6 +109,10 @@ export interface ReconcileDeps {
     skipAdmissionWithoutCpuSample?: boolean;
     /** Flag reader seam used to assert rollout reads happen before admission locks. */
     readRegistryFlag?: typeof readLanesRegistryFlag;
+    /** Durable delivery seam for six-hour blocked-lane escalation. */
+    deliverBlockedEscalation?: (delivery: BlockedLaneEscalationDelivery) => Promise<void>;
+    /** Read a missing escalation ancestor from the authoritative hierarchy. */
+    resolveEscalationLane?: (laneId: string) => Promise<LaneRecord | null>;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */

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;

package/dist/lib/lanes/spawn.js

@@ -1993,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);
     }
@@ -2602,7 +2604,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let workerPid;
     let watcherPid;
     try {
-        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"));
+        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,

package/dist/lib/lanes/store.js

@@ -537,6 +537,7 @@ export function parseLaneRecord(raw, filePath) {
         });
     }
     for (const field of [
+        "blocked_since",
         "keep_alive_opted_in_at",
         "keep_alive_last_resume_at",
         "keep_alive_next_eligible_at",
@@ -547,6 +548,24 @@ export function parseLaneRecord(raw, filePath) {
         if (raw[field] !== undefined)
             requireTimestamp(raw[field], field, filePath);
     }
+    if (raw.escalations !== undefined) {
+        if (!Array.isArray(raw.escalations)) {
+            throw new LaneSchemaError("escalations must be an array", { path: filePath, field: "escalations" });
+        }
+        for (const [index, value] of raw.escalations.entries()) {
+            const field = `escalations[${index}]`;
+            if (!isPlainObject(value) || Object.keys(value).some((key) => !["at", "to", "hours"].includes(key))) {
+                throw new LaneSchemaError(`${field} must contain only at, to, and hours`, { path: filePath, field });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+            if (typeof value.to !== "string" || value.to.trim() === "") {
+                throw new LaneSchemaError(`${field}.to must be a non-empty string`, { path: filePath, field: `${field}.to` });
+            }
+            if (typeof value.hours !== "number" || !Number.isFinite(value.hours) || value.hours < 6) {
+                throw new LaneSchemaError(`${field}.hours must be a finite number of at least 6`, { path: filePath, field: `${field}.hours` });
+            }
+        }
+    }
     requireString(raw.project_id, "project_id");
     if (typeof raw.story_id !== "string" ||
         (raw.story_id.trim() === "" && raw.no_story_reason === undefined)) {
@@ -1165,9 +1184,27 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
+    const seen_at = raw.seen_at === undefined ? null : raw.seen_at;
+    if (seen_at !== null &&
+        (typeof seen_at !== "string" || !Number.isFinite(Date.parse(seen_at)))) {
+        throw new LaneSchemaError("seen_at must be a valid timestamp or null", {
+            path: filePath,
+            value: seen_at,
+        });
+    }
+    const seen_session_id = raw.seen_session_id === undefined ? null : raw.seen_session_id;
+    if (seen_session_id !== null &&
+        (typeof seen_session_id !== "string" || !seen_session_id.trim())) {
+        throw new LaneSchemaError("seen_session_id must be a non-empty string or null", {
+            path: filePath,
+            value: seen_session_id,
+        });
+    }
     return {
         ...raw,
         delivered_at,
+        seen_at,
+        seen_session_id,
         ...(raw.priority === null ? { priority: undefined } : {}),
     };
 }
@@ -1362,12 +1399,15 @@ export function mergeQuestionRecords(live, sidecars) {
     const all = [live, ...sidecars];
     const base = higherVersionRecord(live, sidecars);
     const deliveredAt = all
+        .filter((record) => record.status === "answered")
         .map((record) => record.delivered_at)
         .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
         .sort((a, b) => Date.parse(a) - Date.parse(b))[0] ?? null;
     return {
         ...base,
         delivered_at: deliveredAt,
+        seen_at: base.seen_at ?? null,
+        seen_session_id: base.seen_session_id ?? null,
         answer_history: unionHistory(all.map(questionAnswerHistory), entryIdentity, questionAnswerHistory(base)),
         routing_history: unionHistory(all.map((record) => record.routing_history), entryIdentity, base.routing_history),
     };
@@ -1631,14 +1671,19 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
         // `current` is the pre-update snapshot and stays untouched: the updater
         // receives a deep clone, so mutating its argument in place cannot reach
         // the record the ownership check compares against.
-        const updated = updater(structuredClone(current));
+        const proposed = updater(structuredClone(current));
+        const updated = current.state === "blocked" && proposed.state !== "blocked"
+            ? { ...proposed, blocked_since: undefined }
+            : proposed;
         for (const key of Object.keys(updated)) {
             if (key === "version" || key === "updated_at" || fieldUnchanged(current[key], updated[key]))
                 continue;
             const allowedWriters = LANE_FIELD_WRITERS[key];
+            const transitionClearedBlockedSince = key === "blocked_since" &&
+                current.state === "blocked" && updated.state !== "blocked" && updated.blocked_since === undefined;
             // Unknown forward-version fields are preserved, never assigned an
             // ownership rule by a v1 reader.
-            if (allowedWriters && !allowedWriters.includes(writer)) {
+            if (allowedWriters && !allowedWriters.includes(writer) && !transitionClearedBlockedSince) {
                 throw new LanesError("lane_writer_unauthorized", `Writer ${writer} cannot write lane field ${key}`, { writer, field: key });
             }
         }
@@ -1909,6 +1954,8 @@ export function createQuestion(hqRoot, init, deps = defaultStoreDeps()) {
         schema_version: init.schema_version ?? QUESTION_SCHEMA_VERSION,
         question_id,
         delivered_at: init.delivered_at ?? null,
+        seen_at: init.seen_at ?? null,
+        seen_session_id: init.seen_session_id ?? null,
         version: 1,
         routing_history: init.routing_history ?? [],
     };

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

@@ -546,6 +546,10 @@ export interface LaneRecord {
     senior: SeniorRef;
     senior_history: SeniorHistoryEntry[];
     state: LaneState;
+    /** Start of the current uninterrupted blocked episode; never inferred from an envelope. */
+    blocked_since?: string;
+    /** Durable six-hour blocked-lane escalation history. */
+    escalations?: LaneEscalationEntry[];
     queued_reason?: QueuedReason;
     queued_details?: QueuedDetails;
     /** Time the current queue turn began; old records fall back to created_at. */
@@ -573,6 +577,8 @@ export interface LaneRecord {
     keep_alive?: boolean;
     /** Whether completed keep-alive stories wait for queued work after a done turn. */
     keep_alive_standing?: boolean;
+    /** Conduct loop lanes keep one registered worker identity while phases are queued. */
+    loop_mode?: true;
     /** Time this lane most recently explicitly opted into keep-alive. */
     keep_alive_opted_in_at?: string;
     /** Why reconcile declined to resume this lane most recently. */
@@ -765,6 +771,11 @@ export interface LaneRecord {
     /** Last successful lane_progress mesh delivery, preserved across watcher restarts. */
     last_progress_event_at?: string;
 }
+export interface LaneEscalationEntry {
+    at: string;
+    to: string;
+    hours: number;
+}
 /** The v1 fields that must exist on every durable lane record (spec §3).
  * `company` is normalized from absence for pre-attribution legacy records. */
 export declare const REQUIRED_LANE_RECORD_FIELDS: readonly ["schema_version", "lane_id", "project_id", "story_id", "depth", "senior", "senior_history", "state", "priority", "provider", "host", "version", "created_at", "updated_at", "attribution_history"];
@@ -809,6 +820,10 @@ export interface PendingResume {
     trigger: "answered_questions" | "message" | "monitor_event" | "system_notice" | "resume" | "watcher";
     /** True when this queued resume was initiated automatically by keep-alive. */
     keep_alive?: true;
+    /** Working directory for a deferred loop phase. */
+    working_directory?: string;
+    /** Start this deferred conduct phase with a fresh provider session. */
+    fresh_thread?: true;
     resumed_from?: "interrupted" | "done" | "blocked" | "failed" | "awaiting_input";
     from_failed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
@@ -930,6 +945,9 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
+    /** When the current session audience last saw this pending question. */
+    seen_at?: string | null;
+    seen_session_id?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/dist/lib/lanes/types.js

@@ -230,11 +230,11 @@ export const LANE_FIELD_WRITERS = {
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],
     released_hire_grant: ["command"],
-    state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
+    state: ["creator", "command", "watcher", "reconcile", "spawn"], blocked_since: ["watcher", "reconcile"], escalations: ["reconcile"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile", "spawn"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile", "spawn"], keep_alive_next_eligible_at: ["command", "reconcile", "spawn"], keep_alive_exhausted_at: ["command", "reconcile", "spawn"],
+    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile", "spawn"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile", "spawn"], keep_alive_next_eligible_at: ["command", "reconcile", "spawn"], keep_alive_exhausted_at: ["command", "reconcile", "spawn"], loop_mode: ["creator"],
     provider: ["creator", "command"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],

package/dist/lib/lanes/watcher.js

@@ -469,6 +469,9 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
             ...current,
             ...runResultFields(hqRoot, current, at),
             state: effectiveClassification.state,
+            blocked_since: effectiveClassification.state === "blocked"
+                ? current.state === "blocked" ? current.blocked_since ?? at : at
+                : undefined,
             queued_reason: undefined,
             queued_details: undefined,
             stalled: undefined,

package/package.json

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