@indigoai-us/hq-cli 5.294.0 → 5.296.0

package/dist/lib/lanes/reconcile.js

@@ -31,8 +31,7 @@ import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./qu
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
-import { activeLaneStories, laneStories, storyStatusForEnvelope } from "./stories.js";
-import { resolveManagerStatusGateForLane } from "./manager-status-gate.js";
+import { activeLaneStories, laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -48,43 +47,12 @@ export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
 export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
 export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
-function spawnDepsForHost(deps, lane) {
+function spawnDepsForHost(deps) {
     return {
         ...(deps.spawnLaneDeps ?? {}),
+        env: deps.spawnLaneDeps?.env ?? deps.env ?? process.env,
         hostname: deps.host.hostname,
         admissionHost: deps.host,
-        ...(lane !== undefined && deps.managerStatusGateByLane?.has(lane.lane_id)
-            ? { managerStatusGateEnabled: deps.managerStatusGateByLane.get(lane.lane_id) === true }
-            : {}),
-    };
-}
-async function prepareManagerStatusGateStarts(root, lanes, deps, summary) {
-    const enabledByLane = new Map();
-    let gateFailureRecorded = false;
-    if (!deps.dryRun) {
-        await Promise.all(lanes.filter((lane) => laneRunsHere(lane, deps.host)).map(async (lane) => {
-            const resolution = await resolveManagerStatusGateForLane(root, lane, {
-                env: deps.env,
-                readFlag: deps.readRegistryFlag,
-                onError: (err) => {
-                    if (gateFailureRecorded)
-                        return;
-                    gateFailureRecorded = true;
-                    const code = err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
-                    const message = err instanceof Error ? err.message : String(err);
-                    summary.skipped.push({
-                        kind: "lane",
-                        id: lane.lane_id,
-                        why: `manager status gate disabled for this reconcile pass: ${code}: ${message}`,
-                    });
-                },
-            });
-            enabledByLane.set(lane.lane_id, resolution.enabled);
-        }));
-    }
-    return {
-        ...deps,
-        managerStatusGateByLane: enabledByLane,
     };
 }
 function logSkip(skip) {
@@ -854,7 +822,7 @@ export async function runPassBody(hqRoot, deps) {
     if (deps.afterLoad)
         await deps.afterLoad();
     await runRunawayToolGuardPass(hqRoot, lanes, config, deps, now, summary);
-    const startDeps = await prepareManagerStatusGateStarts(hqRoot, lanes, deps, summary);
+    const startDeps = deps;
     markOverdueLanes(hqRoot, lanes, summary, deps, now);
     await heartbeatAndDeadHosts(hqRoot, lanes, summary, startDeps, now);
     for (const question of questions) {
@@ -1229,7 +1197,7 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     classified.account) {
                     try {
                         const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
-                            ...spawnDepsForHost(deps, classified),
+                            ...spawnDepsForHost(deps),
                         });
                         summary.dead_host.push({
                             id: lane.lane_id,
@@ -1303,24 +1271,22 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     }
                     if (terminalEnvelope && latest) {
                         const envelope = terminalEnvelope;
-                        next.story_status = envelope.story_status;
-                        next.story_complete = envelope.story_complete;
-                        next.story_complete_reason = envelope.story_complete_reason;
-                        const storyStatus = envelope.decision === "blocked"
-                            ? "blocked"
-                            : envelope.decision === "done"
-                                ? "review"
-                                : storyStatusForEnvelope(envelope.story_status);
-                        next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
-                            ? {
-                                ...story,
-                                status: storyStatus,
-                                updated_at: nowIso,
-                                ...(envelope.decision === "blocked"
-                                    ? { blocked_reason: envelope.blocked_reason ?? "" }
-                                    : { blocked_reason: undefined }),
-                            }
-                            : story);
+                        const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+                        if (storyStatus !== undefined) {
+                            next.story_status = envelope.story_status;
+                            next.story_complete = envelope.story_complete;
+                            next.story_complete_reason = envelope.story_complete_reason;
+                            next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                                ? {
+                                    ...story,
+                                    status: storyStatus,
+                                    updated_at: nowIso,
+                                    ...(envelope.decision === "blocked"
+                                        ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                        : { blocked_reason: undefined }),
+                                }
+                                : story);
+                        }
                         if (approvalGate?.violation) {
                             next.last_envelope = {
                                 ref: latest.ref,
@@ -1512,7 +1478,7 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         nowMs,
     });
     const spawnFn = deps.spawn ??
-        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps, lane)));
+        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
     const running = lanes.filter((lane) => (lane.state === "running" ||
         hasFreshAdmissionReservation(lane, now.getTime()) ||
         hasActivePendingResume(lane, now.getTime())) &&
@@ -1699,6 +1665,21 @@ function recordKeepAliveEvent(hqRoot, laneId, summary, event) {
         });
     }
 }
+function keepAliveAccountSelectionEvidence(selection) {
+    if (selection === undefined)
+        return undefined;
+    return {
+        account: selection.account,
+        selected_at: selection.selected_at,
+        reason: selection.reason,
+        considered: selection.considered.map((row) => ({
+            account: row.account,
+            live_lanes: row.live_lanes,
+            eligible: row.eligible,
+            reason: row.ineligible_reason ?? null,
+        })),
+    };
+}
 function keepAliveSkipGuidance(laneId, reason) {
     switch (reason) {
         case "missing_opt_in_time":
@@ -1892,10 +1873,12 @@ async function resumeBlockedKeepAlive(hqRoot, lane, questions, summary, deps, no
         return;
     }
     let current = latest;
+    let accountSelection;
     if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
         try {
             const prepared = await deps.prepareKeepAliveClaudeResume(current);
             current = prepared.lane;
+            accountSelection = prepared.accountSelection;
         }
         catch (error) {
             markDirty(summary, { kind: "lane", id: lane.lane_id, why: `blocked keep-alive account preparation failed: ${error instanceof Error ? error.message : String(error)}` });
@@ -1917,8 +1900,16 @@ async function resumeBlockedKeepAlive(hqRoot, lane, questions, summary, deps, no
     const queued = casLaneIf(hqRoot, latest.lane_id, (latestRecord) => latestRecord.version === expectedVersion && latestRecord.state === "blocked" && latestRecord.last_envelope?.decision === "blocked" && latestRecord.last_envelope.at === terminalAt, (current) => ({
         ...result.lane,
         version: current.version,
+        pending_resume: result.lane.pending_resume === undefined
+            ? undefined
+            : { ...result.lane.pending_resume, keep_alive: true },
         keep_alive_blocked_resume_streak: priorResumes + 1,
         keep_alive_resume_count: (current.keep_alive_resume_count ?? 0) + 1,
+        keep_alive_history: appendCappedHistory(current.keep_alive_history ?? [], {
+            at: now.toISOString(),
+            resumed_from: "blocked",
+            account: current.account ?? null,
+        }),
         keep_alive_last_resume_at: now.toISOString(),
         status_gate_history: appendCappedHistory(current.status_gate_history ?? [], {
             event: "keep_alive_blocked_resumed",
@@ -1935,6 +1926,9 @@ async function resumeBlockedKeepAlive(hqRoot, lane, questions, summary, deps, no
                 at: now.toISOString(),
                 attempt: (lane.keep_alive_resume_count ?? 0) + 1,
                 resumed_from: "blocked",
+                ...(accountSelection !== undefined
+                    ? { account_selection: keepAliveAccountSelectionEvidence(accountSelection) }
+                    : {}),
             });
         }
     }
@@ -2390,6 +2384,7 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             writeAnsweredQuestions(hqRoot, current, questions);
         }
         let accountSelectionFailure;
+        let accountSelection;
         if (current.provider === "claude" && deps.prepareKeepAliveClaudeResume !== undefined) {
             const optInBeforePreparation = current.keep_alive_opted_in_at;
             let preparedLane;
@@ -2397,6 +2392,7 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
                 const prepared = await deps.prepareKeepAliveClaudeResume(current);
                 preparedLane = prepared.lane;
                 accountSelectionFailure = prepared.selectionFailure;
+                accountSelection = prepared.accountSelection;
             }
             catch (err) {
                 // Account balancing is best-effort for keep-alive. A failure to read
@@ -2514,12 +2510,18 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
             pending_resume: {
                 session_id: currentSessionId,
                 trigger: carriesAnsweredQuestions ? "answered_questions" : "resume",
+                keep_alive: true,
                 resumed_from: resumedFrom,
                 text: resumeText,
                 compact: true,
                 at: nowIso,
             },
             keep_alive_resume_count: attempt,
+            keep_alive_history: appendCappedHistory(latestLane.keep_alive_history ?? [], {
+                at: nowIso,
+                resumed_from: resumedFrom,
+                account: latestLane.account ?? null,
+            }),
             keep_alive_last_resume_at: nowIso,
             keep_alive_next_eligible_at: nextEligibleAt,
             keep_alive_exhausted_at: undefined,
@@ -2573,6 +2575,9 @@ async function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, fla
                 attempt,
                 next_eligible_at: nextEligibleAt,
                 resumed_from: resumedFrom,
+                ...(accountSelection !== undefined
+                    ? { account_selection: keepAliveAccountSelectionEvidence(accountSelection) }
+                    : {}),
             });
         }
     }
@@ -2604,7 +2609,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
         const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps, deps.cpuBusyFraction, deps.cpuObservation);
         throttleDecision = throttle.decision;
     }
