@indigoai-us/hq-cli 5.253.0 → 5.255.0

package/dist/lib/lanes/manager-status-gate.js

@@ -0,0 +1,168 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { checkCompanyPath } from "./checked-company-path.js";
+import { LanesError } from "./errors.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+export const MANAGER_STATUS_GATE_FLAG = "lanes.manager-status-gate";
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function invalidMapping(message, filePath, details = {}) {
+    throw new LanesError("manager_status_mapping_invalid", message, { path: filePath, ...details });
+}
+function readJuniors(root) {
+    const filePath = path.join(root, "workspace", "lane-briefs", "juniors.json");
+    let raw;
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            invalidMapping("juniors.json must be a regular file", filePath);
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { filePath, rows: [] };
+        if (err instanceof LanesError)
+            throw err;
+        throw new LanesError("manager_status_mapping_unreadable", `Cannot read manager mapping ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        invalidMapping("juniors.json contains invalid JSON", filePath);
+    }
+    if (!isObject(parsed) || !Array.isArray(parsed.juniors))
+        invalidMapping("juniors.json must contain a juniors array", filePath);
+    const rows = [];
+    for (const [index, row] of parsed.juniors.entries()) {
+        if (!isObject(row))
+            invalidMapping(`juniors[${index}] must be an object`, filePath, { index });
+        rows.push(row);
+    }
+    return { filePath, rows };
+}
+function matchesLane(rowLane, laneId) {
+    const row = rowLane.trim();
+    const bareLaneId = laneId.split("_", 1)[0] ?? "";
+    return row === laneId || row === bareLaneId;
+}
+function managerStatusGateErrorCode(err) {
+    return err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
+}
+function logManagerStatusGateFailure(lane, err) {
+    const code = managerStatusGateErrorCode(err);
+    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`);
+}
+/** Resolve manager identity and the single declared status file, if present. */
+export function resolveManagerStatusTarget(root, lane) {
+    const directIdentity = lane.story_id === "MANAGER"
+        ? "story_id"
+        : lane.worker_profile?.endsWith("-manager") === true
+            ? "worker_profile"
+            : undefined;
+    const registry = readJuniors(root);
+    const matches = [];
+    for (const [index, row] of registry.rows.entries()) {
+        if (typeof row.lane !== "string")
+            invalidMapping(`juniors[${index}].lane must be a string`, registry.filePath, { index });
+        if (matchesLane(row.lane, lane.lane_id))
+            matches.push(row);
+    }
+    if (matches.length > 1)
+        invalidMapping("More than one juniors row maps to this manager lane", registry.filePath, { lane_id: lane.lane_id });
+    const row = matches[0];
+    if (row === undefined) {
+        return directIdentity
+            ? { manager: true, identified_by: directIdentity, skipped: "no_juniors_row" }
+            : { manager: false };
+    }
+    for (const field of ["team", "lane", "host", "status", "prd"]) {
+        if (typeof row[field] !== "string" || row[field].trim() === "") {
+            invalidMapping(`Matched juniors row needs a non-empty ${field}`, registry.filePath, { lane_id: lane.lane_id, field });
+        }
+    }
+    const company = lane.company?.slug ?? lane.mesh_company?.slug ?? "";
+    const statusPath = checkCompanyPath(root, company, row.status, registry.filePath);
+    return {
+        manager: true,
+        identified_by: directIdentity ?? "juniors",
+        statusPath,
+    };
+}
+export async function resolveManagerStatusGateForLane(root, lane, options = {}) {
+    const reportError = options.onError ?? ((err) => logManagerStatusGateFailure(lane, err));
+    let enabled;
+    try {
+        enabled = await (options.readFlag ?? readLanesRegistryFlag)(MANAGER_STATUS_GATE_FLAG, {
+            company: lane.company ?? lane.mesh_company ?? undefined,
+            env: options.env,
+        });
+    }
+    catch (err) {
+        reportError(err);
+        return { enabled: false, error: managerStatusGateErrorCode(err) };
+    }
+    if (!enabled)
+        return { enabled: false };
+    try {
+        const target = resolveManagerStatusTarget(root, lane);
+        return { enabled: target.manager && target.statusPath !== undefined, target };
+    }
+    catch (err) {
+        reportError(err);
+        return { enabled: false, error: managerStatusGateErrorCode(err) };
+    }
+}
+export async function managerStatusGateEnabledForLane(root, lane, options = {}) {
+    return (await resolveManagerStatusGateForLane(root, lane, options)).enabled;
+}
+export function readStatusSnapshot(filePath) {
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { mtime: null, updatedAt: null };
+        throw new LanesError("manager_status_unreadable", `Cannot stat manager status ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
+    }
+    if (!stat.isFile())
+        throw new LanesError("manager_status_invalid", `Manager status path is not a file: ${filePath}`, { path: filePath });
+    let updatedAt = null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        if (isObject(parsed) && typeof parsed.updated_at === "string")
+            updatedAt = parsed.updated_at;
+    }
+    catch (err) {
+        if (!(err instanceof SyntaxError)) {
+            if (err.code === "ENOENT")
+                return { mtime: null, updatedAt: null };
+            throw new LanesError("manager_status_unreadable", `Cannot read manager status ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
+        }
+    }
+    return { mtime: stat.mtimeMs, updatedAt };
+}
+export function managerStatusGateHeartbeat(root, lane, turnId, turnStartedAt) {
+    const target = resolveManagerStatusTarget(root, lane);
+    if (!target.manager || target.statusPath === undefined)
+        return undefined;
+    const snapshot = readStatusSnapshot(target.statusPath);
+    return {
+        turn_started_at: turnStartedAt,
+        status_mtime_at_start: snapshot.mtime,
+        status_updated_at_at_start: snapshot.updatedAt,
+        status_path: target.statusPath,
+        turn_id: turnId,
+        consecutive_misses: lane.status_gate?.consecutive_misses ?? 0,
+    };
+}
+export function managerStatusWasWritten(gate, snapshot) {
+    const startedAt = Date.parse(gate.turn_started_at);
+    return ((snapshot.mtime !== null && Number.isFinite(startedAt) && snapshot.mtime > startedAt) ||
+        snapshot.updatedAt !== gate.status_updated_at_at_start);
+}
+//# sourceMappingURL=manager-status-gate.js.map

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

@@ -79,6 +79,8 @@ export interface ReconcileDeps {
     env?: NodeJS.ProcessEnv;
     /** Flag reader seam used to assert rollout reads happen before admission locks. */
     readRegistryFlag?: typeof readLanesRegistryFlag;
+    /** Pre-read manager gate decisions, scoped to each lane for this pass. */
+    managerStatusGateByLane?: ReadonlyMap<string, boolean>;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */

package/dist/lib/lanes/reconcile.js

@@ -29,6 +29,7 @@ import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuesti
 import { SILENCE_MS, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
 import { 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. */
@@ -44,11 +45,43 @@ 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) {
+function spawnDepsForHost(deps, lane) {
     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) {
@@ -694,8 +727,9 @@ export async function runPassBody(hqRoot, deps) {
         : QUESTION_AGE_MS;
     if (deps.afterLoad)
         await deps.afterLoad();
+    const startDeps = await prepareManagerStatusGateStarts(hqRoot, lanes, deps, summary);
     markOverdueLanes(hqRoot, lanes, summary, deps, now);
-    await heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now);
+    await heartbeatAndDeadHosts(hqRoot, lanes, summary, startDeps, now);
     for (const question of questions) {
         if (question.status !== "pending")
             continue;
@@ -838,10 +872,10 @@ export async function runPassBody(hqRoot, deps) {
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
-        resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, deps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany);
+        resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, startDeps, now, keepAliveFlagByCompany, supersessionLineageAwareByCompany);
         const drainLanes = loadLaneRecords(hqRoot, summary);
-        await admitQueued(hqRoot, drainLanes, summary, deps, now);
-        await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
+        await admitQueued(hqRoot, drainLanes, summary, startDeps, now);
+        await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, startDeps);
     });
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
@@ -1024,10 +1058,12 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                         classification.reason === "account_model_unavailable")) {
                     recordAccountQuota(hqRoot, classified.provider, classified.account, quota);
                 }
-                if (!deps.dryRun && accountRetryReason && classified.account) {
+                if (!deps.dryRun &&
+                    accountRetryReason &&
+                    classified.account) {
                     try {
                         const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
-                            ...spawnDepsForHost(deps),
+                            ...spawnDepsForHost(deps, classified),
                         });
                         summary.dead_host.push({
                             id: lane.lane_id,
@@ -1308,7 +1344,7 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         nowMs,
     });
     const spawnFn = deps.spawn ??
-        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
+        ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps, lane)));
     const running = lanes.filter((lane) => (lane.state === "running" ||
         hasFreshAdmissionReservation(lane, now.getTime()) ||
         hasActivePendingResume(lane, now.getTime())) &&
@@ -1977,7 +2013,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
         const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps);
         throttleDecision = throttle.decision;
     }
-    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps)));
+    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, spawnDepsForHost(deps, lane)));
     const nowMs = deps.now().getTime();
     const fallbackAnswerAt = new Date(nowMs).toISOString();
     const answerAtByLane = new Map();

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

@@ -86,6 +86,8 @@ 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;
@@ -254,6 +256,7 @@ export declare function refuseOutpostSelfTarget(hqRoot: string, lane: LaneRecord
 export declare function armLaneWatcher(hqRoot: string, laneId: string, deps?: SpawnLaneDeps): number;
 export interface SpawnManifestFile {
     envelope_path?: string;
+    turn_id?: string;
     resume?: {
         session_id: string;
     } | null;

package/dist/lib/lanes/spawn.js

@@ -27,6 +27,7 @@ import { ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithReg
 import { registryWorkerRecord } from "./registry-persona.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
+import { managerStatusGateHeartbeat } from "./manager-status-gate.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
 import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
@@ -1476,6 +1477,7 @@ function writeSpawnManifest(runDir, input) {
         watcher_pid: input.watcherPid,
         detached: true,
         envelope_path: input.envelopePath,
+        ...(input.turnId !== undefined ? { turn_id: input.turnId } : {}),
         resume: input.resume,
         worker_out_offset: input.workerOutOffset,
         ...(input.fastMode ? { fast_mode: true } : {}),
@@ -1552,6 +1554,8 @@ export function readSpawnManifest(runDir) {
     const out = {};
     if (typeof rec.envelope_path === "string")
         out.envelope_path = rec.envelope_path;
+    if (typeof rec.turn_id === "string")
+        out.turn_id = rec.turn_id;
     if (typeof rec.provider_home_at_spawn === "string") {
         out.provider_home_at_spawn = rec.provider_home_at_spawn;
     }
@@ -1982,6 +1986,9 @@ 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 claimed = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
@@ -2033,6 +2040,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 }
                 : { model_source: "none" }),
             effort_source: effort.source,
+            status_gate: statusGateHeartbeat,
             last_host_report_at: nowIso,
             ...(profile
                 ? {
@@ -2167,6 +2175,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             workerPid,
             watcherPid,
             envelopePath,
+            turnId: laneTurnId,
             resume: resume ? { session_id: resume.session_id } : null,
             workerOutOffset,
             fastMode,

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

@@ -334,6 +334,23 @@ export interface LastEnvelopeRef {
     artifacts?: unknown[];
     blocked_reason?: string;
 }
+export interface ManagerStatusGate {
+    turn_started_at: string;
+    status_mtime_at_start: number | null;
+    status_updated_at_at_start: string | null;
+    status_path: string;
+    turn_id: string;
+    consecutive_misses: number;
+}
+export interface ManagerStatusGateHistoryEntry {
+    event: "status_missed";
+    turn_id: string;
+    path: string;
+    at: string;
+    identified_by: "story_id" | "worker_profile" | "juniors";
+    resume_queued?: boolean;
+    resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
+}
 export interface LaneStory {
     project_id: string;
     story_id: string;
@@ -473,6 +490,10 @@ export interface LaneRecord {
     fast_mode?: boolean;
     /** Time of the last operator message accepted for this lane. Drives compaction. */
     last_message_at?: string;
+    /** Turn-start baseline used by the optional manager status gate. */
+    status_gate?: ManagerStatusGate;
+    /** Bounded audit history of manager turns that missed their declared status artifact. */
+    status_gate_history?: ManagerStatusGateHistoryEntry[];
     /** Last automatic compaction of a resumed session (compaction.ts). */
     last_compaction?: LaneCompactionRecord;
     /**

package/dist/lib/lanes/types.js

@@ -228,7 +228,7 @@ export const LANE_FIELD_WRITERS = {
     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"], 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"],
-    last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command"], interrupted_at: ["watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],

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

@@ -36,6 +36,7 @@ import { type QuotaSignal } from "./quota.js";
 import { type ProviderRejection } from "./provider-rejection.js";
 import type { AdmissionHost } from "./admission.js";
 import { type LaneMesh } from "./mesh-events.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
 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;
@@ -226,6 +227,8 @@ export interface WatcherLoopDeps {
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume an atomically queued inbox after this watcher wins terminal CAS. */
     recoverQueuedMessages?: (lane: LaneRecord) => Promise<void>;
+    /** Test seam; production reads the company-scoped hq-flags row. */
+    readManagerStatusGateFlag?: typeof readLanesRegistryFlag;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -47,6 +47,9 @@ import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefau
 import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission-host.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, laneStoryStatusSuppressionKey, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { MANAGER_STATUS_GATE_FLAG, managerStatusWasWritten, readStatusSnapshot, resolveManagerStatusTarget, managerStatusGateEnabledForLane, } from "./manager-status-gate.js";
+import { queueManagerStatusGateResume } from "./keep-alive.js";
 import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, writePidRecord, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export const SILENCE_MS = 20 * 60 * 1000;
@@ -639,6 +642,75 @@ export function missingExpectedEnvelopeFile(hqRoot, laneId, envelopePath) {
         missing: true,
     };
 }
+async function settleManagerStatusGate(hqRoot, lane, manifestTurnId, at, deps, logDecision) {
+    const readFlag = deps.readManagerStatusGateFlag ?? readLanesRegistryFlag;
+    let enabled = false;
+    try {
+        enabled = await readFlag(MANAGER_STATUS_GATE_FLAG, {
+            company: lane.company ?? lane.mesh_company ?? undefined,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes watcher: manager status gate flag read failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+        logDecision({ event: "status_gate_flag_failed", at, error: err instanceof Error ? err.name : "UnknownError" });
+    }
+    if (!enabled)
+        return lane;
+    let target;
+    try {
+        target = resolveManagerStatusTarget(hqRoot, lane);
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes watcher: manager status mapping failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+        logDecision({ event: "status_gate_mapping_failed", at, error: err instanceof Error ? err.message : String(err) });
+        return lane;
+    }
+    const gate = lane.status_gate;
+    if (!target.manager || target.statusPath === undefined || gate === undefined)
+        return lane;
+    if (manifestTurnId !== undefined && manifestTurnId !== gate.turn_id ||
+        target.statusPath !== gate.status_path) {
+        logDecision({ event: "status_gate_baseline_mismatch", at, turn_id: gate.turn_id });
+        return lane;
+    }
+    let written;
+    try {
+        written = managerStatusWasWritten(gate, readStatusSnapshot(gate.status_path));
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes watcher: manager status read failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+        logDecision({ event: "status_gate_status_read_failed", at, error: err instanceof Error ? err.message : String(err) });
+        written = false;
+    }
+    if (written) {
+        return retryUpdateLane(hqRoot, lane.lane_id, "watcher", (current) => {
+            if (current.status_gate?.turn_id !== gate.turn_id || current.status_gate.consecutive_misses === 0)
+                return current;
+            return { ...current, status_gate: { ...current.status_gate, consecutive_misses: 0 } };
+        });
+    }
+    const resumeText = `Your turn ended without updating ${gate.status_path}. Write your status now: update updated_at, kpis and current_work, then end the turn.`;
+    const updated = queueManagerStatusGateResume(hqRoot, lane.lane_id, {
+        turn_id: gate.turn_id,
+        path: gate.status_path,
+        at,
+        identified_by: target.identified_by ?? "juniors",
+    }, resumeText);
+    const miss = updated.status_gate_history?.find((entry) => entry.event === "status_missed" && entry.turn_id === gate.turn_id);
+    if (miss) {
+        logDecision({
+            event: "status_missed",
+            at,
+            turn_id: gate.turn_id,
+            path: gate.status_path,
+            consecutive_misses: updated.status_gate?.consecutive_misses ?? 0,
+            resume_queued: miss.resume_queued === true,
+            resume_skipped_reason: miss.resume_skipped_reason,
+            state: updated.state,
+        });
+    }
+    return updated;
+}
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with
  * the event name and the error message, and never propagates: the lane's
@@ -820,10 +892,17 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
     }
     const progressIntervalMs = deps.progressEventMinIntervalMs ?? readProgressIntervalMs(hqRoot, readLaneSoft(hqRoot, laneId));
     const spawnRepair = deps.spawnRepair ?? spawnEnvelopeRepair;
-    const retryAccount = deps.retryAccount ?? ((root, lane, reason) => retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
-        ...deps.retrySpawnDeps,
-        admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
-    }));
+    const retryAccount = deps.retryAccount ?? (async (root, lane, reason) => {
+        const managerStatusGateEnabled = await managerStatusGateEnabledForLane(root, lane, {
+            env: deps.retrySpawnDeps?.env,
+            readFlag: deps.readManagerStatusGateFlag,
+        });
+        return retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
+            ...deps.retrySpawnDeps,
+            managerStatusGateEnabled,
+            admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
+        });
+    });
     let lastSignalMs = now();
     let lastSeenMtime = 0;
     let lastAlive = null;
@@ -1168,7 +1247,7 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                     quota,
                     providerRejection,
                 });
-                const updated = terminalWrite.record;
+                let updated = terminalWrite.record;
                 const effectiveEnvelope = terminalWrite.envelope ?? envelope;
                 const effectiveClassification = terminalWrite.classification;
                 logDecision({
@@ -1201,7 +1280,14 @@ async function runWatcherLoopOwned(hqRoot, laneId, deps) {
                         await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, updated.terminal_reason ?? effectiveClassification.reason, signal), meshRequestTimeoutMs);
                     }
                 }
