@indigoai-us/hq-cli 5.186.0 → 5.188.0

package/dist/lib/lanes/store.js

@@ -473,6 +473,9 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (raw.account_selection !== undefined) {
+        parseLaneAccountSelection(raw.account_selection, filePath);
+    }
     if (raw.placement_default !== undefined) {
         const placement = raw.placement_default;
         if (!isPlainObject(placement) ||
@@ -494,6 +497,89 @@ export function parseLaneRecord(raw, filePath) {
     // a parse/rewrite cycle (spec §5.1 field-preservation).
     return raw;
 }
+function parseLaneAccountSelection(value, filePath) {
+    const failure = (field) => new LaneSchemaError(`Invalid account_selection.${field}`, {
+        path: filePath,
+        field: `account_selection.${field}`,
+    });
+    if (!isPlainObject(value))
+        throw failure("must be an object");
+    const selection = value;
+    if (typeof selection.account !== "string" || selection.account.trim() === "")
+        throw failure("account");
+    if (selection.signal !== "usage" && selection.signal !== "lane_count" && selection.signal !== "explicit")
+        throw failure("signal");
+    if (selection.reason !== "least_loaded" && selection.reason !== "explicit")
+        throw failure("reason");
+    if (typeof selection.selected_at !== "string" || !Number.isFinite(Date.parse(selection.selected_at)))
+        throw failure("selected_at");
+    const parseHost = (host, field) => {
+        if (!isPlainObject(host) || !isHostKind(host.kind) || typeof host.id !== "string" || host.id.trim() === "")
+            throw failure(field);
+    };
+    parseHost(selection.target_host, "target_host");
+    if (!Array.isArray(selection.considered) || !Array.isArray(selection.skipped_accounts) || !Array.isArray(selection.unavailable_hosts)) {
+        throw failure("arrays");
+    }
+    for (const [index, rowValue] of selection.considered.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`considered.${index}`);
+        const row = rowValue;
+        if (typeof row.account !== "string" || row.account.trim() === "" || typeof row.eligible !== "boolean" || typeof row.live_lanes !== "number" || !Number.isInteger(row.live_lanes) || row.live_lanes < 0 || typeof row.counts_complete !== "boolean" || !Array.isArray(row.hosts))
+            throw failure(`considered.${index}`);
+        if (row.ineligible_reason !== undefined && typeof row.ineligible_reason !== "string")
+            throw failure(`considered.${index}.ineligible_reason`);
+        if (row.usage !== null) {
+            if (!isPlainObject(row.usage))
+                throw failure(`considered.${index}.usage`);
+            for (const key of ["five_hour_percent", "weekly_percent"]) {
+                const percent = row.usage[key];
+                if (percent !== undefined && (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0 || percent > 100))
+                    throw failure(`considered.${index}.usage.${key}`);
+            }
+            if (row.usage.sampled_at !== undefined && (typeof row.usage.sampled_at !== "string" || !Number.isFinite(Date.parse(row.usage.sampled_at))))
+                throw failure(`considered.${index}.usage.sampled_at`);
+        }
+        for (const [hostIndex, hostValue] of row.hosts.entries()) {
+            if (!isPlainObject(hostValue))
+                throw failure(`considered.${index}.hosts.${hostIndex}`);
+            const host = hostValue;
+            parseHost(host.host, `considered.${index}.hosts.${hostIndex}.host`);
+            if (typeof host.enabled !== "boolean" || !(host.logged_in === null || typeof host.logged_in === "boolean"))
+                throw failure(`considered.${index}.hosts.${hostIndex}.status`);
+            if (!(host.live_lanes === null || (typeof host.live_lanes === "number" && Number.isInteger(host.live_lanes) && host.live_lanes >= 0)))
+                throw failure(`considered.${index}.hosts.${hostIndex}.live_lanes`);
+            if (!isPlainObject(host.lane_counts))
+                throw failure(`considered.${index}.hosts.${hostIndex}.lane_counts`);
+            for (const key of ["running", "queued", "awaiting_input"]) {
+                const count = host.lane_counts[key];
+                if (!(count === null || (typeof count === "number" && Number.isInteger(count) && count >= 0)))
+                    throw failure(`considered.${index}.hosts.${hostIndex}.lane_counts.${key}`);
+            }
+            if (!["lane_list", "capacity", "capacity_partial", "unavailable"].includes(String(host.count_source)))
+                throw failure(`considered.${index}.hosts.${hostIndex}.count_source`);
+        }
+    }
+    for (const [index, rowValue] of selection.skipped_accounts.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`skipped_accounts.${index}`);
+        const row = rowValue;
+        if (typeof row.account !== "string" || row.account.trim() === "" || typeof row.reason !== "string" || row.reason.trim() === "")
+            throw failure(`skipped_accounts.${index}`);
+        parseHost(row.host, `skipped_accounts.${index}.host`);
+    }
+    for (const [index, rowValue] of selection.unavailable_hosts.entries()) {
+        if (!isPlainObject(rowValue))
+            throw failure(`unavailable_hosts.${index}`);
+        const row = rowValue;
+        if (typeof row.reason !== "string" || row.reason.trim() === "")
+            throw failure(`unavailable_hosts.${index}`);
+        if (isPlainObject(row.host) && row.host.kind === "unknown" && row.host.id === "unknown")
+            continue;
+        parseHost(row.host, `unavailable_hosts.${index}.host`);
+    }
+    return selection;
+}
 export function parseQuestionRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Question record must be a JSON object", {

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