-    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps, lane)));
+    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
     const nowMs = deps.now().getTime();
     const fallbackAnswerAt = new Date(nowMs).toISOString();
     const answerAtByLane = new Map();
@@ -2676,6 +2681,10 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
             if (!deps.dryRun)
                 writeAnsweredQuestions(hqRoot, current, questions);
             if (queueReason !== undefined) {
+                const answerEnv = deps.spawnLaneDeps?.env ?? deps.env ?? process.env;
+                const answerCaller = typeof answerEnv.HQ_LANE_ID === "string"
+                    ? answerEnv.HQ_LANE_ID.trim() || "user"
+                    : "user";
                 const queued = casLaneIf(hqRoot, current.lane_id, (latest) => latest.state === "awaiting_input", (latest) => ({
                     ...latest,
                     state: "queued",
@@ -2687,6 +2696,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
                             ? { session_id: latest.provider_session_id }
                             : {}),
                         trigger: "answered_questions",
+                        caller: answerCaller,
                         at: answeredAt,
                     },
                 }), deps.dryRun);

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

@@ -88,8 +88,6 @@ export interface SpawnLaneDeps {
     runCompaction?: RunCompactionFn;
     /** Finds a session transcript under an account home. Injected in tests. */
     locateTranscript?: (home: string, sessionId: string) => string | null;
-    /** Pre-read by the async command/reconcile boundary before this sync spawn. */
-    managerStatusGateEnabled?: boolean;
 }
 export interface ProviderLaunch {
     command: string;

package/dist/lib/lanes/spawn.js

@@ -354,12 +354,13 @@ function archivedResumeMessageText(hqRoot, laneId, messageId) {
 }
 function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
     const last = lane.last_resume;
+    const keepAlive = last?.keep_alive === true ? { keep_alive: true } : {};
     if (last === undefined || last.session_id !== sessionId) {
-        return { session_id: sessionId, trigger: "resume", resumed_from: "interrupted", at };
+        return { session_id: sessionId, trigger: "resume", resumed_from: "interrupted", at, ...keepAlive };
     }
     const compact = last.compact === undefined ? {} : { compact: last.compact };
     if (last.trigger === "answered_questions") {
-        return { session_id: sessionId, trigger: "answered_questions", at, ...compact };
+        return { session_id: sessionId, trigger: "answered_questions", at, ...compact, ...keepAlive };
     }
     if (last.trigger === "message") {
         if (last.message_id === undefined) {
@@ -376,6 +377,7 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
             message_id: last.message_id,
             at,
             ...compact,
+            ...keepAlive,
         };
     }
     return {
@@ -386,6 +388,7 @@ function pendingResumeForRetry(hqRoot, lane, sessionId, at) {
         ...(last.message_id !== undefined ? { message_id: last.message_id } : {}),
         at,
         ...compact,
+        ...keepAlive,
     };
 }
 /** Change account only after a provider/runtime account failure, then re-admit. */
@@ -1112,6 +1115,8 @@ export function envelopeRepairPrompt(input) {
             `Missing expected envelope file: ${input.envelopePath}`,
             "The previous envelope is stale and must not be reused or copied into this run's result.",
             "Printing an envelope in the conversation or writing it to last-message.txt is not enough; write the JSON object directly to the expected file.",
+            "If the task is unfinished, write decision: done, story_complete: false, and set story_status and story_complete_reason to describe the work that remains. The repair turn itself is never a reason for blocked.",
+            "This repair turn only writes the missing envelope; do not resume the task.",
             "Schema:",
             JSON.stringify(LANE_ENVELOPE_JSON_SCHEMA, null, 2),
             `Write the corrected JSON object to ${input.envelopePath}, overwriting it. ` +
@@ -2000,10 +2005,30 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // Claim running before spawning. Two callers that both observe queued must
     // not both start processes; the CAS loser returns without spawn.
     const nowIso = (deps.now ?? (() => new Date()))().toISOString();
-    const statusGateHeartbeat = deps.managerStatusGateEnabled === true
-        ? managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso)
-        : undefined;
+    const resumeHistoryTrigger = pendingResume?.keep_alive === true
+        ? "keep_alive"
+        : pendingResume?.trigger === "message" || trigger.kind === "message"
+            ? "message"
+            : pendingResume?.trigger === "resume" || trigger.kind === "resume"
+                ? "resume_cli"
+                : "reconcile";
+    const resumeHistoryCaller = pendingResume?.caller ||
+        (typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "") ||
+        (trigger.kind === "answered_questions" || trigger.kind === "resume" || trigger.kind === "message"
+            ? "user"
+            : undefined);
+    let statusGateHeartbeat;
+    try {
+        statusGateHeartbeat = managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso);
+    }
+    catch (err) {
+        const code = err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`hq lanes: manager status gate disabled for ${lane.lane_id}: ${code}: ${message}\n`);
+        statusGateHeartbeat = undefined;
+    }
     let claimed = false;
