@indigoai-us/hq-cli 5.235.0 → 5.236.0

package/dist/lib/bot/local-config.d.ts

@@ -34,13 +34,14 @@ export interface BotLocalConfig {
     autoApprove?: boolean;
     /** Only the memory *kind* travels — never an absolute path from another Mac. */
     memory?: BotMemoryMode;
+    displayName?: string;
     intro?: string;
     kickoff?: string;
 }
 /** Walks a value and throws when any key looks like it could carry a secret. */
 export declare function assertNoSecretKeys(value: unknown, path?: string): void;
 /** The bot.json fields a localConfig is built from — nothing else is read. */
-export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "intro" | "kickoff">;
+export type BotLocalConfigSource = Pick<BotConfig, "runtime" | "workerSource" | "workerId" | "companySlug" | "model" | "effort" | "kind" | "companies" | "autoApprove" | "memoryDir" | "displayName" | "intro" | "kickoff">;
 /**
  * The non-secret settings of a bot, for the cloud to keep. Absolute paths
  * (hqRoot, memoryDir, workerDir) are deliberately left out: they belong to the

package/dist/lib/bot/local-config.js

@@ -51,6 +51,7 @@ export function buildBotLocalConfig(config) {
         ...(kind === "company" ? { companies } : {}),
         ...(config.autoApprove === false ? { autoApprove: false } : {}),
         memory: botMemoryMode(config),
+        ...(config.displayName ? { displayName: config.displayName } : {}),
         ...(config.intro ? { intro: config.intro } : {}),
         ...(config.kickoff ? { kickoff: config.kickoff } : {}),
     };
@@ -107,6 +108,9 @@ export function parseBotLocalConfig(value) {
     const memory = str("memory");
     if (isBotMemoryMode(memory))
         out.memory = memory;
+    const displayName = str("displayName");
+    if (displayName)
+        out.displayName = displayName;
     const intro = str("intro");
     if (intro)
         out.intro = intro;

package/dist/lib/bot/progress.d.ts

@@ -27,6 +27,9 @@ export declare const PROGRESS_COALESCE_MS = 2000;
 export declare const PROGRESS_MIN_GAP_MS = 4000;
 export declare const WORKING_NOTICE_MS = 60000;
 export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export declare const SETUP_WORKING_NOTICE_MS = 30000;
+export declare const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 export interface ProgressPosterOptions {
     /** Post one message; resolve true when it was delivered. */
     send: (body: string) => Promise<boolean>;
@@ -49,6 +52,14 @@ export interface ProgressPosterOptions {
      * (when the turn is not silent); `abandon` posts nothing.
      */
     buffer?: boolean;
+    /**
+     * Never post a message the model wrote right before a tool call. Those are
+     * the model's notes to itself ("Now write the worker."), not replies: the
+     * runtime stream shows them as a text block followed by a tool_use. A
+     * message is held until the next event says which it was: a tool call drops
+     * it, anything else (another message, the end of the turn) keeps it.
+     */
+    dropPreToolMessages?: boolean;
 }
 /** Whitespace-insensitive form used to recognise repeated text. */
 export declare function normalizeForCompare(text: string): string;
