@indigoai-us/hq-cli 5.228.2 → 5.228.4

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [5.228.4] — 2026-09-27
+
+### Fixed
+
+- Account history now distinguishes automatic moves caused by a quota hold, an
+  unavailable or logged-out account, or uneven load.
+
+## [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/commands/lanes.js

@@ -5635,9 +5635,20 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         ...(model !== undefined ? { model } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
     });
+    const historyReason = lane.account === undefined
+        ? "load_balance"
+        : currentConfig?.enabled !== true
+            ? "account_unavailable"
+            : currentLogin === false
+                ? "recorded_account_logged_out"
+                : currentLogin !== true
+                    ? "account_unavailable"
+                    : quotaBlockFor(loadQuotaState(hqRoot), "claude", lane.account, model, ctx.now()).blocked
+                        ? "usage_limit"
+                        : "load_balance";
     return {
         selection: { ...selected, selected_at: ctx.now().toISOString() },
-        ...(repairUnavailableAccount ? { historyReason: "recorded_account_logged_out" } : {}),
+        historyReason,
         ...(preservedModel !== undefined ? { preservedModel } : {}),
     };
 }
@@ -6269,6 +6280,7 @@ async function applyClaudeBalanceMove(ctx, suggestion) {
     const moved = await prepareAccountMove(ctx, lane, {
         account: suggestion.to,
         cliModel: undefined,
+        accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
         deferTurnStart: true,
     });
     return { lane_id: moved.lane.lane_id, host: moved.lane.host, from: moved.from ?? suggestion.from, to: moved.to, state: moved.lane.state };
@@ -6324,6 +6336,7 @@ async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
     const moved = await prepareAccountMove(ctx, lane, {
         account,
         cliModel: undefined,
+        accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
         deferTurnStart: true,
     });
     printJson({
@@ -6335,6 +6348,32 @@ async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
         account: moved.lane.account,
     });
 }
+function automaticBalanceMoveHistoryReason(ctx, lane) {
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const accountId = lane.account;
+    if (accountId === undefined)
+        return "load_balance";
+    const source = config.providers[lane.provider].accounts[accountId];
+    if (source?.enabled !== true)
+        return "account_unavailable";
+    const login = accountStatus(lane.provider, accountId, config, {
+        existsSync: ctx.existsSync,
+        hostname: ctx.hostname(),
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).logged_in;
+    if (login === false)
+        return "recorded_account_logged_out";
+    if (login !== true)
+        return "account_unavailable";
+    const provider = config.providers[lane.provider];
+    const model = lane.model ?? source.model ?? provider.model;
+    if (quotaBlockFor(loadQuotaState(hqRoot), lane.provider, accountId, model, ctx.now()).blocked) {
+        return "usage_limit";
+    }
+    return "load_balance";
+}
 function laneWithRecoveredProviderSession(hqRoot, lane) {
     const manifest = readSpawnManifest(laneRunDir(hqRoot, lane.lane_id));
     const sessionId = (typeof lane.provider_session_id === "string" && lane.provider_session_id.trim()

package/dist/lib/lanes/spawn.js

@@ -189,7 +189,7 @@ function selectSpawnAccount(input) {
     const operatorMovePending = lane.pending_resume !== undefined &&
         lane.account_history?.at(-1)?.reason === "operator_move";
     if (current === undefined || !current.enabled) {
-        reason = repairRecordedAccount ? "recorded_account_logged_out" : "account_unavailable";
+        reason = "account_unavailable";
         refusal = new AccountResolutionError(current === undefined ? "unknown_account" : "account_disabled", `Account ${JSON.stringify(lane.account)} is unavailable for ${lane.provider}`, { provider: lane.provider, account: lane.account });
     }
     else {
@@ -244,7 +244,11 @@ function selectSpawnAccount(input) {
             account: lane.account,
         });
     }
-    if (reason === "recorded_account_logged_out" && lane.provider === "claude") {
+    const recoverRecordedClaudeModel = lane.provider === "claude" &&
+        reason !== undefined &&
+        (reason === "recorded_account_logged_out" ||
+            (reason === "account_unavailable" && repairRecordedAccount && recordedModel !== undefined));
+    if (recoverRecordedClaudeModel) {
         const lanes = listLaneIds(hqRoot)
             .map((laneId) => readLane(hqRoot, laneId))
             .filter((record) => record.host.kind === lane.host.kind && record.host.id === lane.host.id);
@@ -268,7 +272,8 @@ function selectSpawnAccount(input) {
         });
         return {
             account: resolveAccount(lane.provider, selection.account, config, context),
-            changeReason: "recorded_account_logged_out",
+            changeReason: reason,
+            ...(recordedModel !== undefined ? { preservedModel: recordedModel } : {}),
         };
     }
     const allowedAccounts = Object.entries(config.providers[lane.provider].accounts)
@@ -1726,7 +1731,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         process.stderr.write(`hq lanes: account bind failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
         throw err;
     }
-    const preservedAccountModel = selection.changeReason === "recorded_account_logged_out" ? recordedModel : undefined;
+    const preservedAccountModel = selection.preservedModel;
     if (preservedAccountModel !== undefined)
         pinnedModel = preservedAccountModel;
     const resolved = selection.account;

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/dist/lib/lanes/types.d.ts

@@ -523,7 +523,7 @@ export interface AccountHistoryEntry {
     from: string | null;
     to: string;
     at: string;
-    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "operator_move";
+    reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "recorded_account_logged_out" | "load_balance" | "operator_move";
 }
 export interface PendingResume {
     /** Fresh answered-question launches need no previous session id. */

package/package.json

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