@indigoai-us/hq-cli 5.345.172 → 5.345.173

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [5.345.173] — 2026-10-27
+- The sync-core reconcile now counts the conflict and merge actions in a vault's read-only plan as writes: a vault is held read-only while its plan would write more than 100 conflict or merge copies, the count is recorded next to the plan's upload, download and delete counts in `~/.hq/sync-core/rollout.json`, and `hq sync-core status` prints it.
+- A machine can keep one vault off the new sync engine while its company switch is on: `~/.hq/sync-core/skip.json` with `{"vaults": {"<vault uid>": "<reason>"}}` makes the reconcile leave that vault on the current sync (stopping its engine unit if one ran), record the uid and reason under `skipped` in `rollout.json`, and show it in `hq sync-core status`. A malformed file is reported as a warning and skips nothing.
+- The reconcile never downgrades the engine: when `~/.hq/bin/hq-syncd.release` names a release newer than the pinned one and the binary is present, it keeps that binary and runs the engine units with it.
+
 ## [5.345.172] — 2026-10-27
 - The daemon now moves vaults to the new sync engine by itself, following a per-company switch (`sync.rust-engine-rollout`) instead of a hand-written `syncCoreCanary` entry in `~/.hq/daemon/config.json`. A new `sync-core` service on desktop and self-hosted machines runs `hq daemon service sync-core-reconcile` every 10 minutes: it reads the switch for every company this machine belongs to, downloads the pinned hq-syncd release (v0.1.13) from the public mirror and checks it against the release's SHA256SUMS, installs it at `~/.hq/bin/hq-syncd`, writes one engine home per switched vault under `~/.hq/sync-core/engines/<vault>/`, and records the result in `~/.hq/sync-core/rollout.json`. Each vault's engine first runs read-only alongside the current sync until it has built its index and planned a pass; the reconcile records that plan's upload, download, delete, server-row and local-file counts per vault (`hq sync-core status` shows them). A vault is then promoted to full mode and turned off in the current sync (`menubar.json`) only when the plan would upload or delete at most 100 paths, and the daemon runs its `sync-core:<vault>` unit in full mode only after the current sync has stopped touching that vault. Company vaults stay read-only in this release: the engine's server snapshot is filtered by the caller's visibility while the current sync pulled the whole tree, so a full-mode company engine would upload the difference; promotion waits for an engine release that scopes the local tree the same way. The personal vault moves when at least one of the person's companies is switched on. When a switch turns off, the daemon stops that vault's engine, turns the current sync back on for it, and leaves the engine's index on disk. A switch that cannot be read keeps the vault where it was. `hq sync-core reconcile` and `hq sync-core status` run the same logic by hand (agent boxes run `reconcile --companies-only`). The old `syncCoreCanary` config key is ignored.
 

package/dist/commands/sync-core.js

@@ -85,11 +85,13 @@ export function runSyncCoreStatus(opts, d = defaultDeps()) {
         d.out(`  ${vault.uid}  ${vault.kind}${vault.slug ? ` ${vault.slug}` : ""}  ${vault.phase === "full" ? "full" : "read-only"}  legacy sync ${legacyOff ? "off" : "still on"}  home ${vault.engineHome}`);
         if (vault.plan) {
             const p = vault.plan;
-            d.out(`    plan ${p.at}: ${p.remoteRows} server rows, ${p.localFiles} local files; would upload ${p.uploads}, download ${p.downloads}, delete ${p.deletes}`);
+            d.out(`    plan ${p.at}: ${p.remoteRows} server rows, ${p.localFiles} local files; would upload ${p.uploads}, download ${p.downloads}, delete ${p.deletes}, write ${p.conflicts} conflict or merge copies`);
         }
         if (vault.hold)
             d.out(`    held read-only: ${vault.hold}`);
     }
+    for (const skip of state.skipped ?? [])
+        d.out(`  ${skip.uid}  skipped on this machine: ${skip.reason}`);
     if (state.vaults.length === 0)
         d.out("  no vault is switched to the new sync engine");
 }

package/dist/lib/sync-core/engine-home.d.ts

@@ -34,6 +34,7 @@ export interface SyncCorePlanFigures {
     uploads: number;
     downloads: number;
     deletes: number;
+    conflicts: number;
     remoteRows: number;
     localFiles: number;
 }

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

@@ -104,6 +104,7 @@ export function engineReadOnlyPlan(engineHome, vaultUid) {
         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),
     };

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

