@indigoai-us/hq-cli 5.182.0 → 5.183.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [5.183.0] — 2026-09-25
+
+### Added
+
+- `hq core sentry report` can attach bounded hook-timeout timing context to Sentry events when the company-scoped `hook-timeout-debug-context` flag is enabled. The flag defaults off.
+
 ## [5.182.0] — 2026-09-24
 
 ### Fixed

package/dist/lib/core-utils/hook-timeout-debug-context-flag.d.ts

@@ -0,0 +1,20 @@
+import { type FlagClient, type FlagClientOptions } from "@indigoai-us/hq-flags-client";
+export declare const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG = "hook-timeout-debug-context";
+export declare const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK = false;
+export declare const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS = 150;
+type DebugContextFlagClient = Pick<FlagClient, "ready" | "isEnabled" | "close">;
+export interface HookTimeoutDebugContextFlagDependencies {
+    env?: NodeJS.ProcessEnv;
+    createClient?: (options: FlagClientOptions) => DebugContextFlagClient;
+    getToken?: FlagClientOptions["getToken"];
+    fetch?: typeof fetch;
+    reportFailure?: (error: unknown) => void;
+}
+/**
+ * Read the optional diagnostic gate with a short, cancellable hq-flags request.
+ * Missing identity/configuration and every client failure use the default-off
+ * result so a flag outage cannot delay or suppress the underlying timeout.
+ */
+export declare function hookTimeoutDebugContextEnabled(dependencies?: HookTimeoutDebugContextFlagDependencies, callerSignal?: AbortSignal): Promise<boolean>;
+export {};
+//# sourceMappingURL=hook-timeout-debug-context-flag.d.ts.map

package/dist/lib/core-utils/hook-timeout-debug-context-flag.js

@@ -0,0 +1,80 @@
+import { loadCachedTokens } from "@indigoai-us/hq-cloud";
+import { createFlagClient, } from "@indigoai-us/hq-flags-client";
+export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG = "hook-timeout-debug-context";
+export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK = false;
+export const HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS = 150;
+function safeErrorClass(error) {
+    const name = error instanceof Error ? error.name : "UnknownError";
+    return /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(name) ? name : "UnknownError";
+}
+function reportFlagFailure(error) {
+    process.stderr.write(`HQ hook timeout debug flag lookup failed (${safeErrorClass(error)}); using default off.\n`);
+}
+function combineSignals(first, second) {
+    return first ? AbortSignal.any([first, second]) : second;
+}
+/**
+ * Read the optional diagnostic gate with a short, cancellable hq-flags request.
+ * Missing identity/configuration and every client failure use the default-off
+ * result so a flag outage cannot delay or suppress the underlying timeout.
+ */
+export async function hookTimeoutDebugContextEnabled(dependencies = {}, callerSignal) {
+    const env = dependencies.env ?? process.env;
+    const endpoint = env.HQ_FLAGS_API_URL?.trim() || "";
+    const companyUid = env.HQ_COMPANY_UID?.trim() || "";
+    if (!endpoint || !/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
+        return HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK;
+    }
+    const companySlug = env.HQ_COMPANY_SLUG?.trim() || "";
+    const deadline = AbortSignal.timeout(HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS);
+    const signal = callerSignal ? AbortSignal.any([callerSignal, deadline]) : deadline;
+    const doFetch = dependencies.fetch ?? globalThis.fetch;
+    let client;
+    let failed = false;
+    let failureReported = false;
+    let enabled = HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK;
+    const reportFailureOnce = (error) => {
+        failed = true;
+        if (failureReported)
+            return;
+        failureReported = true;
+        (dependencies.reportFailure ?? reportFlagFailure)(error);
+    };
+    try {
+        client = (dependencies.createClient ?? createFlagClient)({
+            endpoint,
+            companyUid,
+            ...(companySlug && /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/.test(companySlug)
+                ? { companyIdentifiers: [companySlug] }
+                : {}),
+            env: {},
+            getToken: dependencies.getToken ?? (() => loadCachedTokens()?.idToken ?? ""),
+            fetch: (input, init) => doFetch(input, {
+                ...init,
+                signal: combineSignals(init?.signal ?? undefined, signal),
+            }),
+            refreshIntervalMs: 0,
+            requestTimeoutMs: HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_TIMEOUT_MS,
+            onError: reportFailureOnce,
+        });
+        await client.ready();
+        if (!failed && !signal.aborted) {
+            enabled = client.isEnabled(HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG, {
+                fallback: HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK,
+            });
+        }
+    }
+    catch (error) {
+        reportFailureOnce(error);
+    }
+    finally {
+        try {
+            client?.close();
+        }
+        catch (error) {
+            reportFailureOnce(error);
+        }
+    }
+    return failed || signal.aborted ? HOOK_TIMEOUT_DEBUG_CONTEXT_FLAG_FALLBACK : enabled;
+}
+//# sourceMappingURL=hook-timeout-debug-context-flag.js.map

