@indigoai-us/hq-cli 5.226.0 → 5.227.1

package/dist/lib/lanes/tracker-mesh-questions.d.ts

@@ -0,0 +1,54 @@
+import type { LaneCompanyRef, QuestionRecord } from "./types.js";
+import { type TrackerMeshRequest } from "./tracker-mesh.js";
+export type TrackerMeshQuestionAudience = "owner" | "operator" | "lane";
+export type TrackerMeshQuestionStatus = "pending" | "answered" | "cancelled";
+export interface TrackerMeshQuestionRow {
+    questionId: string;
+    threadId: string;
+    companyUid: string;
+    projectId: string;
+    laneId: string;
+    host: {
+        kind: string;
+        id: string;
+    };
+    audience: TrackerMeshQuestionAudience;
+    audienceChain: string[];
+    routingHistory: Array<Record<string, string>>;
+    question: string;
+    context?: string;
+    options: string[];
+    recommended?: string;
+    askedAt: string;
+    status: TrackerMeshQuestionStatus;
+    choice?: string;
+    notes?: string;
+    answeredBy?: string;
+    answeredAt?: string;
+    deliveredAt?: string;
+}
+export interface TrackerMeshQuestionInput {
+    laneId: string;
+    threadId?: string;
+    projectId: string;
+    audience: TrackerMeshQuestionAudience;
+    audienceChain: string[];
+    routingHistory: Array<Record<string, string>>;
+    question: string;
+    context: string;
+    options: string[];
+    recommended?: string;
+}
+export interface TrackerMeshQuestionClient {
+    create(input: TrackerMeshQuestionInput): Promise<TrackerMeshQuestionRow>;
+    list(statuses?: readonly TrackerMeshQuestionStatus[]): Promise<TrackerMeshQuestionRow[]>;
+    answer(questionId: string, choice: string, notes?: string): Promise<TrackerMeshQuestionRow>;
+    delivered(questionId: string): Promise<TrackerMeshQuestionRow>;
+}
+/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
+export declare function deliverTrackerMeshQuestionOnce(question: QuestionRecord, company: LaneCompanyRef, client: Pick<TrackerMeshQuestionClient, "delivered">, persist: (deliveredAt: string) => QuestionRecord): Promise<QuestionRecord>;
+export declare function createTrackerMeshQuestionClient(options: {
+    company: LaneCompanyRef;
+    request?: TrackerMeshRequest;
+}): TrackerMeshQuestionClient;
+//# sourceMappingURL=tracker-mesh-questions.d.ts.map

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

@@ -0,0 +1,138 @@
+import { meshJson, requireToken } from "../mesh/client.js";
+import { LanesError } from "./errors.js";
+import { mapWorkMeshTrackerError } from "./tracker-mesh.js";
+/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
+export async function deliverTrackerMeshQuestionOnce(question, company, client, persist) {
+    if (!question.mesh_question_id || question.status !== "answered" ||
+        !question.delivered_at || question.mesh_delivered_at)
+        return question;
+    const delivered = await client.delivered(question.mesh_question_id);
+    if (delivered.questionId !== question.mesh_question_id ||
+        delivered.companyUid !== company.uid ||
+        delivered.laneId !== question.lane_id ||
+        delivered.projectId !== question.project_id ||
+        !delivered.deliveredAt) {
+        throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not stamp the expected question as delivered", {
+            mesh_question_id: question.mesh_question_id,
+            question_id: question.question_id,
+        });
+    }
+    return persist(delivered.deliveredAt);
+}
+const ROOT = "/v1/work-mesh/tracker/questions";
+const AUDIENCES = ["owner", "operator", "lane"];
+const STATUSES = ["pending", "answered", "cancelled"];
+const MAX_PAGES_PER_FILTER = 10;
+function invalidResponse(field) {
+    throw new LanesError("tracker_mesh_response_invalid", `Work Mesh returned an invalid tracker question ${field}`, { field });
+}
+function parseQuestion(raw, company) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return invalidResponse("row");
+    const row = raw;
+    if (typeof row.questionId !== "string" || !row.questionId ||
+        typeof row.threadId !== "string" || !row.threadId ||
+        row.companyUid !== company.uid ||
+        typeof row.projectId !== "string" || !row.projectId ||
+        typeof row.laneId !== "string" || !row.laneId ||
+        !AUDIENCES.includes(row.audience) ||
+        !STATUSES.includes(row.status) ||
+        typeof row.question !== "string" ||
+        !Array.isArray(row.options) || row.options.some((entry) => typeof entry !== "string") ||
+        !Array.isArray(row.audienceChain) || row.audienceChain.some((entry) => typeof entry !== "string") ||
+        !Array.isArray(row.routingHistory) ||
+        typeof row.askedAt !== "string" || !Number.isFinite(Date.parse(row.askedAt)))
+        return invalidResponse("row");
+    if (row.context !== undefined && typeof row.context !== "string")
+        return invalidResponse("context");
+    if (row.recommended !== undefined && typeof row.recommended !== "string")
+        return invalidResponse("recommended");
+    if (row.choice !== undefined && typeof row.choice !== "string")
+        return invalidResponse("choice");
+    if (row.notes !== undefined && typeof row.notes !== "string")
+        return invalidResponse("notes");
+    if (row.answeredBy !== undefined && typeof row.answeredBy !== "string")
+        return invalidResponse("answeredBy");
+    if (row.answeredAt !== undefined && (typeof row.answeredAt !== "string" || !Number.isFinite(Date.parse(row.answeredAt))))
+        return invalidResponse("answeredAt");
+    if (row.deliveredAt !== undefined && (typeof row.deliveredAt !== "string" || !Number.isFinite(Date.parse(row.deliveredAt))))
+        return invalidResponse("deliveredAt");
+    if (!row.host || typeof row.host !== "object" || Array.isArray(row.host) || typeof row.host.kind !== "string" || typeof row.host.id !== "string")
+        return invalidResponse("host");
+    return row;
+}
+export function createTrackerMeshQuestionClient(options) {
+    const { company } = options;
+    if (!company.slug.trim() || !company.uid.trim()) {
+        throw new LanesError("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker questions", {});
+    }
+    const request = options.request ?? (async (endpoint, init) => {
+        const token = await requireToken({ interactive: false });
+        return meshJson(token, endpoint, init);
+    });
+    const call = async (endpoint, init) => {
+        try {
+            const result = await request(endpoint, init);
+            if (!result || typeof result !== "object" || Array.isArray(result))
+                return invalidResponse("response");
+            return result;
+        }
+        catch (err) {
+            throw mapWorkMeshTrackerError(err);
+        }
+    };
+    return {
+        async create(input) {
+            const result = await call(ROOT, { method: "POST", body: { companyUid: company.uid, ...input } });
+            return parseQuestion(result.question, company);
+        },
+        async list(requestedStatuses = STATUSES) {
+            const uniqueStatuses = [...new Set(requestedStatuses)];
+            if (uniqueStatuses.some((status) => !STATUSES.includes(status))) {
+                throw new LanesError("tracker_mesh_query_invalid", "Unsupported Work Mesh tracker question status filter", { statuses: uniqueStatuses });
+            }
+            const rows = new Map();
+            for (const audience of AUDIENCES) {
+                for (const status of uniqueStatuses) {
+                    let cursor;
+                    for (let page = 0; page < MAX_PAGES_PER_FILTER; page += 1) {
+                        const query = { companyUid: company.uid, audience, status, limit: "100", ...(cursor ? { cursor } : {}) };
+                        const result = await call(ROOT, { method: "GET", query });
+                        if (!Array.isArray(result.questions))
+                            return invalidResponse("questions list");
+                        for (const raw of result.questions) {
+                            const row = parseQuestion(raw, company);
+                            if (row.audience !== audience || row.status !== status)
+                                return invalidResponse("filter scope");
+                            rows.set(row.questionId, row);
+                        }
+                        if (result.nextCursor === undefined)
+                            break;
+                        if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor)
+                            return invalidResponse("cursor");
+                        if (page === MAX_PAGES_PER_FILTER - 1) {
+                            throw new LanesError("tracker_mesh_response_incomplete", "Work Mesh tracker question list exceeded its bounded page limit", { audience, status, max_pages: MAX_PAGES_PER_FILTER });
+                        }
+                        cursor = result.nextCursor;
+                    }
+                }
+            }
+            return [...rows.values()].sort((a, b) => b.askedAt.localeCompare(a.askedAt) || a.questionId.localeCompare(b.questionId));
+        },
+        async answer(questionId, choice, notes) {
+            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/answer`, {
+                method: "POST",
+                body: { companyUid: company.uid, choice, ...(notes === undefined ? {} : { notes }) },
+            });
+            return parseQuestion(result.question, company);
+        },
+        async delivered(questionId) {
+            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/delivered`, {
+                method: "POST",
+                body: { companyUid: company.uid },
+            });
+            return parseQuestion(result.question, company);
+        },
+    };
+}
+//# sourceMappingURL=tracker-mesh-questions.js.map

