@indigoai-us/hq-cli 5.166.0 → 5.168.0

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

@@ -54,6 +54,12 @@ export declare function tryReadQuestion(hqRoot: string, questionId: string, deps
 export declare function readQuestion(hqRoot: string, questionId: string, deps?: StoreDeps): QuestionRecord;
 export declare function createLane(hqRoot: string, init: Omit<LaneRecord, "schema_version" | "lane_id" | "version" | "created_at" | "updated_at"> & Partial<Pick<LaneRecord, "schema_version" | "lane_id" | "version" | "created_at" | "updated_at">>, deps?: StoreDeps): LaneRecord;
 export declare function updateLane(hqRoot: string, laneId: string, expectedVersion: number, writer: LaneWriter, updater: (current: LaneRecord) => LaneRecord, deps?: StoreDeps): LaneRecord;
+/**
+ * Replace the primary copy with a terminal snapshot returned by the Outpost
+ * that owns the lane. The owner is authoritative on equal versions; a newer
+ * primary version is a conflict and must not be overwritten.
+ */
+export declare function syncLaneRecordFromOwner(hqRoot: string, laneId: string, outpostId: string, rawOwnerLane: unknown, deps?: StoreDeps): LaneRecord;
 /** Compare-and-set with conflict retry. Callers that race a concurrent writer re-read. */
 export declare function retryUpdateLane(hqRoot: string, laneId: string, writer: LaneWriter, updater: (current: LaneRecord) => LaneRecord, deps?: StoreDeps, attempts?: number): LaneRecord;
 /** Compare-and-set with conflict retry for question records (spec §6.2). */

package/dist/lib/lanes/store.js

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
-import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
+import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
 export const LANES_STORE_REL = path.join("workspace", "lanes");
 export const LANE_RECORDS_DIR = "lanes";
@@ -810,6 +810,71 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
         return updated;
     }, deps);
 }
