@indigoai-us/hq-cli 5.345.93 → 5.345.95

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.345.95] — 2026-10-12
+- `hq doctor --fix` still refreshes a stale personal-files journal and a
+  company journal in the same pass when hook files have uncommitted changes.
+  Session-start health no longer treats that pair as unrepaired.
+
+## [5.345.94] — 2026-10-12
+- Local bots now turn `@Name` in a group-room post into a real mention, so the addressed bot receives that post in its inbox. A room post that does not mention another bot still does not wake that bot.
+
 ## [5.345.93] — 2026-10-12
 - New `hq capacity` command shows how much of each signed-in Claude, Codex,
   and Grok account's usage limit is left and when it resets. The numbers come

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

@@ -249,12 +249,33 @@ export declare class BotApi {
      * (someone else does). Anything else throws.
      */
     claimChannelUnit(channelId: string, unitId: string): Promise<boolean>;
+    /**
+     * GET /v1/notify/channels/{id}/members — roster used to resolve `@Name`
+     * into structured mentions on a room post. Agents may read members of a
+     * channel they belong to (same gate as reading messages).
+     */
+    fetchChannelMembers(channelId: string): Promise<Array<{
+        personUid: string;
+        displayName?: string;
+        email?: string;
+        slug?: string;
+        handle?: string;
+    }>>;
     /** POST /v1/notify/channels/{id}/messages — post in a room as the bot. */
     sendChannelMessage(input: {
         channelId: string;
         body: string;
         rootEventId?: string;
         audience?: "human" | "agent" | "both";
+        /**
+         * Structured HQ mentions. The server never parses `@Name` from the body;
+         * without this array the addressed bot is not written to the agent inbox.
+         */
+        mentions?: ReadonlyArray<{
+            participantUid: string;
+            participantType: "agent" | "human";
+            displayName: string;
+        }>;
     }): Promise<{
         eventId?: string;
         createdAt?: string;

package/dist/lib/bot/api.js

@@ -192,6 +192,30 @@ export class BotApi {
             throw err;
         }
     }
+    /**
+     * GET /v1/notify/channels/{id}/members — roster used to resolve `@Name`
+     * into structured mentions on a room post. Agents may read members of a
+     * channel they belong to (same gate as reading messages).
+     */
+    async fetchChannelMembers(channelId) {
+        const { body } = await this.call(`/v1/notify/channels/${encodeURIComponent(channelId)}/members`);
+        const rows = Array.isArray(body.members) ? body.members : [];
+        const out = [];
+        for (const row of rows) {
+            if (typeof row.personUid !== "string" || !row.personUid.trim())
+                continue;
+            out.push({
+                personUid: row.personUid.trim(),
+                ...(typeof row.displayName === "string" && row.displayName.trim()
+                    ? { displayName: row.displayName.trim() }
+                    : {}),
+                ...(typeof row.email === "string" && row.email.trim() ? { email: row.email.trim() } : {}),
+                ...(typeof row.slug === "string" && row.slug.trim() ? { slug: row.slug.trim() } : {}),
+                ...(typeof row.handle === "string" && row.handle.trim() ? { handle: row.handle.trim() } : {}),
+            });
+        }
+        return out;
+    }
     /** POST /v1/notify/channels/{id}/messages — post in a room as the bot. */
     async sendChannelMessage(input) {
         const payload = { body: input.body };
@@ -199,6 +223,8 @@ export class BotApi {
             payload.rootEventId = input.rootEventId;
         if (input.audience)
             payload.audience = input.audience;
+        if (input.mentions && input.mentions.length > 0)
+            payload.mentions = input.mentions;
         const { body } = await this.call(`/v1/notify/channels/${encodeURIComponent(input.channelId)}/messages`, { method: "POST", body: payload });
         return body;
     }

package/dist/lib/bot/prompt.js

@@ -382,7 +382,8 @@ export function buildSystemPrompt(input) {
         `- \`agent\`: status pings, tool handoffs, and in-progress notes that only another agent needs to read.\n` +
         `- \`human\`: anything a person must read — answers, results, questions, summaries.\n` +
         `- \`both\`: when the content is relevant to both a person and a downstream agent.\n` +
-        `When unsure, use \`human\`. Progress messages sent before the final answer should use \`agent\`; the final answer should use \`human\`.`);
+        `When unsure, use \`human\`. Progress messages sent before the final answer should use \`agent\`; the final answer should use \`human\`.\n\n` +
+        `In a group room, write \`@Name\` to address another person or bot on the roster. That becomes a real mention and puts the post in the addressed bot's inbox. A room post that does not mention another bot does not wake that bot.`);
     return `${parts.join("\n\n")}\n`;
 }
 /**

package/dist/lib/bot/room-mentions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Best-effort structured mentions for a local bot's room post.
+ *
+ * HQ Rooms mentions are structured-only: the server never parses `@Name` out of
+ * the body. `hq dm` already resolves names against the roster and sends the
+ * `mentions` array. Bot room posts did not, so an addressed bot never got an
+ * inbox item (feedback #2774). Unknown or ambiguous `@` words are skipped so a
+ * model typo cannot swallow the visible reply; matched roster members become
+ * real mentions. The sender is never included.
+ */
+import { type ChannelMember } from "../../commands/dm.js";
+export type StructuredChannelMention = {
+    participantUid: string;
+    participantType: "agent" | "human";
+    displayName: string;
+};
+export declare function roomPostHasMentionTokens(body: string): boolean;
+export declare function resolveRoomMentionsForBot(args: {
+    body: string;
+    members: readonly ChannelMember[];
+    selfUid: string;
+}): {
+    body: string;
+    mentions: StructuredChannelMention[];
+};
+//# sourceMappingURL=room-mentions.d.ts.map

package/dist/lib/bot/room-mentions.js

@@ -0,0 +1,40 @@
+/**
+ * Best-effort structured mentions for a local bot's room post.
+ *
+ * HQ Rooms mentions are structured-only: the server never parses `@Name` out of
+ * the body. `hq dm` already resolves names against the roster and sends the
+ * `mentions` array. Bot room posts did not, so an addressed bot never got an
+ * inbox item (feedback #2774). Unknown or ambiguous `@` words are skipped so a
+ * model typo cannot swallow the visible reply; matched roster members become
+ * real mentions. The sender is never included.
+ */
+import { parseMentionTokens, resolveMentions, stripMentionQuotes, } from "../../commands/dm.js";
+export function roomPostHasMentionTokens(body) {
+    return parseMentionTokens(body).length > 0;
+}
+export function resolveRoomMentionsForBot(args) {
+    const tokens = parseMentionTokens(args.body);
+    if (tokens.length === 0)
+        return { body: args.body, mentions: [] };
+    const members = [...args.members];
+    const mentions = [];
+    const claimed = new Set();
+    for (const token of tokens) {
+        const resolved = resolveMentions([token], members);
+        if (!resolved.ok)
+            continue;
+        for (const mention of resolved.mentions) {
+            if (mention.participantUid === args.selfUid)
+                continue;
+            if (claimed.has(mention.participantUid))
+                continue;
+            claimed.add(mention.participantUid);
+            mentions.push(mention);
+        }
+    }
+    return {
+        body: mentions.length > 0 ? stripMentionQuotes(args.body) : args.body,
+        mentions,
+    };
+}
+//# sourceMappingURL=room-mentions.js.map

package/dist/lib/bot/run.js

@@ -73,6 +73,7 @@ import { appendDmHistory, dmHistoryHasModelThread, markDmHistoryModelTurn, readD
 import { attachmentTurnBlock, downloadTurnAttachments } from "./attachments.js";
 import { inboxEntryAttachments } from "../agent-kit/inbox-state.js";
 import { isAgentSender, isDmItem, isMetaNonReply, resolveReplyTarget } from "./room-policy.js";
+import { resolveRoomMentionsForBot, roomPostHasMentionTokens, } from "./room-mentions.js";
 import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOutput, machineTimeZone, planJobRuns, stripJobHeader, SUPERSEDED_DISPOSITION } from "./job-run.js";
 import { botJobQuietOptionEnabled } from "./job-quiet-flag.js";
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
@@ -755,6 +756,15 @@ export async function runBot(deps) {
         }
         return `${header}\n${recent}${from}: ${text}`;
     };
+    const channelMemberCache = new Map();
+    const loadChannelMembers = async (channelId) => {
+        const cached = channelMemberCache.get(channelId);
+        if (cached)
+            return cached;
+        const members = await api.fetchChannelMembers(channelId);
+        channelMemberCache.set(channelId, members);
+        return members;
+    };
     const rememberDm = (scope, message) => {
         if (!isDmSessionScope(scope))
             return;
@@ -1052,13 +1062,16 @@ export async function runBot(deps) {
         }
         await sendToTarget(target, notice.text, rootEventId, "human");
     };
-    const postOne = (target, body, rootEventId, audience) => {
+    const postOne = async (target, body, rootEventId, audience) => {
         const root = rootEventId ? { rootEventId } : {};
-        const send = target.kind === "dm"
-            ? api.sendDm({ toPersonUid: target.peerUid, body, ...root, ...(audience ? { audience } : {}) })
-            : api.sendChannelMessage({ channelId: target.channelId, body, ...root, ...(audience ? { audience } : {}) });
-        return send.then((posted) => {
-            if (target.kind === "dm" && audience !== "agent") {
+        if (target.kind === "dm") {
+            const posted = await api.sendDm({
+                toPersonUid: target.peerUid,
+                body,
+                ...root,
+                ...(audience ? { audience } : {}),
+            });
+            if (audience !== "agent") {
                 const eventId = posted && typeof posted === "object" && "eventId" in posted && typeof posted.eventId === "string"
                     ? posted.eventId
                     : undefined;
@@ -1072,6 +1085,31 @@ export async function runBot(deps) {
                 });
             }
             return posted;
+        }
+        let bodyToSend = body;
+        let mentions;
+        if (roomPostHasMentionTokens(body)) {
+            try {
+                const members = await loadChannelMembers(target.channelId);
+                const resolved = resolveRoomMentionsForBot({
+                    body,
+                    members,
+                    selfUid: config.agentUid,
+                });
+                bodyToSend = resolved.body;
+                if (resolved.mentions.length > 0)
+                    mentions = resolved.mentions;
+            }
+            catch (err) {
+                log("warn", `room mentions for ${target.channelId} unresolved: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return api.sendChannelMessage({
+            channelId: target.channelId,
+            body: bodyToSend,
+            ...root,
+            ...(audience ? { audience } : {}),
+            ...(mentions ? { mentions } : {}),
         });
     };
     /**

package/dist/lib/doctor/fix/apply.d.ts

@@ -8,9 +8,11 @@
  *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses hook-file repairs
  *      and exits non-zero unless `--force`, so those writes can never be
  *      tangled up with unrelated in-flight edits to the security layer.
- *      Repairs that do not write those trees (a stale-company `refresh-sync`
- *      pull) still run: the SessionStart health hook never passes `--force`,
- *      and blocking the pull left `sync.journal.<slug>` WARN after `--fix`.
+ *      Repairs that do not write those trees (`refresh-sync` pulls for a
+ *      stale company journal or the personal vault) still run: the
+ *      SessionStart health hook never passes `--force`, and blocking those
+ *      pulls left `sync.journal.<slug>` and
+ *      `sync.journal.__hq_personal_vault__` WARN after `--fix`.
  *   2. Allowlist only. It repairs the classified safe classes — restore an
  *      execute bit, add a hook id to the gate profiles it is missing from,
  *      re-register a script present on disk, or pull a company or personal

package/dist/lib/doctor/fix/apply.js

@@ -8,9 +8,11 @@
  *      `.claude/`, `.codex/`, or `.grok/`, `--fix` refuses hook-file repairs
  *      and exits non-zero unless `--force`, so those writes can never be
  *      tangled up with unrelated in-flight edits to the security layer.
- *      Repairs that do not write those trees (a stale-company `refresh-sync`
- *      pull) still run: the SessionStart health hook never passes `--force`,
- *      and blocking the pull left `sync.journal.<slug>` WARN after `--fix`.
+ *      Repairs that do not write those trees (`refresh-sync` pulls for a
+ *      stale company journal or the personal vault) still run: the
+ *      SessionStart health hook never passes `--force`, and blocking those
+ *      pulls left `sync.journal.<slug>` and
+ *      `sync.journal.__hq_personal_vault__` WARN after `--fix`.
  *   2. Allowlist only. It repairs the classified safe classes — restore an
  *      execute bit, add a hook id to the gate profiles it is missing from,
  *      re-register a script present on disk, or pull a company or personal
@@ -120,7 +122,10 @@ export async function applyFixes(options) {
     const refuseDirtyHookWrites = (plans) => {
         if (dirty.length === 0)
             return plans;
-        const allowed = plans.filter((plan) => plan.relpath.length === 0);
+        // Journal refreshes never write hook files. Allow them by class, not
+        // only by empty relpath, so a personal-vault pull and a company pull
+        // still run when SessionStart `--fix --yes` cannot pass `--force`.
+        const allowed = plans.filter((plan) => plan.fixClass === "refresh-sync" || plan.relpath.length === 0);
         if (allowed.length === plans.length)
             return plans;
         if (allowed.length === 0)

package/package.json

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