@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.273.0

package/dist/commands/lanes-message.js

@@ -3,38 +3,115 @@ import * as path from "node:path";
 import { appendCappedHistory, appendDropboxMessage, deliveryRefusalReason, dropboxInboxPath, laneAcceptsOperatorMessage, laneDeliveryMechanism, operatorMessageRefusalReason, providerSessionPortable, providerSupportsSessionResume, readLane, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { parseCliEffort } from "../lib/lanes/effort.js";
-import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
+import { parseOutpostHireGrantContext, sameHireGrantSenior } from "../lib/lanes/hire-grant-dispatch.js";
 import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
 import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMonitorEvent, requeueDropboxMessages } from "../lib/lanes/dropbox.js";
 import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision } from "../lib/lanes/watcher.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, keepAliveSupersededBy, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneMessageHandlers(deps) {
     const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, casUpdateLane, dispatchOutpostLaneCommand, drainHookStatusFor, laneIsHostedHere, laneWithRecoveredProviderSession, loadAllLanes, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveActiveQuestionCompany, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
-    async function messageLaneExclusion(ctx, lane) {
+    function currentSuccessorOf(lane, lanes, lineageAware, companyForLane) {
+        const validLanes = lanes.filter((candidate) => Number.isFinite(Date.parse(candidate.created_at)));
+        const newestFirst = [...validLanes].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+        const visited = new Set([lane.lane_id]);
+        let current = lane;
+        for (let depth = 0; depth < validLanes.length; depth += 1) {
+            const next = keepAliveSupersededBy(current, newestFirst, lineageAware, companyForLane);
+            if (!next || visited.has(next.lane_id))
+                break;
+            current = next;
+            visited.add(next.lane_id);
+        }
+        return current.lane_id === lane.lane_id ? undefined : current;
+    }
+    function callerMayMessageSupersededLane(ctx, lane, lanes, lineageAware, companyForLane, callerLaneIdOverride) {
+        if (lane.senior.kind !== "lane")
+            return false;
+        const callerLaneId = callerLaneIdOverride ?? ctx.env.HQ_LANE_ID?.trim();
+        if (!callerLaneId)
+            return false;
+        const senior = lanes.find((candidate) => candidate.lane_id === lane.senior.id);
+        const caller = lanes.find((candidate) => candidate.lane_id === callerLaneId);
+        if (!senior || !caller)
+            return false;
+        const workerCompany = companyForLane(lane);
+        const seniorCompany = companyForLane(senior);
+        const callerCompany = companyForLane(caller);
+        const projectId = lane.project_id;
+        if (!workerCompany ||
+            seniorCompany?.uid !== workerCompany.uid ||
+            callerCompany?.uid !== workerCompany.uid ||
+            !projectId ||
+            senior.project_id !== projectId ||
+            caller.project_id !== projectId)
+            return false;
+        if (caller.lane_id === senior.lane_id)
+            return true;
+        const projectLanes = lanes.filter((candidate) => companyForLane(candidate)?.uid === workerCompany.uid && candidate.project_id === projectId);
+        return currentSuccessorOf(lane, projectLanes, lineageAware, companyForLane)?.lane_id === caller.lane_id;
+    }
+    function keepAliveLaneFromSnapshot(snapshot) {
+        if (snapshot.created_at === undefined || !Object.hasOwn(snapshot, "company"))
+            return undefined;
+        return {
+            lane_id: snapshot.lane_id,
+            created_at: snapshot.created_at,
+            senior: snapshot.senior,
+            company: snapshot.company ?? null,
+            project_id: snapshot.project_id ?? "",
+            ...(snapshot.worker_profile === undefined ? {} : { worker_profile: snapshot.worker_profile }),
+            ...(snapshot.hire_grant === undefined ? {} : { hire_grant: snapshot.hire_grant }),
+        };
+    }
+    async function messageLaneExclusion(ctx, lane, grantContext) {
         if (lane.state === "killed" || lane.state === "cancelled") {
             return { lane, exclusion: lane.state };
         }
-        const hqRoot = ctx.hqRoot();
+        const companyForLane = (candidate) => resolveLaneCompany(ctx.hqRoot(), candidate).company;
         const lineageAware = await readLanesRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, {
-            company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
+            company: companyForLane(lane),
             env: ctx.env,
         });
-        const currentLane = readLane(hqRoot, lane.lane_id);
+        const currentLane = readLane(ctx.hqRoot(), lane.lane_id);
         if (currentLane.state === "killed" || currentLane.state === "cancelled") {
             return { lane: currentLane, exclusion: currentLane.state };
         }
-        const lanes = loadAllLanes(hqRoot);
-        const retiredLaneIds = loadRetiredLaneIds(hqRoot);
-        return {
-            lane: currentLane,
-            exclusion: keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware),
-        };
+        const localLanes = loadAllLanes(ctx.hqRoot());
+        let lanes = localLanes;
+        const retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+        const dispatchedCallerId = grantContext?.superseded_message_caller_id;
+        const dispatchedContextAuthorized = grantContext !== undefined &&
+            dispatchedCallerId !== undefined &&
+            ctx.isSsmOwnerDispatch() &&
+            sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
+        if (dispatchedContextAuthorized && grantContext) {
+            const merged = new Map(localLanes.map((record) => [record.lane_id, record]));
+            for (const snapshot of grantContext.hierarchy) {
+                const contextLane = keepAliveLaneFromSnapshot(snapshot);
+                if (contextLane)
+                    merged.set(contextLane.lane_id, contextLane);
+            }
+            merged.set(currentLane.lane_id, currentLane);
+            lanes = [...merged.values()];
+        }
+        const exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        const callerLaneId = dispatchedContextAuthorized ? dispatchedCallerId : undefined;
+        if (exclusion === "superseded" && callerMayMessageSupersededLane(ctx, currentLane, lanes, lineageAware, companyForLane, callerLaneId)) {
+            return {
+                lane: currentLane,
+                exclusion: undefined,
+                ...(!dispatchedContextAuthorized && ctx.env.HQ_LANE_ID?.trim()
+                    ? { supersededMessageCallerId: ctx.env.HQ_LANE_ID.trim() }
+                    : {}),
+            };
+        }
+        return { lane: currentLane, exclusion };
     }
     function recordMessageUndeliverable(ctx, lane, reason, messageCount) {
         writeWatcherDecision(watcherOutLogPath(ctx.hqRoot(), lane.lane_id), {
@@ -68,7 +145,14 @@ export function createLaneMessageHandlers(deps) {
         const resolution = await deps.resolveCommandLane(ctx, laneId);
         let lane = resolution.lane;
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
-            await dispatchOutpostLaneCommand(ctx, lane, "message", opts, resolution.remoteOnly
+            const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+            const supersededMessageCallerId = callerLaneId === undefined || resolution.remoteOnly
+                ? undefined
+                : (await messageLaneExclusion(ctx, lane)).supersededMessageCallerId;
+            await dispatchOutpostLaneCommand(ctx, lane, "message", {
+                ...opts,
+                ...(supersededMessageCallerId === undefined ? {} : { supersededMessageCallerId }),
+            }, resolution.remoteOnly
                 ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
                 : undefined);
             return;
@@ -115,7 +199,7 @@ export function createLaneMessageHandlers(deps) {
             }
         }
         try {
-            const eligibility = await messageLaneExclusion(ctx, lane);
+            const eligibility = await messageLaneExclusion(ctx, lane, hireGrantContext);
             lane = eligibility.lane;
             const exclusion = eligibility.exclusion;
             if (exclusion !== undefined) {

package/dist/commands/lanes-shared.d.ts

@@ -41,6 +41,8 @@ export interface LaneMessageOptions {
     effort?: string;
     worker?: string;
     grantContext?: string;
+    /** Primary-verified caller identity for a superseded Outpost message. */
+    supersededMessageCallerId?: string;
     monitorEvent?: {
         monitor_id: string;
         description: string;
@@ -237,9 +239,8 @@ export interface Ctx {
     storyLedgerEnabled: () => boolean;
     isSsmOwnerDispatch: () => boolean;
     withGrantHireLocks: typeof withLaneHireLocks;
-    laneTrackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
+    mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    trackerActor: () => string | null;
 }
 export interface LaneWaitCommandOptions {
     any?: string[];

package/dist/commands/lanes.d.ts

@@ -90,12 +90,10 @@ export interface LanesCommandDeps {
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
-    /** Test seam for the hq-flags gated tracker commands. */
-    laneTrackerEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** Test seam for the review-before-merge registry flag. */
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    /** Test seam for recording approvals against the active identity. */
-    trackerActor?: () => string | null;
+    /** Test seam for the repository-merge-hold registry flag. */
+    mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export declare function parseSeniorRef(raw: string): SeniorRef;

package/dist/commands/lanes.js

@@ -21,7 +21,6 @@ import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneKpisCommand } from "./lanes-kpis.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
-import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
 import { registerLaneReviewCommand } from "./lanes-review.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
@@ -29,7 +28,6 @@ import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveProcessFlagCompanyContext } from "../lib/flag-registry.js";
-import { defaultTrackerActor, LANES_TRACKER_FLAG, registerLaneTrackerCommands, } from "./lanes-tracker.js";
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.js";
 import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } from "../lib/lanes/outpost-profile-repin.js";
 import { createOutpostRegistryWorkerApprovalContext, parseOutpostRegistryWorkerApprovalContext, } from "../lib/lanes/outpost-registry-worker-approval.js";
@@ -109,9 +107,6 @@ async function readLanePlacementEnabled(ctx, company) {
         return false;
     }
 }
-function defaultLaneTrackerEnabled(company) {
-    return readLanesRegistryFlag(LANES_TRACKER_FLAG, { company });
-}
 function processLanePlacementCompany(ctx) {
     const context = resolveProcessFlagCompanyContext(ctx.env);
     if (!context.companySlug)
@@ -328,9 +323,8 @@ function resolveDeps(deps = {}) {
         storyLedgerEnabled: deps.storyLedgerEnabled ?? laneStoryLedgerEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
-        laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
         mergeReviewEnabled: deps.mergeReviewEnabled,
-        trackerActor: deps.trackerActor ?? defaultTrackerActor,
+        mergeHoldEnabled: deps.mergeHoldEnabled,
     };
 }
 function livenessDepsFromCtx(ctx) {
@@ -3497,7 +3491,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     }
     else if ((action === "resume" || action === "message") &&
         lane.senior.kind === "lane") {
-        grantContext = createOutpostHireGrantContext(lane, loadAllLanes(ctx.hqRoot()));
+        grantContext = createOutpostHireGrantContext(lane, loadAllLanes(ctx.hqRoot()), action === "message" ? options.supersededMessageCallerId : undefined);
     }
     let dispatched;
     let grantContextRejected = false;
@@ -7083,23 +7077,9 @@ export function registerLanesCommand(parent, deps = {}) {
     const lanes = parent
         .command("lanes", { hidden: true })
         .description("Create, supervise, and steer worker lanes; routed decision queue");
-    registerLaneTrackerCommands(lanes, {
-        hqRoot: ctx.hqRoot,
-        resolveCompany: ctx.resolveCompany,
-        trackerEnabled: ctx.laneTrackerEnabled,
-        now: ctx.now,
-        actor: ctx.trackerActor,
-    }, wrap);
-    registerLaneTrackerImportCommand(lanes, {
-        hqRoot: ctx.hqRoot,
-        resolveCompany: ctx.resolveCompany,
-        trackerEnabled: ctx.laneTrackerEnabled,
-        now: ctx.now,
-    }, wrap);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
-        trackerEnabled: ctx.laneTrackerEnabled,
         now: ctx.now,
         stopLane: (laneId, reason) => runStop(ctx, laneId, reason, true),
         sessionState: (root, sessionId, now) => sessionLiveness(root, sessionId, {
@@ -7111,7 +7091,6 @@ export function registerLanesCommand(parent, deps = {}) {
     registerLaneReportCommands(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
-        trackerEnabled: ctx.laneTrackerEnabled,
         now: ctx.now,
         readQuestionBody: (root, question) => {
             const body = questionHandlers.requireQuestionBody(root, question);
@@ -7124,6 +7103,7 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         now: ctx.now,
         env: ctx.env,
+        mergeHoldEnabled: ctx.mergeHoldEnabled,
         mergeReviewEnabled: ctx.mergeReviewEnabled,
     }, wrap);
     registerLaneReviewCommand(lanes, {

package/dist/commands/sync-mode.d.ts

@@ -70,15 +70,6 @@ export interface SetSyncModeResult {
 export interface ShowSyncModesOptions {
     vaultClient: SyncModeVaultClient;
 }
-export interface GetSyncModeOptions {
-    companySlug: string;
-    vaultClient: SyncModeVaultClient;
-}
-export interface GetSyncModeResult {
-    membershipId: string;
-    companySlug: string;
-    config: MembershipSyncConfig;
-}
 export interface ShowSyncModesRow {
     companySlug: string;
     companyName?: string;
@@ -109,8 +100,6 @@ export declare function setSyncMode(options: SetSyncModeOptions): Promise<SetSyn
  * stable table output.
  */
 export declare function showSyncModes(options: ShowSyncModesOptions): Promise<ShowSyncModesRow[]>;
-/** Read one company's effective sync mode without hiding API read failures. */
-export declare function getSyncModeForCompany(options: GetSyncModeOptions): Promise<GetSyncModeResult>;
 /**
  * Render the `--show` table as plain text. No external dep — hq-cli doesn't
  * use cli-table3, so we hand-format columns to match the existing chalk +

package/dist/commands/sync-mode.js

@@ -163,36 +163,6 @@ export async function showSyncModes(options) {
     rows.sort((a, b) => a.companySlug.localeCompare(b.companySlug));
     return rows;
 }
-/** Read one company's effective sync mode without hiding API read failures. */
-export async function getSyncModeForCompany(options) {
-    const { companySlug, vaultClient } = options;
-    const memberships = await vaultClient.listMyMemberships();
-    const enriched = await Promise.all(memberships.map(async (membership) => {
-        try {
-            const entity = await vaultClient.entity.get(membership.companyUid);
-            return { ok: true, membership, slug: entity.slug };
-        }
-        catch (error) {
-            return { ok: false, membership, error };
-        }
-    }));
-    const match = enriched.find((row) => row.ok && row.slug === companySlug);
-    if (!match) {
-        const failedLookup = enriched.find((row) => !row.ok);
-        if (failedLookup && !failedLookup.ok)
-            throw failedLookup.error;
-        throw new Error(`No membership found for company '${companySlug}'.`);
-    }
-    for (const failedLookup of enriched) {
-        if (!failedLookup.ok) {
-            const detail = failedLookup.error instanceof Error ? failedLookup.error.message : String(failedLookup.error);
-            console.error(`getSyncModeForCompany: entity lookup failed for membership ${failedLookup.membership.membershipKey} while resolving '${companySlug}': ${detail}`);
-        }
-    }
-    const membershipId = match.membership.membershipKey;
-    const config = await vaultClient.getMembershipSyncConfig(membershipId);
-    return { membershipId, companySlug, config };
-}
 // ── Table rendering (used by CLI action, separable for tests) ──────────────
 /**
  * Render the `--show` table as plain text. No external dep — hq-cli doesn't

package/dist/lib/daemon/catalog.d.ts

@@ -10,8 +10,6 @@
  * them instead of silently dropping them.
  */
 import type { MachineType } from "./machine-type.js";
-import type { SyncOwner } from "./config.js";
-import { type SyncRunnerProcess } from "./sync-runner.js";
 export declare const SERVICE_NAMES: readonly ["sync", "mesh", "heartbeat", "inbox", "bots", "remote-control", "codex-remote-control", "session-host", "lanes-reconcile", "search-index", "jobs-reconcile", "updater", "housekeeping"];
 export type ServiceName = (typeof SERVICE_NAMES)[number];
 export declare function isServiceName(value: unknown): value is ServiceName;
@@ -53,8 +51,6 @@ export interface UnitPlan {
     restart: "always" | "on-failure";
     intervalSec?: number;
     initialDelaySec?: number;
-    /** Kill and restart this child after silence on its liveness stream. */
-    heartbeatTimeoutMs?: number;
     command: UnitCommand | null;
     env: Record<string, string>;
     blocked?: UnitBlock;
@@ -72,23 +68,11 @@ export interface PlanContext {
     sessionHostRunnerPath: string | null;
     /** Environment retained from legacy outpost sync systemd drop-ins. */
     legacySyncEnv: Record<string, string>;
-    /** Keep the local sync runner stopped until the operator resumes it. */
-    syncPaused: boolean;
-    /** Persisted/effective owner selected for this machine. */
-    syncOwner: SyncOwner;
-    /** A legacy desktop app or sync unit is still managing sync. */
-    desktopAppManagesSync: boolean;
-    /** Full process list, or null when the daemon could not read it. */
-    syncRunnerProcesses: readonly SyncRunnerProcess[] | null;
-    /** PID recorded in the watch-owner status, when it is readable. */
-    syncRunnerOwnerPid: number | null;
-    /** Sync runner children already started by this daemon before their lease is written. */
-    daemonSyncRunnerPids?: ReadonlySet<number>;
-    /** The protocol-event heartbeat watchdog timeout for the sync runner. */
-    syncHeartbeatTimeoutMs: number;
     signedIn: boolean;
     /** ~/.hq-agent/kit.json exists. */
     kitConfigured: boolean;
+    /** The HQ desktop app runs its own sync on this machine. */
+    desktopAppManagesSync: boolean;
     bots: readonly string[];
     /** Name of a pre-daemon unit that still runs this unit id, or null. */
     legacyOwner: (unitId: string) => string | null;

package/dist/lib/daemon/catalog.js

@@ -9,7 +9,6 @@
  * with no entrypoint yet stay in the catalog as `unavailable` so status shows
  * them instead of silently dropping them.
  */
-import { SYNC_RUNNER_OWNER, syncRunnerUnleasedBlockReason } from "./sync-runner.js";
 export const SERVICE_NAMES = [
     "sync",
     "mesh",
@@ -128,29 +127,14 @@ function planService(service, ctx) {
                 command: {
                     type: "node",
                     script: ctx.syncRunnerPath,
-                    args: ["--companies", "--direction", "both", "--on-conflict", "keep", "--hq-root", ctx.hqRoot ?? "", "--watch", "--event-push", "--owner", SYNC_RUNNER_OWNER],
+                    args: ["--companies", "--direction", "both", "--on-conflict", "keep", "--hq-root", ctx.hqRoot ?? "", "--watch", "--event-push"],
                 },
                 env: { ...ctx.legacySyncEnv },
-                heartbeatTimeoutMs: ctx.syncHeartbeatTimeoutMs,
             });
-            let ownerBlock;
-            if (ctx.machineType === "desktop" && ctx.syncOwner === "desktop-app" && ctx.desktopAppManagesSync) {
-                ownerBlock = "the desktop app is still managing sync (run `hq daemon sync take-ownership` after it stops its runner)";
-            }
-            else if (ctx.machineType === "desktop" &&
-                ctx.syncOwner === "daemon" &&
-                !ctx.syncPaused &&
-                ctx.hqRoot &&
-                ctx.signedIn) {
-                ownerBlock = ctx.syncRunnerProcesses === null
-                    ? "could not check for an existing sync runner; waiting to avoid starting a duplicate"
-                    : syncRunnerUnleasedBlockReason(ctx.hqRoot, ctx.syncRunnerProcesses, ctx.syncRunnerOwnerPid, ctx.platform, ctx.daemonSyncRunnerPids);
-            }
             unit.blocked = firstBlock([
-                [ctx.syncPaused, "sync is paused (run `hq daemon sync resume`)"],
+                [ctx.desktopAppManagesSync, "the HQ desktop app is handling sync on this machine"],
                 [!ctx.hqRoot, NO_HQ_ROOT],
                 [!ctx.signedIn, NOT_SIGNED_IN],
-                [!!ownerBlock, ownerBlock ?? ""],
             ]);
             return [unit];
         }

package/dist/lib/daemon/config.d.ts

@@ -12,17 +12,11 @@ export interface DaemonConfig {
     hqRoot?: string;
     /** Exact hq-cloud package version preferred by this daemon, including prereleases. */
     hqCloudVersion?: string;
-    /** Persisted machine-local sync pause. */
-    syncPaused?: boolean;
-    /** Explicit desktop handoff; absent values preserve the legacy per-machine owner. */
-    syncOwner?: SyncOwner;
     /** Services turned on here beyond the machine type's defaults. */
     enable: string[];
     /** Default services turned off here. */
     disable: string[];
 }
-export type SyncOwner = "daemon" | "desktop-app";
-export declare function effectiveSyncOwner(config: Pick<DaemonConfig, "syncOwner">, machineType: MachineType): SyncOwner;
 export declare function emptyDaemonConfig(): DaemonConfig;
 export declare function readDaemonConfig(file: string): DaemonConfig;
 export declare function writeDaemonConfig(file: string, config: DaemonConfig): void;

package/dist/lib/daemon/config.js

@@ -10,11 +10,8 @@ import { valid as validSemver } from "semver";
 import { isServiceName } from "./catalog.js";
 import { isMachineType } from "./machine-type.js";
 import { ensurePrivateDir } from "./paths.js";
-export function effectiveSyncOwner(config, machineType) {
-    return config.syncOwner ?? (machineType === "desktop" ? "desktop-app" : "daemon");
-}
 export function emptyDaemonConfig() {
-    return { version: 1, syncPaused: false, enable: [], disable: [] };
+    return { version: 1, enable: [], disable: [] };
 }
 function stringList(value) {
     return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
@@ -39,16 +36,9 @@ export function readDaemonConfig(file) {
     if (!raw || typeof raw !== "object")
         throw new Error(`hq daemon config at ${file} is not a JSON object`);
     const obj = raw;
-    const config = {
-        version: 1,
-        syncPaused: obj.syncPaused === true,
-        enable: stringList(obj.enable),
-        disable: stringList(obj.disable),
-    };
+    const config = { version: 1, enable: stringList(obj.enable), disable: stringList(obj.disable) };
     if (isMachineType(obj.machineType))
         config.machineType = obj.machineType;
-    if (obj.syncOwner === "daemon" || obj.syncOwner === "desktop-app")
-        config.syncOwner = obj.syncOwner;
     if (typeof obj.hqRoot === "string" && obj.hqRoot.trim())
         config.hqRoot = obj.hqRoot;
     if (typeof obj.hqCloudVersion === "string" && validSemver(obj.hqCloudVersion) === obj.hqCloudVersion) {
@@ -66,9 +56,6 @@ export function writeDaemonConfig(file, config) {
         ordered.hqRoot = config.hqRoot;
     if (config.hqCloudVersion)
         ordered.hqCloudVersion = config.hqCloudVersion;
-    ordered.syncPaused = config.syncPaused === true;
-    if (config.syncOwner)
-        ordered.syncOwner = config.syncOwner;
     ordered.enable = config.enable;
     ordered.disable = config.disable;
     fs.writeFileSync(tmp, `${JSON.stringify(ordered, null, 2)}\n`, { mode: 0o600 });

package/dist/lib/daemon/requests.d.ts

@@ -15,10 +15,6 @@ export type ControlRequest = {
     action: "stop";
     unit: string;
 }
-/** Re-read persisted configuration and apply any changed blocks immediately. */
- | {
-    action: "reconcile";
-}
 /** Restart the whole daemon, for example after the updater installed a new CLI. */
  | {
     action: "restart-daemon";

package/dist/lib/daemon/requests.js

@@ -19,8 +19,6 @@ function isControlRequest(value) {
         return typeof v.unit === "string";
     if (v.action === "restart-daemon")
         return true;
-    if (v.action === "reconcile")
-        return true;
     return false;
 }
 // Orders requests written by one process within the same millisecond; the