+    let priorStartRecorded = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
         if (current.state === "running" && current.account === resolved.id) {
@@ -2015,6 +2040,12 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         if (!claimableStatesFor(trigger, current).includes(current.state)) {
             throw new LanesError("spawn_state_mismatch", `Cannot mark ${current.lane_id} running from ${current.state}`, { lane_id: current.lane_id, state: current.state, trigger: trigger.kind });
         }
+        // The host report is written in the claim CAS before exec proves that a
+        // worker started. Use the prior spawn manifest's turn id (written only
+        // after detachment is proven), with last_resume for legacy manifests.
+        priorStartRecorded = previousSpawn.turn_id !== undefined ||
+            current.last_resume !== undefined ||
+            (current.resume_history?.length ?? 0) > 0;
         if (failedResumeClaim &&
             (failedResumeExpectedSenior === undefined ||
                 !sameSeniorRef(current.senior, failedResumeExpectedSenior))) {
@@ -2102,6 +2133,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 at: nowIso,
                 account: resolved.id,
                 trigger: pendingResume.trigger,
+                ...(pendingResume.keep_alive === true ? { keep_alive: true } : {}),
                 ...(pendingResume.message_id !== undefined ? { message_id: pendingResume.message_id } : {}),
                 ...(pendingResume.monitor_event === true ? { monitor_event: true } : {}),
                 ...(pendingResume.resumed_from !== undefined ? { resumed_from: pendingResume.resumed_from } : {}),
@@ -2247,6 +2279,16 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         throw err;
     }
+    if (priorStartRecorded) {
+        retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+            ...current,
+            resume_history: appendCappedHistory(current.resume_history ?? [], {
+                at: nowIso,
+                trigger: resumeHistoryTrigger,
+                ...(resumeHistoryCaller ? { caller: resumeHistoryCaller } : {}),
+            }),
+        }));
+    }
     return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
 /**
@@ -2550,6 +2592,16 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             killQuietly(killProcess, workerPid, "worker");
         throw err;
     }
+    const startedAt = (deps.now ?? (() => new Date()))().toISOString();
+    const callerLaneId = typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "";
+    retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+        ...current,
+        resume_history: appendCappedHistory(current.resume_history ?? [], {
+            at: startedAt,
+            trigger: "envelope_repair",
+            ...(callerLaneId ? { caller: callerLaneId } : {}),
+        }),
+    }));
     return workerPid;
 }
 export { PROVIDER_HOME_ENV, PROVIDER_COMMAND };

package/dist/lib/lanes/store.js

@@ -751,6 +751,55 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (isPlainObject(raw.pending_resume) &&
+        raw.pending_resume.caller !== undefined) {
+        requireString(raw.pending_resume.caller, "pending_resume.caller");
+    }
+    if (raw.keep_alive_history !== undefined) {
+        if (!Array.isArray(raw.keep_alive_history) || raw.keep_alive_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`keep_alive_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "keep_alive_history",
+            });
+        }
+        for (const [index, value] of raw.keep_alive_history.entries()) {
+            const field = `keep_alive_history[${index}]`;
+            if (!isPlainObject(value) ||
+                Object.keys(value).some((key) => !["at", "resumed_from", "account"].includes(key)) ||
+                (value.resumed_from !== "done" && value.resumed_from !== "interrupted" && value.resumed_from !== "blocked") ||
+                (value.account !== null && typeof value.account !== "string")) {
+                throw new LaneSchemaError(`${field} must be a keep-alive resume history entry`, {
+                    path: filePath,
+                    field,
+                    value,
+                });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+        }
+    }
+    if (raw.resume_history !== undefined) {
+        if (!Array.isArray(raw.resume_history) || raw.resume_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`resume_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "resume_history",
+            });
+        }
+        for (const [index, value] of raw.resume_history.entries()) {
+            const field = `resume_history[${index}]`;
+            if (!isPlainObject(value) ||
+                Object.keys(value).some((key) => !["at", "trigger", "caller"].includes(key))) {
+                throw new LaneSchemaError(`${field} must be a resume history entry`, {
+                    path: filePath,
+                    field,
+                    value,
+                });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+            requireString(value.trigger, `${field}.trigger`);
+            if (value.caller !== undefined)
+                requireString(value.caller, `${field}.caller`);
+        }
+    }
     if (raw.stop_history !== undefined) {
         if (!Array.isArray(raw.stop_history)) {
             throw new LaneSchemaError("stop_history must be an array when present", {
@@ -1141,6 +1190,11 @@ export function mergeLaneRecords(live, sidecars) {
                 failed_resume_history: unionHistory(all.map((record) => record.failed_resume_history ?? []), entryIdentity, base.failed_resume_history ?? []),
             }
             : {}),
+        ...(all.some((record) => record.resume_history !== undefined)
+            ? {
+                resume_history: unionHistory(all.map((record) => record.resume_history ?? []), entryIdentity, base.resume_history ?? []),
+            }
+            : {}),
         ...(all.some((record) => record.settings_history !== undefined)
             ? {
                 settings_history: unionHistory(all.map((record) => record.settings_history ?? []), entryIdentity, base.settings_history ?? []),

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

@@ -1,4 +1,4 @@
-import type { LaneRecord, LaneStory } from "./types.js";
+import type { LaneRecord, LaneStory, LaneStoryStatus } from "./types.js";
 /** Board-facing states for the stories a lane currently carries. */
 export declare const ACTIVE_LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review"];
 export declare function storyKey(projectId: string, storyId: string): string;
