@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/lib/mesh/live/daemon/legacy-listen.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Retire the pack-era work-mesh listen unit so only `hq mesh daemon` subscribes.
+ *
+ * macOS: ~/Library/LaunchAgents/ai.getindigo.hq-work-mesh-listen.plist
+ * Linux: ~/.config/systemd/user/hq-work-mesh-listen.service
+ * Windows: Scheduled Task ai.getindigo.hq-work-mesh-listen
+ */
+export type LegacyListenPlatform = "darwin" | "linux" | "win32" | "other";
+export declare const LEGACY_LISTEN_LABEL = "ai.getindigo.hq-work-mesh-listen";
+export declare const LEGACY_LISTEN_SYSTEMD_UNIT = "hq-work-mesh-listen.service";
+export declare const LEGACY_LISTEN_TASK = "ai.getindigo.hq-work-mesh-listen";
+export declare const LEGACY_LISTENER_DOCTOR_LINE = "legacy listener still installed";
+export interface CommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+export type CommandRunner = (cmd: string, args: string[]) => CommandResult;
+export declare function legacyListenPlistPath(home: string): string;
+export declare function legacyListenSystemdPath(home: string): string;
+export declare function legacyListenInstalled(opts: {
+    home: string;
+    platform: LegacyListenPlatform;
+    existsSync?: (p: string) => boolean;
+}): boolean;
+/**
+ * Unload and delete the legacy listen unit when it is present.
+ * On-disk unit files are removed on every host. launchctl, systemctl, and
+ * schtasks run only for the matching platform, and only through `run` when
+ * the caller injected one (tests never hit a real service manager).
+ * Missing unit is a no-op.
+ */
+export declare function retireLegacyListen(opts: {
+    home: string;
+    platform: LegacyListenPlatform;
+    run?: CommandRunner;
+    uid?: number;
+    /** Windows task probe: true when the scheduled task is registered. */
+    windowsTaskPresent?: boolean;
+}): {
+    removed: boolean;
+};
+//# sourceMappingURL=legacy-listen.d.ts.map

package/dist/lib/mesh/live/daemon/legacy-listen.js

@@ -0,0 +1,89 @@
+/**
+ * Retire the pack-era work-mesh listen unit so only `hq mesh daemon` subscribes.
+ *
+ * macOS: ~/Library/LaunchAgents/ai.getindigo.hq-work-mesh-listen.plist
+ * Linux: ~/.config/systemd/user/hq-work-mesh-listen.service
+ * Windows: Scheduled Task ai.getindigo.hq-work-mesh-listen
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+export const LEGACY_LISTEN_LABEL = "ai.getindigo.hq-work-mesh-listen";
+export const LEGACY_LISTEN_SYSTEMD_UNIT = "hq-work-mesh-listen.service";
+export const LEGACY_LISTEN_TASK = LEGACY_LISTEN_LABEL;
+export const LEGACY_LISTENER_DOCTOR_LINE = "legacy listener still installed";
+export function legacyListenPlistPath(home) {
+    return path.join(home, "Library", "LaunchAgents", `${LEGACY_LISTEN_LABEL}.plist`);
+}
+export function legacyListenSystemdPath(home) {
+    return path.join(home, ".config", "systemd", "user", LEGACY_LISTEN_SYSTEMD_UNIT);
+}
+const defaultRunner = (cmd, args) => {
+    const r = spawnSync(cmd, args, { encoding: "utf8" });
+    return {
+        status: r.status,
+        stdout: r.stdout ?? "",
+        stderr: r.error ? r.error.message : (r.stderr ?? ""),
+    };
+};
+export function legacyListenInstalled(opts) {
+    const exists = opts.existsSync ?? fs.existsSync;
+    if (opts.platform === "darwin")
+        return exists(legacyListenPlistPath(opts.home));
+    if (opts.platform === "linux")
+        return exists(legacyListenSystemdPath(opts.home));
+    if (opts.platform === "win32")
+        return false;
+    return false;
+}
+/**
+ * Unload and delete the legacy listen unit when it is present.
+ * On-disk unit files are removed on every host. launchctl, systemctl, and
+ * schtasks run only for the matching platform, and only through `run` when
+ * the caller injected one (tests never hit a real service manager).
+ * Missing unit is a no-op.
+ */
+export function retireLegacyListen(opts) {
+    const run = opts.run ?? (opts.platform === "other" ? undefined : defaultRunner);
+    let removed = false;
+    const plist = legacyListenPlistPath(opts.home);
+    if (fs.existsSync(plist)) {
+        if (opts.platform === "darwin" && run) {
+            const uid = opts.uid ?? (typeof process.getuid === "function" ? process.getuid() : undefined);
+            if (uid !== undefined) {
+                run("launchctl", ["bootout", `gui/${uid}/${LEGACY_LISTEN_LABEL}`]);
+            }
+            run("launchctl", ["unload", plist]);
+        }
+        try {
+            fs.unlinkSync(plist);
+            removed = true;
+        }
+        catch {
+            // leave removed false for this file
+        }
+    }
+    const unitPath = legacyListenSystemdPath(opts.home);
+    if (fs.existsSync(unitPath)) {
+        if (opts.platform === "linux" && run) {
+            run("systemctl", ["--user", "disable", "--now", LEGACY_LISTEN_SYSTEMD_UNIT]);
+        }
+        try {
+            fs.unlinkSync(unitPath);
+            removed = true;
+            if (opts.platform === "linux" && run) {
+                run("systemctl", ["--user", "daemon-reload"]);
+            }
+        }
+        catch {
+            // leave prior removed state
+        }
+    }
+    if (opts.platform === "win32" && opts.windowsTaskPresent && run) {
+        const result = run("schtasks.exe", ["/Delete", "/TN", LEGACY_LISTEN_TASK, "/F"]);
+        if (result.status === 0)
+            removed = true;
+    }
+    return { removed };
+}
+//# sourceMappingURL=legacy-listen.js.map