-                if (terminalWrite.changed && deps.recoverQueuedMessages) {
+                if (terminalWrite.changed) {
+                    updated = await settleManagerStatusGate(hqRoot, updated, manifest.turn_id, tick.emit.at, deps, logDecision);
+                }
+                const managerStatusFollowupQueued = manifest.turn_id !== undefined &&
+                    updated.status_gate_history?.some((entry) => entry.event === "status_missed" &&
+                        entry.turn_id === manifest.turn_id &&
+                        entry.resume_queued === true) === true;
+                if (terminalWrite.changed && deps.recoverQueuedMessages && !managerStatusFollowupQueued) {
                     try {
                         if (dropboxInboxHasMessages(hqRoot, laneId)) {
                             await deps.recoverQueuedMessages(updated);

package/dist/lib/mesh/live/daemon/transcript-watch.js

@@ -722,7 +722,7 @@ export class TranscriptWatcher {
                 }
                 if (track.pendingTurn &&
                     nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
-                    if (this.emitKind(track, "turn_end", nowMs)) {
+                    if (this.emitKind(track, "turn_end", nowMs, transcriptTurnAtMs(track, nowMs))) {
                         track.pendingTurn = false;
                         result.turns += 1;
                     }
@@ -824,7 +824,7 @@ export class TranscriptWatcher {
         }
         if (track.pendingTurn &&
             nowMs - track.lastChangeAtMs >= TRANSCRIPT_TURN_QUIET_MS) {
-            if (this.emitKind(track, "turn_end", nowMs)) {
+            if (this.emitKind(track, "turn_end", nowMs, transcriptTurnAtMs(track, nowMs))) {
                 track.pendingTurn = false;
                 result.turns += 1;
             }
@@ -916,7 +916,9 @@ export class TranscriptWatcher {
         }
         return env;
     }
-    emitKind(track, kind, nowMs) {
+    emitKind(track, kind, nowMs, 
+    /** Event time when it differs from detection time (turn_end). */
+    atMs = nowMs) {
         let seq;
         try {
             seq = reserveSessionSeq(track.sessionId, 1, this.seqEnv());
@@ -925,13 +927,18 @@ export class TranscriptWatcher {
             return false;
         }
         track.seq = seq;
+        // `at` must not go backwards against seq: a transcript time older than the
+        // last event this watcher sent for the session is clamped to that event.
+        const eventAtMs = track.lastSentAtMs !== undefined && atMs < track.lastSentAtMs
+            ? track.lastSentAtMs
+            : atMs;
         const opts = {
             kind,
             sessionId: track.sessionId,
             harness: track.harness,
             adapterVersion: TRANSCRIPT_ADAPTER_VERSION,
             source: TRANSCRIPT_EVENT_SOURCE,
-            at: new Date(nowMs).toISOString(),
+            at: new Date(eventAtMs).toISOString(),
             seq,
             cwd: track.cwd,
             hqRoot: this.deps.hqRoot,
@@ -942,6 +949,7 @@ export class TranscriptWatcher {
         };
         try {
             this.enqueueFn(opts);
+            track.lastSentAtMs = eventAtMs;
             return true;
         }
         catch {
@@ -949,6 +957,19 @@ export class TranscriptWatcher {
         }
     }
 }
+/**
+ * A transcript turn ended when the transcript last changed (file mtime), not
+ * when a backed-off or restarted poll noticed it. Never later than now. A
+ * catch-up turn_end sent in the same tick as session_end (restart adoption of
+ * an already quiet transcript) therefore carries the earlier transcript time,
+ * not the session_end time.
+ */
+function transcriptTurnAtMs(track, nowMs) {
+    const mtimeMs = track.lastMtimeMs;
+    if (!Number.isFinite(mtimeMs) || mtimeMs <= 0)
+        return nowMs;
+    return Math.min(mtimeMs, nowMs);
+}
 /**
  * Adaptive interval: busy ticks double up to MAX; quiet ticks return to base.
  */

package/package.json

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