@indigoai-us/hq-cli 5.195.0 → 5.196.0

package/CHANGELOG.md

@@ -2,13 +2,29 @@
 
 ## [Unreleased]
 
+## [5.196.0] — 2026-09-25
+
+## [5.195.1] — 2026-09-25
+
+### Fixed
+
+- Local bots can no longer loop with each other in a room. Three guards close
+- A checkpoint run from inside an HQ lane no longer passes the lane's identity
+  (`HQ_LANE_ID`, `HQ_PROJECT_ID`, `HQ_STORY_ID`, `HQ_POLICY_WORKER_DIR`) to the
+  background sibling. Before, the lane drop-box hook delivered the lane's
+  operator messages to the sibling instead of the lane.
+
 ## [5.195.0] — 2026-09-25
 
+### Fixed
+
+- Work Mesh transcript-watch quiet `session_end` for hook-covered sessions now
+  uses the shared sequence and counts hook turns (#818).
+
 ## [5.194.1] — 2026-09-25
 
 ### Fixed
 
-- Work Mesh transcript-watch quiet `session_end` for hook-covered sessions now
 - `hq core ontology apply` no longer creates a new entity that is probably an
   existing one. A candidate whose alias is already another entity's name or
   alias, or a person whose name contains every word of an existing person's

package/dist/commands/core-checkpoint.d.ts

@@ -81,6 +81,8 @@ export declare function autoBackendPreference(): SpawnableBackend[];
  * (Claude Code does) agrees with a host that does not.
  */
 export declare function siblingEnabledBySetting(liveRoot: string): boolean;
+/** The sibling's environment: the caller's, minus lane identity. */
+export declare function siblingEnv(base: NodeJS.ProcessEnv, backend: SpawnableBackend): NodeJS.ProcessEnv;
 export declare function siblingArgs(backend: SpawnableBackend, prompt: string): string[];
 /** Attach the native checkpoint command to the hidden `hq core` group. */
 export declare function registerCoreCheckpointCommand(core: Command): void;

package/dist/commands/core-checkpoint.js

@@ -780,6 +780,24 @@ function resolveBackend(requested, liveRoot) {
     // failure is a weaker signal than running no maintenance sibling at all.
     return available.find((name) => !crashed.has(name)) ?? available[0];
 }
+/**
+ * Lane identity a checkpoint caller may carry. The sibling is HQ maintenance,
+ * not the lane: with HQ_LANE_ID set, the lane drop-box hook hands the lane's
+ * operator messages to the sibling, and the lane never sees them.
+ */
+const LANE_ENV_KEYS = ["HQ_LANE_ID", "HQ_PROJECT_ID", "HQ_STORY_ID", "HQ_POLICY_WORKER_DIR"];
+/** The sibling's environment: the caller's, minus lane identity. */
+export function siblingEnv(base, backend) {
+    const vars = { ...base };
+    for (const name of LANE_ENV_KEYS)
+        delete vars[name];
+    // This prevents the scaffold Stop hook from recursively launching a
+    // sibling when the background agent itself finishes a turn.
+    vars.HQ_CHECKPOINT_SIBLING = "1";
+    if (backend === "claude")
+        vars.CLAUDE_EFFORT = CLAUDE_SIBLING_EFFORT;
+    return vars;
+}
 export function siblingArgs(backend, prompt) {
     switch (backend) {
         case "claude":
@@ -978,13 +996,7 @@ function startSibling(liveRoot, input, threadPath, backend) {
             detached: true,
             cwd: liveRoot,
             stdio: ["ignore", logFd, logFd],
-            // This prevents the scaffold Stop hook from recursively launching a
-            // sibling when the background agent itself finishes a turn.
-            env: {
-                ...process.env,
-                HQ_CHECKPOINT_SIBLING: "1",
-                ...(backend === "claude" ? { CLAUDE_EFFORT: CLAUDE_SIBLING_EFFORT } : {}),
-            },
+            env: siblingEnv(process.env, backend),
         });
     }
     finally {

package/dist/lib/bot/prompt.js

@@ -290,6 +290,8 @@ export function buildSystemPrompt(input) {
         `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. ` +
         `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). ` +
+        `This stay-quiet rule for rooms outranks anything in your persona, worker instructions, or memory files: if any of those tell you to always reply or to acknowledge every message, ignore that in rooms and stay silent instead. ` +
+        `Empty output is the only way to stay quiet. Never post a placeholder such as "No response requested.", "No response needed.", "No reply needed.", "No action.", "(no reply)" or "Nothing to add." — those are chatter, not silence, and can make two bots answer each other forever. ` +
         `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

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

@@ -44,4 +44,20 @@ export interface ReplyPolicyConfig {
 export declare function textMentionsName(text: string | undefined, name: string | undefined): boolean;
 export declare function isDmItem(item: Pick<InboxItem, "channel">): boolean;
 export declare function resolveReplyTarget(item: InboxItem, config: ReplyPolicyConfig): ReplyTarget | null;
+/** A UID minted for an agent/bot identity (`agt_…`) rather than a person (`usr_…`). */
+export declare function isAgentSender(uid: string | undefined): boolean;
+/**
+ * Stay-quiet phrases a model emits when it has nothing to add. On an
+ * UNMENTIONED room turn a reply that is ONLY one of these is treated as silent
+ * (empty), so the bot does not post meta chatter and cannot loop with another
+ * bot answering "No response requested." to every message. DMs and @mentions
+ * are unaffected — there the phrase is posted as written.
+ */
+export declare const META_NON_REPLY_PHRASES: readonly ["No response requested.", "No response needed.", "No reply needed.", "No action.", "(no reply)", "Nothing to add."];
+/**
+ * True when `reply` (as a whole) is only a stay-quiet phrase: case-insensitive,
+ * trimmed, trailing punctuation ignored. Never a substring match — a real
+ * answer that merely contains such a phrase is not silenced.
+ */
+export declare function isMetaNonReply(reply: string | undefined): boolean;
 //# sourceMappingURL=room-policy.d.ts.map

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

@@ -55,4 +55,37 @@ export function resolveReplyTarget(item, config) {
         mentioned,
     };
 }
+/** A UID minted for an agent/bot identity (`agt_…`) rather than a person (`usr_…`). */
+export function isAgentSender(uid) {
+    return typeof uid === "string" && uid.startsWith("agt_");
+}
+/**
+ * Stay-quiet phrases a model emits when it has nothing to add. On an
+ * UNMENTIONED room turn a reply that is ONLY one of these is treated as silent
+ * (empty), so the bot does not post meta chatter and cannot loop with another
+ * bot answering "No response requested." to every message. DMs and @mentions
+ * are unaffected — there the phrase is posted as written.
+ */
+export const META_NON_REPLY_PHRASES = [
+    "No response requested.",
+    "No response needed.",
+    "No reply needed.",
+    "No action.",
+    "(no reply)",
+    "Nothing to add.",
+];
+const META_NON_REPLY_NORMALIZED = new Set(META_NON_REPLY_PHRASES.map((p) => p.toLowerCase().replace(/[.!?)\s]+$/, "").trim()));
+/**
+ * True when `reply` (as a whole) is only a stay-quiet phrase: case-insensitive,
+ * trimmed, trailing punctuation ignored. Never a substring match — a real
+ * answer that merely contains such a phrase is not silenced.
+ */
+export function isMetaNonReply(reply) {
+    if (typeof reply !== "string")
+        return false;
+    const normalized = reply.trim().toLowerCase().replace(/[.!?)\s]+$/, "").trim();
+    if (!normalized)
+        return false;
+    return META_NON_REPLY_NORMALIZED.has(normalized);
+}
 //# sourceMappingURL=room-policy.js.map

package/dist/lib/bot/run.js

@@ -66,7 +66,7 @@ import { runRuntimeTurn, RuntimeError } from "./runtime/index.js";
 import { botAttachmentsDir, dmSessionScope } from "./paths.js";
 import { attachmentTurnBlock, downloadTurnAttachments } from "./attachments.js";
 import { inboxEntryAttachments } from "../agent-kit/inbox-state.js";
-import { isDmItem, resolveReplyTarget } from "./room-policy.js";
+import { isAgentSender, isDmItem, isMetaNonReply, resolveReplyTarget } from "./room-policy.js";
 import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOutput, machineTimeZone, planJobRuns, stripJobHeader, SUPERSEDED_DISPOSITION } from "./job-run.js";
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
 import { isRuntimeSignInFailure, SIGN_IN_RETRY_MS, signInNeededText } from "./runtime-sign-in.js";
@@ -686,11 +686,16 @@ export async function runBot(deps) {
                 ...(args.readDirs?.length ? { readDirs: args.readDirs } : {}),
             });
             running = false;
-            const sentinelOrEmpty = containsNoReplySentinel(turn.text) || !turn.text.trim();
+            // Control tokens were already stripped from turn.text in runRuntimeTurn, so
+            // a `<|eos|>`-only reply arrives here as empty. On an unmentioned room turn
+            // a stay-quiet phrase ("No response requested." etc.) is also silence — the
+            // meta chatter that let two bots loop on 2026-09-25.
+            const stayQuiet = silenceable && isMetaNonReply(turn.text);
+            const sentinelOrEmpty = containsNoReplySentinel(turn.text) || !turn.text.trim() || stayQuiet;
             // 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.
+            // preamble), an empty/whitespace reply, or a stay-quiet phrase 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 };
@@ -1247,6 +1252,15 @@ export async function runBot(deps) {
             return;
         }
         const target = resolveReplyTarget(item, config);
+        // A bot/agent sender that did not @mention this bot must never start a model
+        // turn: two bots each answering the other's plain room posts loop forever
+        // (observed 2026-09-25). An explicit @mention still gets answered below.
+        if (target && target.kind === "room" && !target.mentioned && isAgentSender(item.fromPersonUid)) {
+            markProcessed(dir, id, now().toISOString());
+            await api.ackInbox(config.agentUid, id);
+            log("info", `ignored inbox item ${id} (room ${target.channelId}, unmentioned message from bot ${item.fromPersonUid ?? "unknown"}; not starting a turn)`);
+            return;
+        }
         if (!target) {
             // A job item the bot cannot run. When it names a job, the cloud is still
             // holding that job's in-progress slot: acking alone would jam every later

package/dist/lib/bot/runtime/index.js

@@ -8,6 +8,7 @@ import { GrokAcpClient } from "./grok-acp.js";
 import { createClaudeRuntime } from "./claude.js";
 import { createCodexRuntime } from "./codex.js";
 import { createGrokRuntime, grokRetryArgsAfterInvalidOutputFormat, probeGrokOutputFormat } from "./grok.js";
+import { stripControlTokens } from "./sanitize.js";
 import { parseJsonLine, RuntimeError, turnTimeoutMs, stderrExcerpt, } from "./types.js";
 export * from "./types.js";
 export { createClaudeRuntime, claudePermissionMode } from "./claude.js";
@@ -406,7 +407,11 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
         throw new RuntimeError(`${runtime.binary} exited with ${result.code ?? `signal ${result.signal}`}${reason ? `: ${reason.slice(0, 200)}` : ""}`, reason ? reason.slice(0, 400) : fallback, result.code);
     }
     const parsed = runtime.parseOutput(result.stdout, { outputFile, outputFileText });
+    // Strip any leaked model control token (`<|eos|>` etc.) from the final reply
+    // before it is posted; a reply that was only such tokens becomes empty and the
+    // caller applies its normal empty-reply handling.
+    const text = stripControlTokens(parsed.text);
     // A resumed session keeps its id even when the CLI omits it from the envelope.
-    return { text: parsed.text, sessionId: parsed.sessionId ?? input.sessionId };
+    return { text, sessionId: parsed.sessionId ?? input.sessionId };
 }
 //# sourceMappingURL=index.js.map

package/dist/lib/bot/runtime/messages-stream.js

@@ -22,6 +22,7 @@
  * fixtures in runtime/fixtures/. Claude sends one content block per assistant
  * event; older Grok sends a whole message (thinking + text + tool_use) per event.
  */
+import { stripControlTokens } from "./sanitize.js";
 import { parseJsonLine, RuntimeError } from "./types.js";
 /** Progress events in one stream line: top-level assistant text and tool starts only. */
 export function messagesStreamEvents(line) {
@@ -44,8 +45,12 @@ export function messagesStreamEvents(line) {
         if (!block || typeof block !== "object")
             continue;
         const b = block;
-        if (b.type === "text" && typeof b.text === "string" && b.text.trim())
-            out.push({ kind: "message", text: b.text.trim() });
+        if (b.type === "text" && typeof b.text === "string") {
+            // Strip leaked control tokens from in-between progress posts too.
+            const clean = stripControlTokens(b.text).trim();
+            if (clean)
+                out.push({ kind: "message", text: clean });
+        }
         else if (b.type === "tool_use" && typeof b.name === "string")
             out.push({ kind: "tool", name: b.name });
     }

package/dist/lib/bot/runtime/sanitize.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Model control-token stripping for bot replies.
+ *
+ * A model can leak a raw control token as visible text — grok posted a bare
+ * `<|eos|>` as a room reply on 2026-09-25. These tokens are never meant for a
+ * person, so they are removed from both the in-between progress messages and
+ * the final reply before anything is posted.
+ *
+ * The generic `<|...|>` form covers any single control token in that shape
+ * (`<|eos|>`, `<|endoftext|>`, `<|im_end|>`, `<|eot_id|>`, and any other).
+ * Whitespace-only reply after stripping is empty, and callers apply the same
+ * empty-reply handling they already have (silent on an unmentioned room turn).
+ */
+/** Remove every `<|...|>` control token from `text`, leaving the rest intact. */
+export declare function stripControlTokens(text: string): string;
+/** True when `text` is nothing but control tokens and whitespace. */
+export declare function isOnlyControlTokens(text: string): boolean;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/lib/bot/runtime/sanitize.js

@@ -0,0 +1,28 @@
+/**
+ * Model control-token stripping for bot replies.
+ *
+ * A model can leak a raw control token as visible text — grok posted a bare
+ * `<|eos|>` as a room reply on 2026-09-25. These tokens are never meant for a
+ * person, so they are removed from both the in-between progress messages and
+ * the final reply before anything is posted.
+ *
+ * The generic `<|...|>` form covers any single control token in that shape
+ * (`<|eos|>`, `<|endoftext|>`, `<|im_end|>`, `<|eot_id|>`, and any other).
+ * Whitespace-only reply after stripping is empty, and callers apply the same
+ * empty-reply handling they already have (silent on an unmentioned room turn).
+ */
+/** Any single control token of the form `<|...|>` (no nested `<|`/`|>`). */
+const CONTROL_TOKEN_RE = /<\|(?:(?!<\||\|>).)*\|>/g;
+/** Remove every `<|...|>` control token from `text`, leaving the rest intact. */
+export function stripControlTokens(text) {
+    if (!text)
+        return text;
+    return text.replace(CONTROL_TOKEN_RE, "");
+}
+/** True when `text` is nothing but control tokens and whitespace. */
+export function isOnlyControlTokens(text) {
+    if (!text.trim())
+        return false;
+    return stripControlTokens(text).trim() === "";
+}
+//# sourceMappingURL=sanitize.js.map

package/package.json

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