package/dist/lib/mesh/live/daemon/live-cache.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Daemon-owned work-mesh live cache.
+ *
+ * ~/.hq/work-mesh/live-cache.json plus live-cache.json.cursor-v2.json.
+ * A project-view push updates the project row and bumps the cursor once.
+ * The same company/project/boardVersion (or eventId) does not bump again.
+ */
+export declare function liveCacheFile(meshRoot: string): string;
+export declare function liveCacheCursorFile(meshRoot: string): string;
+export interface ProjectViewPush {
+    companyUid: string;
+    projectId: string;
+    boardVersion?: string;
+    eventId?: string;
+}
+/** Parse a board wake. Returns null for every other payload. */
+export declare function parseProjectViewPush(payload: unknown): ProjectViewPush | null;
+/**
+ * Apply one project-view push. Cursor increases by exactly one on first sight
+ * of the key, and is left unchanged when the same push is applied again.
+ */
+export declare function applyProjectViewPush(meshRoot: string, push: ProjectViewPush, nowIso?: string): {
+    applied: boolean;
+    cursor: number;
+};
+//# sourceMappingURL=live-cache.d.ts.map

package/dist/lib/mesh/live/daemon/live-cache.js

@@ -0,0 +1,116 @@
+/**
+ * Daemon-owned work-mesh live cache.
+ *
+ * ~/.hq/work-mesh/live-cache.json plus live-cache.json.cursor-v2.json.
+ * A project-view push updates the project row and bumps the cursor once.
+ * The same company/project/boardVersion (or eventId) does not bump again.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function liveCacheFile(meshRoot) {
+    return path.join(meshRoot, "live-cache.json");
+}
+export function liveCacheCursorFile(meshRoot) {
+    return path.join(meshRoot, "live-cache.json.cursor-v2.json");
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function pushKey(push) {
+    if (push.eventId && push.eventId.trim())
+        return `id:${push.eventId.trim()}`;
+    return `pv:${push.companyUid}:${push.projectId}:${push.boardVersion ?? ""}`;
+}
+/** Parse a board wake. Returns null for every other payload. */
+export function parseProjectViewPush(payload) {
+    let value = payload;
+    if (Buffer.isBuffer(value))
+        value = value.toString("utf8");
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const rec = value;
+    if (rec.kind !== "board" || rec.mutation !== "project-view")
+        return null;
+    if (typeof rec.companyUid !== "string" || typeof rec.projectId !== "string")
+        return null;
+    if (!rec.companyUid || !rec.projectId)
+        return null;
+    return {
+        companyUid: rec.companyUid,
+        projectId: rec.projectId,
+        boardVersion: typeof rec.boardVersion === "string" ? rec.boardVersion : undefined,
+        eventId: typeof rec.eventId === "string" ? rec.eventId : undefined,
+    };
+}
+/**
+ * Apply one project-view push. Cursor increases by exactly one on first sight
+ * of the key, and is left unchanged when the same push is applied again.
+ */
+export function applyProjectViewPush(meshRoot, push, nowIso = new Date().toISOString()) {
+    const key = pushKey(push);
+    const stored = readJson(liveCacheCursorFile(meshRoot));
+    const previous = stored &&
+        typeof stored === "object" &&
+        !Array.isArray(stored) &&
+        stored.version === 1 &&
+        typeof stored.cursor === "number"
+        ? {
+            version: 1,
+            cursor: stored.cursor,
+            seen: Array.isArray(stored.seen)
+                ? stored.seen.filter((s) => typeof s === "string").slice(-200)
+                : [],
+        }
+        : { version: 1, cursor: 0, seen: [] };
+    if (previous.seen.includes(key)) {
+        return { applied: false, cursor: previous.cursor };
+    }
+    const cursor = previous.cursor + 1;
+    const cacheRaw = readJson(liveCacheFile(meshRoot));
+    const cache = cacheRaw && typeof cacheRaw === "object" && !Array.isArray(cacheRaw)
+        ? cacheRaw
+        : {};
+    const projects = cache.projects && typeof cache.projects === "object" && !Array.isArray(cache.projects)
+        ? { ...cache.projects }
+        : {};
+    const rowKey = `${push.companyUid}/${push.projectId}`;
+    projects[rowKey] = {
+        companyUid: push.companyUid,
+        projectId: push.projectId,
+        mutation: "project-view",
+        boardVersion: push.boardVersion,
+        updatedAt: nowIso,
+    };
+    writeJson(liveCacheFile(meshRoot), {
+        ...cache,
+        updatedAt: nowIso,
+        cursor,
+        projects,
+    });
+    writeJson(liveCacheCursorFile(meshRoot), {
+        version: 1,
+        cursor,
+        seen: [...previous.seen, key].slice(-200),
+    });
+    return { applied: true, cursor };
+}
+//# sourceMappingURL=live-cache.js.map

