@indigoai-us/hq-cli 5.226.0 → 5.227.1

package/dist/commands/lanes.js

@@ -17,6 +17,8 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { createTrackerMeshQuestionClient, deliverTrackerMeshQuestionOnce } from "../lib/lanes/tracker-mesh-questions.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
@@ -44,7 +46,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, LEAD_LANE_KEEP_ALIVE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
-import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
+import { questionBodyAbsPath, questionRecordRefusalCode, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
@@ -327,6 +329,7 @@ function resolveDeps(deps = {}) {
             ((company) => defaultLaneOutpostQuestionVisibilityEnabled(company, env)),
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
         laneTrackerMeshEnabled: deps.laneTrackerMeshEnabled ?? defaultLaneTrackerMeshEnabled,
+        trackerMeshRequest: deps.trackerMeshRequest,
         laneHostScopedAccountHomesEnabled: deps.laneHostScopedAccountHomesEnabled ??
             ((company) => defaultLaneHostScopedAccountHomesEnabled(company, env)),
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
@@ -516,6 +519,167 @@ function requireQuestionBody(hqRoot, question) {
     }
     return body;
 }
+function trackerMeshAudience(ref) {
+    if (ref.kind === "user")
+        return "owner";
+    if (ref.kind === "session")
+        return "operator";
+    return `lane:${ref.id ?? ""}`;
+}
+function trackerMeshAudienceKind(value) {
+    if (value === "owner" || value.startsWith("owner:"))
+        return "owner";
+    if (value === "operator" || value.startsWith("operator:"))
+        return "operator";
+    return "lane";
+}
+function trackerMeshQuestionInput(lane, question, body) {
+    if (!lane.project_id.trim())
+        throw new LanesError("tracker_mesh_question_invalid", "Question lane has no project id", { lane_id: lane.lane_id });
+    const route = question.routing_history;
+    const currentAudience = route.at(-1)?.audience ?? lane.senior;
+    return {
+        laneId: lane.lane_id,
+        ...(lane.thread_id ? { threadId: lane.thread_id } : {}),
+        projectId: lane.project_id,
+        audience: trackerMeshAudienceKind(trackerMeshAudience(currentAudience)),
+        audienceChain: route.length ? route.map((entry) => trackerMeshAudience(entry.audience)) : [trackerMeshAudience(currentAudience)],
+        routingHistory: route.map((entry) => ({ audience: trackerMeshAudience(entry.audience), at: entry.at, reason: entry.reason })),
+        question: body.question,
+        context: body.context,
+        options: body.options,
+        ...(body.recommended !== undefined ? { recommended: body.recommended } : {}),
+    };
+}
+function assertMeshQuestionMatchesLocal(row, question, company) {
+    if (row.companyUid !== company.uid || row.laneId !== question.lane_id || row.projectId !== question.project_id) {
+        throw new LanesError("tracker_question_company_mismatch", "Work Mesh question does not match the local lane company and project", {
+            question_id: question.question_id,
+            mesh_question_id: row.questionId,
+            lane_id: question.lane_id,
+        });
+    }
+}
+async function indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest })) {
+    if (question.mesh_question_id)
+        return question;
+    if (question.status !== "pending")
+        return question;
+    const input = trackerMeshQuestionInput(lane, question, body);
+    const candidates = (await client.list(["pending", "answered"])).filter((row) => row.laneId === input.laneId && row.projectId === input.projectId && row.threadId === (input.threadId ?? row.threadId) &&
+        row.audience === input.audience && row.question === input.question && row.context === input.context &&
+        JSON.stringify(row.options) === JSON.stringify(input.options) &&
+        row.routingHistory.at(-1)?.at === input.routingHistory.at(-1)?.at);
+    if (candidates.length > 1) {
+        throw new LanesError("tracker_mesh_question_ambiguous", "More than one pending Work Mesh question matches this local question", { question_id: question.question_id, lane_id: lane.lane_id });
+    }
+    const row = candidates[0] ?? await client.create(input);
+    assertMeshQuestionMatchesLocal(row, question, company);
+    return casUpdateQuestion(hqRoot, question.question_id, (current) => {
+        if (current.status !== "pending")
+            return current;
+        if (current.mesh_question_id && current.mesh_question_id !== row.questionId) {
+            throw new LanesError("tracker_mesh_question_conflict", "Local question was already linked to another Work Mesh question", { question_id: current.question_id });
+        }
+        return current.mesh_question_id === row.questionId ? current : { ...current, mesh_question_id: row.questionId };
+    });
+}
+async function syncTrackerMeshQuestions(ctx, hqRoot) {
+    if (!ctx.laneTrackerMeshEnabled)
+        return;
+    const lanes = new Map(loadAllLanes(hqRoot).map((lane) => [lane.lane_id, lane]));
+    const byCompany = new Map();
+    for (const lane of lanes.values()) {
+        let company;
+        try {
+            company = await resolveQuestionCompanyWithFallback(hqRoot, lane, () => resolveActiveQuestionCompany(ctx, "Cannot sync lane questions without an HQ company"));
+        }
+        catch (err) {
+            if (lane.company || lane.mesh_company ||
+                !isLanesError(err) || err.error !== "question_company_unavailable" ||
+                err.details.resolution !== "active_company_required")
+                throw err;
+            continue;
+        }
+        if (!await ctx.laneTrackerMeshEnabled(company))
+            continue;
+        const key = `${company.uid}\0${company.slug}`;
+        if (!byCompany.has(key))
+            byCompany.set(key, { company, client: createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }) });
+    }
+    const localQuestions = loadAllQuestions(hqRoot);
+    for (const question of localQuestions) {
+        if (question.status !== "pending" || question.mesh_question_id)
+            continue;
+        const lane = lanes.get(question.lane_id);
+        if (!lane)
+            continue;
+        const company = question.company ?? lane.company ?? lane.mesh_company;
+        if (!company)
+            continue;
+        const client = byCompany.get(`${company.uid}\0${company.slug}`)?.client;
+        if (!client)
+            continue;
+        const body = requireQuestionBody(hqRoot, question);
+        await indexTrackerQuestion(ctx, hqRoot, lane, question, body, company, client);
+    }
+    for (const { company, client } of byCompany.values()) {
+        const remote = await client.list(["answered"]);
+        const remoteById = new Map(remote.map((row) => [row.questionId, row]));
+        for (const question of loadAllQuestions(hqRoot)) {
+            if (!question.mesh_question_id || question.company?.uid !== company.uid)
+                continue;
+            const row = remoteById.get(question.mesh_question_id);
+            if (!row)
+                continue;
+            assertMeshQuestionMatchesLocal(row, question, company);
+            const lane = lanes.get(question.lane_id);
+            if (!lane)
+                continue;
+            if (row.status === "answered" && question.status === "pending") {
+                if (typeof row.choice !== "string" || typeof row.answeredAt !== "string" || typeof row.answeredBy !== "string") {
+                    throw new LanesError("tracker_mesh_response_invalid", "Answered Work Mesh question is missing its answer fields", { mesh_question_id: row.questionId });
+                }
+                const currentBody = requireQuestionBody(hqRoot, question);
+                let notesRef;
+                let nextBody = question.body;
+                if (row.notes !== undefined) {
+                    const bodyQuestion = question.company || question.body.store === "personal" ? question : { ...question, company };
+                    const stored = writeQuestionBody(hqRoot, bodyQuestion, { ...currentBody, notes: row.notes });
+                    notesRef = stored.ref;
+                    nextBody = stored;
+                }
+                casUpdateQuestion(hqRoot, question.question_id, (current) => {
+                    if (current.status !== "pending")
+                        return current;
+                    if (current.mesh_question_id !== row.questionId)
+                        throw new LanesError("tracker_mesh_question_conflict", "Local question link changed during answer sync", { question_id: current.question_id });
+                    return {
+                        ...current,
+                        company: current.company ?? company,
+                        body: nextBody,
+                        status: "answered",
+                        answer: {
+                            choice: row.choice,
+                            answer_kind: currentBody.options.includes(row.choice) ? "option" : "freeform",
+                            notes_ref: notesRef,
+                            answered_by: row.answeredBy,
+                            answered_at: row.answeredAt,
+                            answered_level: current.hop,
+                        },
+                    };
+                });
+            }
+        }
+        for (const question of loadAllQuestions(hqRoot)) {
+            if (question.company?.uid !== company.uid || !question.mesh_question_id)
+                continue;
+            await deliverTrackerMeshQuestionOnce(question, company, client, (deliveredAt) => casUpdateQuestion(hqRoot, question.question_id, (current) => current.mesh_delivered_at
+                ? current
+                : { ...current, mesh_delivered_at: deliveredAt }));
+        }
+    }
+}
 function loadAllLanes(hqRoot) {
     return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
 }