@@ -65,6 +76,9 @@ export declare class ProgressPoster {
     private readonly workingNoticeMs;
     private readonly workingNoticeText;
     private readonly buffer;
+    private readonly dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    private candidates;
     private pending;
     /** In-between questions, held until the turn ends (see the header). */
     private heldQuestions;
@@ -77,11 +91,22 @@ export declare class ProgressPoster {
     private finished;
     private noticeSent;
     private delivered;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    private queued;
     constructor(opts: ProgressPosterOptions);
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start(): void;
     /** One finished assistant message from the model. */
     message(text: string): void;
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool(): void;
+    private promoteCandidates;
+    private accept;
     /** Posts that actually reached the chat (progress, notice and final). */
     get postedCount(): number;
     /** True once any message from the model was said this turn (not counting the notice). */

package/dist/lib/bot/progress.js

@@ -27,6 +27,9 @@ export const PROGRESS_COALESCE_MS = 2_000;
 export const PROGRESS_MIN_GAP_MS = 4_000;
 export const WORKING_NOTICE_MS = 60_000;
 export const WORKING_NOTICE_TEXT = "Working on it — I'll reply here when it's done.";
+/** The setup bot's heads-up, sent once when a turn runs past SETUP_WORKING_NOTICE_MS. */
+export const SETUP_WORKING_NOTICE_MS = 30_000;
+export const SETUP_WORKING_NOTICE_TEXT = "This one takes a minute. I'll reply here as soon as it's done.";
 /** Whitespace-insensitive form used to recognise repeated text. */
 export function normalizeForCompare(text) {
     return text.replace(/\s+/g, "");
@@ -46,6 +49,9 @@ export class ProgressPoster {
     workingNoticeMs;
     workingNoticeText;
     buffer;
+    dropPreTool;
+    /** dropPreToolMessages: messages waiting to learn whether a tool call follows. */
+    candidates = [];
     pending = [];
     /** In-between questions, held until the turn ends (see the header). */
     heldQuestions = [];
@@ -58,6 +64,13 @@ export class ProgressPoster {
     finished = false;
     noticeSent = false;
     delivered = 0;
+    /**
+     * Posts handed to the send chain this turn, counted when queued rather than
+     * when delivered. The "(no reply)" fallback checks this: a post still in
+     * flight when the turn ends has not bumped `delivered` yet, and counting only
+     * deliveries posted the placeholder right after a real message.
+     */
+    queued = 0;
     constructor(opts) {
         this.send = opts.send;
         this.sendFinalFn = opts.sendFinal;
@@ -69,6 +82,7 @@ export class ProgressPoster {
         this.workingNoticeMs = opts.workingNoticeMs ?? WORKING_NOTICE_MS;
         this.workingNoticeText = opts.workingNoticeText ?? WORKING_NOTICE_TEXT;
         this.buffer = opts.buffer ?? false;
+        this.dropPreTool = opts.dropPreToolMessages ?? false;
     }
     /** Arm the one-time "working on it" note. Call when the turn starts. */
     start() {
@@ -93,6 +107,27 @@ export class ProgressPoster {
         // silence signal, not content, and must never be posted as progress.
         if (containsNoReplySentinel(t))
             return;
+        if (this.dropPreTool) {
+            // The previous message was not followed by a tool call: it was real.
+            this.promoteCandidates();
+            this.candidates.push(t);
+            return;
+        }
+        this.accept(t);
+    }
+    /** The model called a tool: whatever it wrote just before was a note to itself. */
+    tool() {
+        if (this.finished || !this.dropPreTool)
+            return;
+        this.candidates = [];
+    }
+    promoteCandidates() {
+        const kept = this.candidates;
+        this.candidates = [];
+        for (const t of kept)
+            this.accept(t);
+    }
+    accept(t) {
         this.cancelNotice();
         this.said.push(t);
         // An unmentioned room turn holds every in-between message: nothing is posted
@@ -124,6 +159,8 @@ export class ProgressPoster {
     async finish(finalText) {
         if (this.finished)
             return this.chain;
+        // A message the turn ended on (no tool after it) is real.
+        this.promoteCandidates();
         this.finished = true;
         this.cancelNotice();
         this.cancelFlush();
@@ -161,7 +198,7 @@ export class ProgressPoster {
         const shouldAddFinal = Boolean(final && !this.repeatsSaid(final));
         if (!shouldAddFinal && held.length > 0)
             this.pending.push(...held);
-        if (this.pending.length === 0 && this.delivered === 0 && !shouldAddFinal)
+        if (this.pending.length === 0 && this.queued === 0 && !shouldAddFinal)
             this.pending.push("(no reply)");
         if (this.sendFinalFn && shouldAddFinal) {
             // Flush any remaining progress messages first, then the final reply separately.
@@ -229,6 +266,7 @@ export class ProgressPoster {
         // path built this body.
         if (containsNoReplySentinel(body))
             return;
+        this.queued += 1;
         this.lastPostAt = this.now();
         this.chain = this.chain.then(async () => {
             try {

package/dist/lib/bot/prompt.d.ts

@@ -77,6 +77,8 @@ export declare function normalizeInstructions(raw: unknown): string | undefined;
 export declare function readPromptSources(hqRoot: string, workerDir: string, io?: PromptFs, opts?: ReadPromptSourcesOptions): PromptSources;
 export interface BuildSystemPromptInput {
     botName: string;
+    /** The human name people call the bot (e.g. "Maya"); unset = botName. */
+    displayName?: string;
     agentUid: string;
     ownerUid: string;
     hqRoot: string;

package/dist/lib/bot/prompt.js

@@ -229,6 +229,16 @@ export function readPromptSources(hqRoot, workerDir, io = defaultPromptFs, opts
     }
     return { workerYaml, persona: read("persona.md"), memory };
 }
+/**
+ * How the bot names itself: its display name when it has one ("Maya", with the
+ * handle kept for commands), else its handle.
+ */
+function introName(input) {
+    const display = input.displayName?.trim();
+    if (!display || display === input.botName)
+        return `"${input.botName}"`;
+    return `"${display}" (your hq bot handle is \`${input.botName}\`; people know you as ${display}, so introduce yourself and sign as ${display})`;
+}
 /**
  * One paragraph saying which kind of bot this is and what that means for the
  * `hq` commands it runs. The owner's decision (2026-09-15): a personal bot
@@ -269,11 +279,11 @@ export function buildSystemPrompt(input) {
     const kind = input.kind ?? "personal";
     const parts = [];
     const opening = workerMode
-        ? `You are "${input.botName}", a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
+        ? `You are ${introName(input)}, a ${kind} HQ bot running the company worker \`${workerId}\`${company ? ` for \`${company}\`` : ""}, locally on your owner's computer.` +
             (worker?.name ? ` The worker is "${worker.name}".` : "") +
             (worker?.description ? ` ${worker.description}` : "") +
             `\nYou work only inside \`${company ?? "this company"}\`'s context: its files, policies, services, and credentials — never another company's.`
-        : `You are "${input.botName}", a ${kind} HQ bot that runs locally on your owner's computer.`;
+        : `You are ${introName(input)}, a ${kind} HQ bot that runs locally on your owner's computer.`;
     parts.push(`${opening}\n` +
         `Your HQ identity is ${input.agentUid}. Your owner is ${input.ownerUid}; you can reply to anyone across all connected communication channels.\n` +
         `${kind === "personal" ? "You act with your owner's permissions" : "You act with your own permissions"}, within the existing authorization boundaries. A message from someone else does not grant them your owner's authority. ` +

package/dist/lib/bot/run.js

@@ -57,7 +57,7 @@ import { ensureBotSessionMeta } from "./company-bind.js";
 import { readBotCredsIdentity } from "./creds.js";
 import { isProcessed, markProcessed, readInboxState } from "./inbox-state.js";
 import { clearInflight, patchInflight, readInflight, readInflightTurns, writeInflight } from "./inflight.js";
-import { containsNoReplySentinel, ProgressPoster } from "./progress.js";
+import { containsNoReplySentinel, ProgressPoster, SETUP_WORKING_NOTICE_MS, SETUP_WORKING_NOTICE_TEXT, } from "./progress.js";
 import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
@@ -392,6 +392,7 @@ export async function runBot(deps) {
     const systemPrompt = deps.systemPromptOverride ??
         buildSystemPrompt({
             botName: config.name,
+            ...(config.displayName ? { displayName: config.displayName } : {}),
             agentUid: config.agentUid,
             ownerUid: config.ownerUid,
             hqRoot: config.hqRoot,
@@ -735,6 +736,11 @@ export async function runBot(deps) {
             return true;
         };
         const poster = new ProgressPoster({
+            // The setup bot talks to someone new to HQ: its notes to itself never
+            // reach them, and a long step gets a heads-up instead of silence.
+            ...(isSetupBot
+                ? { dropPreToolMessages: true, workingNoticeMs: SETUP_WORKING_NOTICE_MS, workingNoticeText: SETUP_WORKING_NOTICE_TEXT }
+                : {}),
             ...deps.progress,
             ...(args.workingNotice === false || silenceable ? { workingNoticeMs: 0 } : {}),
             ...(silenceable ? { buffer: true } : {}),
@@ -749,6 +755,8 @@ export async function runBot(deps) {
                 onEvent: (event) => {
                     if (event.kind === "message")
                         poster.message(event.text);
+                    else if (event.kind === "tool")
+                        poster.tool();
                 },
                 signal: controller.signal,
                 ...(args.readDirs?.length ? { readDirs: args.readDirs } : {}),
@@ -1450,7 +1458,7 @@ export async function runBot(deps) {
             tReceived,
             send,
             sendFinal,
-            workingNotice: !isSetupBot,
+            // The setup bot's own notice (SETUP_WORKING_NOTICE_TEXT) is set where the poster is built.
             silenceable: target.kind === "room" && !target.mentioned,
             ...(readDirs.length ? { readDirs } : {}),
             ...(target.kind === "room"

package/dist/node-network-compat.d.ts

@@ -1,28 +1,19 @@
 /**
  * Node network defaults for HQ CLI entry points.
  *
- * The compatibility timeout remains the default. On a canary where IPv6 is
- * advertised but unusable, the default-off hq-flags gate can also prefer IPv4
- * and disable automatic family racing before the CLI issues its first request.
+ * The compatibility timeout remains the default for HQ CLI entry points.
  *
  * Keep this module safe to import immediately after the Node version preflight.
- * The hq-flags reader loads dynamically so an unsupported runtime exits through
- * the preflight rather than failing during module linking.
  */
 export declare const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
 export interface NodeNetworkCompatibilityOptions {
     nodeOptions?: string;
     execArgv?: readonly string[];
-    forceIpv4?: boolean;
     /**
      * Inject the net timeout setter (tests). Pass null to simulate a runtime
      * that lacks setDefaultAutoSelectFamilyAttemptTimeout.
      */
     setAttemptTimeout?: ((milliseconds: number) => void) | null;
-    /** Inject Node's automatic family selection setter (tests). */
-    setAutoSelectFamily?: ((enabled: boolean) => void) | null;
-    /** Inject Node's DNS result-order setter (tests). */
-    setDefaultResultOrder?: ((order: "ipv4first") => void) | null;
 }
 export declare function configureNodeNetworkCompatibility(options?: NodeNetworkCompatibilityOptions): boolean;
 //# sourceMappingURL=node-network-compat.d.ts.map

package/dist/node-network-compat.js

@@ -1,15 +1,10 @@
 /**
  * Node network defaults for HQ CLI entry points.
  *
- * The compatibility timeout remains the default. On a canary where IPv6 is
- * advertised but unusable, the default-off hq-flags gate can also prefer IPv4
- * and disable automatic family racing before the CLI issues its first request.
+ * The compatibility timeout remains the default for HQ CLI entry points.
  *
  * Keep this module safe to import immediately after the Node version preflight.
- * The hq-flags reader loads dynamically so an unsupported runtime exits through
- * the preflight rather than failing during module linking.
  */
-import * as nodeDns from "node:dns";
 import * as nodeNet from "node:net";
 export const HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 1000;
 const ATTEMPT_TIMEOUT_OPTION = "--network-family-autoselection-attempt-timeout";
@@ -19,18 +14,6 @@ function hasExplicitAttemptTimeout(nodeOptions, execArgv) {
         execArgv.some((argument) => argument === ATTEMPT_TIMEOUT_OPTION ||
             argument.startsWith(ATTEMPT_TIMEOUT_OPTION + "=")));
 }
-function hasExplicitFamilySelection(nodeOptions, execArgv) {
-    const optionPattern = /(?:^|\s)(?:--network-family-autoselection|--enable-network-family-autoselection|--no-network-family-autoselection|--dns-result-order)(?:=|\s|$)/;
-    return (optionPattern.test(nodeOptions) ||
-        execArgv.some((argument) => argument === "--network-family-autoselection" ||
-            argument === "--enable-network-family-autoselection" ||
-            argument === "--no-network-family-autoselection" ||
-            argument === "--dns-result-order" ||
-            argument.startsWith("--network-family-autoselection=") ||
-            argument.startsWith("--enable-network-family-autoselection=") ||
-            argument.startsWith("--no-network-family-autoselection=") ||
-            argument.startsWith("--dns-result-order=")));
-}
 function resolveSetAttemptTimeout(override) {
     if (override === null)
         return undefined;
@@ -39,69 +22,19 @@ function resolveSetAttemptTimeout(override) {
     const fn = nodeNet.setDefaultAutoSelectFamilyAttemptTimeout;
     return typeof fn === "function" ? fn.bind(nodeNet) : undefined;
 }
-function resolveSetAutoSelectFamily(override) {
-    if (override === null)
-        return undefined;
-    if (override)
-        return override;
-    const fn = nodeNet.setDefaultAutoSelectFamily;
-    return typeof fn === "function" ? fn.bind(nodeNet) : undefined;
-}
-function resolveSetDefaultResultOrder(override) {
-    if (override === null)
-        return undefined;
-    if (override)
-        return override;
-    const fn = nodeDns.setDefaultResultOrder;
-    return typeof fn === "function" ? fn.bind(nodeDns) : undefined;
-}
-function applyIpv4Preference(options, nodeOptions, execArgv) {
-    if (!options.forceIpv4 || hasExplicitFamilySelection(nodeOptions, execArgv)) {
-        return false;
-    }
-    const setAutoSelectFamily = resolveSetAutoSelectFamily(options.setAutoSelectFamily);
-    const setDefaultResultOrder = resolveSetDefaultResultOrder(options.setDefaultResultOrder);
-    if (!setAutoSelectFamily || !setDefaultResultOrder)
-        return false;
-    setDefaultResultOrder("ipv4first");
-    setAutoSelectFamily(false);
-    return true;
-}
 export function configureNodeNetworkCompatibility(options = {}) {
     const nodeOptions = options.nodeOptions ?? process.env.NODE_OPTIONS ?? "";
     const execArgv = options.execArgv ?? process.execArgv;
-    const ipv4Applied = applyIpv4Preference(options, nodeOptions, execArgv);
     if (hasExplicitAttemptTimeout(nodeOptions, execArgv)) {
-        return ipv4Applied;
+        return false;
     }
     const setAttemptTimeout = resolveSetAttemptTimeout(options.setAttemptTimeout);
     if (!setAttemptTimeout) {
         // Runtime lacks the API; the Node preflight should already have exited.
-        return ipv4Applied;
+        return false;
     }
     setAttemptTimeout(HQ_NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS);
     return true;
 }
-async function applyHqFlaggedIpv4Preference() {
-    try {
-        const { nodeNetworkForceIpv4Enabled } = await import("./node-network-compat-flag.js");
-        if (nodeNetworkForceIpv4Enabled &&
-            (await nodeNetworkForceIpv4Enabled())) {
-            configureNodeNetworkCompatibility({ forceIpv4: true });
-        }
-    }
-    catch (error) {
-        const rawName = error instanceof Error ? error.name : "UnknownError";
-        const errorName = /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(rawName)
-            ? rawName
-            : "UnknownError";
-        process.stderr.write("HQ network IPv4 flag lookup failed (" +
-            errorName +
-            "); using default off.\n");
-    }
-}
-// Preserve the historical timeout before any flag request. If the hq-flags
-// lookup succeeds, the IPv4 preference is applied before command dispatch.
 configureNodeNetworkCompatibility();
-await applyHqFlaggedIpv4Preference();
 //# sourceMappingURL=node-network-compat.js.map

package/package.json

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

package/dist/node-network-compat-flag.d.ts

@@ -1,19 +0,0 @@
-import type { FlagClient, FlagClientOptions } from "@indigoai-us/hq-flags-client";
-export declare const NODE_NETWORK_FORCE_IPV4_FLAG = "cli.network.force-ipv4";
-export declare const NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK = false;
-export declare const NODE_NETWORK_FORCE_IPV4_FLAG_TIMEOUT_MS = 1500;
-type NetworkFlagClient = Pick<FlagClient, "ready" | "isEnabled" | "close">;
-export interface NodeNetworkForceIpv4Dependencies {
-    env?: NodeJS.ProcessEnv;
-    createClient?: (options: FlagClientOptions) => NetworkFlagClient;
-    getToken?: () => string | Promise<string>;
-    reportFailure?: (error: unknown) => void;
-}
-/**
- * Read the opt-in hq-flags gate before CLI dispatch. Local hq-flags overrides
- * work without a token or endpoint; service decisions require a company
- * identity and use a short request deadline so startup remains bounded.
- */
-export declare function nodeNetworkForceIpv4Enabled(dependencies?: NodeNetworkForceIpv4Dependencies): Promise<boolean>;
-export {};
-//# sourceMappingURL=node-network-compat-flag.d.ts.map

package/dist/node-network-compat-flag.js

@@ -1,87 +0,0 @@
-import { createFlagClient, readLocalOverride } from "@indigoai-us/hq-flags-client";
-import { resolveFlagRegistryEndpoint } from "./lib/flag-registry-endpoint.js";
-export const NODE_NETWORK_FORCE_IPV4_FLAG = "cli.network.force-ipv4";
-export const NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK = false;
-// Node waits up to 1s before trying the next address family. Keep this request
-// deadline above that wait so a dead IPv6 path can reach the usable IPv4 host.
-export const NODE_NETWORK_FORCE_IPV4_FLAG_TIMEOUT_MS = 1_500;
-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 network IPv4 flag lookup failed (" +
-        safeErrorClass(error) +
-        "); using default off.\n");
-}
-async function loadCachedIdToken() {
-    const { loadCachedTokens } = await import("@indigoai-us/hq-cloud");
-    return loadCachedTokens()?.idToken ?? "";
-}
-/**
- * Read the opt-in hq-flags gate before CLI dispatch. Local hq-flags overrides
- * work without a token or endpoint; service decisions require a company
- * identity and use a short request deadline so startup remains bounded.
- */
-export async function nodeNetworkForceIpv4Enabled(dependencies = {}) {
-    const env = dependencies.env ?? process.env;
-    const localOverride = readLocalOverride(NODE_NETWORK_FORCE_IPV4_FLAG, env);
-    if (localOverride !== null)
-        return localOverride;
-    const endpoint = resolveFlagRegistryEndpoint(undefined, env);
-    const companyUid = env.HQ_COMPANY_UID?.trim() || "";
-    if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid)) {
-        return NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK;
-    }
-    const companySlug = env.HQ_COMPANY_SLUG?.trim() || "";
-    let client;
-    let failed = false;
-    let failureReported = false;
-    let enabled = NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK;
-    const reportFailureOnce = (error) => {
-        failed = true;
-        if (failureReported)
-            return;
-        failureReported = true;
-        (dependencies.reportFailure ?? reportFlagFailure)(error);
-    };
-    try {
-        const token = await (dependencies.getToken ?? loadCachedIdToken)();
-        if (!token)
-            return NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK;
-        const createClient = dependencies.createClient ?? createFlagClient;
-        client = createClient({
-            endpoint,
-            companyUid,
-            ...(companySlug && /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/.test(companySlug)
-                ? { companyIdentifiers: [companySlug] }
-                : {}),
-            env: {},
-            getToken: () => token,
-            refreshIntervalMs: 0,
-            requestTimeoutMs: NODE_NETWORK_FORCE_IPV4_FLAG_TIMEOUT_MS,
-            onError: reportFailureOnce,
-        });
-        await client.ready();
-        if (!failed) {
-            enabled = client.isEnabled(NODE_NETWORK_FORCE_IPV4_FLAG, {
-                fallback: NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK,
-            });
-        }
-    }
-    catch (error) {
-        reportFailureOnce(error);
-    }
-    finally {
-        try {
-            client?.close();
-        }
-        catch (error) {
-            reportFailureOnce(error);
-        }
-    }
-    return failed ? NODE_NETWORK_FORCE_IPV4_FLAG_FALLBACK : enabled;
-}
-//# sourceMappingURL=node-network-compat-flag.js.map