@indigoai-us/hq-cli 5.183.0 → 5.185.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [5.185.0] — 2026-09-25
+
+### Fixed
+
+- Local bots no longer post their no-reply signal, narration, blank messages, or raw model errors into rooms. On a room message that does not mention the bot, in-between messages and the working notice are held until the turn ends, and nothing is posted when the reply is the `{"action":"no_reply"}` signal or empty. Any model failure on such a turn (not only a Grok `reasoning_only` empty response, but every model error) is now silent instead of leaking "I didn't finish that — <model> stopped with an error: <raw excerpt>" into the room. When the turn does produce content, the held in-between messages are posted alongside the final answer, so a bot that answers mid-turn and ends with a short sign-off (claude/codex) no longer loses the answer; a Grok final that just concatenates the in-between messages still posts once with no duplication. The signal is never posted as progress anywhere. DMs and @-mentions still stream and still get a reply; a `reasoning_only` failure there now says "the model returned no answer" instead of the raw internal error, and other failures there keep the existing "did not finish" message. The room prompt also tells the model to produce no output rather than explain that it is staying silent.
+
+## [5.184.0] — 2026-09-25
+
+### Fixed
+
+- Work Mesh transcript-watch now emits `session_end` for hook-covered sessions that have already been quiet for 10 minutes when first seen (the live skip path that left `skippedHook=411 ended=0`). Held/spool rescans stamp last hook activity from each event's `at`, not the scan clock, so leftover `held.jsonl` lines cannot reset the quiet timer.
+- Quiet `session_end` (and SessionEnd flush) send an optional one-sentence summary of the last assistant reply (~140 chars, tokens and secrets-file paths redacted), plus git repo, branch, and PR URLs when cheap.
+
+### Added
+
+- `hq doctor --json` includes stable sync `reasonCode` enums. Client-health reports add `checkId: reasonCode` pairs only when the company-scoped `client-health-sync-reason-codes` hq-flags gate is enabled. `hq doctor --fix --json` reports refresh-sync outcomes without raw error details.
+
+- Repair known stale QMD collection paths behind the default-off `qmd.collection-path-repair` hq-flags canary while preserving collection metadata.
+
 ## [5.183.0] — 2026-09-25
 
 ### Added

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

@@ -5495,6 +5495,9 @@ export declare const COMMAND_CATALOG: readonly [{
     }, {
         readonly flags: "--fix";
         readonly description: "Apply the allowlisted safe repairs (backs up first; read-only without this flag).";
+    }, {
+        readonly flags: "--client-health-report";
+        readonly description: "Resolve the opt-in hq-flags gate used by the client-health report hook.";
     }, {
         readonly flags: "--yes";
         readonly description: "Skip the interactive --fix confirmation (non-interactive use).";

package/dist/command-catalog.generated.js

@@ -7089,6 +7089,10 @@ export const COMMAND_CATALOG = [
                 "flags": "--fix",
                 "description": "Apply the allowlisted safe repairs (backs up first; read-only without this flag)."
             },
+            {
+                "flags": "--client-health-report",
+                "description": "Resolve the opt-in hq-flags gate used by the client-health report hook."
+            },
             {
                 "flags": "--yes",
                 "description": "Skip the interactive --fix confirmation (non-interactive use)."

package/dist/commands/doctor.d.ts

@@ -55,6 +55,8 @@ export interface RunDoctorOptions {
     stderr?: (chunk: string) => void;
     /** Emit the machine-readable JSON document instead of text. Default: false. */
     json?: boolean;
+    /** Resolve hq-flags independently for each company represented in sync results. */
+    resolveClientHealthReasonCodesForCompany?: (companySlug: string | null) => Promise<boolean>;
     /** In text mode, also print every PASS result. Default: false. */
     verbose?: boolean;
     /** In text mode, emit ANSI colour. Default: false (no escape sequences). */

package/dist/commands/doctor.js

@@ -23,6 +23,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { Option } from "commander";
 import { createDefaultRegistry, } from "../lib/doctor/registry.js";
 import { computeExitCode, renderText, UNKNOWN_PLATFORM, } from "../lib/doctor/report.js";
 import { buildDoctorJson, renderJson } from "../lib/doctor/json-output.js";
@@ -30,6 +31,10 @@ import { detectPlatform } from "../lib/doctor/platform.js";
 import { DEEP_FAMILY_ID, DEEP_FAMILY_TITLE, runDeepGuardTests, } from "../lib/doctor/deep/executor.js";
 import { PARITY_FAMILY_ID, PARITY_FAMILY_TITLE, runParityReplay, } from "../lib/doctor/deep/parity.js";
 import { applyFixes } from "../lib/doctor/fix/apply.js";
+import { renderDoctorFixJson } from "../lib/doctor/fix/json-output.js";
+import { clientHealthReasonCodesEnabled as isActiveCompanyClientHealthReasonCodesEnabled, clientHealthReasonCodesEnabledForCompany, } from "../lib/doctor/client-health-reason-codes-flag.js";
+import { isCompanyJournalSlug } from "../lib/doctor/checks/sync-health.js";
+import { readCompaniesManifestMap } from "../lib/work-context/repo-remote.js";
 import * as readline from "node:readline";
 import { runSideEffectTests } from "../lib/doctor/deep/sandbox.js";
 /**
@@ -157,7 +162,16 @@ export async function runDoctor(options = {}) {
         });
     }
     if (options.json) {
-        write(renderJson(buildDoctorJson({ hqRoot, families, platform, scope })));
+        const clientHealthReasonCodesEnabledCheckIds = options.resolveClientHealthReasonCodesForCompany
+            ? await resolveClientHealthReasonCodesCheckIds(families, options.resolveClientHealthReasonCodesForCompany)
+            : undefined;
+        write(renderJson(buildDoctorJson({
+            hqRoot,
+            families,
+            platform,
+            scope,
+            clientHealthReasonCodesEnabledCheckIds,
+        })));
     }
     else {
         write(renderText({
@@ -172,6 +186,61 @@ export async function runDoctor(options = {}) {
     // UNTESTED, NA, and KNOWN-DEFECT are reported but never fail the command.
     return { exitCode: computeExitCode(families), hqRoot, families };
 }
+async function resolveClientHealthReasonCodesCheckIds(families, resolveForCompany) {
+    const checksByCompany = new Map();
+    for (const run of families) {
+        if (run.family.id !== "sync")
+            continue;
+        for (const result of run.results) {
+            if (result.reasonCode === undefined ||
+                (result.status !== "FAIL" && result.status !== "WARN")) {
+                continue;
+            }
+            const scoped = /^sync\.(?:journal|manifest)\.(.+)$/.exec(result.checkId);
+            const companySlug = scoped && isCompanyJournalSlug(scoped[1]) ? scoped[1] : null;
+            const checkIds = checksByCompany.get(companySlug) ?? [];
+            checkIds.push(result.checkId);
+            checksByCompany.set(companySlug, checkIds);
+        }
+    }
+    const enabledChecks = new Set();
+    const decisions = await Promise.all([...checksByCompany.entries()].map(async ([companySlug, checkIds]) => ({
+        checkIds,
+        enabled: await resolveForCompany(companySlug),
+    })));
+    for (const decision of decisions) {
+        if (decision.enabled) {
+            for (const checkId of decision.checkIds)
+                enabledChecks.add(checkId);
+        }
+    }
+    return enabledChecks;
+}
+function createClientHealthReasonCodeCompanyResolver(hqRoot) {
+    const companies = readCompaniesManifestMap(hqRoot);
+    return async (companySlug) => {
+        if (companySlug === null) {
+            return isActiveCompanyClientHealthReasonCodesEnabled();
+        }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(companySlug)) {
+            return false;
+        }
+        const manifestUid = companies?.[companySlug]?.cloud_uid;
+        const activeSlug = process.env.HQ_COMPANY_SLUG?.trim() || "";
+        const activeUid = process.env.HQ_COMPANY_UID?.trim() || "";
+        const companyUid = typeof manifestUid === "string" && manifestUid.trim()
+            ? manifestUid.trim()
+            : companySlug === activeSlug
+                ? activeUid
+                : "";
+        if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid))
+            return false;
+        return clientHealthReasonCodesEnabledForCompany({
+            companyUid,
+            companySlug,
+        });
+    };
+}
 /** Register the top-level `hq doctor` command so it appears in `hq --help`. */
 export function registerDoctorCommand(program) {
     program
@@ -186,6 +255,7 @@ export function registerDoctorCommand(program) {
         .option("--company <slug>", "Company slug for integrations checks (otherwise resolves your single active company).")
         .option("--only <families>", "Run only these comma-separated check families (e.g. hooks). Unknown names are rejected; --json then records the scope.")
         .option("--fix", "Apply the allowlisted safe repairs (backs up first; read-only without this flag).")
+        .addOption(new Option("--client-health-report", "Resolve the opt-in hq-flags gate used by the client-health report hook.").hideHelp())
         .option("--yes", "Skip the interactive --fix confirmation (non-interactive use).")
         .option("--force", "Let --fix run despite uncommitted changes under .claude/, .codex/, or .grok/.")
         .action(async (opts) => {
@@ -208,8 +278,17 @@ export function registerDoctorCommand(program) {
         if (opts.fix === true) {
             const hqRoot = resolveHqRoot();
             if (!hqRoot) {
-                process.stderr.write(`hq doctor --fix: not inside an HQ tree.\n` +
-                    `  Looking for a directory containing all of: ${HQ_ROOT_MARKERS.join(", ")}\n`);
+                if (opts.json === true) {
+                    process.stdout.write(renderDoctorFixJson({
+                        exitCode: 1,
+                        refused: "outside-hq-tree",
+                        applied: [],
+                    }));
+                }
+                else {
+                    process.stderr.write(`hq doctor --fix: not inside an HQ tree.\n` +
+                        `  Looking for a directory containing all of: ${HQ_ROOT_MARKERS.join(", ")}\n`);
+                }
                 process.exitCode = 1;
                 return;
             }
@@ -217,8 +296,14 @@ export function registerDoctorCommand(program) {
                 hqRoot,
                 yes: opts.yes === true,
                 force: opts.force === true,
-                confirm: promptYesNo,
+                confirm: () => promptYesNo(opts.json === true ? process.stderr : process.stdout),
+                ...(opts.json === true
+                    ? { stdout: () => { }, stderr: () => { } }
+                    : {}),
             });
+            if (opts.json === true) {
+                process.stdout.write(renderDoctorFixJson(fixResult));
+            }
             process.exitCode = fixResult.exitCode;
             return;
         }
@@ -237,6 +322,14 @@ export function registerDoctorCommand(program) {
             id: detection.platform,
             evidence: detection.evidence,
         };
+        const clientHealthReasonCodesResolver = json && opts.clientHealthReport === true
+            ? (() => {
+                const hqRoot = resolveHqRoot();
+                return hqRoot
+                    ? createClientHealthReasonCodeCompanyResolver(hqRoot)
+                    : undefined;
+            })()
+            : undefined;
         const result = await runDoctor({
             json,
             verbose: opts.verbose === true,
@@ -247,6 +340,7 @@ export function registerDoctorCommand(program) {
             liveRuntimes: opts.liveRuntimes === true,
             company: opts.company,
             only: parseOnly(opts.only),
+            resolveClientHealthReasonCodesForCompany: clientHealthReasonCodesResolver,
         });
         // Set the exit code rather than calling process.exit, so the CLI's
         // normal shutdown (telemetry flush) still runs. Non-zero means either an
@@ -272,12 +366,12 @@ function parseOnly(value) {
  * (so a piped run without `--yes` writes nothing) and on anything other than an
  * explicit yes.
  */
-function promptYesNo() {
+function promptYesNo(output = process.stdout) {
     if (!process.stdin.isTTY)
         return Promise.resolve(false);
     const rl = readline.createInterface({
         input: process.stdin,
-        output: process.stdout,
+        output,
     });
     return new Promise((resolve) => {
         rl.question("Apply these repairs? [y/N] ", (answer) => {

package/dist/commands/mesh.js

@@ -29,6 +29,7 @@ const MEMBERSHIP_VALIDATION_TIMEOUT_MS = 5_000;
 import { buildEmitEvidence, machineEmitDisposition } from "../lib/mesh/live/emit-evidence.js";
 import { appendHeldLine } from "../lib/mesh/live/spool.js";
 import { createEmitPoster, buildMeshEmitEvent } from "../lib/mesh/live/emit-client.js";
+import { enrichSessionEndEvent } from "../lib/mesh/live/report-summary.js";
 import { emitEvents, formatEmitRejectionLines } from "../lib/mesh/live/emit.js";
 import { readEmitRetry, writeEmitRetry } from "../lib/mesh/live/emit-retry.js";
 import { generateUlid } from "../lib/mesh/live/ulid.js";
@@ -1533,6 +1534,14 @@ async function runSessionEnqueue(cliKind, opts) {
         task: opts.task,
         env: process.env,
     });
+    const reportFields = kind === "session_end"
+        ? enrichSessionEndEvent({
+            kind,
+            sessionId: sessionId,
+            cwd: opts.cwd,
+            summary: opts.summary,
+        })
+        : {};
     const event = buildMeshEmitEvent({
         eventId: opts.eventId?.trim() || generateUlid(Date.now()),
         kind: kind,
@@ -1546,7 +1555,15 @@ async function runSessionEnqueue(cliKind, opts) {
         taskId: opts.taskId,
         status: opts.status,
         reason: opts.reason,
-        summary: opts.summary,
+        summary: opts.summary ||
+            (typeof reportFields.summary === "string" ? reportFields.summary : undefined),
+        repo: typeof reportFields.repo === "string" ? reportFields.repo : undefined,
+        gitBranch: typeof reportFields.gitBranch === "string"
+            ? reportFields.gitBranch
+            : undefined,
+        prUrls: Array.isArray(reportFields.prUrls)
+            ? reportFields.prUrls
+            : undefined,
         evidence,
     });
     const meshRoot = workMeshHomeRoot();

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

@@ -42,9 +42,18 @@ export interface ProgressPosterOptions {
     minGapMs?: number;
     workingNoticeMs?: number;
     workingNoticeText?: string;
+    /**
+     * Unmentioned room turn: hold every in-between message and the working
+     * notice, and post nothing until the turn ends. `finish` then posts the
+     * in-between messages followed by the final answer when it adds something
+     * (when the turn is not silent); `abandon` posts nothing.
+     */
+    buffer?: boolean;
 }
 /** Whitespace-insensitive form used to recognise repeated text. */
 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?;
@@ -55,6 +64,7 @@ export declare class ProgressPoster {
     private readonly minGapMs;
     private readonly workingNoticeMs;
     private readonly workingNoticeText;
+    private readonly buffer;
     private pending;
     /** In-between questions, held until the turn ends (see the header). */
     private heldQuestions;

package/dist/lib/bot/progress.js

@@ -31,6 +31,10 @@ export const WORKING_NOTICE_TEXT = "Working on it — I'll reply here when it's
 export function normalizeForCompare(text) {
     return text.replace(/\s+/g, "");
 }
+/** Matches {"action":"no_reply"} anywhere in a model reply, with or without preamble text. */
+export function containsNoReplySentinel(text) {
+    return /\{\s*"action"\s*:\s*"no_reply"\s*\}/.test(text);
+}
 export class ProgressPoster {
     send;
     sendFinalFn;
@@ -41,6 +45,7 @@ export class ProgressPoster {
     minGapMs;
     workingNoticeMs;
     workingNoticeText;
+    buffer;
     pending = [];
     /** In-between questions, held until the turn ends (see the header). */
     heldQuestions = [];
@@ -63,9 +68,12 @@ export class ProgressPoster {
         this.minGapMs = opts.minGapMs ?? PROGRESS_MIN_GAP_MS;
         this.workingNoticeMs = opts.workingNoticeMs ?? WORKING_NOTICE_MS;
         this.workingNoticeText = opts.workingNoticeText ?? WORKING_NOTICE_TEXT;
+        this.buffer = opts.buffer ?? false;
     }
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start() {
+        if (this.buffer)
+            return;
         if (this.finished || this.noticeTimer !== null || this.workingNoticeMs <= 0)
             return;
         this.noticeTimer = this.setTimer(() => {
@@ -81,8 +89,16 @@ export class ProgressPoster {
         const t = text.trim();
         if (this.finished || !t)
             return;
+        // Never treat the no_reply sentinel as something the model "said": it is a
+        // silence signal, not content, and must never be posted as progress.
+        if (containsNoReplySentinel(t))
+            return;
         this.cancelNotice();
         this.said.push(t);
+        // An unmentioned room turn holds every in-between message: nothing is posted
+        // until the turn ends, and then only the final answer.
+        if (this.buffer)
+            return;
         if (t.includes("?")) {
             this.heldQuestions.push(t);
             return;
@@ -112,6 +128,34 @@ export class ProgressPoster {
         this.cancelNotice();
         this.cancelFlush();
         const final = finalText.trim();
+        // Buffered (unmentioned room): nothing was posted during the turn. Post the
+        // collected in-between messages (the sentinel is already excluded from
+        // `said`), then the final answer when it adds something the in-between
+        // messages did not already say — mirroring the streaming path's
+        // repeatsSaid logic. claude/codex answer mid-turn and end with a short
+        // sign-off, so dropping the in-between messages would lose the real answer;
+        // 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) {
+            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);
+            }
+            this.flushNow();
+            return this.chain;
+        }
         const held = this.heldQuestions;
         this.heldQuestions = [];
         const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
@@ -141,6 +185,13 @@ export class ProgressPoster {
         this.finished = true;
         this.cancelNotice();
         this.cancelFlush();
+        // Buffered turns never post salvage: nothing streamed, so there is nothing
+        // to salvage, and the caller decides whether to post anything.
+        if (this.buffer) {
+            this.pending = [];
+            this.heldQuestions = [];
+            return this.chain;
+        }
         this.pending.push(...this.heldQuestions);
         this.heldQuestions = [];
         this.flushNow();
@@ -174,6 +225,10 @@ export class ProgressPoster {
         this.enqueueWith(body, this.send);
     }
     enqueueWith(body, sendFn) {
+        // Defence in depth: never let the silence sentinel reach the chat, whatever
+        // path built this body.
+        if (containsNoReplySentinel(body))
+            return;
         this.lastPostAt = this.now();
         this.chain = this.chain.then(async () => {
             try {

package/dist/lib/bot/prompt.js

@@ -288,7 +288,9 @@ export function buildSystemPrompt(input) {
         `Your owner can also add you to group chats and channels. A message that starts with a \`[#channel · N members · from Name]\` line ` +
         `comes from a room with other people in it (a "Recent messages:" block may follow for context; the last part is the message you are answering). ` +
         `Answer for the room: reply to the person who asked, keep it short, and never repeat your private memory, your owner's files, ` +
-        `or anything from your DMs to other people.`);
+        `or anything from your DMs to other people. ` +
+        `If the message is not addressed to you, is routine automated output, or you have nothing meaningful to add, produce zero output (completely empty response). ` +
+        `Do not narrate your reasoning, do not print JSON, do not explain that you are staying silent. Just produce nothing.`);
     // Only company bots: the cloud's jobs routes refuse a personal bot's per_
     // company claim today, so telling a personal bot it can schedule work makes
     // it promise its owner something that then fails. Drop this condition when

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

@@ -47,7 +47,7 @@
 import { type OwnerContext } from "./owner-context.js";
 import { type BotApi, type InboxItem } from "./api.js";
 import type { BotConfig, BotKind } from "./config.js";
-import { type ProgressPosterOptions } from "./progress.js";
+import { containsNoReplySentinel, type ProgressPosterOptions } from "./progress.js";
 import { type BotLogger } from "./log.js";
 import { type BotRuntime, type RuntimeTurnInput, type RuntimeTurnResult } from "./runtime/index.js";
 import type { VaultObjectDownloader } from "../agent-kit/attachment-download.js";
@@ -188,6 +188,9 @@ export declare function turnEnv(base: NodeJS.ProcessEnv, kind: BotKind, agentUid
 export declare const SETUP_WORKER_ID = "setup";
 /** The one message a person gets when a turn on their message did not finish. */
 export declare function didNotFinishText(reason: string, progressPosted: boolean): string;
+export { containsNoReplySentinel };
+/** Grok emits is_error with this message when the model produces only reasoning tokens. */
+export declare function isReasoningOnlyError(excerpt: string): boolean;
 /** Owner stop, `hq bot stop` or `hq bot restart`: all arrive as the same signal. */
 export declare const STOPPED_BY_OWNER_REASON = "I was stopped before I was done";
 export declare const RESTARTED_REASON = "I was restarted while I was working on it";

package/dist/lib/bot/run.js

@@ -57,7 +57,7 @@ import { ensureBotSessionMeta } from "./company-bind.js";
 import { readBotCredsIdentity } from "./creds.js";
 import { isProcessed, markProcessed, readInboxState } from "./inbox-state.js";
 import { clearInflight, patchInflight, readInflight, readInflightTurns, writeInflight } from "./inflight.js";
-import { ProgressPoster } from "./progress.js";
+import { containsNoReplySentinel, ProgressPoster } from "./progress.js";
 import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
@@ -178,6 +178,11 @@ export function didNotFinishText(reason, progressPosted) {
     const r = reason.trim().replace(/[.\s]+$/, "");
     return `I didn't finish that — ${r}.${progressPosted ? " The messages above show how far I got." : ""}`;
 }
+export { containsNoReplySentinel };
+/** Grok emits is_error with this message when the model produces only reasoning tokens. */
+export function isReasoningOnlyError(excerpt) {
+    return excerpt.includes("reasoning_only");
+}
 /** Owner stop, `hq bot stop` or `hq bot restart`: all arrive as the same signal. */
 export const STOPPED_BY_OWNER_REASON = "I was stopped before I was done";
 export const RESTARTED_REASON = "I was restarted while I was working on it";
@@ -646,6 +651,7 @@ export async function runBot(deps) {
         writeInflight(dir, { v: 1, ...args.marker, startedAt: now().toISOString() });
         let running = true;
         let posted = 0;
+        const silenceable = args.silenceable === true;
         const makeSendFn = (fn) => async (body) => {
             try {
                 await fn(body);
@@ -662,7 +668,8 @@ export async function runBot(deps) {
         };
         const poster = new ProgressPoster({
             ...deps.progress,
-            ...(args.workingNotice === false ? { workingNoticeMs: 0 } : {}),
+            ...(args.workingNotice === false || silenceable ? { workingNoticeMs: 0 } : {}),
+            ...(silenceable ? { buffer: true } : {}),
             send: makeSendFn(args.send),
             ...(args.sendFinal ? { sendFinal: makeSendFn(args.sendFinal) } : {}),
         });
@@ -679,8 +686,21 @@ export async function runBot(deps) {
                 ...(args.readDirs?.length ? { readDirs: args.readDirs } : {}),
             });
             running = false;
-            await poster.finish(turn.text);
-            return { outcome: { ok: true, reply: turn.text.trim() || "(no reply)" }, poster };
+            const sentinelOrEmpty = containsNoReplySentinel(turn.text) || !turn.text.trim();
+            // Unmentioned room turn: a no_reply sentinel (bare, fenced, or with
+            // preamble) or an empty/whitespace reply means stay quiet. Abandon the
+            // poster (it posts nothing) and return a silent outcome; the caller acks
+            // without posting anything.
+            if (silenceable && sentinelOrEmpty) {
+                await poster.abandon();
+                return { outcome: { ok: true, reply: "", silent: true }, poster };
+            }
+            // DM or @-mentioned room: the person asked directly and must get a reply.
+            // Strip the silence sentinel so its raw JSON never posts, then let the
+            // poster produce its "(no reply)" fallback when there is nothing else.
+            const finalText = sentinelOrEmpty ? "" : turn.text;
+            await poster.finish(finalText);
+            return { outcome: { ok: true, reply: finalText.trim() }, poster };
         }
         catch (err) {
             running = false;
@@ -984,6 +1004,7 @@ export async function runBot(deps) {
         });
         await clearThinking();
         if (outcome.ok) {
+            // The kickoff never runs silenceable, so outcome.silent is never set here.
             if (poster.postedCount === 0) {
                 patchInflight(dir, KICKOFF_MESSAGE_ID, saved(outcome.reply));
                 log("warn", "kickoff reply failed to send; it is posted on the next start");
@@ -1334,12 +1355,23 @@ export async function runBot(deps) {
             send,
             sendFinal,
             workingNotice: !isSetupBot,
+            silenceable: target.kind === "room" && !target.mentioned,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"
                 ? { afterProgressPost: () => api.postAgentStatus(target.channelId, ROOM_THINKING_STATUS, target.rootEventId) }
                 : {}),
         });
         if (outcome.ok) {
+            // A no_reply sentinel or intentionally empty reply: ack silently, post nothing.
+            if (outcome.silent) {
+                markProcessed(dir, id, now().toISOString());
+                await api.ackInbox(config.agentUid, id);
+                clearInflight(dir, id);
+                attempts.delete(id);
+                await clearThinking();
+                log("info", `no_reply sentinel or empty reply for ${id} (${where}); acked silently`);
+                return;
+            }
             // Known gap (#614, not changed here): a progress post counts, so a final answer that fails after one is not resent.
             if (poster.postedCount === 0) {
                 // The work finished but nothing reached the chat: keep the answer —
@@ -1400,8 +1432,31 @@ export async function runBot(deps) {
         // The model started: it may already have done things, so never re-run.
         if (!outcome.aborted)
             recordTurnFailure(outcome.error, sessionScope);
+        // reasoning_only means the model produced only reasoning tokens and no text.
+        const reasoningOnly = !outcome.aborted && isReasoningOnlyError(outcome.excerpt);
+        const silenceableTurn = target.kind === "room" && !target.mentioned;
+        // Unmentioned room turn that posted nothing and was not stopped by the
+        // owner: any model failure (reasoning_only or otherwise) is a silent
+        // no-reply. The failure is already recorded above via recordTurnFailure,
+        // so we just ack quietly and never leak the raw error into the room.
+        if (!outcome.aborted && poster.postedCount === 0 && silenceableTurn) {
+            markProcessed(dir, id, now().toISOString());
+            await api.ackInbox(config.agentUid, id);
+            clearInflight(dir, id);
+            attempts.delete(id);
+            await clearThinking();
+            log("info", `unmentioned room turn ${id} failed with no post (${where}); acked silently`);
+            if (failures.exceeded(now().getTime())) {
+                await finish("failed", 0, `${FAILURE_LIMIT} model failures in 10 minutes; last: ${outcome.excerpt}`);
+            }
+            return;
+        }
         try {
-            await send(didNotFinishText(failureReason(outcome), poster.postedCount > 0));
+            // DM or @-mentioned room reasoning_only: the person asked directly, so
+            // 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));
         }
         catch (err) {
             // Leave it un-acked with the marker: the next poll says it did not finish.