@indigoai-us/hq-cli 5.217.0 → 5.219.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [5.219.0] — 2026-09-26
+
+### Added
+
+- `hq lanes checks` reports six company-scoped tracker checks, prints the
+  records that need attention, and exits with status 2 when any check fails.
+  Input errors return a path-bearing error envelope with status 1. Teams come
+  from `juniors.json` mappings or projects with blocker, KPI, OKR, or directive
+  tracker records, so unrelated project PRDs are not read. Thresholds can be
+  adjusted in `personal/lanes/config.json`.
+
+### Fixed
+
+- `hq lanes` questions now record their company and `delivered_at` when a lane
+  receives an answer. Secret-shaped question text and answer notes are rejected
+  before storage. Existing questions without a company remain readable.
+
+- Legacy personal-store answer notes continue to load from personal storage
+  after their lane gains mesh-company attribution.
+
+## [5.218.0] — 2026-09-26
+
+### Fixed
+
+- The reconcile summary now lists opted-in lanes it could not resume and why.
+  Stderr provides reason-specific guidance and recommends reapplying opt-in only
+  when that can help.
+
 ## [5.217.0] — 2026-09-26
 
 ### Fixed

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

@@ -7239,6 +7239,24 @@ export declare const COMMAND_CATALOG: readonly [{
             }];
             readonly subcommands: readonly [];
         }];
+    }, {
+        readonly name: "checks";
+        readonly description: "Evaluate tracker and lane health checks";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly usage: "[options]";
+        readonly arguments: readonly [];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Select the company by slug";
+        }, {
+            readonly flags: "--project <slug>";
+            readonly description: "Limit checks to one company project";
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "outpost-pruner";
         readonly description: "Inspect, install, and run safe outpost worktree pruning";

package/dist/command-catalog.generated.js

@@ -9358,6 +9358,29 @@ export const COMMAND_CATALOG = [
                     }
                 ]
             },
+            {
+                "name": "checks",
+                "description": "Evaluate tracker and lane health checks",
+                "aliases": [],
+                "hidden": false,
+                "usage": "[options]",
+                "arguments": [],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Select the company by slug"
+                    },
+                    {
+                        "flags": "--project <slug>",
+                        "description": "Limit checks to one company project"
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)"
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "outpost-pruner",
                 "description": "Inspect, install, and run safe outpost worktree pruning",

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

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import type { LaneCompanyRef } from "../lib/lanes/types.js";
+interface LaneChecksDeps {
+    hqRoot: () => string;
+    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
+    trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    trackerMeshEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    now: () => Date;
+}
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export declare function registerLaneChecksCommand(parent: Command, deps: LaneChecksDeps, wrap: WrapHandler): void;
+export {};
+//# sourceMappingURL=lanes-checks.d.ts.map

package/dist/commands/lanes-checks.js

@@ -0,0 +1,558 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadLanesConfig } from "../lib/lanes/config.js";
+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";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validSegment(value, field) {
+    const normalized = value.trim();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(normalized) || normalized === "." || normalized === "..") {
+        return fail("tracker_input_invalid", `${field} must be a safe path segment`, { field });
+    }
+    return normalized;
+}
+function parseTimestamp(value, field, file) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        return fail("tracker_checks_input_invalid", `${field} must be a valid timestamp`, { path: file, field });
+    }
+    return value;
+}
+function readJsonObject(file, missing = "error") {
+    let raw;
+    try {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            return fail("tracker_checks_input_invalid", "Checks input must be a regular file", { path: file });
+        }
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT" && missing === "empty")
+            return null;
+        if (isLanesError(err))
+            throw err;
+        return fail("tracker_checks_input_unreadable", `Checks input could not be read: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return fail("tracker_checks_input_malformed", "Checks input contains invalid JSON", { path: file });
+    }
+    if (!isObject(parsed))
+        return fail("tracker_checks_input_invalid", "Checks input must be a JSON object", { path: file });
+    return parsed;
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+function checkCompanyPath(root, company, file, detailsPath) {
+    if (path.isAbsolute(file))
+        return fail("tracker_checks_mapping_invalid", "Mapped path must be relative to the HQ root", { path: detailsPath });
+    const absolute = path.resolve(root, file);
+    const rootReal = fs.realpathSync(root);
+    if (!isWithin(rootReal, absolute))
+        return fail("tracker_checks_mapping_invalid", "Mapped path escapes the HQ root", { path: detailsPath });
+    const relative = path.relative(rootReal, absolute).split(path.sep);
+    if (relative[0] === "companies" && relative[1] !== company) {
+        return fail("tracker_checks_mapping_invalid", "Mapped path crosses the active company boundary", { path: detailsPath });
+    }
+    try {
+        const real = fs.realpathSync(absolute);
+        if (!isWithin(rootReal, real))
+            return fail("tracker_checks_mapping_invalid", "Mapped path resolves outside the HQ root", { path: detailsPath });
+        const realRelative = path.relative(rootReal, real).split(path.sep);
+        if (realRelative[0] === "companies" && realRelative[1] !== company) {
+            return fail("tracker_checks_mapping_invalid", "Mapped path resolves into another company", { path: detailsPath });
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            return fail("tracker_checks_mapping_unreadable", `Mapped path could not be checked: ${err instanceof Error ? err.message : String(err)}`, { path: absolute });
+        }
+    }
+    return absolute;
+}
+function projectFromPrdReference(root, company, raw, registryPath) {
+    if (typeof raw !== "string" || raw.trim() === "") {
+        return fail("tracker_checks_mapping_invalid", "Team mapping needs a PRD path", { path: registryPath });
+    }
+    if (path.isAbsolute(raw))
+        return fail("tracker_checks_mapping_invalid", "Mapped path must be relative to the HQ root", { path: registryPath });
+    const candidate = path.resolve(root, raw);
+    const segments = path.relative(fs.realpathSync(root), candidate).split(path.sep);
+    if (segments[0] === "companies" && segments[1] !== company)
+        return null;
+    const absolute = checkCompanyPath(root, company, raw, registryPath);
+    const relative = path.relative(fs.realpathSync(root), absolute).split(path.sep);
+    if (relative[0] === "companies" && relative[1] === company && relative[2] === "projects" && relative.length === 5 && relative[4] === "prd.json") {
+        return validSegment(relative[3], "project");
+    }
+    // Older local lanes may point at a personal PRD. Use only its project slug
+    // to join against the active company's own project directory; never read it.
+    if (relative[0] === "personal" && relative[1] === "projects" && relative.length === 4 && relative[3] === "prd.json") {
+        return validSegment(relative[2], "project");
+    }
+    return null;
+}
+function projectDirectories(root, company) {
+    const projectsRoot = path.join(root, "companies", company, "projects");
+    let realProjectsRoot;
+    try {
+        realProjectsRoot = fs.realpathSync(projectsRoot);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        return fail("tracker_checks_input_unreadable", `Company project directory could not be resolved: ${err instanceof Error ? err.message : String(err)}`, { path: projectsRoot });
+    }
+    const projectsRelative = path.relative(fs.realpathSync(root), realProjectsRoot).split(path.sep);
+    if (projectsRelative[0] !== "companies" || projectsRelative[1] !== company || projectsRelative[2] !== "projects") {
+        return fail("tracker_checks_mapping_invalid", "Company project directory resolves outside the active tenant", { path: projectsRoot });
+    }
+    try {
+        return fs.readdirSync(projectsRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .filter((name) => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(name));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        return fail("tracker_checks_input_unreadable", `Company project directory could not be read: ${err instanceof Error ? err.message : String(err)}`, { path: projectsRoot });
+    }
+}
+function projectHasTrackerRecords(root, company, projectId) {
+    const projectPath = path.join(root, "companies", company, "projects", projectId);
+    const trackerRoot = path.join(projectPath, "tracker");
+    let trackerStat;
+    try {
+        trackerStat = fs.lstatSync(trackerRoot);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        return fail("tracker_checks_input_unreadable", `Project tracker directory could not be inspected: ${err instanceof Error ? err.message : String(err)}`, { path: trackerRoot });
+    }
+    if (!trackerStat.isDirectory() || trackerStat.isSymbolicLink()) {
+        return fail("tracker_checks_input_invalid", "Project tracker path must be a regular directory", { path: trackerRoot });
+    }
+    for (const kind of ["blocker", "kpi", "okr", "directive"]) {
+        const directory = path.join(trackerRoot, kind);
+        let stat;
+        try {
+            stat = fs.lstatSync(directory);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            return fail("tracker_checks_input_unreadable", `Project tracker records could not be inspected: ${err instanceof Error ? err.message : String(err)}`, { path: directory });
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            return fail("tracker_checks_input_invalid", "Project tracker record path must be a regular directory", { path: directory });
+        }
+        try {
+            if (fs.readdirSync(directory).some((name) => name.endsWith(".json")))
+                return true;
+        }
+        catch (err) {
+            return fail("tracker_checks_input_unreadable", `Project tracker records could not be listed: ${err instanceof Error ? err.message : String(err)}`, { path: directory });
+        }
+    }
+    return false;
+}
+function loadProjectMappings(root, company, requestedProject) {
+    const registryPath = path.join(root, "workspace", "lane-briefs", "juniors.json");
+    const registry = readJsonObject(registryPath, "empty");
+    const mappings = new Map();
+    if (registry !== null) {
+        if (!Array.isArray(registry.juniors))
+            return fail("tracker_checks_mapping_invalid", "Team mapping must contain a juniors array", { path: registryPath });
+        for (const [index, entry] of registry.juniors.entries()) {
+            if (!isObject(entry))
+                return fail("tracker_checks_mapping_invalid", "Team mapping row must be an object", { path: registryPath, index });
+            const projectId = projectFromPrdReference(root, company, entry.prd, registryPath);
+            if (projectId === null)
+                continue;
+            if (typeof entry.team !== "string" || typeof entry.lane !== "string" || typeof entry.status !== "string") {
+                return fail("tracker_checks_mapping_invalid", "Active team mapping needs team, lane, and status paths", { path: registryPath, index });
+            }
+            const team = validSegment(entry.team, "team");
+            const leadLaneId = validSegment(entry.lane, "lead lane id");
+            const statusPath = checkCompanyPath(root, company, entry.status, registryPath);
+            if (mappings.has(projectId))
+                return fail("tracker_checks_mapping_ambiguous", "More than one active team maps to a project", { path: registryPath, project_id: projectId });
+            mappings.set(projectId, { projectId, team, leadLaneId, statusPath });
+        }
+    }
+    const projectsRoot = path.join(root, "companies", company, "projects");
+    const knownProjectIds = new Set(projectDirectories(root, company));
+    for (const projectId of knownProjectIds) {
+        if (projectHasTrackerRecords(root, company, projectId) && !mappings.has(projectId)) {
+            mappings.set(projectId, {
+                projectId,
+                team: projectId,
+                statusPath: path.join(projectsRoot, projectId, "manager-status.json"),
+            });
+        }
+    }
+    if (requestedProject !== undefined) {
+        const projectId = validSegment(requestedProject, "project");
+        if (!knownProjectIds.has(projectId) && !mappings.has(projectId)) {
+            return fail("tracker_project_not_found", "Project directory was not found for this company", { project_id: projectId, path: path.join(projectsRoot, projectId) });
+        }
+        return new Map([...mappings].filter(([mappedProjectId]) => mappedProjectId === projectId));
+    }
+    return mappings;
+}
+function readProject(root, company, prdPath) {
+    checkCompanyPath(root, company, path.relative(root, prdPath), prdPath);
+    const parsed = readJsonObject(prdPath);
+    if (parsed === null)
+        return fail("tracker_checks_input_invalid", "Project task list must be a JSON object", { path: prdPath });
+    const metadata = isObject(parsed.metadata) ? parsed.metadata : undefined;
+    const rawCompany = parsed.company ?? metadata?.company;
+    const projectCompany = typeof rawCompany === "string"
+        ? rawCompany
+        : isObject(rawCompany) && typeof rawCompany.slug === "string"
+            ? rawCompany.slug
+            : null;
+    if (rawCompany !== undefined && rawCompany !== null && projectCompany === null) {
+        return fail("tracker_project_invalid", "Project company metadata must name a company slug", { path: prdPath });
+    }
+    if (projectCompany !== null && projectCompany !== company) {
+        return fail("tracker_company_mismatch", "Project company does not match the active HQ company", { active_company: company, project_company: projectCompany, path: prdPath });
+    }
+    const rawStories = parsed.userStories === undefined ? parsed.stories : parsed.userStories;
+    if (!Array.isArray(rawStories))
+        return fail("tracker_checks_input_invalid", "Project task list must contain a userStories or stories array", { path: prdPath });
+    const stories = rawStories.map((story, index) => {
+        if (!isObject(story) || typeof story.id !== "string" || story.id.trim() === "") {
+            return fail("tracker_checks_input_invalid", "Project task list contains a story without an id", { path: prdPath, index });
+        }
+        if (story.prs !== undefined && !Array.isArray(story.prs)) {
+            return fail("tracker_checks_input_invalid", "Project story prs must be an array", { path: prdPath, story_id: story.id });
+        }
+        return story;
+    });
+    try {
+        return { stories, mtime: fs.statSync(prdPath).mtimeMs };
+    }
+    catch (err) {
+        return fail("tracker_checks_input_unreadable", `Project task list could not be stat'ed: ${err instanceof Error ? err.message : String(err)}`, { path: prdPath });
+    }
+}
+function readStatusUpdatedAt(statusPath) {
+    const status = readJsonObject(statusPath, "empty");
+    if (status === null)
+        return null;
+    return parseTimestamp(status.updated_at, "status.updated_at", statusPath);
+}
+function storyIsDone(story) {
+    const state = typeof story.state === "string" ? story.state : story.status;
+    return story.passes === true || state === "done" || state === "dropped";
+}
+function pullRequestReferences(value, out = new Set(), seen = new Set()) {
+    if (typeof value === "string") {
+        const matches = value.match(/https?:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/[0-9]+(?:\/)?/g) ?? [];
+        for (const match of matches)
+            out.add(match.replace(/\/$/, ""));
+    }
+    else if (value !== null && typeof value === "object" && !seen.has(value)) {
+        seen.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value)
+                pullRequestReferences(item, out, seen);
+        }
+        else {
+            const object = value;
+            const state = object.state ?? object.status;
+            if (object.merged === true || object.closed === true || state === "merged" || state === "closed")
+                return [...out].sort();
+            for (const nested of Object.values(object))
+                pullRequestReferences(nested, out, seen);
+        }
+    }
+    return [...out].sort();
+}
+function laneMatchesProject(lane, projectId) {
+    return lane.project_id === projectId || (lane.stories ?? []).some((story) => story.project_id === projectId);
+}
+function laneMetadataMatchesScope(record, company, projectIds) {
+    const laneCompany = isObject(record.company) ? record.company : null;
+    if (laneCompany?.slug !== company.slug || laneCompany.uid !== company.uid)
+        return false;
+    if (typeof record.project_id === "string" && projectIds.has(record.project_id))
+        return true;
+    return Array.isArray(record.stories) && record.stories.some((story) => isObject(story) && typeof story.project_id === "string" && projectIds.has(story.project_id));
+}
+function readScopedLanes(root, company, projects) {
+    const projectIds = new Set(projects.map((project) => project.projectId));
+    if (projectIds.size === 0)
+        return [];
+    return listLaneIds(root).flatMap((id) => {
+        const file = laneRecordPath(root, id);
+        const metadata = readJsonObject(file);
+        if (metadata === null)
+            return fail("tracker_checks_input_unreadable", "Lane record could not be read while checking its scope", { path: file });
+        if (!laneMetadataMatchesScope(metadata, company, projectIds))
+            return [];
+        return [readLane(root, id)];
+    });
+}
+function sameCompanyLane(lane, company) {
+    return lane.company?.slug === company.slug && lane.company.uid === company.uid;
+}
+function questionSurfacingState(root, questions) {
+    const statePath = path.join(root, "workspace", "lane-briefs", "ops-board-state.json");
+    const state = readJsonObject(statePath, "empty");
+    const surfaced = new Map();
+    if (state === null)
+        return surfaced;
+    if (state.questions !== undefined && !isObject(state.questions)) {
+        return fail("tracker_checks_input_invalid", "Owner question state must contain a questions object", { path: statePath });
+    }
+    const questionState = isObject(state.questions) ? state.questions : {};
+    for (const question of questions) {
+        const entry = questionState[question.id];
+        if (entry === undefined) {
+            surfaced.set(question.id, null);
+            continue;
+        }
+        if (!isObject(entry))
+            return fail("tracker_checks_input_invalid", "Owner question state must be an object", { path: statePath, question_id: question.id });
+        const at = entry.surfaced_at === undefined || entry.surfaced_at === null
+            ? null
+            : parseTimestamp(entry.surfaced_at, "surfaced_at", statePath);
+        surfaced.set(question.id, at);
+    }
+    return surfaced;
+}
+function questionMetadataMatchesScope(record, company, projectId) {
+    if (record.company === null)
+        return false;
+    if (!isObject(record.company))
+        return true;
+    if (typeof record.company.slug === "string" && record.company.slug !== company.slug)
+        return false;
+    if (typeof record.company.uid === "string" && record.company.uid !== company.uid)
+        return false;
+    if (record.company.slug === company.slug && record.company.uid === company.uid && projectId !== undefined &&
+        typeof record.project_id === "string" && record.project_id !== projectId)
+        return false;
+    return true;
+}
+function readCompanyQuestions(root, company, projectId) {
+    const records = listQuestionIds(root)
+        .flatMap((id) => {
+        const file = questionRecordPath(root, id);
+        const metadata = readJsonObject(file);
+        if (metadata === null)
+            return fail("tracker_checks_input_unreadable", "Question record could not be read while checking its scope", { path: file });
+        if (!questionMetadataMatchesScope(metadata, company, projectId))
+            return [];
+        const question = readQuestion(root, id);
+        return question.company?.slug === company.slug && question.company.uid === company.uid &&
+            (projectId === undefined || question.project_id === projectId) ? [question] : [];
+    });
+    const surfacedAt = questionSurfacingState(root, records.map((question) => ({
+        id: question.question_id,
+        status: question.status,
+        asked_at: question.asked_at,
+        routing_history: question.routing_history.map((entry) => ({ at: entry.at, audience_kind: entry.audience.kind })),
+        surfaced_at: null,
+    })));
+    return records.map((question) => ({
+        id: question.question_id,
+        status: question.status,
+        asked_at: question.asked_at,
+        routing_history: question.routing_history.map((entry) => ({ at: entry.at, audience_kind: entry.audience.kind })),
+        surfaced_at: surfacedAt.get(question.question_id) ?? null,
+    }));
+}
+function readTeamInputs(root, company, projects, lanes) {
+    const inputs = [];
+    for (const project of projects) {
+        const projectPath = path.join(root, "companies", company.slug, "projects", project.projectId);
+        const prdPath = path.join(projectPath, "prd.json");
+        const { stories, mtime } = readProject(root, company.slug, prdPath);
+        const teamLanes = lanes.filter((lane) => sameCompanyLane(lane, company) && laneMatchesProject(lane, project.projectId));
+        const lead = project.leadLaneId === undefined
+            ? undefined
+            : teamLanes.find((lane) => lane.lane_id === project.leadLaneId);
+        const openStories = stories.filter((story) => !storyIsDone(story));
+        const openPrRefs = new Set();
+        for (const story of openStories) {
+            for (const ref of pullRequestReferences(story.prs ?? []))
+                openPrRefs.add(ref);
+        }
+        for (const lane of teamLanes) {
+            for (const ref of pullRequestReferences(lane.last_envelope?.artifacts ?? []))
+                openPrRefs.add(ref);
+        }
+        const runningWorkers = teamLanes
+            .filter((lane) => lane.lane_id !== project.leadLaneId && lane.senior.kind === "lane" && lane.state === "running")
+            .map((lane) => lane.lane_id);
+        inputs.push({
+            team: project.team,
+            project_id: project.projectId,
+            ...(lead ? { lead_lane: { id: lead.lane_id, state: lead.state } } : {}),
+            open_story_ids: openStories.map((story) => String(story.id)),
+            open_pr_refs: [...openPrRefs].sort(),
+            running_worker_ids: runningWorkers,
+            status_path: project.statusPath,
+            status_updated_at: readStatusUpdatedAt(project.statusPath),
+            task_list_path: prdPath,
+            task_list_updated_at: new Date(mtime).toISOString(),
+        });
+    }
+    return inputs;
+}
+function pathForTrackerRecord(projectDirectory, kind, id) {
+    return path.join(projectDirectory, "tracker", kind, `${id}.json`);
+}
+function recordInvalid(kind, record, projectDirectory, field) {
+    return fail("tracker_checks_record_invalid", `Tracker ${kind} record has invalid ${field}`, {
+        kind,
+        id: record.id,
+        field,
+        path: pathForTrackerRecord(projectDirectory, kind, record.id),
+    });
+}
+function requiredRecordDate(kind, record, projectDirectory, field) {
+    const value = record[field];
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        return recordInvalid(kind, record, projectDirectory, field);
+    return value;
+}
+function listTrackerRecords(projectDirectory, kind) {
+    try {
+        return createLocalTrackerStore(projectDirectory).list(kind);
+    }
+    catch (err) {
+        if (isLanesError(err) && typeof err.details.path === "string")
+            throw err;
+        return fail("tracker_checks_store_unreadable", `Tracker ${kind} records could not be read: ${err instanceof Error ? err.message : String(err)}`, { path: path.join(projectDirectory, "tracker", kind) });
+    }
+}
+function readTrackerCheckRecords(root, company, projects) {
+    const blockers = [];
+    const kpis = [];
+    const directives = [];
+    for (const project of projects) {
+        const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
+        const records = {
+            blocker: listTrackerRecords(absoluteDirectory, "blocker"),
+            kpi: listTrackerRecords(absoluteDirectory, "kpi"),
+            directive: listTrackerRecords(absoluteDirectory, "directive"),
+        };
+        for (const record of records.blocker) {
+            if (record.company !== company.slug || record.project_id !== project.projectId)
+                continue;
+            const openedAt = requiredRecordDate("blocker", record, absoluteDirectory, "opened_at");
+            const resolvedAt = record.resolved_at;
+            if (resolvedAt !== null && (typeof resolvedAt !== "string" || !Number.isFinite(Date.parse(resolvedAt))))
+                recordInvalid("blocker", record, absoluteDirectory, "resolved_at");
+            const nextStep = record.next_step;
+            if (nextStep !== undefined && nextStep !== null && typeof nextStep !== "string")
+                recordInvalid("blocker", record, absoluteDirectory, "next_step");
+            blockers.push({ id: record.id, opened_at: openedAt, resolved_at: resolvedAt, next_step: typeof nextStep === "string" ? nextStep : null });
+        }
+        for (const record of records.kpi) {
+            if (record.company !== company.slug || record.project_id !== project.projectId)
+                continue;
+            const createdAt = requiredRecordDate("kpi", record, absoluteDirectory, "created_at");
+            if (!Array.isArray(record.values))
+                recordInvalid("kpi", record, absoluteDirectory, "values");
+            const values = record.values.map((value) => {
+                if (!isObject(value))
+                    recordInvalid("kpi", record, absoluteDirectory, "values");
+                return { at: parseTimestamp(value.at, "values.at", pathForTrackerRecord(absoluteDirectory, "kpi", record.id)) };
+            });
+            kpis.push({ id: record.id, created_at: createdAt, values });
+        }
+        for (const record of records.directive) {
+            if (record.company !== company.slug || record.project_id !== project.projectId)
+                continue;
+            const createdAt = requiredRecordDate("directive", record, absoluteDirectory, "created_at");
+            if (!Array.isArray(record.teams) || record.teams.some((team) => typeof team !== "string"))
+                recordInvalid("directive", record, absoluteDirectory, "teams");
+            if (!Array.isArray(record.acknowledgements))
+                recordInvalid("directive", record, absoluteDirectory, "acknowledgements");
+            const acknowledgements = record.acknowledgements.map((ack) => {
+                if (!isObject(ack) || typeof ack.team !== "string" || typeof ack.lane_id !== "string")
+                    recordInvalid("directive", record, absoluteDirectory, "acknowledgements");
+                return { team: ack.team, lane_id: ack.lane_id, at: parseTimestamp(ack.at, "acknowledgements.at", pathForTrackerRecord(absoluteDirectory, "directive", record.id)) };
+            });
+            directives.push({ id: record.id, created_at: createdAt, teams: record.teams, acknowledgements });
+        }
+    }
+    return { blockers, kpis, directives };
+}
+async function resolveTrackerCompany(deps, requested) {
+    const company = await deps.resolveCompany(requested);
+    if (!company.slug)
+        fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
+    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) {
+    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 directiveTeams = [...directiveProjects.values()].map((project) => ({
+        team: project.team,
+        ...(project.leadLaneId === undefined ? {} : { lead_lane_id: project.leadLaneId }),
+    }));
+    return {
+        ok: true,
+        company: company.slug,
+        generated_at: now.toISOString(),
+        checks: evaluateTrackerChecks({
+            now,
+            thresholds: loadLanesConfig(root).tracker.checks,
+            questions: questionRecords,
+            teams,
+            ...trackerRecords,
+            directives: trackerRecords.directives,
+            directive_teams: directiveTeams,
+        }),
+    };
+}
+export function registerLaneChecksCommand(parent, deps, wrap) {
+    parent.command("checks")
+        .description("Evaluate tracker and lane health checks")
+        .option("--company <slug>", "Select the company by slug")
+        .option("--project <slug>", "Limit checks to one company project")
+        .action(wrap(async (options) => {
+        const company = await resolveTrackerCompany(deps, options.company);
+        const root = deps.hqRoot();
+        const projectFilter = options.project === undefined ? undefined : validSegment(options.project, "project");
+        const projects = loadProjectMappings(root, company.slug, projectFilter);
+        const directiveProjects = projectFilter === undefined
+            ? projects
+            : loadProjectMappings(root, company.slug);
+        const report = checkReport(root, company, projects, directiveProjects, projectFilter, deps.now());
+        console.log(JSON.stringify(report, null, 2));
+        if (report.checks.some((item) => item.result === "failing"))
+            process.exitCode = 2;
+    }));
+}
+//# sourceMappingURL=lanes-checks.js.map