package/dist/lib/mesh/live/daemon/mqtt-events.d.ts

@@ -0,0 +1,7 @@
+import type { MqttClientEventCallbacks } from "mqtt";
+/** Event callbacks shared by the daemon's two MQTT client seams. */
+export type MeshMqttEventMap = Pick<MqttClientEventCallbacks, "connect" | "error" | "close" | "message">;
+export interface MeshMqttEventClient {
+    on<Event extends keyof MeshMqttEventMap>(event: Event, handler: MeshMqttEventMap[Event]): unknown;
+}
+//# sourceMappingURL=mqtt-events.d.ts.map

package/dist/lib/mesh/live/daemon/mqtt-events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mqtt-events.js.map

package/dist/lib/mesh/live/daemon/mqtt-events.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mqtt-events.test-d.d.ts.map

package/dist/lib/mesh/live/daemon/mqtt-events.test-d.js

@@ -0,0 +1,10 @@
+// @ts-expect-error unsupported event names are not part of mqtt's event map
+presence.on("conect", () => { });
+// @ts-expect-error MQTT message handlers receive a string topic
+presence.on("message", (topic) => void topic);
+// @ts-expect-error unsupported event names are not part of mqtt's event map
+workCache.on("conect", () => { });
+// @ts-expect-error MQTT message handlers receive a string topic
+workCache.on("message", (topic) => void topic);
+export {};
+//# sourceMappingURL=mqtt-events.test-d.js.map

package/dist/lib/mesh/live/daemon/paths.d.ts

@@ -9,6 +9,8 @@ export declare const DAEMON_LOG_NAME = "log";
 export declare const DAEMON_LOG_MAX_BYTES: number;
 export declare const LAUNCHD_LABEL = "ai.getindigo.hq-mesh-daemon";
 export declare const SYSTEMD_UNIT_NAME = "hq-mesh-daemon.service";
+/** Windows per-user Scheduled Task name (same label as the LaunchAgent). */
+export declare const WINDOWS_TASK_NAME = "ai.getindigo.hq-mesh-daemon";
 export declare function daemonDir(meshRoot?: string, home?: string, env?: NodeJS.ProcessEnv): string;
 export declare function daemonPidPath(dir?: string): string;
 export declare function daemonStatePath(dir?: string): string;

package/dist/lib/mesh/live/daemon/paths.js

@@ -12,6 +12,8 @@ export const DAEMON_LOG_NAME = "log";
 export const DAEMON_LOG_MAX_BYTES = 5 * 1024 * 1024;
 export const LAUNCHD_LABEL = "ai.getindigo.hq-mesh-daemon";
 export const SYSTEMD_UNIT_NAME = "hq-mesh-daemon.service";
+/** Windows per-user Scheduled Task name (same label as the LaunchAgent). */
+export const WINDOWS_TASK_NAME = "ai.getindigo.hq-mesh-daemon";
 export function daemonDir(meshRoot, home = os.homedir(), env = process.env) {
     return path.join(meshRoot ?? workMeshRoot(home, env), DAEMON_DIRNAME);
 }

package/dist/lib/mesh/live/daemon/presence.d.ts

@@ -12,6 +12,7 @@
  * - Server credential refusals use a long retry (default 10m ±20%)
  */
 import { type IClientOptions, type MqttClient } from "mqtt";
+import type { MeshMqttEventClient } from "./mqtt-events.js";
 import { type Contract3Bundle, type CredentialsFetcher, type TimerHost } from "./credentials.js";
 export type MqttConnectionState = "idle" | "connecting" | "connected" | "reconnecting" | "closed";
 /**
@@ -34,7 +35,11 @@ export declare const CONNECT_STABLE_GRACE_MS = 5000;
  * waits at least this long regardless of the backoff/grace-reset state.
  */
 export declare const RECONNECT_MIN_DELAY_MS = 1000;
