@indigoai-us/hq-cli 5.314.0 → 5.315.0

package/dist/utils/console-origin.js

@@ -0,0 +1,28 @@
+import { DEFAULT_VAULT_API_URL } from "./cognito-session.js";
+const PRODUCTION_CONSOLE_ORIGIN = "https://hq.computer";
+const PRODUCTION_VAULT_API_HOST = "hqapi.hq.computer";
+/**
+ * The console that fronts the control plane this CLI is pointed at.
+ *
+ * A handoff must land on the console for the same backend. When an override is
+ * active, derive its console from the control-plane host instead of assuming
+ * production. `HQ_CONSOLE_URL` remains an explicit override.
+ */
+export function consoleOrigin(vaultApiUrl = DEFAULT_VAULT_API_URL) {
+    const explicit = process.env.HQ_CONSOLE_URL?.trim();
+    if (explicit)
+        return explicit.replace(/\/+$/, "");
+    let api;
+    try {
+        api = new URL(vaultApiUrl);
+    }
+    catch {
+        return undefined;
+    }
+    if (api.host === PRODUCTION_VAULT_API_HOST)
+        return PRODUCTION_CONSOLE_ORIGIN;
+    if (!api.hostname.startsWith("hqapi."))
+        return undefined;
+    return `${api.protocol}//${api.host.slice("hqapi.".length)}`;
+}
+//# sourceMappingURL=console-origin.js.map

package/dist/utils/contribution-table.d.ts

@@ -99,5 +99,5 @@ export declare const CONTRIBUTION_KEYS: ContributionKey[];
  */
 export declare function payloadFor(key: ContributionKey, item: string): string;
 /** Keys whose contributions are wired by a host symlink (skip `merge` rows). */
-export declare const SYMLINK_KEYS: ("workers" | "knowledge" | "skills" | "commands" | "hooks" | "policies" | "scripts" | "mcp")[];
+export declare const SYMLINK_KEYS: ("workers" | "mcp" | "commands" | "skills" | "knowledge" | "hooks" | "policies" | "scripts")[];
 //# sourceMappingURL=contribution-table.d.ts.map

package/dist/utils/core-eval-trigger.d.ts

@@ -0,0 +1,4 @@
+/** Return shell-compatible 0/1/2: true, false, or malformed. */
+export declare function evaluateTrigger(expr: string, facts?: string): number;
+export declare function checkTriggerExpressions(stdin: string): string;
+//# sourceMappingURL=core-eval-trigger.d.ts.map

package/dist/utils/core-eval-trigger.js

@@ -0,0 +1,88 @@
+/** Pure evaluator shared by the native command and migration helper. */
+function parseBooleanExpression(input) {
+    const expression = input;
+    if (/[^01&|!() \t]/.test(expression))
+        return { valid: false, value: false };
+    let position = 0;
+    let valid = true;
+    const skip = () => { while (expression[position] === " " || expression[position] === "\t")
+        position += 1; };
+    const atom = () => {
+        skip();
+        const char = expression[position];
+        if (char === "(") {
+            position += 1;
+            const value = parseOr();
+            skip();
+            if (expression[position] !== ")") {
+                valid = false;
+                return false;
+            }
+            position += 1;
+            return value;
+        }
+        if (char === "0" || char === "1") {
+            position += 1;
+            return char === "1";
+        }
+        valid = false;
+        return false;
+    };
+    const parseNot = () => {
+        skip();
+        if (expression[position] === "!") {
+            position += 1;
+            return !parseNot();
+        }
+        return atom();
+    };
+    const parseAnd = () => {
+        let value = parseNot();
+        skip();
+        while (valid && expression.slice(position, position + 2) === "&&") {
+            position += 2;
+            const rhs = parseNot();
+            value = value && rhs;
+            skip();
+        }
+        return value;
+    };
+    function parseOr() {
+        let value = parseAnd();
+        skip();
+        while (valid && expression.slice(position, position + 2) === "||") {
+            position += 2;
+            const rhs = parseAnd();
+            value = value || rhs;
+            skip();
+        }
+        return value;
+    }
+    const value = parseOr();
+    skip();
+    return { valid: valid && position === expression.length, value };
+}
+/** Return shell-compatible 0/1/2: true, false, or malformed. */
+export function evaluateTrigger(expr, facts = "") {
+    if (expr.replace(/[ \t]/g, "") === "")
+        return 2;
+    const have = new Set(facts.split(/[ ,]+/).filter(Boolean));
+    const substituted = expr.replace(/[A-Za-z0-9_./][A-Za-z0-9_./-]*/g, (token) => have.has(token.toLowerCase()) ? "1" : "0");
+    if (/[^01&|!() \t]/.test(substituted))
+        return 2;
+    const parsed = parseBooleanExpression(substituted);
+    if (!parsed.valid)
+        return 2;
+    return parsed.value ? 0 : 1;
+}
+export function checkTriggerExpressions(stdin) {
+    if (!stdin)
+        return "";
+    return stdin.split("\n").filter((line, index, all) => index < all.length - 1 || line !== "").map((line) => {
+        const tab = line.indexOf("\t");
+        const id = tab < 0 ? line : line.slice(0, tab);
+        const expr = tab < 0 ? "" : line.slice(tab + 1);
+        return `${id}\t${evaluateTrigger(expr, "") === 2 ? "malformed" : "ok"}\n`;
+    }).join("");
+}
+//# sourceMappingURL=core-eval-trigger.js.map

package/dist/utils/environmental-error.d.ts

@@ -7,4 +7,22 @@
  * result means "this is a normal error; handle it as usual (capture to Sentry)".
  */
 export declare function environmentalFsErrorMessage(err: unknown): string | null;
+export type FilesystemErrorCaptureContext = {
+    fingerprint: ["fs-error", string, string, string];
+    tags: Record<string, string>;
+    extra: {
+        fs_path: string;
+        fs_reason: string;
+    };
+};
+/** Return only the registered command path, never positional user data. */
+export declare function hqCommand(argv?: readonly string[]): string;
+/**
+ * Build stable Sentry context for known OS filesystem refusals. The failure is
+ * intentionally still captured: this is instrumentation for the OneDrive /
+ * antivirus / path-length hypotheses, not an expected-error suppression.
+ */
+export declare function filesystemErrorCaptureContext(err: unknown, argv?: readonly string[]): FilesystemErrorCaptureContext | null;
+/** Plain operator guidance for a captured filesystem failure. */
+export declare function filesystemErrorMessage(err: unknown): string | null;
 //# sourceMappingURL=environmental-error.d.ts.map

package/dist/utils/environmental-error.js

@@ -1,16 +1,20 @@
 // src/utils/environmental-error.ts
 //
 // Classify errors that stem from the user's machine/filesystem state rather
-// than an HQ code defect. These are unactionable from our side: a full disk, an
-// exhausted quota, or a read-only filesystem. The CLI surfaces a clear,
-// actionable message and does NOT report them to Sentry — otherwise a single
-// full disk floods the issue tracker with identical, unfixable crash reports.
+// than an HQ code defect. Full-disk conditions have a known remedy and remain
+// quiet; permission and file-lock conditions remain captured with bounded
+// attribution so the next occurrence can identify the real cause.
 //
 // HQ-CLI-2: `hq reindex` hit ENOSPC in the operation-lock temp-file write
 // (`fs.openSync` → "ENOSPC: no space left on device, open") and the raw error
 // propagated uncaught to the CLI's top-level handler, which captured it to
 // Sentry and exited silently — 5 stack-trace crashes in 6 seconds, with no
 // message telling the user their disk was full.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { COMMAND_CATALOG } from "../command-catalog.generated.js";
