@indigoai-us/hq-cli 5.226.0 → 5.227.1

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.227.1] — 2026-09-27
+
+### Fixed
+
+- `hq files browse` and `hq files search` no longer crash on vaults with many objects.
+
+## [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/agents.js

@@ -30,6 +30,7 @@ import chalk from "chalk";
 import { randomUUID } from "node:crypto";
 import * as readline from "node:readline";
 import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
+import { maxLength } from "../utils/table-width.js";
 import { DEFAULT_VAULT_API_URL } from "../utils/cognito-session.js";
 import { gateApiKeyCapabilities } from "../utils/api-key-command-gate.js";
 import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
@@ -849,7 +850,7 @@ export function formatJobsTable(jobs) {
         j.lastRunOutcome ?? "-",
         j.status ?? "",
     ]);
-    const widths = cols.map((c, i) => Math.max(c.length, ...rows.map((r) => r[i].length)));
+    const widths = cols.map((c, i) => maxLength(rows, (row) => row[i].length, c.length));
     const render = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ");
     return [chalk.bold(render(cols)), ...rows.map(render)].join("\n");
 }

package/dist/commands/files-browse.js

@@ -44,6 +44,7 @@ import { VaultClient, } from "@indigoai-us/hq-cloud";
 import { isPrivateFolderPattern } from "./_patterns.js";
 import { DEFAULT_HQ_ROOT, DEFAULT_COGNITO, buildVaultConfig, } from "../utils/cognito-session.js";
 import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
+import { maxLength } from "../utils/table-width.js";
 import { getCompanyUid, looksLikeCompanyUid, looksLikePersonVaultUid, vaultApiFetch, } from "../utils/vault-api.js";
 import { resolveCanonicalPersonUid } from "./cloud.js";
 // ── Pure helpers ────────────────────────────────────────────────────────────
@@ -181,13 +182,14 @@ export function formatBrowseTable(rows) {
         r.lastModified ? r.lastModified.toISOString() : "—",
         displayAclSource(r.aclSource),
     ]);
-    const widths = cols.map((c, i) => Math.max(c.length, ...data.map((row) => row[i].length)));
+    const widths = cols.map((c, i) => maxLength(data, (row) => row[i].length, c.length));
     const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
     const lines = [
         chalk.bold(renderRow(cols)),
         chalk.dim(renderRow(widths.map((w) => "─".repeat(w)))),
-        ...data.map(renderRow),
     ];
+    for (const row of data)
+        lines.push(renderRow(row));
     return lines.join("\n");
 }
 /** Guard: the personal path needs an S3 factory. */
@@ -494,13 +496,14 @@ export function formatSharedWithMeTable(rows) {
         r.permission,
         r.source,
     ]);
-    const widths = cols.map((c, i) => Math.max(c.length, ...data.map((row) => row[i].length)));
+    const widths = cols.map((c, i) => maxLength(data, (row) => row[i].length, c.length));
     const renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
     const lines = [
         chalk.bold(renderRow(cols)),
         chalk.dim(renderRow(widths.map((w) => "─".repeat(w)))),
-        ...data.map(renderRow),
     ];
+    for (const row of data)
+        lines.push(renderRow(row));
     if (rows.some((row) => isPrivateFolderPattern(row.path))) {
         lines.push("Private folders expose the folder only; children are creator-only.");
     }

package/dist/commands/files.js

@@ -11,6 +11,7 @@ import { formatAccessDenied, offerAccessLadder, } from "../utils/access-denied-h
 import { fetchChannels, matchChannelsByName } from "./dm.js";
 import { resolveCompanySlug, resolvePersonWithRosterFallback, } from "./people.js";
 import { findHqRoot } from "../utils/manifest.js";
+import { maxLength } from "../utils/table-width.js";
 const PERSON_UID_PATTERN = /^(prs|agt)_[A-Za-z0-9_-]+$/;
 function collectMentions(value, previous) {
     return [...previous, value];
@@ -1227,13 +1228,15 @@ export function formatFilesVersionsTable(rows) {
         row.lastModified,
         row.isDeleteMarker ? "—" : formatBytes(row.size),
     ]);
-    const widths = cols.map((col, index) => Math.max(col.length, ...data.map((row) => row[index].length)));
+    const widths = cols.map((col, index) => maxLength(data, (row) => row[index].length, col.length));
     const renderRow = (row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ");
-    return [
+    const lines = [
         chalk.bold(renderRow(cols)),
         chalk.dim(renderRow(widths.map((width) => "─".repeat(width)))),
-        ...data.map(renderRow),
-    ].join("\n");
+    ];
+    for (const row of data)
+        lines.push(renderRow(row));
+    return lines.join("\n");
 }
 /** Render durable delete tombstones without implying the objects still exist. */
 export function formatFilesTrashTable(rows) {
@@ -1247,13 +1250,15 @@ export function formatFilesTrashTable(rows) {
         row.deletedBy,
         row.deletedPrefix,
     ]);
-    const widths = cols.map((col, index) => Math.max(col.length, ...data.map((row) => row[index].length)));
+    const widths = cols.map((col, index) => maxLength(data, (row) => row[index].length, col.length));
     const renderRow = (row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ");
-    return [
+    const lines = [
         chalk.bold(renderRow(cols)),
         chalk.dim(renderRow(widths.map((width) => "─".repeat(width)))),
-        ...data.map(renderRow),
-    ].join("\n");
+    ];
+    for (const row of data)
+        lines.push(renderRow(row));
+    return lines.join("\n");
 }
 function throwRecoveryHttpError(status, body, statusText) {
     throw new FilesRecoveryHttpError(status, body.message ?? body.error ?? statusText, body.code);

package/dist/commands/groups.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { vaultApiFetch, getCompanyUid } from "./secrets.js";
 import { GROUP_ID_PATTERN } from "./_patterns.js";
+import { maxLength } from "../utils/table-width.js";
 const EMAIL_PATTERN = /^[^\s]+@[^\s]+$/;
 const PERSON_UID_PATTERN = /^prs_[A-Za-z0-9_-]+$/;
 const AGENT_UID_PATTERN = /^agt_[A-Za-z0-9_-]+$/;
@@ -261,9 +262,9 @@ export function registerGroupsCommand(program) {
                 console.log(chalk.gray("No groups in this company yet."));
                 return;
             }
-            const idW = Math.max(8, ...data.groups.map((g) => g.groupId.length));
-            const nameW = Math.max(4, ...data.groups.map((g) => g.name.length));
-            const descW = Math.max(11, ...data.groups.map((g) => (g.description ?? "").length));
+            const idW = maxLength(data.groups, (group) => group.groupId.length, 8);
+            const nameW = maxLength(data.groups, (group) => group.name.length, 4);
+            const descW = maxLength(data.groups, (group) => (group.description ?? "").length, 11);
             console.log(chalk.bold([
                 "GROUP_ID".padEnd(idW),
                 "NAME".padEnd(nameW),
@@ -326,8 +327,8 @@ export function registerGroupsCommand(program) {
                 console.log(chalk.gray("No members yet — use 'hq groups add' to add."));
                 return;
             }
-            const uidW = Math.max(10, ...data.members.map((m) => m.personUid.length));
-            const byW = Math.max(8, ...data.members.map((m) => m.addedBy.length));
+            const uidW = maxLength(data.members, (member) => member.personUid.length, 10);
+            const byW = maxLength(data.members, (member) => member.addedBy.length, 8);
             console.log(chalk.bold([
                 "PERSON_UID".padEnd(uidW),
                 "ADDED_BY".padEnd(byW),

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;