@@ -4,6 +4,7 @@ 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 { readSyncCoreSkips } from "./skip.js";
 import { readSyncCoreRolloutState, writeSyncCoreRolloutState, } from "./rollout-state.js";
 function message(error) {
     return error instanceof Error ? error.message : String(error);
@@ -16,6 +17,9 @@ export function promotionHold(vault, plan, release) {
     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})`;
     }
@@ -77,6 +81,20 @@ export async function reconcileSyncCore(deps) {
         if (personUid)
             desired.push({ uid: personUid, kind: "personal" });
     }
+    const skipped = [];
+    try {
+        const skips = readSyncCoreSkips(deps.home);
+        for (let i = desired.length - 1; i >= 0; i -= 1) {
+            const skip = skips.find((entry) => entry.uid === desired[i]?.uid);
+            if (!skip)
+                continue;
+            skipped.unshift(skip);
+            desired.splice(i, 1);
+        }
+    }
+    catch (error) {
+        warnings.push(message(error));
+    }
     let binaryPath = syncCoreBinaryPath(deps.home);
     let installedRelease = installedSyncCoreRelease(deps.home);
     if (desired.length > 0) {
@@ -165,6 +183,7 @@ export async function reconcileSyncCore(deps) {
         release: installedRelease ?? release,
         binaryPath,
         vaults,
+        ...(skipped.length > 0 ? { skipped } : {}),
         ...(warnings.length > 0 ? { error: warnings.join("; ") } : {}),
     };
     writeSyncCoreRolloutState(deps.home, state);
@@ -189,6 +208,8 @@ export async function reconcileSyncCore(deps) {
         log(`${uid}: index warm; moving to 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 warning of warnings)
         log(`warning: ${warning}`);
     return { state, started, promoted, stopped, kept, warnings };

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

@@ -94,8 +94,10 @@ async function download(fetcher, url) {
 export async function ensureSyncCoreBinary(opts) {
     const release = opts.release ?? SYNC_CORE_RELEASE;
     const binaryPath = syncCoreBinaryPath(opts.home);
-    if (installedSyncCoreRelease(opts.home) === release)
-        return { binaryPath, release, installed: false };
+    const installedRelease = installedSyncCoreRelease(opts.home);
+    if (installedRelease && compareSyncCoreReleases(installedRelease, release) >= 0 && fs.existsSync(binaryPath)) {
+        return { binaryPath, release: installedRelease, installed: false };
+    }
     const asset = syncCoreAssetName(release, opts.platform, opts.arch);
     if (!asset)
         throw new SyncCoreReleaseError(`the sync engine has no ${release} build for ${opts.platform} on ${opts.arch}`);

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

@@ -16,6 +16,10 @@ export interface SyncCoreRolloutState {
     release: string;
     binaryPath: string;
     vaults: RolloutVault[];
+    skipped?: {
+        uid: string;
+        reason: string;
+    }[];
     error?: string;
 }
 export declare function syncCoreRolloutStatePath(home: string): string;

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

@@ -10,15 +10,32 @@ function planFigures(value) {
     const numbers = ["uploads", "downloads", "deletes", "remoteRows", "localFiles"];
     if (numbers.some((key) => typeof p[key] !== "number" || !Number.isFinite(p[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,
     };
 }
+function skippedEntries(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        return null;
+    const out = [];
+    for (const entry of value) {
+        const e = entry && typeof entry === "object" ? entry : undefined;
+        if (!e || !isSyncCoreVaultUid(e.uid) || typeof e.reason !== "string")
+            return null;
+        out.push({ uid: e.uid, reason: e.reason });
+    }
+    return out;
+}
 export function syncCoreRolloutStatePath(home) {
     return path.join(home, ".hq", "sync-core", "rollout.json");
 }
@@ -75,12 +92,16 @@ export function readSyncCoreRolloutState(home) {
     const vaults = obj.vaults.map(vault);
     if (vaults.some((v) => v === null))
         return null;
+    const skipped = skippedEntries(obj.skipped);
+    if (skipped === null)
+        return null;
     return {
         version: 1,
         readAt: obj.readAt,
         release: obj.release,
         binaryPath: obj.binaryPath,
         vaults: vaults,
+        ...(skipped.length > 0 ? { skipped } : {}),
         ...(typeof obj.error === "string" ? { error: obj.error } : {}),
     };
 }

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

@@ -0,0 +1,7 @@
+export interface SyncCoreSkip {
+    uid: string;
+    reason: string;
+}
+export declare function syncCoreSkipPath(home: string): string;
+export declare function readSyncCoreSkips(home: string): SyncCoreSkip[];
+//# sourceMappingURL=skip.d.ts.map

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

@@ -0,0 +1,30 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isSyncCoreVaultUid } from "./engine-home.js";
+export function syncCoreSkipPath(home) {
+    return path.join(home, ".hq", "sync-core", "skip.json");
+}
+export function readSyncCoreSkips(home) {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(syncCoreSkipPath(home), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw new Error(`${syncCoreSkipPath(home)} could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const vaults = raw && typeof raw === "object" && !Array.isArray(raw) ? raw.vaults : undefined;
+    if (!vaults || typeof vaults !== "object" || Array.isArray(vaults)) {
+        throw new Error(`${syncCoreSkipPath(home)} must be {"vaults": {"<vault uid>": "<reason>"}}`);
+    }
+    const skips = [];
+    for (const [uid, reason] of Object.entries(vaults)) {
+        if (!isSyncCoreVaultUid(uid) || typeof reason !== "string" || reason.trim() === "") {
+            throw new Error(`${syncCoreSkipPath(home)} must map vault uids to a non-empty reason (bad entry ${uid})`);
+        }
+        skips.push({ uid, reason: reason.trim() });
+    }
+    return skips;
+}
+//# sourceMappingURL=skip.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.172",
+  "version": "5.345.173",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -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.172",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.172",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.172",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.172",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.172",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.172"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.173",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.173",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.173",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.173",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.173",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.173"
   }
 }