+import { CLI_VERSION } from "../cli-version.js";
+import { redactErrorText } from "./redact-error-text.js";
 /**
  * Node errno codes for "the filesystem cannot accept this write" — purely
  * environmental, never a code bug. Mapped to the message shown to the user.
@@ -20,6 +24,24 @@ const ENVIRONMENTAL_FS_CODES = {
     EDQUOT: "Disk quota exceeded. Free up space (or raise your quota) and try again.",
     EROFS: "The filesystem is read-only, so HQ can't write here. Check the mount/permissions and try again.",
 };
+const MAX_CAUSE_DEPTH = 4;
+function errorRecord(value) {
+    return value !== null && typeof value === "object" ? value : null;
+}
+function findErrorWithCode(err, codes) {
+    const seen = new Set();
+    let current = err;
+    for (let depth = 0; depth <= MAX_CAUSE_DEPTH; depth += 1) {
+        const record = errorRecord(current);
+        if (!record || seen.has(record))
+            return null;
+        seen.add(record);
+        if (typeof record.code === "string" && codes.has(record.code))
+            return record;
+        current = record.cause;
+    }
+    return null;
+}
 /**
  * If `err` is an environmental disk/quota/read-only filesystem error, return a
  * short, user-facing message explaining it; otherwise return `null`.
@@ -29,9 +51,220 @@ const ENVIRONMENTAL_FS_CODES = {
  * result means "this is a normal error; handle it as usual (capture to Sentry)".
  */
 export function environmentalFsErrorMessage(err) {
-    const code = err?.code;
-    if (typeof code !== "string")
+    const record = findErrorWithCode(err, new Set(Object.keys(ENVIRONMENTAL_FS_CODES)));
+    return record && typeof record.code === "string"
+        ? ENVIRONMENTAL_FS_CODES[record.code] ?? null
+        : null;
+}
+const CAPTURED_FS_CODES = new Set(["EPERM", "EACCES", "EBUSY", "UNKNOWN"]);
+const CAPTURED_FS_SYSCALLS = new Set(["open", "symlink", "rename", "unlink"]);
+function stringField(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function pathFromMessage(message, syscall) {
+    const text = stringField(message);
+    if (!text)
+        return null;
+    const escapedSyscall = syscall.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`${escapedSyscall}\\s+['"]([^'"]+)['"]`, "i").exec(text);
+    return match?.[1] ?? null;
+}
+function findFilesystemError(err) {
+    const seen = new Set();
+    let current = err;
+    for (let depth = 0; depth <= MAX_CAUSE_DEPTH; depth += 1) {
+        const record = errorRecord(current);
+        if (!record || seen.has(record))
+            return null;
+        seen.add(record);
+        const code = stringField(record.code);
+        const syscall = stringField(record.syscall);
+        if (code && syscall && CAPTURED_FS_CODES.has(code) && CAPTURED_FS_SYSCALLS.has(syscall)) {
+            const rawPath = stringField(record.path) ??
+                stringField(record.dest) ??
+                pathFromMessage(record.message, syscall) ??
+                "unknown";
+            return { record, code, syscall, rawPath };
+        }
+        current = record.cause;
+    }
+    return null;
+}
+function canonicalPath(rawPath) {
+    if (rawPath === "unknown")
+        return "";
+    const resolved = path.resolve(rawPath);
+    try {
+        return path.normalize(requireRealpath(resolved));
+    }
+    catch {
+        // The failed path may not exist. Resolving its parent still canonicalizes
+        // symlinked HQ roots without turning missing-file attribution into a throw.
+        const parent = path.dirname(resolved);
+        try {
+            return path.join(requireRealpath(parent), path.basename(resolved));
+        }
+        catch {
+            return resolved;
+        }
+    }
+}
+function requireRealpath(candidate) {
+    // Keep the filesystem read behind one tiny seam so the classifier remains
+    // safe when the failed target has already disappeared.
+    return fs.realpathSync.native(candidate);
+}
+function pathSegments(value) {
+    return value
+        .replaceAll("\\", "/")
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => segment.toLowerCase());
+}
+function pathKind(rawPath, resolvedPath) {
+    if (rawPath === "unknown")
+        return "other";
+    const segments = pathSegments(`${resolvedPath}/${rawPath}`);
+    if (segments.includes("node_modules") || segments.includes(".pnpm"))
+        return "install-tree";
+    if (segments.includes("worktree") || segments.includes("worktrees"))
+        return "worktree";
+    if (segments.includes("companies"))
+        return "companies";
+    if (segments.includes("workspace"))
+        return "workspace";
+    if (segments.includes("hq"))
+        return "hq-root";
+    return "other";
+}
+function syncedFolder(resolvedPath) {
+    if (!resolvedPath)
+        return "none";
+    const segments = pathSegments(resolvedPath);
+    // iCloud is identified from canonical path components, not a display-name
+    // substring: Desktop/Documents aliases can point into this container.
+    for (let i = 0; i + 1 < segments.length; i += 1) {
+        if (segments[i] === "library" && segments[i + 1] === "mobile documents")
+            return "icloud";
+    }
+    if (segments.some((segment) => segment === "onedrive" || segment.startsWith("onedrive -")))
+        return "onedrive";
+    if (segments.includes("dropbox"))
+        return "dropbox";
+    if (segments.some((segment) => segment === "google drive" || segment === "google-drive" || segment === "googledrive")) {
+        return "google-drive";
+    }
+    return "none";
+}
+function redactedPath(rawPath) {
+    if (rawPath === "unknown")
+        return "unknown";
+    const segments = rawPath.replaceAll("\\", "/").split("/").filter(Boolean);
+    const tail = segments.slice(-2).join("/");
+    return redactErrorText(tail) || "unknown";
+}
+function fileAttributes(record, rawPath) {
+    const metadata = [record.fileAttributes, record.attributes]
+        .map(stringField)
+        .filter((value) => value !== null)
+        .join(" ")
+        .toLowerCase();
+    if (metadata.includes("offline") || record.offline === true)
+        return "offline";
+    if (metadata.includes("readonly") || metadata.includes("read-only") || record.readonly === true)
+        return "readonly";
+    const leaf = rawPath.replaceAll("\\", "/").split("/").filter(Boolean).at(-1) ?? rawPath;
+    if (metadata.includes("hidden") || record.hidden === true || leaf.startsWith("."))
+        return "hidden";
+    return "none";
+}
+function findRegisteredCommand(commands, token) {
+    return commands.find((command) => command.name === token || command.aliases.includes(token)) ?? null;
+}
+function optionTakesValue(command, token) {
+    const optionName = token.split("=", 1)[0];
+    return command.options.some((option) => {
+        const names = option.flags
+            .split(",")
+            .map((flag) => flag.trim().split(/\s+/, 1)[0])
+            .filter((name) => Boolean(name));
+        return names.includes(optionName) && /(?:<[^>]+>|\[[^\]]+\])/.test(option.flags);
+    });
+}
+/** Return only the registered command path, never positional user data. */
+export function hqCommand(argv = process.argv) {
+    const commandPath = [];
+    let commands = COMMAND_CATALOG;
+    let currentCommand = null;
+    for (let index = 2; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token || token === "--")
+            break;
+        if (token.startsWith("-")) {
+            if (!token.includes("=") && currentCommand && optionTakesValue(currentCommand, token)) {
+                index += 1;
+            }
+            continue;
+        }
+        const command = findRegisteredCommand(commands, token);
+        if (!command)
+            break;
+        commandPath.push(command.name);
+        currentCommand = command;
+        commands = command.subcommands;
+    }
+    return commandPath.join(" ") || "unknown";
+}
+function pathLengthBucket(rawPath) {
+    if (rawPath.length < 200)
+        return "<200";
+    if (rawPath.length <= 260)
+        return "200-260";
+    return ">260";
+}
+/**
+ * Build stable Sentry context for known OS filesystem refusals. The failure is
+ * intentionally still captured: this is instrumentation for the OneDrive /
+ * antivirus / path-length hypotheses, not an expected-error suppression.
+ */
+export function filesystemErrorCaptureContext(err, argv = process.argv) {
+    const details = findFilesystemError(err);
+    if (!details)
+        return null;
+    const resolvedPath = canonicalPath(details.rawPath);
+    const safePath = redactedPath(details.rawPath);
+    const command = hqCommand(argv);
+    return {
+        fingerprint: ["fs-error", details.code, details.syscall, command],
+        tags: {
+            fs_code: details.code,
+            fs_syscall: details.syscall,
+            path_kind: pathKind(details.rawPath, resolvedPath),
+            synced_folder: syncedFolder(resolvedPath),
+            path_len_bucket: pathLengthBucket(details.rawPath),
+            file_attributes: fileAttributes(details.record, details.rawPath),
+            hq_command: command,
+            platform: process.platform,
+            hq_cli_version: CLI_VERSION,
+        },
+        extra: {
+            fs_path: safePath,
+            fs_reason: redactErrorText(`${details.code} ${details.syscall} failed at ${safePath}`),
+        },
+    };
+}
+/** Plain operator guidance for a captured filesystem failure. */
+export function filesystemErrorMessage(err) {
+    const details = findFilesystemError(err);
+    if (!details)
         return null;
-    return ENVIRONMENTAL_FS_CODES[code] ?? null;
+    const resolvedPath = canonicalPath(details.rawPath);
+    const safePath = redactedPath(details.rawPath);
+    const synced = syncedFolder(resolvedPath);
+    const permissionDenied = details.code === "EACCES" || details.code === "EPERM";
+    const remedy = permissionDenied && process.platform !== "win32" && synced === "none"
+        ? "Check file and folder permissions, close the file, then retry."
+        : "Close the file or exclude its folder from cloud sync; if it persists, check permissions, then retry.";
+    return `Filesystem operation ${details.syscall} failed (${details.code}) at ${safePath}. ${remedy}`;
 }
 //# sourceMappingURL=environmental-error.js.map

package/dist/utils/exclusive-lock.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Acquiring a lock file on a filesystem that may not do hard links.
+ *
+ * The refresh lock is a classic POSIX `link()` lock: write a candidate file,
+ * hard-link it into place, and let EEXIST mean somebody else holds it. That
+ * is atomic on a local disk and on NFS, and it is simply absent on CIFS/SMB
+ * — Azure Files returns ENOTSUP for `link()` on every call, so a bot whose
+ * agent home lives on such a share could never mint a token at all. Its
+ * probe failed every line with:
+ *
+ *     ENOTSUP: operation not supported on socket, link
+ *       '.../cognito-tokens.json.lock.candidate.48560...' -> '.../lock'
+ *
+ * An exclusive create (`open(..., O_EXCL)`) gives the same guarantee — the
+ * server refuses the second creator — and works on those shares. So the link
+ * is tried first, and a filesystem that says it cannot do links is remembered
+ * and switched to the exclusive-create path for the rest of the process.
+ *
+ * Both paths fail with EEXIST when the lock is held, so contention, stale-
+ * owner reclamation and release are unchanged for every caller.
+ */
+/** Test seam: forget what we learned about which filesystems do links. */
+export declare function resetLinkSupportCache(): void;
+/**
+ * Create `lockFile` exclusively, or throw EEXIST if it already exists.
+ *
+ * `candidate` is an already-written file holding the owner's pid; on a
+ * link-capable filesystem it becomes the lock, and otherwise its contents
+ * are written directly. Either way the lock ends up holding the same bytes.
+ */
+export declare function acquireLockFileExclusively(candidate: string, lockFile: string, dirKey: string): void;
+//# sourceMappingURL=exclusive-lock.d.ts.map