-/** Always emit the first N close info lines, then at most one per interval. */
+/**
+ * Close/reconnect info is one line per transition into reconnecting.
+ * Repeated `close` events while already reconnecting do not log again.
+ * Kept so older imports still resolve; they no longer gate the log.
+ */
 export declare const CLOSE_LOG_ALWAYS_COUNT = 3;
 export declare const CLOSE_LOG_INTERVAL_MS = 60000;
 export interface PresencePayload {
@@ -45,8 +50,7 @@ export interface PresencePayload {
     at: string;
 }
 /** Structural mqtt client surface used by PresenceClient (test seam). */
-export interface MeshMqttClientLike {
-    on(event: string, handler: (...args: any[]) => void): unknown;
+export interface MeshMqttClientLike extends MeshMqttEventClient {
     publish(topic: string, message: string | Buffer, opts: {
         qos: 0 | 1 | 2;
         retain?: boolean;
@@ -80,6 +84,13 @@ export interface PresenceClientOptions {
     onRefusal?: (refusal: PresenceRefusal | null) => void;
     now?: () => Date;
     env?: NodeJS.ProcessEnv;
+    /**
+     * Companies the daemon is working in. When the set changes, presence
+     * re-vends instead of waiting for credential expiry (at most once a minute).
+     * Undefined means a read failed — do not re-vend.
+     */
+    readPreferredCompanyUids?: () => string[] | undefined;
+    preferredRevendMinMs?: number;
 }
 /**
  * Full-jitter capped exponential backoff (1s base → 60s cap by default),
@@ -111,14 +122,17 @@ export declare class PresenceClient {
     private reconnectHandle;
     private stableHandle;
     private connectedAtMs;
-    private closeLogCount;
-    private lastCloseLogAtMs;
+    /** One close log per transition into reconnecting, until the next connect. */
+    private reconnectLogged;
     private stopped;
     private generation;
     private publishedTopics;
     /** Last refusal code we logged via onError (episode dedupe). */
     private loggedRefusalKey;
     private refusal;
+    private preferredHandle;
+    private preferredSnapshot;
+    private lastPreferredVendMs;
     private readonly mqttConnect;
     private readonly timers;
     private readonly random;
@@ -133,6 +147,11 @@ export declare class PresenceClient {
     getRefusal(): PresenceRefusal | null;
     /** Topics this client has published to (for doctor / tests). */
     getPublishedTopics(): readonly string[];
+    private preferredMinMs;
+    private notePreferredVend;
+    private clearPreferredWatch;
+    private armPreferredWatch;
+    private maybeRevendPreferred;
     private setState;
     start(): Promise<void>;
     /**

package/dist/lib/mesh/live/daemon/presence.js

@@ -12,7 +12,7 @@
  * - Server credential refusals use a long retry (default 10m ±20%)
  */
 import mqtt from "mqtt";
-import { CredentialVendError, CredentialRenewalManager, MQTT_KEEPALIVE_SECONDS, clampRetryDelayMs, defaultRefusedRetryMs, realTimerHost, refusedRetryDelayMs, scheduleBoundedTimeout, } from "./credentials.js";
+import { CredentialVendError, CredentialRenewalManager, MQTT_KEEPALIVE_SECONDS, PREFERRED_REVEND_MIN_MS, clampRetryDelayMs, defaultRefusedRetryMs, realTimerHost, refusedRetryDelayMs, scheduleBoundedTimeout, shouldRevendPreferredCompanies, } from "./credentials.js";
 import { presignIotWssUrl } from "./presign.js";
 /**
  * A connection that drops before this grace window after `connect` is treated
@@ -34,7 +34,11 @@ export const CONNECT_STABLE_GRACE_MS = 5_000;
  * waits at least this long regardless of the backoff/grace-reset state.
  */
 export const RECONNECT_MIN_DELAY_MS = 1_000;
-/** Always emit the first N close info lines, then at most one per interval. */
+/**
+ * Close/reconnect info is one line per transition into reconnecting.
+ * Repeated `close` events while already reconnecting do not log again.
+ * Kept so older imports still resolve; they no longer gate the log.
+ */
 export const CLOSE_LOG_ALWAYS_COUNT = 3;
 export const CLOSE_LOG_INTERVAL_MS = 60_000;
 /**
@@ -81,14 +85,17 @@ export class PresenceClient {
     reconnectHandle = null;
     stableHandle = null;
     connectedAtMs = null;
-    closeLogCount = 0;
-    lastCloseLogAtMs = Number.NEGATIVE_INFINITY;
+    /** One close log per transition into reconnecting, until the next connect. */
+    reconnectLogged = false;
     stopped = false;
     generation = 0;
     publishedTopics = [];
     /** Last refusal code we logged via onError (episode dedupe). */
     loggedRefusalKey = null;
     refusal = null;
+    preferredHandle = null;
+    preferredSnapshot = [];
+    lastPreferredVendMs = 0;
     mqttConnect;
     timers;
     random;
@@ -124,6 +131,67 @@ export class PresenceClient {
     getPublishedTopics() {
         return this.publishedTopics;
     }
+    preferredMinMs() {
+        return this.options.preferredRevendMinMs ?? PREFERRED_REVEND_MIN_MS;
+    }
+    notePreferredVend() {
+        const read = this.options.readPreferredCompanyUids;
+        if (!read)
+            return;
+        let next;
+        try {
+            next = read();
+        }
+        catch {
+            return;
+        }
+        if (!next)
+            return;
+        this.preferredSnapshot = next;
+        this.lastPreferredVendMs = this.timers.now();
+    }
+    clearPreferredWatch() {
+        if (this.preferredHandle) {
+            this.preferredHandle.clear();
+            this.preferredHandle = null;
+        }
+    }
+    armPreferredWatch() {
+        if (!this.options.readPreferredCompanyUids || this.stopped)
+            return;
+        this.clearPreferredWatch();
+        this.preferredHandle = scheduleBoundedTimeout(this.timers, () => {
+            this.preferredHandle = null;
+            if (this.stopped)
+                return;
+            this.maybeRevendPreferred();
+            this.armPreferredWatch();
+        }, this.preferredMinMs());
+    }
+    maybeRevendPreferred() {
+        const read = this.options.readPreferredCompanyUids;
+        if (!read || this.stopped || this.refusal)
+            return;
+        let next;
+        try {
+            next = read();
+        }
+        catch {
+            return;
+        }
+        if (!shouldRevendPreferredCompanies({
+            previous: this.preferredSnapshot,
+            next,
+            lastVendMs: this.lastPreferredVendMs,
+            nowMs: this.timers.now(),
+            minIntervalMs: this.preferredMinMs(),
+        })) {
+            return;
+        }
+        this.lastPreferredVendMs = this.timers.now();
+        this.preferredSnapshot = next;
+        this.renewal.renewNow();
+    }
     setState(state) {
         if (this.state === state)
             return;
@@ -145,6 +213,7 @@ export class PresenceClient {
         this.stopped = true;
         this.generation += 1;
         this.renewal.stop();
+        this.clearPreferredWatch();
         this.clearReconnect();
         this.clearStableTimer();
         this.connectedAtMs = null;
@@ -186,6 +255,7 @@ export class PresenceClient {
     }
     async onCredentialsRenewed(bundle) {
         this.bundle = bundle;
+        this.notePreferredVend();
         // Successful vend ends a refusal episode (renewal skips connectOnce's vend path).
         this.clearRefusal(true);
         if (this.stopped)
@@ -245,6 +315,8 @@ export class PresenceClient {
                 // Successful vend ends a refusal episode (even before MQTT connects).
                 this.clearRefusal(true);
                 this.renewal.schedule(this.bundle);
+                this.notePreferredVend();
+                this.armPreferredWatch();
             }
             const bundle = this.bundle;
             const url = presignIotWssUrl(bundle.credentials, bundle.iotEndpoint, bundle.region, this.now());
@@ -281,6 +353,7 @@ export class PresenceClient {
                     this.attempt = 0;
                     this.lastBackoffMs = 0;
                 }, CONNECT_STABLE_GRACE_MS);
+                this.reconnectLogged = false;
                 this.setState("connected");
                 void this.publishAll("online").then(() => {
                     this.options.onOnline?.(bundle.companies.map((c) => c.companyUid));
@@ -383,13 +456,9 @@ export class PresenceClient {
         return delay;
     }
     maybeLogClose(elapsedMs, delayMs) {
-        const now = this.timers.now();
-        const withinAlways = this.closeLogCount < CLOSE_LOG_ALWAYS_COUNT;
-        const intervalElapsed = now - this.lastCloseLogAtMs >= CLOSE_LOG_INTERVAL_MS;
-        if (!withinAlways && !intervalElapsed)
+        if (this.reconnectLogged)
             return;
-        this.closeLogCount += 1;
-        this.lastCloseLogAtMs = now;
+        this.reconnectLogged = true;
         this.options.onInfo?.(`presence mqtt closed after ${elapsedMs}ms; reconnect in ${delayMs}ms`);
     }
     clearReconnect() {

package/dist/lib/mesh/live/daemon/run.d.ts

@@ -8,14 +8,24 @@
  * - MQTT presence (contract-3)
  * - SIGTERM/SIGINT: flush once more, MQTT DISCONNECT (server derives offline), exit
  */
+import { type DeliverFn } from "../../../work-context/outbox.js";
+import { type SessionEventsPoster } from "../session-events-client.js";
 import { type FlushSummary } from "../flush.js";
+import { type BackfillHeldResult } from "../backfill-held.js";
+import { type BoardReader } from "./board-refresh.js";
 import { type CredentialsFetcher, type TimerHost } from "./credentials.js";
 import { type PidLockDeps } from "./pid-lock.js";
 import { PresenceClient, type MqttConnectFn } from "./presence.js";
 import { TranscriptWatcher, type TranscriptFs } from "./transcript-watch.js";
 import { type MeshEmitMode } from "./mode.js";
+import { type CommandRunner, type LegacyListenPlatform } from "./legacy-listen.js";
 export declare const SPOOL_DEBOUNCE_MS = 2000;
 export declare const FLUSH_INTERVAL_MS = 10000;
+/** Keep startup recovery bounded: the next daemon start continues the backlog. */
+export declare const HELD_BACKFILL_STARTUP_BATCH_SIZE = 100;
+export declare const DEVICE_DEFAULT_MEMBERSHIP_TIMEOUT_MS = 2000;
+/** Non-zero exit reserved for CLI version drift so legacy Restart=on-failure units restart. */
+export declare const DAEMON_VERSION_DRIFT_EXIT_CODE = 75;
 /**
  * Only producer appends to spool.jsonl should wake the watcher. Every other
  * file in the work-mesh root (held.jsonl, spool.<ts>.claimed, held.<ts>.claimed,
@@ -35,8 +45,8 @@ export interface DaemonRunDeps {
     timers?: TimerHost;
     fetchCredentials?: CredentialsFetcher;
     mqttConnect?: MqttConnectFn;
-    /** Injected flush (tests). */
-    flush?: () => Promise<FlushSummary>;
+    /** Injected flush (tests). Receives the daemon shutdown signal. */
+    flush?: (signal?: AbortSignal) => Promise<FlushSummary>;
     /** Injected outbox replay (tests). */
     replayOutbox?: () => Promise<{
         delivered: number;
@@ -44,6 +54,10 @@ export interface DaemonRunDeps {
         quarantined: number;
         skipped?: number;
     }>;
+    /** Injected held-session recovery (tests). Runs once before the startup flush. */
+    backfillHeld?: () => Promise<BackfillHeldResult>;
+    /** Maximum distinct held sessions reconciled during one daemon startup. */
+    heldBackfillBatchSize?: number;
     /** Injected board refresh (tests). */
     refreshBoards?: () => Promise<{
         refreshed: number;
@@ -70,11 +84,43 @@ export interface DaemonRunDeps {
     exit?: (code: number) => void;
     /** Token provider (tests). */
     getToken?: () => Promise<string>;
+    /** Low-level tenant I/O seams used by authorization regression tests. */
+    poster?: SessionEventsPoster;
+    deliver?: DeliverFn;
+    readBoard?: BoardReader;
+    resolveMembership?: (token: string, slug: string, signal?: AbortSignal) => Promise<{
+        companyUid: string;
+    } | null>;
+    /**
+     * Machine credential (fleet box or local bot). A refused or empty membership
+     * probe defers; it does not clear the company. Defaults to isMachineIdentity().
+     */
+    machineIdentity?: boolean;
+    /** Test seam immediately before a device-default revocation's guarded commit. */
+    beforeDeviceDefaultRevocationCommit?: () => void;
     log?: (dir: string, line: string) => void;
     /** Stop after this many ms (tests). */
     runForMs?: number;
+    /** CLI version loaded by this daemon. Defaults to this package's version. */
+    daemonVersion?: string;
+    /** realpath of the CLI entry. Defaults to process.argv[1]. */
+    cliEntry?: string;
+    /**
+     * Subscribe to the personal work topic and write live-cache.json.
+     * The `hq mesh daemon run` command turns this on. Tests leave it off
+     * unless they inject credentials.
+     */
+    enableWorkCache?: boolean;
+    fetchPersonalCredentials?: import("./credentials.js").PersonalCredentialsFetcher;
+    /** Read the currently installed CLI version behind the launch entrypoint. */
+    readInstalledCliVersion?: () => string | null;
     random?: () => number;
     now?: () => Date;
+    /** Host for legacy listen retirement. Tests inject this; default is process.platform. */
+    legacyListenPlatform?: LegacyListenPlatform;
+    /** Service-manager runner for legacy listen retirement (tests inject). */
+    legacyListenRun?: CommandRunner;
+    windowsLegacyTaskPresent?: boolean;
 }
 export interface DaemonHandle {
     stop: () => Promise<void>;