@indigoai-us/hq-cli 5.284.0 → 5.286.0

package/CHANGELOG.md

@@ -2,8 +2,24 @@
 
 ## [Unreleased]
 
+## [5.286.0] — 2026-09-29
+
+### Changed
+
+- On Linux the daemon's sync runner writes its protocol output to a named
+  pipe, `~/.hq/daemon/protocol/sync.fifo`, instead of an anonymous pipe. With
+  `daemon.supervisor-handoff` on, an outpost daemon restart now hands sync to
+  the next daemon like the other services instead of stopping and restarting
+  it, and output the old daemon had not read reaches the new one. Other
+  platforms keep the anonymous pipe.
+
+## [5.285.0] — 2026-09-29
+
+- Route eligible Linux CI jobs onto ARM runners while retaining existing test and platform gates.
+
 ## [5.284.0] — 2026-09-29
 - The existing Work Mesh MQTT subscriber can signal agent inbox wakes through a private local marker without persisting MQTT message contents.
+- Add `hq agents jobs resume <uid> <jobId>` to re-enable paused agent job schedules.
 
 ### Fixed
 
@@ -11,6 +27,14 @@
   capacity probes, or mirror snapshots to other Outposts. Two Outposts that
   each held a lane placed on the other ran `hq lanes list --json` on each other
   without end, which filled both boxes with SSM commands.
+- `hq doctor` labels the detected agent runtime value as `Agent platform` in human output. The JSON platform field and schema are unchanged.
+
+### Fixed
+
+- Refresh remote lane mirrors on hosts with an Outpost identity, while excluding
+  mirrors owned by that host. Resolve company attribution before checking the
+  mirror gate for refreshes and remote logs; unresolved lanes stay local.
+  Remote-read invocations skip refresh to prevent reciprocal Outpost fan-out.
 
 ## [5.283.0] — 2026-09-29
 

package/dist/command-catalog.generated.d.ts

@@ -4257,7 +4257,7 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly subcommands: readonly [];
     }, {
         readonly name: "jobs";
-        readonly description: "List, pause, or cancel an agent's scheduled jobs";
+        readonly description: "List, pause, resume, or cancel an agent's scheduled jobs";
         readonly aliases: readonly [];
         readonly hidden: false;
         readonly usage: "[options] [command]";
@@ -4302,6 +4302,26 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "Company slug (to resolve an agent by name/slug)";
             }];
             readonly subcommands: readonly [];
+        }, {
+            readonly name: "resume";
+            readonly description: "Resume a paused job's schedule";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly usage: "[options] <agentUid> <jobId>";
+            readonly arguments: readonly [{
+                readonly name: "agentUid";
+                readonly required: true;
+                readonly variadic: false;
+            }, {
+                readonly name: "jobId";
+                readonly required: true;
+                readonly variadic: false;
+            }];
+            readonly options: readonly [{
+                readonly flags: "--company <slug>";
+                readonly description: "Company slug (to resolve an agent by name/slug)";
+            }];
+            readonly subcommands: readonly [];
         }, {
             readonly name: "cancel";
             readonly description: "Cancel a job and delete its schedule";

package/dist/command-catalog.generated.js

@@ -5512,7 +5512,7 @@ export const COMMAND_CATALOG = [
             },
             {
                 "name": "jobs",
-                "description": "List, pause, or cancel an agent's scheduled jobs",
+                "description": "List, pause, resume, or cancel an agent's scheduled jobs",
                 "aliases": [],
                 "hidden": false,
                 "usage": "[options] [command]",
@@ -5570,6 +5570,32 @@ export const COMMAND_CATALOG = [
                         ],
                         "subcommands": []
                     },
+                    {
+                        "name": "resume",
+                        "description": "Resume a paused job's schedule",
+                        "aliases": [],
+                        "hidden": false,
+                        "usage": "[options] <agentUid> <jobId>",
+                        "arguments": [
+                            {
+                                "name": "agentUid",
+                                "required": true,
+                                "variadic": false
+                            },
+                            {
+                                "name": "jobId",
+                                "required": true,
+                                "variadic": false
+                            }
+                        ],
+                        "options": [
+                            {
+                                "flags": "--company <slug>",
+                                "description": "Company slug (to resolve an agent by name/slug)"
+                            }
+                        ],
+                        "subcommands": []
+                    },
                     {
                         "name": "cancel",
                         "description": "Cancel a job and delete its schedule",

package/dist/commands/agents.d.ts

@@ -19,6 +19,7 @@
  *   hq agents revoke <uid> --yes   — revoke an external agent (--remove deletes it)
  *   hq agents jobs list <uid>      — off-box job roster (schedule + rate)
  *   hq agents jobs pause <uid> <jobId>  — flip schedule State=DISABLED
+ *   hq agents jobs resume <uid> <jobId> — flip schedule State=ENABLED
  *   hq agents jobs cancel <uid> <jobId> — delete schedule + drop the job
  *
  * Agents are company-scoped. `--company <slug>` may sit on the group
@@ -320,12 +321,20 @@ export interface PauseJobResult {
     changed: boolean;
     previousState?: string;
 }
+export interface ResumeJobResult {
+    ok: true;
+    jobId: string;
+    scheduleState: "ENABLED" | string;
+    changed: boolean;
+    previousState?: string;
+}
 export interface CancelJobResult {
     ok: true;
     jobId: string;
 }
 export declare function listAgentJobs(token: string, agentUid: string): Promise<AgentJobView[]>;
 export declare function pauseAgentJob(token: string, agentUid: string, jobId: string): Promise<PauseJobResult>;
+export declare function resumeAgentJob(token: string, agentUid: string, jobId: string): Promise<ResumeJobResult>;
 export declare function cancelAgentJob(token: string, agentUid: string, jobId: string): Promise<CancelJobResult>;
 /**
  * Map a jobs-control HTTP error to a single operator-facing line. Pure so the
@@ -336,10 +345,11 @@ export declare function cancelAgentJob(token: string, agentUid: string, jobId: s
  * the agent is cross-company) must print a clear message and exit non-zero,
  * never throw a stack trace.
  */
-export declare function formatJobsHttpError(err: AgentsHttpError, jobId?: string): string;
+export declare function formatJobsHttpError(err: AgentsHttpError, jobId?: string, action?: "resume"): string;
 /** Stable padEnd table: jobId, scheduleState, rate, lastRunOutcome, status. */
 export declare function formatJobsTable(jobs: AgentJobView[]): string;
 export declare function formatPauseResult(result: PauseJobResult): string;
+export declare function formatResumeResult(result: ResumeJobResult): string;
 /** Human-readable "hot-applied to the running box" vs "saved for next launch". */
 export declare function appliedHint(applied: boolean): string;
 /** Stable human table shared by the all-provider and provider-filtered forms. */

package/dist/commands/agents.js

@@ -19,6 +19,7 @@
  *   hq agents revoke <uid> --yes   — revoke an external agent (--remove deletes it)
  *   hq agents jobs list <uid>      — off-box job roster (schedule + rate)
  *   hq agents jobs pause <uid> <jobId>  — flip schedule State=DISABLED
+ *   hq agents jobs resume <uid> <jobId> — flip schedule State=ENABLED
  *   hq agents jobs cancel <uid> <jobId> — delete schedule + drop the job
  *
  * Agents are company-scoped. `--company <slug>` may sit on the group
@@ -790,6 +791,13 @@ export async function pauseAgentJob(token, agentUid, jobId) {
         method: "POST",
     });
 }
+export async function resumeAgentJob(token, agentUid, jobId) {
+    return agentsRequest({
+        token,
+        path: `/v1/agents/${encodeURIComponent(agentUid)}/jobs/${encodeURIComponent(jobId)}/resume`,
+        method: "POST",
+    });
+}
 export async function cancelAgentJob(token, agentUid, jobId) {
     return agentsRequest({
         token,
@@ -806,7 +814,7 @@ export async function cancelAgentJob(token, agentUid, jobId) {
  * the agent is cross-company) must print a clear message and exit non-zero,
  * never throw a stack trace.
  */
-export function formatJobsHttpError(err, jobId) {
+export function formatJobsHttpError(err, jobId, action) {
     if (err.status === 401)
         return "Not authenticated — run `hq login`.";
     // A 403 CROSS_AGENT_JOB is hq-pro's self-only jobs guard, not a role problem:
@@ -816,12 +824,17 @@ export function formatJobsHttpError(err, jobId) {
     // closed locally before the request, see crossAgentJobsRefusal).
     if (err.status === 403 && err.code === "CROSS_AGENT_JOB") {
         return ("Jobs are scoped to the calling agent's own identity — an agent may only " +
-            "list, pause, or cancel its OWN jobs (use the on-box `hq-agent-jobs` tool). " +
+            "list, pause, resume, or cancel its OWN jobs (use the on-box `hq-agent-jobs` tool). " +
             "Managing another agent's jobs needs a person session with owner/admin on " +
             "the company.");
     }
     if (err.status === 403)
         return "You need owner/admin on this company.";
+    if (action === "resume" &&
+        err.status === 404 &&
+        (err.code === "JOB_NOT_FOUND" || err.code === "SCHEDULE_NOT_FOUND")) {
+        return "job not found or its schedule was deleted; it cannot be resumed";
+    }
     if (err.status === 404 && err.code === "JOB_NOT_FOUND") {
         const id = jobId ?? extractQuotedJobId(err.message) ?? "unknown";
         return `Job '${id}' not found.`;
@@ -860,6 +873,12 @@ export function formatPauseResult(result) {
     const from = result.previousState ?? "ENABLED";
     return `Paused ${result.jobId} (${from} → ${result.scheduleState})`;
 }
+export function formatResumeResult(result) {
+    if (!result.changed)
+        return "Already active";
+    const from = result.previousState ?? "DISABLED";
+    return `Resumed ${result.jobId} (${from} → ${result.scheduleState})`;
+}
 /** Human-readable "hot-applied to the running box" vs "saved for next launch". */
 export function appliedHint(applied) {
     return applied
@@ -1119,9 +1138,9 @@ function fail(err) {
     }
     process.exit(1);
 }
-function failJobs(err, jobId) {
+function failJobs(err, jobId, action) {
     if (err instanceof AgentsHttpError) {
-        console.error(chalk.red(formatJobsHttpError(err, jobId)));
+        console.error(chalk.red(formatJobsHttpError(err, jobId, action)));
         process.exit(1);
     }
     fail(err);
@@ -1922,11 +1941,11 @@ export function registerAgentsCommand(program) {
         }
     });
     // Off-box job control (US-003). Nested group so `hq agents jobs --help`
-    // lists list|pause|cancel. Same vaultApiFetch + person JWT as the rest of
+    // lists list|pause|resume|cancel. Same vaultApiFetch + person JWT as the rest of
     // this file; keyed HQ_API_KEY rewrites /v1/agents → /v1/keys/agents.
     const jobs = agents
         .command("jobs")
-        .description("List, pause, or cancel an agent's scheduled jobs");
+        .description("List, pause, resume, or cancel an agent's scheduled jobs");
     jobs
         .command("list <agentUid>")
         .description("List an agent's scheduled jobs")
@@ -1964,6 +1983,20 @@ export function registerAgentsCommand(program) {
             failJobs(err, jobId);
         }
     });
+    jobs
+        .command("resume <agentUid> <jobId>")
+        .description("Resume a paused job's schedule")
+        .option("--company <slug>", "Company slug (to resolve an agent by name/slug)")
+        .action(async function (agentUid, jobId) {
+        const { token, targetUid } = await resolveJobsTargetOrExit(agentUid, companyOf(this));
+        try {
+            const result = await resumeAgentJob(token, targetUid, jobId);
+            console.log(chalk.green(formatResumeResult(result)));
+        }
+        catch (err) {
+            failJobs(err, jobId, "resume");
+        }
+    });
     jobs
         .command("cancel <agentUid> <jobId>")
         .description("Cancel a job and delete its schedule")

package/dist/commands/lanes.js

@@ -1238,17 +1238,17 @@ async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispa
     }
     return invocationMemo.getOrCreate(outpostId, query, () => readOutpostSnapshotWithCache(ctx, outpostLaneListSnapshotKey(outpostId, query), isLaneRecordArray, () => readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions)));
 }
-/** Refresh only primary-created, non-terminal Outpost mirrors in one bounded owner query per Outpost. */
+/** Refresh only this host's non-terminal Outpost mirrors in one bounded owner query per Outpost. */
 async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
     const result = {
         updated: new Map(),
         unverifiedRemote: new Map(),
     };
     const host = reconcileHostFromCtx(ctx);
-    if (host.outpostId !== null || parentLaneIds?.size === 0)
+    if (ctx.env.HQ_LANES_REMOTE_READ === "1" || parentLaneIds?.size === 0)
         return result;
     let primaryIdentity;
-    const originMatchesThisPrimary = (lane) => {
+    const originMatchesThisHost = (lane) => {
         if (lane.origin_host_source !== "imds") {
             return lane.origin_host === host.hostname;
         }
@@ -1261,7 +1261,8 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
     };
     const candidates = records
         .filter((lane) => lane.host.kind === "outpost" &&
-        originMatchesThisPrimary(lane) &&
+        (host.outpostId === null || lane.host.id !== host.outpostId) &&
+        originMatchesThisHost(lane) &&
         (parentLaneIds === undefined || (lane.senior.kind === "lane" &&
             lane.senior.id !== undefined &&
             parentLaneIds.has(lane.senior.id))) &&
@@ -1272,11 +1273,14 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
     const enabledByCompany = new Map();
     const enabledCandidates = [];
     for (const lane of candidates) {
-        const companyKey = JSON.stringify([lane.company?.uid ?? null, lane.company?.slug ?? null]);
+        const company = resolveLaneCompany(hqRoot, lane).company;
+        if (company === null)
+            continue;
+        const companyKey = JSON.stringify([company.uid, company.slug]);
         let enabled = enabledByCompany.get(companyKey);
         if (enabled === undefined) {
             enabled = await readLanesRegistryFlag(LANE_REMOTE_MIRROR_SYNC_FLAG, {
-                company: lane.company,
+                company,
                 env: ctx.env,
             });
             enabledByCompany.set(companyKey, enabled);
@@ -1346,7 +1350,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                 : undefined;
             const before = readLane(hqRoot, mirror.lane_id);
             if (before.host.kind !== "outpost" || before.host.id !== outpostId ||
-                !originMatchesThisPrimary(before) || isTerminalLaneState(before.state)) {
+                !originMatchesThisHost(before) || isTerminalLaneState(before.state)) {
                 result.updated.set(mirror.lane_id, before);
                 continue;
             }
@@ -1365,7 +1369,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
             }
             const updated = retryUpdateLane(hqRoot, mirror.lane_id, "reconcile", (current) => {
                 if (current.host.kind !== "outpost" || current.host.id !== outpostId ||
-                    !originMatchesThisPrimary(current) || isTerminalLaneState(current.state))
+                    !originMatchesThisHost(current) || isTerminalLaneState(current.state))
                     return current;
                 return {
                     ...current,
@@ -6805,14 +6809,18 @@ const CANONICAL_LOG_STREAMS = [
 async function runLogs(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     const lane = readLane(hqRoot, laneId);
+    const remoteMirrorCompany = lane.host.kind === "outpost"
+        ? resolveLaneCompany(hqRoot, lane).company
+        : null;
     const tail = parseOptionalInt(opts.tail, "--tail");
     if (tail === 0) {
         throw new LanesError("invalid_integer", "--tail must be a positive integer", { flag: "--tail", value: opts.tail });
     }
     if (lane.host.kind === "outpost" &&
         !laneRunsHere(lane, reconcileHostFromCtx(ctx)) &&
+        remoteMirrorCompany !== null &&
         await readLanesRegistryFlag(LANE_REMOTE_MIRROR_SYNC_FLAG, {
-            company: lane.company,
+            company: remoteMirrorCompany,
             env: ctx.env,
         })) {
         const outpostId = lane.host.id;

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

@@ -12,6 +12,8 @@ export interface DaemonPaths {
     requestsDir: string;
     supervisorLogPath: string;
     unitLogPath: (unitId: string) => string;
+    /** The FIFO a unit that speaks the sync protocol writes its stdout to (see protocol-tail.ts); kept out of logs/ so nothing reading logs drains it. */
+    unitProtocolPath: (unitId: string) => string;
 }
 export declare function daemonPaths(home?: string, env?: NodeJS.ProcessEnv): DaemonPaths;
 /** Create `dir` (and any missing parents) readable only by its owner, and tighten it if it already exists. */

package/dist/lib/daemon/paths.js

@@ -18,6 +18,7 @@ export function daemonPaths(home = os.homedir(), env = process.env) {
         requestsDir: path.join(root, "requests"),
         supervisorLogPath: path.join(logsDir, "daemon.log"),
         unitLogPath: (unitId) => path.join(logsDir, `${unitId.replace(/[^A-Za-z0-9_.-]/g, "-")}.log`),
+        unitProtocolPath: (unitId) => path.join(root, "protocol", `${unitId.replace(/[^A-Za-z0-9_.-]/g, "-")}.fifo`),
     };
 }
 /** Create `dir` (and any missing parents) readable only by its owner, and tighten it if it already exists. */

package/dist/lib/daemon/protocol-tail.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A service's protocol output read from a named pipe instead of an anonymous
+ * one.
+ *
+ * An anonymous pipe loses its reader when the daemon exits, so a service
+ * writing to one cannot be handed to the next daemon. Here the service's
+ * stdout is a FIFO it holds open for reading and writing, so it always has a
+ * reader and never gets EPIPE. Each daemon polls the FIFO without blocking and
+ * feeds what it reads to the supervisor as the child's stdout. On a handoff
+ * the daemon stops reading without draining, so output it has not read stays
+ * in the kernel buffer for the next daemon, and nothing accumulates on disk.
+ */
+export interface ProtocolTail {
+    /** "data" carries each chunk read; "end" fires once, after close(). */
+    on(event: "data" | "end", handler: (chunk?: Buffer | string) => void): ProtocolTail;
+    /** The service exited: read what is left, emit "end" and stop polling. */
+    close(): void;
+    /** Handing over: stop polling without reading, leaving the rest for the next daemon. */
+    detach(): void;
+}
+/** Make `file` a FIFO, replacing anything else found there. */
+export declare function ensureProtocolFifo(file: string): void;
+/**
+ * The service's stdout. Opened for reading and writing, so the FIFO keeps a
+ * reader while no daemon has it open and the service's writes never fail.
+ */
+export declare function openProtocolWriter(file: string): number;
+export declare function createProtocolTail(file: string, opts?: {
+    pollMs?: number;
+    setInterval?: (fn: () => void, ms: number) => unknown;
+    clearInterval?: (handle: unknown) => void;
+}): ProtocolTail;
+//# sourceMappingURL=protocol-tail.d.ts.map

package/dist/lib/daemon/protocol-tail.js

@@ -0,0 +1,131 @@
+/**
+ * A service's protocol output read from a named pipe instead of an anonymous
+ * one.
+ *
+ * An anonymous pipe loses its reader when the daemon exits, so a service
+ * writing to one cannot be handed to the next daemon. Here the service's
+ * stdout is a FIFO it holds open for reading and writing, so it always has a
+ * reader and never gets EPIPE. Each daemon polls the FIFO without blocking and
+ * feeds what it reads to the supervisor as the child's stdout. On a handoff
+ * the daemon stops reading without draining, so output it has not read stays
+ * in the kernel buffer for the next daemon, and nothing accumulates on disk.
+ */
+import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ensurePrivateDir } from "./paths.js";
+const POLL_MS = 1_000;
+const READ_CHUNK_BYTES = 64 * 1024;
+/** Make `file` a FIFO, replacing anything else found there. */
+export function ensureProtocolFifo(file) {
+    ensurePrivateDir(path.dirname(file));
+    try {
+        if (fs.lstatSync(file).isFIFO())
+            return;
+        fs.rmSync(file, { force: true });
+    }
+    catch {
+        // Missing: created below.
+    }
+    const r = spawnSync("mkfifo", ["-m", "600", file], { encoding: "utf8" });
+    if (r.error)
+        throw r.error;
+    if (r.status !== 0)
+        throw new Error(`mkfifo ${file} failed: ${(r.stderr ?? "").trim() || `exit ${r.status}`}`);
+}
+/**
+ * The service's stdout. Opened for reading and writing, so the FIFO keeps a
+ * reader while no daemon has it open and the service's writes never fail.
+ */
+export function openProtocolWriter(file) {
+    return fs.openSync(file, fs.constants.O_RDWR);
+}
+export function createProtocolTail(file, opts = {}) {
+    const events = new EventEmitter();
+    const setI = opts.setInterval ?? ((fn, ms) => setInterval(fn, ms));
+    const clearI = opts.clearInterval ?? ((h) => clearInterval(h));
+    let fd = null;
+    let done = false;
+    const open = () => {
+        if (fd !== null)
+            return fd;
+        try {
+            fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+        }
+        catch {
+            fd = null;
+        }
+        return fd;
+    };
+    const read = () => {
+        const handle = open();
+        if (handle === null)
+            return;
+        const buf = Buffer.alloc(READ_CHUNK_BYTES);
+        for (;;) {
+            let n;
+            try {
+                n = fs.readSync(handle, buf, 0, buf.length, null);
+            }
+            catch (err) {
+                // EAGAIN: nothing written since the last read.
+                if (err.code === "EAGAIN")
+                    return;
+                throw err;
+            }
+            if (n <= 0)
+                return;
+            events.emit("data", Buffer.from(buf.subarray(0, n)));
+        }
+    };
+    const stop = () => {
+        done = true;
+        clearI(timer);
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // already closed
+            }
+            fd = null;
+        }
+    };
+    const timer = setI(() => {
+        try {
+            read();
+        }
+        catch {
+            // An unreadable FIFO reads as silence; the heartbeat watchdog restarts the service.
+        }
+    }, opts.pollMs ?? POLL_MS);
+    timer.unref?.();
+    // Open now, so the FIFO has a reader before the service starts writing.
+    open();
+    const tail = {
+        on(event, handler) {
+            events.on(event, handler);
+            return tail;
+        },
+        close() {
+            if (done)
+                return;
+            try {
+                read();
+            }
+            catch {
+                // nothing more to read
+            }
+            stop();
+            events.emit("end");
+        },
+        detach() {
+            if (done)
+                return;
+            stop();
+        },
+    };
+    return tail;
+}
+//# sourceMappingURL=protocol-tail.js.map

package/dist/lib/daemon/run.js

@@ -25,6 +25,7 @@ import { acquireDaemonLock, releaseDaemonLock } from "./lock.js";
 import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
+import { createProtocolTail, ensureProtocolFifo, openProtocolWriter } from "./protocol-tail.js";
 import { takeControlRequests } from "./requests.js";
 import { currentHqCloud, hqCloudRunners } from "./hq-cloud.js";
 import { runnerSessionName } from "./remote-control.js";
@@ -224,6 +225,14 @@ export function unitProcessEnv(base, unit) {
         env.NODE_OPTIONS = syncRunnerNodeOptions(env);
     return env;
 }
+function isFifo(file) {
+    try {
+        return fs.lstatSync(file).isFIFO();
+    }
+    catch {
+        return false;
+    }
+}
 export async function runDaemon(opts) {
     const env = opts.env ?? process.env;
     const home = opts.home ?? os.homedir();
@@ -263,6 +272,8 @@ export async function runDaemon(opts) {
         process.kill(pid, sig);
     };
     let adopt = [];
+    /** Readers of units' protocol FIFOs; a handoff detaches them so the next daemon reads what is left. */
+    const protocolTails = new Set();
     if (succession) {
         const taken = takeSuccession(succession, { now: Date.now, readStart: readProcStart, log });
         await stopOrphans(taken.orphans, {
@@ -271,7 +282,20 @@ export async function runDaemon(opts) {
             sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
             log,
         });
-        adopt = taken.adopt.map((u) => ({ id: u.id, key: u.key, child: adoptChild(u, { readStart: readProcStart, signal: signalPid }) }));
+        adopt = taken.adopt.map((u) => {
+            // A unit that speaks the sync protocol writes it to a FIFO; read what the previous daemon left.
+            const protocolPath = paths.unitProtocolPath(u.id);
+            const stdout = isFifo(protocolPath) ? createProtocolTail(protocolPath) : undefined;
+            const child = adoptChild(u, { readStart: readProcStart, signal: signalPid, ...(stdout ? { stdout } : {}) });
+            if (stdout) {
+                protocolTails.add(stdout);
+                child.on("exit", () => {
+                    protocolTails.delete(stdout);
+                    stdout.close();
+                });
+            }
+            return { id: u.id, key: u.key, child };
+        });
     }
     const tracker = succession ? createChildTracker(succession.childrenPath, { readStart: readProcStart, log }) : null;
     for (const unit of adopt)
@@ -381,11 +405,57 @@ export async function runDaemon(opts) {
                 : [command.file, command.args];
         const logPath = paths.unitLogPath(unit.id);
         const cwd = unit.env.HQ_ROOT && fs.existsSync(unit.env.HQ_ROOT) ? unit.env.HQ_ROOT : home;
+        if (unit.heartbeatTimeoutMs && succession) {
+            // The supervisor reads this unit's protocol heartbeats from stdout. Where
+            // services can outlive the daemon, stdout is a FIFO (see protocol-tail.ts)
+            // rather than a pipe, so the unit can be handed to the next daemon.
+            const protocolPath = paths.unitProtocolPath(unit.id);
+            ensureProtocolFifo(protocolPath);
+            const stdout = createProtocolTail(protocolPath);
+            const outFd = openProtocolWriter(protocolPath);
+            const errFd = openPrivateAppend(logPath);
+            try {
+                const child = spawn(file, args, {
+                    cwd,
+                    env: unitProcessEnv(env, unit),
+                    stdio: ["ignore", outFd, errFd],
+                    windowsHide: true,
+                });
+                spawned.add(child);
+                if (unit.service === "sync" && child.pid !== undefined)
+                    daemonSyncRunnerPids.add(child.pid);
+                protocolTails.add(stdout);
+                const finish = () => {
+                    protocolTails.delete(stdout);
+                    stdout.close();
+                };
+                child.once("exit", () => {
+                    spawned.delete(child);
+                    if (child.pid !== undefined)
+                        daemonSyncRunnerPids.delete(child.pid);
+                    finish();
+                });
+                child.once("error", finish);
+                const supervised = {
+                    pid: child.pid,
+                    stdout,
+                    on(event, handler) {
+                        child.on(event, handler);
+                        return supervised;
+                    },
+                    kill: (signal) => child.kill(signal),
+                };
+                if (unit.kind === "long-running")
+                    tracker?.track(unit.id, supervised);
+                return supervised;
+            }
+            finally {
+                fs.closeSync(outFd);
+                fs.closeSync(errFd);
+            }
+        }
         if (unit.heartbeatTimeoutMs) {
-            // The supervisor reads this unit's protocol heartbeats from stdout, so its
-            // output goes through the daemon. A piped child cannot outlive the daemon,
-            // so it is never handed over: a handoff stops it and the next daemon
-            // starts it again.
+            // Elsewhere the service stops with the daemon, so its output can go through a pipe.
             const logFd = openPrivateAppend(logPath);
             const logStream = fs.createWriteStream(logPath, { fd: logFd, autoClose: true });
             logStream.on("error", (err) => log("error", `could not write ${unit.id} log ${logPath}: ${err.message}`));
@@ -525,6 +595,10 @@ export async function runDaemon(opts) {
                 return;
             stopping = true;
             const released = supervisor.release();
+            // What these readers have not read stays in the FIFO for the next daemon.
+            for (const tail of protocolTails)
+                tail.detach();
+            protocolTails.clear();
             const starts = new Map((tracker?.records() ?? []).map((r) => [r.pid, r.start]));
             const units = released.flatMap((u) => {
                 const start = starts.get(u.pid);

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

@@ -95,6 +95,8 @@ export declare function adoptChild(record: ChildRecord, deps: {
     setInterval?: (fn: () => void, ms: number) => unknown;
     clearInterval?: (handle: unknown) => void;
     pollMs?: number;
+    /** Its protocol output, read from the file it writes to (see protocol-tail.ts). */
+    stdout?: SupervisedChild["stdout"];
 }): SupervisedChild;
 /** The loaded daemon unit's KillMode, or null when systemctl cannot tell. */
 export declare function systemdKillMode(run: (file: string, args: string[]) => {

package/dist/lib/daemon/succession.js

@@ -226,6 +226,7 @@ export function adoptChild(record, deps) {
     poll.unref?.();
     const child = {
         pid: record.pid,
+        ...(deps.stdout ? { stdout: deps.stdout } : {}),
         on(event, handler) {
             events.on(event, handler);
             return child;

package/dist/lib/doctor/report.js

@@ -103,7 +103,7 @@ export function renderText(options) {
     const pad = " ".repeat(STATUS_LABEL_WIDTH);
     const lines = [];
     lines.push(`hq doctor — HQ root: ${hqRoot}`);
-    lines.push(`Platform: ${platform.id}`);
+    lines.push(`Agent platform: ${platform.id}`);
     for (const run of families) {
         lines.push("");
         lines.push(`${run.family.title} (${run.family.id})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.284.0",
+  "version": "5.286.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {