@indigoai-us/hq-cli 5.215.0 → 5.216.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [5.216.0] — 2026-09-26
+
+### Fixed
+
+- Lane watchers keep valid questions from a malformed `ask` envelope when
+  repair is skipped, cannot start, or still produces invalid output. The lane
+  stores the validation errors, and recovered question context includes them.
+  Repair spawns ignore unknown profile metadata and log the field names.
+  `hq lanes create` and `hq lanes resume --worker` keep strict validation.
+
+- `hq lanes` stops sending status updates for stories missing from the project
+  board. The watcher reports the refusal once per lane run and keeps appending
+  lane events.
+
 ## [5.215.0] — 2026-09-26
 
 ### Fixed
@@ -9,6 +23,7 @@
 - hq-cli 5.211.0 could resume a retired lead from its worker profile's
   `keep_alive` value. Reconcile now requires an explicit lane opt-in written
   after the latest envelope, and skips retired or superseded leads.
+
 ## [5.214.0] — 2026-09-26
 
 ### Added

package/dist/commands/lanes.js

@@ -36,7 +36,7 @@ import { CompanySelectionError } from "../utils/company-selection-error.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { keepAliveExclusion, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
@@ -897,41 +897,6 @@ async function withResumeHireAdmission(ctx, lane, fn) {
         return fn();
     });
 }
