@indigoai-us/hq-cli 5.226.0 → 5.227.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [5.227.0] — 2026-09-27
+
+### Added
+
+- `hq lanes tracker`, `checks`, `import`, and `report` use the Work Mesh tracker
+  store when `lanes.tracker-mesh` is enabled. Company questions are indexed and
+  shared across hosts; reconcile polls for remote answers, wakes the owning lane,
+  and stamps delivery once.
+
 ## [5.226.0] — 2026-09-26
 
 ### Added

package/dist/command-catalog.generated.d.ts

@@ -7069,6 +7069,9 @@ export declare const COMMAND_CATALOG: readonly [{
             }, {
                 readonly flags: "--company <slug>";
                 readonly description: "Select the company by slug";
+            }, {
+                readonly flags: "--question <id>";
+                readonly description: "Answered owner question authorizing this approval";
             }, {
                 readonly flags: "--json";
                 readonly description: "JSON on stdout (always)";
@@ -7145,6 +7148,9 @@ export declare const COMMAND_CATALOG: readonly [{
             }, {
                 readonly flags: "--company <slug>";
                 readonly description: "Select the company by slug";
+            }, {
+                readonly flags: "--question <id>";
+                readonly description: "Answered owner question authorizing this approval";
             }, {
                 readonly flags: "--json";
                 readonly description: "JSON on stdout (always)";

package/dist/command-catalog.generated.js

@@ -9137,6 +9137,10 @@ export const COMMAND_CATALOG = [
                                 "flags": "--company <slug>",
                                 "description": "Select the company by slug"
                             },
+                            {
+                                "flags": "--question <id>",
+                                "description": "Answered owner question authorizing this approval"
+                            },
                             {
                                 "flags": "--json",
                                 "description": "JSON on stdout (always)"
@@ -9235,6 +9239,10 @@ export const COMMAND_CATALOG = [
                                 "flags": "--company <slug>",
                                 "description": "Select the company by slug"
                             },
+                            {
+                                "flags": "--question <id>",
+                                "description": "Answered owner question authorizing this approval"
+                            },
                             {
                                 "flags": "--json",
                                 "description": "JSON on stdout (always)"

package/dist/commands/lanes-checks.d.ts

@@ -1,5 +1,6 @@
 import type { Command } from "commander";
 import { type TrackerKind, type TrackerRecord } from "../lib/lanes/tracker-store.js";
+import type { TrackerStore } from "../lib/lanes/tracker-store.js";
 import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
 export interface LaneChecksDeps {
     hqRoot: () => string;
@@ -7,6 +8,7 @@ export interface LaneChecksDeps {
     trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     trackerMeshEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     now: () => Date;
+    meshStore?: (company: LaneCompanyRef, projectId: string) => TrackerStore;
 }
 type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
 export interface ProjectMapping {

package/dist/commands/lanes-checks.js

@@ -5,7 +5,8 @@ import { LanesError, isLanesError } from "../lib/lanes/errors.js";
 import { evaluateTrackerChecks } from "../lib/lanes/tracker-checks.js";
 import { laneRecordPath, listLaneIds, listQuestionIds, questionRecordPath, readLane, readQuestion } from "../lib/lanes/store.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
-import { LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG } from "./lanes-tracker.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
+import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -503,16 +504,20 @@ export function listTrackerRecordsTolerant(projectDirectory, kind) {
     records.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
     return { records, errors };
 }
-function readTrackerCheckRecords(root, company, projects) {
+async function readTrackerCheckRecords(root, company, projects, deps) {
     const blockers = [];
     const kpis = [];
     const directives = [];
+    const useMesh = await deps.trackerMeshEnabled(company);
     for (const project of projects) {
         const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
+        const store = useMesh
+            ? (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(company, project.projectId)
+            : createLocalTrackerStore(absoluteDirectory);
         const records = {
-            blocker: listTrackerRecords(absoluteDirectory, "blocker"),
-            kpi: listTrackerRecords(absoluteDirectory, "kpi"),
-            directive: listTrackerRecords(absoluteDirectory, "directive"),
+            blocker: await store.list("blocker"),
+            kpi: await store.list("kpi"),
+            directive: await store.list("directive"),
         };
         for (const record of records.blocker) {
             if (record.company !== company.slug || record.project_id !== project.projectId)
@@ -564,17 +569,14 @@ export async function resolveTrackerCompany(deps, requested) {
     if (!await deps.trackerEnabled(company)) {
         fail("tracker_disabled", `hq lanes tracker commands require the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
     }
-    if (await deps.trackerMeshEnabled(company)) {
-        fail("tracker_mesh_unavailable", `Work Mesh tracker storage is not available while ${LANES_TRACKER_MESH_FLAG} is enabled`, { company: company.slug });
-    }
     return company;
 }
-function checkReport(root, company, projects, directiveProjects, projectFilter, now) {
+async function checkReport(root, company, projects, directiveProjects, projectFilter, now, deps) {
     const selectedProjects = [...projects.values()];
     const laneRecords = readScopedLanes(root, company, selectedProjects);
     const teams = readTeamInputs(root, company, selectedProjects, laneRecords);
     const questionRecords = readCompanyQuestions(root, company, projectFilter);
-    const trackerRecords = readTrackerCheckRecords(root, company, selectedProjects);
+    const trackerRecords = await readTrackerCheckRecords(root, company, selectedProjects, deps);
     const directiveTeams = [...directiveProjects.values()].map((project) => ({
         team: project.team,
         ...(project.leadLaneId === undefined ? {} : { lead_lane_id: project.leadLaneId }),
@@ -607,7 +609,7 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
         const directiveProjects = projectFilter === undefined
             ? projects
             : loadProjectMappings(root, company.slug);
-        const report = checkReport(root, company, projects, directiveProjects, projectFilter, deps.now());
+        const report = await checkReport(root, company, projects, directiveProjects, projectFilter, deps.now(), deps);
         console.log(JSON.stringify(report, null, 2));
         if (report.checks.some((item) => item.result === "failing"))
             process.exitCode = 2;

package/dist/commands/lanes-import.d.ts

@@ -9,6 +9,7 @@ export interface LaneTrackerImportDeps {
     trackerMeshEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     now: () => Date;
     store?: (projectDirectory: string) => TrackerStore;
+    meshStore?: (company: LaneCompanyRef, projectId: string) => TrackerStore;
 }
 export declare function registerLaneTrackerImportCommand(parent: Command, deps: LaneTrackerImportDeps, wrap: WrapHandler): void;
 export {};

package/dist/commands/lanes-import.js

@@ -5,7 +5,8 @@ import { isDeepStrictEqual } from "node:util";
 import { LanesError } from "../lib/lanes/errors.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLocalTrackerStore, } from "../lib/lanes/tracker-store.js";
-import { LANES_TRACKER_FLAG, LANES_TRACKER_MESH_FLAG } from "./lanes-tracker.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
+import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 const IMPORT_DATE = "2026-09-25";
 const IMPORT_KEY_PREFIX = "trk7";
 const MAX_TEXT_BYTES = 32_000;
@@ -946,7 +947,7 @@ async function executeCandidates(work, candidates, mode, company, now, kpiIds) {
     const existing = new Map();
     try {
         for (const kind of kinds)
-            existing.set(kind, work.store.list(kind));
+            existing.set(kind, await work.store.list(kind));
     }
     catch (err) {
         addTeamError(work.result, err);
@@ -997,7 +998,7 @@ async function executeCandidates(work, candidates, mode, company, now, kpiIds) {
             let record;
             let action;
             if (!current) {
-                record = work.store.create({
+                record = await work.store.create({
                     kind: candidate.kind,
                     id: importedRecordId(candidate),
                     company,
@@ -1011,7 +1012,7 @@ async function executeCandidates(work, candidates, mode, company, now, kpiIds) {
                 action = "unchanged";
             }
             else {
-                record = work.store.update(candidate.kind, current.id, current.version, (live) => ({
+                record = await work.store.update(candidate.kind, current.id, current.version, (live) => ({
                     ...live,
                     ...fields,
                     ...(candidate.kind === "kpi" ? { values: mergeImportedKpiValues(live, candidate) } : {}),
@@ -1048,7 +1049,7 @@ function statusOkrCandidates(status, statusSource, result) {
 function makeEmptyTeamResult(team) {
     return { team, status: "error", sources: { prd: null, status: null, brief: null, directives: null }, actions: [], skipped: [], errors: [], unlinked_key_results: [] };
 }
-async function prepareTeam(root, company, row, index, globalMarkdown, globalDirectivePath, deps) {
+async function prepareTeam(root, company, companyRef, useMesh, row, index, globalMarkdown, globalDirectivePath, deps) {
     const team = typeof row.team === "string" && row.team.trim() ? row.team.trim() : `unknown-${index}`;
     const result = makeEmptyTeamResult(team);
     let prdPath = "";
@@ -1097,7 +1098,9 @@ async function prepareTeam(root, company, row, index, globalMarkdown, globalDire
             addSkip(result, { kind: "okr", source_path: statusSource, reason: "no_explicit_goal_or_okr_source" });
         }
         candidates.push(...okrCandidates([...statusOkrs, ...briefOkrs], kpis, result, team));
-        const store = (deps.store ?? ((directory) => createLocalTrackerStore(directory, deps.now)))(path.dirname(prdPath));
+        const store = useMesh
+            ? (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(companyRef, resolved.projectId)
+            : deps.store?.(path.dirname(prdPath)) ?? createLocalTrackerStore(path.dirname(prdPath), deps.now);
         const importCandidates = uniqueCandidates(candidates, result);
         result.status = result.errors.length ? "imported_with_errors" : "imported";
         return { result, company, projectId: resolved.projectId, store, candidates: importCandidates };
@@ -1129,9 +1132,7 @@ export function registerLaneTrackerImportCommand(parent, deps, wrap) {
         if (!await deps.trackerEnabled(company)) {
             fail("tracker_disabled", `hq lanes import requires the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
         }
-        if (await deps.trackerMeshEnabled(company)) {
-            fail("tracker_mesh_unavailable", `hq lanes import cannot write while ${LANES_TRACKER_MESH_FLAG} is enabled`, { company: company.slug });
-        }
+        const trackerMeshEnabled = await deps.trackerMeshEnabled(company);
         const root = deps.hqRoot();
         const registryPath = resolveSourcePath(root, "workspace/lane-briefs/juniors.json", "juniors registry");
         const registry = readJsonObject(registryPath, "juniors registry");
@@ -1151,13 +1152,13 @@ export function registerLaneTrackerImportCommand(parent, deps, wrap) {
         const globalMarkdown = readText(globalPath, "operator-session-directives.md");
         const works = [];
         for (const [index, row] of selectedRows.entries()) {
-            works.push(await prepareTeam(root, company.slug, row, index, globalMarkdown, globalPath, deps));
+            works.push(await prepareTeam(root, company.slug, company, trackerMeshEnabled, row, index, globalMarkdown, globalPath, deps));
         }
         const mode = options.apply ? "apply" : "dry-run";
         const kpiIds = new Map();
         for (const work of works) {
             try {
-                for (const record of work.store.list("kpi")) {
+                for (const record of await work.store.list("kpi")) {
                     if (typeof record.import_key === "string")
                         kpiIds.set(record.import_key, record.id);
                 }

package/dist/commands/lanes-report.js

@@ -4,6 +4,7 @@ import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { questionRecordPath } from "../lib/lanes/store.js";
 import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
 import { mapSourceStoryStatus } from "../lib/mesh/story-status.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { buildTrackerOwnerReport, buildTrackerTeamPage, renderTrackerOwnerReportText, renderTrackerTeamPageText, } from "../lib/lanes/tracker-report.js";
 import { FIRST_TRACKER_REPORT_SINCE, readTrackerReportState, writeTrackerReportState, } from "../lib/lanes/tracker-report-state.js";
 import { listTrackerRecordsTolerant, loadCompanyQuestionRecords, loadProjectMappings, pathForTrackerRecord, readProject, resolveTrackerCompany, } from "./lanes-checks.js";
@@ -142,8 +143,14 @@ function currentAudience(question, sourcePath) {
         default: return fail("tracker_report_question_route_invalid", "Question current audience is unsupported", { question_id: question.question_id, path: sourcePath });
     }
 }
-function trackerRecords(root, company, project, kind, errors) {
+async function trackerRecords(root, company, project, kind, errors, deps) {
     const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
+    if (await deps.trackerMeshEnabled(company)) {
+        const store = (deps.meshStore ?? ((resolvedCompany, projectId) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId, now: deps.now })))(company, project.projectId);
+        return (await store.list(kind))
+            .filter((record) => record.company === company.slug && record.project_id === project.projectId)
+            .map((record) => ({ ...record, source_path: `work-mesh://${company.uid}/projects/${project.projectId}/tracker/${kind}/${record.id}` }));
+    }
     const loaded = listTrackerRecordsTolerant(projectDirectory, kind);
     for (const issue of loaded.errors) {
         errors.push({ path: issue.path, field: issue.field, message: issue.message, ...(issue.record_id ? { record_id: issue.record_id } : {}) });
@@ -163,7 +170,7 @@ function issueFromError(err, fallbackPath, fallbackField, ids = {}) {
         ...(typeof details.question_id === "string" ? { question_id: details.question_id } : ids.question_id ? { question_id: ids.question_id } : {}),
     };
 }
-function teamInput(root, company, project, questions, deps, errors = []) {
+async function teamInput(root, company, project, questions, deps, errors = []) {
     const projectDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
     const prdPath = path.join(projectDirectory, "prd.json");
     let prd = { stories: [], mtime: 0 };
@@ -235,19 +242,18 @@ function teamInput(root, company, project, questions, deps, errors = []) {
         stories,
         pull_requests: pullRequests,
         releases,
-        blockers: trackerRecords(root, company, project, "blocker", errors),
-        kpis: trackerRecords(root, company, project, "kpi", errors),
-        okrs: trackerRecords(root, company, project, "okr", errors),
-        directives: trackerRecords(root, company, project, "directive", errors),
+        blockers: await trackerRecords(root, company, project, "blocker", errors, deps),
+        kpis: await trackerRecords(root, company, project, "kpi", errors, deps),
+        okrs: await trackerRecords(root, company, project, "okr", errors, deps),
+        directives: await trackerRecords(root, company, project, "directive", errors, deps),
         questions: teamQuestions,
         errors,
     };
 }
-function allTeamInputs(root, company, deps) {
+async function allTeamInputs(root, company, deps) {
     const mappings = loadProjectMappings(root, company.slug);
-    return [...mappings.values()]
-        .sort((a, b) => a.team.localeCompare(b.team) || a.projectId.localeCompare(b.projectId))
-        .map((project) => {
+    const teams = [];
+    for (const project of [...mappings.values()].sort((a, b) => a.team.localeCompare(b.team) || a.projectId.localeCompare(b.projectId))) {
         const errors = [];
         let questions = [];
         try {
@@ -256,8 +262,9 @@ function allTeamInputs(root, company, deps) {
         catch (err) {
             errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", project.projectId), "questions"));
         }
-        return teamInput(root, company, project, questions, deps, errors);
-    });
+        teams.push(await teamInput(root, company, project, questions, deps, errors));
+    }
+    return teams;
 }
 function sinceForTeam(root, company) {
     return readTrackerReportState(root, company)?.last_report_at ?? FIRST_TRACKER_REPORT_SINCE;
@@ -286,7 +293,7 @@ export function registerLaneReportCommands(parent, deps, wrap) {
             generated_at: generatedAt,
             since,
             since_source: options.since !== undefined ? "explicit" : previous ? "previous_report" : "first_run",
-            teams: allTeamInputs(root, company, deps),
+            teams: await allTeamInputs(root, company, deps),
         };
         const report = buildTrackerOwnerReport(input);
         const hasErrors = report.teams.some((team) => team.errors.length > 0);
@@ -320,7 +327,7 @@ export function registerLaneReportCommands(parent, deps, wrap) {
         catch (err) {
             errors.push(issueFromError(err, path.join(root, "companies", company.slug, "projects", candidates[0].projectId), "questions"));
         }
-        const input = teamInput(root, company, candidates[0], questions, deps, errors);
+        const input = await teamInput(root, company, candidates[0], questions, deps, errors);
         const page = buildTrackerTeamPage(input, company.slug, since, generatedAt);
         if (page.errors.length > 0)
             process.exitCode = 2;

package/dist/commands/lanes-tracker.d.ts

@@ -12,6 +12,7 @@ export interface LaneTrackerCommandDeps {
     actor: () => string | null;
     /** Test seam; production uses the same local store used by the public commands. */
     store?: (projectDirectory: string) => TrackerStore;
+    meshStore?: (company: LaneCompanyRef, projectId: string) => TrackerStore;
 }
 type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
 export declare function registerLaneTrackerCommands(parent: Command, deps: LaneTrackerCommandDeps, wrap: WrapHandler): void;

package/dist/commands/lanes-tracker.js

@@ -6,6 +6,7 @@ import { LanesError } from "../lib/lanes/errors.js";
 import { resolveProjectStoryLedger } from "../lib/lanes/story-ledger.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
+import { createWorkMeshTrackerStore } from "../lib/lanes/tracker-mesh.js";
 import { peekIdToken } from "../utils/id-token.js";
 export const LANES_TRACKER_FLAG = "lanes.tracker";
 export const LANES_TRACKER_MESH_FLAG = "lanes.tracker-mesh";
@@ -72,9 +73,7 @@ async function target(deps, options) {
     if (!await deps.trackerEnabled(company)) {
         fail("tracker_disabled", "hq lanes tracker commands require the lanes.tracker flag", { company: company.slug });
     }
-    if (await deps.trackerMeshEnabled(company)) {
-        fail("tracker_mesh_unavailable", "Work Mesh tracker storage is not available in this CLI version", { company: company.slug });
-    }
+    const useMesh = await deps.trackerMeshEnabled(company);
     const project = validSegment(options.project, "project");
     const ledger = resolveProjectStoryLedger(deps.hqRoot(), project, company.slug);
     const projectCompany = readProjectCompany(ledger.path);
@@ -106,7 +105,10 @@ async function target(deps, options) {
     return {
         company,
         project,
-        store: (deps.store ?? ((dir) => createLocalTrackerStore(dir, deps.now)))(realDirectory),
+        usesMesh: useMesh,
+        store: useMesh
+            ? (deps.meshStore ?? ((resolvedCompany, resolvedProject) => createWorkMeshTrackerStore({ company: resolvedCompany, projectId: resolvedProject, now: deps.now })))(company, project)
+            : deps.store?.(realDirectory) ?? createLocalTrackerStore(realDirectory, deps.now),
     };
 }
 function requireActor(deps) {
@@ -184,8 +186,8 @@ function addProjectOptions(command) {
         .requiredOption("--project <slug>", "HQ team project slug")
         .option("--company <slug>", "Select the company by slug");
 }
-function createRecord(store, kind, company, project, fields) {
-    return store.create({ kind, id: randomUUID(), company, project_id: project, ...fields });
+async function createRecord(store, kind, company, project, fields) {
+    return await store.create({ kind, id: randomUUID(), company, project_id: project, ...fields });
 }
 export function registerLaneTrackerCommands(parent, deps, wrap) {
     const blocker = parent.command("blocker").description("Record and manage project blockers");
@@ -200,7 +202,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
             fail("tracker_input_invalid", "story must not be empty", { field: "story" });
         for (const [field, value] of [["what", options.what], ["waiting_on", options.waitingOn], ["next_step", options.nextStep]])
             checkedText(field, value);
-        const record = createRecord(store, "blocker", company.slug, project, {
+        const record = await createRecord(store, "blocker", company.slug, project, {
             story_id: options.story.trim(), what: options.what, waiting_on: options.waitingOn,
             next_step: options.nextStep, opened_at: deps.now().toISOString(), resolved_at: null, resolution: null,
         });
@@ -217,12 +219,12 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
             checkedText("waiting_on", options.waitingOn);
         if (options.nextStep !== undefined)
             checkedText("next_step", options.nextStep);
-        const current = store.read("blocker", id);
+        const current = await store.read("blocker", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker blocker record ${id} was not found`, { kind: "blocker", id });
         if (current.resolved_at !== null)
             fail("tracker_already_resolved", "Blocker is already resolved", { id });
-        const record = store.update("blocker", id, current.version, (value) => ({
+        const record = await store.update("blocker", id, current.version, (value) => ({
             ...value,
             ...(options.waitingOn === undefined ? {} : { waiting_on: options.waitingOn }),
             ...(options.nextStep === undefined ? {} : { next_step: options.nextStep }),
@@ -234,18 +236,18 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         .action(wrap(async (id, options) => {
         const { store } = await target(deps, options);
         checkedText("resolution", options.resolution);
-        const current = store.read("blocker", id);
+        const current = await store.read("blocker", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker blocker record ${id} was not found`, { kind: "blocker", id });
         if (current.resolved_at !== null)
             fail("tracker_already_resolved", "Blocker is already resolved", { id });
-        const record = store.update("blocker", id, current.version, (value) => ({ ...value, resolved_at: deps.now().toISOString(), resolution: options.resolution }));
+        const record = await store.update("blocker", id, current.version, (value) => ({ ...value, resolved_at: deps.now().toISOString(), resolution: options.resolution }));
         console.log(JSON.stringify({ ok: true, action: "blocker.resolve", record }, null, 2));
     }));
     addProjectOptions(blocker.command("list").description("List blockers")).option("--all", "Include resolved blockers")
         .action(wrap(async (options) => {
         const { store } = await target(deps, options);
-        const records = store.list("blocker").filter((record) => options.all || record.resolved_at === null);
+        const records = (await store.list("blocker")).filter((record) => options.all || record.resolved_at === null);
         console.log(JSON.stringify({ ok: true, action: "blocker.list", records }, null, 2));
     }));
     const kpi = parent.command("kpi").description("Define KPIs and record values");
@@ -262,7 +264,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         checkedText("name", options.name);
         checkedText("definition", options.definition);
         requiredText("unit", options.unit);
-        const record = createRecord(store, "kpi", company.slug, project, {
+        const record = await createRecord(store, "kpi", company.slug, project, {
             name: options.name, definition: options.definition, unit: options.unit,
             target: numberValue(options.target, "target"), direction: options.direction,
             status: "proposed", approved_by: null, approved_at: null, values: [],
@@ -278,31 +280,34 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         checkedText("source", options.source);
         const value = numberValue(options.value, "value");
         const at = options.at === undefined ? deps.now() : validTimestamp(options.at);
-        const current = store.read("kpi", id);
+        const current = await store.read("kpi", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker KPI record ${id} was not found`, { kind: "kpi", id });
         const values = current.values;
         if (!Array.isArray(values))
             fail("tracker_record_invalid", "KPI values must be an array", { id });
-        const record = store.update("kpi", id, current.version, (record) => ({ ...record, values: [...values, { at: at.toISOString(), value, source: options.source }] }));
+        const record = await store.update("kpi", id, current.version, (record) => ({ ...record, values: [...values, { at: at.toISOString(), value, source: options.source }] }));
         console.log(JSON.stringify({ ok: true, action: "kpi.record", record }, null, 2));
     }));
     addProjectOptions(kpi.command("approve").description("Approve a KPI proposal").argument("<kpi-id>", "KPI id"))
+        .option("--question <id>", "Answered owner question authorizing this approval")
         .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        const current = store.read("kpi", id);
+        const { store, usesMesh } = await target(deps, options);
+        if (usesMesh && !options.question)
+            fail("tracker_approval_question_required", "Work Mesh KPI approval requires --question <answered-owner-question-id>", { id });
+        const current = await store.read("kpi", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker KPI record ${id} was not found`, { kind: "kpi", id });
-        const record = store.update("kpi", id, current.version, (value) => {
+        const record = await store.update("kpi", id, current.version, (value) => {
             if (value.status === "approved")
                 fail("tracker_already_approved", "KPI is already approved", { id });
             return { ...value, status: "approved", approved_by: requireActor(deps), approved_at: deps.now().toISOString() };
-        });
+        }, options.question ? { approvalQuestionId: options.question } : undefined);
         console.log(JSON.stringify({ ok: true, action: "kpi.approve", record }, null, 2));
     }));
     addProjectOptions(kpi.command("list").description("List KPIs")).action(wrap(async (options) => {
         const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "kpi.list", records: store.list("kpi") }, null, 2));
+        console.log(JSON.stringify({ ok: true, action: "kpi.list", records: await store.list("kpi") }, null, 2));
     }));
     const okr = parent.command("okr").description("Set and approve OKRs");
     addProjectOptions(okr.command("set").description("Create a proposed OKR"))
@@ -319,11 +324,11 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         for (const keyResult of keyResults)
             checkedText("key_result", keyResult.text);
         for (const keyResult of keyResults) {
-            if (!store.read("kpi", keyResult.kpi_id)) {
+            if (!await store.read("kpi", keyResult.kpi_id)) {
                 fail("tracker_kpi_not_found", `Referenced KPI ${keyResult.kpi_id} was not found in this project`, { kpi_id: keyResult.kpi_id, project_id: project });
             }
         }
-        const record = createRecord(store, "okr", company.slug, project, {
+        const record = await createRecord(store, "okr", company.slug, project, {
             objective: options.objective, period: options.period,
             key_results: keyResults.map((value) => ({ kr_id: randomUUID(), ...value })),
             status: "proposed", approved_by: null, approved_at: null,
@@ -331,21 +336,24 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         console.log(JSON.stringify({ ok: true, action: "okr.set", record }, null, 2));
     }));
     addProjectOptions(okr.command("approve").description("Approve an OKR proposal").argument("<okr-id>", "OKR id"))
+        .option("--question <id>", "Answered owner question authorizing this approval")
         .action(wrap(async (id, options) => {
-        const { store } = await target(deps, options);
-        const current = store.read("okr", id);
+        const { store, usesMesh } = await target(deps, options);
+        if (usesMesh && !options.question)
+            fail("tracker_approval_question_required", "Work Mesh OKR approval requires --question <answered-owner-question-id>", { id });
+        const current = await store.read("okr", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker OKR record ${id} was not found`, { kind: "okr", id });
-        const record = store.update("okr", id, current.version, (value) => {
+        const record = await store.update("okr", id, current.version, (value) => {
             if (value.status === "approved")
                 fail("tracker_already_approved", "OKR is already approved", { id });
             return { ...value, status: "approved", approved_by: requireActor(deps), approved_at: deps.now().toISOString() };
-        });
+        }, options.question ? { approvalQuestionId: options.question } : undefined);
         console.log(JSON.stringify({ ok: true, action: "okr.approve", record }, null, 2));
     }));
     addProjectOptions(okr.command("list").description("List OKRs")).action(wrap(async (options) => {
         const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "okr.list", records: store.list("okr") }, null, 2));
+        console.log(JSON.stringify({ ok: true, action: "okr.list", records: await store.list("okr") }, null, 2));
     }));
     const directive = parent.command("directive").description("Record directives and acknowledgements");
     addProjectOptions(directive.command("record").description("Record a directive"))
@@ -373,7 +381,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         }
         if (url.protocol !== "https:" && url.protocol !== "http:")
             fail("tracker_source_url_invalid", "Source URL must use HTTP or HTTPS", {});
-        const record = createRecord(store, "directive", company.slug, project, {
+        const record = await createRecord(store, "directive", company.slug, project, {
             text: options.text, date: validDate(options.date), source_url: options.sourceUrl,
             teams: [...new Set(teams)].sort(), policy_path: policyPath, acknowledgements: [],
         });
@@ -386,7 +394,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
         const { store } = await target(deps, options);
         const team = validSegment(options.team, "team");
         const lane = validSegment(options.lane, "lane");
-        const current = store.read("directive", id);
+        const current = await store.read("directive", id);
         if (!current)
             fail("tracker_record_not_found", `Tracker directive record ${id} was not found`, { kind: "directive", id });
         const teams = current.teams;
@@ -395,7 +403,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
             fail("tracker_team_not_targeted", "Team is not listed on this directive", { id, team });
         if (!Array.isArray(acknowledgements))
             fail("tracker_record_invalid", "Directive acknowledgements must be an array", { id });
-        const record = store.update("directive", id, current.version, (value) => ({
+        const record = await store.update("directive", id, current.version, (value) => ({
             ...value,
             acknowledgements: [...acknowledgements.filter((ack) => !(ack && typeof ack === "object" && ack.team === team && ack.lane_id === lane)), { team, lane_id: lane, at: deps.now().toISOString() }],
         }));
@@ -403,7 +411,7 @@ export function registerLaneTrackerCommands(parent, deps, wrap) {
     }));
     addProjectOptions(directive.command("list").description("List directives")).action(wrap(async (options) => {
         const { store } = await target(deps, options);
-        console.log(JSON.stringify({ ok: true, action: "directive.list", records: store.list("directive") }, null, 2));
+        console.log(JSON.stringify({ ok: true, action: "directive.list", records: await store.list("directive") }, null, 2));
     }));
 }
 export function defaultTrackerActor() {

package/dist/commands/lanes.d.ts

@@ -6,6 +6,7 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
+import { type TrackerMeshRequest } from "../lib/lanes/tracker-mesh.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -102,6 +103,8 @@ export interface LanesCommandDeps {
     laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** The local-only PR 2 implementation refuses if mesh storage is enabled. */
     laneTrackerMeshEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    /** Fake transport seam used by the disposable-root Work Mesh contract check. */
+    trackerMeshRequest?: TrackerMeshRequest;
     /** Test seam for the default-off host-scoped account-home writer gate. */
     laneHostScopedAccountHomesEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
     /** Test seam for recording approvals against the active identity. */