+/**
+ * Replace the primary copy with a terminal snapshot returned by the Outpost
+ * that owns the lane. The owner is authoritative on equal versions; a newer
+ * primary version is a conflict and must not be overwritten.
+ */
+export function syncLaneRecordFromOwner(hqRoot, laneId, outpostId, rawOwnerLane, deps = defaultStoreDeps()) {
+    let ownerLane;
+    try {
+        ownerLane = parseLaneRecord(rawOwnerLane);
+    }
+    catch (err) {
+        throw new LanesError("outpost_lane_sync_invalid", `Outpost ${outpostId} returned an invalid lane snapshot for ${laneId}`, {
+            lane_id: laneId,
+            outpost_id: outpostId,
+            cause: err instanceof Error ? err.message : String(err),
+        });
+    }
+    if (ownerLane.lane_id !== laneId ||
+        ownerLane.host.kind !== "outpost" ||
+        ownerLane.host.id !== outpostId ||
+        !isTerminalLaneState(ownerLane.state)) {
+        throw new LanesError("outpost_lane_sync_invalid", `Outpost ${outpostId} did not return its terminal record for lane ${laneId}`, {
+            lane_id: laneId,
+            outpost_id: outpostId,
+            owner_lane_id: ownerLane.lane_id,
+            owner_host: ownerLane.host,
+            owner_state: ownerLane.state,
+        });
+    }
+    const filePath = laneRecordPath(hqRoot, laneId);
+    return withRecordLock(filePath, deps, () => {
+        const current = readMergedRecord(filePath, parseLaneRecord, mergeLaneRecords, deps);
+        if (current === null) {
+            throw new LaneSchemaError(`Record disappeared under lock: ${filePath}`, {
+                path: filePath,
+            });
+        }
+        if (current.lane_id !== laneId ||
+            current.host.kind !== "outpost" ||
+            current.host.id !== outpostId) {
+            throw new LanesError("outpost_lane_sync_conflict", `Primary lane ${laneId} is no longer owned by Outpost ${outpostId}`, {
+                lane_id: laneId,
+                outpost_id: outpostId,
+                current_lane_id: current.lane_id,
+                current_host: current.host,
+            });
+        }
+        if (ownerLane.version < current.version) {
+            throw new LanesError("outpost_lane_sync_conflict", `Outpost ${outpostId} returned lane ${laneId} at version ${ownerLane.version}, behind primary version ${current.version}`, {
+                lane_id: laneId,
+                outpost_id: outpostId,
+                owner_version: ownerLane.version,
+                primary_version: current.version,
+            });
+        }
+        const ownerSnapshot = ownerLane.outpost_command_id === undefined &&
+            current.outpost_command_id !== undefined
+            ? { ...ownerLane, outpost_command_id: current.outpost_command_id }
+            : ownerLane;
+        const synced = mergeLaneRecords(ownerSnapshot, [current]);
+        parseLaneRecord(synced, filePath);
+        atomicWriteJson(filePath, synced, deps);
+        return synced;
+    });
+}
 /** Compare-and-set with conflict retry. Callers that race a concurrent writer re-read. */
 export function retryUpdateLane(hqRoot, laneId, writer, updater, deps = defaultStoreDeps(), attempts = 5) {
     let last;

package/dist/lib/mesh/live/session-events-client.js

@@ -22,14 +22,15 @@ function parseRetryAfterMs(value, nowMs = Date.now()) {
     const trimmed = value.trim();
     if (/^\d+$/.test(trimmed)) {
         const delayMs = Number(trimmed) * 1_000;
-        return Number.isSafeInteger(delayMs) ? delayMs : undefined;
+        return Number.isSafeInteger(delayMs) && delayMs > 0 ? delayMs : undefined;
     }
     if (/^[+-]/.test(trimmed))
         return undefined;
     const retryAtMs = Date.parse(trimmed);
     if (!Number.isFinite(retryAtMs))
         return undefined;
-    return Math.max(0, retryAtMs - nowMs);
+    const delayMs = retryAtMs - nowMs;
+    return delayMs > 0 ? delayMs : undefined;
 }
 function retryAfterForStatus(status, headers) {
     if (status !== 429 && status !== 503)

package/dist/lib/mesh/project-board.d.ts

@@ -1,4 +1,11 @@
 import { type MeshCompany, type MeshProjectRegistration, type MeshProjectRepo, type MeshProjectStoryInput, type MeshProjectView } from "./api.js";
+/** Same merge as `hq mesh project ensure`: add missing stories, keep live status. */
+export declare function mergeProjectStories(current: MeshProjectStoryInput[], planned: MeshProjectStoryInput[], opts?: {
+    resetStatus?: boolean;
+}): MeshProjectStoryInput[];
+export declare function boardStoryStatus(story: MeshProjectStoryInput): string;
+/** One-line summary of live→next status diffs for existing story ids. */
+export declare function formatStoryStatusChanges(current: MeshProjectStoryInput[], next: MeshProjectStoryInput[]): string | undefined;
 /**
  * Add Board stories that a prd-sync emit is about to name, when they are missing.
  * A missing view uses ensureProjectBoard. An existing view is merged so live

package/dist/lib/mesh/project-board.js

@@ -6,13 +6,19 @@ function httpStatus(err) {
     return undefined;
 }
 /** Same merge as `hq mesh project ensure`: add missing stories, keep live status. */
-function mergeProjectStories(current, planned) {
+export function mergeProjectStories(current, planned, opts) {
     const currentById = new Map(current.map((story) => [story.id, story]));
     const plannedIds = new Set(planned.map((story) => story.id));
     const merged = planned.map((story) => {
         const live = currentById.get(story.id);
         if (!live)
             return story;
+        if (opts?.resetStatus) {
+            return {
+                ...story,
+                ...(live.assigneeUid ? { assigneeUid: live.assigneeUid } : {}),
+            };
+        }
         const status = live.status || story.status;
         return {
             ...story,
@@ -23,6 +29,28 @@ function mergeProjectStories(current, planned) {
     });
     return [...merged, ...current.filter((story) => !plannedIds.has(story.id))];
 }
+export function boardStoryStatus(story) {
+    if (story.status)
+        return story.status;
+    return story.passes === true ? "done" : "queued";
+}
+/** One-line summary of live→next status diffs for existing story ids. */
+export function formatStoryStatusChanges(current, next) {
+    const currentById = new Map(current.map((story) => [story.id, story]));
+    const changes = [];
+    for (const story of next) {
+        const live = currentById.get(story.id);
+        if (!live)
+            continue;
+        const from = boardStoryStatus(live);
+        const to = boardStoryStatus(story);
+        if (from !== to)
+            changes.push(`${story.id} ${from}→${to}`);
+    }
+    if (changes.length === 0)
+        return undefined;
+    return `Work mesh: project set changed status: ${changes.join(", ")}`;
+}
 function mergeProjectRepos(current, planned) {
     const plannedPaths = new Set(planned.map((repo) => repo.path));
     return [...planned, ...current.filter((repo) => !plannedPaths.has(repo.path))];

package/package.json

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