@indigoai-us/hq-cli 5.342.18 → 5.343.1

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/doctor/checks/work-context.js

@@ -13,6 +13,7 @@ import { workContextRoot, workContextSessionsDir } from "../../work-context/path
 import { countDistinctHeldEvents, countJsonlLines, deadLetterNonEmpty, } from "../../mesh/live/spool.js";
 import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../../mesh/live/paths.js";
 import { collectDaemonDoctor, formatDaemonDoctor, } from "../../mesh/live/daemon/doctor.js";
+import { workSessionDenialReason } from "../../mesh/denial-codes.js";
 export const WORK_CONTEXT_FAMILY_ID = "work-context";
 export const WORK_CONTEXT_FAMILY_TITLE = "Work context";
 const DEFAULT_DEPS = {
@@ -97,6 +98,9 @@ function runChecks(deps) {
     ]
         .filter(Boolean)
         .join(" ");
+    const quarantineDenialReason = showQuarantineReason
+        ? workSessionDenialReason(stats.lastQuarantineServerCode)
+        : undefined;
     results.push({
         status: stats.quarantined > 0 ? "WARN" : "PASS",
         checkId: "work-context.outbox-quarantined",
@@ -104,6 +108,7 @@ function runChecks(deps) {
         message: `Outbox quarantined count=${stats.quarantined}${showQuarantineReason
             ? ` (last reason=${stats.lastQuarantineReason ?? "unknown"}${quarantineDetails ? `; ${quarantineDetails}` : ""})`
             : ""}.`,
+        ...(quarantineDenialReason ? { remediation: quarantineDenialReason } : {}),
     });
     // Default-company mode + migration capability (US-017B)
     try {

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/lib/mesh/client.js

@@ -79,6 +79,17 @@ export function createWorkSessionDeliverer(opts) {
                 if (status === 429 || (status >= 500 && status <= 599)) {
                     return { ok: false, retryable: true, code: `HTTP_${status}` };
                 }
+                if (status === 404 && isWorkSessionDenialCode(errorFields.code)) {
+                    // Keep the allowlisted code (FEATURE_DISABLED) so the refusal can be
+                    // explained and picked up by the default requeue filter.
+                    return {
+                        ok: false,
+                        retryable: false,
+                        code: "HTTP_404",
+                        httpStatus: 404,
+                        serverCode: errorFields.code,
+                    };
+                }
                 if (status === 404 ||
                     status === 409 ||
                     status === 410 ||

package/dist/lib/mesh/denial-codes.d.ts

@@ -1,5 +1,16 @@
-/** Explicit 401/403 codes returned by hq-pro's work-session registration path. */
-export declare const WORK_SESSION_DENIAL_CODES: readonly ["AUTH_REQUIRED", "AGENT_IDENTITY_UNVERIFIED", "IMPERSONATION_FORBIDDEN", "NO_PERSON_ENTITY", "INVALID_COMPANY", "WORK_REGISTRY_DISABLED"];
+/**
+ * Explicit refusal codes returned by hq-pro's work-session registration path:
+ * the 401/403 denials, plus the 404 FEATURE_DISABLED answer given while the
+ * company's Work Mesh Live setting is off.
+ */
+export declare const WORK_SESSION_DENIAL_CODES: readonly ["AUTH_REQUIRED", "AGENT_IDENTITY_UNVERIFIED", "IMPERSONATION_FORBIDDEN", "NO_PERSON_ENTITY", "INVALID_COMPANY", "WORK_REGISTRY_DISABLED", "FEATURE_DISABLED"];
+/**
+ * Refusals that end once the company owner turns a setting on. The default
+ * `hq mesh context requeue` filter re-sends operations stored with these.
+ */
+export declare const WORK_TRACKING_OFF_DENIAL_CODES: readonly WorkSessionDenialCode[];
 export type WorkSessionDenialCode = (typeof WORK_SESSION_DENIAL_CODES)[number];
 export declare function isWorkSessionDenialCode(value: unknown): value is WorkSessionDenialCode;
+/** Plain reason for a server denial code, or undefined when there is none. */
+export declare function workSessionDenialReason(value: unknown): string | undefined;
 //# sourceMappingURL=denial-codes.d.ts.map

package/dist/lib/mesh/denial-codes.js

@@ -1,4 +1,8 @@
-/** Explicit 401/403 codes returned by hq-pro's work-session registration path. */
+/**
+ * Explicit refusal codes returned by hq-pro's work-session registration path:
+ * the 401/403 denials, plus the 404 FEATURE_DISABLED answer given while the
+ * company's Work Mesh Live setting is off.
+ */
 export const WORK_SESSION_DENIAL_CODES = [
     "AUTH_REQUIRED",
     "AGENT_IDENTITY_UNVERIFIED",
@@ -6,9 +10,29 @@ export const WORK_SESSION_DENIAL_CODES = [
     "NO_PERSON_ENTITY",
     "INVALID_COMPANY",
     "WORK_REGISTRY_DISABLED",
+    "FEATURE_DISABLED",
+];
+/**
+ * Refusals that end once the company owner turns a setting on. The default
+ * `hq mesh context requeue` filter re-sends operations stored with these.
+ */
+export const WORK_TRACKING_OFF_DENIAL_CODES = [
+    "WORK_REGISTRY_DISABLED",
+    "FEATURE_DISABLED",
 ];
 export function isWorkSessionDenialCode(value) {
     return typeof value === "string" &&
         WORK_SESSION_DENIAL_CODES.includes(value);
 }
+/** Plain-language reasons for denial codes the user can act on. */
+const WORK_SESSION_DENIAL_REASONS = {
+    WORK_REGISTRY_DISABLED: "Work tracking is turned off for this company. The company owner can turn it on with: hq company --company <slug> settings set --work-registry-enabled true",
+    FEATURE_DISABLED: "Live work tracking is turned off for this company. The company owner can turn it on with: hq company --company <slug> settings set --work-mesh-live-enabled true",
+};
+/** Plain reason for a server denial code, or undefined when there is none. */
+export function workSessionDenialReason(value) {
+    return isWorkSessionDenialCode(value)
+        ? WORK_SESSION_DENIAL_REASONS[value]
+        : undefined;
+}
 //# sourceMappingURL=denial-codes.js.map

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

@@ -23,6 +23,7 @@ import { readDaemonState } from "./state.js";
 import { CLI_VERSION } from "../../../../cli-version.js";
 import { resolveRunningCliEntry } from "./install.js";
 import { readInstalledCliVersion } from "./version-drift.js";
+import { workSessionDenialReason } from "../../denial-codes.js";
 import { LEGACY_LISTENER_DOCTOR_LINE, legacyListenInstalled, } from "./legacy-listen.js";
 export const UNHEALTHY_SPOOL_AGE_MS = 60_000;
 function oldestJsonlAgeMs(filePath, nowMs) {
@@ -321,6 +322,9 @@ export function formatDaemonDoctor(report) {
             .filter(Boolean)
             .join(" ");
         lines.push(`outbox quarantined: ${report.outboxQuarantined} (last reason=${report.outboxLastQuarantineReason ?? "unknown"}${quarantineDetails ? `; ${quarantineDetails}` : ""})`);
+        const denialReason = workSessionDenialReason(report.outboxLastQuarantineServerCode);
+        if (denialReason)
+            lines.push(denialReason);
     }
     if (report.emitMode !== "legacy" && report.heldCount > 0) {
         lines.push(`held: ${report.heldCount} (needs_company; not sent as NONE)`);

package/dist/lib/work-context/outbox.js

@@ -8,7 +8,7 @@ import * as path from "node:path";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 import { atomicWriteJson, ensureOwnerDir } from "./atomic.js";
 import { NotTrackingError } from "./errors.js";
-import { isWorkSessionDenialCode } from "../mesh/denial-codes.js";
+import { isWorkSessionDenialCode, WORK_TRACKING_OFF_DENIAL_CODES, } from "../mesh/denial-codes.js";
 import { readSessionState, stripRegisterReceiptEpisodes, updateSessionState, writeAcknowledgedRegisterBinding, } from "./state.js";
 import { isSafeWorkContextSegment, workContextOutboxDir, workContextOutboxPath, } from "./paths.js";
 /** Base delay for outbox retry backoff (attempt 1 → 30s). */
@@ -390,8 +390,14 @@ export function requeueQuarantinedOutbox(root, opts = {}) {
     for (const op of listOutboxOperations(root)) {
         if (op.delivery !== "quarantined")
             continue;
-        if (errorCode !== null && op.lastErrorCode !== errorCode)
+        // Default filter: AUTH_DENIED, plus refusals stored with a server code
+        // that means work tracking was off for the company (a 404 FEATURE_DISABLED
+        // is stored as HTTP_404). An explicit errorCode matches lastErrorCode only.
+        const workTrackingWasOff = opts.errorCode === undefined &&
+            WORK_TRACKING_OFF_DENIAL_CODES.includes(op.lastServerErrorCode ?? "");
+        if (errorCode !== null && op.lastErrorCode !== errorCode && !workTrackingWasOff) {
             continue;
+        }
         op.delivery = "queued";
         op.attemptCount = 0;
         op.lastErrorCode = undefined;

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 {