-function hireGrantCapacityError(parent, children) {
-    const grant = parent.hire_grant ?? 0;
-    const grantor = (parent.senior.kind === "lane" || parent.senior.kind === "session") &&
-        parent.senior.id
-        ? { kind: parent.senior.kind, id: parent.senior.id }
-        : null;
-    const grantorReason = grantor
-        ? undefined
-        : parent.senior.kind === "user"
-            ? "senior_is_user"
-            : "parent_senior_missing_id";
-    const capacity = children.length === grant
-        ? `is at its hire grant (${children.length} of ${grant} alive children)`
-        : `has exhausted its hire grant (${children.length} alive children; grant ${grant})`;
-    const grantCommand = `hq lanes grant ${parent.lane_id} --hire <n>`;
-    const authorityGuidance = grantor
-        ? `Its senior ${grantor.kind} ${grantor.id} can raise it with: ${grantCommand}`
-        : parent.senior.kind === "user"
-            ? `Its senior is the user and can raise it with: ${grantCommand}`
-            : `No senior is recorded, so an operator must resolve ownership before running: ${grantCommand}`;
-    const message = `Lane ${parent.lane_id} ${capacity}. ${authorityGuidance}`;
-    return new LanesError("hire_grant_exhausted", message, {
-        senior_lane_id: parent.lane_id,
-        parent_grant: grant,
-        alive_children: children.map((child) => child.lane_id),
-        alive_child_count: children.length,
-        grantor,
-        ...(grantorReason ? { grantor_reason: grantorReason } : {}),
-        message,
-        ask_guidance: {
-            envelope: "decision=ask; include the desired total grant and the reason",
-            senior_command: `hq lanes grant ${parent.lane_id} --hire <n>`,
-        },
-    });
-}
 const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
 const MAX_PLACEMENT_OUTPOSTS = 16;
 function outpostIdentityUnknownError(message, expectedId, details = {}) {
@@ -2072,7 +2037,7 @@ async function emitLaneTerminalStateSoft(ctx, lane) {
         process.stderr.write(`hq lanes: terminal mesh update failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
     }
 }
-async function emitLaneStartedForStories(ctx, company, lane, threadId) {
+async function emitLaneStartedForStories(ctx, company, lane, threadId, knownAbsentStories = new Set()) {
     let ready = lane;
     if (ctx.mesh.ensureLaneThread) {
         try {
@@ -2108,6 +2073,8 @@ async function emitLaneStartedForStories(ctx, company, lane, threadId) {
             failures.push(err);
             continue;
         }
+        if (knownAbsentStories.has(storyBoardStoryKey(story.project_id, story.story_id)))
+            continue;
         try {
             await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
         }
@@ -2135,20 +2102,30 @@ function storyNotOnBoardWarning(err) {
         ? err.message
         : undefined;
 }
+function storyBoardStoryKey(projectId, storyId) {
+    return JSON.stringify([projectId, storyId]);
+}
 function combinedStoryWarning(lane, additional = []) {
     const warnings = [storyWarning(lane), ...additional]
         .filter((warning) => warning !== undefined && warning.trim().length > 0);
     return [...new Set(warnings)].join(" ") || null;
 }
-async function storyBoardWarning(ctx, company, projectId, storyIds) {
+async function storyBoardCheck(ctx, company, projectId, storyIds) {
     try {
         await assertStoriesOnBoard(ctx, company, projectId, storyIds);
-        return undefined;
+        return { absentStoryIds: new Set() };
     }
     catch (err) {
         const warning = storyNotOnBoardWarning(err);
-        if (warning !== undefined)
-            return warning;
+        if (warning !== undefined) {
+            const storyId = isLanesError(err) && typeof err.details.story_id === "string"
+                ? err.details.story_id
+                : undefined;
+            return {
+                warning,
+                absentStoryIds: new Set(storyId ? [storyId] : []),
+            };
+        }
         throw err;
     }
 }
@@ -2451,10 +2428,14 @@ async function runCreate(ctx, opts) {
     const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
     assertSameTenant(company, senior, seniorCompany);
     const createStoryWarnings = [];
+    const knownAbsentStories = new Set();
     if (meshCompany && storyIds.length > 0) {
-        const warning = await storyBoardWarning(ctx, meshCompany, project, storyIds);
-        if (warning !== undefined)
-            createStoryWarnings.push(warning);
+        const boardCheck = await storyBoardCheck(ctx, meshCompany, project, storyIds);
+        if (boardCheck.warning !== undefined)
+            createStoryWarnings.push(boardCheck.warning);
+        for (const storyId of boardCheck.absentStoryIds) {
+            knownAbsentStories.add(storyBoardStoryKey(project, storyId));
+        }
     }
     let resolvedWorker;
     if (opts.worker) {
@@ -3067,7 +3048,7 @@ async function runCreate(ctx, opts) {
             locateTranscript: ctx.locateTranscript,
         });
         if (meshCompany) {
-            createStoryWarnings.push(...await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id));
+            createStoryWarnings.push(...await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id, knownAbsentStories));
         }
     }
     else if (outpostId) {
@@ -4510,6 +4491,7 @@ async function runShow(ctx, laneId) {
         provider_session_id: lane.provider_session_id ?? null,
         provider_session_id_absent: lane.provider_session_id_absent ?? null,
         envelope_repair_mode: lane.envelope_repair?.mode ?? null,
+        envelope_validation_errors: lane.envelope_validation_errors ?? [],
         last_resume: lane.last_resume ?? null,
         account: lane.account ?? null,
         account_history: lane.account_history ?? [],
@@ -6327,7 +6309,7 @@ async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, st
     }
     return updated;
 }
-async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}) {
+async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
     const company = lane.mesh_company ?? lane.company;
     if (!company)
         return;
@@ -6341,7 +6323,9 @@ async function emitStoryTransition(ctx, lane, projectId, storyId, event, status,
         ...payload,
         lane_status: lane.state,
     });
-    await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
+    if (!skipStoryStatusPatch) {
+        await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
+    }
 }
 function sameCommittedStory(current, expected, projectId, storyId) {
     const currentStory = laneStory(current, projectId, storyId);
@@ -6350,9 +6334,9 @@ function sameCommittedStory(current, expected, projectId, storyId) {
         current.story_id === expected.story_id &&
         JSON.stringify(currentStory) === JSON.stringify(expectedStory));
 }
-async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}) {
+async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}, skipStoryStatusPatch = false) {
     try {
-        await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload);
+        await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload, skipStoryStatusPatch);
         return undefined;
     }
     catch (err) {
@@ -6408,10 +6392,12 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
     }
     const company = lane.mesh_company ?? lane.company;
     const warnings = [];
+    let storyKnownAbsent = false;
     if (company) {
-        const warning = await storyBoardWarning(ctx, company, projectId, [normalizedStoryId]);
-        if (warning !== undefined)
-            warnings.push(warning);
+        const boardCheck = await storyBoardCheck(ctx, company, projectId, [normalizedStoryId]);
+        if (boardCheck.warning !== undefined)
+            warnings.push(boardCheck.warning);
+        storyKnownAbsent = boardCheck.absentStoryIds.has(normalizedStoryId);
     }
     const at = ctx.now().toISOString();
     const thread = await ensureStoryThreadForTransition(ctx, lane, projectId, normalizedStoryId);
@@ -6427,7 +6413,7 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
             no_story_reason: undefined,
         };
     });
-    const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress", {}, storyKnownAbsent);
     if (transitionWarning !== undefined)
         warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);

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

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export type { HireGrantBackfillRow } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
+export { assignedChildHireGrants, aliveDirectChildren, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";

package/dist/lib/lanes/mesh-events.d.ts

@@ -92,6 +92,7 @@ export interface CreateLaneMeshOptions {
     }) => Promise<void>;
 }
 export declare function storyNotOnBoardError(company: LaneCompanyRef, projectId: string, storyId: string): LanesError;
+export declare function laneStoryStatusSuppressionKey(company: LaneCompanyRef, projectId: string, storyId: string): string;
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 /** Resolve the explicit mesh attribution before falling back to the lane tenant. */
 export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;
@@ -106,6 +107,8 @@ export declare function laneMeshEventIdentity(lane: LaneRecord): Record<string,
 export declare function emitLaneDecisionEvents(mesh: LaneMesh, lane: LaneRecord, envelope: Pick<LaneEnvelope, "decision" | "summary" | "blocked_reason">, opts?: {
     questionIds?: string[];
     signal?: AbortSignal;
+    /** Per-watcher-run cache for story_not_on_board refusals. */
+    storyStatusSuppressions?: Set<string>;
 }): Promise<void>;
 /** Emit an abnormal terminal state even when the worker produced no envelope. */
 export declare function emitLaneTerminalStateEvent(mesh: LaneMesh, lane: LaneRecord, state: Exclude<TerminalLaneState, "done">, summary?: string, signal?: AbortSignal): Promise<void>;

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,10 +33,14 @@ 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" | "none";

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) {

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/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

@@ -470,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

@@ -432,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

@@ -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";

package/dist/lib/lanes/watcher.js

@@ -35,7 +35,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { raiseEnvelopeQuestions } from "./questions.js";
-import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, } from "./types.js";
+import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, } from "./types.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { readLane, retryUpdateLane } from "./store.js";
 import { readWorkerRunResult } from "./delivery.js";
@@ -44,7 +44,7 @@ import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, provide
 import { readToolActivity, toolActivityPath } from "./dropbox.js";
 import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefaultHoldMs } from "./config.js";
 import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission-host.js";
-import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, progressEventDue, } from "./mesh-events.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, laneStoryStatusSuppressionKey, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
 import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
@@ -313,7 +313,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
         classification.state === "awaiting_input" &&
         opts.envelope &&
         (opts.envelope.questions?.length ?? 0) > 0) {
-        raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at);
+        raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes);
     }
     let changed = false;
     const updated = retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
@@ -336,6 +336,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
             stalled: undefined,
             stalled_at: undefined,
             stalled_reason: undefined,
+            envelope_validation_errors: opts.envelopeValidationErrors,
         };
         changed = true;
         if (classification.reason) {
@@ -432,6 +433,81 @@ function fileNonEmpty(filePath) {
         throw err;
     }
 }
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Keep only questions that the normal envelope parser accepts. */
+function recoverAskEnvelope(text, validationErrors) {
+    const raw = JSON.parse(text);
+    if (!isPlainObject(raw) || raw.decision !== "ask" || !Array.isArray(raw.questions)) {
+        return null;
+    }
+    const validQuestions = [];
+    const questionIndexes = [];
+    const questionErrors = [];
+    for (let index = 0; index < raw.questions.length; index += 1) {
+        const question = raw.questions[index];
+        try {
+            const parsed = parseLaneEnvelope({
+                schema_version: "hq-lane-envelope.v1",
+                decision: "ask",
+                summary: "Recovered operator question",
+                story_status: "in_progress",
+                artifacts: [],
+                questions: [question],
+            });
+            const item = parsed.questions?.[0];
+            if (item === undefined) {
+                throw new Error("question parser returned no question");
+            }
+            validQuestions.push(item);
+            questionIndexes.push(index);
+        }
+        catch (err) {
+            questionErrors.push(`questions[${index}] is invalid: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (validQuestions.length === 0) {
+        return {
+            envelope: {
+                schema_version: "hq-lane-envelope.v1",
+                decision: "ask",
+                summary: "The worker needs operator input after envelope validation failed.",
+                story_status: STORY_STATUSES.includes(raw.story_status)
+                    ? raw.story_status
+                    : "in_progress",
+                artifacts: [],
+                questions: [],
+            },
+            questionIndexes,
+            questionErrors,
+            sourceQuestionCount: raw.questions.length,
+        };
+    }
+    const contextErrors = [...new Set([...validationErrors, ...questionErrors])];
+    const storyStatus = STORY_STATUSES.includes(raw.story_status) && raw.story_status !== "done"
+        ? raw.story_status
+        : "in_progress";
+    const questions = validQuestions.map((question) => ({
+        ...question,
+        context: `${question.context}\n\nEnvelope validation errors:\n${contextErrors.map((error) => `- ${error}`).join("\n")}`,
+    }));
+    return {
+        envelope: {
+            schema_version: "hq-lane-envelope.v1",
+            decision: "ask",
+            summary: typeof raw.summary === "string" && raw.summary.length > 0
+                ? raw.summary
+                : "The worker needs operator input after envelope validation failed.",
+            story_status: storyStatus,
+            artifacts: [],
+            questions,
+        },
+        questionIndexes,
+        questionErrors,
+        sourceQuestionCount: raw.questions.length,
+    };
+}
 export function readLatestEnvelope(hqRoot, laneId, minName) {
     return readLatestEnvelopeRecord(hqRoot, laneId, minName)?.envelope ?? null;
 }
@@ -570,8 +646,8 @@ function readLaneSoft(hqRoot, laneId) {
     }
 }
 /** Question ids an ask envelope raised, as `raiseEnvelopeQuestions` mints them. */
-export function envelopeQuestionIds(laneId, envelopeRef, envelope) {
-    return (envelope.questions ?? []).map((_q, i) => envelopeQuestionId(laneId, envelopeRef, i));
+export function envelopeQuestionIds(laneId, envelopeRef, envelope, questionIndexes) {
+    return (envelope.questions ?? []).map((_q, i) => envelopeQuestionId(laneId, envelopeRef, questionIndexes?.[i] ?? i));
 }
 function defaultSleep(ms) {
     return new Promise((resolve) => {
@@ -604,6 +680,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     const progressFiles = [...logFiles, ...activityFiles];
     // Mesh seam (spec §8). Non-interactive: nobody is at this process's tty.
     const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+    const storyStatusSuppressions = new Set();
     const meshRequestTimeoutMs = deps.meshRequestTimeoutMs ?? 10_000;
     const initialLane = readLaneSoft(hqRoot, laneId);
     if (mesh && initialLane) {
@@ -631,6 +708,10 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
+                if (company && initialLane.story_id &&
+                    err instanceof LanesError && err.error === "story_not_on_board") {
+                    storyStatusSuppressions.add(laneStoryStatusSuppressionKey(company, initialLane.project_id, initialLane.story_id));
+                }
                 process.stderr.write(`hq lanes watcher: mesh thread ensure failed for ${laneId}: ${message}\n`);
                 writeWatcherDecision(outPath, {
                     event: "mesh_event_failed",
@@ -701,10 +782,10 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
         const missingExpected = !processAlive && latestFile === null
             ? missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)
             : null;
-        const latest = latestFile && latestFile.envelope
+        let latest = latestFile && latestFile.envelope
             ? { envelope: latestFile.envelope, ref: latestFile.ref }
             : null;
-        const envelope = latest?.envelope ?? null;
+        let envelope = latest?.envelope ?? null;
         if (latest && latest.ref !== lastEnvelopeRef) {
             logDecision({
                 event: "envelope_observed",
@@ -751,6 +832,9 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
         // fails the same way, and would end the lane envelope_invalid without
         // ever recording the hold. The quota result applies immediately instead.
         let invalidEnvelope = null;
+        let envelopeValidationErrors;
+        let questionIndexes;
+        let recoveredAsk = false;
         const repairCandidate = latestFile ?? missingExpected;
         if (!processAlive &&
             !envelope &&
@@ -771,11 +855,70 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                     await sleep(pollMs);
                     continue;
                 }
-                if (!repairCandidate.missing)
-                    invalidEnvelope = { errors: repair.errors };
+                if (!repairCandidate.missing) {
+                    const validationErrors = repair.errors.filter((error) => !error.startsWith("repair_spawn_failed:"));
+                    let recovery = null;
+                    try {
+                        recovery = recoverAskEnvelope(repairCandidate.text, validationErrors);
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        process.stderr.write(`hq lanes watcher: invalid ask fallback could not parse ${repairCandidate.path} for ${laneId}: ${message}\n`);
+                        logDecision({
+                            event: "envelope_repair",
+                            at: new Date(now()).toISOString(),
+                            outcome: "ask_fallback_skipped",
+                            reason: "invalid_json",
+                            error: message,
+                            validation_errors: validationErrors,
+                        });
+                    }
+                    if (recovery !== null && (recovery.envelope.questions?.length ?? 0) > 0) {
+                        const errors = [...new Set([...validationErrors, ...recovery.questionErrors])];
+                        envelopeValidationErrors = errors;
+                        questionIndexes = recovery.questionIndexes;
+                        latest = { envelope: recovery.envelope, ref: repairCandidate.ref };
+                        envelope = recovery.envelope;
+                        recoveredAsk = true;
+                        const message = `hq lanes watcher: routing invalid ask envelope for ${laneId} to awaiting_input ` +
+                            `with ${recovery.envelope.questions?.length ?? 0} validated question(s); errors: ${errors.join("; ")}`;
+                        process.stderr.write(`${message}\n`);
+                        logDecision({
+                            event: "envelope_repair",
+                            at: new Date(now()).toISOString(),
+                            outcome: "ask_fallback_routed",
+                            state: "awaiting_input",
+                            questions: recovery.envelope.questions?.length ?? 0,
+                            validation_errors: errors,
+                        });
+                    }
+                    else {
+                        const errors = recovery === null
+                            ? repair.errors
+                            : [...new Set([...repair.errors, ...recovery.questionErrors])];
+                        invalidEnvelope = { errors };
+                        if (recovery !== null) {
+                            const message = `hq lanes watcher: invalid ask envelope for ${laneId} remains failed; ` +
+                                `0 of ${recovery.sourceQuestionCount} questions passed validation`;
+                            process.stderr.write(`${message}\n`);
+                            logDecision({
+                                event: "envelope_repair",
+                                at: new Date(now()).toISOString(),
+                                outcome: "ask_fallback_skipped",
+                                reason: "no_valid_questions",
+                                questions: 0,
+                                validation_errors: errors,
+                            });
+                        }
+                    }
+                }
             }
         }
-        if (processAlive === false && envelope && latestFile) {
+        if (processAlive === false &&
+            envelope &&
+            latestFile !== null &&
+            latestFile.envelope !== null &&
+            !recoveredAsk) {
             markRepairSucceeded(hqRoot, laneId, latestFile.ref);
         }
         const tick = tickWatcher({
@@ -913,6 +1056,8 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 const terminalWrite = applyTerminalToLaneWithResult(hqRoot, laneId, classification, {
                     envelope,
                     envelopeRef: latest?.ref,
+                    envelopeValidationErrors,
+                    questionIndexes,
                     at: tick.emit.at,
                     quota,
                     providerRejection,
@@ -930,9 +1075,13 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 if (mesh && terminalWrite.changed) {
                     if (envelope && latest) {
                         const questionIds = envelope.decision === "ask"
-                            ? envelopeQuestionIds(laneId, latest.ref, envelope)
+                            ? envelopeQuestionIds(laneId, latest.ref, envelope, questionIndexes)
                             : undefined;
-                        await emitMeshSoft(`lane_${envelope.decision}`, logDecision, tick.emit.at, (signal) => emitLaneDecisionEvents(mesh, updated, envelope, { questionIds, signal }), meshRequestTimeoutMs);
+                        await emitMeshSoft(`lane_${envelope.decision}`, logDecision, tick.emit.at, (signal) => emitLaneDecisionEvents(mesh, updated, envelope, {
+                            questionIds,
+                            signal,
+                            storyStatusSuppressions,
+                        }), meshRequestTimeoutMs);
                     }
                     else if (updated.state === "failed" || updated.state === "interrupted" ||
                         updated.state === "cancelled" || updated.state === "killed") {
@@ -973,9 +1122,11 @@ export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair,
     const runDir = laneRunDir(hqRoot, laneId);
     const manifest = readSpawnManifest(runDir);
     const prior = lane.envelope_repair;
-    const repairRef = missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)?.ref ??
-        prior?.envelope_ref ??
-        latest.ref;
+    // A resumed worker can write its next envelope before spawn.json points to
+    // that slot. Use the newest of the manifest's expected slot and the actual
+    // latest file so an older manifest or repair record cannot spend its budget.
+    const expectedRef = missingExpectedEnvelopeFile(hqRoot, laneId, manifest.envelope_path)?.ref;
+    const repairRef = expectedRef !== undefined && expectedRef > latest.ref ? expectedRef : latest.ref;
     const priorAppliesToSlot = prior?.envelope_ref === undefined || prior.envelope_ref === repairRef;
     if (prior && prior.attempted && priorAppliesToSlot) {
         // The repair turn ran and its output does not parse either.
@@ -1025,6 +1176,14 @@ export function decideEnvelopeRepair(hqRoot, laneId, latest, nowMs, spawnRepair,
             error,
             rawText: latest.text,
             missing: latest.missing,
+            onProfileWarning: (fields) => {
+                logDecision({
+                    event: "envelope_repair",
+                    at,
+                    outcome: "profile_unknown_meta_fields_ignored",
+                    fields: [...fields],
+                });
+            },
         });
         logDecision({ event: "envelope_repair", at, outcome: "spawned", mode, pid, session_id: sessionId, error });
         return { action: "spawned" };

package/package.json

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