@indigoai-us/hq-cli 5.345.166 → 5.345.168

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+## [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-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/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/notify-recipient.d.ts

@@ -4,4 +4,19 @@ export declare const AGENT_UID_PATTERN: RegExp;
 export declare const EMAIL_PATTERN: RegExp;
 export declare function isRecipientUid(value: string): boolean;
 export declare function isAgentUid(value: string): boolean;
+/** Who a notify message is for. */
+export type DmAudience = "human" | "agent" | "both";
+/** What a send is addressed to, for the default audience. */
+export type DmRecipientKind = "person" | "agent" | "channel" | "group";
+/**
+ * Classify a single 1:1 recipient (email, prs_ or agt_ uid) for the default
+ * audience. Anything that is not an agent uid is a person.
+ */
+export declare function recipientKindOf(recipient: string): "person" | "agent";
+/**
+ * Default audience by recipient: a 1:1 message to a person is for that
+ * person (`human`); a message to an agent, a channel or a group is tagged
+ * `agent` and folded away from people by default.
+ */
+export declare function defaultAudienceFor(kind: DmRecipientKind): DmAudience;
 //# sourceMappingURL=notify-recipient.d.ts.map

package/dist/lib/notify-recipient.js

@@ -8,4 +8,19 @@ export function isRecipientUid(value) {
 export function isAgentUid(value) {
     return AGENT_UID_PATTERN.test(value.trim());
 }
+/**
+ * Classify a single 1:1 recipient (email, prs_ or agt_ uid) for the default
+ * audience. Anything that is not an agent uid is a person.
+ */
+export function recipientKindOf(recipient) {
+    return /^agt_/.test(recipient.trim()) ? "agent" : "person";
+}
+/**
+ * Default audience by recipient: a 1:1 message to a person is for that
+ * person (`human`); a message to an agent, a channel or a group is tagged
+ * `agent` and folded away from people by default.
+ */
+export function defaultAudienceFor(kind) {
+    return kind === "person" ? "human" : "agent";
+}
 //# sourceMappingURL=notify-recipient.js.map

package/dist/lib/secret-scan/repo-config.d.ts

@@ -26,13 +26,19 @@
  * there, because a pattern can always be widened, alone or combined with other
  * entries, to hide a real credential.
  *
- * Fails closed: anything not acceptable is a ScanConfigError, and the scan
- * exits 2 rather than running with a guess.
+ * An allowlist that is not acceptable is an InvalidAllowlistError. The scan
+ * then warns and runs with no repo allowlist at all (stricter, never looser),
+ * so a rejected file cannot block the commit that replaces it. Other config
+ * problems, such as an unknown --allowlist-rev, are a ScanConfigError and the
+ * scan exits 2.
  */
 import { type Probe } from "./probes.js";
 import { type CompiledAllowlist } from "./rules.js";
 export declare class ScanConfigError extends Error {
 }
+/** The repo's .gitleaks.toml cannot be used; the scan ignores it (see the top of the file). */
+export declare class InvalidAllowlistError extends ScanConfigError {
+}
 export declare const REPO_CONFIG_FILE = ".gitleaks.toml";
 /**
  * The first probe credential the allowlist would hide, judged as the detector

package/dist/lib/secret-scan/repo-config.js

@@ -26,8 +26,11 @@
  * there, because a pattern can always be widened, alone or combined with other
  * entries, to hide a real credential.
  *
- * Fails closed: anything not acceptable is a ScanConfigError, and the scan
- * exits 2 rather than running with a guess.
+ * An allowlist that is not acceptable is an InvalidAllowlistError. The scan
+ * then warns and runs with no repo allowlist at all (stricter, never looser),
+ * so a rejected file cannot block the commit that replaces it. Other config
+ * problems, such as an unknown --allowlist-rev, are a ScanConfigError and the
+ * scan exits 2.
  */
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -38,6 +41,9 @@ import { credentialProbes } from "./probes.js";
 import { compileAllowlist, compiledRules } from "./rules.js";
 export class ScanConfigError extends Error {
 }
+/** The repo's .gitleaks.toml cannot be used; the scan ignores it (see the top of the file). */
+export class InvalidAllowlistError extends ScanConfigError {
+}
 export const REPO_CONFIG_FILE = ".gitleaks.toml";
 const KEYS = new Set(["description", "condition", "regexTarget", "paths", "regexes", "stopwords", "commits", "targetRules"]);
 const MIN_PATH_PREFIX = 3;
@@ -68,7 +74,7 @@ export function suppressedProbe(al) {
     return probes.find((p, i) => probeBaseline[i] && scanFragment(probeFragment(p.line), rules).length === 0);
 }
 function fail(file, where, msg) {
-    throw new ScanConfigError(`${file}: ${where}: ${msg}`);
+    throw new InvalidAllowlistError(`${file}: ${where}: ${msg}`);
 }
 function stringList(file, where, key, v) {
     if (v === undefined)
@@ -292,7 +298,7 @@ function parseToml(text, file) {
         return parse(text);
     }
     catch (err) {
-        throw new ScanConfigError(`${file}: could not be parsed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
+        throw new InvalidAllowlistError(`${file}: could not be parsed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`);
     }
 }
 function git(repoRoot, args) {
@@ -313,10 +319,10 @@ function entry(out, blobField) {
 }
 function readEntry(repoRoot, e, where) {
     if (e.mode === "120000")
-        throw new ScanConfigError(`${REPO_CONFIG_FILE} (${where}) is a symlink; commit a regular file`);
+        throw new InvalidAllowlistError(`${REPO_CONFIG_FILE} (${where}) is a symlink; commit a regular file`);
     const text = git(repoRoot, ["cat-file", "blob", e.blob]);
     if (text === null)
-        throw new ScanConfigError(`${REPO_CONFIG_FILE} (${where}) could not be read from git`);
+        throw new InvalidAllowlistError(`${REPO_CONFIG_FILE} (${where}) could not be read from git`);
     return text;
 }
 /**

package/dist/lib/secret-scan/staged.d.ts

@@ -13,6 +13,12 @@ export interface ParsedDiff {
 export declare function parseUnifiedDiff(diff: string): ParsedDiff;
 export declare function stagedDiff(cwd: string): string;
 export declare function repoRoot(cwd: string): string;
+/**
+ * The repo's allowlists, or none when its .gitleaks.toml is rejected. The
+ * warning is fixed text: a validation message can quote a path or other
+ * entry, and an entry can hold a credential.
+ */
+export declare const ALLOWLIST_IGNORED_WARNING = "HQ secret scan: warning: the repo .gitleaks.toml allowlist was rejected; ignoring it and scanning with no repo allowlist";
 /**
  * Built-in rules plus the repo's own .gitleaks.toml allowlists. Diff paths are
  * relative to the repo root, as gitleaks' allowlist paths are.

package/dist/lib/secret-scan/staged.js

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { scanFragment, scanPath } from "./detect.js";
-import { loadCommittedAllowlists, loadRepoAllowlists } from "./repo-config.js";
+import { InvalidAllowlistError, loadCommittedAllowlists, loadRepoAllowlists } from "./repo-config.js";
 import { compiledRules } from "./rules.js";
 export class ScanInputError extends Error {
 }
@@ -101,13 +101,31 @@ export function repoRoot(cwd) {
         throw new ScanInputError(`could not find the repo root: ${detail || "git rev-parse failed"}`);
     }
 }
+/**
+ * The repo's allowlists, or none when its .gitleaks.toml is rejected. The
+ * warning is fixed text: a validation message can quote a path or other
+ * entry, and an entry can hold a credential.
+ */
+export const ALLOWLIST_IGNORED_WARNING = "HQ secret scan: warning: the repo .gitleaks.toml allowlist was rejected; ignoring it and scanning with no repo allowlist";
+function repoAllowlistsOrNone(load) {
+    try {
+        return load();
+    }
+    catch (err) {
+        if (!(err instanceof InvalidAllowlistError))
+            throw err;
+        process.stderr.write(`${ALLOWLIST_IGNORED_WARNING}\n`);
+        return [];
+    }
+}
 /**
  * Built-in rules plus the repo's own .gitleaks.toml allowlists. Diff paths are
  * relative to the repo root, as gitleaks' allowlist paths are.
  */
 export function scanStaged(cwd) {
     const diff = stagedDiff(cwd);
-    const rules = { ...compiledRules(), repo: loadRepoAllowlists(repoRoot(cwd)) };
+    const root = repoRoot(cwd);
+    const rules = { ...compiledRules(), repo: repoAllowlistsOrNone(() => loadRepoAllowlists(root)) };
     const { fragments, binaryFiles } = parseUnifiedDiff(diff);
     return [...fragments.flatMap((f) => scanFragment(f, rules)), ...binaryFiles.flatMap((f) => scanPath(f, rules))];
 }
@@ -145,7 +163,7 @@ function matchPath(p, repo, snapshotRoot) {
 }
 export function scanFiles(paths, opts = {}) {
     const root = opts.repo !== undefined ? repoRoot(opts.repo) : undefined;
-    const rules = root !== undefined ? { ...compiledRules(), repo: loadCommittedAllowlists(root, opts.allowlistRev) } : compiledRules();
+    const rules = root !== undefined ? { ...compiledRules(), repo: repoAllowlistsOrNone(() => loadCommittedAllowlists(root, opts.allowlistRev)) } : compiledRules();
     const repo = root !== undefined ? real(root) : undefined;
     const snapshotRoot = opts.snapshotRoot !== undefined ? real(opts.snapshotRoot) : undefined;
     const out = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.166",
+  "version": "5.345.168",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -114,11 +114,11 @@
     "*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}": "eslint --cache --no-error-on-unmatched-pattern"
   },
   "optionalDependencies": {
-    "@indigoai-us/hq-hook-win32-x64": "5.345.166",
-    "@indigoai-us/hq-hook-win32-arm64": "5.345.166",
-    "@indigoai-us/hq-hook-darwin-x64": "5.345.166",
-    "@indigoai-us/hq-hook-darwin-arm64": "5.345.166",
-    "@indigoai-us/hq-hook-linux-x64": "5.345.166",
-    "@indigoai-us/hq-hook-linux-arm64": "5.345.166"
+    "@indigoai-us/hq-hook-win32-x64": "5.345.168",
+    "@indigoai-us/hq-hook-win32-arm64": "5.345.168",
+    "@indigoai-us/hq-hook-darwin-x64": "5.345.168",
+    "@indigoai-us/hq-hook-darwin-arm64": "5.345.168",
+    "@indigoai-us/hq-hook-linux-x64": "5.345.168",
+    "@indigoai-us/hq-hook-linux-arm64": "5.345.168"
   }
 }