@@ -7396,7 +7560,7 @@ async function runAsk(ctx, opts) {
     const attempts = ASK_ATTEMPTS;
     for (let i = 0; i < attempts; i += 1) {
         try {
-            const withBody = raiseLaneQuestion({
+            let withBody = raiseLaneQuestion({
                 hqRoot,
                 lane,
                 body,
@@ -7406,6 +7570,9 @@ async function runAsk(ctx, opts) {
                 questionId,
             });
             questionId = withBody.question_id;
+            if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
+                withBody = await indexTrackerQuestion(ctx, hqRoot, lane, withBody, body, questionCompany);
+            }
             await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question", {
                 lane_id: lane.lane_id,
                 question_id: withBody.question_id,
@@ -7792,18 +7959,28 @@ async function runQuestionsList(ctx, opts) {
     const outpostLoad = opts.allHosts
         ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
         : { questions: [], errors: [] };
+    const meshRows = await ctx.laneTrackerMeshEnabled(company) && status !== "expired"
+        ? await createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest }).list(status ? [status] : undefined)
+        : [];
     for (const owner of outpostLoad.questions) {
         assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
         syncPrimaryQuestionDelivery(hqRoot, owner);
     }
     const remoteQuestionIds = new Set(outpostLoad.questions.map(({ question }) => question.question_id));
+    const localMeshQuestionIds = new Set(localQuestions.map((question) => question.mesh_question_id).filter((id) => Boolean(id)));
     const questions = [
         ...localQuestions
             .filter((q) => !remoteQuestionIds.has(q.question_id))
             .map((q) => {
+            const meshRow = q.mesh_question_id ? meshRows.find((row) => row.questionId === q.mesh_question_id) : undefined;
             const row = {
                 ...q,
                 audience: resolveAudience(hqRoot, q, ctx),
+                ...(meshRow ? {
+                    mesh_question_id: meshRow.questionId,
+                    body_preview: { question: meshRow.question, context: meshRow.context ?? "", options: meshRow.options, ...(meshRow.recommended ? { recommended: meshRow.recommended } : {}) },
+                    host: `${meshRow.host.kind}:${meshRow.host.id}`,
+                } : {}),
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
             };
             if (!opts.allHosts)
@@ -7835,6 +8012,50 @@ async function runQuestionsList(ctx, opts) {
             audience,
             ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
         })),
+        ...meshRows
+            .filter((row) => {
+            if (localMeshQuestionIds.has(row.questionId))
+                return false;
+            if (status && row.status !== status)
+                return false;
+            if (opts.from && row.laneId !== opts.from)
+                return false;
+            if (opts.project && row.projectId !== opts.project)
+                return false;
+            if (opts.story) {
+                const lane = localLanes.get(row.laneId);
+                if (!lane || lane.story_id !== opts.story)
+                    return false;
+            }
+            const audience = row.audience === "owner"
+                ? { kind: "user" }
+                : row.audience === "operator"
+                    ? { kind: "session", id: "mesh" }
+                    : { kind: "lane", id: row.laneId };
+            if (forFilter && !audienceMatches(audience, forFilter))
+                return false;
+            return true;
+        })
+            .map((row) => ({
+            question_id: row.questionId,
+            mesh_question_id: row.questionId,
+            lane_id: row.laneId,
+            company,
+            project_id: row.projectId,
+            story_id: localLanes.get(row.laneId)?.story_id ?? "",
+            ...(row.threadId ? { thread_id: row.threadId } : {}),
+            asked_at: row.askedAt,
+            origin: { kind: "lane", id: row.laneId },
+            hop: row.routingHistory.length || 1,
+            status: row.status,
+            audience: row.audience,
+            host: `${row.host.kind}:${row.host.id}`,
+            question: row.question,
+            context: row.context ?? "",
+            options: row.options,
+            ...(row.recommended ? { recommended: row.recommended } : {}),
+            ...(row.choice !== undefined ? { answer: { choice: row.choice, answered_by: row.answeredBy, answered_at: row.answeredAt, notes: row.notes } } : {}),
+        })),
     ];
     printJson({
         ok: true,
@@ -7852,6 +8073,43 @@ async function runQuestionsShow(ctx, questionId) {
     catch (err) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
+        let meshCompany = null;
+        try {
+            meshCompany = await resolveActiveQuestionCompany(ctx, "Cannot look up Work Mesh question without an active company");
+        }
+        catch (companyError) {
+            if (questionRecordRefusalCode(companyError) !== "question_company_unavailable")
+                throw companyError;
+            // The Outpost lookup below remains available to unscoped primary hosts.
+        }
+        if (meshCompany && await ctx.laneTrackerMeshEnabled(meshCompany)) {
+            const rows = await createTrackerMeshQuestionClient({ company: meshCompany, request: ctx.trackerMeshRequest }).list();
+            const matches = rows.filter((row) => row.questionId === questionId);
+            if (matches.length > 1)
+                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
+            const row = matches[0];
+            if (row) {
+                printJson({
+                    ok: true,
+                    action: "questions.show",
+                    question: {
+                        question_id: row.questionId,
+                        mesh_question_id: row.questionId,
+                        lane_id: row.laneId,
+                        company: meshCompany,
+                        project_id: row.projectId,
+                        thread_id: row.threadId,
+                        asked_at: row.askedAt,
+                        status: row.status,
+                        audience: row.audience,
+                        host: `${row.host.kind}:${row.host.id}`,
+                    },
+                    audience: row.audience,
+                    body: { question: row.question, context: row.context ?? "", options: row.options, ...(row.recommended ? { recommended: row.recommended } : {}), ...(row.notes ? { notes: row.notes } : {}) },
+                });
+                return;
+            }
+        }
         const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
         if (lookup.errors.length > 0) {
             throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -7907,6 +8165,42 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (!isLanesError(err) || err.error !== "question_not_found")
             throw err;
         const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
+        if (await ctx.laneTrackerMeshEnabled(company)) {
+            const client = createTrackerMeshQuestionClient({ company, request: ctx.trackerMeshRequest });
+            const matches = (await client.list(["pending", "answered"])).filter((row) => row.questionId === questionId);
+            if (matches.length > 1)
+                throw new LanesError("tracker_mesh_question_ambiguous", `Work Mesh question ${questionId} is duplicated in the company inbox`, { question_id: questionId });
+            const row = matches[0];
+            if (row) {
+                if (row.status !== "pending")
+                    throw new LanesError("question_not_pending", `Question ${questionId} is ${row.status}`, { question_id: questionId, status: row.status });
+                const freeform = opts.freeform?.trim() || undefined;
+                if (freeform !== undefined && row.options.length === 0)
+                    throw new LanesError("freeform_not_allowed", "--freeform is only allowed for a question with options", { question_id: questionId });
+                if (!freeform && !opts.choice)
+                    throw new LanesError("missing_choice", "--choice or --freeform is required", {});
+                const choice = freeform ?? resolveAnswerChoice(opts.choice, row.options, false);
+                const answer = await client.answer(questionId, choice, opts.notes);
+                printJson({
+                    ok: true,
+                    action: "questions.answer",
+                    lane_id: answer.laneId,
+                    question: {
+                        question_id: answer.questionId,
+                        mesh_question_id: answer.questionId,
+                        lane_id: answer.laneId,
+                        project_id: answer.projectId,
+                        status: answer.status,
+                        choice: answer.choice,
+                        answered_by: answer.answeredBy,
+                        answered_at: answer.answeredAt,
+                        delivered_at: answer.deliveredAt ?? null,
+                    },
+                    delivery: "awaiting_host_poll",
+                });
+                return;
+            }
+        }
         const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
         if (lookup.errors.length > 0) {
             throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -7982,6 +8276,22 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         throw new LanesError("missing_choice", "--choice or --freeform is required", {});
     }
     const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
+    let remoteAnswer;
+    let meshQuestionId = question.mesh_question_id;
+    if (await ctx.laneTrackerMeshEnabled(questionCompany)) {
+        const client = createTrackerMeshQuestionClient({ company: questionCompany, request: ctx.trackerMeshRequest });
+        if (!meshQuestionId) {
+            const indexed = await indexTrackerQuestion(ctx, hqRoot, askingLane, question, body, questionCompany, client);
+            meshQuestionId = indexed.mesh_question_id;
+        }
+        if (!meshQuestionId)
+            throw new LanesError("tracker_mesh_question_link_missing", "Work Mesh question could not be linked before answering", { question_id: question.question_id });
+        remoteAnswer = await client.answer(meshQuestionId, choice, opts.notes);
+        assertMeshQuestionMatchesLocal(remoteAnswer, question, questionCompany);
+        if (remoteAnswer.status !== "answered" || remoteAnswer.choice !== choice) {
+            throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not record the requested question answer", { mesh_question_id: meshQuestionId });
+        }
+    }
     const at = ctx.now().toISOString();
     const answeredBy = sessionIdFromEnv(ctx.env)
         ? `session:${sessionIdFromEnv(ctx.env)}`
@@ -8016,6 +8326,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
                 answered_at: at,
                 answered_level: current.hop,
             },
+            ...(meshQuestionId ? { mesh_question_id: meshQuestionId } : {}),
         };
     });
     const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
@@ -8050,6 +8361,8 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
         if (wake.status === "failed") {
             throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${wake.error}`, { lane_id: askingLane.lane_id, question_id: questionId, wake_error: wake.error });
         }
+        if (remoteAnswer)
+            await syncTrackerMeshQuestions(ctx, hqRoot);
         printJson({
             ok: true,
             action: "questions.answer",
@@ -8709,6 +9022,7 @@ async function runReconcile(ctx, opts) {
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
         resolveQuestionActiveCompany: () => resolveActiveQuestionCompany(ctx),
+        syncTrackerQuestions: (root) => syncTrackerMeshQuestions(ctx, root),
         recoverQueuedMessages: async (lane) => {
             await recoverQueuedMessages(ctx, lane.lane_id);
         },
@@ -8789,6 +9103,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         actor: ctx.trackerActor,
     }, wrap);
@@ -8797,6 +9112,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneChecksCommand(lanes, {
@@ -8804,6 +9120,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
     }, wrap);
     registerLaneReportCommands(lanes, {
@@ -8811,6 +9128,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         trackerEnabled: ctx.laneTrackerEnabled,
         trackerMeshEnabled: ctx.laneTrackerMeshEnabled,
+        meshStore: (company, projectId) => createWorkMeshTrackerStore({ company, projectId, request: ctx.trackerMeshRequest, now: ctx.now }),
         now: ctx.now,
         readQuestionBody: (root, question) => {
             const body = requireQuestionBody(root, question);

package/dist/lib/checkpoint-ontology/plan.d.ts

@@ -11,7 +11,6 @@ import { type CompanyBriefResult } from "./company-brief.js";
 import { type OntologyCompany } from "./company.js";
 import { type MultiWriterStart } from "./multi-writer.js";
 export declare const ONTOLOGY_FLAG = "checkpoint.ontology";
-export declare const SHARED_INPUTS_FLAG = "checkpoint.ontology.shared-inputs";
 export declare const COMPANY_BRIEF_FLAG = "checkpoint.ontology.company-brief";
 /**
  * Applies only when the payload's sibling backend is grok. On gold-v2, Claude
@@ -43,7 +42,7 @@ export declare const BUDGET: {
     readonly maxTokens: 60000;
     readonly chunkTokens: 12000;
 };
-export type PendingReason = "session-touched" | "shared" | "first-run-gap" | "missing-refs";
+export type PendingReason = "session-touched";
 export interface LedgerEntry {
     sha256: string;
     size: number;
@@ -89,7 +88,6 @@ export interface OntologyPlan {
     created_at: string;
     first_run: boolean;
     boundary: string | null;
-    shared_inputs: boolean;
     /** Present only when `checkpoint.ontology.company-brief` was on for this plan. */
     company_brief?: {
         status: CompanyBriefResult["status"];
@@ -152,10 +150,10 @@ export declare function sessionTouched(hqRoot: string, company: OntologyCompany,
 export declare function chunkLines(content: string, chunkTokens: number): Array<[number, number]>;
 /**
  * Update the ledger with the current tree and return it. New or changed files
- * become pending when this machine should process them (design 14.1) and
- * seen otherwise. The first run seeds from the entity boundary (design 14.3).
+ * the session touched become pending; others are recorded as seen. The first
+ * run records the entity boundary (design 14.3).
  */
-export declare function refreshLedger(company: OntologyCompany, existing: Ledger | null, touched: Set<string>, sharedInputs: boolean): {
+export declare function refreshLedger(company: OntologyCompany, existing: Ledger | null, touched: Set<string>): {
     ledger: Ledger;
     firstRun: boolean;
 };

package/dist/lib/checkpoint-ontology/plan.js

@@ -15,7 +15,6 @@ import { resolveOntologyCompany, safeWriteFile, stateRoot } from "./company.js";
 import { startMultiWriterRun } from "./multi-writer.js";
 import { buildEntityIndex, listKnowledgeFiles, listSignalFiles, readSignal } from "./tree.js";
 export const ONTOLOGY_FLAG = "checkpoint.ontology";
-export const SHARED_INPUTS_FLAG = "checkpoint.ontology.shared-inputs";
 export const COMPANY_BRIEF_FLAG = "checkpoint.ontology.company-brief";
 /**
  * Applies only when the payload's sibling backend is grok. On gold-v2, Claude
@@ -163,14 +162,13 @@ function missingRefs(companyDir, rel) {
 }
 /**
  * Update the ledger with the current tree and return it. New or changed files
- * become pending when this machine should process them (design 14.1) and
- * seen otherwise. The first run seeds from the entity boundary (design 14.3).
+ * the session touched become pending; others are recorded as seen. The first
+ * run records the entity boundary (design 14.3).
  */
-export function refreshLedger(company, existing, touched, sharedInputs) {
+export function refreshLedger(company, existing, touched) {
     const firstRun = existing === null;
     const index = firstRun ? buildEntityIndex(company.dir) : null;
     const boundary = existing ? existing.boundary : entityBoundary(index);
-    const boundaryMs = boundary ? Date.parse(boundary) : Number.NaN;
     const entries = {};
     const files = [...listKnowledgeFiles(company.dir), ...listSignalFiles(company.dir)];
     for (const rel of files) {
@@ -188,24 +186,10 @@ export function refreshLedger(company, existing, touched, sharedInputs) {
                 : { ...previous, ...base };
             continue;
         }
-        let reason = null;
-        if (touched.has(rel))
-            reason = "session-touched";
-        else if (sharedInputs && firstRun) {
-            if (Number.isFinite(boundaryMs) && stat.mtimeMs > boundaryMs)
-                reason = "first-run-gap";
-            else if (rel.startsWith("signals/") && missingRefs(company.dir, rel).length > 0)
-                reason = "missing-refs";
-        }
-        else if (sharedInputs)
-            reason = "shared";
-        entries[rel] = reason ? { ...base, state: "pending", reason } : { ...base, state: "seen" };
+        entries[rel] = touched.has(rel) ? { ...base, state: "pending", reason: "session-touched" } : { ...base, state: "seen" };
     }
     return { ledger: { schema: LEDGER_SCHEMA, company: company.slug, boundary, entries }, firstRun };
 }
-function reasonRank(reason) {
-    return reason === "session-touched" ? 0 : 1;
-}
 /** Plan this run. Never throws for a skip; returns the reason instead. */
 export async function planOntologyRun(options) {
     const { hqRoot, runDir, payload } = options;
@@ -218,7 +202,6 @@ export async function planOntologyRun(options) {
         fs.rmSync(backendPreferencePath(hqRoot, company), { force: true });
         return { status: "skipped", reason: "flag off" };
     }
-    const sharedInputs = await options.readFlag(SHARED_INPUTS_FLAG, company);
     const briefOn = await options.readFlag(COMPANY_BRIEF_FLAG, company);
     const ignoreAnnotations = (await options.readFlag(IGNORE_ANNOTATIONS_FLAG, company)) && payload.backend === "grok";
     recordBackendPreference(hqRoot, company, await options.readFlag(GROK_BACKEND_FLAG, company));
@@ -226,15 +209,15 @@ export async function planOntologyRun(options) {
     const touched = sessionTouched(hqRoot, company, payload.files);
     // A first run takes its boundary from the entity tree, so the ledger is
     // refreshed before merge-back moves any `last_updated` forward.
-    const { ledger, firstRun } = refreshLedger(company, readLedger(hqRoot, company), touched, sharedInputs);
+    const { ledger, firstRun } = refreshLedger(company, readLedger(hqRoot, company), touched);
     // Merge-back and the brief come before the nothing-changed return, so such
     // a plan still merges set-aside versions and records the brief; the brief
     // follows merge-back so its counts include merged entities.
     const multiWriter = multiWriterOn ? startMultiWriterRun(hqRoot, company, options.now ?? new Date()) : undefined;
     const companyBrief = briefOn ? writeCompanyBrief(hqRoot, company, options.now ?? new Date()) : undefined;
     const pending = Object.entries(ledger.entries)
-        .filter(([, entry]) => entry.state === "pending" && (sharedInputs || entry.reason === "session-touched"))
-        .sort(([aRel, a], [bRel, b]) => reasonRank(a.reason) - reasonRank(b.reason) || a.mtime_ms - b.mtime_ms || aRel.localeCompare(bRel));
+        .filter(([, entry]) => entry.state === "pending" && entry.reason === "session-touched")
+        .sort(([aRel, a], [bRel, b]) => a.mtime_ms - b.mtime_ms || aRel.localeCompare(bRel));
     const inputs = [];
     let tokens = 0;
     let remaining = 0;
@@ -264,7 +247,7 @@ export async function planOntologyRun(options) {
                 kind,
                 path: rel,
                 audience: "company",
-                reason: entry.reason ?? "shared",
+                reason: "session-touched",
                 sha256: entry.sha256,
                 est_tokens: cost,
                 lines: chunks.length > 1 ? [start, end] : null,
@@ -313,7 +296,6 @@ export async function planOntologyRun(options) {
         created_at: (options.now ?? new Date()).toISOString(),
         first_run: firstRun,
         boundary: ledger.boundary,
-        shared_inputs: sharedInputs,
         ...(companyBrief
             ? {
                 company_brief: companyBrief.reason

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

@@ -81,6 +81,8 @@ export interface ReconcileDeps {
     readRegistryFlag?: typeof readLanesRegistryFlag;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
+    /** Index local questions and poll remote answers before the normal answer-wake pass. */
+    syncTrackerQuestions?: (hqRoot: string) => Promise<void>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */
     recoverQueuedMessages?: (lane: LaneRecord) => Promise<void>;
     /** Detached mesh seam for dead-watcher recovery. */

package/dist/lib/lanes/reconcile.js

@@ -632,6 +632,14 @@ export async function runPassBody(hqRoot, deps) {
     const livenessDeps = deps.livenessDeps ?? defaultLivenessDeps();
     let lanes;
     let questions;
+    if (!deps.dryRun) {
+        try {
+            await deps.syncTrackerQuestions?.(hqRoot);
+        }
+        catch (err) {
+            markError(summary, err);
+        }
+    }
     try {
         lanes = loadLaneRecords(hqRoot, summary);
         questions = loadQuestionRecords(hqRoot, summary);
@@ -845,6 +853,14 @@ export async function runPassBody(hqRoot, deps) {
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
+    if (!deps.dryRun && deps.syncTrackerQuestions) {
+        try {
+            await deps.syncTrackerQuestions(hqRoot);
+        }
+        catch (err) {
+            markError(summary, err);
+        }
+    }
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
             writeHeartbeatFile(hqRoot, summary, nowIso);

package/dist/lib/lanes/store.js

@@ -708,7 +708,15 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
-    return { ...raw, delivered_at };
+    const mesh_question_id = raw.mesh_question_id;
+    if (mesh_question_id !== undefined && (typeof mesh_question_id !== "string" || !mesh_question_id.trim())) {
+        throw new LaneSchemaError("mesh_question_id must be a non-empty string when present", { path: filePath, value: mesh_question_id });
+    }
+    const mesh_delivered_at = raw.mesh_delivered_at === undefined ? null : raw.mesh_delivered_at;
+    if (mesh_delivered_at !== null && (typeof mesh_delivered_at !== "string" || !Number.isFinite(Date.parse(mesh_delivered_at)))) {
+        throw new LaneSchemaError("mesh_delivered_at must be a valid timestamp or null", { path: filePath, value: mesh_delivered_at });
+    }
+    return { ...raw, delivered_at, mesh_delivered_at };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`: