@indigoai-us/hq-cli 5.343.0 → 5.343.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [5.343.1] — 2026-10-04
+
+- Include the bounded hq-cli version in `cli_feature_used` telemetry so feature-use rows can be grouped by release.
+
+- Release the HQ CLI package-use lease before hq daemon call waits for its daemon response, after preloading the request protocol.
+- Release the package-use lease after Outpost lane message and resume requests are submitted and their result-wait imports are preloaded.
+- Preserve human, agent, and both audience tags when CLI tools and local bots post or reply in channels.
+- Wait for a live installer to finish before retrying a failed CLI import when the install tree is still in flight.
+- Preserve bounded master-hook slow-phase and per-phase timeout attribution in Sentry reports.
+
 ## [5.343.0] — 2026-10-04
 - `hq company --company <slug> settings set --work-registry-enabled <true|false>` and `--work-mesh-live-enabled <true|false>` let a company owner turn work tracking on or off. Work tracking needs both switches; after either is set the command says whether work tracking is on and prints the exact command for the switch that is still off. `hq company --company <slug> settings get` now also shows both switches for an owner or admin.
 - `hq mesh context requeue` now also re-sends, by default, sessions that were refused while work tracking was off. `hq doctor` and `hq mesh daemon doctor` explain those refusals in plain words.

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

@@ -3204,7 +3204,7 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }, {
             readonly flags: "--audience <human|agent|both>";
-            readonly description: "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)";
+            readonly description: "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both";
             readonly hidden: false;
         }];
         readonly subcommands: readonly [];

package/dist/command-catalog.generated.js

@@ -3874,7 +3874,7 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--audience <human|agent|both>",
-                        "description": "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)",
+                        "description": "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both",
                         "hidden": false
                     }
                 ],

package/dist/commands/daemon.js

@@ -29,6 +29,7 @@ import { MACHINE_TYPE_MARKER_PATH, detectMachineType, homeFromPasswd, } from "..
 import { daemonPaths } from "../lib/daemon/paths.js";
 import { processCommandLine } from "../lib/daemon/lock.js";
 import { writeControlRequest } from "../lib/daemon/requests.js";
+import { runDaemonCall } from "../lib/daemon/command-call.js";
 import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
 import { getSyncModeForCompany, setSyncMode } from "./sync-mode.js";
 import { requireAnywhereRuntime } from "./anywhere-runtime-flag.js";
@@ -857,17 +858,7 @@ export function registerDaemonCommand(program, over = {}) {
         const timeoutMs = Number(opts.timeout ?? (op === "policy.check" ? "40000" : "20000"));
         if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
             throw new Error("--timeout must be a positive number of milliseconds");
-        const { hqdRequest, hqdSocketPath, HqdClientError } = await import("../lib/daemon/protocol.js");
-        try {
-            const result = await hqdRequest(op, args, { socketPath: hqdSocketPath(d.home, d.env), timeoutMs });
-            d.out(JSON.stringify(result, null, 2));
-        }
-        catch (err) {
-            if (!(err instanceof HqdClientError))
-                throw err;
-            d.out(JSON.stringify({ error: { code: err.code, message: err.message } }, null, 2));
-            process.exitCode = 1;
-        }
+        await runResidentCommandWithPackageLease("daemon-call", () => runDaemonCall(op, args, timeoutMs, d));
     }));
     daemon
         .command("status")

package/dist/commands/dm.js

@@ -614,11 +614,20 @@ async function runChannelSend(channelName, message, opts) {
         // Send the human-readable form: the quotes only existed for parsing.
         if (mentions.length > 0)
             body = stripMentionQuotes(body);
+        let audience;
+        if (opts.audience !== undefined && opts.audience !== "") {
+            if (!DM_AUDIENCE_VALUES.includes(opts.audience)) {
+                throw new Error(`Invalid --audience '${opts.audience}': must be human, agent, or both.`);
+            }
+            audience = opts.audience;
+        }
         const payload = { body };
         if (mentions.length > 0)
             payload.mentions = mentions;
         if (rootEventId)
             payload.rootEventId = rootEventId;
+        if (audience)
+            payload.audience = audience;
         const sendRes = await vaultApiFetch({
             token,
             path: `/v1/notify/channels/${encodeURIComponent(channel.channelId)}/messages`,
@@ -1327,7 +1336,7 @@ export function registerDmCommand(program) {
         .option("--details-file <path>", "Read the details from a file (1:1 DMs only)")
         .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time; 1:1 DMs only)")
         .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)")
-        .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both (1:1 DMs only)")
+        .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both")
         .action(async (recipient, message, opts) => {
         await runDmSend(recipient, message, opts);
     });

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

@@ -272,6 +272,7 @@ export interface Ctx {
         command: string;
         timeoutSeconds?: number;
         waitMs?: number;
+        beforeWait?: () => Promise<void>;
     }) => Promise<OutpostDispatchResult>;
     backfillOutpostIdentity: (expectedId: string) => "created" | "unchanged";
     fetchText: (url: string) => Promise<string>;

package/dist/commands/lanes.d.ts

@@ -86,6 +86,7 @@ export interface LanesCommandDeps {
         command: string;
         timeoutSeconds?: number;
         waitMs?: number;
+        beforeWait?: () => Promise<void>;
     }) => Promise<OutpostDispatchResult>;
     /** Test seam for the atomic, non-overwriting marker repair. */
     backfillOutpostIdentity?: (expectedId: string) => "created" | "unchanged";

package/dist/commands/lanes.js

@@ -4317,11 +4317,22 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     let dispatched;
     let grantContextRejected = false;
     let failedResumeOptionRejected = false;
