@indigoai-us/hq-cli 5.345.175 → 5.345.177

package/dist/lib/sync-core/engine-home.js

@@ -72,10 +72,11 @@ export function writeEngineHome(opts) {
     }
     return { engineHome, changed: configChanged || ownedChanged };
 }
+export const SYNC_CORE_STATUS_WORK_LIMIT = 20;
 function count(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
 }
-export function engineReadOnlyPlan(engineHome, vaultUid) {
+export function engineFirstCycle(engineHome, vaultUid, since) {
     let status;
     try {
         status = record(JSON.parse(fs.readFileSync(path.join(engineHome, ".hq", "sync-core", "status.json"), "utf8")));
@@ -83,30 +84,30 @@ export function engineReadOnlyPlan(engineHome, vaultUid) {
     catch {
         return null;
     }
-    if (record(status?.mode)?.value !== "readonly")
+    if (record(status?.mode)?.value !== "full")
         return null;
-    const lastPlan = record(status?.last_plan);
-    if (!lastPlan || typeof lastPlan.at_ms !== "number" || lastPlan.at_ms <= 0)
+    const cycle = record(status?.last_canary);
+    if (!cycle || cycle.vault !== vaultUid || cycle.full_vault !== true)
         return null;
-    const vaults = Array.isArray(lastPlan.vaults) ? lastPlan.vaults : [];
-    const run = vaults.map(record).find((v) => v?.vault === vaultUid);
-    if (!run)
+    const sinceMs = Date.parse(since);
+    if (typeof cycle.at_ms !== "number" || cycle.at_ms <= 0 || !Number.isFinite(sinceMs) || cycle.at_ms < sinceMs)
         return null;
-    const errors = Array.isArray(lastPlan.errors) ? lastPlan.errors : [];
-    if (errors.some((e) => {
-        const vault = record(e)?.vault;
-        return vault === vaultUid || typeof vault !== "string";
-    }))
-        return null;
-    const ops = record(record(run.plan)?.ops_by_action) ?? {};
+    const work = (Array.isArray(cycle.work) ? cycle.work : []).map(record).filter((item) => item !== undefined);
+    const actions = (...names) => work.filter((item) => names.includes(String(item.action))).length;
     return {
-        at: new Date(lastPlan.at_ms).toISOString(),
-        uploads: count(ops.upload),
-        downloads: count(ops.download),
-        deletes: count(ops.delete_local) + count(ops.delete_remote),
-        conflicts: count(ops.conflict) + count(ops.merge),
-        remoteRows: count(record(run.remote)?.rows),
-        localFiles: count(record(run.local)?.files),
+        at: new Date(cycle.at_ms).toISOString(),
+        planned: count(cycle.planned),
+        completed: count(cycle.completed),
+        pending: count(cycle.pending),
+        held: count(cycle.held),
+        notApplied: count(cycle.not_applied),
+        uploads: actions("upload"),
+        downloads: actions("download"),
+        deletes: actions("delete_local", "delete_remote"),
+        conflicts: actions("conflict", "merge"),
+        deferred: actions("deferred"),
+        listed: work.length,
+        truncated: work.length >= SYNC_CORE_STATUS_WORK_LIMIT,
     };
 }
 export function clearEngineStatus(home, vaultUid) {

package/dist/lib/sync-core/manifest-scopes.d.ts

@@ -0,0 +1,15 @@
+import type { VaultSyncSwitches } from "../vault-sync-switches.js";
+export interface EngineManifestVault {
+    kind: "personal" | "company";
+    slug?: string;
+    phase: "warming" | "full";
+}
+export type EngineManifestScope = {
+    kind: "personal";
+} | {
+    kind: "company";
+    slug: string;
+};
+export declare function engineOwnedManifestScopes(switches: Pick<VaultSyncSwitches, "allOff" | "personalOff" | "offCompanies"> | undefined, vaults: readonly EngineManifestVault[] | undefined): EngineManifestScope[];
+export declare function manifestScopeArg(scope: EngineManifestScope): string;
+//# sourceMappingURL=manifest-scopes.d.ts.map

package/dist/lib/sync-core/manifest-scopes.js

@@ -0,0 +1,26 @@
+export function engineOwnedManifestScopes(switches, vaults) {
+    if (!switches || switches.allOff)
+        return [];
+    let personal = false;
+    const companies = new Set();
+    for (const vault of vaults ?? []) {
+        if (vault.phase !== "full")
+            continue;
+        if (vault.kind === "personal") {
+            if (switches.personalOff)
+                personal = true;
+            continue;
+        }
+        const slug = vault.slug?.trim().toLowerCase();
+        if (slug && switches.offCompanies.has(slug))
+            companies.add(slug);
+    }
+    const scopes = personal ? [{ kind: "personal" }] : [];
+    for (const slug of [...companies].sort())
+        scopes.push({ kind: "company", slug });
+    return scopes;
+}
+export function manifestScopeArg(scope) {
+    return scope.kind === "personal" ? "personal" : scope.slug;
+}
+//# sourceMappingURL=manifest-scopes.js.map

package/dist/lib/sync-core/reconcile.d.ts

@@ -1,4 +1,4 @@
-import { type SyncCorePlanFigures, type SyncCoreVault } from "./engine-home.js";
+import { type SyncCoreVault } from "./engine-home.js";
 import { type SyncCoreBinaryInstall } from "./release.js";
 import { type SyncCoreRolloutState } from "./rollout-state.js";
 export interface SyncCoreMembership {
@@ -26,6 +26,6 @@ export interface SyncCoreReconcileResult {
     kept: string[];
     warnings: string[];
 }
-export declare function promotionHold(vault: SyncCoreVault, plan: SyncCorePlanFigures, release: string): string | undefined;
+export declare function companyFullHold(vault: SyncCoreVault, release: string): string | undefined;
 export declare function reconcileSyncCore(deps: SyncCoreReconcileDeps): Promise<SyncCoreReconcileResult>;
 //# sourceMappingURL=reconcile.d.ts.map

package/dist/lib/sync-core/reconcile.js

@@ -2,28 +2,18 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { readCompaniesManifestMap } from "../work-context/repo-remote.js";
 import { readVaultSyncSwitches, writeVaultSyncSwitches } from "../vault-sync-switches.js";
-import { clearEngineStatus, engineReadOnlyPlan, removeEngineOwnership, syncCoreEngineHome, writeEngineHome, } from "./engine-home.js";
-import { SYNC_CORE_COMPANY_FULL_RELEASE, SYNC_CORE_PROMOTION_OP_LIMIT, SYNC_CORE_RELEASE, companyFullModeAllowed, installedSyncCoreRelease, syncCoreBinaryPath, } from "./release.js";
+import { clearEngineStatus, engineFirstCycle, isSyncCoreVaultUid, removeEngineOwnership, syncCoreEngineHome, writeEngineHome, } from "./engine-home.js";
+import { SYNC_CORE_COMPANY_FULL_RELEASE, SYNC_CORE_RELEASE, companyFullModeAllowed, installedSyncCoreRelease, syncCoreBinaryPath, } from "./release.js";
 import { readSyncCoreSkips } from "./skip.js";
-import { readSyncCoreRolloutState, writeSyncCoreRolloutState, } from "./rollout-state.js";
+import { readSyncCoreRolloutState, syncCoreRolloutStatePath, writeSyncCoreRolloutState, } from "./rollout-state.js";
 function message(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function promotionHold(vault, plan, release) {
-    if (vault.kind === "company" && !companyFullModeAllowed(release)) {
-        const needed = SYNC_CORE_COMPANY_FULL_RELEASE ? `engine release ${SYNC_CORE_COMPANY_FULL_RELEASE}` : "an engine release that";
-        return `company vaults stay read-only until ${needed} scopes the local tree to this account's visibility (${release} installed)`;
-    }
-    if (plan.deletes > SYNC_CORE_PROMOTION_OP_LIMIT) {
-        return `the read-only plan would delete ${plan.deletes} paths (limit ${SYNC_CORE_PROMOTION_OP_LIMIT})`;
-    }
-    if (plan.conflicts > SYNC_CORE_PROMOTION_OP_LIMIT) {
-        return `the read-only plan would write ${plan.conflicts} conflict or merge copies (limit ${SYNC_CORE_PROMOTION_OP_LIMIT})`;
-    }
-    if (plan.uploads > SYNC_CORE_PROMOTION_OP_LIMIT) {
-        return `the read-only plan would upload ${plan.uploads} files against ${plan.remoteRows} server rows (limit ${SYNC_CORE_PROMOTION_OP_LIMIT})`;
-    }
-    return undefined;
+export function companyFullHold(vault, release) {
+    if (vault.kind !== "company" || companyFullModeAllowed(release))
+        return undefined;
+    const needed = SYNC_CORE_COMPANY_FULL_RELEASE ? `engine release ${SYNC_CORE_COMPANY_FULL_RELEASE} or later` : "an engine release cleared for company vaults";
+    return `company vaults move to the new sync engine with ${needed} (${release} installed); staying on the current sync`;
 }
 function localCompanies(hqRoot, memberships) {
     const manifest = readCompaniesManifestMap(hqRoot) ?? {};
@@ -44,13 +34,41 @@ function localCompanies(hqRoot, memberships) {
     }
     return candidates;
 }
+function ownedVaultsWithoutState(home, hqRoot) {
+    if (!fs.existsSync(syncCoreRolloutStatePath(home)))
+        return [];
+    const slugByUid = new Map();
+    for (const [slug, entry] of Object.entries(readCompaniesManifestMap(hqRoot) ?? {})) {
+        if (typeof entry?.cloud_uid === "string" && /^[a-z0-9][a-z0-9_-]*$/.test(slug))
+            slugByUid.set(entry.cloud_uid, slug);
+    }
+    let uids;
+    try {
+        uids = fs.readdirSync(path.join(home, ".hq", "sync-core", "engines")).filter(isSyncCoreVaultUid);
+    }
+    catch {
+        return [];
+    }
+    const vaults = [];
+    for (const uid of uids) {
+        const engineHome = syncCoreEngineHome(home, uid);
+        if (!fs.existsSync(path.join(engineHome, ".hq", "sync-core", "owned", `${uid}.json`)))
+            continue;
+        const slug = slugByUid.get(uid);
+        if (uid.startsWith("cmp_") && !slug)
+            continue;
+        vaults.push({ uid, kind: uid.startsWith("prs_") ? "personal" : "company", ...(slug ? { slug } : {}), phase: "full", engineHome });
+    }
+    return vaults;
+}
 export async function reconcileSyncCore(deps) {
     const now = deps.now ?? (() => new Date());
     const log = deps.log ?? (() => { });
     const release = deps.release ?? SYNC_CORE_RELEASE;
     const warnings = [];
     const previous = readSyncCoreRolloutState(deps.home);
-    const previousByUid = new Map((previous?.vaults ?? []).map((vault) => [vault.uid, vault]));
+    const previousVaults = previous?.vaults ?? ownedVaultsWithoutState(deps.home, deps.hqRoot);
+    const previousByUid = new Map(previousVaults.map((vault) => [vault.uid, vault]));
     const memberships = await deps.listMemberships();
     const desired = [];
     let anyCompanyOn = false;
@@ -111,6 +129,15 @@ export async function reconcileSyncCore(deps) {
                 desired.length = 0;
         }
     }
+    const held = [];
+    const engineRelease = installedRelease ?? release;
+    for (let i = desired.length - 1; i >= 0; i -= 1) {
+        const reason = companyFullHold(desired[i], engineRelease);
+        if (!reason)
+            continue;
+        held.unshift({ uid: desired[i].uid, reason });
+        desired.splice(i, 1);
+    }
     const at = now().toISOString();
     const switchesBefore = readVaultSyncSwitches(deps.home);
     const vaults = [];
@@ -124,42 +151,36 @@ export async function reconcileSyncCore(deps) {
         const engineHome = syncCoreEngineHome(deps.home, vault.uid);
         if (!before)
             clearEngineStatus(deps.home, vault.uid);
-        const plan = engineReadOnlyPlan(engineHome, vault.uid) ?? undefined;
-        let phase = before?.phase === "full" ? "full" : "warming";
-        let hold;
-        if (phase === "warming" && plan) {
-            hold = promotionHold(vault, plan, installedRelease ?? release);
-            if (!hold)
-                phase = "full";
-        }
-        writeEngineHome({ home: deps.home, hqRoot: deps.hqRoot, vault, phase, tokenFile: deps.tokenFile });
+        writeEngineHome({ home: deps.home, hqRoot: deps.hqRoot, vault, phase: "full", tokenFile: deps.tokenFile });
+        const wasFull = before?.phase === "full";
         const alreadyOff = vault.kind === "personal"
             ? switchesBefore.personalOff
             : switchesBefore.offCompanies.has(vault.slug ?? "");
-        const legacyAlreadyOff = before?.phase === "full" ? before.legacyAlreadyOff === true : phase === "full" && alreadyOff;
-        const legacyOffSince = phase === "full" ? before?.legacyOffSince ?? at : undefined;
+        const legacyAlreadyOff = wasFull ? before.legacyAlreadyOff === true : alreadyOff;
+        const legacyOffSince = (wasFull ? before.legacyOffSince : undefined) ?? at;
+        const recorded = wasFull ? before.firstCycle : undefined;
+        const firstCycle = recorded && recorded.planned > 0
+            ? recorded
+            : engineFirstCycle(engineHome, vault.uid, legacyOffSince) ?? recorded;
         vaults.push({
             uid: vault.uid,
             kind: vault.kind,
             ...(vault.slug ? { slug: vault.slug } : {}),
-            phase,
+            phase: "full",
             engineHome,
-            ...(legacyOffSince ? { legacyOffSince } : {}),
+            legacyOffSince,
             ...(legacyAlreadyOff ? { legacyAlreadyOff: true } : {}),
-            ...(plan ? { plan } : {}),
-            ...(hold ? { hold } : {}),
+            ...(firstCycle ? { firstCycle } : {}),
         });
-        if (hold && before?.hold !== hold)
-            log(`${vault.uid}: staying read-only: ${hold}`);
-        if (phase === "full") {
-            if (vault.kind === "company" && vault.slug)
-                companies[vault.slug] = false;
-            else
-                personalOff = true;
-        }
+        if (firstCycle && firstCycle !== recorded && (!recorded || firstCycle.planned > 0))
+            log(`${vault.uid}: first full cycle ${firstCycle.at}: ${firstCycle.planned} planned, ${firstCycle.completed} completed, ${firstCycle.held} held`);
+        if (vault.kind === "company" && vault.slug)
+            companies[vault.slug] = false;
+        else
+            personalOff = true;
         if (!before)
             started.push(vault.uid);
-        else if (before.phase !== phase)
+        else if (!wasFull)
             promoted.push(vault.uid);
         else
             kept.push(vault.uid);
@@ -170,7 +191,7 @@ export async function reconcileSyncCore(deps) {
         if (desired.some((candidate) => candidate.uid === vault.uid))
             continue;
         stopped.push(vault.uid);
-        if (vault.phase !== "full" || vault.legacyAlreadyOff)
+        if (vault.phase !== "full")
             continue;
         if (vault.kind === "company" && vault.slug)
             companies[vault.slug] = true;
@@ -184,6 +205,7 @@ export async function reconcileSyncCore(deps) {
         binaryPath,
         vaults,
         ...(skipped.length > 0 ? { skipped } : {}),
+        ...(held.length > 0 ? { held } : {}),
         ...(warnings.length > 0 ? { error: warnings.join("; ") } : {}),
     };
     writeSyncCoreRolloutState(deps.home, state);
@@ -203,13 +225,15 @@ export async function reconcileSyncCore(deps) {
         writeSyncCoreRolloutState(deps.home, state);
     }
     for (const uid of started)
-        log(`${uid}: warming the new sync engine's index (home ${syncCoreEngineHome(deps.home, uid)})`);
+        log(`${uid}: moving to the new sync engine in full mode (home ${syncCoreEngineHome(deps.home, uid)})`);
     for (const uid of promoted)
-        log(`${uid}: index warm; moving to the new sync engine`);
+        log(`${uid}: moving from the read-only index to full mode on the new sync engine`);
     for (const uid of stopped)
         log(`${uid}: back on the current sync`);
     for (const skip of skipped)
         log(`${skip.uid}: skipped on this machine: ${skip.reason}`);
+    for (const hold of held)
+        log(`${hold.uid}: ${hold.reason}`);
     for (const warning of warnings)
         log(`warning: ${warning}`);
     return { state, started, promoted, stopped, kept, warnings };

package/dist/lib/sync-core/release.d.ts

@@ -1,6 +1,5 @@
-export declare const SYNC_CORE_RELEASE = "v0.1.13";
+export declare const SYNC_CORE_RELEASE = "v0.1.21";
 export declare const SYNC_CORE_COMPANY_FULL_RELEASE: string | null;
-export declare const SYNC_CORE_PROMOTION_OP_LIMIT = 100;
 export declare function compareSyncCoreReleases(a: string, b: string): number;
 export declare function companyFullModeAllowed(release: string): boolean;
 export declare const SYNC_CORE_DOWNLOAD_BASE = "https://indigoai-public.s3.amazonaws.com/hq-sync-core";
@@ -10,6 +9,7 @@ export declare function syncCoreReleaseMarkerPath(home?: string): string;
 export declare function syncCoreAssetName(release: string, platform: NodeJS.Platform, arch: string): string | null;
 export declare function syncCoreDownloadBase(env?: NodeJS.ProcessEnv): string;
 export declare function parseSha256Sums(text: string): Map<string, string>;
+export declare function syncCoreBinaryVersion(binaryPath: string): string | null;
 export declare function installedSyncCoreRelease(home: string): string | null;
 export interface EnsureSyncCoreBinaryOptions {
     home: string;

package/dist/lib/sync-core/release.js

@@ -3,9 +3,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { execFileSync } from "node:child_process";
-export const SYNC_CORE_RELEASE = "v0.1.13";
-export const SYNC_CORE_COMPANY_FULL_RELEASE = null;
-export const SYNC_CORE_PROMOTION_OP_LIMIT = 100;
+export const SYNC_CORE_RELEASE = "v0.1.21";
+export const SYNC_CORE_COMPANY_FULL_RELEASE = "v0.1.21";
 export function compareSyncCoreReleases(a, b) {
     const parse = (release) => release.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
     const [x, y] = [parse(a), parse(b)];
@@ -50,14 +49,27 @@ export function parseSha256Sums(text) {
     }
     return sums;
 }
+export function syncCoreBinaryVersion(binaryPath) {
+    try {
+        const out = execFileSync(binaryPath, ["--version"], { encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "ignore"] });
+        const match = /hq-syncd\s+v?(\d+\.\d+\.\d+)/.exec(out);
+        return match ? `v${match[1]}` : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function installedSyncCoreRelease(home) {
     try {
-        const marker = fs.readFileSync(syncCoreReleaseMarkerPath(home), "utf8").trim();
         const binary = syncCoreBinaryPath(home);
-        if (!marker || !fs.statSync(binary).isFile())
+        if (!fs.statSync(binary).isFile())
             return null;
         fs.accessSync(binary, fs.constants.X_OK);
-        return marker;
+        const reported = syncCoreBinaryVersion(binary);
+        if (reported)
+            return reported;
+        const marker = fs.readFileSync(syncCoreReleaseMarkerPath(home), "utf8").trim();
+        return marker || null;
     }
     catch {
         return null;
@@ -96,6 +108,19 @@ export async function ensureSyncCoreBinary(opts) {
     const binaryPath = syncCoreBinaryPath(opts.home);
     const installedRelease = installedSyncCoreRelease(opts.home);
     if (installedRelease && compareSyncCoreReleases(installedRelease, release) >= 0 && fs.existsSync(binaryPath)) {
+        const marker = syncCoreReleaseMarkerPath(opts.home);
+        let current = "";
+        try {
+            current = fs.readFileSync(marker, "utf8").trim();
+        }
+        catch {
+            current = "";
+        }
+        if (current !== installedRelease) {
+            const tmp = `${marker}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, `${installedRelease}\n`, { mode: 0o600 });
+            fs.renameSync(tmp, marker);
+        }
         return { binaryPath, release: installedRelease, installed: false };
     }
     const asset = syncCoreAssetName(release, opts.platform, opts.arch);

package/dist/lib/sync-core/rollout-state.d.ts

@@ -1,4 +1,4 @@
-import { type SyncCorePlanFigures, type SyncCoreVaultKind, type SyncCoreVaultPhase } from "./engine-home.js";
+import { type SyncCoreFirstCycle, type SyncCoreVaultKind, type SyncCoreVaultPhase } from "./engine-home.js";
 export interface RolloutVault {
     uid: string;
     kind: SyncCoreVaultKind;
@@ -7,8 +7,7 @@ export interface RolloutVault {
     engineHome: string;
     legacyOffSince?: string;
     legacyAlreadyOff?: true;
-    plan?: SyncCorePlanFigures;
-    hold?: string;
+    firstCycle?: SyncCoreFirstCycle;
 }
 export interface SyncCoreRolloutState {
     version: 1;
@@ -20,6 +19,10 @@ export interface SyncCoreRolloutState {
         uid: string;
         reason: string;
     }[];
+    held?: {
+        uid: string;
+        reason: string;
+    }[];
     error?: string;
 }
 export declare function syncCoreRolloutStatePath(home: string): string;

package/dist/lib/sync-core/rollout-state.js

@@ -1,26 +1,29 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isSyncCoreVaultUid } from "./engine-home.js";
-function planFigures(value) {
+const FIRST_CYCLE_COUNTS = [
+    "planned",
+    "completed",
+    "pending",
+    "held",
+    "notApplied",
+    "uploads",
+    "downloads",
+    "deletes",
+    "conflicts",
+    "deferred",
+    "listed",
+];
+function firstCycle(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
-    const p = value;
-    if (typeof p.at !== "string")
+    const c = value;
+    if (typeof c.at !== "string" || typeof c.truncated !== "boolean")
         return null;
-    const numbers = ["uploads", "downloads", "deletes", "remoteRows", "localFiles"];
-    if (numbers.some((key) => typeof p[key] !== "number" || !Number.isFinite(p[key])))
+    if (FIRST_CYCLE_COUNTS.some((key) => typeof c[key] !== "number" || !Number.isFinite(c[key])))
         return null;
-    if (p.conflicts !== undefined && (typeof p.conflicts !== "number" || !Number.isFinite(p.conflicts)))
-        return null;
-    return {
-        at: p.at,
-        uploads: p.uploads,
-        downloads: p.downloads,
-        deletes: p.deletes,
-        conflicts: typeof p.conflicts === "number" ? p.conflicts : 0,
-        remoteRows: p.remoteRows,
-        localFiles: p.localFiles,
-    };
+    const counts = Object.fromEntries(FIRST_CYCLE_COUNTS.map((key) => [key, c[key]]));
+    return { at: c.at, ...counts, truncated: c.truncated };
 }
 function skippedEntries(value) {
     if (value === undefined)
@@ -57,10 +60,8 @@ function vault(value) {
         return null;
     if (v.kind === "company" && (typeof v.slug !== "string" || !/^[a-z0-9][a-z0-9_-]*$/.test(v.slug)))
         return null;
-    const plan = v.plan === undefined ? undefined : planFigures(v.plan);
-    if (plan === null)
-        return null;
-    if (v.hold !== undefined && typeof v.hold !== "string")
+    const cycle = v.firstCycle === undefined ? undefined : firstCycle(v.firstCycle);
+    if (cycle === null)
         return null;
     return {
         uid: v.uid,
@@ -70,8 +71,7 @@ function vault(value) {
         engineHome: v.engineHome,
         ...(typeof v.legacyOffSince === "string" ? { legacyOffSince: v.legacyOffSince } : {}),
         ...(v.legacyAlreadyOff === true ? { legacyAlreadyOff: true } : {}),
-        ...(plan ? { plan } : {}),
-        ...(typeof v.hold === "string" ? { hold: v.hold } : {}),
+        ...(cycle ? { firstCycle: cycle } : {}),
     };
 }
 export function readSyncCoreRolloutState(home) {
@@ -95,6 +95,9 @@ export function readSyncCoreRolloutState(home) {
     const skipped = skippedEntries(obj.skipped);
     if (skipped === null)
         return null;
+    const held = skippedEntries(obj.held);
+    if (held === null)
+        return null;
     return {
         version: 1,
         readAt: obj.readAt,
@@ -102,6 +105,7 @@ export function readSyncCoreRolloutState(home) {
         binaryPath: obj.binaryPath,
         vaults: vaults,
         ...(skipped.length > 0 ? { skipped } : {}),
+        ...(held.length > 0 ? { held } : {}),
         ...(typeof obj.error === "string" ? { error: obj.error } : {}),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.175",
+  "version": "5.345.177",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -52,7 +52,7 @@
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
     "@aws-sdk/dsql-signer": "^3.1146.0",
-    "@indigoai-us/hq-cloud": "6.18.103",
+    "@indigoai-us/hq-cloud": "6.18.104",
     "@indigoai-us/hq-flags-client": "^0.1.2",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@sentry/node": "^10.49.0",
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.175",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.175",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.175",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.175",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.175",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.175"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.177",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.177",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.177",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.177",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.177",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.177"
   }
 }