package/dist/utils/exclusive-lock.js

@@ -0,0 +1,75 @@
+/**
+ * Acquiring a lock file on a filesystem that may not do hard links.
+ *
+ * The refresh lock is a classic POSIX `link()` lock: write a candidate file,
+ * hard-link it into place, and let EEXIST mean somebody else holds it. That
+ * is atomic on a local disk and on NFS, and it is simply absent on CIFS/SMB
+ * — Azure Files returns ENOTSUP for `link()` on every call, so a bot whose
+ * agent home lives on such a share could never mint a token at all. Its
+ * probe failed every line with:
+ *
+ *     ENOTSUP: operation not supported on socket, link
+ *       '.../cognito-tokens.json.lock.candidate.48560...' -> '.../lock'
+ *
+ * An exclusive create (`open(..., O_EXCL)`) gives the same guarantee — the
+ * server refuses the second creator — and works on those shares. So the link
+ * is tried first, and a filesystem that says it cannot do links is remembered
+ * and switched to the exclusive-create path for the rest of the process.
+ *
+ * Both paths fail with EEXIST when the lock is held, so contention, stale-
+ * owner reclamation and release are unchanged for every caller.
+ */
+import * as fs from "fs";
+/**
+ * `link()` errnos that mean "this filesystem does not implement links"
+ * rather than "the link failed". EEXIST is deliberately NOT here: that is
+ * ordinary contention and the caller's own retry loop owns it.
+ */
+const LINK_UNSUPPORTED_CODES = new Set([
+    "ENOTSUP",
+    "EOPNOTSUPP",
+    "EPERM",
+    "EXDEV",
+    "EACCES",
+]);
+/**
+ * Per-process, per-directory memory of a filesystem that cannot hard-link,
+ * so the cost is one failed call rather than one per acquisition.
+ */
+const linkUnsupportedDirs = new Set();
+/** Test seam: forget what we learned about which filesystems do links. */
+export function resetLinkSupportCache() {
+    linkUnsupportedDirs.clear();
+}
+/**
+ * Create `lockFile` exclusively, or throw EEXIST if it already exists.
+ *
+ * `candidate` is an already-written file holding the owner's pid; on a
+ * link-capable filesystem it becomes the lock, and otherwise its contents
+ * are written directly. Either way the lock ends up holding the same bytes.
+ */
+export function acquireLockFileExclusively(candidate, lockFile, dirKey) {
+    if (!linkUnsupportedDirs.has(dirKey)) {
+        try {
+            fs.linkSync(candidate, lockFile);
+            return;
+        }
+        catch (error) {
+            const code = error.code ?? "";
+            // Contention is the caller's business, and an unrecognised failure is
+            // a real fault: neither one means "try the other strategy".
+            if (code === "EEXIST")
+                throw error;
+            if (!LINK_UNSUPPORTED_CODES.has(code))
+                throw error;
+            linkUnsupportedDirs.add(dirKey);
+        }
+    }
+    // O_EXCL: the create fails with EEXIST if anyone got there first, which is
+    // exactly the signal the link path produced.
+    fs.writeFileSync(lockFile, fs.readFileSync(candidate), {
+        flag: "wx",
+        mode: 0o600,
+    });
+}
+//# sourceMappingURL=exclusive-lock.js.map

