@indigoai-us/hq-cli 5.132.0 → 5.133.0

package/dist/lib/lanes/types.js

@@ -198,7 +198,8 @@ export const LANE_FIELD_WRITERS = {
     project_id: ["command"], story_id: ["command"], thread_id: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "reconcile"],
-    pickup_validation_pending: ["creator", "command", "spawn"],
+    pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
+    pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"],
     provider: ["creator"], account: ["creator", "spawn", "command"], account_history: ["command"], pending_resume: ["command", "spawn"], host: ["creator"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],

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

@@ -5,6 +5,7 @@
 import { type CognitoActorKind, type CognitoTokenSource } from "../../../../utils/cognito-session.js";
 import { type UnattributedEventCounts } from "../spool.js";
 import { type DaemonStateFile } from "./state.js";
+import { type LegacyListenPlatform } from "./legacy-listen.js";
 export declare const UNHEALTHY_SPOOL_AGE_MS = 60000;
 export interface DaemonDoctorReport {
     running: boolean;
@@ -54,6 +55,8 @@ export interface DaemonDoctorReport {
     };
     /** Work held or quarantined after default-derived membership was denied. */
     deviceDefaultAuthorizationDenials: number;
+    /** True when the pack-era listen unit is still on disk. */
+    legacyListenerInstalled: boolean;
 }
 export interface DaemonDoctorDeps {
     home?: string;
@@ -64,6 +67,9 @@ export interface DaemonDoctorDeps {
     env?: NodeJS.ProcessEnv;
     isProcessAlive?: (pid: number) => boolean;
     now?: () => number;
+    /** Override the legacy-listen probe (tests). */
+    legacyListenerInstalled?: boolean;
+    platform?: LegacyListenPlatform;
 }
 export declare function collectDaemonDoctor(deps?: DaemonDoctorDeps): DaemonDoctorReport;
 export declare function formatDaemonDoctor(report: DaemonDoctorReport): string[];

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

@@ -18,6 +18,7 @@ import { hasCurrentAcknowledgedRegistration, readHeldSessions, refWithLocalCompa
 import { readDaemonConfig } from "./config.js";
 import { pidLockStatus, readPidLock } from "./pid-lock.js";
 import { readDaemonState } from "./state.js";
+import { LEGACY_LISTENER_DOCTOR_LINE, legacyListenInstalled, } from "./legacy-listen.js";
 export const UNHEALTHY_SPOOL_AGE_MS = 60_000;
 function oldestJsonlAgeMs(filePath, nowMs) {
     if (!fs.existsSync(filePath))
@@ -144,6 +145,14 @@ export function collectDaemonDoctor(deps = {}) {
     if (presenceRefusal) {
         unhealthyReasons.push(`presence credential refused (${presenceRefusal.code}); next retry ${presenceRefusal.nextRetryAt}`);
     }
+    const platform = deps.platform ?? process.platform;
+    const legacyListener = deps.legacyListenerInstalled ??
+        (platform === "darwin" || platform === "linux"
+            ? legacyListenInstalled({ home, platform })
+            : false);
+    if (legacyListener) {
+        unhealthyReasons.push(LEGACY_LISTENER_DOCTOR_LINE);
+    }
     const auth = describeCognitoTokenSource({ home, env });
     const whoamiTokens = readPersonTokenFile(home, env);
     const daemonTokens = auth.tokenSource === "machine"
@@ -192,6 +201,7 @@ export function collectDaemonDoctor(deps = {}) {
             }
             : undefined,
         deviceDefaultAuthorizationDenials,
+        legacyListenerInstalled: legacyListener,
     };
 }
 export function formatDaemonDoctor(report) {
@@ -200,6 +210,7 @@ export function formatDaemonDoctor(report) {
         `mode: ${report.emitMode}`,
         `mqtt: ${report.mqttState}`,
         `subscription: ${report.subscribed ? "connected" : "disconnected"}`,
+        ...(report.legacyListenerInstalled ? [LEGACY_LISTENER_DOCTOR_LINE] : []),
         `companies online: ${report.companiesOnline.length ? report.companiesOnline.join(", ") : "(none)"}`,
     ];
     if (report.emitMode === "legacy") {

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

@@ -235,6 +235,13 @@ export declare function installDaemonService(opts: {
     schtasks?: SchtasksRunner;
     /** Windows: terminate the recorded daemon pid when replacing a task (tests inject). */
     kill?: (pid: number) => void;
+    /** Service-manager runner for retiring the legacy listen unit (tests inject). */
+    runCommand?: (cmd: string, args: string[]) => {
+        status: number | null;
+        stdout: string;
+        stderr: string;
+    };
+    windowsLegacyTaskPresent?: boolean;
 }): InstallResult;
 export declare function uninstallDaemonService(opts: {
     platform?: DaemonInstallPlatform;

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

@@ -19,6 +19,7 @@ import { resolveDaemonAssetDir } from "./log.js";
 import { LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, WINDOWS_TASK_NAME, daemonDir, daemonLogPath, daemonPidPath, } from "./paths.js";
 import { isInstallableHqRoot, readDaemonConfig, registerTrustedHqRoot, verifyHqRoot } from "./config.js";
 import { defaultPidLockDeps, pidLockStatus, readPidLock } from "./pid-lock.js";
+import { retireLegacyListen } from "./legacy-listen.js";
 /**
  * `schtasks /End` terminates the task's root process only. The daemon is
  * launched through `conhost.exe --headless`, so ending the task kills conhost
@@ -651,6 +652,15 @@ export function installDaemonService(opts) {
     const mkdirSync = opts.mkdirSync ?? fs.mkdirSync;
     mkdirSync(paths.daemonDir, { recursive: true, mode: 0o700 });
     registerTrustedHqRoot(paths.daemonDir, paths.hqRoot);
+    const retired = retireLegacyListen({
+        home: paths.home,
+        platform,
+        run: opts.runCommand,
+        windowsTaskPresent: opts.windowsLegacyTaskPresent,
+    });
+    const legacyNote = retired.removed
+        ? " Retired legacy listener ai.getindigo.hq-work-mesh-listen."
+        : "";
     if (platform === "darwin") {
         const rendered = renderLaunchdPlist(paths);
         mkdirSync(paths.launchAgentsDir, { recursive: true });
@@ -662,7 +672,7 @@ export function installDaemonService(opts) {
             paths,
             rendered,
             dest: paths.plistPath,
-            message: `Installed LaunchAgent ${LAUNCHD_LABEL} → ${paths.plistPath}`,
+            message: `Installed LaunchAgent ${LAUNCHD_LABEL} → ${paths.plistPath}${legacyNote}`,
         };
     }
     if (platform === "linux") {
@@ -682,7 +692,7 @@ export function installDaemonService(opts) {
                 dest,
                 message: `Wrote system unit template for user ${opts.systemUser ?? paths.systemUser} at ${dest}. ` +
                     `Install with: sudo cp ${dest} /etc/systemd/system/${SYSTEMD_UNIT_NAME} && ` +
-                    `sudo systemctl daemon-reload && sudo systemctl enable --now ${SYSTEMD_UNIT_NAME}`,
+                    `sudo systemctl daemon-reload && sudo systemctl enable --now ${SYSTEMD_UNIT_NAME}${legacyNote}`,
             };
         }
         const rendered = renderSystemdUserUnit(paths);
@@ -696,7 +706,7 @@ export function installDaemonService(opts) {
             paths,
             rendered,
             dest: paths.systemdUnitPath,
-            message: `Installed systemd user unit ${SYSTEMD_UNIT_NAME} → ${paths.systemdUnitPath}`,
+            message: `Installed systemd user unit ${SYSTEMD_UNIT_NAME} → ${paths.systemdUnitPath}${legacyNote}`,
         };
     }
     if (platform === "win32") {
@@ -728,9 +738,9 @@ export function installDaemonService(opts) {
             dest: paths.windowsTaskXmlPath,
             running,
             message: running
-                ? `${rootLine}Installed Scheduled Task ${WINDOWS_TASK_NAME} → ${paths.windowsTaskXmlPath} (started; ${mode})`
+                ? `${rootLine}Installed Scheduled Task ${WINDOWS_TASK_NAME} → ${paths.windowsTaskXmlPath} (started; ${mode})${legacyNote}`
                 : `${rootLine}Installed Scheduled Task ${WINDOWS_TASK_NAME} → ${paths.windowsTaskXmlPath} (${mode}); ` +
-                    `start failed: ${(started.stderr || started.stdout).trim()}. It starts at next logon.`,
+                    `start failed: ${(started.stderr || started.stdout).trim()}. It starts at next logon.${legacyNote}`,
             notice: windowsLogonNotice(paths),
         };
     }
@@ -738,7 +748,7 @@ export function installDaemonService(opts) {
         platform,
         action: "install",
         paths,
-        message: `Unsupported platform for service install; run: ${paths.nodeBinary} ${paths.hqBinary} mesh daemon run`,
+        message: `Unsupported platform for service install; run: ${paths.nodeBinary} ${paths.hqBinary} mesh daemon run${legacyNote}`,
     };
 }
 export function uninstallDaemonService(opts) {

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/presence.d.ts

@@ -34,7 +34,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 {
@@ -111,8 +115,8 @@ 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;

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

@@ -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,8 +85,8 @@ 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 = [];
@@ -281,6 +285,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 +388,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

@@ -18,6 +18,7 @@ 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. */
@@ -102,10 +103,22 @@ export interface DaemonRunDeps {
     runForMs?: number;
     /** CLI version loaded by this daemon. Defaults to this package's version. */
     daemonVersion?: 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>;

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

@@ -26,17 +26,19 @@ import { backfillHeldSessions, } from "../backfill-held.js";
 import { reconcileObservation } from "../../../work-context/reconcile.js";
 import { workMeshRoot, workMeshSpoolPath } from "../paths.js";
 import { createVaultBoardReader, refreshBoundSessionBoards, BOARD_REFRESH_INTERVAL_MS, } from "./board-refresh.js";
-import { createContract3Fetcher, realTimerHost, } from "./credentials.js";
+import { createContract3Fetcher, createPersonalRealtimeFetcher, realTimerHost, } from "./credentials.js";
 import { appendDaemonLog, daemonLogLine, ensureDaemonLog } from "./log.js";
 import { acquirePidLock, defaultPidLockDeps, releasePidLock, } from "./pid-lock.js";
 import { daemonDir } from "./paths.js";
-import { PresenceClient, } from "./presence.js";
+import { PresenceClient, defaultMqttConnect, } from "./presence.js";
 import { defaultDaemonState, patchDaemonState, readDaemonState, writeDaemonState, } from "./state.js";
 import { workMeshHeldPath } from "../paths.js";
 import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, TranscriptWatcher, } from "./transcript-watch.js";
 import { resolveMeshEmitMode, runsEmitPath, } from "./mode.js";
 import { hasCliVersionDrift, readInstalledCliVersion } from "./version-drift.js";
 import { readDaemonConfig } from "./config.js";
+import { retireLegacyListen } from "./legacy-listen.js";
+import { startWorkCacheSubscriber } from "./work-subscribe.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
 /** Keep startup recovery bounded: the next daemon start continues the backlog. */
@@ -112,6 +114,15 @@ export async function runMeshDaemon(deps = {}) {
     const daemonVersion = deps.daemonVersion ?? CLI_VERSION;
     const installedCliVersion = deps.readInstalledCliVersion ?? readInstalledCliVersion;
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const hostPlatform = process.platform === "darwin" || process.platform === "linux" || process.platform === "win32"
+        ? process.platform
+        : "other";
+    const retiredListen = retireLegacyListen({
+        home,
+        platform: deps.legacyListenPlatform ?? hostPlatform,
+        run: deps.legacyListenRun,
+        windowsTaskPresent: deps.windowsLegacyTaskPresent,
+    });
     const configuredRoots = readDaemonConfig(dir).trustedHqRoots;
     const trustedRoots = [...new Set([
             ...(deps.hqRoot ? [deps.hqRoot] : []),
@@ -119,6 +130,9 @@ export async function runMeshDaemon(deps = {}) {
             ...configuredRoots,
         ])];
     ensureDaemonLog(dir);
+    if (retiredListen.removed) {
+        log(dir, "retired legacy listener ai.getindigo.hq-work-mesh-listen");
+    }
     const lockDeps = deps.pidLock ?? defaultPidLockDeps({ isProcessAlive: alive });
     const lock = acquirePidLock(dir, lockDeps);
     if (!lock.ok) {
@@ -369,6 +383,7 @@ export async function runMeshDaemon(deps = {}) {
             });
         });
     let presence = null;
+    let workCache = null;
     if (deps.enablePresence !== false) {
         const fetchCredentialsRaw = deps.fetchCredentials ??
             (async () => {
@@ -430,6 +445,31 @@ export async function runMeshDaemon(deps = {}) {
             // Continue draining spool even if MQTT is down.
         }
     }
+    if (deps.enableWorkCache) {
+        try {
+            workCache = await startWorkCacheSubscriber({
+                meshRoot,
+                fetchCredentials: deps.fetchPersonalCredentials ?? (async () => {
+                    const t = await getToken();
+                    return createPersonalRealtimeFetcher({
+                        token: t,
+                        baseUrl: resolveVaultApiBase(env),
+                    })();
+                }),
+                mqttConnect: (url, options) => {
+                    const connect = deps.mqttConnect ?? defaultMqttConnect;
+                    return connect(url, options);
+                },
+                now,
+                onInfo: (message) => log(dir, message.slice(0, 200)),
+                random: deps.random,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(dir, `work cache subscribe failed: ${msg.slice(0, 200)}`);
+        }
+    }
     let stopped = false;
     let restartRequested = false;
     let flushInFlight = null;
@@ -708,6 +748,15 @@ export async function runMeshDaemon(deps = {}) {
         // Final flush, then clean MQTT DISCONNECT so the broker emits the
         // lifecycle event; offline is published server-side only.
         await doFlushCycle("shutdown", { force: true });
+        if (workCache) {
+            try {
+                await workCache.stop();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(dir, `work cache stop error: ${msg.slice(0, 120)}`);
+            }
+        }
         if (presence) {
             try {
                 await presence.stop();