@indigoai-us/hq-cli 5.214.0 → 5.216.0

package/dist/lib/lanes/mesh-events.js

@@ -229,6 +229,17 @@ function isUnknownProjectStory(error) {
         typeof candidate.message === "string" &&
         candidate.message.includes("Unknown story"));
 }
+function isUncodedStoryPatchNotFound(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    // The story-absent route response is exactly `404 Not found` without a code.
+    // Keep coded 404s, especially PROJECT_VIEW_NOT_FOUND, on their own paths.
+    return (candidate.status === 404 &&
+        candidate.code === undefined &&
+        typeof candidate.message === "string" &&
+        /^404 not found$/i.test(candidate.message));
+}
 function shellQuote(value) {
     return "'" + value.replace(/'/g, "'\\''") + "'";
 }
@@ -245,6 +256,9 @@ export function storyNotOnBoardError(company, projectId, storyId) {
         command,
     });
 }
+export function laneStoryStatusSuppressionKey(company, projectId, storyId) {
+    return JSON.stringify([company.uid, projectId, storyId]);
+}
 function isAlreadyRegistered(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -365,7 +379,7 @@ export function createLaneMesh(opts = {}) {
                     await patchStoryStatus(tok, company.uid, projectId, storyId, status);
                 }
                 catch (error) {
-                    if (isUnknownProjectStory(error)) {
+                    if (isUnknownProjectStory(error) || isUncodedStoryPatchNotFound(error)) {
                         throw storyNotOnBoardError(company, projectId, storyId);
                     }
                     throw error;
@@ -437,6 +451,21 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
     const threadId = await ensureLaneEventThread(mesh, company, lane, lane.state, opts.signal);
     if (!company || !threadId)
         return;
+    const patchStoryStatus = async (status) => {
+        const suppressions = opts.storyStatusSuppressions;
+        const key = laneStoryStatusSuppressionKey(company, lane.project_id, lane.story_id);
+        if (suppressions?.has(key))
+            return;
+        try {
+            await mesh.patchStoryStatus(company, lane.project_id, lane.story_id, status);
+        }
+        catch (err) {
+            if (suppressions && err instanceof LanesError && err.error === "story_not_on_board") {
+                suppressions.add(key);
+            }
+            throw err;
+        }
+    };
     switch (envelope.decision) {
         case "done": {
             const outcomes = await Promise.allSettled([
@@ -444,7 +473,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
                     ...laneMeshEventIdentity(lane),
                     summary: envelope.summary,
                 }, opts.signal),
-                mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "review"),
+                patchStoryStatus("review"),
             ]);
             const failure = outcomes.find((outcome) => outcome.status === "rejected");
             if (failure?.status === "rejected")
@@ -458,7 +487,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
                         ...laneMeshEventIdentity(lane),
                         blocked_reason: envelope.blocked_reason ?? "",
                     }),
-                    mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "in_progress"),
+                    patchStoryStatus("in_progress"),
                 ]);
                 const failure = outcomes.find((outcome) => outcome.status === "rejected");
                 if (failure?.status === "rejected")

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

@@ -33,16 +33,20 @@ export interface WorkerProfileRuntime {
     settingsPath?: string;
     hooksDir?: string;
 }
+export interface LoadWorkerProfileOptions {
+    /** Unknown keys may be ignored only by callers with an explicit recovery path. */
+    onUnknownMetaFields?: (fields: readonly string[]) => void;
+}
 export declare function personalWorkerProfileDir(hqRoot: string, id: string): string;
 /** A meta.yaml file is the explicit marker for a personal worker profile. */
 export declare function workerProfileMarker(hqRoot: string, id: string): "absent" | "present";
-export declare function loadWorkerProfile(hqRoot: string, id: string): WorkerProfile;
+export declare function loadWorkerProfile(hqRoot: string, id: string, options?: LoadWorkerProfileOptions): WorkerProfile;
 export interface EffectiveLaneKeepAlive {
     enabled: boolean;
-    source: "lane" | "profile" | "none";
+    source: "lane" | "none";
 }
