@indigoai-us/hq-cli 5.217.0 → 5.219.0

package/dist/commands/lanes.js

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import { readLocalOverride } from "@indigoai-us/hq-flags-client";
 import { Option } from "commander";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
+import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -33,6 +34,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { resolveActiveMembershipCompany } from "../lib/mesh/api.js";
 import { openMeshTransport, requireToken } from "../lib/mesh/client.js";
 import { CompanySelectionError } from "../utils/company-selection-error.js";
+import { assertNoSecretText } from "../lib/lanes/text-scan.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";
@@ -40,7 +42,7 @@ import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_
 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";
-import { questionBodyAbsPath } from "../lib/lanes/questions.js";
+import { questionBodyAbsPath, resolveQuestionCompany, } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
@@ -1579,6 +1581,40 @@ function sameQuestionCompany(a, b) {
     const bSlug = b.slug.trim();
     return aSlug !== "" && aSlug === bSlug;
 }
+function effectiveLaneQuestionCompany(lane) {
+    return lane.company ?? lane.mesh_company ?? null;
+}
+function questionCompanyForLane(question, lane) {
+    return question.company ?? effectiveLaneQuestionCompany(lane);
+}
+async function resolveActiveQuestionCompany(ctx) {
+    try {
+        return await ctx.resolveCompany();
+    }
+    catch (err) {
+        if (!(err instanceof CompanySelectionError))
+            throw err;
+        throw new LanesError("question_company_unavailable", "Cannot access lane questions because the active HQ company could not be resolved", {});
+    }
+}
+function assertQuestionCompanyMatchesLane(question, lane, code) {
+    const laneCompany = effectiveLaneQuestionCompany(lane);
+    if (question.company != null && laneCompany !== null && !sameQuestionCompany(question.company, laneCompany)) {
+        throw new LanesError(code, `Question ${question.question_id} does not match lane ${lane.lane_id}'s company`, { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+}
+function assertQuestionCompanyAccess(question, lane, requestedCompany) {
+    assertQuestionCompanyMatchesLane(question, lane, "question_company_mismatch");
+    const questionCompany = questionCompanyForLane(question, lane);
+    if (questionCompany !== null && !sameQuestionCompany(questionCompany, requestedCompany)) {
+        throw new LanesError("question_company_mismatch", `Question ${question.question_id} does not belong to the requested or active company`, { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+}
+function assertQuestionCompanyResolvedForAnswer(question, lane) {
+    if (questionCompanyForLane(question, lane) !== null)
+        return;
+    throw new LanesError("question_company_unavailable", `Cannot answer legacy question ${question.question_id}: its company cannot be resolved from the question or lane`, { question_id: question.question_id, lane_id: lane.lane_id });
+}
 function questionCompanyRefMatches(recordCompany, filter) {
     return recordCompany !== null &&
         recordCompany !== undefined &&
@@ -3543,9 +3579,11 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         });
     }
     const ownerAnswer = ownerQuestion.answer;
+    const ownerLaneCompany = effectiveLaneQuestionCompany(lane);
     if (!isQuestionAnswer(ownerAnswer) ||
         ownerQuestion.lane_id !== lane.lane_id ||
-        !sameQuestionCompany(ownerQuestion.company, lane.company)) {
+        (ownerQuestion.company !== null && ownerLaneCompany !== null &&
+            !sameQuestionCompany(ownerQuestion.company, ownerLaneCompany))) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return the confirmed answer for question ${questionId}`, {
             lane_id: lane.lane_id,
             question_id: questionId,
@@ -3557,14 +3595,31 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         if (current.lane_id !== lane.lane_id) {
             throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different lane than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
         }
-        if (!sameQuestionCompany(current.company, lane.company)) {
+        if (current.company !== null &&
+            effectiveLaneQuestionCompany(lane) !== null &&
+            !sameQuestionCompany(current.company, effectiveLaneQuestionCompany(lane))) {
             throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
         }
+        if (current.company !== null &&
+            ownerQuestion.company !== null &&
+            !sameQuestionCompany(current.company, ownerQuestion.company)) {
+            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} has a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+        }
         if (current.status === "pending") {
-            return { ...current, status: "answered", answer: ownerAnswer };
+            return {
+                ...current,
+                company: current.company ?? ownerQuestion.company,
+                status: "answered",
+                answer: ownerAnswer,
+                delivered_at: ownerQuestion.delivered_at ?? current.delivered_at ?? null,
+            };
         }
         if (current.status === "answered" && sameQuestionAnswer(current.answer, ownerAnswer)) {
-            return current;
+            const deliveredAt = ownerQuestion.delivered_at ?? current.delivered_at ?? null;
+            const company = current.company ?? ownerQuestion.company;
+            return deliveredAt === current.delivered_at && company === current.company
+                ? current
+                : { ...current, company, delivered_at: deliveredAt };
         }
         throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} is ${current.status} or has a different answer than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
     });
@@ -3576,7 +3631,9 @@ async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
         const primaryLane = readLane(ctx.hqRoot(), lane.lane_id);
-        if (!sameQuestionCompany(primaryLane.company, lane.company)) {
+        const primaryCompany = effectiveLaneQuestionCompany(primaryLane);
+        const ownerCompany = effectiveLaneQuestionCompany(lane);
+        if (primaryCompany !== null && ownerCompany !== null && !sameQuestionCompany(primaryCompany, ownerCompany)) {
             throw new LanesError("outpost_question_sync_conflict", `Primary lane ${lane.lane_id} belongs to a different company than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
         }
         try {
@@ -7035,6 +7092,10 @@ async function runAsk(ctx, opts) {
     }
     const lane = readLane(hqRoot, laneId);
     assertLaneRunsHereForOperatorMutation(ctx, lane, "ask");
+    const activeCompany = lane.company || lane.mesh_company
+        ? undefined
+        : await resolveActiveQuestionCompany(ctx);
+    const questionCompany = resolveQuestionCompany(lane, activeCompany);
     const optionList = Array.isArray(opts.option)
         ? opts.option
         : opts.option
@@ -7059,6 +7120,7 @@ async function runAsk(ctx, opts) {
                 body,
                 raisedVia: "cli",
                 at,
+                activeCompany: questionCompany,
                 questionId,
             });
             questionId = withBody.question_id;
@@ -7084,6 +7146,8 @@ async function runAsk(ctx, opts) {
             return;
         }
         catch (err) {
+            if (isLanesError(err) && err.error === "secret_text_refused")
+                throw err;
             lastErr = err;
             process.stderr.write(`hq lanes ask: attempt ${i + 1}/${attempts} failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
             if (i === attempts - 1)
@@ -7113,14 +7177,15 @@ async function runAsk(ctx, opts) {
     });
 }
 const OUTPOST_QUESTION_LOOKUP_CONCURRENCY = 4;
-function groupQuestionLanesByCompany(lanes) {
+function groupQuestionLanesByCompany(lanes, fallbackCompany) {
     const groups = [];
     for (const lane of lanes) {
-        const existing = groups.find((group) => sameQuestionCompany(group.company, lane.company));
+        const company = effectiveLaneQuestionCompany(lane) ?? fallbackCompany ?? null;
+        const existing = groups.find((group) => sameQuestionCompany(group.company, company));
         if (existing)
             existing.lanes.push(lane);
         else
-            groups.push({ company: lane.company, lanes: [lane] });
+            groups.push({ company, lanes: [lane] });
     }
     return groups;
 }
@@ -7265,7 +7330,7 @@ async function readOutpostQuestionDetail(ctx, owner) {
     }
     if (question.question_id !== owner.question.question_id ||
         question.lane_id !== owner.lane.lane_id ||
-        !sameQuestionCompany(question.company, owner.lane.company)) {
+        !sameQuestionCompany(question.company, effectiveLaneQuestionCompany(owner.lane))) {
         throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} returned question ${owner.question.question_id} for a different lane or company`, { outpost_id: outpostId, question_id: owner.question.question_id });
     }
     const audience = parseOutpostQuestionAudience(response.audience, outpostId, 0);
@@ -7274,7 +7339,9 @@ async function readOutpostQuestionDetail(ctx, owner) {
 }
 async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
     const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
-        (!companyFilter || questionCompanyRefMatches(lane.company, companyFilter)));
+        (!companyFilter ||
+            effectiveLaneQuestionCompany(lane) === null ||
+            questionCompanyRefMatches(effectiveLaneQuestionCompany(lane), companyFilter)));
     const lanesByOutpost = new Map();
     for (const lane of hostedLanes) {
         if (lane.host.kind !== "outpost")
@@ -7287,7 +7354,7 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
     const errors = [];
     const eligibleGroups = [];
     for (const [outpostId, lanes] of [...lanesByOutpost.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-        for (const group of groupQuestionLanesByCompany(lanes)) {
+        for (const group of groupQuestionLanesByCompany(lanes, companyFilter)) {
             if (group.company === null) {
                 if (await ctx.laneOutpostQuestionVisibilityEnabled(null)) {
                     errors.push({
@@ -7346,7 +7413,7 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
                 const lane = localLanesById.get(question.lane_id);
                 if (!lane)
                     continue;
-                if (!sameQuestionCompany(question.company, lane.company)) {
+                if (!sameQuestionCompany(question.company, effectiveLaneQuestionCompany(lane))) {
                     throw new LanesError("outpost_question_company_mismatch", `Outpost ${outpostId} question ${question.question_id} does not match its primary lane company`, { outpost_id: outpostId, question_id: question.question_id });
                 }
                 if (seenQuestionIds.has(question.question_id)) {
@@ -7379,14 +7446,42 @@ async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
         errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()],
     };
 }
+function syncPrimaryQuestionDelivery(hqRoot, owner) {
+    const deliveredAt = owner.question.delivered_at;
+    if (!deliveredAt)
+        return;
+    try {
+        casUpdateQuestion(hqRoot, owner.question.question_id, (current) => {
+            if (current.lane_id !== owner.lane.lane_id) {
+                throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different lane than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
+            }
+            if (current.company !== null &&
+                owner.question.company !== null &&
+                !sameQuestionCompany(current.company, owner.question.company)) {
+                throw new LanesError("outpost_question_sync_conflict", `Primary question ${current.question_id} belongs to a different company than its Outpost owner`, { lane_id: owner.lane.lane_id, question_id: current.question_id });
+            }
+            const company = current.company ?? owner.question.company;
+            const nextDeliveredAt = current.delivered_at ?? deliveredAt;
+            return company === current.company && nextDeliveredAt === current.delivered_at
+                ? current
+                : { ...current, company, delivered_at: nextDeliveredAt };
+        });
+    }
+    catch (err) {
+        if (isLanesError(err) && err.error === "question_not_found")
+            return;
+        throw err;
+    }
+}
 async function runQuestionsList(ctx, opts) {
     const hqRoot = ctx.hqRoot();
     const status = opts.status ? parseQuestionStatus(opts.status) : undefined;
     const forFilter = opts.for ? parseForFilter(opts.for, ctx) : undefined;
-    let company;
-    if (opts.company)
-        company = await ctx.resolveCompany(opts.company);
-    const localLanes = opts.allHosts ? new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane])) : undefined;
+    const company = opts.company
+        ? await ctx.resolveCompany(opts.company)
+        : await resolveActiveQuestionCompany(ctx);
+    const localLanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
+    const targeted = opts.from !== undefined || opts.project !== undefined || opts.story !== undefined;
     const localQuestions = loadAllQuestions(hqRoot)
         .filter((q) => {
         if (status && q.status !== status)
@@ -7397,16 +7492,15 @@ async function runQuestionsList(ctx, opts) {
             return false;
         if (opts.story && q.story_id !== opts.story)
             return false;
-        if (company && !(opts.allHosts
-            ? questionCompanyRefMatches(q.company, company)
-            : companyRefMatches(q.company, company))) {
-            return false;
-        }
-        if (company && localLanes) {
-            const lane = localLanes.get(q.lane_id);
-            if (!lane || !questionCompanyRefMatches(lane.company, company) || !sameQuestionCompany(q.company, lane.company)) {
-                return false;
+        const lane = localLanes.get(q.lane_id);
+        if (lane)
+            assertQuestionCompanyMatchesLane(q, lane, "question_company_mismatch");
+        const questionCompany = lane ? questionCompanyForLane(q, lane) : q.company;
+        if (questionCompany !== null && !sameQuestionCompany(questionCompany, company)) {
+            if (targeted) {
+                throw new LanesError("question_company_mismatch", `Question ${q.question_id} does not belong to the requested or active company`, { question_id: q.question_id, lane_id: q.lane_id });
             }
+            return false;
         }
         if (forFilter) {
             const audience = resolveAudience(hqRoot, q, ctx);
@@ -7418,6 +7512,10 @@ async function runQuestionsList(ctx, opts) {
     const outpostLoad = opts.allHosts
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
+    for (const owner of outpostLoad.questions) {
+        assertQuestionCompanyAccess(owner.question, owner.lane, company);
+        syncPrimaryQuestionDelivery(hqRoot, owner);
+    }
     const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
     const questions = [
         ...localQuestions
@@ -7430,7 +7528,7 @@ async function runQuestionsList(ctx, opts) {
             };
             if (!opts.allHosts)
                 return row;
-            const lane = localLanes?.get(q.lane_id);
+            const lane = localLanes.get(q.lane_id);
             const host = lane?.host.kind === "outpost" ? `outpost:${lane.host.id}` : "local";
             return { ...row, host };
         }),
@@ -7444,11 +7542,7 @@ async function runQuestionsList(ctx, opts) {
                 return false;
             if (opts.story && q.story_id !== opts.story)
                 return false;
-            if (company && (!questionCompanyRefMatches(q.company, company) ||
-                !questionCompanyRefMatches(lane.company, company) ||
-                !sameQuestionCompany(q.company, lane.company))) {
-                return false;
-            }
+            assertQuestionCompanyAccess(q, lane, company);
             if (forFilter) {
                 if (!audienceMatches(audience, forFilter))
                     return false;
@@ -7518,7 +7612,15 @@ async function runQuestionsShow(ctx, questionId) {
 }
 async function runQuestionsAnswer(ctx, questionId, opts) {
     const hqRoot = ctx.hqRoot();
-    const company = opts.company ? await ctx.resolveCompany(opts.company) : undefined;
+    if (opts.choice !== undefined)
+        assertNoSecretText("answer choice", opts.choice);
+    if (opts.freeform !== undefined)
+        assertNoSecretText("freeform answer", opts.freeform);
+    if (opts.notes !== undefined)
+        assertNoSecretText("answer notes", opts.notes);
+    const company = opts.company
+        ? await ctx.resolveCompany(opts.company)
+        : await resolveActiveQuestionCompany(ctx);
     let question;
     try {
         question = readQuestion(hqRoot, questionId);
@@ -7535,6 +7637,17 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         }
         const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
         if (matches.length === 0) {
+            const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+            const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
+            if (otherCompanyMatch) {
+                assertQuestionCompanyAccess(otherCompanyMatch.question, otherCompanyMatch.lane, company);
+            }
+            if (allCompanyLookup.errors.length > 0) {
+                throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
+                    question_id: questionId,
+                    hosts: allCompanyLookup.errors.map(({ host, error }) => ({ host, error })),
+                });
+            }
             throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
         }
         if (matches.length > 1) {
@@ -7544,29 +7657,24 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (!owner) {
             throw new LanesError("question_not_found", `Question ${questionId} not found on this primary or its Outposts`, { question_id: questionId });
         }
-        if (!sameQuestionCompany(owner.question.company, owner.lane.company)) {
-            throw new LanesError("outpost_question_company_mismatch", `Question ${questionId} does not match its primary lane company`, { question_id: questionId, lane_id: owner.lane.lane_id });
-        }
+        assertQuestionCompanyAccess(owner.question, owner.lane, company);
+        assertQuestionCompanyResolvedForAnswer(owner.question, owner.lane);
         throwIfQuestionNotPending(owner.question);
         await yieldEventLoop();
         await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
             ...opts,
-            company: questionListCompanyArg(owner.lane.company),
+            company: questionListCompanyArg(effectiveLaneQuestionCompany(owner.lane)),
         });
         return;
     }
     await yieldEventLoop();
     const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
-    if (company &&
-        (!questionCompanyRefMatches(question.company, company) ||
-            !questionCompanyRefMatches(askingLane.company, company) ||
-            !sameQuestionCompany(question.company, askingLane.company))) {
-        throw new LanesError("question_company_mismatch", `Question ${questionId} does not belong to the requested company`, { question_id: questionId, lane_id: askingLane.lane_id });
-    }
+    assertQuestionCompanyAccess(question, askingLane, company);
+    assertQuestionCompanyResolvedForAnswer(question, askingLane);
     if (askingLane.host.kind === "outpost" && !laneIsHostedHere(ctx, askingLane)) {
         await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, {
             ...opts,
-            ...(askingLane.company ? { company: questionListCompanyArg(askingLane.company) } : {}),
+            company: questionListCompanyArg(effectiveLaneQuestionCompany(askingLane)),
         });
         return;
     }
@@ -8303,6 +8411,7 @@ async function runReconcile(ctx, opts) {
         throttleDeps: ctx.throttleDeps,
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
+        resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
         mesh: ctx.mesh,
         env: ctx.env,
     });
@@ -8383,6 +8492,13 @@ export function registerLanesCommand(parent, deps = {}) {
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
+    registerLaneChecksCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        resolveCompany: ctx.resolveCompany,
+        trackerEnabled: ctx.laneTrackerEnabled,
+        trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        now: ctx.now,
+    }, wrap);
     registerOutpostPrunerCommand(lanes);
     const noStoryOption = new Option("--no-story <reason>", "Create a lane without a story and record why");
     noStoryOption.attributeName = () => "noStory";

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

@@ -7,7 +7,7 @@
  * that resolve to the same home are refused (identity-keyed-cap rule).
  */
 import * as fs from "node:fs";
-import { type AccountConfig, type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
+import { type AccountConfig, type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig, type TrackerChecksConfig } from "./types.js";
 export declare const LANES_CONFIG_REL: string;
 export declare const DEFAULT_MAX_QUEUED = 3;
 export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
@@ -39,6 +39,7 @@ export declare const DEFAULT_TURN_START_LOST_MS: number;
 export declare const DEFAULT_SILENT_LOST_MS: number;
 /** Unanswered session questions move to the next audience after 10 minutes. */
 export declare const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS: number;
+export declare const DEFAULT_TRACKER_CHECKS: TrackerChecksConfig;
 export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
 export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;
 export declare const DEFAULT_ACCOUNT_HOMES: Record<LaneProvider, string>;

package/dist/lib/lanes/config.js

@@ -43,6 +43,15 @@ export const DEFAULT_TURN_START_LOST_MS = 2 * 60 * 60 * 1000;
 export const DEFAULT_SILENT_LOST_MS = 12 * 60 * 60 * 1000;
 /** Unanswered session questions move to the next audience after 10 minutes. */
 export const DEFAULT_SESSION_QUESTION_TIMEOUT_SECS = 10 * 60;
+export const DEFAULT_TRACKER_CHECKS = {
+    owner_question_surface_ms: 10 * 60 * 1000,
+    open_question_age_ms: 2 * 60 * 60 * 1000,
+    status_stale_ms: 90 * 60 * 1000,
+    task_list_stale_ms: 120 * 60 * 1000,
+    blocker_max_age_ms: 24 * 60 * 60 * 1000,
+    kpi_value_max_age_ms: 24 * 60 * 60 * 1000,
+    directive_ack_timeout_ms: 30 * 60 * 1000,
+};
 export const DEFAULT_LIVENESS_WINDOWS = {
     live_within_ms: DEFAULT_LIVE_WITHIN_MS,
     turn_start_lost_ms: DEFAULT_TURN_START_LOST_MS,
@@ -362,6 +371,25 @@ function parseLiveness(raw) {
         silent_lost_ms: positiveInt(obj.silent_lost_ms, "liveness.silent_lost_ms", DEFAULT_SILENT_LOST_MS),
     };
 }
+function parseTrackerChecks(raw) {
+    const tracker = raw === undefined ? {} : raw;
+    if (!isPlainObject(tracker)) {
+        throw new LanesConfigError("invalid_config", "tracker must be an object");
+    }
+    const checks = tracker.checks === undefined ? {} : tracker.checks;
+    if (!isPlainObject(checks)) {
+        throw new LanesConfigError("invalid_config", "tracker.checks must be an object");
+    }
+    return {
+        owner_question_surface_ms: positiveInt(checks.owner_question_surface_ms, "tracker.checks.owner_question_surface_ms", DEFAULT_TRACKER_CHECKS.owner_question_surface_ms),
+        open_question_age_ms: positiveInt(checks.open_question_age_ms, "tracker.checks.open_question_age_ms", DEFAULT_TRACKER_CHECKS.open_question_age_ms),
+        status_stale_ms: positiveInt(checks.status_stale_ms, "tracker.checks.status_stale_ms", DEFAULT_TRACKER_CHECKS.status_stale_ms),
+        task_list_stale_ms: positiveInt(checks.task_list_stale_ms, "tracker.checks.task_list_stale_ms", DEFAULT_TRACKER_CHECKS.task_list_stale_ms),
+        blocker_max_age_ms: positiveInt(checks.blocker_max_age_ms, "tracker.checks.blocker_max_age_ms", DEFAULT_TRACKER_CHECKS.blocker_max_age_ms),
+        kpi_value_max_age_ms: positiveInt(checks.kpi_value_max_age_ms, "tracker.checks.kpi_value_max_age_ms", DEFAULT_TRACKER_CHECKS.kpi_value_max_age_ms),
+        directive_ack_timeout_ms: positiveInt(checks.directive_ack_timeout_ms, "tracker.checks.directive_ack_timeout_ms", DEFAULT_TRACKER_CHECKS.directive_ack_timeout_ms),
+    };
+}
 export function documentedDefaultConfig(deps = defaultDeps()) {
     const providers = {};
     for (const provider of LANE_PROVIDERS) {
@@ -384,6 +412,7 @@ export function documentedDefaultConfig(deps = defaultDeps()) {
             min_available_mem_mb: DEFAULT_MIN_AVAILABLE_MEM_MB,
         },
         liveness: { ...DEFAULT_LIVENESS_WINDOWS },
+        tracker: { checks: { ...DEFAULT_TRACKER_CHECKS } },
         session_question_timeout_secs: DEFAULT_SESSION_QUESTION_TIMEOUT_SECS,
     };
 }
@@ -425,6 +454,7 @@ export function parseLanesConfig(raw, deps = defaultDeps()) {
         providers,
         throttle: parseThrottle(raw.throttle),
         liveness: parseLiveness(raw.liveness),
+        tracker: { checks: parseTrackerChecks(raw.tracker) },
         session_question_timeout_secs: positiveInt(raw.session_question_timeout_secs, "session_question_timeout_secs", DEFAULT_SESSION_QUESTION_TIMEOUT_SECS),
     };
 }

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

@@ -3,7 +3,7 @@
  * path and for envelope `decision: "ask"` ingestion. Two writers here would
  * drift on hop, origin, raised_via, body store, and routing_history.
  */
-import { type LaneEnvelope, type LaneRecord, type QuestionBodyStore, type QuestionKind, type QuestionRecord, type RaisedVia } from "./types.js";
+import { type LaneEnvelope, type LaneRecord, type LaneCompanyRef, type QuestionBodyStore, type QuestionKind, type QuestionRecord, type RaisedVia } from "./types.js";
 export interface QuestionBody {
     question: string;
     context: string;
@@ -11,8 +11,12 @@ export interface QuestionBody {
     recommended?: string;
     notes?: string;
 }
+export declare function assertQuestionBodySecretSafe(body: QuestionBody): void;
+/** Errors that make an envelope ask unsafe or impossible to persist. */
+export declare function questionRecordRefusalCode(err: unknown): "secret_text_refused" | "question_company_unavailable" | null;
 export declare function parseQuestionBodyStore(value: unknown): QuestionBodyStore;
-export declare function bodyStoreForLane(lane: Pick<LaneRecord, "company">): QuestionBodyStore;
+export declare function bodyStoreForLane(lane: Pick<LaneRecord, "company" | "mesh_company">, resolvedCompany?: LaneCompanyRef): QuestionBodyStore;
+export declare function resolveQuestionCompany(lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company">, activeCompany?: LaneCompanyRef | null): LaneCompanyRef;
 export declare function questionBodyRef(questionId: string): string;
 export declare function sha256Text(text: string): string;
 /** Tenant-store path for a question body (spec §6.2 / §10). Never the personal vault for company prose. */
@@ -28,6 +32,7 @@ export interface RaiseLaneQuestionInput {
     body: QuestionBody;
     raisedVia: RaisedVia;
     at: string;
+    activeCompany?: LaneCompanyRef | null;
     questionId?: string;
 }
 /**
@@ -43,15 +48,15 @@ export declare function raiseLaneQuestion(input: RaiseLaneQuestionInput): Questi
  */
 export declare function classifyQuestionKind(options: readonly string[]): QuestionKind | undefined;
 /** The store a lane's question bodies live in, derived from the lane and never the reverse. */
-export declare function questionBodyPathForLane(hqRoot: string, lane: Pick<LaneRecord, "company">, questionId: string): string;
+export declare function questionBodyPathForLane(hqRoot: string, lane: Pick<LaneRecord, "company" | "mesh_company">, questionId: string): string;
 /**
  * Free-text notes the operator attached with `questions answer --notes`.
  * Read from the lane's own store (spec §6.5): the company store for a company
  * lane, the personal store otherwise. Returns undefined when the answer has
- * no notes_ref or the body carries no notes; a body the host cannot read is
- * reported and skipped rather than failing the resume.
+ * no notes_ref or the body carries no notes. An unavailable or malformed body
+ * fails the resume so the lane cannot continue without its answer notes.
  */
-export declare function readAnswerNotes(hqRoot: string, lane: Pick<LaneRecord, "company">, question: Pick<QuestionRecord, "question_id" | "answer">): string | undefined;
+export declare function readAnswerNotes(hqRoot: string, lane: Pick<LaneRecord, "company" | "mesh_company">, question: Pick<QuestionRecord, "question_id" | "company" | "body" | "answer">): string | undefined;
 export interface AnsweredQuestionEntry {
     question_id: string;
     choice: string | undefined;
@@ -66,10 +71,11 @@ export interface AnsweredQuestionEntry {
  * directory on the executing host.
  */
 export declare function answeredQuestionEntries(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company">, questions: QuestionRecord[]): AnsweredQuestionEntry[];
+export declare function markAnsweredQuestionsDelivered(hqRoot: string, laneId: string, questionIds: readonly string[], deliveredAt: string): QuestionRecord[];
 export declare function envelopeQuestionId(laneId: string, envelopeRef: string, index: number): 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, questionIndexes?: readonly number[]): QuestionRecord[];
+export declare function raiseEnvelopeQuestions(hqRoot: string, lane: LaneRecord, envelope: LaneEnvelope, envelopeRef: string, at: string, questionIndexes?: readonly number[], activeCompany?: LaneCompanyRef | null): QuestionRecord[];
 //# sourceMappingURL=questions.d.ts.map