@indigoai-us/hq-cli 5.218.0 → 5.220.0

package/dist/lib/lanes/spawn.js

@@ -27,6 +27,7 @@ import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./s
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
 import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
+import { markAnsweredQuestionsDelivered } from "./questions.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
 import { resolveAdmissionHost } from "./admission-host.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, ENVELOPE_INVALID_REASON, parseLaneProvider, } from "./types.js";
@@ -979,22 +980,30 @@ export function readAnsweredQuestionLines(answersPath) {
         parsed = JSON.parse(text);
     }
     catch (err) {
-        process.stderr.write(`hq lanes: ${answersPath} is not JSON: ${err instanceof Error ? err.message : String(err)}\n`);
-        return [];
+        throw new LanesError("answered_questions_invalid", `Answered questions at ${answersPath} are not valid JSON`, { path: answersPath });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new LanesError("answered_questions_invalid", `Answered questions at ${answersPath} must be a JSON array`, { path: answersPath });
     }
-    if (!Array.isArray(parsed))
-        return [];
     const out = [];
-    for (const item of parsed) {
-        if (!item || typeof item !== "object")
-            continue;
+    for (const [index, item] of parsed.entries()) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new LanesError("answered_questions_invalid", `Answered question ${index} at ${answersPath} must be an object`, { path: answersPath, index });
+        }
         const rec = item;
-        if (typeof rec.question_id !== "string")
-            continue;
+        if (typeof rec.question_id !== "string" || !rec.question_id.trim()) {
+            throw new LanesError("answered_questions_invalid", `Answered question ${index} at ${answersPath} must have a question_id`, { path: answersPath, index });
+        }
+        if (typeof rec.choice !== "string") {
+            throw new LanesError("answered_questions_invalid", `Answered question ${rec.question_id} at ${answersPath} must have a choice`, { path: answersPath, question_id: rec.question_id });
+        }
         const line = {
             question_id: rec.question_id,
-            choice: typeof rec.choice === "string" ? rec.choice : JSON.stringify(rec.choice ?? null),
+            choice: rec.choice,
         };
+        if (rec.notes !== undefined && typeof rec.notes !== "string") {
+            throw new LanesError("answered_questions_invalid", `Answered question ${rec.question_id} at ${answersPath} has invalid notes`, { path: answersPath, question_id: rec.question_id });
+        }
         if (typeof rec.notes === "string" && rec.notes.length > 0)
             line.notes = rec.notes;
         out.push(line);
@@ -1744,6 +1753,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const envelopePath = nextEnvelopePath(runDir);
     const lastMessagePath = path.join(logsDir, "last-message.txt");
     const answersPath = path.join(runDir, ANSWERED_QUESTIONS_FILE);
+    const carriesAnsweredQuestions = trigger.kind === "answered_questions" || pendingResume?.trigger === "answered_questions";
+    const answeredLines = carriesAnsweredQuestions && existsSync(answersPath)
+        ? readAnsweredQuestionLines(answersPath)
+        : undefined;
     const extraPrompt = existsSync(answersPath)
         ? `Previously answered questions are at ${answersPath}; treat those choices as operator decisions that outrank the brief.`
         : undefined;
@@ -1795,12 +1808,8 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                         ? pendingResume.text
                         : undefined,
                 resumedFrom: trigger.kind === "resume" ? trigger.from : pendingResume?.resumed_from,
-                answersPath: (trigger.kind === "answered_questions" || pendingResume?.trigger === "answered_questions") && existsSync(answersPath)
-                    ? answersPath
-                    : undefined,
-                answers: (trigger.kind === "answered_questions" || pendingResume?.trigger === "answered_questions") && existsSync(answersPath)
-                    ? readAnsweredQuestionLines(answersPath)
-                    : undefined,
+                answersPath: answeredLines !== undefined ? answersPath : undefined,
+                answers: answeredLines,
                 envelopeRepairErrors: lane.terminal_reason === ENVELOPE_INVALID_REASON &&
                     lane.envelope_repair?.attempted === true &&
                     lane.envelope_repair.succeeded === false