package/dist/lib/core-utils/sentry-report.d.ts

@@ -27,14 +27,32 @@ export declare const MAX_SENTRY_REPORT_METADATA_VALUE_BYTES = 256;
  * is owner-approved telemetry for the exact hook script and may include a
  * company directory; it is never a substitute for hook input or a transcript.
  */
-export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence"];
+export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence", "hook_timeout_debug_context"];
 export declare const MAX_SENTRY_REPORT_METADATA_KEYS: number;
 export type HookSequenceEntry = {
     script: string;
     event: string;
     ms: number;
 };
-export type SentryReportMetadataValue = string | number | boolean | HookSequenceEntry[];
+export type HookTimeoutDebugPhaseTiming = {
+    phase: string;
+    elapsed_ms: number;
+};
+export type HookTimeoutDebugContext = {
+    hook_name: string;
+    hook_event: string;
+    budget_ms: number;
+    elapsed_ms: number;
+    remaining_ms: number;
+    phase_timings: HookTimeoutDebugPhaseTiming[];
+    wait_point: string;
+    waiting_child_basename: string;
+    waiting_child_elapsed_ms: number;
+    load_average?: number | "unavailable";
+    spawn_ms?: number | "unavailable";
+    process_count?: number | "unavailable";
+};
+export type SentryReportMetadataValue = string | number | boolean | HookSequenceEntry[] | HookTimeoutDebugContext;
 export type SentryReportMetadata = Record<string, SentryReportMetadataValue>;
 export type SentryReportEvent = {
     type: string;
@@ -53,6 +71,8 @@ export type SentryReportOptions = {
     rateLimitDirectory?: string;
     /** Test seam for deterministic rate-limit windows. */
     rateLimitNow?: () => number;
+    /** Optional caller cancellation forwarded to the bounded flag lookup. */
+    signal?: AbortSignal;
 };
 export type SentryReportDependencies = {
     sentry: {
@@ -67,6 +87,8 @@ export type SentryReportDependencies = {
     rateLimitDirectory?: string;
     /** Test seam; production uses Date.now. */
     rateLimitNow?: () => number;
+    /** Test seam for the company-scoped, bounded debug-context gate. */
+    timeoutDebugContextEnabled?: (signal?: AbortSignal) => Promise<boolean>;
 };
 export type SentryReportResult = {
     code: 0 | 1;

package/dist/lib/core-utils/sentry-report.js

@@ -23,6 +23,7 @@ import * as Sentry from "@sentry/node";
 import { CLI_VERSION } from "../../cli-version.js";
 import { beforeSend } from "../../sentry-before-send.js";
 import { resolveLiveRoot } from "../../utils/hq-roots.js";
+import { hookTimeoutDebugContextEnabled } from "./hook-timeout-debug-context-flag.js";
 export const DEFAULT_SENTRY_REPORT_TIMEOUT_MS = 750;
 export const MAX_SENTRY_REPORT_TIMEOUT_MS = 5_000;
 export const MAX_SENTRY_REPORT_PAYLOAD_BYTES = 2_048;
@@ -47,6 +48,8 @@ const HOOK_TIMEOUT_EXCEEDED_FINGERPRINT = "hook-timeout-exceeded";
 const HOOK_TIMEOUT_WARNING_FINGERPRINT = "hook-timeout";
 const HOOK_TIMEOUT_MACHINE_WIDE_FINGERPRINT = "hq-hook-slow";
 const MAX_HOOK_SEQUENCE_ENTRIES = 20;
+const MAX_HOOK_TIMEOUT_DEBUG_PHASES = 24;
+const MAX_HOOK_TIMEOUT_DEBUG_MS = 86_400_000;
 const HOOK_TIMEOUT_RATE_LIMIT_WINDOW_MS = 10 * 60 * 1_000;
 const RATE_LIMIT_LOCK_WAIT_MS = 500;
 const RATE_LIMIT_LOCK_POLL_MS = 5;
@@ -65,6 +68,72 @@ const KNOWN_HOOK_SCRIPTS = new Set([
     "45-lanes-senior-monitor.sh",
     "lanes-senior-monitor-stop-gate.sh",
 ]);
+const DEBUG_CONTEXT_HOOK_NAMES = new Set([
+    ...KNOWN_HOOK_SCRIPTS,
+    "reindex.sh",
+]);
+const DEBUG_CONTEXT_CHILD_NAMES = new Set([
+    ...DEBUG_CONTEXT_HOOK_NAMES,
+    "bash",
+    "bash.exe",
+    "sh",
+    "cmd",
+    "cmd.exe",
+    "powershell",
+    "powershell.exe",
+    "wmic.exe",
+    "jq",
+    "jq.exe",
+    "node",
+    "node.exe",
+    "git",
+    "git.exe",
+    "python",
+    "python.exe",
+    "python3",
+    "python3.exe",
+    "true",
+    "sleep",
+    "cat",
+    "grep",
+    "sed",
+    "awk",
+    "find",
+    "timeout",
+    "curl",
+    "gh",
+    "hq",
+    "npm",
+    "pnpm",
+    "npx",
+]);
+const DEBUG_CONTEXT_HOOK_EVENTS = new Set([
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "SessionStart",
+    "SessionEnd",
+    "Stop",
+    "PreCompact",
+    "Notification",
+    "PermissionRequest",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCompleted",
+    "TeammateIdle",
+]);
+const DEBUG_CONTEXT_PHASES = new Set([
+    "startup",
+    "source",
+    "config_load",
+    "policy_load",
+    "external_command",
+    "output_write",
+    "wait",
+    "child_wait",
+    "probe",
+    "parse",
+]);
 /**
  * The only hook diagnostics that can be attached as metadata. The list omits
  * command text, prompts, payloads, company names, and repositories. `hook_path`
@@ -96,6 +165,7 @@ export const ALLOWED_SENTRY_REPORT_METADATA_KEYS = [
     "shell",
     "nproc",
     "hook_sequence",
+    "hook_timeout_debug_context",
 ];
 const ALLOWED_METADATA_KEYS = new Set(ALLOWED_SENTRY_REPORT_METADATA_KEYS);
 const SENTRY_REPORT_METADATA_KEY_HEADROOM = 2;
@@ -107,6 +177,7 @@ const defaultDependencies = {
     sentry: Sentry,
     stdout: process.stdout,
     stderr: process.stderr,
+    timeoutDebugContextEnabled: (signal) => hookTimeoutDebugContextEnabled({}, signal),
 };
 /**
  * Read no more than the accepted event size. Returning early keeps a malformed
@@ -153,6 +224,90 @@ function isHookSequenceEntry(value) {
         Number.isFinite(value.ms) &&
         value.ms >= 0);
 }
+function boundedDebugName(value, known) {
+    if (typeof value !== "string" || value.length === 0)
+        return "other";
+    return known.has(basenameFromPath(value)) ? basenameFromPath(value) : "other";
+}
+function boundedDebugPhase(value) {
+    return typeof value === "string" && DEBUG_CONTEXT_PHASES.has(value) ? value : "other";
+}
+function boundedDebugHookEvent(value) {
+    return typeof value === "string" && DEBUG_CONTEXT_HOOK_EVENTS.has(value) ? value : "other";
+}
+function boundedDebugMilliseconds(value, allowNegative = false) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    const bounded = allowNegative
+        ? Math.abs(value) <= MAX_HOOK_TIMEOUT_DEBUG_MS
+        : value >= 0 && value <= MAX_HOOK_TIMEOUT_DEBUG_MS;
+    return bounded ? value : null;
+}
+function boundedDebugProbe(value) {
+    if (value === "unavailable")
+        return value;
+    return boundedDebugMilliseconds(value) ?? undefined;
+}
+function boundedDebugPhaseTimings(value) {
+    if (!Array.isArray(value) || value.length > MAX_HOOK_TIMEOUT_DEBUG_PHASES)
+        return null;
+    const timings = [];
+    for (const entry of value) {
+        if (!isRecord(entry))
+            return null;
+        const elapsed = boundedDebugMilliseconds(entry.elapsed_ms);
+        if (elapsed === null)
+            return null;
+        const timing = {
+            phase: boundedDebugPhase(entry.phase),
+            elapsed_ms: elapsed,
+        };
+        timings.push(timing);
+    }
+    return timings;
+}
+/** Return only the closed, bounded shell-to-CLI context shape. */
+function boundedHookTimeoutDebugContext(value) {
+    if (!isRecord(value))
+        return null;
+    const budget = boundedDebugMilliseconds(value.budget_ms);
+    const elapsed = boundedDebugMilliseconds(value.elapsed_ms);
+    const remaining = boundedDebugMilliseconds(value.remaining_ms, true);
+    const childElapsed = boundedDebugMilliseconds(value.waiting_child_elapsed_ms);
+    const phaseTimings = boundedDebugPhaseTimings(value.phase_timings);
+    if (budget === null ||
+        elapsed === null ||
+        remaining === null ||
+        childElapsed === null ||
+        phaseTimings === null) {
+        return null;
+    }
+    const loadAverage = boundedDebugProbe(value.load_average);
+    const spawnMs = boundedDebugProbe(value.spawn_ms);
+    const processCount = boundedDebugProbe(value.process_count);
+    const hasLoadAverage = typeof loadAverage === "number";
+    const hasWindowsProbe = spawnMs !== undefined && processCount !== undefined;
+    if (!hasLoadAverage && !hasWindowsProbe)
+        return null;
+    if (typeof processCount === "number" &&
+        (!Number.isInteger(processCount) || processCount > 1_000_000)) {
+        return null;
+    }
+    return {
+        hook_name: boundedDebugName(value.hook_name, DEBUG_CONTEXT_HOOK_NAMES),
+        hook_event: boundedDebugHookEvent(value.hook_event),
+        budget_ms: budget,
+        elapsed_ms: elapsed,
+        remaining_ms: remaining,
+        phase_timings: phaseTimings,
+        wait_point: boundedDebugPhase(value.wait_point),
+        waiting_child_basename: boundedDebugName(value.waiting_child_basename, DEBUG_CONTEXT_CHILD_NAMES),
+        waiting_child_elapsed_ms: childElapsed,
+        ...(loadAverage !== undefined ? { load_average: loadAverage } : {}),
+        ...(spawnMs !== undefined ? { spawn_ms: spawnMs } : {}),
+        ...(processCount !== undefined ? { process_count: processCount } : {}),
+    };
+}
 function boundedHookSequence(value) {
     if (!Array.isArray(value))
         return null;
@@ -168,6 +323,8 @@ function boundedHookSequence(value) {
 function isAllowedMetadataValue(key, value) {
     if (key === "hook_sequence")
         return boundedHookSequence(value) !== null;
+    if (key === "hook_timeout_debug_context")
+        return boundedHookTimeoutDebugContext(value) !== null;
     if (!isScalarMetadataValue(value))
         return false;
     if (key === "tool_name" || key === "session_id" || key === "hook_path") {
@@ -236,9 +393,10 @@ export function parseSentryReportEvent(stdin) {
         }
         if (!isAllowedMetadataValue(key, rawMetadata[key]))
             return invalidInput();
-        metadata[key] =
-            key === "hook_sequence"
-                ? boundedHookSequence(rawMetadata[key])
+        metadata[key] = key === "hook_sequence"
+            ? boundedHookSequence(rawMetadata[key])
+            : key === "hook_timeout_debug_context"
+                ? boundedHookTimeoutDebugContext(rawMetadata[key])
                 : rawMetadata[key];
     }
     if (typeof metadata.slow_child === "string") {
@@ -319,6 +477,11 @@ function elapsedBucket(elapsedMs) {
         return "20-60s";
     return ">=60s";
 }
+function remainingBucket(remainingMs) {
+    return remainingMs < 0
+        ? `overdue-${elapsedBucket(Math.abs(remainingMs))}`
+        : elapsedBucket(remainingMs);
+}
 function loadBucket(loadAverage) {
     if (loadAverage === undefined)
         return "unknown";
@@ -368,6 +531,53 @@ function spawnMsBucket(metadata) {
         return "500-999ms";
     return ">=1000ms";
 }
+function debugSpawnMsBucket(value) {
+    if (typeof value !== "number")
+        return "unavailable";
+    if (value < 100)
+        return "<100ms";
+    if (value < 500)
+        return "100-499ms";
+    if (value < 1_000)
+        return "500-999ms";
+    return ">=1000ms";
+}
+function processCountBucket(value) {
+    if (typeof value !== "number")
+        return "unavailable";
+    if (value < 5)
+        return "0-4";
+    if (value < 17)
+        return "5-16";
+    if (value < 65)
+        return "17-64";
+    return "65+";
+}
+function hookTimeoutDebugContextTags(context) {
+    const tags = {
+        timeout_debug_hook_name: context.hook_name,
+        timeout_debug_hook_event: context.hook_event,
+        timeout_debug_budget_bucket: elapsedBucket(context.budget_ms),
+        timeout_debug_elapsed_bucket: elapsedBucket(context.elapsed_ms),
+        timeout_debug_remaining_bucket: remainingBucket(context.remaining_ms),
+        timeout_debug_wait_point: context.wait_point,
+        timeout_debug_waiting_child: context.waiting_child_basename,
+        timeout_debug_waiting_child_elapsed_bucket: elapsedBucket(context.waiting_child_elapsed_ms),
+        timeout_debug_load_bucket: context.load_average === "unavailable"
+            ? "unavailable"
+            : loadBucket(context.load_average),
+        timeout_debug_spawn_ms_bucket: debugSpawnMsBucket(context.spawn_ms),
+        timeout_debug_process_count_bucket: processCountBucket(context.process_count),
+    };
+    const phaseElapsed = new Map();
+    for (const timing of context.phase_timings) {
+        phaseElapsed.set(timing.phase, Math.max(phaseElapsed.get(timing.phase) ?? 0, timing.elapsed_ms));
+    }
+    for (const [phase, elapsedMs] of phaseElapsed) {
+        tags[`timeout_debug_phase_${phase}_bucket`] = elapsedBucket(elapsedMs);
+    }
+    return tags;
+}
 function safeSlowChild(metadata) {
     const value = metadata.slow_child;
     if (typeof value !== "string" || value.length === 0)
@@ -464,10 +674,10 @@ function sentryEnvelope(event, overrides, additionalTags = {}) {
     };
 }
 /** Build the same scrubbed event projection that the live SDK path uses. */
-function scrubbedSentryEnvelope(event, overrides) {
+function scrubbedSentryEnvelope(event, overrides, additionalTags = {}) {
     return beforeSend({
         message: event.message,
-        ...sentryEnvelope(event, overrides),
+        ...sentryEnvelope(event, overrides, additionalTags),
     }, {});
 }
 /**
@@ -740,19 +950,47 @@ export async function reportSentryEvent(stdin, options = {}, dependencies = defa
         const noun = result.droppedMetadataKeys === 1 ? "key" : "keys";
         dependencies.stderr.write(`Dropped ${result.droppedMetadataKeys} unsupported Sentry report metadata ${noun}.\n`);
     }
-    const overrides = hookTimeoutExceededOverrides(result.event);
+    let event = result.event;
+    let debugContextTags = {};
+    const debugContext = event.metadata.hook_timeout_debug_context;
+    if (debugContext && isHookTimeoutEvent(event)) {
+        let enabled;
+        try {
+            enabled =
+                (await dependencies.timeoutDebugContextEnabled?.(options.signal)) ?? false;
+        }
+        catch {
+            // An optional diagnostic flag read must never suppress the base report.
+            enabled = false;
+        }
+        if (enabled) {
+            debugContextTags = hookTimeoutDebugContextTags(debugContext);
+        }
+        else {
+            const metadata = { ...event.metadata };
+            delete metadata.hook_timeout_debug_context;
+            event = { ...event, metadata };
+        }
+    }
+    else if (debugContext) {
+        const metadata = { ...event.metadata };
+        delete metadata.hook_timeout_debug_context;
+        event = { ...event, metadata };
+    }
+    result.event = event;
+    const overrides = hookTimeoutExceededOverrides(event);
     if (options.dryRun) {
-        const scrubbed = scrubbedSentryEnvelope(result.event, overrides);
+        const scrubbed = scrubbedSentryEnvelope(event, overrides, debugContextTags);
         if (scrubbed)
             dependencies.stdout.write(`${JSON.stringify(scrubbed)}\n`);
         return result;
     }
-    if (isHookTimeoutEvent(result.event)) {
-        addHookSequenceBreadcrumbs(result.event, dependencies);
-        const kind = hookTimeoutKind(result.event);
+    if (isHookTimeoutEvent(event)) {
+        addHookSequenceBreadcrumbs(event, dependencies);
+        const kind = hookTimeoutKind(event);
         let rateLimit;
         try {
-            rateLimit = timeoutRateLimitLease(result.event, kind, options, dependencies);
+            rateLimit = timeoutRateLimitLease(event, kind, options, dependencies);
         }
         catch {
             dependencies.stderr.write("Sentry timeout rate limit state unavailable; sending without rate limiting.\n");
@@ -764,14 +1002,14 @@ export async function reportSentryEvent(stdin, options = {}, dependencies = defa
             };
         }
         if (!rateLimit.capture) {
-            return reportSuppressedTimeout(result, result.event, timeoutMs, dependencies, kind);
+            return reportSuppressedTimeout(result, event, timeoutMs, dependencies, kind);
         }
         const tags = rateLimit.suppressedSinceLast > 0
             ? { suppressed_since_last: String(rateLimit.suppressedSinceLast) }
             : {};
-        const envelope = sentryEnvelope(result.event, overrides, tags);
+        const envelope = sentryEnvelope(event, overrides, { ...debugContextTags, ...tags });
         try {
-            dependencies.sentry.captureMessage(result.event.message, envelope);
+            dependencies.sentry.captureMessage(event.message, envelope);
             rateLimit.commitCapture();
             if (await flushWithin(dependencies.sentry, timeoutMs))
                 return result;
@@ -783,9 +1021,9 @@ export async function reportSentryEvent(stdin, options = {}, dependencies = defa
         dependencies.stderr.write("Sentry report failed.\n");
         return invalidInput();
     }
-    const envelope = sentryEnvelope(result.event, overrides);
+    const envelope = sentryEnvelope(event, overrides, debugContextTags);
     try {
-        dependencies.sentry.captureMessage(result.event.message, envelope);
+        dependencies.sentry.captureMessage(event.message, envelope);
         if (await flushWithin(dependencies.sentry, timeoutMs))
             return result;
     }

package/package.json

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