@@ -230,6 +230,52 @@ export interface LaneHost {
     kind: HostKind;
     id: string;
 }
+export interface LaneAccountSelectionHostCount {
+    host: LaneHost;
+    enabled: boolean;
+    logged_in: boolean | null;
+    live_lanes: number | null;
+    lane_counts: {
+        running: number | null;
+        queued: number | null;
+        awaiting_input: number | null;
+    };
+    count_source: "lane_list" | "capacity" | "capacity_partial" | "unavailable";
+}
+export interface LaneAccountSelectionConsidered {
+    account: string;
+    eligible: boolean;
+    ineligible_reason?: string;
+    live_lanes: number;
+    counts_complete: boolean;
+    usage: {
+        five_hour_percent?: number;
+        weekly_percent?: number;
+        sampled_at?: string;
+    } | null;
+    hosts: LaneAccountSelectionHostCount[];
+}
+/** Decision evidence saved with a Claude lane when account balancing is active. */
+export interface LaneAccountSelection {
+    account: string;
+    signal: "usage" | "lane_count" | "explicit";
+    reason: "least_loaded" | "explicit";
+    target_host: LaneHost;
+    selected_at: string;
+    considered: LaneAccountSelectionConsidered[];
+    skipped_accounts: Array<{
+        account: string;
+        host: LaneHost;
+        reason: string;
+    }>;
+    unavailable_hosts: Array<{
+        host: LaneHost | {
+            kind: "unknown";
+            id: "unknown";
+        };
+        reason: string;
+    }>;
+}
 export interface SeniorHistoryEntry {
     from: SeniorRef;
     to: SeniorRef;
@@ -309,6 +355,8 @@ export interface LaneRecord {
     worker_policy_delivery?: "hook" | "prompt";
     provider: LaneProvider;
     account?: string;
+    /** Recent Claude account-selection evidence for a create or automatic resume move. */
+    account_selection?: LaneAccountSelection;
     /** Eligible accounts for a queue entry created without an explicit account. */
     admission_accounts?: string[];
     /**

package/dist/lib/lanes/types.js

@@ -224,7 +224,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
+    provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
     last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],

package/dist/lib/mesh/live/report-summary.js

@@ -75,14 +75,27 @@ export function extractLastAssistantText(jsonl) {
         const type = typeof obj.type === "string" ? obj.type : "";
         const role = typeof obj.role === "string" ? obj.role : "";
         const payload = obj.payload;
+        const item = obj.item;
+        const message = obj.message;
         let text = "";
         if (type === "assistant" || role === "assistant") {
             text = textFromUnknown(obj.message ?? obj.content);
         }
+        else if (message && (message.role === "assistant" || message.type === "assistant")) {
+            text = textFromUnknown(message.content ?? message.text ?? message);
+        }
         else if (payload &&
             (payload.type === "agent_message" || payload.type === "assistant")) {
             text = textFromUnknown(payload.message ?? payload.content ?? payload.text);
         }
+        else if (type === "item.completed" &&
+            item &&
+            item.type === "agent_message") {
+            text = textFromUnknown(item.text ?? item.content ?? item.message);
+        }
+        else if (type === "result" && typeof obj.result === "string") {
+            text = obj.result;
+        }
         const trimmed = text.trim();
         if (trimmed)
             last = trimmed;

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

@@ -4,6 +4,15 @@ export declare function mergeProjectStories(current: MeshProjectStoryInput[], pl
     resetStatus?: boolean;
 }): MeshProjectStoryInput[];
 export declare function boardStoryStatus(story: MeshProjectStoryInput): string;
+/**
+ * Keep only prd-sync task_status events whose Board status actually differs.
+ * Missing Board rows stay (ensure will add them). Same-status replays of
+ * already-done stories must not be sent again (US-051b).
+ */
+export declare function prdSyncEventsThatChangeBoard<T extends {
+    taskId: string;
+    status: string;
+}>(events: readonly T[], boardStories: readonly MeshProjectStoryInput[]): T[];
 /** One-line summary of live→next status diffs for existing story ids. */
 export declare function formatStoryStatusChanges(current: MeshProjectStoryInput[], next: MeshProjectStoryInput[]): string | undefined;
 /**

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

@@ -34,6 +34,15 @@ export function boardStoryStatus(story) {
         return story.status;
     return story.passes === true ? "done" : "queued";
 }
+/**
+ * Keep only prd-sync task_status events whose Board status actually differs.
+ * Missing Board rows stay (ensure will add them). Same-status replays of
+ * already-done stories must not be sent again (US-051b).
+ */
+export function prdSyncEventsThatChangeBoard(events, boardStories) {
+    const byId = new Map(boardStories.map((story) => [story.id, boardStoryStatus(story)]));
+    return events.filter((event) => byId.get(event.taskId) !== event.status);
+}
 /** 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]));

package/package.json

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