@indigoai-us/hq-cli 5.293.0 → 5.295.0

package/dist/lib/lanes/reconcile.js

@@ -32,7 +32,6 @@ import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuesti
 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 { 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,11 @@ 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 ?? {}),
         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 +821,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 +1196,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,
@@ -1512,7 +1479,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 +1666,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 +1874,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 +1901,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 +1927,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 +2385,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 +2393,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 +2511,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 +2576,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 +2610,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();

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,9 +2005,16 @@ 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;
+    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;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
@@ -2102,6 +2114,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 } : {}),

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

@@ -7,6 +7,7 @@
  * compare-and-set on `version`. Histories are capped at 50 at the append site.
  */
 import * as fs from "node:fs";
+import { type OutpostIdentity } from "./admission-host.js";
 import { type AttributionHistoryEntry, type LaneRecord, type LaneWriter, type QuestionRecord, type RoutingHistoryEntry, type SeniorHistoryEntry } from "./types.js";
 export declare const LANES_STORE_REL: string;
 export declare const LANE_RECORDS_DIR = "lanes";
@@ -15,6 +16,7 @@ export declare const PENDING_INDEX_DIR: string;
 export interface StoreDeps {
     now: () => Date;
     hostname: () => string;
+    outpostIdentity: () => OutpostIdentity;
     mkdirSync: typeof fs.mkdirSync;
     readFileSync: typeof fs.readFileSync;
     writeFileSync: typeof fs.writeFileSync;

package/dist/lib/lanes/store.js

@@ -14,6 +14,7 @@ import semver from "semver";
 import { CLI_VERSION } from "../../cli-version.js";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
+import { readOutpostIdentity } from "./admission-host.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
 import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
@@ -29,6 +30,7 @@ function defaultStoreDeps() {
     return {
         now: () => new Date(),
         hostname: () => os.hostname(),
+        outpostIdentity: () => readOutpostIdentity(),
         mkdirSync: fs.mkdirSync.bind(fs),
         readFileSync: fs.readFileSync.bind(fs),
         writeFileSync: fs.writeFileSync.bind(fs),
@@ -749,6 +751,28 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    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.stop_history !== undefined) {
         if (!Array.isArray(raw.stop_history)) {
             throw new LaneSchemaError("stop_history must be an array when present", {
@@ -1238,9 +1262,36 @@ export function readAllLanes(hqRoot, deps = defaultStoreDeps()) {
         ...deps,
         conflictSidecarPathsFor: (recordPath) => sidecarsByRecord.get(path.basename(recordPath)) ?? [],
     };
-    return laneIds
-        .map((laneId) => readLane(hqRoot, laneId, indexedDeps))
-        .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
+    const records = [];
+    for (const laneId of laneIds) {
+        try {
+            records.push(readLane(hqRoot, laneId, indexedDeps));
+        }
+        catch (err) {
+            if (!(err instanceof LaneSchemaError))
+                throw err;
+            const filePath = laneRecordPath(hqRoot, laneId);
+            const raw = readJsonFile(filePath, indexedDeps);
+            const host = raw !== null && typeof raw === "object" && !Array.isArray(raw)
+                ? raw.host
+                : undefined;
+            const hostRecord = host !== null && typeof host === "object" && !Array.isArray(host)
+                ? host
+                : undefined;
+            const outpostId = hostRecord?.kind === "outpost" &&
+                typeof hostRecord.id === "string" && hostRecord.id.trim() !== ""
+                ? hostRecord.id
+                : undefined;
+            const identity = indexedDeps.outpostIdentity();
+            const isRemoteMirror = outpostId !== undefined && (identity.kind === "not_outpost" ||
+                (identity.kind === "id" && identity.id !== outpostId));
+            if (!isRemoteMirror)
+                throw err;
+            const field = typeof err.details.field === "string" ? err.details.field : "unknown_field";
+            process.stderr.write(`lanes store: skipping malformed mirrored lane ${laneId} field ${field}: ${err.message}\n`);
+        }
+    }
+    return records.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
         a.lane_id.localeCompare(b.lane_id));
 }
 export function tryReadQuestion(hqRoot, questionId, deps = defaultStoreDeps()) {

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

@@ -407,6 +407,11 @@ 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;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -418,7 +423,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 +502,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. */
@@ -700,6 +713,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. */
@@ -727,6 +742,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"],

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