+    let outpostWaitLeasePreparationStarted = false;
     try {
         const dispatchCommand = (contexts) => ctx.dispatchOutpostExec({
             outpostId,
             timeoutSeconds: Math.ceil(waitMs / 1000),
             waitMs,
+            ...(action === "message" || action === "resume"
+                ? {
+                    beforeWait: async () => {
+                        if (outpostWaitLeasePreparationStarted)
+                            return;
+                        outpostWaitLeasePreparationStarted = true;
+                        await runResidentCommandWithPackageLease("outpost-wait", async () => undefined);
+                    },
+                }
+                : {}),
             command: buildOutpostLaneCommand({
                 action: action === "grant"
                     ? "grant-target"

package/dist/lib/agent-kit/mcp/tools.js

@@ -237,7 +237,7 @@ export function buildAgentMcpTools(clients) {
                     const token = await clients.getToken();
                     const res = await clients.apiJson(token, `/v1/notify/channels/${encodeURIComponent(to)}/messages`, {
                         method: "POST",
-                        body: { body: message },
+                        body: { body: message, ...(audience ? { audience } : {}) },
                     });
                     if (res.status < 200 || res.status >= 300) {
                         return errorResult(`Channel send failed (${res.status}): ${describeError(res.body)}`);

package/dist/lib/bot/api.d.ts

@@ -239,6 +239,7 @@ export declare class BotApi {
         channelId: string;
         body: string;
         rootEventId?: string;
+        audience?: "human" | "agent" | "both";
     }): Promise<{
         eventId?: string;
         createdAt?: string;

package/dist/lib/bot/api.js

@@ -195,6 +195,8 @@ export class BotApi {
         const payload = { body: input.body };
         if (input.rootEventId)
             payload.rootEventId = input.rootEventId;
+        if (input.audience)
+            payload.audience = input.audience;
         const { body } = await this.call(`/v1/notify/channels/${encodeURIComponent(input.channelId)}/messages`, { method: "POST", body: payload });
         return body;
     }

package/dist/lib/bot/progress.d.ts

@@ -28,13 +28,10 @@ export declare const PROGRESS_MIN_GAP_MS = 4000;
 export declare const WORKING_NOTICE_MS = 60000;
 export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here when it's done.";
 export interface ProgressPosterOptions {
-    /** Post one message; resolve true when it was delivered. */
-    send: (body: string) => Promise<boolean>;
-    /**
-     * If provided, the final reply is sent through this instead of `send`.
-     * Use to tag the final reply differently from in-between progress messages.
-     */
-    sendFinal?: (body: string) => Promise<boolean>;
+    /** Post a live progress beat while the turn is still running. */
+    sendProgress: (body: string) => Promise<boolean>;
+    /** Post terminal content that the person needs to read. */
+    sendToPerson: (body: string) => Promise<boolean>;
     now?: () => number;
     setTimer?: (fn: () => void, ms: number) => unknown;
     clearTimer?: (handle: unknown) => void;
@@ -63,8 +60,8 @@ export declare function normalizeForCompare(text: string): string;
 /** Matches {"action":"no_reply"} anywhere in a model reply, with or without preamble text. */
 export declare function containsNoReplySentinel(text: string): boolean;
 export declare class ProgressPoster {
-    private readonly send;
-    private readonly sendFinalFn?;
+    private readonly sendProgress;
+    private readonly sendToPerson;
     private readonly now;
     private readonly setTimer;
     private readonly clearTimer;
@@ -95,6 +92,8 @@ export declare class ProgressPoster {
      * deliveries posted the placeholder right after a real message.
      */
     private queued;
+    /** Posts queued for the person, excluding agent-lane status beats. */
+    private personQueued;
     constructor(opts: ProgressPosterOptions);
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start(): void;
@@ -109,11 +108,9 @@ export declare class ProgressPoster {
     /** True once any message from the model was said this turn (not counting the notice). */
     get saidAnything(): boolean;
     /**
-     * The turn succeeded: post whatever is pending, then the final answer unless
-     * it repeats what was already said. Resolves once everything is sent.
-     *
-     * When `sendFinal` was provided, progress items flush through `send` and the
-     * final reply goes through `sendFinal` — keeping their audience tags distinct.
+     * The turn succeeded: post pending human-facing text, then a human-lane
+     * terminal message when the final adds something. Agent-lane status beats
+     * alone still receive a human-lane fallback before the turn closes.
      */
     finish(finalText: string): Promise<void>;
     /**
@@ -125,6 +122,7 @@ export declare class ProgressPoster {
     private scheduleFlush;
     private flushNow;
     private enqueue;
+    private enqueueToPerson;
     private enqueueWith;
     private cancelFlush;
     private cancelNotice;

package/dist/lib/bot/progress.js

@@ -36,8 +36,8 @@ export function containsNoReplySentinel(text) {
     return /\{\s*"action"\s*:\s*"no_reply"\s*\}/.test(text);
 }
 export class ProgressPoster {
-    send;
-    sendFinalFn;
+    sendProgress;
+    sendToPerson;
     now;
     setTimer;
     clearTimer;
@@ -68,9 +68,11 @@ export class ProgressPoster {
      * deliveries posted the placeholder right after a real message.
      */
     queued = 0;
+    /** Posts queued for the person, excluding agent-lane status beats. */
+    personQueued = 0;
     constructor(opts) {
-        this.send = opts.send;
-        this.sendFinalFn = opts.sendFinal;
+        this.sendProgress = opts.sendProgress;
+        this.sendToPerson = opts.sendToPerson;
         this.now = opts.now ?? Date.now;
         this.setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
         this.clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
@@ -92,7 +94,7 @@ export class ProgressPoster {
             if (this.finished || this.said.length > 0 || this.noticeSent)
                 return;
             this.noticeSent = true;
-            this.enqueue(this.workingNoticeText);
+            this.enqueueWith(this.workingNoticeText, this.sendProgress);
         }, this.workingNoticeMs);
     }
     /** One finished assistant message from the model. */
@@ -147,11 +149,9 @@ export class ProgressPoster {
         return this.said.length > 0;
     }
     /**
-     * The turn succeeded: post whatever is pending, then the final answer unless
-     * it repeats what was already said. Resolves once everything is sent.
-     *
-     * When `sendFinal` was provided, progress items flush through `send` and the
-     * final reply goes through `sendFinal` — keeping their audience tags distinct.
+     * The turn succeeded: post pending human-facing text, then a human-lane
+     * terminal message when the final adds something. Agent-lane status beats
+     * alone still receive a human-lane fallback before the turn closes.
      */
     async finish(finalText) {
         if (this.finished)
@@ -171,42 +171,25 @@ export class ProgressPoster {
         // Grok's final is every message concatenated, so it repeats and is skipped.
         // A silent turn (run.ts decides via sentinel/empty) never reaches here.
         if (this.buffer) {
+            const terminalParts = this.said.filter((s) => !containsNoReplySentinel(s));
             this.pending = [];
             this.heldQuestions = [];
-            for (const s of this.said) {
-                if (!containsNoReplySentinel(s))
-                    this.pending.push(s);
-            }
             if (final && !containsNoReplySentinel(final) && !this.repeatsSaid(final)) {
-                if (this.sendFinalFn) {
-                    // Keep the audience split: collected messages go through send, the
-                    // final reply through sendFinal.
-                    this.flushNow();
-                    this.enqueueWith(final, this.sendFinalFn);
-                    return this.chain;
-                }
-                this.pending.push(final);
+                terminalParts.push(final);
             }
-            this.flushNow();
+            this.enqueueToPerson(terminalParts.join("\n\n") || "(no reply)");
             return this.chain;
         }
         const held = this.heldQuestions;
         this.heldQuestions = [];
-        const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
-        if (!shouldAddFinal && held.length > 0)
-            this.pending.push(...held);
-        if (this.pending.length === 0 && this.queued === 0 && !shouldAddFinal)
-            this.pending.push("(no reply)");
-        if (this.sendFinalFn && shouldAddFinal) {
-            // Flush any remaining progress messages first, then the final reply separately.
-            this.flushNow();
-            this.enqueueWith(final, this.sendFinalFn);
-        }
-        else {
-            if (shouldAddFinal)
-                this.pending.push(final);
-            this.flushNow();
-        }
+        this.flushNow();
+        const shouldAddFinal = Boolean(final && !containsNoReplySentinel(final) && !this.repeatsSaid(final));
+        if (shouldAddFinal)
+            this.enqueueToPerson(final);
+        else if (held.length > 0)
+            this.enqueueToPerson(held.join("\n\n"));
+        else if (this.personQueued === 0)
+            this.enqueueToPerson("(no reply)");
         return this.chain;
     }
     /**
@@ -226,9 +209,11 @@ export class ProgressPoster {
             this.heldQuestions = [];
             return this.chain;
         }
-        this.pending.push(...this.heldQuestions);
+        const held = this.heldQuestions;
         this.heldQuestions = [];
         this.flushNow();
+        if (held.length > 0)
+            this.enqueueToPerson(held.join("\n\n"));
         return this.chain;
     }
     repeatsSaid(final) {
@@ -256,7 +241,11 @@ export class ProgressPoster {
         this.enqueue(body);
     }
     enqueue(body) {
-        this.enqueueWith(body, this.send);
+        this.enqueueToPerson(body);
+    }
+    enqueueToPerson(body) {
+        this.personQueued += 1;
+        this.enqueueWith(body, this.sendToPerson);
     }
     enqueueWith(body, sendFn) {
         // Defence in depth: never let the silence sentinel reach the chat, whatever

package/dist/lib/bot/run.js

@@ -766,8 +766,8 @@ export async function runBot(deps) {
             ...deps.progress,
             ...(args.workingNotice === false || silenceable || isSetupBot ? { workingNoticeMs: 0 } : {}),
             ...(silenceable || args.suppressOutput ? { buffer: true } : {}),
-            send: makeSendFn(args.send),
-            ...(args.sendFinal ? { sendFinal: makeSendFn(args.sendFinal) } : {}),
+            sendProgress: makeSendFn(args.sendProgress),
+            sendToPerson: makeSendFn(args.sendToPerson),
         });
         const controller = new AbortController();
         currentTurns.add(controller);
@@ -827,7 +827,7 @@ export async function runBot(deps) {
         const root = rootEventId ? { rootEventId } : {};
         return target.kind === "dm"
             ? api.sendDm({ toPersonUid: target.peerUid, body, ...root, ...(audience ? { audience } : {}) })
-            : api.sendChannelMessage({ channelId: target.channelId, body, ...root });
+            : api.sendChannelMessage({ channelId: target.channelId, body, ...root, ...(audience ? { audience } : {}) });
     };
     /**
      * Post `parts` in order, starting at `from`. A failure throws a
@@ -863,15 +863,15 @@ export async function runBot(deps) {
                 throw err;
             }
         };
-        const send = makeSend(target.kind === "dm" ? "agent" : undefined);
-        const sendFinal = makeSend(target.kind === "dm" ? "human" : undefined);
+        const sendProgress = makeSend("agent");
+        const sendToPerson = makeSend("human");
         const saved = (reply) => {
             const parts = splitBody(reply);
             const partial = last.value;
             const sameBody = partial !== null && partial.parts.length === parts.length && partial.parts.every((p, i) => p === parts[i]);
             return { reply, replyParts: parts, replyPartsDelivered: sameBody ? partial.delivered : 0 };
         };
-        return { send, sendFinal, saved };
+        return { sendProgress, sendToPerson, saved };
     };
     // ── Scheduled jobs ────────────────────────────────────────────────────────
     /** Newest pending run key already picked up, per jobId (one catch-up per wake). */
@@ -1113,14 +1113,14 @@ export async function runBot(deps) {
             }
         };
         const target = { kind: "dm", peerUid };
-        const { send, sendFinal, saved } = trackingSend(target);
+        const { sendProgress, sendToPerson, saved } = trackingSend(target);
         const { outcome, poster } = await runTurnWithProgress({
             marker: { messageId: KICKOFF_MESSAGE_ID, target, ...(thinking && introEventId ? { reactionEventId: introEventId } : {}) },
             prompt,
             sessionScope: "dm",
             tReceived,
-            send,
-            sendFinal,
+            sendProgress,
+            sendToPerson,
             // The intro already said the bot is starting, and the app shows it thinking.
             workingNotice: false,
         });
@@ -1146,7 +1146,7 @@ export async function runBot(deps) {
             clearInflight(dir, KICKOFF_MESSAGE_ID);
             patchBotConfig(dir, { kickoffPendingSignIn: true });
             markSignInBroken(outcome.excerpt);
-            await tellSignInNeeded("dm", send, true);
+            await tellSignInNeeded("dm", sendToPerson, true);
             return;
         }
         if (readBotConfig(dir)?.kickoffPendingSignIn)
@@ -1158,7 +1158,7 @@ export async function runBot(deps) {
             ? `${didNotFinishText(failureReason(outcome), poster.postedCount > 0)} Send me any message and I'll pick up from there.`
             : `Sorry — I couldn't get started on my own (${runtime.id} failed: ${outcome.excerpt.slice(0, 160)}). Send me any message and I'll pick up from there, or check that ${runtime.id} is signed in on this computer.`;
         try {
-            await send(body);
+            await sendToPerson(body);
             clearInflight(dir, KICKOFF_MESSAGE_ID);
         }
         catch {
@@ -1235,8 +1235,8 @@ export async function runBot(deps) {
                 throw err;
             }
         };
-        const send = makeSend(tracking.send);
-        const sendFinal = makeSend(tracking.sendFinal);
+        const sendProgress = makeSend(tracking.sendProgress);
+        const sendToPerson = makeSend(tracking.sendToPerson);
         const normalize = (text) => text.replace(/\s+/g, " ").trim();
         /**
          * True only when the final report itself reached the chat in full. With no
@@ -1272,8 +1272,8 @@ export async function runBot(deps) {
             prompt: buildJobTurnPrompt(job, { now: now(), timeZone }),
             sessionScope: target.sessionScope,
             tReceived,
-            send,
-            sendFinal,
+            sendProgress,
+            sendToPerson,
             // A scheduled run has nobody waiting in a chat: no "working on it" filler.
             workingNotice: false,
             ...(quietJob ? { suppressOutput: true } : {}),
@@ -1307,7 +1307,7 @@ export async function runBot(deps) {
             clearInflight(dir, id);
             attempts.delete(id);
             markSignInBroken(outcome.excerpt);
-            await tellSignInNeeded(`job:${jobId}`, (body) => sendToTarget(markerTarget, body));
+            await tellSignInNeeded(`job:${jobId}`, (body) => sendToTarget(markerTarget, body, undefined, "human"));
             log("warn", `kept scheduled run ${id} of job ${jobId} until ${runtime.id} can sign in again`);
             return; // un-acked, un-reported: run once the sign-in works
         }
@@ -1320,7 +1320,7 @@ export async function runBot(deps) {
                 return;
             }
             if (attempt >= MAX_ATTEMPTS_PER_MESSAGE) {
-                await send(`I couldn't run this one — ${runtime.id} kept failing: ${excerpt.slice(0, 160)}.`).catch(() => undefined);
+                await sendToPerson(`I couldn't run this one — ${runtime.id} kept failing: ${excerpt.slice(0, 160)}.`).catch(() => undefined);
                 await completeJobRun(jobId, id, { status: "failed", output: jobRunOutput(excerpt), disposition: `${runtime.id} could not be started` });
                 markReported("failed");
                 markProcessed(dir, id, now().toISOString());
@@ -1339,7 +1339,7 @@ export async function runBot(deps) {
         // reports and says this real reason, not "the bot was restarted".
         patchInflight(dir, id, { jobFailure: { reason, ...(outcome.excerpt ? { excerpt: outcome.excerpt } : {}) } });
         try {
-            await send(didNotFinishText(reason, poster.postedCount > 0));
+            await sendToPerson(didNotFinishText(reason, poster.postedCount > 0));
         }
         catch (err) {
             // Leave it un-acked with the marker: the next poll reports it.
@@ -1534,7 +1534,7 @@ export async function runBot(deps) {
         const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? ownerText :
             `[HQ DM sender: ${target.peerUid}; owner: ${config.ownerUid}; sender is not the owner.]\n\n${text}`;
         const markerTarget = target.kind === "dm" ? { kind: "dm", peerUid: target.peerUid } : { kind: "room", channelId: target.channelId };
-        const { send, sendFinal, saved } = trackingSend(markerTarget, item.rootEventId);
+        const { sendProgress, sendToPerson, saved } = trackingSend(markerTarget, item.rootEventId);
         const { outcome, poster } = await runTurnWithProgress({
             marker: {
                 messageId: id,
@@ -1545,8 +1545,8 @@ export async function runBot(deps) {
             prompt,
             sessionScope,
             tReceived,
-            send,
-            sendFinal,
+            sendProgress,
+            sendToPerson,
             silenceable: target.kind === "room" && !target.mentioned,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"
@@ -1605,7 +1605,7 @@ export async function runBot(deps) {
             attempts.delete(id);
             markSignInBroken(outcome.excerpt);
             const conversation = markerTarget.kind === "dm" ? sessionScope : `room:${markerTarget.channelId}:${item.rootEventId ?? ""}`;
-            await tellSignInNeeded(conversation, send);
+            await tellSignInNeeded(conversation, sendToPerson);
             log("warn", `kept ${id} until ${runtime.id} can sign in again`);
             return; // un-acked: answered once the sign-in works
         }
@@ -1620,7 +1620,7 @@ export async function runBot(deps) {
             }
             if (attempt >= MAX_ATTEMPTS_PER_MESSAGE) {
                 try {
-                    await send(`Sorry — I couldn't answer that one (${runtime.id} kept failing: ${excerpt.slice(0, 160)}). Try again in a bit, or check that ${runtime.id} is signed in on this computer.`);
+                    await sendToPerson(`Sorry — I couldn't answer that one (${runtime.id} kept failing: ${excerpt.slice(0, 160)}). Try again in a bit, or check that ${runtime.id} is signed in on this computer.`);
                 }
                 catch {
                     /* best-effort */
@@ -1660,7 +1660,7 @@ export async function runBot(deps) {
             // still say we did not finish — but with a plain reason, never the raw
             // internal error string.
             const reason = reasoningOnly ? "the model returned no answer" : failureReason(outcome);
-            await send(didNotFinishText(reason, poster.postedCount > 0));
+            await sendToPerson(didNotFinishText(reason, poster.postedCount > 0));
         }
         catch (err) {
             // Leave it un-acked with the marker: the next poll says it did not finish.

package/dist/lib/core-utils/sentry-report.d.ts

@@ -26,7 +26,7 @@ export declare const MAX_SENTRY_REPORT_METADATA_VALUE_BYTES = 256;
  * is owner-approved telemetry for the exact hook script and may include a
  * company directory; it is never a substitute for hook input or a transcript.
  */
-export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence", "hook_timeout_debug_context"];
+export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "slow_phase", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence", "hook_timeout_debug_context"];
 export declare const MAX_SENTRY_REPORT_METADATA_KEYS: number;
 export type HookSequenceEntry = {
     script: string;

package/dist/lib/core-utils/sentry-report.js

@@ -130,18 +130,25 @@ const DEBUG_CONTEXT_HOOK_EVENTS = new Set([
     "TaskCompleted",
     "TeammateIdle",
 ]);
-const DEBUG_CONTEXT_PHASES = new Set([
+const SAFE_SLOW_PHASES = new Set([
     "startup",
     "source",
     "config_load",
     "policy_load",
     "external_command",
     "output_write",
+    "output_scan",
+    "output_merge",
+    "output_stdout",
+    "output_abandoned_scan",
+    "output_abandoned_merge",
+    "output_abandoned_stdout",
     "wait",
     "child_wait",
     "probe",
     "parse",
 ]);
+const DEBUG_CONTEXT_PHASES = new Set(SAFE_SLOW_PHASES);
 /**
  * The only hook diagnostics that can be attached as metadata. The list omits
  * command text, prompts, payloads, company names, and repositories. `hook_path`
@@ -166,6 +173,7 @@ export const ALLOWED_SENTRY_REPORT_METADATA_KEYS = [
     "spawn_ms",
     "slow_child",
     "slow_child_ms",
+    "slow_phase",
     "exit_code",
     "final_elapsed_ms",
     "bash_env_set",
@@ -255,6 +263,11 @@ function boundedDebugName(value, known) {
 function boundedDebugPhase(value) {
     return typeof value === "string" && DEBUG_CONTEXT_PHASES.has(value) ? value : "other";
 }
+function safeSlowPhase(value) {
+    if (typeof value !== "string")
+        return "unknown";
+    return SAFE_SLOW_PHASES.has(value) ? value : "other";
+}
 function boundedDebugHookEvent(value) {
     return typeof value === "string" && DEBUG_CONTEXT_HOOK_EVENTS.has(value) ? value : "other";
 }
@@ -425,6 +438,9 @@ function parseSentryReportEvent(stdin) {
     if (typeof metadata.slow_child === "string") {
         metadata.slow_child = safeSlowChild(metadata);
     }
+    if ("slow_phase" in metadata) {
+        metadata.slow_phase = safeSlowPhase(metadata.slow_phase);
+    }
     return {
         code: 0,
         event: {
@@ -678,6 +694,7 @@ function hookTimeoutTags(event) {
         load_bucket: loadAverage === "unavailable" ? "unavailable" : loadBucket(loadAverage),
         spawn_ms_bucket: spawnMsBucket(metadata),
         slow_child: safeSlowChild(metadata),
+        slow_phase: safeSlowPhase(metadata.slow_phase),
         slow_child_ms_bucket: typeof slowChildMs === "number" && Number.isFinite(slowChildMs)
             ? elapsedBucket(slowChildMs)
             : "unknown",

package/dist/lib/daemon/command-call.d.ts

@@ -0,0 +1,9 @@
+interface DaemonCallDependencies {
+    home: string;
+    env: NodeJS.ProcessEnv;
+    out: (line: string) => void;
+}
+/** Send one CLI request after its protocol module has been preloaded. */
+export declare function runDaemonCall(op: string, args: Record<string, unknown>, timeoutMs: number, deps: DaemonCallDependencies): Promise<void>;
+export {};
+//# sourceMappingURL=command-call.d.ts.map

package/dist/lib/daemon/command-call.js

@@ -0,0 +1,18 @@
+/** Send one CLI request after its protocol module has been preloaded. */
+export async function runDaemonCall(op, args, timeoutMs, deps) {
+    const { hqdRequest, hqdSocketPath, HqdClientError } = await import("./protocol.js");
+    try {
+        const result = await hqdRequest(op, args, {
+            socketPath: hqdSocketPath(deps.home, deps.env),
+            timeoutMs,
+        });
+        deps.out(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        if (!(error instanceof HqdClientError))
+            throw error;
+        deps.out(JSON.stringify({ error: { code: error.code, message: error.message } }, null, 2));
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=command-call.js.map

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -146,6 +146,7 @@ export declare function dispatchOutpostPickup(port: OutpostExecPort, input: {
     command: string;
     timeoutSeconds?: number;
     waitMs?: number;
+    beforeWait?: () => Promise<void>;
 }): Promise<OutpostDispatchResult>;
 export declare function dispatchErrorMessage(err: unknown): string;
 /** Factory matching `hq outposts exec`'s client wiring. */

package/dist/lib/lanes/outpost-dispatch.js

@@ -252,6 +252,7 @@ export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
 }
 export async function dispatchOutpostPickup(port, input) {
     const submitted = await port.submitExec(input.command, input.outpostId, input.timeoutSeconds ?? PICKUP_EXEC_TIMEOUT_SECONDS);
+    await input.beforeWait?.();
     const ac = new AbortController();
     const waitMs = input.waitMs ?? PICKUP_WAIT_MS;
     const timer = setTimeout(() => ac.abort(), waitMs);

package/dist/utils/cli-telemetry.js

@@ -186,7 +186,11 @@ export async function emitCliFeatureUsed(usage, timeoutMs = TELEMETRY_TIMEOUT_MS
                             consentBasis,
                             schemaVersion: 1,
                             ...(companyUid ? { companyUid } : {}),
-                            properties: { kind: usage.kind, outcome: usage.outcome },
+                            properties: {
+                                kind: usage.kind,
+                                outcome: usage.outcome,
+                                version: CLI_VERSION.slice(0, 40),
+                            },
                         },
                     ],
                 },

package/dist/utils/install-tree-torn.d.ts

@@ -278,7 +278,8 @@ type VersionGatePhase = "preflight" | "lock_acquired" | "installer_running" | "v
 /**
  * Poll until the install tree has been continuously READY for `quietMs`, or the
  * wait exhausts its bounds. READY means: (i) no FRESH update lock held by another
- * pid, (ii) the missing target is present, and — when `packageRoot` is known —
+ * pid and no live recorded updater while the tree is in flight, (ii) the missing
+ * target is present, and — when `packageRoot` is known —
  * (iii) `<packageRoot>/package.json` parses with `name === CLI_NAME` and (iv) no
  * `.<leaf>-<rand>` retired sibling remains beside it. Every filesystem error makes
  * its condition "not ready" rather than throwing.
@@ -295,20 +296,22 @@ type VersionGatePhase = "preflight" | "lock_acquired" | "installer_running" | "v
  *     any installer before attempting a repair. Any observed signature change
  *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
  *     readiness once.
- *   - LOCKED time — wall time observed under a fresh foreign lock held by a live
- *     pid — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
- *     10-minute staleness window) and does NOT consume the settle budget. When
- *     that ceiling is reached with the lock still held, the result is unsettled
- *     with `lockHeldAtEnd` true so the seam can report a distinct `lock-held`
- *     outcome and remedy rather than telling the user to reinstall over a live
- *     writer.
- * Each poll's REAL elapsed interval (now() deltas) is attributed to the locked or
- * unlocked bucket by whether a fresh foreign lock was held when the interval
- * began, so a starved event loop only makes the wait coarser, never unbounded. A
+ *   - WRITER time — wall time observed under a fresh foreign lock, or while a
+ *     recorded foreign updater pid is alive and the tree has an in-flight signal
+ *     — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
+ *     10-minute staleness window) and does NOT consume the settle budget. This
+ *     also covers a still-running updater whose lock became stale by age. When
+ *     that ceiling is reached, the result is unsettled; `lockHeldAtEnd` remains
+ *     reserved for a fresh lock held at the end.
+ * Each poll's REAL elapsed interval (now() deltas) is attributed to the writer or
+ * unlocked bucket by whether a fresh lock or qualifying live updater was observed
+ * when the interval began, so a starved event loop only makes the wait coarser,
+ * never unbounded. A
  * stale lock (dead pid, older than the staleness window, unparseable) or our own
- * pid never extends anything. The whole wait is bounded (≤ `deadlineMs +
+ * pid never extends anything by itself. The whole wait is bounded (≤ `deadlineMs +
  * lockWaitMs`), and the unchanged-tree path normally returns after the much
- * shorter `staleProbeMs` observation window.
+ * shorter `staleProbeMs` observation window unless a live updater pid is still
+ * present with an in-flight tree signal.
  */
 export declare function waitForInstallTreeSettled(args: WaitForInstallTreeSettledArgs): Promise<WaitForInstallTreeSettledResult>;
 export interface InstallRewriteSignalArgs {

package/dist/utils/install-tree-torn.js

@@ -714,6 +714,28 @@ function updaterPidAlive(lockPath, fs, isPidAlive) {
         return "unknown";
     }
 }
+/** Whether the lock names a live process other than this CLI invocation. */
+function liveForeignUpdaterPid(lockPath, fs, isPidAlive) {
+    try {
+        const lock = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
+        if (typeof lock.startedAt !== "string" ||
+            Number.isNaN(Date.parse(lock.startedAt)) ||
+            typeof lock.tool !== "string" ||
+            lock.tool.length === 0 ||
+            typeof lock.version !== "string" ||
+            lock.version.length === 0) {
+            return false;
+        }
+        return typeof lock.pid === "number" &&
+            Number.isSafeInteger(lock.pid) &&
+            lock.pid > 0 &&
+            lock.pid !== process.pid &&
+            isPidAlive(lock.pid);
+    }
+    catch {
+        return false;
+    }
+}
 /** Snapshot retired sibling trees so changes below their root stay observable. */
 function retiredSiblingActivitySignature(packageRoot, fs) {
     const { leaf } = cliNameParts();
@@ -917,7 +939,8 @@ const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1_500;
 /**
  * Poll until the install tree has been continuously READY for `quietMs`, or the
  * wait exhausts its bounds. READY means: (i) no FRESH update lock held by another
- * pid, (ii) the missing target is present, and — when `packageRoot` is known —
+ * pid and no live recorded updater while the tree is in flight, (ii) the missing
+ * target is present, and — when `packageRoot` is known —
  * (iii) `<packageRoot>/package.json` parses with `name === CLI_NAME` and (iv) no
  * `.<leaf>-<rand>` retired sibling remains beside it. Every filesystem error makes
  * its condition "not ready" rather than throwing.
@@ -934,20 +957,22 @@ const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1_500;
  *     any installer before attempting a repair. Any observed signature change
  *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
  *     readiness once.
- *   - LOCKED time — wall time observed under a fresh foreign lock held by a live
- *     pid — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
- *     10-minute staleness window) and does NOT consume the settle budget. When
- *     that ceiling is reached with the lock still held, the result is unsettled
- *     with `lockHeldAtEnd` true so the seam can report a distinct `lock-held`
- *     outcome and remedy rather than telling the user to reinstall over a live
- *     writer.
- * Each poll's REAL elapsed interval (now() deltas) is attributed to the locked or
- * unlocked bucket by whether a fresh foreign lock was held when the interval
- * began, so a starved event loop only makes the wait coarser, never unbounded. A
+ *   - WRITER time — wall time observed under a fresh foreign lock, or while a
+ *     recorded foreign updater pid is alive and the tree has an in-flight signal
+ *     — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
+ *     10-minute staleness window) and does NOT consume the settle budget. This
+ *     also covers a still-running updater whose lock became stale by age. When
+ *     that ceiling is reached, the result is unsettled; `lockHeldAtEnd` remains
+ *     reserved for a fresh lock held at the end.
+ * Each poll's REAL elapsed interval (now() deltas) is attributed to the writer or
+ * unlocked bucket by whether a fresh lock or qualifying live updater was observed
+ * when the interval began, so a starved event loop only makes the wait coarser,
+ * never unbounded. A
  * stale lock (dead pid, older than the staleness window, unparseable) or our own
- * pid never extends anything. The whole wait is bounded (≤ `deadlineMs +
+ * pid never extends anything by itself. The whole wait is bounded (≤ `deadlineMs +
  * lockWaitMs`), and the unchanged-tree path normally returns after the much
- * shorter `staleProbeMs` observation window.
+ * shorter `staleProbeMs` observation window unless a live updater pid is still
+ * present with an in-flight tree signal.
  */
 export async function waitForInstallTreeSettled(args) {
     const now = args.now ?? Date.now;
@@ -967,17 +992,21 @@ export async function waitForInstallTreeSettled(args) {
     let sawLock = false;
     let sawRetired = false;
     let lockedMs = 0;
+    let writerMs = 0;
     let unlockedMs = 0;
     let lockTool = "";
     let prevT = start;
     let prevForeignLockHeld = false;
+    let prevWriterHeld = false;
     let lockExtendedFired = false;
     for (;;) {
         const t = now();
-        // Attribute the interval that just elapsed [prevT, t) to the bucket for the
-        // lock state that held when it BEGAN (real now() deltas, never nominal pollMs).
+        // Attribute the interval that just elapsed [prevT, t) using the state that
+        // held when it BEGAN (real now() deltas, never nominal pollMs).
         if (prevForeignLockHeld)
             lockedMs += t - prevT;
+        if (prevWriterHeld)
+            writerMs += t - prevT;
         else
             unlockedMs += t - prevT;
         const lock = freshForeignLock(args.lockPath, t, isPidAlive, fs);
@@ -1015,7 +1044,10 @@ export async function waitForInstallTreeSettled(args) {
                 retiredCheckFailed = true;
             }
         }
-        let ready = !foreignLockHeld && installTargetPresent(args.target, fs);
+        const inFlightTree = sawLock || sawRetired || sawTreeChange;
+        const updaterPidHeld = inFlightTree && liveForeignUpdaterPid(args.lockPath, fs, isPidAlive);
+        const writerHeld = foreignLockHeld || updaterPidHeld;
+        let ready = !writerHeld && installTargetPresent(args.target, fs);
         if (ready && args.packageRoot) {
             try {
                 if (!packageRootHealthy(args.packageRoot, fs))
@@ -1055,6 +1087,7 @@ export async function waitForInstallTreeSettled(args) {
         }
         if (!ready &&
             !foreignLockHeld &&
+            !updaterPidHeld &&
             !retiredCheckFailed &&
             !sawLock &&
             !sawTreeChange &&
@@ -1078,14 +1111,13 @@ export async function waitForInstallTreeSettled(args) {
             };
         }
         // Give up when the TREE has had a full unlocked budget with no writer visible,
-        // OR a writer is STILL holding the lock and has held it past its own staleness
-        // ceiling. The lock ceiling is gated on a lock being held RIGHT NOW so that a
-        // ceiling of 0 (HQ_INSTALL_SETTLE_LOCK_TIMEOUT_MS=0, "do not extend under a
-        // lock") disables only the extension and does not collapse the ordinary
-        // deadlineMs settle when no lock exists — `lockedMs` is 0 ≥ 0 on every poll.
+        // OR a qualifying writer has exceeded the shared writer ceiling. The writer
+        // ceiling only extends while a fresh lock or in-flight live PID is present, so
+        // a ceiling of 0 disables only that extension and does not collapse the normal
+        // deadlineMs settle when no writer exists.
         // `deadlineMs` 0 makes the unlocked test fire on the first poll (evaluate-once),
         // matching the pre-lock-aware contract; `lockHeldAtEnd` distinguishes the causes.
-        if (unlockedMs >= deadlineMs || (foreignLockHeld && lockedMs >= lockWaitMs)) {
+        if (unlockedMs >= deadlineMs || (writerHeld && writerMs >= lockWaitMs)) {
             return {
                 settled: false,
                 waitedMs,
@@ -1102,15 +1134,15 @@ export async function waitForInstallTreeSettled(args) {
                 updaterPidAlive: updaterPidAlive(args.lockPath, fs, isPidAlive),
             };
         }
-        // The first poll at which the wait has reached `deadlineMs` while a lock is
-        // still held is exactly where the pre-lock-aware wait gave up — announce the
-        // extension once, and only when we are genuinely going to keep waiting.
-        if (!lockExtendedFired && foreignLockHeld && waitedMs >= deadlineMs) {
+        // Announce once when the deadline has passed and a qualifying writer is why
+        // the bounded wait continues.
+        if (!lockExtendedFired && writerHeld && waitedMs >= deadlineMs) {
             lockExtendedFired = true;
             args.onLockExtended?.();
         }
         prevT = t;
         prevForeignLockHeld = foreignLockHeld;
+        prevWriterHeld = writerHeld;
         await sleep(pollMs);
     }
 }

package/dist/utils/resident-package-preload.d.ts

@@ -1,4 +1,4 @@
-export type ResidentPackagePath = "agent-kit" | "agent-mcp" | "auth-login" | "agents-terminal" | "bot" | "bot-logs-follow" | "childWrapper" | "coreJobRun" | "login" | "mcp" | "daemon" | "daemon-logs-follow" | "mesh-daemon" | "lanes-watch" | "monitor-wait" | "monitor-run" | "agents-message-wait" | "integrations-oauth-wait" | "secrets-sandbox" | "pkg-update" | "pack-install";
+export type ResidentPackagePath = "agent-kit" | "agent-mcp" | "auth-login" | "agents-terminal" | "bot" | "bot-logs-follow" | "childWrapper" | "coreJobRun" | "daemon-call" | "login" | "mcp" | "daemon" | "daemon-logs-follow" | "mesh-daemon" | "lanes-watch" | "monitor-wait" | "monitor-run" | "agents-message-wait" | "integrations-oauth-wait" | "outpost-wait" | "secrets-sandbox" | "pkg-update" | "pack-install";
 /** Runtime modules that resident commands may need after a wait starts. */
 export declare const RESIDENT_PACKAGE_MODULES: Record<ResidentPackagePath, readonly string[]>;
 export declare class ResidentPackagePreloadError extends Error {

package/dist/utils/resident-package-preload.js

@@ -43,6 +43,7 @@ export const RESIDENT_PACKAGE_MODULES = {
     mcp: ["../lib/mcp/tools.js", "../lib/mcp/prompts.js"],
     childWrapper: ["../main.js"],
     coreJobRun: ["../lib/flag-registry.js"],
+    "daemon-call": ["../lib/daemon/protocol.js"],
     daemon: [
         "../sentry.js",
         "../utils/cognito-session.js",
@@ -63,6 +64,7 @@ export const RESIDENT_PACKAGE_MODULES = {
     "monitor-run": ["../commands/lanes.js", "../lib/plan-limit-nag.js", "../utils/plan-gate-error.js", "../sentry.js", "open", "../utils/cognito-session.js", "../lib/first-sync-next-step.js", "@indigoai-us/hq-cloud"],
     "agents-message-wait": ["../sentry.js", "../lib/plan-limit-nag.js", "../utils/plan-gate-error.js", "open", "../utils/cognito-session.js", "../lib/first-sync-next-step.js", "@indigoai-us/hq-cloud"],
     "integrations-oauth-wait": ["../sentry.js", "../lib/plan-limit-nag.js", "../utils/plan-gate-error.js", "open", "../utils/cognito-session.js", "../lib/first-sync-next-step.js", "@indigoai-us/hq-cloud"],
+    "outpost-wait": ["../commands/lanes.js", "../lib/plan-limit-nag.js", "../utils/plan-gate-error.js", "../sentry.js", "open", "../utils/cognito-session.js", "../lib/first-sync-next-step.js", "@indigoai-us/hq-cloud"],
     "secrets-sandbox": [],
     "pkg-update": ["../sentry.js", "../utils/cognito-session.js", "@indigoai-us/hq-cloud"],
     "pack-install": [
@@ -175,6 +177,9 @@ const LOADERS = {
     coreJobRun: [
         () => import("../lib/flag-registry.js"),
     ],
+    "daemon-call": [
+        () => import("../lib/daemon/protocol.js"),
+    ],
     daemon: [
         async () => {
             const { preloadSentrySdk } = await import("../sentry.js");
@@ -265,6 +270,19 @@ const LOADERS = {
         () => import("../lib/first-sync-next-step.js"),
         () => import("@indigoai-us/hq-cloud"),
     ],
+    "outpost-wait": [
+        () => import("../commands/lanes.js"),
+        () => import("../lib/plan-limit-nag.js"),
+        () => import("../utils/plan-gate-error.js"),
+        async () => {
+            const { preloadSentrySdk } = await import("../sentry.js");
+            preloadSentrySdk();
+        },
+        () => import("open"),
+        () => import("../utils/cognito-session.js"),
+        () => import("../lib/first-sync-next-step.js"),
+        () => import("@indigoai-us/hq-cloud"),
+    ],
     "secrets-sandbox": [],
     "pkg-update": [
         async () => {

package/package.json

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