@ken-jo/agent-connector 0.4.79 → 0.4.92

package/dist/{action-OHGFVKMC.js → action-CVIEPX4U.js}

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import {
   fail
-} from "./chunk-VKRGQLY4.js";
+} from "./chunk-5Z36KVU2.js";
 import {
   runAction
-} from "./chunk-LKAVD4HP.js";
+} from "./chunk-447JWFZO.js";
 import "./chunk-OP4KBXUO.js";
-import "./chunk-LN76OGNR.js";
-import "./chunk-S4E6QQEM.js";
-import "./chunk-ZXX5DVSE.js";
-import "./chunk-4FWETID5.js";
+import "./chunk-Z2MRSS2I.js";
+import "./chunk-FO5CEXXN.js";
+import "./chunk-FBCBHEGB.js";
 import "./chunk-KHO5WNTP.js";
-import "./chunk-7NXEHZAK.js";
-import "./chunk-PZHB5TVA.js";
-import "./chunk-X457NOFE.js";
-import "./chunk-56R2ER7K.js";
-import "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+import "./chunk-IVAWP6HH.js";
+import "./chunk-JVO6NBTT.js";
+import "./chunk-AY3VFNOH.js";
+import "./chunk-KA55FISM.js";
+import "./chunk-NBYKLUF6.js";
+import "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 
 // src/cli/commands/action.ts
 import { parseArgs } from "util";
@@ -52,4 +52,4 @@ async function run(argv) {
 export {
   run
 };
-//# sourceMappingURL=action-OHGFVKMC.js.map
+//# sourceMappingURL=action-CVIEPX4U.js.map

package/dist/{amazon-q-B52EY2SV.js → amazon-q-TIT7FIW3.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-BEFVJ2OE.js";
 import {
   BaseAdapter
-} from "./chunk-VVFDU4IX.js";
+} from "./chunk-WFEHWTLM.js";
 import {
   buildWrappedStdio,
   isHomeBinHookCommand
-} from "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+} from "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 
 // src/adapters/amazon-q/index.ts
 import { existsSync, statSync } from "fs";
@@ -563,4 +563,4 @@ export {
   adapter,
   amazon_q_default as default
 };
-//# sourceMappingURL=amazon-q-B52EY2SV.js.map
+//# sourceMappingURL=amazon-q-TIT7FIW3.js.map

package/dist/{amp-UXABVUKC.js → amp-NF3OAAUG.js}

@@ -8,12 +8,12 @@ import {
 import {
   BaseAdapter,
   renderSkillMd
-} from "./chunk-VVFDU4IX.js";
+} from "./chunk-WFEHWTLM.js";
 import {
   buildWrappedStdio
-} from "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+} from "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 
 // src/adapters/amp/index.ts
 import { existsSync } from "fs";
@@ -608,4 +608,4 @@ export {
   adapter,
   amp_default as default
 };
-//# sourceMappingURL=amp-UXABVUKC.js.map
+//# sourceMappingURL=amp-NF3OAAUG.js.map

package/dist/{antigravity-RZHN53VB.js → antigravity-7LPK7QOY.js}

@@ -3,16 +3,16 @@ import {
   AntigravityAdapter,
   adapter,
   antigravity_default
-} from "./chunk-4HVQ7IUM.js";
+} from "./chunk-DI5S6TXJ.js";
 import "./chunk-H53QZQJI.js";
 import "./chunk-BEFVJ2OE.js";
-import "./chunk-VVFDU4IX.js";
-import "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+import "./chunk-WFEHWTLM.js";
+import "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 export {
   AntigravityAdapter,
   adapter,
   antigravity_default as default
 };
-//# sourceMappingURL=antigravity-RZHN53VB.js.map
+//# sourceMappingURL=antigravity-7LPK7QOY.js.map

package/dist/antigravity-cli-MDEMPPAH.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+import {
+  AntigravityAdapter,
+  adapter
+} from "./chunk-DI5S6TXJ.js";
+import {
+  addLedgerOwner,
+  createLedgerEntry,
+  describeJsonValue,
+  dropLedgerEntry,
+  findLedgerEntry,
+  hashJsonValue,
+  jsonDeepEquals,
+  ledgerEntriesOwnedBy,
+  loadConfigPatchLedger,
+  removeLedgerOwner,
+  saveConfigPatchLedger
+} from "./chunk-NBYKLUF6.js";
+import "./chunk-H53QZQJI.js";
+import "./chunk-BEFVJ2OE.js";
+import "./chunk-WFEHWTLM.js";
+import {
+  buildHomeBinStatuslineCommand,
+  isHomeBinStatuslineCommand
+} from "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
+
+// src/adapters/antigravity-cli/index.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOST = "antigravity-cli";
+var STATUSLINE_KEY = "statusLine";
+var AntigravityCliAdapter = class _AntigravityCliAdapter extends AntigravityAdapter {
+  id = HOST;
+  name = "Antigravity CLI";
+  /**
+   * Capabilities = the inherited IDE surface, with the two CLI-specific
+   * divergences applied on top:
+   *
+   *   - `supportsStatusline: true` — the `agy` custom status line, live-verified
+   *     above (the IDE app does NOT advertise statusline; its payload is unverified).
+   *   - `sessionStart: false` — the `agy` CLI does NOT recognize a SessionStart
+   *     hook. LIVE-VERIFIED (agy): the binary's recognized hook events are exactly
+   *     PreToolUse / PostToolUse / PreInvocation / PostInvocation / Stop — the
+   *     `/hooks` UI lists only those five and writing both SessionStart + PreToolUse
+   *     into hooks.json loads ONLY PreToolUse. Declaring SessionStart on the IDE
+   *     `antigravity` adapter is left UNCHANGED (this finding is agy-CLI-specific
+   *     and was NOT verified for the IDE app). This flag is the source of truth for
+   *     the docs hooks-matrix + the fleet-wide never-silent-drop contract; the
+   *     matching install-time warn-skip is driven by {@link supportedHookEvents}.
+   *
+   * Everything else is spread from the IDE adapter's own capabilities so the two
+   * surfaces stay in lock-step (a parent field added later flows in automatically).
+   * `super.capabilities` is unusable here: the parent's `capabilities` is an
+   * instance FIELD (not on the prototype), so it resolves to undefined in a
+   * subclass field initializer — spread the IDE singleton instead.
+   */
+  capabilities = {
+    ...adapter.capabilities,
+    supportsStatusline: true,
+    sessionStart: false
+  };
+  /**
+   * The hook events the `agy` CLI actually recognizes. LIVE-VERIFIED: agy's hook
+   * event tokens are exactly PreToolUse / PostToolUse / PreInvocation /
+   * PostInvocation / Stop — confirmed by the `/hooks` UI listing only those five,
+   * by the binary's hook-event tokens, and by agy loading ONLY PreToolUse when
+   * both SessionStart + PreToolUse are written into hooks.json. SessionStart is
+   * therefore DROPPED: a declared SessionStart hook warn-skips at install rather
+   * than writing an inert hooks.json entry that never loads / never fires / never
+   * shows in `/hooks`. NOTE: PreInvocation / PostInvocation are agy-only events
+   * with no canonical AC analog — left unmapped here (a possible future
+   * nativeHooks enhancement, NOT this fix). This narrows the IDE's
+   * {@link AntigravityAdapter.supportedHookEvents} (which still includes
+   * SessionStart for the IDE app, where this finding was not verified).
+   */
+  static CLI_SUPPORTED_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "Stop"]);
+  supportedHookEvents() {
+    return _AntigravityCliAdapter.CLI_SUPPORTED_EVENTS;
+  }
+  // ── Detection ────────────────────────────────────────────────────────────
+  /**
+   * Probe the CLI's runtime markers, DISTINCT from the IDE app even though the
+   * two share `~/.gemini/antigravity/`: the `agy` binary at ~/.local/bin/agy
+   * (the definitive CLI marker, CONFIRMED present) and the shared
+   * ~/.gemini/antigravity/ tree (or a user-scope mcp_config candidate / the
+   * project config). Reported before the IDE adapter in the registry so the
+   * more-specific CLI marker (the `agy` binary) wins host detection. Note: a
+   * machine with ONLY the IDE (no `agy` binary) will not match here, while one
+   * with the CLI matches on the binary regardless of the shared config dir.
+   */
+  detectInstalled(projectDir) {
+    const home = homedir();
+    const userConfig = this.resolveUserConfigPath();
+    const agyBin = join(home, ".local", "bin", "agy");
+    const sharedDir = join(home, ".gemini", "antigravity");
+    const projectConfig = join(projectDir, ".agents", "mcp_config.json");
+    const cliMarker = existsSync(agyBin);
+    const userInstalled = cliMarker || existsSync(sharedDir) || this.userConfigCandidates().some((parts) => existsSync(join(home, ...parts)));
+    const projInstalled = existsSync(projectConfig);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projectConfig : userConfig;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? scope === "project" ? `found project Antigravity CLI config at ${projectConfig}` : `found Antigravity CLI (agy) at ${agyBin} / shared ${sharedDir}` : `no Antigravity CLI install at ${agyBin}, ${sharedDir}, or ${projectConfig}`,
+      // The `agy` binary is a high-confidence CLI marker; matching only the shared
+      // config dir is weaker (it could be a pure-IDE install).
+      confidence: cliMarker ? "high" : installed ? "medium" : "low"
+    };
+  }
+  /**
+   * MCP user-config path — LIVE-PROVEN for `agy` v1.0.5 (2026-06-04). The
+   * standalone CLI reads user MCP servers from `~/.gemini/config/mcp_config.json`
+   * (root key `mcpServers`), NOT the IDE's `~/.gemini/antigravity/mcp_config.json`:
+   * a real `agy -p` session spawned an MCP server ONLY when it was placed in
+   * `config/` (negative control: a server in `antigravity/` was ignored), and the
+   * binary carries the error string "failed to read mcp_config.json" + a literal
+   * "/.gemini/config" path. `agy mcp` is TUI-only (no headless add) and there is
+   * no `--mcp-config` flag. So the CLI must PREFER `config/` over the inherited
+   * `antigravity/` default; the IDE path stays as a prefer-existing fallback.
+   * (Skills/workflows/hooks dirs remain inherited; project scope
+   * `<proj>/.agents/mcp_config.json` is already correct and live-proven.)
+   */
+  static CLI_USER_CONFIG_CANDIDATES = [
+    [".gemini", "config", "mcp_config.json"],
+    // CONFIRMED canonical for agy v1.0.5
+    [".gemini", "antigravity", "mcp_config.json"]
+    // legacy IDE layout (prefer-existing)
+  ];
+  userConfigCandidates() {
+    return _AntigravityCliAdapter.CLI_USER_CONFIG_CANDIDATES;
+  }
+  // ── Statusline surface (the `agy` custom status line) ─────────────────────
+  // Wires settings.json `statusLine` = { enabled:true, command:<home-bin
+  // statusline cmd> } through the SAME refcounted ownership ledger as configPatch
+  // (the ledger primitives are surface-agnostic). antigravity-cli does NOT
+  // advertise supportsConfigPatch, so — like qwen-code — this adapter performs the
+  // set-if-absent write directly with the exported ledger primitives. Semantics
+  // are identical to claude-code/qwen-code: never clobber a `statusLine`
+  // agent-connector does not own (skip-warn), record prior state + owner
+  // (refcounted across connectors), reversible by uninstallStatusline
+  // (last-owner-verified delete).
+  //
+  // The home-bin command makes agy exec
+  // `<homeBin> statusline antigravity-cli --connector <id>` on every refresh,
+  // which re-imports the connector module and renders the line (runtime/
+  // statusline-entrypoint). The status line lives in the GLOBAL
+  // ~/.gemini/antigravity-cli/settings.json (agy has no project-scope statusLine),
+  // so this surface is user-scope regardless of the install scope. No telemetry
+  // in v1.
+  /**
+   * The `agy` settings.json that holds the statusLine config. LIVE-VERIFIED at
+   * ~/.gemini/antigravity-cli/settings.json (the CLI's own global home — distinct
+   * from the shared ~/.gemini/config/mcp_config.json the MCP surface writes). agy
+   * stores statusLine as a GLOBAL UI setting with no project-scope variant, so the
+   * path is scope-independent.
+   */
+  statuslineSettingsPath() {
+    return join(homedir(), ".gemini", "antigravity-cli", "settings.json");
+  }
+  /** The statusLine config value agent-connector writes at `statusLine`. */
+  statuslineValue(ctx) {
+    const command = buildHomeBinStatuslineCommand(ctx.homeBinPath, HOST, ctx.connector.id);
+    return { enabled: true, command };
+  }
+  installStatusline(ctx) {
+    const { connector } = ctx;
+    if (connector.statusline == null) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no statusline" }];
+    }
+    if (connector.platforms[HOST]?.statusline === false) {
+      return [{ platform: this.id, action: "skip", detail: `statusline disabled for ${HOST}` }];
+    }
+    const filePath = this.statuslineSettingsPath();
+    const symlink = this.symlinkPathWarning(filePath);
+    if (symlink) return [symlink];
+    if (this.isPresentButUnparseable(filePath)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not parseable; statusline left unapplied (back it up / fix it, then re-run)`
+        }
+      ];
+    }
+    const settings = this.readJson(filePath) ?? {};
+    if (typeof settings !== "object" || Array.isArray(settings)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `existing ${filePath} is not a JSON object; statusline left unapplied`
+        }
+      ];
+    }
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const desired = this.statuslineValue(ctx);
+    const leaf = settings[STATUSLINE_KEY];
+    const entry = findLedgerEntry(ledger, HOST, filePath, STATUSLINE_KEY);
+    const changes = [];
+    if (leaf === void 0) {
+      settings[STATUSLINE_KEY] = desired;
+      this.writeJson(filePath, settings, ctx.dryRun);
+      if (entry) {
+        entry.writtenValue = desired;
+        entry.writtenValueHash = hashJsonValue(desired);
+        addLedgerOwner(entry, connector.id, connector.version);
+      } else {
+        createLedgerEntry(ledger, {
+          platform: HOST,
+          file: filePath,
+          key: STATUSLINE_KEY,
+          value: desired,
+          connectorId: connector.id,
+          connectorVersion: connector.version
+        });
+      }
+      if (!ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+      changes.push({
+        platform: this.id,
+        action: "create",
+        path: filePath,
+        detail: `statusline ${STATUSLINE_KEY}: <absent> \u2192 ${describeJsonValue(desired)}`
+      });
+      return changes;
+    }
+    const leafValue = leaf;
+    if (!entry) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY} skipped: already set to ${describeJsonValue(leafValue)} (not created by agent-connector) \u2014 left untouched`
+        }
+      ];
+    }
+    if (!jsonDeepEquals(leafValue, entry.writtenValue)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY}: value changed since install (current ${describeJsonValue(leafValue)}, wrote ${describeJsonValue(entry.writtenValue)}); leaving in place`
+        }
+      ];
+    }
+    if (jsonDeepEquals(desired, leafValue)) {
+      const owners = entry.owners.map((o) => o.connectorId);
+      if (addLedgerOwner(entry, connector.id, connector.version)) {
+        if (!ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+        return [
+          {
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${STATUSLINE_KEY} already installed; registered as co-owner (co-owned with ${owners.join(", ")})`
+          }
+        ];
+      }
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path: filePath,
+          detail: `statusline ${STATUSLINE_KEY} already installed`
+        }
+      ];
+    }
+    return [
+      {
+        platform: this.id,
+        action: "warn",
+        path: filePath,
+        detail: `statusline ${STATUSLINE_KEY} skipped: already owned by ${entry.owners.map((o) => o.connectorId).join(", ")} with a different value \u2014 left untouched`
+      }
+    ];
+  }
+  uninstallStatusline(ctx) {
+    const ledger = loadConfigPatchLedger(ctx.dataRoot);
+    const owned = ledgerEntriesOwnedBy(ledger, HOST, ctx.connector.id).filter(
+      (e) => e.key === STATUSLINE_KEY
+    );
+    if (owned.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: "statusline: no ownership recorded; left untouched"
+        }
+      ];
+    }
+    const changes = [];
+    let ledgerMutated = false;
+    const byFile = /* @__PURE__ */ new Map();
+    for (const entry of owned) {
+      const bucket = byFile.get(entry.file) ?? [];
+      bucket.push(entry);
+      byFile.set(entry.file, bucket);
+    }
+    for (const [filePath, entries] of byFile) {
+      const symlink = this.symlinkPathWarning(filePath);
+      if (symlink) {
+        changes.push(symlink);
+        continue;
+      }
+      const unparseable = this.isPresentButUnparseable(filePath);
+      const settings = unparseable ? null : this.readJson(filePath);
+      let fileMutated = false;
+      for (const entry of entries) {
+        const { lastOwner } = removeLedgerOwner(entry, ctx.connector.id);
+        ledgerMutated = true;
+        if (!lastOwner) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} retained: still owned by ${entry.owners.map((o) => o.connectorId).join(", ")}`
+          });
+          continue;
+        }
+        dropLedgerEntry(ledger, entry);
+        if (unparseable) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `statusline ${entry.key}: ${filePath} is not parseable; key left in place (ownership released)`
+          });
+          continue;
+        }
+        if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} already absent (no settings file); ownership record dropped`
+          });
+          continue;
+        }
+        const leaf = settings[entry.key];
+        if (leaf === void 0) {
+          changes.push({
+            platform: this.id,
+            action: "skip",
+            path: filePath,
+            detail: `statusline ${entry.key} already absent; ownership record dropped`
+          });
+          continue;
+        }
+        if (entry.prior?.present !== false || !jsonDeepEquals(leaf, entry.writtenValue)) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            path: filePath,
+            detail: `statusline ${entry.key}: value changed since install (current ${describeJsonValue(leaf)}, wrote ${describeJsonValue(entry.writtenValue)}); left in place`
+          });
+          continue;
+        }
+        delete settings[entry.key];
+        fileMutated = true;
+        changes.push({
+          platform: this.id,
+          action: "remove",
+          path: filePath,
+          detail: `statusline ${entry.key} removed (was ${describeJsonValue(entry.writtenValue)})`
+        });
+      }
+      if (fileMutated && settings) this.writeJson(filePath, settings, ctx.dryRun);
+    }
+    if (ledgerMutated && !ctx.dryRun) saveConfigPatchLedger(ctx.dataRoot, ledger);
+    return changes;
+  }
+  /**
+   * Parse the `agy` statusLine stdin JSON into the normalized
+   * {@link StatuslineContext}. agy pipes a JSON object on stdin
+   * (model/context_window/workspace/…); fields the payload omits stay undefined.
+   * `raw` keeps the verbatim payload (incl. version/agent_state/vcs/plan_tier/
+   * quota/email/terminal_width). agy has no cost analog, so `ctx.cost` is left
+   * undefined. LIVE-CAPTURED against agy v1.0.10 (see header / AgyStatuslineInput).
+   */
+  parseStatusInput(raw) {
+    const input = raw ?? {};
+    const ctx = {
+      host: HOST,
+      capabilities: this.capabilities,
+      raw
+    };
+    const sessionId = typeof input.conversation_id === "string" && input.conversation_id !== "" ? input.conversation_id : typeof input.session_id === "string" && input.session_id !== "" ? input.session_id : void 0;
+    if (sessionId !== void 0) ctx.sessionId = sessionId;
+    const cwd = typeof input.cwd === "string" ? input.cwd : typeof input.workspace?.current_dir === "string" ? input.workspace.current_dir : void 0;
+    if (cwd !== void 0) ctx.cwd = cwd;
+    if (typeof input.transcript_path === "string") ctx.transcriptPath = input.transcript_path;
+    const model = {};
+    if (typeof input.model?.id === "string") model.id = input.model.id;
+    if (typeof input.model?.display_name === "string") model.displayName = input.model.display_name;
+    if (model.id !== void 0 || model.displayName !== void 0) ctx.model = model;
+    const cw = input.context_window;
+    if (cw) {
+      const context = {};
+      if (typeof cw.context_window_size === "number") context.maxTokens = cw.context_window_size;
+      if (typeof cw.total_input_tokens === "number" || typeof cw.total_output_tokens === "number") {
+        context.usedTokens = (cw.total_input_tokens ?? 0) + (cw.total_output_tokens ?? 0);
+      }
+      if (typeof cw.used_percentage === "number") context.percent = cw.used_percentage;
+      if (context.usedTokens !== void 0 || context.maxTokens !== void 0 || context.percent !== void 0) {
+        ctx.context = context;
+      }
+    }
+    return ctx;
+  }
+  /** Format the rendered status line into agy's native reply: stdout = line, exit 0. */
+  formatStatusOutput(rendered) {
+    return { exitCode: 0, stdout: rendered };
+  }
+  // ── Diagnostics: add the statusline check on top of the inherited IDE checks ─
+  getHealthChecks(ctx) {
+    const checks = [...super.getHealthChecks(ctx)];
+    const settingsPath = this.statuslineSettingsPath();
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const statuslineLedgerOwned = ledgerEntriesOwnedBy(
+      loadConfigPatchLedger(ctx.dataRoot),
+      HOST,
+      connectorId
+    ).some((e) => e.key === STATUSLINE_KEY);
+    if ((ctx.connector.statusline != null || statuslineLedgerOwned) && ctx.connector.platforms[HOST]?.statusline !== false) {
+      checks.push({
+        name: `${this.name}: statusline wired`,
+        check: () => {
+          const settings = this.readJson(settingsPath);
+          const command = settings?.statusLine?.command;
+          if (command === void 0) {
+            return { status: "FAIL", detail: `statusLine not set in ${settingsPath}` };
+          }
+          if (typeof command === "string" && isHomeBinStatuslineCommand(command, homeBin, connectorId)) {
+            return { status: "OK", detail: "statusLine command present" };
+          }
+          return {
+            status: "FAIL",
+            detail: `statusLine in ${settingsPath} is not agent-connector's (left untouched)`
+          };
+        }
+      });
+    }
+    return checks;
+  }
+};
+var adapter2 = new AntigravityCliAdapter();
+var antigravity_cli_default = adapter2;
+export {
+  AntigravityCliAdapter,
+  adapter2 as adapter,
+  antigravity_cli_default as default
+};
+//# sourceMappingURL=antigravity-cli-MDEMPPAH.js.map