-/** Resolve the keep-alive opt-in recorded on a lane or its attached profile. */
-export declare function resolveLaneKeepAlive(hqRoot: string, lane: Pick<LaneRecord, "keep_alive" | "worker_profile">): EffectiveLaneKeepAlive;
+/** Resolve keep-alive from the lane record; profile metadata only seeds new spawns. */
+export declare function resolveLaneKeepAlive(_hqRoot: string, lane: Pick<LaneRecord, "keep_alive">): EffectiveLaneKeepAlive;
 export declare function workerProfilePrompt(profile: WorkerProfile, delivery?: "hook" | "prompt"): string;
 export declare function ignoredWorkerProfileFields(provider: LaneProvider): string[];
 /**

package/dist/lib/lanes/profile.js

@@ -117,15 +117,18 @@ function collectFiles(id, dir, relativeDir) {
     visit(absoluteDir, relativeDir);
     return files.sort((a, b) => a.localeCompare(b));
 }
-function parseMeta(id, dir, raw) {
+function parseMeta(id, dir, raw, options = {}) {
     if (!isPlainObject(raw)) {
         throw profileError(id, dir, "meta.yaml must contain an object");
     }
     const unknown = Object.keys(raw).filter((key) => !PROFILE_META_KEYS.has(key));
     if (unknown.length > 0) {
-        throw profileError(id, dir, `meta.yaml has unknown field(s): ${unknown.join(", ")}`, {
-            fields: unknown,
-        });
+        if (options.onUnknownMetaFields === undefined) {
+            throw profileError(id, dir, `meta.yaml has unknown field(s): ${unknown.join(", ")}`, {
+                fields: unknown,
+            });
+        }
+        options.onUnknownMetaFields(unknown);
     }
     const provider = raw.provider;
     if (typeof provider !== "string" || !isLaneProvider(provider.trim())) {
@@ -305,7 +308,7 @@ export function workerProfileMarker(hqRoot, id) {
         return "present";
     return "present";
 }
-export function loadWorkerProfile(hqRoot, id) {
+export function loadWorkerProfile(hqRoot, id, options = {}) {
     const dir = personalWorkerProfileDir(hqRoot, id);
     if (!validProfileId(id)) {
         throw profileError(id, dir, "profile id must be a simple directory name", {
@@ -338,7 +341,7 @@ export function loadWorkerProfile(hqRoot, id) {
             field: PROFILE_META,
         });
     }
-    const meta = parseMeta(id, dir, metaRaw);
+    const meta = parseMeta(id, dir, metaRaw, options);
     const systemPromptPath = path.join(dir, PROFILE_SYSTEM_PROMPT);
     const systemPrompt = readRequiredText(id, dir, systemPromptPath, PROFILE_SYSTEM_PROMPT);
     if (systemPrompt.trim().length === 0) {
@@ -370,18 +373,11 @@ export function loadWorkerProfile(hqRoot, id) {
         contentHash: hashProfileFiles(dir, hashFiles),
     };
 }
-/** Resolve the keep-alive opt-in recorded on a lane or its attached profile. */
-export function resolveLaneKeepAlive(hqRoot, lane) {
-    if (lane.keep_alive !== undefined) {
-        return { enabled: lane.keep_alive, source: "lane" };
-    }
-    if (lane.worker_profile === undefined) {
-        return { enabled: false, source: "none" };
-    }
-    const profileKeepAlive = loadWorkerProfile(hqRoot, lane.worker_profile).meta.keep_alive;
-    return profileKeepAlive === undefined
+/** Resolve keep-alive from the lane record; profile metadata only seeds new spawns. */
+export function resolveLaneKeepAlive(_hqRoot, lane) {
+    return lane.keep_alive === undefined
         ? { enabled: false, source: "none" }
-        : { enabled: profileKeepAlive, source: "profile" };
+        : { enabled: lane.keep_alive, source: "lane" };
 }
 export function workerProfilePrompt(profile, delivery = "prompt") {
     const parts = [profile.systemPrompt.trimEnd()];

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

@@ -71,5 +71,5 @@ export declare function envelopeQuestionId(laneId: string, envelopeRef: string,
  * Spec §6.1: each envelope questions[] entry becomes one queue record, via
  * raiseLaneQuestion (the same function the CLI ask path uses).
  */
-export declare function raiseEnvelopeQuestions(hqRoot: string, lane: LaneRecord, envelope: LaneEnvelope, envelopeRef: string, at: string): QuestionRecord[];
+export declare function raiseEnvelopeQuestions(hqRoot: string, lane: LaneRecord, envelope: LaneEnvelope, envelopeRef: string, at: string, questionIndexes?: readonly number[]): QuestionRecord[];
 //# sourceMappingURL=questions.d.ts.map

package/dist/lib/lanes/questions.js

@@ -222,7 +222,7 @@ function envelopeQuestionBody(item) {
  * Spec §6.1: each envelope questions[] entry becomes one queue record, via
  * raiseLaneQuestion (the same function the CLI ask path uses).
  */
-export function raiseEnvelopeQuestions(hqRoot, lane, envelope, envelopeRef, at) {
+export function raiseEnvelopeQuestions(hqRoot, lane, envelope, envelopeRef, at, questionIndexes) {
     const items = envelope.questions ?? [];
     const raised = [];
     for (let i = 0; i < items.length; i += 1) {
@@ -235,7 +235,7 @@ export function raiseEnvelopeQuestions(hqRoot, lane, envelope, envelopeRef, at)
             body: envelopeQuestionBody(item),
             raisedVia: "envelope",
             at,
-            questionId: envelopeQuestionId(lane.lane_id, envelopeRef, i),
+            questionId: envelopeQuestionId(lane.lane_id, envelopeRef, questionIndexes?.[i] ?? i),
         }));
     }
     return raised;

package/dist/lib/lanes/reconcile.js

@@ -14,14 +14,14 @@ import { effectiveAccountHome } from "./account-home.js";
 import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
+import { loadWorkerProfile } from "./profile.js";
 import { LANE_HIRE_GRANTS_FLAG, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
-import { loadWorkerProfile, resolveLaneKeepAlive } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, leadLaneKeepAliveBackoffMs, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
@@ -800,18 +800,19 @@ export async function runPassBody(hqRoot, deps) {
     const keepAliveFlagCompanies = new Map();
     const keepAliveHireGrantFlagCompanies = new Map();
     for (const lane of lanes) {
-        if (lane.state !== "done" ||
-            (lane.keep_alive !== true &&
-                !(lane.keep_alive === undefined && lane.worker_profile !== undefined)) ||
+        if (!(lane.state === "done" || lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") ||
+            (lane.keep_alive !== true && lane.worker_profile === undefined) ||
             !laneRunsHere(lane, deps.host) ||
-            lane.terminal_reason === PROVIDER_REJECTED_REASON ||
-            lane.terminal_reason === "account_not_logged_in" ||
-            !providerSupportsSessionResume(lane.provider) ||
-            !(lane.provider_session_id ?? lane.last_resume?.session_id))
-            continue;
-        const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-        if (!envelope || envelope.decision !== "done" || envelope.story_complete === true)
+            (lane.state === "done" && (lane.terminal_reason === PROVIDER_REJECTED_REASON ||
+                lane.terminal_reason === "account_not_logged_in" ||
+                !providerSupportsSessionResume(lane.provider) ||
+                !(lane.provider_session_id ?? lane.last_resume?.session_id))))
             continue;
+        if (lane.state === "done") {
+            const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
+            if (!envelope || envelope.decision !== "done" || envelope.story_complete === true)
+                continue;
+        }
         const key = keepAliveCompanyKey(lane.company);
         keepAliveFlagCompanies.set(key, lane.company);
         if (lane.senior.kind === "lane" && lane.senior.id) {
@@ -1413,80 +1414,164 @@ function recordKeepAliveEvent(hqRoot, laneId, summary, event) {
         });
     }
 }
+function recordKeepAliveSkip(hqRoot, lane, reason, summary, deps, detail) {
+    summary.skipped.push({
+        kind: "lane",
+        id: lane.lane_id,
+        why: `keep_alive_${reason}${detail ? `: ${detail}` : ""}`,
+    });
+    if (deps.dryRun || lane.keep_alive_blocked_reason === reason)
+        return;
+    try {
+        casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version && current.state === lane.state, (current) => ({ ...current, keep_alive_blocked_reason: reason }), false);
+    }
+    catch (err) {
+        markDirty(summary, {
+            kind: "lane",
+            id: lane.lane_id,
+            why: `keep-alive skip state write failed: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
+    const filePath = path.join(laneRunDir(hqRoot, lane.lane_id), ref);
+    try {
+        return fs.statSync(filePath).mtimeMs;
+    }
+    catch (err) {
+        throw new LanesError("keep_alive_envelope_timestamp_unavailable", `Cannot stat latest envelope for lane ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id, path: filePath });
+    }
+}
 function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, hireGrantFlagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
+    const keepAliveEnabled = [...flagByCompany.values()].some((enabled) => enabled);
+    let retiredLaneIds = null;
+    if (keepAliveEnabled) {
+        try {
+            retiredLaneIds = loadRetiredLaneIds(hqRoot);
+        }
+        catch (err) {
+            markError(summary, err);
+        }
+    }
     for (const lane of lanes) {
-        const hasRecordedProfileFallback = lane.keep_alive === undefined && lane.worker_profile !== undefined;
+        if (!laneRunsHere(lane, deps.host))
+            continue;
+        if (lane.state === "killed" || lane.state === "cancelled" || lane.state === "failed") {
+            if (lane.keep_alive === true &&
+                flagByCompany.get(keepAliveCompanyKey(lane.company)) === true)
+                recordKeepAliveSkip(hqRoot, lane, "terminal_state", summary, deps);
+            continue;
+        }
         if (lane.state !== "done" ||
-            lane.keep_alive === false ||
-            (lane.keep_alive !== true && !hasRecordedProfileFallback) ||
-            !laneRunsHere(lane, deps.host))
+            (lane.keep_alive !== true && lane.worker_profile === undefined))
             continue;
         const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
         const envelope = latest?.envelope;
         if (!envelope || envelope.decision !== "done")
             continue;
-        const keepAliveConfigurationUnchanged = (candidate) => lane.keep_alive === true
-            ? candidate.keep_alive === true
-            : lane.keep_alive === undefined &&
-                lane.worker_profile !== undefined &&
-                candidate.keep_alive === undefined &&
-                candidate.worker_profile === lane.worker_profile;
         if (envelope.story_complete === true) {
             if (hasKeepAliveProgress(lane)) {
                 casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
                     current.state === "done" &&
-                    keepAliveConfigurationUnchanged(current), (current) => clearedKeepAliveProgress(current), deps.dryRun);
+                    current.keep_alive === lane.keep_alive, (current) => ({ ...clearedKeepAliveProgress(current), keep_alive_blocked_reason: undefined }), deps.dryRun);
             }
             continue;
         }
+        if (flagByCompany.get(keepAliveCompanyKey(lane.company)) !== true)
+            continue;
         if (lane.terminal_reason === PROVIDER_REJECTED_REASON ||
-            lane.terminal_reason === "account_not_logged_in" ||
-            !providerSupportsSessionResume(lane.provider) ||
-            !(lane.provider_session_id ?? lane.last_resume?.session_id))
+            lane.terminal_reason === "account_not_logged_in") {
+            recordKeepAliveSkip(hqRoot, lane, "terminal_state", summary, deps, lane.terminal_reason);
             continue;
-        if (flagByCompany.get(keepAliveCompanyKey(lane.company)) !== true)
+        }
+        if (lane.keep_alive !== true) {
+            recordKeepAliveSkip(hqRoot, lane, "not_opted_in", summary, deps);
             continue;
-        let keepAlive;
+        }
+        const optedInAtMs = Date.parse(lane.keep_alive_opted_in_at ?? "");
+        if (!Number.isFinite(optedInAtMs)) {
+            recordKeepAliveSkip(hqRoot, lane, "missing_opt_in_time", summary, deps);
+            continue;
+        }
+        let envelopeAtMs;
         try {
-            keepAlive = resolveLaneKeepAlive(hqRoot, lane);
+            envelopeAtMs = latestEnvelopeMtimeMs(hqRoot, lane, latest.ref);
         }
         catch (err) {
-            const message = err instanceof LanesError
-                ? `${err.error}: ${err.message}`
-                : err instanceof Error ? err.message : String(err);
             markDirty(summary, {
                 kind: "lane",
                 id: lane.lane_id,
-                why: `keep-alive worker profile could not be loaded: ${message}`,
+                why: `keep-alive envelope timestamp unavailable: ${err instanceof Error ? err.message : String(err)}`,
             });
             continue;
         }
-        if (!keepAlive.enabled)
+        if (envelopeAtMs <= optedInAtMs) {
+            recordKeepAliveSkip(hqRoot, lane, "envelope_before_opt_in", summary, deps);
+            continue;
+        }
+        if (retiredLaneIds === null) {
+            recordKeepAliveSkip(hqRoot, lane, "retired_list_invalid", summary, deps);
+            continue;
+        }
+        const exclusion = keepAliveExclusion(lane, lanes, retiredLaneIds);
+        if (exclusion !== undefined) {
+            recordKeepAliveSkip(hqRoot, lane, exclusion, summary, deps);
+            continue;
+        }
+        if (!providerSupportsSessionResume(lane.provider) ||
+            !(lane.provider_session_id ?? lane.last_resume?.session_id))
             continue;
-        const keepAliveStillEnabled = (candidate) => keepAlive.source === "lane"
-            ? candidate.keep_alive === true
-            : candidate.keep_alive === undefined &&
-                candidate.worker_profile === lane.worker_profile;
+        const keepAliveStillEnabled = (candidate) => candidate.keep_alive === true &&
+            candidate.keep_alive_opted_in_at === lane.keep_alive_opted_in_at;
         const current = readLane(hqRoot, lane.lane_id);
         if (current.version !== lane.version ||
             current.state !== "done" ||
             !keepAliveStillEnabled(current) ||
             !laneRunsHere(current, deps.host))
             continue;
-        const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id)?.envelope;
+        const currentEnvelopeRecord = readLatestEnvelopeRecord(hqRoot, current.lane_id);
+        const currentEnvelope = currentEnvelopeRecord?.envelope;
         if (!currentEnvelope || currentEnvelope.decision !== "done")
             continue;
         if (currentEnvelope.story_complete === true) {
             if (hasKeepAliveProgress(current)) {
                 casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                     latestLane.state === "done" &&
-                    keepAliveStillEnabled(latestLane), (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+                    keepAliveStillEnabled(latestLane), (latestLane) => ({ ...clearedKeepAliveProgress(latestLane), keep_alive_blocked_reason: undefined }), deps.dryRun);
             }
             continue;
         }