package/dist/lib/lanes/tracker-mesh.d.ts

@@ -0,0 +1,19 @@
+import { LanesError } from "./errors.js";
+import type { LaneCompanyRef } from "./types.js";
+import type { TrackerStore } from "./tracker-store.js";
+export interface TrackerMeshRequestInit {
+    method?: string;
+    body?: Record<string, unknown>;
+    query?: Record<string, string>;
+}
+export type TrackerMeshRequest = (path: string, init: TrackerMeshRequestInit) => Promise<unknown>;
+export interface WorkMeshTrackerStoreOptions {
+    company: LaneCompanyRef;
+    projectId: string;
+    request?: TrackerMeshRequest;
+    now?: () => Date;
+    clientRecordId?: () => string;
+}
+export declare function mapWorkMeshTrackerError(err: unknown): LanesError;
+export declare function createWorkMeshTrackerStore(options: WorkMeshTrackerStoreOptions): TrackerStore;
+//# sourceMappingURL=tracker-mesh.d.ts.map

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

@@ -0,0 +1,228 @@
+import { randomUUID } from "node:crypto";
+import { meshJson, requireToken } from "../mesh/client.js";
+import { LanesError } from "./errors.js";
+const ROOT = "/v1/work-mesh/tracker/records";
+const MAX_RECORD_PAGES = 20;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function mapWorkMeshTrackerError(err) {
+    if (err instanceof LanesError)
+        return err;
+    const value = err;
+    const status = typeof value?.status === "number" ? value.status : Number(/^\s*(\d{3})\b/.exec(err instanceof Error ? err.message : "")?.[1]);
+    const code = typeof value?.code === "string" ? value.code : "";
+    if (status === 404 && code === "tracker_records_disabled") {
+        return new LanesError("tracker_records_disabled", "Work Mesh tracker records are disabled for this company", { status, code });
+    }
+    if (status === 404)
+        return new LanesError("tracker_record_not_found", "Work Mesh tracker record was not found", { status, code });
+    if (status === 409 && (code === "stale_version" || /stale.version/i.test(err instanceof Error ? err.message : ""))) {
+        return new LanesError("tracker_version_conflict", "Work Mesh tracker record changed before this update", { status, code });
+    }
+    if (status === 409)
+        return new LanesError("tracker_mesh_conflict", "Work Mesh rejected the tracker update because the record state changed", { status, code });
+    if (status === 401 || status === 403)
+        return new LanesError("tracker_mesh_auth_failed", "Work Mesh tracker access was denied for this company", { status, code });
+    if (status === 400 || status === 422)
+        return new LanesError("tracker_mesh_validation_failed", "Work Mesh rejected the tracker record data", { status, code });
+    return new LanesError("tracker_mesh_unavailable", `Work Mesh tracker request failed: ${err instanceof Error ? err.message : String(err)}`, { status: Number.isFinite(status) ? status : undefined });
+}
+function toMesh(value) {
+    if (Array.isArray(value))
+        return value.map(toMesh);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase()),
+        toMesh(item),
+    ]));
+}
+function fromMesh(value) {
+    if (Array.isArray(value))
+        return value.map(fromMesh);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`),
+        fromMesh(item),
+    ]));
+}
+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 });
+    }
+    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 });
+    }
+    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 });
+    }
+    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,
+        company: company.slug,
+        project_id: projectId,
+        version: version,
+        created_at: createdAt,
+        updated_at: updatedAt,
+    };
+    return record;
+}
+function identityMatches(record, kind, id, company, projectId) {
+    return record.kind === kind && record.id === id && record.company === company.slug && record.project_id === projectId;
+}
+function equalValue(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+export function createWorkMeshTrackerStore(options) {
+    const { company, projectId } = options;
+    if (!company.slug.trim() || !company.uid.trim())
+        fail("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker storage", {});
+    if (!projectId.trim())
+        fail("tracker_project_invalid", "A project id is required for Work Mesh tracker storage", {});
+    const now = options.now ?? (() => new Date());
+    const request = options.request ?? (async (endpoint, init) => {
+        const token = await requireToken({ interactive: false });
+        return meshJson(token, endpoint, init);
+    });
+    const requestJson = async (endpoint, init) => {
+        try {
+            const result = await request(endpoint, init);
+            if (!result || typeof result !== "object" || Array.isArray(result)) {
+                return fail("tracker_mesh_response_invalid", "Work Mesh returned an invalid tracker response", { endpoint });
+            }
+            return result;
+        }
+        catch (err) {
+            throw mapWorkMeshTrackerError(err);
+        }
+    };
+    const list = async (kind) => {
+        const records = [];
+        let cursor;
+        for (let page = 0; page < MAX_RECORD_PAGES; page += 1) {
+            const query = { companyUid: company.uid, projectId, kind, limit: "100", ...(cursor ? { cursor } : {}) };
+            const result = await requestJson(ROOT, { method: "GET", query });
+            if (!Array.isArray(result.threads))
+                return fail("tracker_mesh_response_invalid", "Work Mesh tracker list did not include a threads array", { kind, project_id: projectId });
+            for (const row of result.threads)
+                records.push(recordFromMeta(row, company, projectId, kind));
+            if (result.nextCursor === undefined)
+                return records.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
+            if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor) {
+                return fail("tracker_mesh_response_invalid", "Work Mesh tracker list returned an invalid pagination cursor", { kind, project_id: projectId });
+            }
+            cursor = result.nextCursor;
+        }
+        return fail("tracker_mesh_response_incomplete", "Work Mesh tracker list exceeded its bounded page limit", { kind, project_id: projectId, max_pages: MAX_RECORD_PAGES });
+    };
+    const read = async (kind, id) => {
+        const record = (await list(kind)).find((candidate) => candidate.id === id);
+        if (record && !identityMatches(record, kind, id, company, projectId)) {
+            return fail("tracker_company_mismatch", "Work Mesh tracker record does not belong to the selected company and project", { kind, id, project_id: projectId });
+        }
+        return record ?? null;
+    };
+    return {
+        read,
+        list,
+        async create(input) {
+            if (input.company !== company.slug || input.project_id !== projectId) {
+                return fail("tracker_company_mismatch", "Tracker record company and project must match the resolved Work Mesh scope", { company: input.company, project_id: input.project_id });
+            }
+            const clientRecordId = input.id ?? (options.clientRecordId ?? randomUUID)();
+            const { id: _id, company: _company, project_id: _projectId, kind, ...fields } = input;
+            const result = await requestJson(ROOT, {
+                method: "POST",
+                body: { companyUid: company.uid, kind, projectId, clientRecordId, ...toMesh(fields) },
+            });
+            if (typeof result.threadId !== "string" || !result.threadId || !Number.isSafeInteger(result.version) || result.version < 1 || typeof result.createdAt !== "string" || !Number.isFinite(Date.parse(result.createdAt))) {
+                return fail("tracker_mesh_response_invalid", "Work Mesh did not return valid tracker creation metadata", { kind, project_id: projectId });
+            }
+            const createdAt = result.createdAt;
+            return {
+                ...input,
+                schema_version: "hq-lanes-tracker-record.v1",
+                kind,
+                id: result.threadId,
+                company: company.slug,
+                project_id: projectId,
+                version: result.version,
+                created_at: createdAt,
+                updated_at: typeof result.lastActivityAt === "string" ? result.lastActivityAt : createdAt,
+            };
+        },
+        async update(kind, id, expectedVersion, change, metadata) {
+            const current = await read(kind, id);
+            if (!current)
+                return fail("tracker_record_not_found", `Tracker ${kind} record ${id} was not found`, { kind, id, project_id: projectId });
+            if (current.version !== expectedVersion) {
+                return fail("tracker_version_conflict", `Tracker record version conflict: expected ${expectedVersion}, found ${current.version}`, { kind, id, expected: expectedVersion, actual: current.version });
+            }
+            const changed = change(current);
+            if (changed.id !== current.id || changed.kind !== current.kind || changed.company !== current.company || changed.project_id !== current.project_id || changed.created_at !== current.created_at) {
+                return fail("tracker_update_invalid", "Tracker update cannot change record identity", { kind, id });
+            }
+            const patch = Object.fromEntries(Object.entries(changed).filter(([key, value]) => !["schema_version", "kind", "id", "company", "project_id", "version", "created_at", "updated_at"].includes(key) && !equalValue(current[key], value)));
+            if (Object.keys(patch).length === 0)
+                return current;
+            const currentValues = Array.isArray(current.values) ? current.values : [];
+            const changedValues = Array.isArray(changed.values) ? changed.values : [];
+            const isKpiAppend = kind === "kpi" && changedValues.length === currentValues.length + 1 && currentValues.every((value, index) => equalValue(value, changedValues[index]));
+            const currentAcks = Array.isArray(current.acknowledgements) ? current.acknowledgements : [];
+            const changedAcks = Array.isArray(changed.acknowledgements) ? changed.acknowledgements : [];
+            const isAckAppend = kind === "directive" && changedAcks.length === currentAcks.length + 1 && currentAcks.every((value, index) => equalValue(value, changedAcks[index]));
+            let version;
+            let updatedAt = now().toISOString();
+            if (isKpiAppend) {
+                const value = changedValues.at(-1);
+                const response = await requestJson(`${ROOT}/${encodeURIComponent(id)}/events`, {
+                    method: "POST",
+                    body: { companyUid: company.uid, eventKind: "kpi_value", payload: toMesh(value) },
+                });
+                version = Number(response.version ?? current.version + 1);
+                if (typeof response.createdAt === "string")
+                    updatedAt = response.createdAt;
+            }
+            else if (isAckAppend) {
+                const ack = changedAcks.at(-1);
+                const response = await requestJson(`${ROOT}/${encodeURIComponent(id)}/events`, {
+                    method: "POST",
+                    body: { companyUid: company.uid, eventKind: "ack", payload: toMesh(ack) },
+                });
+                version = Number(response.version ?? current.version + 1);
+                if (typeof response.createdAt === "string")
+                    updatedAt = response.createdAt;
+            }
+            else {
+                const action = kind === "blocker" && current.resolved_at == null && changed.resolved_at != null
+                    ? "resolve"
+                    : ((kind === "kpi" || kind === "okr") && changed.status === "approved" && current.status !== "approved")
+                        ? "approve"
+                        : "update";
+                const result = await requestJson(`${ROOT}/${encodeURIComponent(id)}`, {
+                    method: "PATCH",
+                    body: { companyUid: company.uid, action, expectedVersion, ...(action === "approve" && metadata?.approvalQuestionId ? { approvalQuestionId: metadata.approvalQuestionId } : {}), ...toMesh(patch) },
+                });
+                version = Number(result.version);
+                if (typeof result.lastActivityAt === "string")
+                    updatedAt = result.lastActivityAt;
+            }
+            if (!Number.isSafeInteger(version) || version <= current.version) {
+                return fail("tracker_mesh_response_invalid", "Work Mesh tracker update returned an invalid version", { kind, id });
+            }
+            return { ...changed, schema_version: "hq-lanes-tracker-record.v1", version, created_at: current.created_at, updated_at: updatedAt };
+        },
+    };
+}
+//# sourceMappingURL=tracker-mesh.js.map

package/dist/lib/lanes/tracker-store.d.ts

@@ -17,11 +17,22 @@ export interface TrackerRecordInput {
     project_id: string;
     [key: string]: unknown;
 }
+export type StoreValue<T> = T | Promise<T>;
 export interface TrackerStore {
+    read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
+    list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
+    create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
+        approvalQuestionId?: string;
+    }): StoreValue<TrackerRecord>;
+}
+export interface LocalTrackerStore extends TrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
     create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
+        approvalQuestionId?: string;
+    }): TrackerRecord;
 }
-export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): TrackerStore;
+export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map

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

@@ -238,7 +238,7 @@ export function createLocalTrackerStore(projectDirectory, now = () => new Date()
             writeExclusive(path.join(directory, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`);
             return record;
         },
-        update(kind, id, expectedVersion, change) {
+        update(kind, id, expectedVersion, change, _metadata) {
             const file = recordPath(root, kind, id);
             const directory = ensureKindDirectory(root, kind);
             return withRecordLock(file, () => {

package/dist/lib/lanes/types.d.ts

@@ -638,6 +638,10 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
+    /** Work Mesh's server-issued id; absent for pre-TRK-9 local questions. */
+    mesh_question_id?: string;
+    /** Local checkpoint that the server accepted this question's delivery stamp. */
+    mesh_delivered_at?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/dist/utils/table-width.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Return the largest measured cell length without passing an unbounded number
+ * of values as function arguments. Large vault tables can contain hundreds of
+ * thousands of rows, beyond the argument limit of Math.max(...values).
+ */
+export declare function maxLength<T>(values: Iterable<T>, measure: (value: T) => number, floor: number): number;
+//# sourceMappingURL=table-width.d.ts.map

package/dist/utils/table-width.js

@@ -0,0 +1,15 @@
+/**
+ * Return the largest measured cell length without passing an unbounded number
+ * of values as function arguments. Large vault tables can contain hundreds of
+ * thousands of rows, beyond the argument limit of Math.max(...values).
+ */
+export function maxLength(values, measure, floor) {
+    let maximum = floor;
+    for (const value of values) {
+        const length = measure(value);
+        if (length > maximum)
+            maximum = length;
+    }
+    return maximum;
+}
+//# sourceMappingURL=table-width.js.map

package/package.json

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