@indigoai-us/hq-cli 5.228.2 → 5.228.3

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.228.3] — 2026-09-27
+
+### Fixed
+
+- Work Mesh tracker rows use the local record fields. Missing blocker
+  `opened_at` values use `createdAt`, and invalid mesh rows identify Work Mesh
+  as their source.
+- KPI and OKR records retain their status when read from Work Mesh, including in
+  `kpi list`, `okr list`, and `team --json` output.
+
 ## [5.228.2] — 2026-09-27
 
 ## [5.228.1] — 2026-09-27

package/dist/commands/lanes-checks.js

@@ -435,7 +435,17 @@ function readTeamInputs(root, company, projects, lanes) {
 export function pathForTrackerRecord(projectDirectory, kind, id) {
     return path.join(projectDirectory, "tracker", kind, `${id}.json`);
 }
-function recordInvalid(kind, record, projectDirectory, field) {
+function recordInvalid(kind, record, projectDirectory, field, source = "local") {
+    if (source === "Work Mesh") {
+        return fail("tracker_checks_record_invalid", `Work Mesh tracker ${kind} record ${record.id} has invalid ${field}`, {
+            source,
+            record_id: record.id,
+            kind,
+            company: record.company,
+            project_id: record.project_id,
+            field,
+        });
+    }
     return fail("tracker_checks_record_invalid", `Tracker ${kind} record has invalid ${field}`, {
         kind,
         id: record.id,
@@ -443,10 +453,18 @@ function recordInvalid(kind, record, projectDirectory, field) {
         path: pathForTrackerRecord(projectDirectory, kind, record.id),
     });
 }
-function requiredRecordDate(kind, record, projectDirectory, field) {
+function requiredRecordDate(kind, record, projectDirectory, field, source = "local") {
     const value = record[field];
     if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
-        return recordInvalid(kind, record, projectDirectory, field);
+        return recordInvalid(kind, record, projectDirectory, field, source);
+    return value;
+}
+function requiredRecordTimestamp(kind, record, projectDirectory, field, value, source) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        if (source === "Work Mesh")
+            return recordInvalid(kind, record, projectDirectory, field, source);
+        return parseTimestamp(value, field, pathForTrackerRecord(projectDirectory, kind, record.id));
+    }
     return value;
 }
 export function listTrackerRecords(projectDirectory, kind) {
@@ -509,6 +527,7 @@ async function readTrackerCheckRecords(root, company, projects, deps) {
     const kpis = [];
     const directives = [];
     const useMesh = await deps.trackerMeshEnabled(company);
+    const source = useMesh ? "Work Mesh" : "local";
     for (const project of projects) {
         const absoluteDirectory = path.join(root, "companies", company.slug, "projects", project.projectId);
         const store = useMesh
@@ -522,40 +541,40 @@ async function readTrackerCheckRecords(root, company, projects, deps) {
         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 openedAt = requiredRecordDate("blocker", record, absoluteDirectory, "opened_at", source);
             const resolvedAt = record.resolved_at;
             if (resolvedAt !== null && (typeof resolvedAt !== "string" || !Number.isFinite(Date.parse(resolvedAt))))
-                recordInvalid("blocker", record, absoluteDirectory, "resolved_at");
+                recordInvalid("blocker", record, absoluteDirectory, "resolved_at", source);
             const nextStep = record.next_step;
             if (nextStep !== undefined && nextStep !== null && typeof nextStep !== "string")
-                recordInvalid("blocker", record, absoluteDirectory, "next_step");
+                recordInvalid("blocker", record, absoluteDirectory, "next_step", source);
             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");
+            const createdAt = requiredRecordDate("kpi", record, absoluteDirectory, "created_at", source);
             if (!Array.isArray(record.values))
-                recordInvalid("kpi", record, absoluteDirectory, "values");
+                recordInvalid("kpi", record, absoluteDirectory, "values", source);
             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)) };
+                    recordInvalid("kpi", record, absoluteDirectory, "values", source);
+                return { at: requiredRecordTimestamp("kpi", record, absoluteDirectory, "values[].at", value.at, source) };
             });
             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");
+            const createdAt = requiredRecordDate("directive", record, absoluteDirectory, "created_at", source);
             if (!Array.isArray(record.teams) || record.teams.some((team) => typeof team !== "string"))
-                recordInvalid("directive", record, absoluteDirectory, "teams");
+                recordInvalid("directive", record, absoluteDirectory, "teams", source);
             if (!Array.isArray(record.acknowledgements))
-                recordInvalid("directive", record, absoluteDirectory, "acknowledgements");
+                recordInvalid("directive", record, absoluteDirectory, "acknowledgements", source);
             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)) };