@@ -2053,6 +2062,9 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             starttime: readProcStarttime(workerPid) ?? undefined,
         });
         requireDetached(proveDetached, workerPid, "worker");
+        if (answeredLines && answeredLines.length > 0) {
+            markAnsweredQuestionsDelivered(hqRoot, lane.lane_id, answeredLines.map(({ question_id }) => question_id), (deps.now ?? (() => new Date()))().toISOString());
+        }
         watcherPid = armLaneWatcher(hqRoot, lane.lane_id, deps);
         writeSpawnManifest(runDir, {
             command: command.command,

package/dist/lib/lanes/store.js

@@ -700,7 +700,15 @@ export function parseQuestionRecord(raw, filePath) {
             path: filePath,
         });
     }
-    return raw;
+    const delivered_at = raw.delivered_at === undefined ? null : raw.delivered_at;
+    if (delivered_at !== null &&
+        (typeof delivered_at !== "string" || !Number.isFinite(Date.parse(delivered_at)))) {
+        throw new LaneSchemaError("delivered_at must be a valid timestamp or null", {
+            path: filePath,
+            value: delivered_at,
+        });
+    }
+    return { ...raw, delivered_at };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`:
@@ -845,8 +853,13 @@ export function mergeQuestionRecords(live, sidecars) {
         return live;
     const all = [live, ...sidecars];
     const base = higherVersionRecord(live, sidecars);
+    const deliveredAt = all
+        .map((record) => record.delivered_at)
+        .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
+        .sort((a, b) => Date.parse(a) - Date.parse(b))[0] ?? null;
     return {
         ...base,
+        delivered_at: deliveredAt,
         answer_history: unionHistory(all.map(questionAnswerHistory), entryIdentity, questionAnswerHistory(base)),
         routing_history: unionHistory(all.map((record) => record.routing_history), entryIdentity, base.routing_history),
     };
@@ -1205,6 +1218,7 @@ export function createQuestion(hqRoot, init, deps = defaultStoreDeps()) {
         ...init,
         schema_version: init.schema_version ?? QUESTION_SCHEMA_VERSION,
         question_id,
+        delivered_at: init.delivered_at ?? null,
         version: 1,
         routing_history: init.routing_history ?? [],
     };

package/dist/lib/lanes/tracker-checks.d.ts

@@ -0,0 +1,77 @@
+import type { TrackerChecksConfig } from "./types.js";
+export interface TrackerCheckQuestion {
+    id: string;
+    status: string;
+    asked_at: string;
+    routing_history: Array<{
+        at: string;
+        audience_kind: string;
+    }>;
+    surfaced_at: string | null;
+}
+export interface TrackerCheckTeam {
+    team: string;
+    project_id: string;
+    lead_lane?: {
+        id: string;
+        state: string;
+    };
+    open_story_ids: string[];
+    open_pr_refs: string[];
+    running_worker_ids: string[];
+    status_path: string;
+    status_updated_at: string | null;
+    task_list_path: string;
+    task_list_updated_at: string | null;
+}
+export interface TrackerCheckBlocker {
+    id: string;
+    opened_at: string;
+    resolved_at: string | null;
+    next_step: string | null;
+}
+export interface TrackerCheckKpi {
+    id: string;
+    created_at: string;
+    defined_at?: string;
+    values: Array<{
+        at: string;
+    }>;
+}
+export interface TrackerCheckDirective {
+    id: string;
+    created_at: string;
+    teams: string[];
+    acknowledgements: Array<{
+        team: string;
+        lane_id: string;
+        at: string;
+    }>;
+}
+export interface TrackerCheckDirectiveTeam {
+    team: string;
+    lead_lane_id?: string;
+}
+export interface TrackerChecksInput {
+    now: Date;
+    thresholds: TrackerChecksConfig;
+    questions: TrackerCheckQuestion[];
+    teams: TrackerCheckTeam[];
+    blockers: TrackerCheckBlocker[];
+    kpis: TrackerCheckKpi[];
+    directives: TrackerCheckDirective[];
+    /** Company-wide mapping retained when the caller filters checks to one project. */
+    directive_teams?: TrackerCheckDirectiveTeam[];
+}
+export interface TrackerCheckFinding {
+    id: string;
+    reason: string;
+    [key: string]: unknown;
+}
+export interface TrackerCheckResult {
+    id: "questions" | "lead_lanes" | "freshness" | "blockers" | "kpis" | "directives";
+    result: "ok" | "failing";
+    items: TrackerCheckFinding[];
+}
+export declare function evaluateTrackerChecks(input: TrackerChecksInput): TrackerCheckResult[];
+//# sourceMappingURL=tracker-checks.d.ts.map

package/dist/lib/lanes/tracker-checks.js

@@ -0,0 +1,134 @@
+function timestamp(value, field) {
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new TypeError(`Invalid tracker check timestamp for ${field}`);
+    return parsed;
+}
+function check(id, items) {
+    return { id, result: items.length === 0 ? "ok" : "failing", items };
+}
+export function evaluateTrackerChecks(input) {
+    const now = input.now.getTime();
+    const questions = new Map();
+    for (const question of input.questions) {
+        if (question.status !== "pending")
+            continue;
+        const askedAt = timestamp(question.asked_at, `question ${question.id}.asked_at`);
+        if (now - askedAt > input.thresholds.open_question_age_ms) {
+            questions.set(question.id, {
+                id: question.id,
+                reason: "open_question_overdue",
+                age_ms: now - askedAt,
+            });
+        }
+        const latestRoute = question.routing_history
+            .map((route) => ({ ...route, at_ms: timestamp(route.at, `question ${question.id}.routing_history.at`) }))
+            .sort((a, b) => a.at_ms - b.at_ms)
+            .at(-1);
+        if (!latestRoute || latestRoute.audience_kind !== "user")
+            continue;
+        const surfacedAt = question.surfaced_at === null
+            ? null
+            : timestamp(question.surfaced_at, `question ${question.id}.surfaced_at`);
+        if (now - latestRoute.at_ms >= input.thresholds.owner_question_surface_ms &&
+            (surfacedAt === null || surfacedAt < latestRoute.at_ms)) {
+            const finding = questions.get(question.id);
+            questions.set(question.id, {
+                ...(finding ?? { id: question.id }),
+                reason: finding ? `${finding.reason},owner_not_surfaced` : "owner_not_surfaced",
+                routed_to_owner_at: new Date(latestRoute.at_ms).toISOString(),
+            });
+        }
+    }
+    const leadLanes = input.teams.flatMap((team) => {
+        const lead = team.lead_lane;
+        if (!lead || (lead.state !== "done" && lead.state !== "failed"))
+            return [];
+        const hasOpenWork = team.open_story_ids.length > 0 ||
+            team.open_pr_refs.length > 0 || team.running_worker_ids.length > 0;
+        if (!hasOpenWork)
+            return [];
+        return [{
+                id: team.team,
+                reason: "terminal_lead_with_open_work",
+                lead_lane_id: lead.id,
+                lead_state: lead.state,
+                open_story_ids: team.open_story_ids,
+                open_pr_refs: team.open_pr_refs,
+                running_worker_ids: team.running_worker_ids,
+            }];
+    });
+    const freshness = [];
+    for (const team of input.teams) {
+        if (team.status_updated_at === null) {
+            freshness.push({ id: team.team, reason: "status_missing", path: team.status_path });
+        }
+        else {
+            const age = now - timestamp(team.status_updated_at, `${team.team}.status.updated_at`);
+            if (age >= input.thresholds.status_stale_ms) {
+                freshness.push({ id: team.team, reason: "status_stale", path: team.status_path, age_ms: age });
+            }
+        }
+        if (team.task_list_updated_at === null) {
+            freshness.push({ id: team.team, reason: "task_list_missing", path: team.task_list_path });
+        }
+        else {
+            const age = now - timestamp(team.task_list_updated_at, `${team.team}.task_list.mtime`);
+            if (age >= input.thresholds.task_list_stale_ms) {
+                freshness.push({ id: team.team, reason: "task_list_stale", path: team.task_list_path, age_ms: age });
+            }
+        }
+    }
+    const blockers = input.blockers.flatMap((blocker) => {
+        if (blocker.resolved_at !== null)
+            return [];
+        const reasons = [];
+        const age = now - timestamp(blocker.opened_at, `blocker ${blocker.id}.opened_at`);
+        if (typeof blocker.next_step !== "string" || blocker.next_step.trim() === "")
+            reasons.push("missing_next_step");
+        if (age > input.thresholds.blocker_max_age_ms)
+            reasons.push("open_overdue");
+        return reasons.length === 0 ? [] : [{ id: blocker.id, reason: reasons.join(","), age_ms: age }];
+    });
+    const kpis = input.kpis.flatMap((kpi) => {
+        const latestValue = kpi.values
+            .map((value) => timestamp(value.at, `KPI ${kpi.id}.values.at`))
+            .reduce((latest, at) => latest === null || at > latest ? at : latest, null);
+        const baseline = latestValue ?? timestamp(kpi.created_at, `KPI ${kpi.id}.created_at`);
+        const age = now - baseline;
+        return age >= input.thresholds.kpi_value_max_age_ms
+            ? [{ id: kpi.id, reason: latestValue === null ? "no_value_overdue" : "value_stale", age_ms: age }]
+            : [];
+    });
+    const directiveTeams = input.directive_teams ?? input.teams.map((team) => ({
+        team: team.team,
+        ...(team.lead_lane ? { lead_lane_id: team.lead_lane.id } : {}),
+    }));
+    const teamByName = new Map(directiveTeams.map((team) => [team.team, team.lead_lane_id]));
+    const directives = input.directives.flatMap((directive) => {
+        const age = now - timestamp(directive.created_at, `directive ${directive.id}.created_at`);
+        if (age < input.thresholds.directive_ack_timeout_ms)
+            return [];
+        return directive.teams.flatMap((teamName) => {
+            const leadId = teamByName.get(teamName);
+            const acknowledged = leadId !== undefined && directive.acknowledgements.some((ack) => ack.team === teamName && ack.lane_id === leadId);
+            return acknowledged ? [] : [{
+                    id: `${directive.id}:${teamName}`,
+                    reason: leadId === undefined ? "target_team_lead_unavailable" : "lead_ack_missing",
+                    directive_id: directive.id,
+                    team: teamName,
+                    lead_lane_id: leadId ?? null,
+                    age_ms: age,
+                }];
+        });
+    });
+    return [
+        check("questions", [...questions.values()]),
+        check("lead_lanes", leadLanes),
+        check("freshness", freshness),
+        check("blockers", blockers),
+        check("kpis", kpis),
+        check("directives", directives),
+    ];
+}
+//# sourceMappingURL=tracker-checks.js.map

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

@@ -636,6 +636,8 @@ export interface QuestionRecord {
     hop: number;
     status: QuestionStatus;
     version: number;
+    /** Null until the owner starts a resume carrying this answer; absent on old records. */
+    delivered_at?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;
@@ -727,11 +729,24 @@ export interface LivenessWindows {
     /** No event at all for this window (and no `session_end`) → lost. Default 12 hours. */
     silent_lost_ms: number;
 }
+/** Age limits used by `hq lanes checks`; each value is a positive millisecond count. */
+export interface TrackerChecksConfig {
+    owner_question_surface_ms: number;
+    open_question_age_ms: number;
+    status_stale_ms: number;
+    task_list_stale_ms: number;
+    blocker_max_age_ms: number;
+    kpi_value_max_age_ms: number;
+    directive_ack_timeout_ms: number;
+}
 export interface LanesConfig {
     schema_version: typeof CONFIG_SCHEMA_VERSION | string;
     providers: Record<LaneProvider, ProviderConfig>;
     throttle: ThrottleConfig;
     liveness: LivenessWindows;
+    tracker: {
+        checks: TrackerChecksConfig;
+    };
     /** Seconds an unanswered question waits at a session audience before advancing. */
     session_question_timeout_secs: number;
 }

package/dist/lib/lanes/watcher-main.js

@@ -6,6 +6,20 @@
  * Requires HQ_ROOT in the environment.
  */
 import { runWatcherLoop } from "./watcher.js";
+import { LanesError } from "./errors.js";
+import { openMeshTransport } from "../mesh/client.js";
+import { CompanySelectionError } from "../../utils/company-selection-error.js";
+async function resolveQuestionActiveCompany() {
+    try {
+        const { company } = await openMeshTransport({});
+        return { slug: company.companySlug, uid: company.companyUid };
+    }
+    catch (err) {
+        if (!(err instanceof CompanySelectionError))
+            throw err;
+        throw new LanesError("question_company_unavailable", "Cannot raise a lane question because the active HQ company could not be resolved", {});
+    }
+}
 function main() {
     const laneId = process.argv[2]?.trim();
     const hqRoot = process.env.HQ_ROOT?.trim();
@@ -13,7 +27,9 @@ function main() {
         process.stderr.write("hq lanes watcher: requires lane id argv and HQ_ROOT in the environment\n");
         process.exit(1);
     }
-    void runWatcherLoop(hqRoot, laneId).catch((err) => {
+    void runWatcherLoop(hqRoot, laneId, {
+        resolveQuestionActiveCompany,
+    }).catch((err) => {
         process.stderr.write(`hq lanes watcher: ${err instanceof Error ? err.message : String(err)}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
         process.exit(1);
     });

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

@@ -31,7 +31,7 @@
  * Queue admission of the next lane when a slot frees is owned by the
  * periodic reconcile pass and is out of scope here.
  */
-import { ENVELOPE_INVALID_REASON, type LaneEnvelope, type LaneRecord, type LaneState } from "./types.js";
+import { ENVELOPE_INVALID_REASON, type LaneEnvelope, type LaneCompanyRef, type LaneRecord, type LaneState } from "./types.js";
 import { type QuotaSignal } from "./quota.js";
 import { type ProviderRejection } from "./provider-rejection.js";
 import type { AdmissionHost } from "./admission.js";
@@ -145,6 +145,7 @@ export interface ApplyTerminalOpts {
     envelopeRef?: string;
     envelopeValidationErrors?: string[];
     questionIndexes?: readonly number[];
+    activeCompany?: LaneCompanyRef | null;
     at?: string;
     quota?: QuotaSignal | null;
     /** Written to `terminal_details` with the model and account the run used. */
@@ -219,6 +220,8 @@ export interface WatcherLoopDeps {
     resolveAdmissionHost?: () => AdmissionHost;
     /** Spawn seams for account retry; host scope is supplied by the resolver above. */
     retrySpawnDeps?: Omit<SpawnLaneDeps, "admissionHost">;
+    /** Active-company fallback when an unscoped lane asks from its envelope. */
+    resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
 }
 /**
  * Wrap one mesh call. A failed emit is logged as `mesh_event_failed` with

package/dist/lib/lanes/watcher.js

@@ -34,7 +34,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
-import { raiseEnvelopeQuestions } from "./questions.js";
+import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, } from "./types.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { readLane, retryUpdateLane } from "./store.js";
@@ -309,12 +309,27 @@ export function applyTerminalToLane(hqRoot, laneId, classification, opts = {}) {
 export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}) {
     const at = opts.at ?? new Date().toISOString();
     const existing = readLane(hqRoot, laneId);
+    let questionRefusalCode = null;
     if (!isTerminalLaneState(existing.state) &&
         classification.state === "awaiting_input" &&
         opts.envelope &&
         (opts.envelope.questions?.length ?? 0) > 0) {
-        raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes);
+        try {
+            raiseEnvelopeQuestions(hqRoot, existing, opts.envelope, opts.envelopeRef ?? "envelopes/unknown.json", at, opts.questionIndexes, opts.activeCompany);
+        }
+        catch (err) {
+            questionRefusalCode = questionRecordRefusalCode(err);
+            if (questionRefusalCode === null)
+                throw err;
+            process.stderr.write(`hq lanes watcher: terminal ask refused for ${laneId}: ${questionRefusalCode}\n`);
+        }
     }
+    const terminalClassification = questionRefusalCode === null
+        ? classification
+        : {
+            state: "failed",
+            reason: `question_record_refused:${questionRefusalCode}`,
+        };
     let changed = false;
     const updated = retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
         const terminal = current.state === "done" ||
@@ -331,7 +346,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
         const next = {
             ...current,
             ...runResultFields(hqRoot, current),
-            state: classification.state,
+            state: terminalClassification.state,
             queued_reason: undefined,
             stalled: undefined,
             stalled_at: undefined,
@@ -340,9 +355,9 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
             envelope_validation_errors: opts.envelopeValidationErrors,
         };
         changed = true;
-        if (classification.reason) {
+        if (terminalClassification.reason) {
             next.terminal_reason =
-                classification.reason;
+                terminalClassification.reason;
         }
         if (opts.quota?.quota_reset_at) {
             next.quota_reset_at = opts.quota.quota_reset_at;
@@ -1054,11 +1069,25 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                             return;
                     }
                 }
+                const terminalLane = readLane(hqRoot, laneId);
+                let activeQuestionCompany;
+                if (envelope?.decision === "ask" && (envelope.questions?.length ?? 0) > 0) {
+                    try {
+                        activeQuestionCompany = await resolveQuestionCompanyWithFallback(hqRoot, terminalLane, deps.resolveQuestionActiveCompany);
+                    }
+                    catch (err) {
+                        if (questionRecordRefusalCode(err) !== "question_company_unavailable")
+                            throw err;
+                        // applyTerminalToLaneWithResult repeats the synchronous lane and
+                        // project checks, then terminalizes this ask with the named refusal.
+                    }
+                }
                 const terminalWrite = applyTerminalToLaneWithResult(hqRoot, laneId, classification, {
                     envelope,
                     envelopeRef: latest?.ref,
                     envelopeValidationErrors,
                     questionIndexes,
+                    activeCompany: activeQuestionCompany,
                     at: tick.emit.at,
                     quota,
                     providerRejection,
@@ -1074,7 +1103,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 // lane_blocked; ask → lane_ask with the queue ids. After the state
                 // write, so a mesh failure can never leave the lane unclassified.
                 if (mesh && terminalWrite.changed) {
-                    if (envelope && latest) {
+                    if (envelope && latest && updated.state === classification.state) {
                         const questionIds = envelope.decision === "ask"
                             ? envelopeQuestionIds(laneId, latest.ref, envelope, questionIndexes)
                             : undefined;
@@ -1086,7 +1115,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                     }
                     else if (updated.state === "failed" || updated.state === "interrupted" ||
                         updated.state === "cancelled" || updated.state === "killed") {
-                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, classification.reason, signal), meshRequestTimeoutMs);
+                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, updated.terminal_reason ?? classification.reason, signal), meshRequestTimeoutMs);
                     }
                 }
             }

package/dist/sentry.js

@@ -26,6 +26,9 @@ export function epipeAwareBeforeSend(event, hint) {
             return null;
         event.level = "warning";
         event.tags = { ...event.tags, worker: "flag-registry" };
+        const missingFile = flagRegistryWorkerMissingFileTags(hint?.originalException, event);
+        if (missingFile)
+            event.tags = { ...event.tags, ...missingFile };
     }
     if (!flagRegistryWorkerEvent && isEpipe(hint?.originalException))
         return null;
@@ -123,6 +126,44 @@ function isExpectedFlagRegistryWorkerStartupFailure(error) {
     return missingModule.replaceAll("\\", "/").endsWith("/flag-registry-worker.js") ||
         missingModule === "flag-registry-worker.js";
 }
+function flagRegistryWorkerMissingFileTags(error, event) {
+    if (typeof error !== "object" || error === null)
+        return null;
+    const details = error;
+    if (details.code !== "ENOENT" || !["open", "lstat"].includes(String(details.syscall))) {
+        return null;
+    }
+    let missingPath = typeof details.path === "string" ? details.path : "";
+    if (!missingPath && typeof details.message === "string") {
+        missingPath = /\b(?:open|lstat)\s+['"]([^'"]+)['"]/.exec(details.message)?.[1] ?? "";
+    }
+    const basename = missingPath.replaceAll("\\", "/").split("/").at(-1) ?? "";
+    if (!basename)
+        return null;
+    const normalizedPath = missingPath.replaceAll("\\", "/");
+    const role = basename === "flag-registry-worker.js"
+        ? "worker_entry"
+        : normalizedPath.includes("/node_modules/")
+            ? "dependency"
+            : "other";
+    const eventText = [
+        event.message,
+        ...(event.exception?.values?.map((value) => value.value) ?? []),
+    ].filter((value) => typeof value === "string").join("\n");
+    const pathVisibility = eventText.includes(missingPath)
+        ? "full_path"
+        : eventText.includes(basename)
+            ? "basename_only"
+            : "omitted";
+    return {
+        flag_worker_load_failure: "1",
+        flag_worker_missing_basename: basename,
+        flag_worker_missing_file_role: role,
+        flag_worker_path_in_event: pathVisibility,
+        // The HQ beforeSend scrubber redacts credentials but does not strip paths.
+        flag_worker_path_scrubbed_by_hq_cli: "no",
+    };
+}
 /**
  * Tests substitute only the transport so the real SDK lifecycle can be
  * exercised without an ingest request. Production callers pass nothing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.218.0",
+  "version": "5.220.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -22,12 +22,14 @@
     "scripts/mesh-daemon-if-stale.mjs"
   ],
   "scripts": {
-    "build": "node scripts/generate-dsn.mjs && tsc && node scripts/generate-command-catalog.mjs --check && node scripts/copy-schemas.mjs && node scripts/chmod-bins.mjs",
+    "build": "node scripts/generate-dsn.mjs && node scripts/build-flag-registry-worker.mjs && tsc && node scripts/generate-command-catalog.mjs --check && node scripts/copy-schemas.mjs && node scripts/chmod-bins.mjs",
     "prepublishOnly": "npm run build",
+    "pretypecheck": "node scripts/generate-dsn.mjs && node scripts/build-flag-registry-worker.mjs",
     "typecheck": "tsc --noEmit",
     "gen:scan-golden": "node scripts/generate-scan-packages-table.mjs > src/utils/__fixtures__/scan-packages.generated-block.sh",
     "gen:command-catalog": "tsc && node scripts/generate-command-catalog.mjs",
     "lint": "eslint .",
+    "pretest": "node scripts/generate-dsn.mjs && node scripts/build-flag-registry-worker.mjs",
     "test": "vitest run",
     "test:db": "vitest run src/lib/db test/commands/db.test.ts test/commands/db-tenant-isolation.test.ts",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
@@ -66,6 +68,7 @@
     "@vitest/coverage-v8": "4.1.6",
     "aedes": "1.1.2",
     "aws-sdk-client-mock": "^4.1.0",
+    "esbuild": "0.27.0",
     "eslint": "^10.5.0",
     "husky": "^9.1.7",
     "lint-staged": "^15.5.2",