pi-dcg 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -6,6 +6,31 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-09
+
+### Fixed
+
+- Keep footer labels palette-neutral and terminal-only, preserving RPC confirmations and notifications.
+
+### Changed
+
+- Update the shared Pi development and contract-test baseline to 1.1.0; require Node.js >=22.19.0 to match the host runtime. Pi remains a host-supplied peer dependency.
+- Share install telemetry mechanics through `@mocito/install-telemetry` while preserving Pi-specific settings and state paths.
+
+### Fixed
+
+- Let `enableInstallTelemetry: false` override an enabled `PI_TELEMETRY` environment flag.
+- Cancel active and queued confirmations on turn abort or runtime shutdown, reject late approvals, and preserve cancellation blocking in both bridge-error modes.
+- Serialize DCG confirmation dialogs so parallel bash calls cannot displace each other's prompt.
+
+### Added
+
+- Real Pi 1.1.0 session contracts for direct, codemode, and custom nested bash calls, with mocked provider/process/shell boundaries, native TUI selector checks, approval composition, reload, and user `!`/`!!` coverage.
+
+### Security
+
+- Document the remaining Pi 1.1.0 input-object replacement and cross-extension dialog scheduling limitations; DCG does not replace the host executor or claim those upstream gaps are fixed.
+
 ## [0.1.0] - 2026-07-17
 
 ### Added

package/CONTRIBUTING.md

@@ -25,6 +25,27 @@ pi
 
 Run `/dcg` to verify binary discovery. Exercise safe and destructive fixtures only through `dcg test` or a disposable sandbox; do not run genuinely destructive commands to test the bridge.
 
+### Automated session and TUI smoke tests
+
+From the repository root:
+
+```bash
+npm run -w packages/pi-dcg test
+node --import tsx --test packages/pi-dcg/tests/ui-contract.test.mjs
+```
+
+The second command is the focused TUI smoke test. It drives Pi's actual selector rendering and keyboard handlers, plus the `!`/`!!` entry point, with a mock terminal. Every profile is temporary; provider requests, DCG process responses, and shell execution are mocked. No real credentials, user policy files, live model requests, or destructive commands are needed.
+
+The session tests use the real extension factory, `DcgClient` parser, loader, event runner, tool registry, and codemode. A negative control without DCG proves that the shell-execution spy can be reached. Blocked calls must never reach it. Check nested execution-end events and parent IDs rather than assuming nested calls are transcript entries or that pre-execution blocks emit `tool_result`.
+
+Private TUI method access is confined to `tests/ui-contract.test.mjs`; production code uses public extension APIs. These tests do not simulate every terminal emulator. For terminal-specific failures, use a disposable profile and harmless commands, confirm that parallel DCG prompts appear one at a time, then interrupt a pending prompt and check that it disappears without execution. Never change your normal Pi settings to perform the smoke test.
+
+### Upstream follow-ups from #166
+
+Pi 1.1.0 can detach `tool_call` event input from the actual execution arguments when an earlier handler replaces the object. It also lacks a shared queue for concurrent dialogs from different extensions. The tests that name these limitations deliberately characterize the current behavior; they do not certify it as safe.
+
+An upstream fix should preserve input identity from the start of dispatch and coordinate terminal dialogs across extensions. Do not patch installed Pi files, replace bash, or weaken DCG policy to hide these gaps. When the host fixes them, update the shared baseline and replace the characterization assertions with the desired guarantees. Do not treat the local #166 work as closing those upstream requirements.
+
 ## Pull request checklist
 
 - Run `npm run -w packages/pi-dcg check`.

package/README.md

@@ -1,13 +1,27 @@
 # pi-dcg
 
-Guard Pi shell commands with [Destructive Command Guard (dcg)](https://github.com/Dicklesworthstone/destructive_command_guard) before they execute.
+Stop destructive shell commands before they damage your system.
+
+`pi-dcg` brings [Destructive Command Guard (dcg)](https://github.com/Dicklesworthstone/destructive_command_guard) policy checks into Pi, screening both agent-generated shell calls and your own `!` commands before execution.
+
+## Features
+
+- **Pre-execution protection** — block dangerous commands before Pi runs them.
+- **Guard agent and user commands** — cover built-in `bash` tool calls plus `!command` and `!!command` invocations.
+- **Actionable decisions** — surface matched rules and remediation while keeping hard denials non-overridable by the agent.
+- **Your policy stays yours** — honor dcg's Pi-specific profiles, packs, allowlists, exceptions, and audit history.
+- **Configurable failure posture** — choose fail-open convenience or fail-closed protection when dcg is unavailable.
 
 `pi-dcg` is a Pi extension bridge. It does not bundle dcg, replace dcg policy, or provide a sandbox.
 
+The TUI footer uses palette-neutral health labels, including the configured
+blocking/fail-open state when unavailable. It does not retain colors from an old
+theme. RPC confirmations and notifications remain separate from this terminal-only status.
+
 ## Requirements
 
-- Node.js 20.6 or newer
-- Pi 0.80 or newer
+- Node.js 22.19.0 or newer
+- Pi, supplied by the host; contract-tested against Pi 1.1.0
 - A separately installed `dcg` executable; dcg 0.6.8 or newer is recommended
 
 Install dcg using its [upstream installation instructions](https://github.com/Dicklesworthstone/destructive_command_guard#installation), review its release-verification guidance, and confirm that the binary is visible in the same environment as Pi:
@@ -40,24 +54,30 @@ pi -e /path/to/pi-mono/packages/pi-dcg
 
 By default, the extension checks both Pi shell events available to extensions:
 
-- agent calls to Pi's built-in `bash` tool;
+- agent calls to Pi's built-in `bash` tool, including nested calls through codemode (`on` and `only`) or `ctx.executeTool()`;
 - user `!command` and `!!command` invocations.
 
 Pi's separate RPC control-channel `{"type":"bash"}` command does not emit either event in current Pi releases and cannot be intercepted by `pi-dcg`; see [Limitations](#limitations).
 
 For every non-empty command, the extension starts dcg directly without a shell, sends a Claude-compatible `PreToolUse` payload on stdin, and waits for dcg's decision before Pi executes the command.
 
-Pi allows `tool_call` handlers to rewrite tool arguments in sequence. `pi-dcg` checks mutations made by earlier handlers, then seals both the approved `command` value and its input reference. If a later handler attempts to replace either one, Pi blocks the tool call rather than executing a command dcg did not check.
+Pi allows `tool_call` handlers to rewrite tool arguments in sequence. `pi-dcg` checks **in-place** mutations made by earlier handlers, then seals both the approved `command` value and its input reference. If a later handler attempts to replace either one, Pi blocks the tool call. Pi 1.1.0 has a separate argument-identity limitation when an earlier handler replaces the entire input object; see [Limitations](#limitations).
+
+DCG does not replace the bash executor, activate excluded tools, or bypass another extension's approval hooks.
 
 | dcg response | Pi behavior |
 | --- | --- |
 | Empty stdout / explicit `allow` | Execute the command |
 | `permissionDecision: "deny"` | Block and show bounded rule/remediation details |
 | `permissionDecision: "ask"` | Ask for confirmation when UI is available; otherwise block |
-| Bridge failure | Allow by default, visibly marking dcg unavailable; configurable to block |
+| Bridge failure | Allow by default, warning when UI is available; configurable to block |
 
 Hard denials are never converted into one-click approvals. When dcg provides an allow-once code, `pi-dcg` shows the exact `dcg allow-once ...` command only in a user-facing UI notification. It is deliberately excluded from the model-visible blocked tool result so an agent cannot redeem the exception itself.
 
+DCG confirmation dialogs run one at a time per extension instance, so parallel bash calls cannot replace each other's DCG prompt. Policy checks and allowed commands remain concurrent. Turn cancellation dismisses the active confirmation and blocks queued confirmations; runtime shutdown, including reload or session replacement, also cancels pending checks and confirmations. Cancellation blocks even with `PI_DCG_ON_ERROR=allow`, and a late dialog response cannot approve a cancelled call.
+
+RPC extension UI can confirm `ask` decisions. Print/JSON sessions without UI block them. RPC **agent tool calls** are distinct from the excluded RPC control-channel `bash` command.
+
 Run `/dcg` to probe the binary and show the active bridge configuration.
 
 ## Why this uses hook mode
@@ -130,6 +150,11 @@ This extension intercepts Pi events, not operating-system process execution. It
 
 `user_bash` handlers are first-result-wins in Pi. An earlier extension that fully handles `!` commands can prevent later handlers, including `pi-dcg`, from seeing them.
 
+Two Pi 1.1.0 composition limits remain:
+
+- If an earlier `tool_call` handler assigns a new object to `event.input`, Pi can execute the original arguments while DCG checks the replacement. Integrations must mutate argument fields in place, not replace the input object. DCG cannot repair this host contract after the replacement has occurred.
+- The confirmation queue covers this DCG instance, not other extensions' dialogs. Concurrent dialogs from another extension can still displace a prompt in Pi's shared editor slot. Cross-extension dialog scheduling requires host-level coordination.
+
 Use a container, VM, sandbox, restricted credentials, backups, and review controls when a hard security boundary is required.
 
 ## Development

package/SECURITY.md

@@ -14,7 +14,7 @@ Do not open a public issue for a suspected vulnerability. Report privately throu
 
 The bridge:
 
-- intercepts Pi's built-in agent `bash` calls and, by default, user `!`/`!!` commands;
+- intercepts Pi's built-in agent `bash` calls, including codemode and other `ctx.executeTool()` calls, and, by default, user `!`/`!!` commands;
 - starts the configured dcg executable directly without a shell;
 - sends command text to that local child process on stdin;
 - sets the child cwd to Pi's current working directory;
@@ -23,7 +23,8 @@ The bridge:
 - keeps allow-once commands out of model-visible denial results and shows them only through user-facing UI notifications;
 - captures but does not log or forward dcg stderr;
 - bounds child output and denial text;
-- blocks a command when its check is cancelled;
+- forwards turn/runtime cancellation to policy checks and confirmation dialogs, blocking even in fail-open mode;
+- serializes this extension instance's confirmation dialogs without serializing ordinary policy checks or allowing approvals to carry over to another call;
 - preserves hard dcg denials without a one-click bypass.
 
 The child receives Pi's environment because dcg policy is intentionally configured through `DCG_*` variables. `pi-dcg` additionally sets `PI_CODING_AGENT=true`, `DCG_NO_SELF_HEAL=1`, and no-color flags for that child. Environment values are never logged or sent over the network by this package.
@@ -34,6 +35,16 @@ Bridge failures default to visible fail-open behavior to match dcg's integration
 
 This setting cannot detect dcg's internal intentional fail-open paths, which may return a valid allow after size, parse, AST, or deadline fallback. Configure dcg itself for stricter analysis where supported.
 
+Turn abort and runtime shutdown cancel active and queued DCG confirmations. Late UI responses cannot reverse cancellation. Print/JSON sessions without UI block `ask`; RPC clients can answer through the extension UI protocol. This does not extend coverage to RPC control-channel shell commands.
+
+### Pi 1.1.0 composition limits
+
+Command sealing protects against later `tool_call` mutations, not a replacement of the entire input object by an earlier handler. Pi retains the original execution arguments in that case, but DCG sees the replacement. An upstream argument-identity fix is needed before claiming that every possible hook composition executes exactly the checked command. Earlier handlers must mutate argument fields in place.
+
+The confirmation queue is local to one DCG extension instance. Pi's terminal dialog slot is shared across extensions, and another extension's simultaneous dialog can still displace a pending prompt. This does not grant approval to the displaced call, but it can leave that call waiting until cancellation. General dialog scheduling must be fixed in Pi rather than by replacing the bash executor.
+
+The real-session tests record these host limitations explicitly. They are not passing safety guarantees. No global fail-open switch, model-callable bypass, executor replacement, new credential flow, or additional command logging is introduced.
+
 ### Known bypasses
 
 The extension cannot intercept arbitrary process creation. Important bypasses include:
@@ -54,4 +65,4 @@ Use least-privilege credentials, version control, backups, containers/VMs, and O
 
 ## Telemetry
 
-On startup, the package sends a best-effort install/update telemetry ping to `mocito.dev` once per package version unless disabled by CI, `PI_OFFLINE`, `PI_TELEMETRY`, or Pi's `enableInstallTelemetry` setting. The ping includes only package name/version and platform/runtime/architecture. It never includes commands, paths, dcg decisions, stderr, configuration, environment variables, prompts, credentials, or policy.
+On startup, `@mocito/install-telemetry` sends a best-effort install/update telemetry ping to the configured telemetry endpoint once per package version unless disabled by CI, `PI_OFFLINE`, `PI_TELEMETRY`, or Pi's `enableInstallTelemetry` setting. The ping includes only package name/version and platform/runtime/architecture. It never includes commands, paths, dcg decisions, stderr, configuration, environment variables, prompts, credentials, or policy.

package/extensions/index.ts

@@ -4,6 +4,7 @@ import {
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { loadDcgBridgeConfig, type DcgBridgeConfig } from "../src/config.js";
+import { ConfirmationQueue } from "../src/confirmation-queue.js";
 import {
   DcgClient,
   DcgProcessError,
@@ -100,26 +101,26 @@ function setStatus(
   config: DcgBridgeConfig,
   version?: string,
 ): void {
-  if (!ctx.hasUI) return;
+  if (ctx.mode !== "tui") return;
   try {
     if (health === "active") {
       const label = version ? `dcg ${version}` : "dcg active";
-      ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("success", `shield ${label}`));
+      ctx.ui.setStatus(STATUS_KEY, `shield ${label}`);
       return;
     }
     if (health === "degraded") {
       const behavior = config.onError === "block" ? "blocking" : "fail-open";
-      ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("warning", `shield dcg unavailable (${behavior})`));
+      ctx.ui.setStatus(STATUS_KEY, `shield dcg unavailable (${behavior})`);
       return;
     }
-    ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg("muted", "shield dcg checking"));
+    ctx.ui.setStatus(STATUS_KEY, "shield dcg checking");
   } catch {
     // Status rendering is advisory and must never alter a dcg decision.
   }
 }
 
 function clearStatus(ctx: ExtensionContext): void {
-  if (!ctx.hasUI) return;
+  if (ctx.mode !== "tui") return;
   try {
     ctx.ui.setStatus(STATUS_KEY, undefined);
   } catch {
@@ -135,6 +136,8 @@ export default function piDcg(
 
   const config = dependencies.config ?? loadDcgBridgeConfig();
   const client = dependencies.client ?? new DcgClient(config);
+  const confirmations = new ConfirmationQueue();
+  const lifetime = new AbortController();
   let version: string | undefined;
   let lastNotifiedError: string | undefined;
   let warnedAboutVersion = false;
@@ -160,15 +163,24 @@ export default function piDcg(
     cwd: string,
     ctx: ExtensionContext,
   ): Promise<GuardOutcome> => {
+    // Capture once: ctx.signal is a live getter and may change when a run ends.
+    const turnSignal = ctx.signal;
+    const signal = turnSignal ? AbortSignal.any([turnSignal, lifetime.signal]) : lifetime.signal;
+    const cancelled = (): GuardOutcome => ({
+      block: true,
+      reason: "dcg check or confirmation was cancelled; the command was not run.",
+    });
+    if (signal.aborted) return cancelled();
     if (!command.trim()) return { block: false };
 
     let result;
     try {
-      result = await client.check(command, cwd, ctx.signal);
+      result = await client.check(command, cwd, signal);
+      if (signal.aborted) return cancelled();
       markHealthy(ctx);
     } catch (error) {
-      if (error instanceof DcgProcessError && error.code === "aborted") {
-        return { block: true, reason: "dcg check was cancelled; the command was not run." };
+      if (signal.aborted || (error instanceof DcgProcessError && error.code === "aborted")) {
+        return cancelled();
       }
       markDegraded(ctx, error);
       if (config.onError === "block") {
@@ -196,13 +208,16 @@ export default function piDcg(
 
     let approved = false;
     try {
-      approved = await ctx.ui.confirm(
+      approved = await confirmations.confirm(signal, () => ctx.ui.confirm(
         "dcg requires confirmation",
         `Command:\n${truncate(command, MAX_COMMAND_PREVIEW_CHARS)}\n\n${reason}`,
-      );
+        { signal },
+      ));
     } catch {
+      if (signal.aborted) return cancelled();
       return { block: true, reason: `${reason}\n\nThe confirmation dialog failed, so the command was blocked.` };
     }
+    if (signal.aborted) return cancelled();
     return approved ? { block: false } : { block: true, reason: `${reason}\n\nThe command was not approved.` };
   };
 
@@ -231,8 +246,8 @@ export default function piDcg(
     const outcome = await guard(command, ctx.cwd, ctx);
     if (outcome.block) return { block: true, reason: outcome.reason };
 
-    // Pi executes this same input object after all tool_call handlers finish.
-    // Seal the checked value so a later extension cannot replace it unchecked.
+    // Seal against later mutations. Pi 1.1.0 cannot reconcile an input reference
+    // replaced by an earlier handler; see the documented upstream limitation.
     sealCheckedBashCommand(event, command);
     return undefined;
   });
@@ -277,6 +292,7 @@ export default function piDcg(
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
+    lifetime.abort();
     clearStatus(ctx);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-dcg",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Guard Pi shell commands with Destructive Command Guard.",
   "type": "module",
   "license": "MIT",
@@ -53,15 +53,18 @@
     "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.80.0",
-    "@types/node": "^26.1.0",
-    "tsx": "^4.23.0",
-    "typescript": "^6.0.3"
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@types/node": "^26.6.3",
+    "tsx": "^4.23.15",
+    "typescript": "^7.0.2"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=20.6.0"
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "@mocito/install-telemetry": "0.1.1"
   }
 }

package/src/confirmation-queue.ts

@@ -0,0 +1,41 @@
+/** Wait without retaining an abort listener or accepting a late UI response. */
+function abortable<T>(pending: Promise<T>, signal: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = (): void => reject(signal.reason);
+    const cleanup = (): void => signal.removeEventListener("abort", onAbort);
+    // Observe both outcomes even when cancellation wins the race.
+    pending.then(
+      (value) => { cleanup(); resolve(value); },
+      (error: unknown) => { cleanup(); reject(error); },
+    );
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+
+/** Pi's terminal dialogs share one editor slot. Queue only this bridge's prompts. */
+export class ConfirmationQueue {
+  private tail: Promise<void> = Promise.resolve();
+
+  async confirm(signal: AbortSignal, show: () => Promise<boolean>): Promise<boolean> {
+    const previous = this.tail;
+    let release!: () => void;
+    const current = new Promise<void>((resolve) => { release = resolve; });
+    // A cancelled waiter must not let its successors overtake the current dialog.
+    this.tail = previous.then(() => current);
+    try {
+      await abortable(previous, signal);
+      signal.throwIfAborted();
+      const approved = await abortable(Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return show();
+      }), signal);
+      return !signal.aborted && approved === true;
+    } finally {
+      release();
+    }
+  }
+}

package/src/install-telemetry.ts

@@ -1,12 +1,11 @@
 import { readFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { reportInstallTelemetry as report } from "@mocito/install-telemetry";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
 const PACKAGE_NAME = "pi-dcg";
-const INSTALL_TELEMETRY_URL = "https://mocito.dev/api/report-install";
-const INSTALL_TELEMETRY_TIMEOUT_MS = 5000;
+const INSTALL_TELEMETRY_ENDPOINT = "https://mocito.dev/api/report-install";
 const CI_ENVIRONMENT_VARIABLES = [
   "APPVEYOR",
   "BITBUCKET_BUILD_NUMBER",
@@ -24,10 +23,6 @@ const CI_ENVIRONMENT_VARIABLES = [
   "VERCEL",
 ];
 
-interface InstallTelemetryState {
-  lastReportedVersion?: string;
-}
-
 interface PiSettingsDocument {
   enableInstallTelemetry?: unknown;
 }
@@ -51,18 +46,15 @@ function isPresentEnvFlag(value: string | undefined): boolean {
   return normalized !== "0" && normalized !== "false" && normalized !== "no";
 }
 
-function isCiEnvironment(): boolean {
-  if (isTruthyEnvFlag(process.env.CI)) return true;
-  return CI_ENVIRONMENT_VARIABLES.some((name) => isPresentEnvFlag(process.env[name]));
-}
-
-function isInstallTelemetryEnabled(): boolean {
-  if (isCiEnvironment()) return false;
-  if (isTruthyEnvFlag(process.env.PI_OFFLINE)) return false;
-  if (process.env.PI_TELEMETRY !== undefined) return isTruthyEnvFlag(process.env.PI_TELEMETRY);
+export function isInstallTelemetryEnabled(env: NodeJS.ProcessEnv = process.env, settingsPath = join(getAgentDir(), "settings.json")): boolean {
+  if (isTruthyEnvFlag(env.CI)) return false;
+  if (CI_ENVIRONMENT_VARIABLES.some((name) => isPresentEnvFlag(env[name]))) return false;
+  if (isTruthyEnvFlag(env.PI_OFFLINE)) return false;
 
-  const settings = readJsonFile(join(getAgentDir(), "settings.json")) as PiSettingsDocument;
-  return settings.enableInstallTelemetry !== false;
+  const settings = readJsonFile(settingsPath) as PiSettingsDocument;
+  if (settings.enableInstallTelemetry === false) return false;
+  if (env.PI_TELEMETRY !== undefined) return isTruthyEnvFlag(env.PI_TELEMETRY);
+  return true;
 }
 
 function getPackageVersion(): string {
@@ -70,35 +62,16 @@ function getPackageVersion(): string {
   return typeof packageJson.version === "string" && packageJson.version.length > 0 ? packageJson.version : "0.0.0";
 }
 
-function getInstallTelemetryUserAgent(version: string): string {
-  const runtimeVersions = process.versions as NodeJS.ProcessVersions & { bun?: string };
-  const runtime = runtimeVersions.bun ? `bun/${runtimeVersions.bun}` : `node/${process.version}`;
-  return `${PACKAGE_NAME}/${version} (${process.platform}; ${runtime}; ${process.arch})`;
-}
-
-async function reportInstallTelemetryAsync(): Promise<void> {
+export function reportInstallTelemetry(): void {
   try {
-    if (!isInstallTelemetryEnabled()) return;
-
-    const version = getPackageVersion();
-    const extensionsDir = join(getAgentDir(), "extensions");
-    const statePath = join(extensionsDir, "pi-dcg-install.json");
-    const state = readJsonFile(statePath) as InstallTelemetryState;
-    if (state.lastReportedVersion === version) return;
-
-    await mkdir(extensionsDir, { recursive: true });
-    await writeFile(statePath, `${JSON.stringify({ lastReportedVersion: version }, null, 2)}\n`, "utf8");
-
-    const params = new URLSearchParams({ tool: PACKAGE_NAME, version });
-    await fetch(`${INSTALL_TELEMETRY_URL}?${params.toString()}`, {
-      headers: { "User-Agent": getInstallTelemetryUserAgent(version) },
-      signal: AbortSignal.timeout(INSTALL_TELEMETRY_TIMEOUT_MS),
-    });
+    void report({
+      endpoint: INSTALL_TELEMETRY_ENDPOINT,
+      tool: PACKAGE_NAME,
+      version: getPackageVersion(),
+      statePath: join(getAgentDir(), "extensions", "pi-dcg-install.json"),
+      enabled: isInstallTelemetryEnabled(),
+    }).catch(() => undefined);
   } catch {
-    // Best-effort telemetry: ignore settings, filesystem, and network failures.
+    // Best-effort telemetry: ignore local policy and filesystem failures.
   }
 }
-
-export function reportInstallTelemetry(): void {
-  void reportInstallTelemetryAsync();
-}