+                    recordInvalid("directive", record, absoluteDirectory, "acknowledgements", source);
+                return { team: ack.team, lane_id: ack.lane_id, at: requiredRecordTimestamp("directive", record, absoluteDirectory, "acknowledgements[].at", ack.at, source) };
             });
             directives.push({ id: record.id, created_at: createdAt, teams: record.teams, acknowledgements });
         }

package/dist/lib/lanes/tracker-mesh.js

@@ -3,6 +3,12 @@ import { meshJson, requireToken } from "../mesh/client.js";
 import { LanesError } from "./errors.js";
 const ROOT = "/v1/work-mesh/tracker/records";
 const MAX_RECORD_PAGES = 20;
+const RECORD_FIELDS = {
+    blocker: ["story_id", "what", "waiting_on", "next_step", "opened_at", "resolved_at", "resolution", "import_key", "source_path", "source_item_id"],
+    kpi: ["name", "definition", "unit", "target", "direction", "status", "approved_by", "approved_at", "values", "import_key", "source_path", "source_item_id"],
+    okr: ["objective", "period", "key_results", "status", "approved_by", "approved_at", "import_key", "source_path", "source_item_id"],
+    directive: ["text", "date", "source_url", "teams", "policy_path", "acknowledgements", "import_key", "source_path", "source_item_id"],
+};
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -50,23 +56,30 @@ function fromMesh(value) {
 }
 function recordFromMeta(raw, company, projectId, expectedKind) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh returned a malformed tracker record", { project_id: projectId, kind: expectedKind });
+        return fail("tracker_mesh_response_invalid", "Work Mesh returned a malformed tracker record", {
+            source: "Work Mesh", kind: expectedKind, company: company.slug, project_id: projectId,
+        });
     }
     const meta = raw;
     if (meta.companyUid !== company.uid || meta.projectId !== projectId || meta.kind !== expectedKind || typeof meta.threadId !== "string" || !meta.threadId) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record identity did not match the requested company, project, and kind", { project_id: projectId, kind: expectedKind });
+        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record identity did not match the requested company, project, and kind", {
+            source: "Work Mesh",
+            ...(typeof meta.threadId === "string" && meta.threadId ? { record_id: meta.threadId } : {}),
+            kind: expectedKind,
+            company: company.slug,
+            project_id: projectId,
+        });
     }
     const fields = fromMesh(meta);
     const createdAt = typeof meta.createdAt === "string" ? meta.createdAt : "";
     const updatedAt = typeof meta.lastActivityAt === "string" ? meta.lastActivityAt : createdAt;
     const version = meta.version;
     if (!Number.isSafeInteger(version) || version < 1 || !Number.isFinite(Date.parse(createdAt)) || !Number.isFinite(Date.parse(updatedAt))) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record has invalid version or timestamps", { record_id: meta.threadId, kind: expectedKind });
+        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record has invalid version or timestamps", {
+            source: "Work Mesh", record_id: meta.threadId, kind: expectedKind, company: company.slug, project_id: projectId,
+        });
     }
-    const { company_uid: _companyUid, project_id: _projectId, thread_id: _threadId, thread_status: threadStatus, ...rest } = fields;
     const record = {
-        ...rest,
-        ...(typeof threadStatus === "string" && rest.status === undefined ? { status: threadStatus } : {}),
         schema_version: "hq-lanes-tracker-record.v1",
         kind: expectedKind,
         id: meta.threadId,
@@ -76,6 +89,16 @@ function recordFromMeta(raw, company, projectId, expectedKind) {
         created_at: createdAt,
         updated_at: updatedAt,
     };
+    for (const field of RECORD_FIELDS[expectedKind]) {
+        if (Object.hasOwn(fields, field))
+            record[field] = fields[field];
+    }
+    // hq-pro stores KPI and OKR status in the shared threadStatus metadata field.
+    if ((expectedKind === "kpi" || expectedKind === "okr") && !Object.hasOwn(record, "status") && Object.hasOwn(fields, "thread_status")) {
+        record.status = fields.thread_status;
+    }
+    if (expectedKind === "blocker" && !Object.hasOwn(record, "opened_at"))
+        record.opened_at = createdAt;
     return record;
 }
 function identityMatches(record, kind, id, company, projectId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.228.2",
+  "version": "5.228.3",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {