@indigoai-us/hq-cli 5.345.166 → 5.345.169

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [5.345.169] — 2026-10-24
+- Sentry error reports now redact CloudFront signed-URL params (`Policy`, `Key-Pair-Id`) and the `AWSAccessKeyId` and `GoogleAccessId` ids when they appear as structured keys in event data, for example a parsed query under `extra`. The feedback diagnostics scrubber already redacted them (#2177); the Sentry scrubber caught them only inside strings. The shared structured-key cases now run against the Sentry scrubber too.
+- A debounced automatic checkpoint is now queued for the next checkpoint sibling. Before this, `hq core checkpoint` wrote the `-auto-` thread when the per-session debounce skipped the sibling, but it never queued the payload, so no sibling ever filled the thread in. The payload is now added to the pending queue once, and the next sibling run picks it up. The debounce still limits how many siblings start. When the pending queue goes over its cap of 50, a message on stderr now gives the number of oldest payloads dropped. Feedback a2a5c2c3-5ea0-4e1f-8155-1f39ce6ac750.
+
+- `hq feedback` now redacts presigned URL signatures, session tokens, bearer tokens and other credentials from the diagnostics it attaches. Before this fix, recent Sentry breadcrumbs were copied into diagnostics without scrubbing, so an S3 presigned URL's X-Amz-Security-Token could reach the stored feedback row. Diagnostics passed in by callers are scrubbed too, and the inline log tails and the S3 log bundle now also catch bare, URL-encoded, CloudFront, GCS and Azure signed URL parameters.
+- `hq doctor --fix` no longer starts a second background sync pull while a pull it stopped at its time limit is still shutting down. It takes the pull-start lock from another process only when that process has exited or its process id now belongs to a different process.
+- `hq doctor --fix` can now refresh sync journals on drives without hard links (exFAT, FAT, some network drives). `hq doctor` warns, naming the process, when a journal refresh lock has been held for more than 10 minutes.
+- `hq doctor --fix` no longer kills a slow sync journal pull after 90 seconds. A pull that is still running keeps going in the background for up to 10 minutes, one at a time, and `hq doctor` shows that journal as "refresh in progress" until it finishes. It never blocks your own `hq sync`, and it steps aside at once for `hq rescue` and other repairs, keeping what it already downloaded. A large company is no longer reported as stale every day.
+
+## [5.345.168] — 2026-10-24
+- `hq dm` now picks the default audience from the recipient when no audience flag is passed. A 1:1 DM to a person (email, `prs_` uid, or a bare name that resolves to a person) sends `audience: "human"`. A 1:1 DM to an agent (`agt_` uid), a group DM and a channel post send `audience: "agent"`, so script and lane messages stay out of people's conversations. Scheduled sends (`--at`, `--in`) follow the same rule. Pass `--for-human` (alias for `--audience human`) to tag any message for people; an explicit `--audience human|agent|both` wins over `--for-human`, with a warning on stderr, and is validated on every path. `hq core delegate send` tags the pickup DM `audience: "both"`, `hq dm-bind post` keeps the channel default (`audience: "agent"`) for its automated status posts, and the agent MCP `hq_dm_send` tool, `hq agents message` and the `hq access` grant request apply the recipient rule. Reading commands (inbox, thread, channel) are unchanged, and `hq dm forward` does not set an audience.
+- `hq scan secrets` no longer exits 2 when a repo's `.gitleaks.toml` allowlist is rejected. In staged and file scans it now prints a fixed warning that quotes no part of the file and scans with no repo allowlist, so a real key is still reported (exit 1) and a commit that replaces a bad allowlist is not blocked. An unknown `--allowlist-rev` still exits 2.
+
 ## [5.345.166] — 2026-10-24
 - `hq integrations approve` now says why an approved call did not run. When an app refuses it, the CLI prints the app's own reason, such as Slack's refusal to send into a Slack Connect channel. Before this it printed only "failed (rejected)". With an older server it prints the rejection code instead. `hq integrations pending --history` adds a `Why:` line for decided calls that did not run. The approve command printed after a queued call keeps `--company` when you passed it. Before printing, the reason is cleaned of terminal escape codes, credentials and credential-bearing links, and it is capped at 500 characters. Feedback 15e7593c-50e5-4e6a-ae3a-342d618363c0.
 - The bundled sync engine now uses hq-cloud 6.18.101, the current npm `latest`.

package/assets/scaffold/core/scripts/hq-delegate-send.sh

@@ -283,7 +283,7 @@ if ! jq '.status = "sending"' "$MANIFEST" > "$TMP_MANIFEST" || ! mv "$TMP_MANIFE
   rm -f "$TMP_MANIFEST"
   die "could not persist sending state; no DM attempted"
 fi
-DM_OUT="$(hq dm "$PRINCIPAL" "$HEADLINE" --prompt-file "$PROMPT" --details-file "$BRIEF")" \
+DM_OUT="$(hq dm "$PRINCIPAL" "$HEADLINE" --audience both --prompt-file "$PROMPT" --details-file "$BRIEF")" \
   || die "hq dm delivery outcome is uncertain; status is sending, inspect DM history before retrying"
 
 EVENT_ID="$(printf '%s' "$DM_OUT" | grep -oE 'eventId[: ]+[A-Za-z0-9_-]+' | head -1 | sed -E 's/eventId[: ]+//' || true)"

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

@@ -3987,7 +3987,7 @@ export declare const COMMAND_CATALOG: readonly [{
     }];
 }, {
     readonly name: "dm";
-    readonly description: "Send and read direct messages, and manage connection requests.";
+    readonly description: "Send and read direct messages, and manage connection requests. Messages to a person send to them; messages to an agent, a channel or a group are tagged for agents and folded away from people by default. Pass --for-human or --audience human|agent|both to override.";
     readonly aliases: readonly [];
     readonly hidden: false;
     readonly helpOption: true;
@@ -4054,7 +4054,11 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }, {
             readonly flags: "--audience <human|agent|both>";
-            readonly description: "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both";
+            readonly description: "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both. Default: human for a person, agent for an agent, a channel or a group. Wins over --for-human.";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--for-human";
+            readonly description: "Tag the message for people (alias for --audience human).";
             readonly hidden: false;
         }, {
             readonly flags: "--attach <path>";

package/dist/command-catalog.generated.js

@@ -4827,7 +4827,7 @@ export const COMMAND_CATALOG = [
     },
     {
         "name": "dm",
-        "description": "Send and read direct messages, and manage connection requests.",
+        "description": "Send and read direct messages, and manage connection requests. Messages to a person send to them; messages to an agent, a channel or a group are tagged for agents and folded away from people by default. Pass --for-human or --audience human|agent|both to override.",
         "aliases": [],
         "hidden": false,
         "helpOption": true,
@@ -4908,7 +4908,12 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--audience <human|agent|both>",
-                        "description": "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both",
+                        "description": "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both. Default: human for a person, agent for an agent, a channel or a group. Wins over --for-human.",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--for-human",
+                        "description": "Tag the message for people (alias for --audience human).",
                         "hidden": false
                     },
                     {

package/dist/commands/access.js

@@ -25,6 +25,7 @@ import { listJournals, syncDoctor, } from "@indigoai-us/hq-cloud";
 import { listActiveMembers } from "./members.js";
 import { aclLockedBy } from "./acl-lock.js";
 import { buildDmBody } from "./dm.js";
+import { defaultAudienceFor, recipientKindOf } from "../lib/notify-recipient.js";
 import { peekIdToken } from "../utils/id-token.js";
 import { findRecentAccessRequest, formatTimeAgo, recordAccessRequest, } from "../utils/access-requests.js";
 import { recordAccessOutcome } from "../utils/access-outcomes.js";
@@ -1155,6 +1156,7 @@ async function buildLiveAccessDeps(slug, hqRoot) {
                 prompt: msg.prompt,
                 details: msg.details,
                 now: Date.now(),
+                audience: defaultAudienceFor(recipientKindOf(msg.recipient)),
             });
             const res = await vaultApiFetch({
                 token,

package/dist/commands/agents.js

@@ -42,7 +42,7 @@ import { consoleOrigin } from "./integrations-connect.js";
 import { launchSessionManagerPlugin, SessionManagerPluginLaunchError, TerminalSessionTimeoutError, } from "@indigoai-us/hq-cloud/outposts/node";
 import { peekIdToken } from "../utils/id-token.js";
 import { canOfferTeamUpgrade, formatUpgradeRefusal, isPlanGateError, offerUpgradeLink, } from "../utils/plan-gate-error.js";
-import { AGENT_UID_PATTERN, isAgentUid } from "../lib/notify-recipient.js";
+import { AGENT_UID_PATTERN, defaultAudienceFor, isAgentUid } from "../lib/notify-recipient.js";
 import { AGENT_MODEL_PROVIDERS, modelSelectionErrorMessage, readAgentModelCatalog, validateAgentModelSelection, } from "../lib/agents/model-catalog.js";
 import { fetchCompanyPricingPlan, isUsageOnly, usageOnlyBoxSentence, usageOnlyCardRequiredLines, } from "../lib/billing/usage-only.js";
 import { BUNDLED_USAGE_CARD, fetchUsageCard, } from "../lib/billing/usage-card.js";
@@ -1139,7 +1139,7 @@ export async function sendAgentDm(token, agentUid, message) {
         token,
         path: "/v1/notify/dm",
         method: "POST",
-        body: { toPersonUid: agentUid, body: message },
+        body: { toPersonUid: agentUid, body: message, audience: defaultAudienceFor("agent") },
     });
 }
 /** Read the two-way DM conversation with an agent (most recent `limit`). */

package/dist/commands/core-checkpoint-native.js

@@ -1206,8 +1206,30 @@ function appendPending(pendingPath, payload) {
     // runs once the queue is already over cap, where newest-wins is the point.
     const kept = lines.slice(-MAX_PENDING_PAYLOADS);
     fs.writeFileSync(pendingPath, `${kept.join("\n")}\n`);
+    // Say so instead of dropping silently: a wedged sibling shows up here.
+    const dropped = lines.length - kept.length;
+    printError(`checkpoint: pending queue over cap (${MAX_PENDING_PAYLOADS}); dropped ${dropped} oldest payload(s)`);
     return kept.length;
 }
+/**
+ * Queue a payload for the next sibling run and record its ontology touches.
+ * Shared by the busy-sibling path and the debounced automatic path, so both
+ * hand their thread to the next run instead of leaving it unfilled.
+ */
+async function queuePayload(liveRoot, payload) {
+    const siblingRoot = path.join(liveRoot, "workspace", "checkpoints", "sibling");
+    fs.mkdirSync(siblingRoot, { recursive: true });
+    const depth = appendPending(path.join(siblingRoot, "pending.jsonl"), payload);
+    try {
+        const { recordQueuedTouches } = await import("../lib/checkpoint-ontology/queued-touches.js");
+        recordQueuedTouches(liveRoot, payload.company, payload.files, new Date());
+    }
+    catch {
+        // Queued touches only help a later ontology plan; they must never fail
+        // the checkpoint itself.
+    }
+    return depth;
+}
 /**
  * Take ownership of the queued payloads by renaming the queue aside.
  *
@@ -1369,15 +1391,7 @@ async function startSibling(liveRoot, input, threadPath, backend) {
     const activePid = existingSiblingPid(lockPath, Date.now());
     fs.mkdirSync(siblingRoot, { recursive: true });
     if (activePid !== null) {
-        const depth = appendPending(pendingPath, payload);
-        try {
-            const { recordQueuedTouches } = await import("../lib/checkpoint-ontology/queued-touches.js");
-            recordQueuedTouches(liveRoot, payload.company, payload.files, new Date());
-        }
-        catch {
-            // Queued touches only help a later ontology plan; they must never fail
-            // the checkpoint itself.
-        }
+        const depth = await queuePayload(liveRoot, payload);
         printResult(`checkpoint: sibling busy — payload queued (${depth} pending)`);
         return;
     }
@@ -1579,7 +1593,13 @@ async function runCheckpoint(options, command, group, preResolvedHqRoot) {
                 printResult(`checkpoint: sibling disabled (${SIBLING_SETTING})`);
             }
             else if (autoDebounced) {
-                printResult("checkpoint: sibling skipped (automatic checkpoint; one ran for this session recently)");
+                // feedback_a2a5c2c3: the debounce limits how many siblings start, but
+                // the thread still needs filling. Queue it once; the next sibling run
+                // claims it. The debounce stamp is not refreshed, so the window still
+                // closes on schedule and the next automatic checkpoint starts a run.
+                const depth = await queuePayload(liveRoot, siblingPayload(input, threadPath, "none"));
+                printResult("checkpoint: sibling skipped (automatic checkpoint; one ran for this session recently)" +
+                    ` — payload queued (${depth} pending)`);
             }
             else if (backend === "none") {
                 printResult("checkpoint: sibling disabled (backend none)");

package/dist/commands/core-delegate-w1b.js

@@ -1079,7 +1079,8 @@ function runSend(args, context) {
         catch {
             return fail("send", "could not persist sending state; no DM attempted");
         }
-        const dm = runHq(["dm", principal, headline, "--prompt-file", prompt, "--details-file", brief], context);
+        // The pickup DM is read by the person and acted on by their agent.
+        const dm = runHq(["dm", principal, headline, "--audience", "both", "--prompt-file", prompt, "--details-file", brief], context);
         if (dm.code !== 0)
             return fail("send", "hq dm delivery outcome is uncertain; status is sending, inspect DM history before retrying");
         const event = /eventId[: ]+([A-Za-z0-9_-]+)/.exec(dm.stdout ?? "")?.[1] ?? "";

package/dist/commands/core-dm-bind-native.js

@@ -579,6 +579,8 @@ async function post(d, args) {
         const versionError = requireCliVersion(d);
         if (versionError)
             return versionError;
+        // An automated status post keeps the channel default (agent audience); only a
+        // reply to a message a person wrote is for humans.
         const call = ["dm", ch, ...(root ? ["--thread", root] : []), cliMessage];
         const sent = d.runHq(call, { ...d.env, HQ_ROOT: d.root });
         if (sent.code !== 0)
@@ -594,7 +596,7 @@ async function post(d, args) {
         const mentions = mentionsJson(d, sid, names);
         if (!mentions.length)
             return fail("no mention resolved to a channel member id — not posting an update that notifies nobody");
-        const payload = { body: postedMessage, mentions };
+        const payload = { body: postedMessage, mentions, audience: "agent" };
         if (root)
             payload.rootEventId = root;
         try {

package/dist/commands/dm.d.ts

@@ -1,4 +1,6 @@
 import { Command } from "commander";
+import { defaultAudienceFor, recipientKindOf, type DmRecipientKind } from "../lib/notify-recipient.js";
+export { defaultAudienceFor, recipientKindOf, type DmRecipientKind };
 import { type DmAttachmentWire } from "./dm-attach.js";
 export interface DmRecipient {
     toEmail?: string;
@@ -158,7 +160,8 @@ export declare function resolveMentions(tokens: string[], members: ChannelMember
  * Returns null on anything that doesn't match. Pure → unit-testable.
  */
 export declare function parseDuration(input: string): number | null;
-type DmAudience = "human" | "agent" | "both";
+import type { DmAudience } from "../lib/notify-recipient.js";
+export type { DmAudience };
 export interface DmSendBody {
     toEmail?: string;
     toPersonUid?: string;
@@ -233,6 +236,15 @@ export declare function fetchChannels(token: string): Promise<ChannelSummary[]>;
  * post itself passes. Used to resolve `@name` mentions into participant uids.
  */
 export declare function fetchChannelMembers(token: string, channelId: string): Promise<ChannelMember[]>;
+/**
+ * Resolve the audience for a send. The default comes from the recipient kind
+ * (`defaultAudienceFor`); `--for-human` maps to `human`; an explicit
+ * `--audience` wins over `--for-human` (with a warning) and is validated.
+ */
+export declare function resolveSendAudience(opts: {
+    audience?: string;
+    forHuman?: boolean;
+}, recipientKind: DmRecipientKind, warn?: (msg: string) => void): string;
 /** One incoming DM as returned by GET /v1/notify/inbox. */
 export interface DmInboxEvent {
     eventId: string;
@@ -411,5 +423,4 @@ export declare function formatChannelTranscript(messages: ChannelMessageItem[],
 export declare function agentCallerUid(token: string, machine?: () => boolean): string | null;
 export declare const AGENT_THREAD_UNAVAILABLE: string;
 export declare function registerDmCommand(program: Command): void;
-export {};
 //# sourceMappingURL=dm.d.ts.map

package/dist/commands/dm.js

@@ -5,7 +5,8 @@ import { resolveDestinationCompanyUid, vaultApiFetch } from "../utils/vault-api.
 import { isMachineIdentity } from "@indigoai-us/hq-cloud";
 import { peekIdToken } from "../utils/id-token.js";
 import { redactAgentInboxItem as redactInboxCredentials } from "../lib/agent-kit/inbox-redact.js";
-import { EMAIL_PATTERN, RECIPIENT_UID_PATTERN } from "../lib/notify-recipient.js";
+import { EMAIL_PATTERN, RECIPIENT_UID_PATTERN, defaultAudienceFor, recipientKindOf, } from "../lib/notify-recipient.js";
+export { defaultAudienceFor, recipientKindOf };
 import { dmForwardCliEnabled } from "./dm-forward-flag.js";
 import { attachmentScopeForChannel, formatUploadedAttachments, personalScopeForCaller, uploadDmAttachments, validateAttachmentPaths, } from "./dm-attach.js";
 import { ChannelNotFoundError, suggestChannels, withChannelSuggestions, } from "./channel-suggest.js";
@@ -555,7 +556,7 @@ async function runConnectionAction(action, identifier) {
  * the server's idempotent participant-key dedupe) a group channel, then posts
  * the message into it. Reuses the same vault API client + auth as the 1:1 path.
  */
-async function runGroupSend(recipients, message) {
+async function runGroupSend(recipients, message, audience) {
     try {
         const participants = [];
         for (const r of recipients) {
@@ -601,7 +602,7 @@ async function runGroupSend(recipients, message) {
             token,
             path: `/v1/notify/channels/${encodeURIComponent(channelId)}/messages`,
             method: "POST",
-            body: { body },
+            body: { body, ...(audience ? { audience } : {}) },
         });
         if (!sendRes.ok) {
             const err = (await sendRes.json().catch(() => ({})));
@@ -810,11 +811,41 @@ async function runChannelSend(channelName, message, opts) {
         process.exit(1);
     }
 }
-async function runDmSend(recipient, message, opts) {
+function explicitAudience(opts) {
+    const explicit = opts.audience !== undefined && opts.audience !== "" ? opts.audience : undefined;
+    if (explicit !== undefined && !DM_AUDIENCE_VALUES.includes(explicit)) {
+        throw new Error("Invalid --audience '" + explicit + "': must be human, agent, or both.");
+    }
+    return explicit;
+}
+/**
+ * Resolve the audience for a send. The default comes from the recipient kind
+ * (`defaultAudienceFor`); `--for-human` maps to `human`; an explicit
+ * `--audience` wins over `--for-human` (with a warning) and is validated.
+ */
+export function resolveSendAudience(opts, recipientKind, warn = (m) => console.error(chalk.yellow(m))) {
+    const explicit = explicitAudience(opts);
+    if (explicit !== undefined) {
+        if (opts.forHuman) {
+            warn("Both --audience " + explicit + " and --for-human were passed; using --audience " + explicit + ".");
+        }
+        return explicit;
+    }
+    return opts.forHuman ? "human" : defaultAudienceFor(recipientKind);
+}
+async function runDmSend(recipient, message, rawOpts) {
+    // Validate an explicit --audience before any network call; the default is
+    // applied once the recipient kind is known.
+    explicitAudience(rawOpts);
+    const opts = { ...rawOpts };
+    const withAudience = (kind) => ({
+        ...rawOpts,
+        audience: resolveSendAudience(rawOpts, kind),
+    });
     // --channel <name> is an explicit channel target; the positional carries the
     // message (recipient slot), e.g. `hq dm --channel vyg-dev "hello"`.
     if (opts.channel !== undefined) {
-        await runChannelSend(opts.channel, message ?? recipient, opts);
+        await runChannelSend(opts.channel, message ?? recipient, withAudience("channel"));
         return;
     }
     if (recipient === undefined) {
@@ -837,7 +868,7 @@ async function runDmSend(recipient, message, opts) {
             process.exit(1);
             return;
         }
-        await runGroupSend(group, message);
+        await runGroupSend(group, message, withAudience("group").audience);
         return;
     }
     // A bare name or #hash addresses a named DM channel.
@@ -849,12 +880,13 @@ async function runDmSend(recipient, message, opts) {
             ? null
             : matchContactByName(await fetchContacts(await ensureCognitoToken()), channelName);
         if (!person?.personUid) {
-            await runChannelSend(channelName, message, opts);
+            await runChannelSend(channelName, message, withAudience("channel"));
             return;
         }
         console.log(chalk.dim(`Resolved '${channelName}' to person ${person.displayName || person.email || person.personUid} (${person.personUid}). Use '#${channelName}' or --channel ${channelName} to post to a channel instead.`));
         recipient = person.personUid;
     }
+    Object.assign(opts, withAudience(recipientKindOf(recipient)));
     if (opts.thread !== undefined) {
         console.error(chalk.red("--thread is only supported for channel messages (hq dm <channel> --thread <eventId|last> \"…\")."));
         process.exit(1);
@@ -1697,7 +1729,7 @@ async function runDmChannel(target, opts) {
 export function registerDmCommand(program) {
     const dm = program
         .command("dm")
-        .description("Send and read direct messages, and manage connection requests.");
+        .description("Send and read direct messages, and manage connection requests. Messages to a person send to them; messages to an agent, a channel or a group are tagged for agents and folded away from people by default. Pass --for-human or --audience human|agent|both to override.");
     dm
         .command("send [recipient] [message]", { isDefault: true, hidden: true })
         .description('Send a direct message. RECIPIENT can be a person (email, personUid, or agentUid), a GROUP DM (comma-separated: "a@x.com,b@y.com"), or one of your DM CHANNELS by name — bare (hq dm vyg-dev "hi"), hash form (hq dm "#vyg-dev" "hi"), or via --channel (hq dm --channel vyg-dev "hi"). A person receives a DM as an HQ Sync notification; an agent receives it in its durable box inbox. If you aren\'t connected yet, it sends a connection request that holds your message. See your channels with `hq channels`.\n\nCHANNEL MENTIONS: HQ mentions are structured — the server never reads `@name` out of your text, so a channel message has to carry the participants alongside the body. When you write `@name` in a channel message, this command looks the name up in the channel roster (case-insensitive on display name and slug/handle; quote multi-word names as @"Jacob Posel") and sends it as a real mention, which notifies people and wakes agents. If a name is unknown or matches more than one member, the send FAILS with the candidates instead of posting something that mentions nobody. A bare "@" or an email address in your prose is never treated as a mention. Pass --no-mentions to post the text literally.\n\nCHANNEL THREADS: `hq dm <channel> --thread <eventId> "…"` replies under an existing root (the request carries rootEventId). `--thread last` replies to your most recent top-level message in that channel. Copy a root eventId from `hq dm channel <name>`, which prints each root\'s id and indents replies underneath.')
@@ -1710,7 +1742,8 @@ export function registerDmCommand(program) {
         .option("--details-file <path>", "Read the details from a file (1:1 DMs; channel sends also supported)")
         .option("--at <iso>", "Schedule delivery at an ISO8601 time (store-and-forward; delivered within ~60s of the time; 1:1 DMs only)")
         .option("--in <duration>", "Schedule delivery after a relative delay: 30s, 10m, 2h, 1d (1:1 DMs only)")
-        .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both")
+        .option("--audience <human|agent|both>", "Tag who this message is for: human (a person must read it), agent (progress/status, hidden from humans by default), or both. Default: human for a person, agent for an agent, a channel or a group. Wins over --for-human.")
+        .option("--for-human", "Tag the message for people (alias for --audience human).")
         .option("--attach <path>", "Upload a local file and attach it to the message (repeatable, up to 5 files, 25 MB each). 1:1 DMs and named channels; the file lands in the conversation's vault scope and the recipient can open it. Not available for group DMs or scheduled sends.", (value, previous = []) => [...previous, value])
         .action(async (recipient, message, opts) => {
         await runDmSend(recipient, message, opts);

package/dist/commands/feedback.js

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import { ensureCognitoToken, loadCachedTokens } from "../utils/cognito-session.js";
 import { assertVaultApiRequestSupported, vaultApiFetch, } from "../utils/vault-api.js";
 import { collectDiagnostics } from "../utils/feedback-diagnostics.js";
+import { scrubDiagnosticsString, scrubDiagnosticsValue } from "../utils/scrub-diagnostics.js";
 import { MAX_SCREENSHOTS, uploadScreenshots } from "../utils/feedback-screenshots.js";
 import { FEEDBACK_LOGS_MAX_TOTAL_BYTES, FEEDBACK_LOGS_MIN_USEFUL_BYTES, collectFeedbackLogs, feedbackLogsEnabled, } from "../utils/feedback-logs.js";
 import { uploadLogBundle } from "../utils/feedback-log-bundle.js";
@@ -79,8 +80,10 @@ export function resolveFeedbackReporter(env = process.env, isTTY = process.stdin
 function buildFeedbackRequestBody(opts) {
     const requestBody = {
         type: opts.type,
-        title: opts.title,
-        body: opts.body,
+        // Title and body are free text, and /hq-bug puts tool output in the body,
+        // so they get the same credential scrub as diagnostics.
+        title: scrubDiagnosticsString(opts.title),
+        body: scrubDiagnosticsString(opts.body),
         diagnostics: opts.diagnostics,
     };
     if (opts.reporterMark) {
@@ -157,7 +160,12 @@ export async function submitFeedback(opts) {
     // Keep submitFeedback safe for direct callers as well as the command path,
     // which invokes the same validator before uploading any attachments.
     validateFeedbackContent(opts.title, opts.body);
-    const diagnostics = opts.diagnostics ?? collectDiagnostics();
+    // Scrub here, at the one point every submission passes through. Callers may
+    // hand in their own diagnostics (the command path collects them before
+    // uploads, and adds latestVersion afterwards), and a caller-supplied blob
+    // previously skipped redaction entirely. The scrubbed copy is the object
+    // attachDebugLogs later mutates, so inline logs still land in the request.
+    const diagnostics = scrubDiagnosticsValue(opts.diagnostics ?? collectDiagnostics());
     const reporterMark = opts.type === "bug" && resolveProcessFlagGate(FEEDBACK_REPORTER_KIND_FLAG, { fallback: FEEDBACK_REPORTER_KIND_FLAG_FALLBACK }, () => FEEDBACK_REPORTER_KIND_FLAG_FALLBACK)
         ? resolveFeedbackReporter(process.env, process.stdin.isTTY === true, opts.reporterOverride)
         : undefined;

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

@@ -17,7 +17,7 @@
  */
 import { CLI_VERSION } from "../../../cli-version.js";
 import { peekIdToken } from "../../../utils/id-token.js";
-import { isRecipientUid } from "../../../lib/notify-recipient.js";
+import { defaultAudienceFor, isAgentUid, isRecipientUid } from "../../../lib/notify-recipient.js";
 import { redactAgentInboxItem } from "../inbox-redact.js";
 import { markInboxDone, mergeAgentInbox, readDoneIds, summarizeInboxEntry } from "../inbox-state.js";
 import { AttachmentCompanyUnresolvedError, fetchChatAttachment } from "./attachments.js";
@@ -214,13 +214,13 @@ export function buildAgentMcpTools(clients) {
         },
         {
             name: "hq_dm_send",
-            description: "Send an HQ message as this agent to a person (email or prs_…), an agent (agt_…), or a channel or group DM (chn_…). When replying to an inbox item that has a channelId, pass that channelId as `to` so the answer lands in the conversation it came from. Use audience='agent' for progress/status messages that only agents need to see; audience='human' for messages a person must read; audience='both' when unsure.",
+            description: "Send an HQ message as this agent to a person (email or prs_…), an agent (agt_…), or a channel or group DM (chn_…). When replying to an inbox item that has a channelId, pass that channelId as `to` so the answer lands in the conversation it came from. Use audience='agent' for progress/status messages that only agents need to see; audience='human' for messages a person must read; audience='both' when unsure. Default: human for a person, agent for an agent, a channel or a group.",
             inputSchema: {
                 type: "object",
                 properties: {
                     to: { type: "string", description: "Email, prs_… or agt_… uid, or a chn_… channel id" },
                     message: { type: "string" },
-                    audience: { type: "string", enum: ["human", "agent", "both"], description: "Who this message is for (default: human)" },
+                    audience: { type: "string", enum: ["human", "agent", "both"], description: "Who this message is for (default: human for a person, agent for an agent, channel or group)" },
                 },
                 required: ["to", "message"],
                 additionalProperties: false,
@@ -238,7 +238,7 @@ export function buildAgentMcpTools(clients) {
                     const token = await clients.getToken();
                     const res = await clients.apiJson(token, `/v1/notify/channels/${encodeURIComponent(to)}/messages`, {
                         method: "POST",
-                        body: { body: message, ...(audience ? { audience } : {}) },
+                        body: { body: message, audience: audience ?? defaultAudienceFor("channel") },
                     });
                     if (res.status < 200 || res.status >= 300) {
                         return errorResult(`Channel send failed (${res.status}): ${describeError(res.body)}`);
@@ -252,8 +252,7 @@ export function buildAgentMcpTools(clients) {
                         : (() => {
                             throw new McpToolInputError('"to" must be an email, prs_… or agt_… uid, or a chn_… channel id');
                         })();
-                if (audience)
-                    body.audience = audience;
+                body.audience = audience ?? defaultAudienceFor(isAgentUid(to) ? "agent" : "person");
                 const token = await clients.getToken();
                 const res = await clients.apiJson(token, "/v1/notify/dm", { method: "POST", body });
                 if (res.status < 200 || res.status >= 300) {

package/dist/lib/doctor/checks/sync-health.d.ts

@@ -116,6 +116,13 @@ export interface SyncHealthDeps {
      * since a re-upload would exit 0 without uploading.
      */
     manifestUploadsDisabled?: () => boolean;
+    /**
+     * Start time (epoch ms) of a live background `hq doctor --fix` pull for
+     * this refresh target (a company slug, or `personal`), or null. A journal
+     * whose refresh is still running is reported "refresh in progress" rather
+     * than stale (feedback cd56a501).
+     */
+    refreshInProgress?: (fixTarget: string) => number | null;
 }
 /**
  * True when `slug` is a filesystem-safe company folder name. Rejects empty
@@ -148,7 +155,6 @@ export declare function isPersonalJournalSlug(slug: string): boolean;
 export declare function journalSlugFromCheckId(checkId: string): string | null;
 /** The versions/sync check family. Registered in `createDefaultRegistry`. */
 export declare const syncHealthFamily: CheckFamily;
-/** Run every versions/sync check. A thrown check degrades to UNKNOWN. */
 export declare function checkSyncHealth(context: CheckContext, rawDeps?: SyncHealthDeps): CheckResult[];
 /** True when `a` > `b` for plain X.Y.Z versions. Non-numeric parts compare 0. */
 export declare function semverGt(a: string, b: string): boolean;

package/dist/lib/doctor/checks/sync-health.js

@@ -25,6 +25,8 @@
  */
 import { defaultSyncRuntimeResults } from "./sync-runtime.js";
 import * as fs from "node:fs";
+import { DEFAULT_OWNER_IDENTITY } from "../fix/process-identity.js";
+import { REFRESH_SPAWN_LOCK_WARN_MS, inspectRefreshSpawnLock, refreshHandoffStartedAt, } from "../fix/refresh-sync-handoff.js";
 import * as path from "node:path";
 // Namespace import, deliberately: hq-cloud is an ESM package, so a static
 // NAMED import of an export the installed version lacks is a link-time
@@ -63,6 +65,8 @@ function withDefaults(deps, hqRoot) {
         companySyncResolvable: deps.companySyncResolvable ??
             ((slug, lastSync) => !companyRecordedNotResolved(hqRoot, slug, deps.now().getTime(), lastSync)),
         manifestUploadsDisabled: deps.manifestUploadsDisabled ?? (() => manifestUploadsDisabled()),
+        refreshInProgress: deps.refreshInProgress ??
+            ((fixTarget) => refreshHandoffStartedAt(hqRoot, fixTarget, deps.now().getTime())),
     };
 }
 /**
@@ -294,6 +298,36 @@ export const syncHealthFamily = {
     run: (context) => Promise.resolve(checkSyncHealth(context)),
 };
 /** Run every versions/sync check. A thrown check degrades to UNKNOWN. */
+/**
+ * WARN when the `hq doctor --fix` spawn lock has been held for over
+ * {@link REFRESH_SPAWN_LOCK_WARN_MS}, naming the holder pid, so a stalled or
+ * suspended holder is visible. Report only: the lock is never removed here.
+ */
+function refreshSpawnLockResult(hqRoot, nowMs) {
+    let lock;
+    try {
+        lock = inspectRefreshSpawnLock(hqRoot, nowMs, DEFAULT_OWNER_IDENTITY);
+    }
+    catch {
+        return [];
+    }
+    if (!lock || lock.heldMs === null || lock.heldMs <= REFRESH_SPAWN_LOCK_WARN_MS)
+        return [];
+    // Left by a claimer that has exited: nothing to stop, and the next
+    // `hq doctor --fix` releases it.
+    if (lock.ownerGone)
+        return [];
+    const minutes = Math.floor(lock.heldMs / 60_000);
+    return [
+        {
+            status: "WARN",
+            checkId: "sync.refresh.spawn-lock",
+            reasonCode: "refresh-lock-held",
+            message: `The hq doctor --fix refresh lock has been held for ${minutes} minutes by process ${lock.pid}. No new journal refresh can start until it is released.`,
+            remediation: `If process ${lock.pid} is stuck or suspended, resume or stop it; the lock is released when it exits.`,
+        },
+    ];
+}
 export function checkSyncHealth(context, rawDeps = DEFAULT_DEPS) {
     const deps = withDefaults(rawDeps, context.hqRoot);
     try {
@@ -301,6 +335,7 @@ export function checkSyncHealth(context, rawDeps = DEFAULT_DEPS) {
             ...versionResults(context, deps),
             ...updateAvailabilityResult(context, deps),
             ...journalAndManifestResults(deps),
+            ...refreshSpawnLockResult(context.hqRoot, deps.now().getTime()),
             ...deps.runtime(deps.now()),
         ];
     }
@@ -528,7 +563,7 @@ function journalResults(deps, journals) {
         if (entry.slug === PERSONAL_SCOPE_SLUG) {
             results.push(leftoverPersonalJournalResult(entry));
             if (!hasPersonalVaultJournal) {
-                results.push(journalFreshnessResult(entry, PERSONAL_VAULT_SCOPE_SLUG, nowMs));
+                results.push(withRefreshInProgress(deps, journalFreshnessResult(entry, PERSONAL_VAULT_SCOPE_SLUG, nowMs), "personal"));
             }
             continue;
         }
@@ -570,10 +605,40 @@ function journalResults(deps, journals) {
             results.push(notOnThisMachineResult(entry, checkId));
             continue;
         }
-        results.push(freshness);
+        results.push(withRefreshInProgress(deps, freshness, isPersonalJournalSlug(entry.slug) ? "personal" : entry.slug));
     }
     return results;
 }
+/**
+ * A stale or never-synced journal whose `hq doctor --fix` pull is still
+ * running in the background is UNTESTED "refresh in progress", not WARN.
+ * The pull records lastSync only when it finishes, so until then the journal
+ * looks stale even though the repair is under way. Once the process is gone
+ * the record no longer counts and the WARN comes back, so a pull that died is
+ * retried by the next `--fix`.
+ */
+function withRefreshInProgress(deps, result, fixTarget) {
+    if (result.status !== "WARN")
+        return result;
+    if (result.reasonCode !== "stale-threshold" && result.reasonCode !== "never-synced")
+        return result;
+    let startedAtMs;
+    try {
+        startedAtMs = deps.refreshInProgress(fixTarget);
+    }
+    catch {
+        return result;
+    }
+    if (startedAtMs === null)
+        return result;
+    return {
+        status: "UNTESTED",
+        checkId: result.checkId,
+        reasonCode: "refresh-in-progress",
+        ...(result.target ? { target: result.target } : {}),
+        message: `${result.message} hq doctor --fix is refreshing it in the background (started ${new Date(startedAtMs).toISOString()}); it passes when that pull finishes.`,
+    };
+}
 function companySyncResolvable(deps, slug, lastSync) {
     try {
         return deps.companySyncResolvable(slug, lastSync);