package/dist/utils/expected-cli-error.d.ts

@@ -5,6 +5,8 @@
 export interface ExpectedUserError extends Error {
     expected: true;
 }
+/** Stamp an existing Error with the boundary's caller-owned disposition. */
+export declare function markExpectedUserError<T extends Error>(err: T): T & ExpectedUserError;
 /**
  * True when `err` is an Error explicitly marked `expected === true`. A non-null
  * result means the top-level handler should print `err.message` and skip Sentry

package/dist/utils/expected-cli-error.js

@@ -16,6 +16,10 @@
 // ("Only a company owner can approve or reject queued integration writes"); the
 // thrown error propagated to the top-level handler, which captured it to Sentry
 // as an error-level crash and printed nothing to the user.
+/** Stamp an existing Error with the boundary's caller-owned disposition. */
+export function markExpectedUserError(err) {
+    return Object.assign(err, { expected: true });
+}
 /**
  * True when `err` is an Error explicitly marked `expected === true`. A non-null
  * result means the top-level handler should print `err.message` and skip Sentry

package/dist/utils/fast-stream-errors.d.ts

@@ -0,0 +1,12 @@
+type ErrorEventStream = {
+    on: (event: "error", listener: (err: unknown) => void) => unknown;
+};
+export type FastStreamErrorDependencies = {
+    stdout: ErrorEventStream;
+    stderr: ErrorEventStream;
+    exit: (code: number) => void;
+};
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export declare function installFastPathStreamErrorHandlers(deps?: FastStreamErrorDependencies): void;
+export {};
+//# sourceMappingURL=fast-stream-errors.d.ts.map

package/dist/utils/fast-stream-errors.js

@@ -0,0 +1,18 @@
+import { isEpipe } from "./epipe.js";
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export function installFastPathStreamErrorHandlers(deps = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    exit: (code) => process.exit(code),
+}) {
+    const handle = (err) => {
+        if (isEpipe(err)) {
+            deps.exit(0);
+            return;
+        }
+        throw err;
+    };
+    deps.stdout.on("error", handle);
+    deps.stderr.on("error", handle);
+}
+//# sourceMappingURL=fast-stream-errors.js.map

package/dist/utils/feedback-diagnostics.d.ts

@@ -1,6 +1,6 @@
 import { type VersionInfo } from "./feedback-versions.js";
 import type { FeedbackLogsBlob } from "./feedback-logs.js";
-export interface GitContext {
+interface GitContext {
     branch: string | null;
     head: string | null;
     dirty: boolean;
@@ -37,4 +37,5 @@ export interface DiagnosticsBlob {
 }
 export declare function sanitizeArgv(argv: string[]): string[];
 export declare function collectDiagnostics(): DiagnosticsBlob;
+export {};
 //# sourceMappingURL=feedback-diagnostics.d.ts.map