@@ -14,4 +14,10 @@ export declare function storyWarning(lane: LaneRecord): string | undefined;
 export declare function withCurrentStory(lane: LaneRecord, projectId: string, storyId: string): LaneRecord;
 export declare function withLaneStories(lane: LaneRecord, stories: LaneStory[]): LaneRecord;
 export declare function storyStatusForEnvelope(status: string): "in_progress" | "review";
+/**
+ * Resolve the story status requested by a terminal envelope. Already-final
+ * carried stories are immutable through the envelope path; senior verification
+ * and explicit story commands own those transitions.
+ */
+export declare function terminalEnvelopeStoryStatus(lane: LaneRecord, decision: "done" | "blocked" | "ask", envelopeStatus?: string): LaneStoryStatus | undefined;
 //# sourceMappingURL=stories.d.ts.map

package/dist/lib/lanes/stories.js

@@ -73,4 +73,20 @@ export function storyStatusForEnvelope(status) {
         return "review";
     return "in_progress";
 }
+/**
+ * Resolve the story status requested by a terminal envelope. Already-final
+ * carried stories are immutable through the envelope path; senior verification
+ * and explicit story commands own those transitions.
+ */
+export function terminalEnvelopeStoryStatus(lane, decision, envelopeStatus = "in_progress") {
+    const primary = laneStory(lane, lane.project_id, lane.story_id);
+    if (primary && (String(primary.status) === "done" || String(primary.status) === "dropped")) {
+        return undefined;
+    }
+    if (decision === "blocked")
+        return "blocked";
+    if (decision === "done")
+        return "review";
+    return storyStatusForEnvelope(envelopeStatus);
+}
 //# sourceMappingURL=stories.js.map

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