+        if (currentEnvelopeRecord !== null) {
+            let currentEnvelopeAtMs;
+            try {
+                currentEnvelopeAtMs = latestEnvelopeMtimeMs(hqRoot, current, currentEnvelopeRecord.ref);
+            }
+            catch (err) {
+                markDirty(summary, {
+                    kind: "lane",
+                    id: current.lane_id,
+                    why: `keep-alive envelope timestamp unavailable: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                continue;
+            }
+            if (currentEnvelopeAtMs <= Date.parse(current.keep_alive_opted_in_at ?? "")) {
+                recordKeepAliveSkip(hqRoot, current, "envelope_before_opt_in", summary, deps);
+                continue;
+            }
+        }
+        if (retiredLaneIds === null) {
+            recordKeepAliveSkip(hqRoot, current, "retired_list_invalid", summary, deps);
+            continue;
+        }
+        const currentLanes = loadLaneRecords(hqRoot, summary);
+        const currentExclusion = keepAliveExclusion(current, currentLanes, retiredLaneIds);
+        if (currentExclusion !== undefined) {
+            recordKeepAliveSkip(hqRoot, current, currentExclusion, summary, deps);
+            continue;
+        }
         const providerSessionId = current.provider_session_id ?? current.last_resume?.session_id;
         if (current.terminal_reason === PROVIDER_REJECTED_REASON ||
             current.terminal_reason === "account_not_logged_in" ||
@@ -1567,6 +1652,7 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
             keep_alive_last_resume_at: nowIso,
             keep_alive_next_eligible_at: nextEligibleAt,
             keep_alive_exhausted_at: undefined,
+            keep_alive_blocked_reason: undefined,
         }), deps.dryRun);
         const seniorId = current.senior.kind === "lane" ? current.senior.id : undefined;
         let queued;

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

@@ -305,6 +305,8 @@ export interface EnvelopeRepairSpawnInput {
     rawText: string;
     /** True when this run never wrote its expected envelope file. */
     missing?: boolean;
+    /** Repair-only warning hook for profile metadata ignored during recovery. */
+    onProfileWarning?: (fields: readonly string[]) => void;
 }
 /** How the spec §4 repair turn reaches the provider (recorded as `envelope_repair.mode`). */
 export type EnvelopeRepairMode = "resume" | "fresh_turn";

package/dist/lib/lanes/spawn.js

@@ -2152,7 +2152,12 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     ensureDir(logsDir);
     const config = loadLanesConfig(hqRoot);
     const profile = lane.worker_profile
-        ? loadWorkerProfile(hqRoot, lane.worker_profile)
+        ? loadWorkerProfile(hqRoot, lane.worker_profile, {
+            onUnknownMetaFields: (fields) => {
+                process.stderr.write(`hq lanes watcher: envelope repair ignored unknown worker profile meta field(s) for ${lane.worker_profile}: ${fields.join(", ")}\n`);
+                input.onProfileWarning?.(fields);
+            },
+        })
         : undefined;
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
     const profileModel = profileDefaultsApply ? profile.meta.model : undefined;

package/dist/lib/lanes/store.js

@@ -409,6 +409,25 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.keep_alive,
         });
     }
+    const keepAliveBlockedReason = raw.keep_alive_blocked_reason;
+    const validKeepAliveBlockedReasons = [
+        "not_opted_in",
+        "missing_opt_in_time",
+        "envelope_before_opt_in",
+        "retired",
+        "superseded",
+        "retired_list_invalid",
+        "terminal_state",
+    ];
+    if (keepAliveBlockedReason !== undefined &&
+        (typeof keepAliveBlockedReason !== "string" ||
+            !validKeepAliveBlockedReasons.includes(keepAliveBlockedReason))) {
+        throw new LaneSchemaError("keep_alive_blocked_reason is invalid", {
+            path: filePath,
+            field: "keep_alive_blocked_reason",
+            value: keepAliveBlockedReason,
+        });
+    }
     if (raw.keep_alive_resume_count !== undefined &&
         (typeof raw.keep_alive_resume_count !== "number" ||
             !Number.isSafeInteger(raw.keep_alive_resume_count) ||
@@ -420,6 +439,7 @@ export function parseLaneRecord(raw, filePath) {
         });
     }
     for (const field of [
+        "keep_alive_opted_in_at",
         "keep_alive_last_resume_at",
         "keep_alive_next_eligible_at",
         "keep_alive_exhausted_at",
@@ -450,6 +470,11 @@ export function parseLaneRecord(raw, filePath) {
         new Set(raw.pending_question_ids).size !== raw.pending_question_ids.length)) {
         throw new LaneSchemaError("pending_question_ids must be an array of unique non-empty ids", { path: filePath, field: "pending_question_ids" });
     }
+    if (raw.envelope_validation_errors !== undefined && (!Array.isArray(raw.envelope_validation_errors) ||
+        raw.envelope_validation_errors.length === 0 ||
+        raw.envelope_validation_errors.some((error) => typeof error !== "string" || error.trim() === ""))) {
+        throw new LaneSchemaError("envelope_validation_errors must be a non-empty array of non-empty strings", { path: filePath, field: "envelope_validation_errors" });
+    }
     requireTimestamp(raw.created_at, "created_at", filePath);
     requireTimestamp(raw.updated_at, "updated_at", filePath);
     if (raw.queued_reason !== undefined && !isQueuedReason(raw.queued_reason)) {

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

@@ -356,6 +356,10 @@ export interface LaneRecord {
     worker_profile?: string;
     /** Whether this lead lane should resume completed turns while its story is open. */
     keep_alive?: boolean;
+    /** 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. */
+    keep_alive_blocked_reason?: "not_opted_in" | "missing_opt_in_time" | "envelope_before_opt_in" | "retired" | "superseded" | "retired_list_invalid" | "terminal_state";
     /** Consecutive automatic keep-alive resumes since the last human reset. */
     keep_alive_resume_count?: number;
     /** Time the most recent automatic keep-alive resume was queued. */
@@ -428,6 +432,8 @@ export interface LaneRecord {
     story_complete_reason?: string;
     /** Copied from the last ingested envelope when present. */
     story_status?: StoryStatus;
+    /** Envelope parser failures retained when a usable ask is recovered. */
+    envelope_validation_errors?: string[];
     /** Set by the reconcile pass when `--timeout` has passed (spec §5.7). */
     overdue?: boolean;
     overdue_at?: string;

package/dist/lib/lanes/types.js

@@ -224,7 +224,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"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    keep_alive: ["creator", "command"], keep_alive_resume_count: ["command", "reconcile"], 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_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], 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"], 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"], 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"],
@@ -232,7 +232,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"], 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"], envelope_repair: ["watcher", "reconcile"], 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"], last_run_usage: ["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

@@ -143,6 +143,8 @@ export declare function notifySlotFreed(_input: {
 export interface ApplyTerminalOpts {
     envelope?: LaneEnvelope | null;
     envelopeRef?: string;
+    envelopeValidationErrors?: string[];
+    questionIndexes?: readonly number[];
     at?: string;
     quota?: QuotaSignal | null;
     /** Written to `terminal_details` with the model and account the run used. */
@@ -225,7 +227,7 @@ export interface WatcherLoopDeps {
  */
 export declare function emitMeshSoft(event: string, logDecision: (record: Record<string, unknown>) => void, at: string, fn: (signal: AbortSignal) => Promise<void>, timeoutMs?: number): Promise<boolean>;
 /** Question ids an ask envelope raised, as `raiseEnvelopeQuestions` mints them. */
-export declare function envelopeQuestionIds(laneId: string, envelopeRef: string, envelope: LaneEnvelope): string[];
+export declare function envelopeQuestionIds(laneId: string, envelopeRef: string, envelope: LaneEnvelope, questionIndexes?: readonly number[]): string[];
 export declare function runWatcherLoop(hqRoot: string, laneId: string, deps?: WatcherLoopDeps): Promise<void>;
 export type EnvelopeRepairDecision = {
     action: "spawned";