@@ -407,6 +407,19 @@ export interface KeepAliveBlockedHistoryEntry {
     resume_skipped_reason?: "open_question" | "blocked_grace";
     resume_queued?: boolean;
 }
+export interface KeepAliveResumeHistoryEntry {
+    at: string;
+    resumed_from: "done" | "interrupted" | "blocked";
+    account: string | null;
+}
+/** Bounded audit entry for every lane worker start after its first start. */
+export interface LaneResumeHistoryEntry {
+    at: string;
+    /** Stable trigger class; path-specific starts may use their path name. */
+    trigger: string;
+    /** HQ lane id for an agent caller, or `user` for an explicit human CLI action. */
+    caller?: string;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -418,7 +431,13 @@ export interface KrFreshnessHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
-export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry | KeepAliveBlockedHistoryEntry;
+export interface EnvelopeRepairContinueHistoryEntry {
+    event: "envelope_repair_continued";
+    at: string;
+    envelope_ref: string;
+    session_id: string;
+}
+export type LaneGateHistoryEntry = ManagerStatusGateHistoryEntry | BlockerFreshnessHistoryEntry | KrFreshnessHistoryEntry | EnvelopeRepairContinueHistoryEntry | KeepAliveBlockedHistoryEntry;
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -491,6 +510,8 @@ export interface LaneRecord {
     keep_alive_blocked_reason?: "not_opted_in" | "missing_opt_in_time" | "envelope_before_opt_in" | "interruption_before_opt_in" | "missing_interruption_time" | "retired" | "superseded" | "retired_list_invalid" | "terminal_state";
     /** Consecutive automatic keep-alive resumes since the last human reset. */
     keep_alive_resume_count?: number;
+    /** Bounded audit trail of automatic keep-alive resumes; human resets never clear it. */
+    keep_alive_history?: KeepAliveResumeHistoryEntry[];
     /** Blocked keep-alive resumes in the current blocked episode. */
     keep_alive_blocked_resume_streak?: number;
     /** Time the most recent automatic keep-alive resume was queued. */
@@ -646,6 +667,8 @@ export interface LaneRecord {
     provider_home_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
+    /** Last 50 lane worker starts after the initial start, including actor provenance. */
+    resume_history?: LaneResumeHistoryEntry[];
     /** Cache counters from the last exited run's result. Nothing else from the payload. */
     last_run_usage?: LaneRunUsage;
     /** Completion time paired with last_run_usage; written by the watcher. */
@@ -700,6 +723,8 @@ export interface PendingResume {
     /** Fresh answered-question launches need no previous session id. */
     session_id?: string;
     trigger: "answered_questions" | "message" | "resume";
+    /** True when this queued resume was initiated automatically by keep-alive. */
+    keep_alive?: true;
     resumed_from?: "interrupted" | "done" | "blocked" | "failed";
     from_failed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
@@ -708,6 +733,8 @@ export interface PendingResume {
     message_id?: string;
     /** The text is already framed as untrusted monitor data, not an operator instruction. */
     monitor_event?: true;
+    /** Caller identity captured when a deferred start was requested, when known. */
+    caller?: string;
     /** False when the command passed --no-compact; the deferred spawn honours it. */
     compact?: boolean;
     at: string;
@@ -727,6 +754,8 @@ export interface LaneResumeRecord {
     /** Account the resumed run was bound to. */
     account?: string;
     trigger: "answered_questions" | "message" | "resume";
+    /** True when this was an automatic keep-alive resume. */
+    keep_alive?: true;
     message_id?: string;
     monitor_event?: true;
     /**

package/dist/lib/lanes/types.js

@@ -225,7 +225,7 @@ export const LANE_FIELD_WRITERS = {
     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"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
+    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"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["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"],
     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"],
@@ -233,7 +233,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

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

@@ -41,6 +41,7 @@ import { type EnvelopeRepairSpawnInput, type SpawnLaneDeps } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export declare const SILENCE_MS: number;
 export declare const WATCHER_POLL_MS = 5000;
+export declare const ENVELOPE_REPAIR_CONTINUE_TEXT = "continue the task; the previous turn ended without an envelope.";
 /** Synced last_host_report_at cadence. Reconcile dead-host TTL is 20 minutes. */
 export declare const WATCHER_HEARTBEAT_MS: number;
 /**
@@ -49,7 +50,7 @@ export declare const WATCHER_HEARTBEAT_MS: number;
  * once the file would exceed this, the oldest complete lines are dropped.
  */
 export declare const WATCHER_OUT_MAX_BYTES: number;
-export declare const WATCHER_DECISION_EVENTS: readonly ["liveness_transition", "silence_deadline", "envelope_observed", "envelope_invalid", "envelope_repair", "classification", "terminal_write", "message_recovery", "message_recovery_failed", "message_undeliverable", "mesh_event", "mesh_event_failed"];
+export declare const WATCHER_DECISION_EVENTS: readonly ["liveness_transition", "silence_deadline", "envelope_observed", "envelope_invalid", "envelope_repair", "envelope_repair_continue", "classification", "terminal_write", "message_recovery", "message_recovery_failed", "message_undeliverable", "mesh_event", "mesh_event_failed"];
 /** Terminal reason when the envelope failed to parse after the repair turn (spec §4). */
 export { ENVELOPE_INVALID_REASON };
 export type WatcherDecisionEvent = (typeof WATCHER_DECISION_EVENTS)[number];
@@ -232,11 +233,11 @@ export interface WatcherLoopDeps {
     /** Deliver a lane-senior escalation through the normal lane-message router. */
     deliverLaneSeniorMessage?: (seniorLaneId: string, text: string) => Promise<void>;
     /** Test seam; production reads the company-scoped hq-flags row. */
-    readManagerStatusGateFlag?: typeof readLanesRegistryFlag;
-    /** Test seam; production reads the company-scoped hq-flags row. */
     readBlockerFreshnessFlag?: typeof readLanesRegistryFlag;
     /** Test seam; production reads the company-scoped hq-flags row. */
     readKrFreshnessFlag?: typeof readLanesRegistryFlag;
+    /** Test seam; production reads the company-scoped hq-flags row. */
+    readEnvelopeRepairContinueFlag?: typeof readLanesRegistryFlag;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with