waitspin 0.1.7 → 0.1.9

package/dist/cli.js

@@ -3,9 +3,10 @@ import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod, cp, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { access, chmod, cp, mkdir, readFile, readdir, rename, rm, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { parse as parseJsonc, printParseErrorCode, } from "jsonc-parser";
 import { experimentalAllInstallTargets, experimentalInstallTarget, isExperimentalCliTargetName, runExperimentalCliTargetInstall, runExperimentalCliTargetStatus, runExperimentalCliTargetUninstall, } from "./targets/experimental-cli.js";
 import { formatBidCheckoutResult, formatBidsListResult, formatCampaignCreateResult, formatInitResult, formatInstallAllResult, formatMarketResult, formatStatusAllResult, formatTargetInstallResult, formatTargetStatusResult, formatTargetUninstallResult, formatWalletConnectResult, } from "./cli-format.js";
 import { formatWalletLedger, formatWalletPayout, formatWalletStatus, } from "./wallet-format.js";
@@ -67,6 +68,13 @@ const MIMOCODE_DEFAULT_BIN = "mimo";
 const OPENCODE_PUBLISHER_TARGET = "opencode";
 const OPENCODE_BIN_ENV = "WAITSPIN_OPENCODE_BIN";
 const OPENCODE_DEFAULT_BIN = "opencode";
+const COPILOT_PUBLISHER_TARGET = "copilot";
+const COPILOT_BIN_ENV = "WAITSPIN_COPILOT_BIN";
+const COPILOT_HOME_ENV = "COPILOT_HOME";
+const COPILOT_DEFAULT_BIN = "copilot";
+const ANTIGRAVITY_PUBLISHER_TARGET = "antigravity";
+const ANTIGRAVITY_BIN_ENV = "WAITSPIN_ANTIGRAVITY_BIN";
+const ANTIGRAVITY_DEFAULT_BIN = "agy";
 const extensionTargets = {
     vscode: "vscode",
 };
@@ -100,11 +108,17 @@ export function usageText() {
         "  waitspin grok install [--json] [--api-key KEY] [--dry-run]",
         "  waitspin grok status [--json]",
         "  waitspin grok uninstall [--json] [--dry-run]",
+        "  waitspin antigravity install [--json] [--api-key KEY] [--compose-existing] [--dry-run]",
+        "  waitspin antigravity status [--json]",
+        "  waitspin antigravity uninstall [--json] [--dry-run]",
+        "  waitspin copilot install [--json] [--api-key KEY] [--compose-existing] [--dry-run]",
+        "  waitspin copilot status [--json]",
+        "  waitspin copilot uninstall [--json] [--dry-run]",
         "",
         "Defaults:",
         "  API base: https://api.waitspin.com",
         "  API key: WAITSPIN_API_KEY env var",
-        "  Public user targets: status-bar-fallback, claude-code, mimocode, opencode, grok",
+        "  Public user targets: status-bar-fallback, claude-code, mimocode, opencode, grok, antigravity, copilot",
     ].join("\n") + "\n");
 }
 function usage(exitCode = 1) {
@@ -705,6 +719,36 @@ async function registerPublisherInstall(input) {
                 "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
             ].join("\n"));
         }
+        if (input.target === COPILOT_PUBLISHER_TARGET &&
+            error instanceof WaitSpinCliHttpError &&
+            error.status === 400 &&
+            /Invalid input|Validation error/.test(error.message)) {
+            throw new Error([
+                `WaitSpin API rejected target "${COPILOT_PUBLISHER_TARGET}".`,
+                "Your local CLI supports this hidden GitHub Copilot CLI target, but the selected API base does not.",
+                "",
+                "For production:",
+                "  deploy the backend target allowlist only after full public acceptance, then rerun:",
+                `  waitspin ${COPILOT_PUBLISHER_TARGET} install`,
+                "",
+                "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
+            ].join("\n"));
+        }
+        if (input.target === ANTIGRAVITY_PUBLISHER_TARGET &&
+            error instanceof WaitSpinCliHttpError &&
+            error.status === 400 &&
+            /Invalid input|Validation error/.test(error.message)) {
+            throw new Error([
+                `WaitSpin API rejected target "${ANTIGRAVITY_PUBLISHER_TARGET}".`,
+                "Your local CLI supports this hidden Antigravity target, but the selected API base does not.",
+                "",
+                "For production:",
+                "  deploy the backend target allowlist only after full public acceptance, then rerun:",
+                `  waitspin ${ANTIGRAVITY_PUBLISHER_TARGET} install`,
+                "",
+                "For developer-local acceptance only, use an explicit loopback API with --allow-dev-api-base.",
+            ].join("\n"));
+        }
         if (isExperimentalCliTargetName(input.target) &&
             error instanceof WaitSpinCliHttpError &&
             error.status === 400 &&
@@ -892,8 +936,11 @@ export async function runExtensionInstall(flags) {
     printCliOutput(flags, output, formatTargetInstallResult(output));
 }
 async function pathExists(filePath) {
+    return pathAccessible(filePath, fsConstants.F_OK);
+}
+async function pathAccessible(filePath, mode) {
     try {
-        await access(filePath, fsConstants.F_OK);
+        await access(filePath, mode);
         return true;
     }
     catch {
@@ -1114,16 +1161,29 @@ function isErrno(error, code) {
         "code" in error &&
         error.code === code);
 }
-async function readJsonObjectFile(filePath) {
+function parseJsonObject(filePath, raw, options = {}) {
+    const errors = [];
+    const parsed = options.jsonc
+        ? parseJsonc(raw, errors, {
+            allowTrailingComma: true,
+            disallowComments: false,
+        })
+        : JSON.parse(raw);
+    if (errors.length > 0) {
+        const first = errors[0];
+        throw new Error(`${filePath} contains invalid JSONC: ${printParseErrorCode(first.error)} at offset ${first.offset}.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${filePath} must contain a JSON object.`);
+    }
+    return parsed;
+}
+async function readJsonObjectFile(filePath, options = {}) {
     try {
         const raw = await readFile(filePath, "utf8");
         if (!raw.trim())
             return {};
-        const parsed = JSON.parse(raw);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            throw new Error(`${filePath} must contain a JSON object.`);
-        }
-        return parsed;
+        return parseJsonObject(filePath, raw, options);
     }
     catch (error) {
         if (isErrno(error, "ENOENT")) {
@@ -1167,6 +1227,50 @@ async function loadClaudeCodeInstallState() {
     }
     return parsed;
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requireStringField(value, field, statePath) {
+    const fieldValue = value[field];
+    if (typeof fieldValue !== "string" || !fieldValue.trim()) {
+        throw new Error(`${statePath} is missing required string field ${field}.`);
+    }
+    return fieldValue;
+}
+function requireRecordField(value, field, statePath) {
+    const fieldValue = value[field];
+    if (!isRecord(fieldValue)) {
+        throw new Error(`${statePath} is missing required object field ${field}.`);
+    }
+    return fieldValue;
+}
+function pathIsInside(candidate, root) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function managedHeartbeatPaths(cachePath, assertSafeManagedPath) {
+    const safeCachePath = assertSafeManagedPath(cachePath);
+    const directory = path.dirname(safeCachePath);
+    const prefix = `${path.basename(safeCachePath)}.`;
+    const suffix = ".heartbeat";
+    let entries;
+    try {
+        entries = await readdir(directory);
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return [];
+        throw error;
+    }
+    return entries
+        .filter((entry) => entry.startsWith(prefix) && entry.endsWith(suffix))
+        .map((entry) => assertSafeManagedPath(path.join(directory, entry)));
+}
+async function writeSecretFile(filePath, value) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${value}\n`, { encoding: "utf8", mode: 0o600 });
+    await chmod(filePath, 0o600);
+}
 function isCommandStatusLine(value) {
     return (Boolean(value) &&
         typeof value === "object" &&
@@ -1269,6 +1373,17 @@ const HEARTBEAT_IMPRESSION_WAIT_MS = 2_500;
 const LOCK_RETRY_MS = 40;
 const LOCK_TIMEOUT_MS = 2_000;
 const LOCK_STALE_MS = 10_000;
+const SHELL_PROCESS_NAMES = new Set([
+  "bash",
+  "cmd",
+  "dash",
+  "fish",
+  "ksh",
+  "powershell",
+  "pwsh",
+  "sh",
+  "zsh",
+]);
 
 function argValue(name) {
   const index = process.argv.indexOf(name);
@@ -1289,6 +1404,15 @@ async function readJson(filePath, fallback) {
   }
 }
 
+async function readSecret(filePath) {
+  if (!filePath) return "";
+  try {
+    return (await readFile(filePath, "utf8")).trim();
+  } catch {
+    return "";
+  }
+}
+
 async function writeJson(filePath, value) {
   const tmp = filePath + "." + process.pid + ".tmp";
   await writeFile(tmp, JSON.stringify(value, null, 2) + "\n", {
@@ -1358,14 +1482,44 @@ function cleanLine(value) {
     .slice(0, 120);
 }
 
-async function runPreviousStatusLine(command, input) {
+function expandExecutablePath(command) {
+  const value = String(command || "").trim();
+  if (!value) return "";
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  let expanded = value;
+  if (
+    home &&
+    (expanded === "~" || expanded.startsWith("~/") || expanded.startsWith("~\\"))
+  ) {
+    expanded = path.join(home, expanded.slice(2));
+  }
+  if (home) {
+    expanded = expanded
+      .replace(/\$\{HOME\}/g, home)
+      .replace(/\$HOME(?=\/|\\|$)/g, home);
+  }
+  const userProfile = process.env.USERPROFILE || "";
+  if (userProfile) {
+    expanded = expanded.replace(/%USERPROFILE%/gi, userProfile);
+  }
+  return expanded;
+}
+
+async function runPreviousStatusLine(command, input, mode = "shell") {
   if (!command) return "";
   return await new Promise((resolve) => {
-    const child = spawn(command, {
-      shell: true,
-      stdio: ["pipe", "pipe", "ignore"],
-      env: process.env,
-    });
+    const child =
+      mode === "exec-path"
+        ? spawn(expandExecutablePath(command), [], {
+            shell: false,
+            stdio: ["pipe", "pipe", "ignore"],
+            env: process.env,
+          })
+        : spawn(command, {
+            shell: true,
+            stdio: ["pipe", "pipe", "ignore"],
+            env: process.env,
+          });
     let stdout = "";
     let settled = false;
     let killTimer = null;
@@ -1487,6 +1641,144 @@ async function waitForHeartbeatVisibleAfter(heartbeatPath, shownAt) {
   } while (true);
 }
 
+function processAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function processInfo(pid) {
+  if (!processAlive(pid)) return null;
+  if (process.platform === "win32") {
+    return await new Promise((resolve) => {
+      const numericPid = Math.trunc(Number(pid));
+      const command = [
+        "$p=Get-CimInstance Win32_Process -Filter 'ProcessId = " + numericPid + "';",
+        "if ($p) { Write-Output ([string]$p.ParentProcessId + ' ' + [string]$p.Name) }",
+      ].join(" ");
+      const child = spawn("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        command,
+      ], {
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      let stdout = "";
+      let settled = false;
+      function finish(value) {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      }
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+        if (stdout.length > 4000) stdout = stdout.slice(0, 4000);
+      });
+      child.on("error", () => finish(null));
+      child.on("close", (code) => {
+        if (code !== 0) {
+          finish(null);
+          return;
+        }
+        const line = stdout.trim().split(/\r?\n/).filter(Boolean).pop() || "";
+        const match = line.trim().match(/^(\d+)\s+(.+)$/);
+        if (!match) {
+          finish(null);
+          return;
+        }
+        finish({ ppid: Number(match[1]), command: match[2] });
+      });
+    });
+  }
+  return await new Promise((resolve) => {
+    const child = spawn("ps", ["-o", "ppid=,comm=", "-p", String(pid)], {
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    let stdout = "";
+    let settled = false;
+    function finish(value) {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    }
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      if (stdout.length > 4000) stdout = stdout.slice(0, 4000);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        finish(null);
+        return;
+      }
+      const line = stdout.trim().split(/\r?\n/).filter(Boolean).pop() || "";
+      const match = line.trim().match(/^(\d+)\s+(.+)$/);
+      if (!match) {
+        finish(null);
+        return;
+      }
+      finish({ ppid: Number(match[1]), command: match[2] });
+    });
+  });
+}
+
+function isShellProcess(command) {
+  const base = path.basename(String(command || "")).toLowerCase();
+  return SHELL_PROCESS_NAMES.has(base);
+}
+
+async function detectOwnerPid() {
+  const parentPid = Number(process.ppid);
+  if (!processAlive(parentPid)) return 0;
+  const parent = await processInfo(parentPid);
+  if (parent && isShellProcess(parent.command) && processAlive(parent.ppid)) {
+    return parent.ppid;
+  }
+  return parentPid;
+}
+
+async function ownerAliveAfterVisible(session) {
+  const ownerPid = Number(session.ownerPid || 0);
+  return processAlive(ownerPid);
+}
+
+function commandStatusLineMatches(current, managed) {
+  if (!current || !managed || typeof current !== "object" || typeof managed !== "object") {
+    return false;
+  }
+  if (Array.isArray(current) || Array.isArray(managed)) return false;
+  if (typeof current.command !== "string" || typeof managed.command !== "string") {
+    return false;
+  }
+  if (current.command !== managed.command) return false;
+  if (managed.type !== undefined && current.type !== managed.type) return false;
+  if (managed.padding !== undefined && current.padding !== managed.padding) return false;
+  if (managed.enabled !== undefined && current.enabled !== managed.enabled) return false;
+  return current.enabled !== false;
+}
+
+async function installedSurfaceStillConfigured(state) {
+  if (!state?.settings_path || !state?.managed_status_line) return false;
+  const settings = await readJson(state.settings_path, null);
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    return false;
+  }
+  if (!commandStatusLineMatches(settings.statusLine, state.managed_status_line)) {
+    return false;
+  }
+  if (state.target === "copilot") {
+    return Boolean(settings.footer?.showCustom === true);
+  }
+  return true;
+}
+
 async function markShown(session, heartbeatPath) {
   const serve = session.activeServe;
   if (!serve || serve.impressionRecorded || !heartbeatPath) return false;
@@ -1606,27 +1898,37 @@ async function recordDelayedImpression() {
   const heartbeatPath = argValue("--heartbeat");
   if (!statePath || !expectedServeId || !heartbeatPath) return;
   const state = await readJson(statePath, null);
-  if (!state?.api_key || !state.install_id || !state.base_url || !state.cache_path) {
+  const apiKey = state?.api_key || (await readSecret(state?.api_key_path));
+  if (!apiKey || !state?.install_id || !state.base_url || !state.cache_path) {
     return;
   }
-  const cache = await readJson(state.cache_path, { sessions: {} });
-  const session = Object.values(cache.sessions || {}).find(
-    (candidate) =>
-      candidate?.activeServe?.serveId === expectedServeId &&
-      candidate.activeServe.shownHeartbeatPath === heartbeatPath,
+  const runtimeState = { ...state, api_key: apiKey };
+  const cache = normalizeSessionCache(
+    await readJson(state.cache_path, { sessions: {} }),
   );
+  const session = findSessionByServe(cache, expectedServeId, heartbeatPath);
   const serve = session?.activeServe;
   if (!serve || serve.impressionRecorded || !serve.shownAt) return;
   const visibleAt = serve.shownAt + Math.max(serve.minVisibleMs || 5000, 5000);
   const dueAt = visibleAt + 250;
   if (Date.now() < dueAt) await sleep(dueAt - Date.now());
-  if (!(await waitForHeartbeatVisibleAfter(heartbeatPath, visibleAt))) return;
+  const ownerConfiguredVisible =
+    (await ownerAliveAfterVisible(session)) &&
+    (await installedSurfaceStillConfigured(state));
+  if (
+    !(await waitForHeartbeatVisibleAfter(heartbeatPath, visibleAt)) &&
+    !ownerConfiguredVisible
+  ) {
+    return;
+  }
   await withCacheLock(state.cache_path, async () => {
-    const lockedCache = await readJson(state.cache_path, { sessions: {} });
-    const lockedSession = Object.values(lockedCache.sessions || {}).find(
-      (candidate) =>
-        candidate?.activeServe?.serveId === expectedServeId &&
-        candidate.activeServe.shownHeartbeatPath === heartbeatPath,
+    const lockedCache = normalizeSessionCache(
+      await readJson(state.cache_path, { sessions: {} }),
+    );
+    const lockedSession = findSessionByServe(
+      lockedCache,
+      expectedServeId,
+      heartbeatPath,
     );
     if (!lockedSession) return;
     const lockedServe = lockedSession.activeServe;
@@ -1639,9 +1941,11 @@ async function recordDelayedImpression() {
       lockedServe.shownAt &&
       lockedServe.shownHeartbeatPath === heartbeatPath &&
       !serveIsExpired(lockedServe) &&
-      (await heartbeatVisibleAfter(heartbeatPath, lockedVisibleAt))
+      ((await heartbeatVisibleAfter(heartbeatPath, lockedVisibleAt)) ||
+        ((await ownerAliveAfterVisible(lockedSession)) &&
+          (await installedSurfaceStillConfigured(state))))
     ) {
-      await recordImpression(state, lockedSession);
+      await recordImpression(runtimeState, lockedSession);
     }
     delete lockedSession.impressionTickServeId;
     delete lockedSession.impressionTickScheduledAt;
@@ -1649,130 +1953,1179 @@ async function recordDelayedImpression() {
     await writeJson(state.cache_path, lockedCache);
   });
 }
-
-function sessionKey(inputJson) {
-  return (
-    inputJson.session_id ||
-    inputJson.transcript_path ||
-    inputJson.cwd ||
-    "claude-code"
-  );
+
+function sessionKey(inputJson) {
+  return (
+    inputJson.session_id ||
+    inputJson.conversation_id ||
+    inputJson.transcript_path ||
+    inputJson.workspace_current_dir ||
+    inputJson.cwd ||
+    "claude-code"
+  );
+}
+
+function safeInputJson(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const output = {};
+  for (const key of ["session_id", "transcript_path", "cwd"]) {
+    if (typeof value[key] === "string" && value[key].trim()) {
+      output[key] = value[key];
+    }
+  }
+  if (typeof value.conversation_id === "string" && value.conversation_id.trim()) {
+    output.conversation_id = value.conversation_id;
+  }
+  if (
+    value.workspace &&
+    typeof value.workspace === "object" &&
+    !Array.isArray(value.workspace) &&
+    typeof value.workspace.current_dir === "string" &&
+    value.workspace.current_dir.trim()
+  ) {
+    output.workspace_current_dir = value.workspace.current_dir;
+  }
+  return output;
+}
+
+function safeSessionKey(inputJson) {
+  return createHash("sha256")
+    .update(String(sessionKey(inputJson)))
+    .digest("hex");
+}
+
+function normalizeSessionCache(value) {
+  const cache =
+    value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  if (
+    !cache.sessions ||
+    typeof cache.sessions !== "object" ||
+    Array.isArray(cache.sessions)
+  ) {
+    cache.sessions = {};
+  }
+  return cache;
+}
+
+function findSessionByServe(cache, expectedServeId, heartbeatPath) {
+  return Object.values(cache.sessions).find(
+    (candidate) =>
+      candidate &&
+      typeof candidate === "object" &&
+      !Array.isArray(candidate) &&
+      candidate.activeServe?.serveId === expectedServeId &&
+      candidate.activeServe.shownHeartbeatPath === heartbeatPath,
+  );
+}
+
+async function pruneSessions(cachePath, cache) {
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const [key, value] of Object.entries(cache.sessions || {})) {
+    if ((value.lastSeenAt || 0) < cutoff) {
+      delete cache.sessions[key];
+      await rm(heartbeatPathFor(cachePath, key), { force: true }).catch(() => {});
+    }
+  }
+}
+
+async function main() {
+  const statePath = argValue("--state");
+  if (!statePath) return;
+  const stdin = await readStdin();
+  let inputJson = {};
+  try {
+    inputJson = safeInputJson(stdin.trim() ? JSON.parse(stdin) : {});
+  } catch {
+    inputJson = {};
+  }
+  const state = await readJson(statePath, null);
+  const apiKey = state?.api_key || (await readSecret(state?.api_key_path));
+  if (!apiKey || !state?.install_id || !state.base_url || !state.cache_path) {
+    return;
+  }
+  const runtimeState = { ...state, api_key: apiKey };
+  const ownerPid = await detectOwnerPid();
+
+  const previous = await runPreviousStatusLine(
+    typeof state.previous_status_line?.command === "string"
+      ? state.previous_status_line.command
+      : "",
+    stdin,
+    state.previous_status_line_command_mode ||
+      (state.target === "copilot" || state.target === "antigravity"
+        ? "exec-path"
+        : "shell"),
+  );
+  let renderedSession = null;
+
+  try {
+    renderedSession = await withCacheLock(state.cache_path, async () => {
+      const cache = normalizeSessionCache(
+        await readJson(state.cache_path, { sessions: {} }),
+      );
+      const key = safeSessionKey(inputJson);
+      const existingSession = Object.prototype.hasOwnProperty.call(
+        cache.sessions,
+        key,
+      )
+        ? cache.sessions[key]
+        : {};
+      const session =
+        existingSession &&
+        typeof existingSession === "object" &&
+        !Array.isArray(existingSession)
+          ? existingSession
+          : {};
+      session.lastSeenAt = Date.now();
+      cache.sessions[key] = session;
+      const heartbeatPath = heartbeatPathFor(state.cache_path, key);
+      await writeHeartbeat(heartbeatPath);
+      if (ownerPid > 1) session.ownerPid = ownerPid;
+
+      if (session.activeServe && serveIsExpired(session.activeServe)) {
+        session.activeServe = null;
+      }
+      await recordForegroundImpression(runtimeState, session, heartbeatPath);
+      const shouldFetchNext = !session.activeServe
+        ? Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS
+        : session.activeServe.impressionRecorded &&
+          Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS;
+      if (shouldFetchNext) {
+        await fetchNextServe(runtimeState, session);
+      }
+      if (session.activeServe && !session.activeServe.impressionRecorded) {
+        await markShown(session, heartbeatPath);
+        await scheduleImpressionTick(statePath, heartbeatPath, session);
+      }
+      await pruneSessions(state.cache_path, cache);
+      await writeJson(state.cache_path, cache);
+      return session;
+    });
+  } catch {
+    // Statusline rendering must never interrupt Claude Code.
+  }
+
+  const sponsor = renderedSession?.activeServe?.line
+    ? "Sponsored: " + renderedSession.activeServe.line
+    : "";
+  const lines = [previous, sponsor].filter(Boolean);
+  if (lines.length > 0) process.stdout.write(lines.join("\n"));
+}
+
+const task = process.argv.includes("--impression-tick")
+  ? recordDelayedImpression()
+  : main();
+task.catch(() => {});
+`;
+}
+async function writeClaudeCodeRuntime(runtimePath) {
+    await mkdir(path.dirname(runtimePath), { recursive: true });
+    await writeFile(runtimePath, claudeCodeStatuslineRuntimeSource(), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(runtimePath, 0o755);
+}
+function assertSafeClaudeCodeManagedPath(filePath) {
+    const installRoot = path.resolve(claudeCodeInstallDir());
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(`${installRoot}${path.sep}`) ||
+        !path.basename(resolved).startsWith("claude-code-")) {
+        throw new Error("Refusing to manage a Claude Code WaitSpin file outside ~/.waitspin.");
+    }
+    return resolved;
+}
+export async function runClaudeCodeInstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const baseUrl = resolveCredentialedBaseUrl(flags);
+    const statePath = claudeCodeStatePath();
+    const runtimePath = claudeCodeRuntimePath();
+    const cachePath = claudeCodeCachePath();
+    const settingsPath = claudeCodeSettingsPath();
+    const existingState = await loadClaudeCodeInstallState();
+    const installId = existingState?.install_id || generateInstallId();
+    const managedStatusLine = managedClaudeCodeStatusLine({
+        runtimePath,
+        statePath,
+    });
+    const settings = await loadClaudeCodeSettings();
+    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
+    const scopedStatusLineBlockedReason = claudeCodeScopedStatusLineBlocker(scopedStatusLine, managedStatusLine);
+    let settingsUpdate = null;
+    let settingsBlockedReason = null;
+    try {
+        settingsUpdate = resolveClaudeCodeSettingsUpdate({
+            settings,
+            managedStatusLine,
+            existingState,
+            composeExisting: booleanFlag(flags, "compose-existing"),
+        });
+    }
+    catch (error) {
+        if (!dryRun)
+            throw error;
+        settingsBlockedReason =
+            error instanceof Error ? error.message : String(error);
+    }
+    if (scopedStatusLineBlockedReason && !dryRun) {
+        throw new Error(scopedStatusLineBlockedReason);
+    }
+    const summary = {
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        install_id: installId,
+        publisher_target: CLAUDE_CODE_PUBLISHER_TARGET,
+        state_path: statePath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        settings_path: settingsPath,
+        settings_action: settingsUpdate?.action ?? "blocked",
+        composed_existing_status_line: settingsUpdate?.composedExistingStatusLine ?? false,
+        note: "Installs WaitSpin through Claude Code's official statusLine.command surface.",
+        next: "check_status",
+        next_command: "waitspin claude-code status",
+    };
+    if (dryRun) {
+        const blockedReason = settingsBlockedReason ?? scopedStatusLineBlockedReason;
+        const output = {
+            ...summary,
+            dry_run: true,
+            publisher_registered: false,
+            has_existing_status_line: Boolean(settings.statusLine),
+            ...(scopedStatusLine
+                ? {
+                    scoped_status_line: {
+                        scope: scopedStatusLine.scope,
+                        path: scopedStatusLine.path,
+                        overrides_user_settings: Boolean(scopedStatusLineBlockedReason),
+                    },
+                }
+                : {}),
+            ...(blockedReason
+                ? {
+                    would_fail: true,
+                    settings_blocked_reason: blockedReason,
+                    next: settingsBlockedReason
+                        ? "resolve_status_line_conflict"
+                        : "resolve_project_status_line_override",
+                    ...(settingsBlockedReason
+                        ? {
+                            next_command: "waitspin claude-code install --compose-existing",
+                        }
+                        : {
+                            human_message: "Current project/local Claude Code settings override user-level statusLine. Remove or compose that statusLine before installing WaitSpin for this project.",
+                        }),
+                }
+                : {}),
+        };
+        printCliOutput(flags, output, formatTargetInstallResult(output));
+        return;
+    }
+    if (!settingsUpdate) {
+        throw new Error("Unable to resolve Claude Code settings update.");
+    }
+    const claudeVersion = await assertSupportedClaudeCodeVersion();
+    const apiKey = requireApiKey(flags);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+    });
+    const installedAt = new Date().toISOString();
+    const installState = {
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: installedAt,
+        base_url: baseUrl,
+        api_key: apiKey,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        settings_path: settingsPath,
+        managed_status_line: managedStatusLine,
+        previous_status_line: settingsUpdate.previousStatusLine,
+        composed_existing_status_line: settingsUpdate.composedExistingStatusLine,
+        claude_version: claudeVersion,
+        installed_at: installedAt,
+    };
+    try {
+        await writeClaudeCodeRuntime(runtimePath);
+        await writeJsonObjectFile(statePath, installState, 0o600);
+        await writeJsonObjectFile(settingsPath, settingsUpdate.nextSettings);
+    }
+    catch (error) {
+        if (existingState) {
+            await writeJsonObjectFile(statePath, existingState, 0o600).catch(() => { });
+        }
+        else {
+            await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+        }
+        throw error;
+    }
+    const output = {
+        ...summary,
+        ...redactedClaudeCodeState(installState),
+        publisher_registered: true,
+        claude_version: claudeVersion,
+        next: "launch_claude_code",
+        next_command: "claude",
+        acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+    };
+    printCliOutput(flags, output, formatTargetInstallResult(output));
+}
+export async function runClaudeCodeStatus(flags = new Map()) {
+    const state = await loadClaudeCodeInstallState();
+    const settings = await loadClaudeCodeSettings();
+    const managedStatusLine = state?.managed_status_line ?? null;
+    const currentStatusLine = settings.statusLine;
+    const statusLineConfigured = Boolean(managedStatusLine && statusLineEquals(currentStatusLine, managedStatusLine));
+    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
+    const scopedStatusLineOverridden = Boolean(managedStatusLine &&
+        scopedStatusLine &&
+        !statusLineEquals(scopedStatusLine.statusLine, managedStatusLine));
+    const effectiveStatusLineConfigured = statusLineConfigured && !scopedStatusLineOverridden;
+    const runtimeInstalled = state
+        ? await pathExists(assertSafeClaudeCodeManagedPath(state.runtime_path))
+        : false;
+    const installed = Boolean(state && runtimeInstalled && effectiveStatusLineConfigured);
+    const output = {
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        installed,
+        publisher_registered: Boolean(state?.publisher_id),
+        install_id: state?.install_id ?? null,
+        publisher_id: state?.publisher_id ?? null,
+        publisher_target: state?.publisher_target ?? CLAUDE_CODE_PUBLISHER_TARGET,
+        state_path: claudeCodeStatePath(),
+        runtime_path: state?.runtime_path ?? claudeCodeRuntimePath(),
+        cache_path: state?.cache_path ?? claudeCodeCachePath(),
+        settings_path: claudeCodeSettingsPath(),
+        runtime_installed: runtimeInstalled,
+        status_line_configured: statusLineConfigured,
+        effective_status_line_configured: effectiveStatusLineConfigured,
+        status_line_overridden: scopedStatusLineOverridden,
+        ...(scopedStatusLineOverridden && scopedStatusLine
+            ? {
+                status_line_override_scope: scopedStatusLine.scope,
+                status_line_override_path: scopedStatusLine.path,
+            }
+            : {}),
+        composed_existing_status_line: Boolean(state?.composed_existing_status_line),
+        has_previous_status_line: Boolean(state?.previous_status_line),
+        claude_version: state?.claude_version ?? null,
+        ...(installed
+            ? {
+                next: "launch_claude_code",
+                next_command: "claude",
+                acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+            }
+            : {
+                next: "install_claude_code",
+                next_command: "waitspin claude-code install --compose-existing",
+                human_message: scopedStatusLineOverridden
+                    ? "Claude Code WaitSpin support is installed in user settings, but a higher-priority project/local statusLine overrides it in this directory."
+                    : "Claude Code WaitSpin statusline support is not installed for this user.",
+            }),
+    };
+    printCliOutput(flags, output, formatTargetStatusResult(output));
+}
+export async function runClaudeCodeUninstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const state = await loadClaudeCodeInstallState();
+    const settings = await loadClaudeCodeSettings();
+    const declaredRemovePaths = state
+        ? [
+            state.runtime_path,
+            state.cache_path,
+            claudeCodeStatePath(),
+            `${state.cache_path}.*.heartbeat`,
+        ]
+        : [claudeCodeStatePath()];
+    let nextSettings = null;
+    let settingsAction = "not-managed";
+    let settingsWarning = null;
+    if (state?.managed_status_line) {
+        if (!statusLineEquals(settings.statusLine, state.managed_status_line)) {
+            settingsAction = "skip-user-settings";
+            settingsWarning =
+                "Claude Code statusLine is no longer the WaitSpin managed command; leaving user settings unchanged while removing WaitSpin-managed files.";
+        }
+        else {
+            nextSettings = { ...settings };
+            if (state.previous_status_line !== undefined) {
+                nextSettings.statusLine = state.previous_status_line;
+                settingsAction = "restore-previous";
+            }
+            else {
+                delete nextSettings.statusLine;
+                settingsAction = "remove-managed";
+            }
+        }
+    }
+    if (dryRun) {
+        const output = {
+            ok: true,
+            target: CLAUDE_CODE_PUBLISHER_TARGET,
+            dry_run: true,
+            installed: Boolean(state),
+            settings_action: settingsAction,
+            would_remove: declaredRemovePaths,
+            path_validation: state ? "deferred_until_apply" : "not_needed",
+            ...(settingsWarning
+                ? {
+                    settings_warning: settingsWarning,
+                }
+                : {}),
+        };
+        printCliOutput(flags, output, formatTargetUninstallResult(output));
+        return;
+    }
+    const removePaths = state
+        ? [
+            assertSafeClaudeCodeManagedPath(state.runtime_path),
+            assertSafeClaudeCodeManagedPath(state.cache_path),
+            claudeCodeStatePath(),
+            ...(await managedHeartbeatPaths(state.cache_path, assertSafeClaudeCodeManagedPath)),
+        ]
+        : [claudeCodeStatePath()];
+    if (nextSettings) {
+        await writeJsonObjectFile(claudeCodeSettingsPath(), nextSettings);
+    }
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    const output = {
+        ok: true,
+        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        uninstalled: true,
+        settings_action: settingsAction,
+        removed: removePaths,
+        ...(settingsWarning ? { settings_warning: settingsWarning } : {}),
+    };
+    printCliOutput(flags, output, formatTargetUninstallResult(output));
+}
+function antigravityInstallDir() {
+    return path.join(os.homedir(), ".waitspin");
+}
+function antigravityStatePath() {
+    return path.join(antigravityInstallDir(), "antigravity-install.json");
+}
+function antigravityRuntimePath() {
+    return path.join(antigravityInstallDir(), "antigravity-statusline.mjs");
+}
+function antigravityCommandPath() {
+    return path.join(antigravityInstallDir(), process.platform === "win32"
+        ? "antigravity-statusline-command.cmd"
+        : "antigravity-statusline-command");
+}
+function antigravityCachePath() {
+    return path.join(antigravityInstallDir(), "antigravity-statusline-cache.json");
+}
+function antigravityApiKeyPath() {
+    return path.join(antigravityInstallDir(), "antigravity-api-key.secret");
+}
+function antigravitySettingsPath() {
+    return path.join(os.homedir(), ".gemini", "antigravity-cli", "settings.json");
+}
+function antigravityBinary() {
+    return executableFromEnv(ANTIGRAVITY_BIN_ENV, ANTIGRAVITY_DEFAULT_BIN);
+}
+async function readAntigravityVersion() {
+    try {
+        const result = await execFileText(antigravityBinary(), ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        return `${result.stdout || result.stderr || ""}`.trim();
+    }
+    catch (error) {
+        throw new Error(`Unable to run Antigravity CLI. Install Antigravity CLI or set ${ANTIGRAVITY_BIN_ENV} to its executable path before installing WaitSpin Antigravity support.`, { cause: error });
+    }
+}
+async function loadAntigravitySettings() {
+    const parsed = await readJsonObjectFile(antigravitySettingsPath(), {
+        jsonc: true,
+    });
+    return (parsed ?? {});
+}
+async function loadAntigravityInstallState() {
+    const statePath = antigravityStatePath();
+    const parsed = await readJsonObjectFile(statePath);
+    if (!parsed?.install_id || parsed.target !== ANTIGRAVITY_PUBLISHER_TARGET) {
+        return null;
+    }
+    for (const field of [
+        "install_id",
+        "publisher_id",
+        "publisher_target",
+        "registered_at",
+        "base_url",
+        "runtime_path",
+        "cache_path",
+        "settings_path",
+        "api_key_path",
+        "installed_at",
+    ]) {
+        requireStringField(parsed, field, statePath);
+    }
+    requireRecordField(parsed, "managed_status_line", statePath);
+    return parsed;
+}
+function antigravityStatusLineWrapperSource(input) {
+    if (process.platform === "win32") {
+        const cmdQuote = (value) => `"${value.replace(/"/g, "\"\"")}"`;
+        return [
+            "@echo off",
+            `${cmdQuote(process.execPath)} ${cmdQuote(input.runtimePath)} --state ${cmdQuote(input.statePath)}`,
+            "",
+        ].join("\r\n");
+    }
+    return [
+        "#!/bin/sh",
+        `exec ${shellQuote(process.execPath)} ${shellQuote(input.runtimePath)} --state ${shellQuote(input.statePath)}`,
+        "",
+    ].join("\n");
+}
+function managedAntigravityStatusLine(input) {
+    return {
+        type: "command",
+        command: input.commandPath,
+        enabled: true,
+    };
+}
+function isAntigravityCommandStatusLine(value) {
+    return (Boolean(value) &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof value.command === "string" &&
+        value.command.trim().length > 0 &&
+        value.enabled !== false);
+}
+function isEmptyAntigravityStatusLine(value) {
+    return (Boolean(value) &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof value.command === "string" &&
+        value.command.trim().length === 0);
+}
+function antigravityStatusLineEquals(left, right) {
+    if (isAntigravityCommandStatusLine(left) && isAntigravityCommandStatusLine(right)) {
+        return (left.command === right.command &&
+            left.enabled !== false &&
+            right.enabled !== false &&
+            left.type === right.type);
+    }
+    return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+}
+function resolveAntigravitySettingsUpdate(input) {
+    const current = isEmptyAntigravityStatusLine(input.settings.statusLine)
+        ? undefined
+        : input.settings.statusLine;
+    const isAlreadyManaged = antigravityStatusLineEquals(current, input.managedStatusLine) ||
+        (input.existingState?.managed_status_line &&
+            antigravityStatusLineEquals(current, input.existingState.managed_status_line));
+    if (!current || isAlreadyManaged) {
+        return {
+            nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+            previousStatusLine: input.existingState?.previous_status_line,
+            composedExistingStatusLine: Boolean(input.existingState?.composed_existing_status_line),
+            action: isAlreadyManaged ? "refresh-managed" : "install",
+        };
+    }
+    if (!input.composeExisting) {
+        throw new Error("Antigravity already has a statusLine configured. Re-run with --compose-existing to preserve it and append the WaitSpin sponsor line, or remove it first.");
+    }
+    if (!isAntigravityCommandStatusLine(current)) {
+        throw new Error("Antigravity statusLine exists but is not a command status line; refusing to compose because restore would be ambiguous.");
+    }
+    if (current.command === input.managedStatusLine.command) {
+        return {
+            nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+            composedExistingStatusLine: false,
+            action: "refresh-managed",
+        };
+    }
+    return {
+        nextSettings: { ...input.settings, statusLine: input.managedStatusLine },
+        previousStatusLine: current,
+        composedExistingStatusLine: true,
+        action: "compose-existing",
+    };
+}
+function redactedAntigravityState(state) {
+    if (!state)
+        return null;
+    return {
+        target: state.target,
+        install_id: state.install_id,
+        publisher_id: state.publisher_id,
+        publisher_target: state.publisher_target,
+        registered_at: state.registered_at,
+        base_url: state.base_url,
+        runtime_path: state.runtime_path,
+        cache_path: state.cache_path,
+        settings_path: state.settings_path,
+        composed_existing_status_line: Boolean(state.composed_existing_status_line),
+        has_previous_status_line: state.previous_status_line !== undefined,
+        antigravity_version: state.antigravity_version,
+        installed_at: state.installed_at,
+        api_key_present: Boolean(state.api_key || state.api_key_path),
+    };
+}
+async function writeAntigravityRuntime(input) {
+    const { runtimePath, commandPath, statePath } = input;
+    await mkdir(path.dirname(runtimePath), { recursive: true });
+    await writeFile(runtimePath, claudeCodeStatuslineRuntimeSource(), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(runtimePath, 0o755);
+    await writeFile(commandPath, antigravityStatusLineWrapperSource({ runtimePath, statePath }), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(commandPath, 0o755);
+}
+function assertSafeAntigravityManagedPath(filePath) {
+    const installRoot = path.resolve(antigravityInstallDir());
+    const resolved = path.resolve(filePath);
+    if (!resolved.startsWith(`${installRoot}${path.sep}`) ||
+        !path.basename(resolved).startsWith("antigravity-")) {
+        throw new Error("Refusing to manage an Antigravity WaitSpin file outside ~/.waitspin.");
+    }
+    return resolved;
+}
+export async function runAntigravityInstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const baseUrl = resolveCredentialedBaseUrl(flags);
+    const statePath = antigravityStatePath();
+    const runtimePath = antigravityRuntimePath();
+    const commandPath = antigravityCommandPath();
+    const cachePath = antigravityCachePath();
+    const apiKeyPath = antigravityApiKeyPath();
+    const settingsPath = antigravitySettingsPath();
+    const existingState = await loadAntigravityInstallState();
+    const installId = existingState?.install_id || generateInstallId();
+    const managedStatusLine = managedAntigravityStatusLine({
+        commandPath,
+    });
+    const settings = await loadAntigravitySettings();
+    let settingsUpdate = null;
+    let settingsBlockedReason = null;
+    try {
+        settingsUpdate = resolveAntigravitySettingsUpdate({
+            settings,
+            managedStatusLine,
+            existingState,
+            composeExisting: booleanFlag(flags, "compose-existing"),
+        });
+    }
+    catch (error) {
+        if (!dryRun)
+            throw error;
+        settingsBlockedReason =
+            error instanceof Error ? error.message : String(error);
+    }
+    const summary = {
+        ok: true,
+        target: ANTIGRAVITY_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        install_id: installId,
+        publisher_target: ANTIGRAVITY_PUBLISHER_TARGET,
+        state_path: statePath,
+        command_path: commandPath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        api_key_path: apiKeyPath,
+        settings_path: settingsPath,
+        settings_action: settingsUpdate?.action ?? "blocked",
+        composed_existing_status_line: settingsUpdate?.composedExistingStatusLine ?? false,
+        note: "Installs WaitSpin through Antigravity CLI's statusLine.command surface.",
+        next: "check_status",
+        next_command: "waitspin antigravity status",
+    };
+    if (dryRun) {
+        const output = {
+            ...summary,
+            dry_run: true,
+            publisher_registered: false,
+            has_existing_status_line: Boolean(settings.statusLine),
+            ...(settingsBlockedReason
+                ? {
+                    would_fail: true,
+                    settings_blocked_reason: settingsBlockedReason,
+                    next: "resolve_status_line_conflict",
+                    next_command: "waitspin antigravity install --compose-existing",
+                }
+                : {}),
+        };
+        printCliOutput(flags, output, formatTargetInstallResult(output));
+        return;
+    }
+    if (!settingsUpdate) {
+        throw new Error("Unable to resolve Antigravity settings update.");
+    }
+    const antigravityVersion = await readAntigravityVersion();
+    const apiKey = requireApiKey(flags);
+    const registration = await registerPublisherInstall({
+        baseUrl,
+        apiKey,
+        installId,
+        target: ANTIGRAVITY_PUBLISHER_TARGET,
+    });
+    const installedAt = new Date().toISOString();
+    const installState = {
+        target: ANTIGRAVITY_PUBLISHER_TARGET,
+        install_id: registration.install_id,
+        publisher_id: registration.publisher_id,
+        publisher_target: registration.target,
+        registered_at: installedAt,
+        base_url: baseUrl,
+        api_key_path: apiKeyPath,
+        command_path: commandPath,
+        runtime_path: runtimePath,
+        cache_path: cachePath,
+        settings_path: settingsPath,
+        managed_status_line: managedStatusLine,
+        previous_status_line: settingsUpdate.previousStatusLine,
+        previous_status_line_command_mode: settingsUpdate.previousStatusLine === undefined ? undefined : "exec-path",
+        composed_existing_status_line: settingsUpdate.composedExistingStatusLine,
+        antigravity_version: antigravityVersion,
+        installed_at: installedAt,
+    };
+    try {
+        await writeAntigravityRuntime({ runtimePath, commandPath, statePath });
+        await writeSecretFile(apiKeyPath, apiKey);
+        await writeJsonObjectFile(statePath, installState, 0o600);
+        await writeJsonObjectFile(settingsPath, settingsUpdate.nextSettings);
+    }
+    catch (error) {
+        if (existingState) {
+            await writeJsonObjectFile(statePath, existingState, 0o600).catch(() => { });
+        }
+        else {
+            await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(commandPath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(apiKeyPath, { force: true, recursive: true })).catch(() => { });
+        }
+        throw error;
+    }
+    const output = {
+        ...summary,
+        ...redactedAntigravityState(installState),
+        publisher_registered: true,
+        antigravity_version: antigravityVersion,
+        next: "launch_antigravity",
+        next_command: ANTIGRAVITY_DEFAULT_BIN,
+        verification_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+    };
+    printCliOutput(flags, output, formatTargetInstallResult(output));
+}
+export async function runAntigravityStatus(flags = new Map()) {
+    const state = await loadAntigravityInstallState();
+    const settings = await loadAntigravitySettings();
+    const managedStatusLine = state?.managed_status_line ?? null;
+    const currentStatusLine = settings.statusLine;
+    const statusLineConfigured = Boolean(managedStatusLine &&
+        antigravityStatusLineEquals(currentStatusLine, managedStatusLine));
+    const runtimeInstalled = state
+        ? await pathAccessible(assertSafeAntigravityManagedPath(state.runtime_path), fsConstants.R_OK)
+        : false;
+    const commandInstalled = state?.command_path
+        ? await pathAccessible(assertSafeAntigravityManagedPath(state.command_path), fsConstants.X_OK)
+        : false;
+    const apiKeyInstalled = state
+        ? await pathAccessible(assertSafeAntigravityManagedPath(state.api_key_path), fsConstants.R_OK)
+        : false;
+    const installed = Boolean(state &&
+        runtimeInstalled &&
+        commandInstalled &&
+        apiKeyInstalled &&
+        statusLineConfigured);
+    const output = {
+        ok: true,
+        target: ANTIGRAVITY_PUBLISHER_TARGET,
+        mode: "statusline-command",
+        installed,
+        publisher_registered: Boolean(state?.publisher_id),
+        install_id: state?.install_id ?? null,
+        publisher_id: state?.publisher_id ?? null,
+        publisher_target: state?.publisher_target ?? ANTIGRAVITY_PUBLISHER_TARGET,
+        state_path: antigravityStatePath(),
+        command_path: state?.command_path ?? antigravityCommandPath(),
+        runtime_path: state?.runtime_path ?? antigravityRuntimePath(),
+        cache_path: state?.cache_path ?? antigravityCachePath(),
+        settings_path: antigravitySettingsPath(),
+        api_key_path: state?.api_key_path ?? antigravityApiKeyPath(),
+        api_key_installed: apiKeyInstalled,
+        command_installed: commandInstalled,
+        runtime_installed: runtimeInstalled,
+        status_line_configured: statusLineConfigured,
+        composed_existing_status_line: Boolean(state?.composed_existing_status_line),
+        has_previous_status_line: Boolean(state?.previous_status_line),
+        antigravity_version: state?.antigravity_version ?? null,
+        ...(installed
+            ? {
+                next: "launch_antigravity",
+                next_command: ANTIGRAVITY_DEFAULT_BIN,
+                verification_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+            }
+            : {
+                next: "install_antigravity",
+                next_command: "waitspin antigravity install",
+                human_message: "Antigravity WaitSpin statusline support is not installed for this user.",
+            }),
+    };
+    printCliOutput(flags, output, formatTargetStatusResult(output));
+}
+export async function runAntigravityUninstall(flags) {
+    const dryRun = booleanFlag(flags, "dry-run");
+    const state = await loadAntigravityInstallState();
+    const settings = await loadAntigravitySettings();
+    const declaredRemovePaths = state
+        ? [
+            ...(state.command_path ? [state.command_path] : []),
+            state.runtime_path,
+            state.cache_path,
+            state.api_key_path,
+            antigravityStatePath(),
+            `${state.cache_path}.*.heartbeat`,
+        ]
+        : [antigravityStatePath()];
+    let nextSettings = null;
+    let settingsAction = "not-managed";
+    let settingsWarning = null;
+    if (state?.managed_status_line) {
+        if (!antigravityStatusLineEquals(settings.statusLine, state.managed_status_line)) {
+            settingsAction = "skip-user-settings";
+            settingsWarning =
+                "Antigravity statusLine is no longer the WaitSpin managed command; leaving user settings unchanged while removing WaitSpin-managed files.";
+        }
+        else {
+            nextSettings = { ...settings };
+            if (state.previous_status_line !== undefined) {
+                nextSettings.statusLine = state.previous_status_line;
+                settingsAction = "restore-previous";
+            }
+            else {
+                delete nextSettings.statusLine;
+                settingsAction = "remove-managed";
+            }
+        }
+    }
+    if (dryRun) {
+        const output = {
+            ok: true,
+            target: ANTIGRAVITY_PUBLISHER_TARGET,
+            dry_run: true,
+            installed: Boolean(state),
+            settings_action: settingsAction,
+            would_remove: declaredRemovePaths,
+            path_validation: state ? "deferred_until_apply" : "not_needed",
+            ...(settingsWarning
+                ? {
+                    settings_warning: settingsWarning,
+                }
+                : {}),
+        };
+        printCliOutput(flags, output, formatTargetUninstallResult(output));
+        return;
+    }
+    const removePaths = state
+        ? [
+            ...(state.command_path
+                ? [assertSafeAntigravityManagedPath(state.command_path)]
+                : []),
+            assertSafeAntigravityManagedPath(state.runtime_path),
+            assertSafeAntigravityManagedPath(state.cache_path),
+            assertSafeAntigravityManagedPath(state.api_key_path),
+            antigravityStatePath(),
+            ...(await managedHeartbeatPaths(state.cache_path, assertSafeAntigravityManagedPath)),
+        ]
+        : [antigravityStatePath()];
+    if (nextSettings) {
+        await writeJsonObjectFile(antigravitySettingsPath(), nextSettings);
+    }
+    await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
+    const output = {
+        ok: true,
+        target: ANTIGRAVITY_PUBLISHER_TARGET,
+        uninstalled: true,
+        settings_action: settingsAction,
+        removed: removePaths,
+        ...(settingsWarning ? { settings_warning: settingsWarning } : {}),
+    };
+    printCliOutput(flags, output, formatTargetUninstallResult(output));
+}
+function copilotInstallDir() {
+    return path.join(os.homedir(), ".waitspin");
+}
+function copilotStatePath() {
+    return path.join(copilotInstallDir(), "copilot-install.json");
+}
+function copilotRuntimePath() {
+    return path.join(copilotInstallDir(), "copilot-statusline.mjs");
+}
+function copilotCommandPath() {
+    return path.join(copilotInstallDir(), process.platform === "win32"
+        ? "copilot-statusline-command.cmd"
+        : "copilot-statusline-command");
+}
+function copilotCachePath() {
+    return path.join(copilotInstallDir(), "copilot-statusline-cache.json");
+}
+function copilotApiKeyPath() {
+    return path.join(copilotInstallDir(), "copilot-api-key.secret");
+}
+function assertSafeCopilotConfigDir(resolved) {
+    const homeDir = path.resolve(os.homedir());
+    const tmpDir = path.resolve(os.tmpdir());
+    if (!pathIsInside(resolved, homeDir) && !pathIsInside(resolved, tmpDir)) {
+        throw new Error(`${COPILOT_HOME_ENV} must resolve inside the user's home directory or the system temporary directory for unattended WaitSpin installs.`);
+    }
+    if (resolved === path.parse(resolved).root) {
+        throw new Error(`${COPILOT_HOME_ENV} must not point at a filesystem root.`);
+    }
+    return resolved;
+}
+function copilotConfigDir() {
+    const configuredHome = process.env[COPILOT_HOME_ENV]?.trim();
+    return configuredHome
+        ? assertSafeCopilotConfigDir(path.resolve(configuredHome))
+        : path.join(os.homedir(), ".copilot");
+}
+function copilotSettingsPath() {
+    return path.join(copilotConfigDir(), "settings.json");
+}
+function copilotBinary() {
+    return executableFromEnv(COPILOT_BIN_ENV, COPILOT_DEFAULT_BIN);
+}
+async function readCopilotVersion() {
+    try {
+        const result = await execFileText(copilotBinary(), ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        return `${result.stdout || result.stderr || ""}`.trim();
+    }
+    catch (error) {
+        throw new Error(`Unable to run GitHub Copilot CLI. Install GitHub Copilot CLI or set ${COPILOT_BIN_ENV} to its executable path before installing WaitSpin Copilot support.`, { cause: error });
+    }
+}
+async function loadCopilotSettings(settingsPath = copilotSettingsPath()) {
+    const parsed = await readJsonObjectFile(settingsPath, {
+        jsonc: true,
+    });
+    return (parsed ?? {});
+}
+async function loadCopilotInstallState() {
+    const statePath = copilotStatePath();
+    const parsed = await readJsonObjectFile(statePath);
+    if (!parsed?.install_id || parsed.target !== COPILOT_PUBLISHER_TARGET) {
+        return null;
+    }
+    for (const field of [
+        "install_id",
+        "publisher_id",
+        "publisher_target",
+        "registered_at",
+        "base_url",
+        "runtime_path",
+        "cache_path",
+        "settings_path",
+        "command_path",
+        "api_key_path",
+        "installed_at",
+    ]) {
+        requireStringField(parsed, field, statePath);
+    }
+    requireRecordField(parsed, "managed_status_line", statePath);
+    return parsed;
+}
+function copilotStatusLineWrapperSource(input) {
+    if (process.platform === "win32") {
+        const cmdQuote = (value) => `"${value.replace(/"/g, "\"\"")}"`;
+        return [
+            "@echo off",
+            `${cmdQuote(process.execPath)} ${cmdQuote(input.runtimePath)} --state ${cmdQuote(input.statePath)}`,
+            "",
+        ].join("\r\n");
+    }
+    return [
+        "#!/bin/sh",
+        `exec ${shellQuote(process.execPath)} ${shellQuote(input.runtimePath)} --state ${shellQuote(input.statePath)}`,
+        "",
+    ].join("\n");
+}
+function managedCopilotStatusLine(input) {
+    return {
+        type: "command",
+        command: input.commandPath,
+        padding: 0,
+    };
+}
+function copilotStatusLineEquals(left, right) {
+    if (isCommandStatusLine(left) && isCommandStatusLine(right)) {
+        return (left.type === right.type &&
+            left.command === right.command &&
+            left.padding === right.padding);
+    }
+    return statusLineEquals(left, right);
+}
+function copilotFooterWithCustomEnabled(settings) {
+    const currentFooter = isRecord(settings.footer) ? settings.footer : {};
+    const hadPreviousFooterShowCustom = Object.prototype.hasOwnProperty.call(currentFooter, "showCustom");
+    return {
+        footer: { ...currentFooter, showCustom: true },
+        previousFooterShowCustom: currentFooter.showCustom,
+        hadPreviousFooterShowCustom,
+    };
 }
-
-function pruneSessions(cache) {
-  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-  for (const [key, value] of Object.entries(cache.sessions || {})) {
-    if ((value.lastSeenAt || 0) < cutoff) delete cache.sessions[key];
-  }
+function restoreCopilotFooterShowCustom(settings, state) {
+    const currentFooter = isRecord(settings.footer) ? { ...settings.footer } : {};
+    if (state.had_previous_footer_show_custom &&
+        state.previous_footer_show_custom !== undefined) {
+        currentFooter.showCustom = state.previous_footer_show_custom;
+    }
+    else {
+        delete currentFooter.showCustom;
+    }
+    const nextSettings = { ...settings };
+    if (Object.keys(currentFooter).length > 0) {
+        nextSettings.footer = currentFooter;
+    }
+    else {
+        delete nextSettings.footer;
+    }
+    return nextSettings;
 }
-
-async function main() {
-  const statePath = argValue("--state");
-  if (!statePath) return;
-  const stdin = await readStdin();
-  let inputJson = {};
-  try {
-    inputJson = stdin.trim() ? JSON.parse(stdin) : {};
-  } catch {
-    inputJson = {};
-  }
-  const state = await readJson(statePath, null);
-  if (!state?.api_key || !state.install_id || !state.base_url || !state.cache_path) {
-    return;
-  }
-
-  const previous = await runPreviousStatusLine(
-    state.previous_status_line?.type === "command"
-      ? state.previous_status_line.command
-      : "",
-    stdin,
-  );
-  let renderedSession = null;
-
-  try {
-    renderedSession = await withCacheLock(state.cache_path, async () => {
-      const cache = await readJson(state.cache_path, { sessions: {} });
-      if (!cache.sessions || typeof cache.sessions !== "object") cache.sessions = {};
-      const key = sessionKey(inputJson);
-      const session = cache.sessions[key] || {};
-      session.lastSeenAt = Date.now();
-      cache.sessions[key] = session;
-      const heartbeatPath = heartbeatPathFor(state.cache_path, key);
-      await writeHeartbeat(heartbeatPath);
-
-      if (session.activeServe && serveIsExpired(session.activeServe)) {
-        session.activeServe = null;
-      }
-      await recordForegroundImpression(state, session, heartbeatPath);
-      const shouldFetchNext = !session.activeServe
-        ? Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS
-        : session.activeServe.impressionRecorded &&
-          Date.now() - (session.lastFetchAt || 0) >= FETCH_INTERVAL_MS;
-      if (shouldFetchNext) {
-        await fetchNextServe(state, session);
-      }
-      if (session.activeServe && !session.activeServe.impressionRecorded) {
-        await markShown(session, heartbeatPath);
-        await scheduleImpressionTick(statePath, heartbeatPath, session);
-      }
-      pruneSessions(cache);
-      await writeJson(state.cache_path, cache);
-      return session;
-    });
-  } catch {
-    // Statusline rendering must never interrupt Claude Code.
-  }
-
-  const sponsor = renderedSession?.activeServe?.line
-    ? "Sponsored: " + renderedSession.activeServe.line
-    : "";
-  const lines = [previous, sponsor].filter(Boolean);
-  if (lines.length > 0) process.stdout.write(lines.join("\n"));
+function resolveCopilotSettingsUpdate(input) {
+    const current = input.settings.statusLine;
+    const footerUpdate = copilotFooterWithCustomEnabled(input.settings);
+    const isAlreadyManaged = copilotStatusLineEquals(current, input.managedStatusLine) ||
+        (input.existingState?.managed_status_line &&
+            copilotStatusLineEquals(current, input.existingState.managed_status_line));
+    if (!current || isAlreadyManaged) {
+        return {
+            nextSettings: {
+                ...input.settings,
+                footer: footerUpdate.footer,
+                statusLine: input.managedStatusLine,
+            },
+            previousStatusLine: input.existingState?.previous_status_line,
+            composedExistingStatusLine: Boolean(input.existingState?.composed_existing_status_line),
+            previousFooterShowCustom: input.existingState?.previous_footer_show_custom ??
+                footerUpdate.previousFooterShowCustom,
+            hadPreviousFooterShowCustom: input.existingState?.had_previous_footer_show_custom ??
+                footerUpdate.hadPreviousFooterShowCustom,
+            action: isAlreadyManaged ? "refresh-managed" : "install",
+        };
+    }
+    if (!input.composeExisting) {
+        throw new Error("GitHub Copilot CLI already has a statusLine configured. Re-run with --compose-existing to preserve it and append the WaitSpin sponsor line, or remove it first.");
+    }
+    if (!isCommandStatusLine(current)) {
+        throw new Error("GitHub Copilot CLI statusLine exists but is not a command status line; refusing to compose because restore would be ambiguous.");
+    }
+    if (current.command === input.managedStatusLine.command) {
+        return {
+            nextSettings: {
+                ...input.settings,
+                footer: footerUpdate.footer,
+                statusLine: input.managedStatusLine,
+            },
+            composedExistingStatusLine: false,
+            previousFooterShowCustom: input.existingState?.previous_footer_show_custom ??
+                footerUpdate.previousFooterShowCustom,
+            hadPreviousFooterShowCustom: input.existingState?.had_previous_footer_show_custom ??
+                footerUpdate.hadPreviousFooterShowCustom,
+            action: "refresh-managed",
+        };
+    }
+    return {
+        nextSettings: {
+            ...input.settings,
+            footer: footerUpdate.footer,
+            statusLine: input.managedStatusLine,
+        },
+        previousStatusLine: current,
+        composedExistingStatusLine: true,
+        previousFooterShowCustom: footerUpdate.previousFooterShowCustom,
+        hadPreviousFooterShowCustom: footerUpdate.hadPreviousFooterShowCustom,
+        action: "compose-existing",
+    };
 }
-
-const task = process.argv.includes("--impression-tick")
-  ? recordDelayedImpression()
-  : main();
-task.catch(() => {});
-`;
+function redactedCopilotState(state) {
+    if (!state)
+        return null;
+    return {
+        target: state.target,
+        install_id: state.install_id,
+        publisher_id: state.publisher_id,
+        publisher_target: state.publisher_target,
+        registered_at: state.registered_at,
+        base_url: state.base_url,
+        runtime_path: state.runtime_path,
+        cache_path: state.cache_path,
+        settings_path: state.settings_path,
+        composed_existing_status_line: Boolean(state.composed_existing_status_line),
+        has_previous_status_line: state.previous_status_line !== undefined,
+        copilot_version: state.copilot_version,
+        installed_at: state.installed_at,
+        api_key_present: Boolean(state.api_key || state.api_key_path),
+    };
 }
-async function writeClaudeCodeRuntime(runtimePath) {
+async function writeCopilotRuntime(input) {
+    const { runtimePath, commandPath, statePath } = input;
     await mkdir(path.dirname(runtimePath), { recursive: true });
     await writeFile(runtimePath, claudeCodeStatuslineRuntimeSource(), {
         encoding: "utf8",
         mode: 0o755,
     });
     await chmod(runtimePath, 0o755);
+    await writeFile(commandPath, copilotStatusLineWrapperSource({ runtimePath, statePath }), {
+        encoding: "utf8",
+        mode: 0o755,
+    });
+    await chmod(commandPath, 0o755);
 }
-function assertSafeClaudeCodeManagedPath(filePath) {
-    const installRoot = path.resolve(claudeCodeInstallDir());
+function assertSafeCopilotManagedPath(filePath) {
+    const installRoot = path.resolve(copilotInstallDir());
     const resolved = path.resolve(filePath);
     if (!resolved.startsWith(`${installRoot}${path.sep}`) ||
-        !path.basename(resolved).startsWith("claude-code-")) {
-        throw new Error("Refusing to manage a Claude Code WaitSpin file outside ~/.waitspin.");
+        !path.basename(resolved).startsWith("copilot-")) {
+        throw new Error("Refusing to manage a GitHub Copilot CLI WaitSpin file outside ~/.waitspin.");
     }
     return resolved;
 }
-export async function runClaudeCodeInstall(flags) {
+export async function runCopilotInstall(flags) {
     const dryRun = booleanFlag(flags, "dry-run");
     const baseUrl = resolveCredentialedBaseUrl(flags);
-    const statePath = claudeCodeStatePath();
-    const runtimePath = claudeCodeRuntimePath();
-    const cachePath = claudeCodeCachePath();
-    const settingsPath = claudeCodeSettingsPath();
-    const existingState = await loadClaudeCodeInstallState();
+    const statePath = copilotStatePath();
+    const runtimePath = copilotRuntimePath();
+    const commandPath = copilotCommandPath();
+    const cachePath = copilotCachePath();
+    const apiKeyPath = copilotApiKeyPath();
+    const currentSettingsPath = copilotSettingsPath();
+    const existingState = await loadCopilotInstallState();
+    if (existingState &&
+        path.resolve(existingState.settings_path) !== path.resolve(currentSettingsPath)) {
+        throw new Error(`Existing GitHub Copilot CLI WaitSpin install uses ${existingState.settings_path}, but the current ${COPILOT_HOME_ENV} resolves to ${currentSettingsPath}. Re-run with the original ${COPILOT_HOME_ENV} or uninstall before installing into another Copilot config home.`);
+    }
+    const settingsPath = existingState?.settings_path ?? currentSettingsPath;
     const installId = existingState?.install_id || generateInstallId();
-    const managedStatusLine = managedClaudeCodeStatusLine({
-        runtimePath,
-        statePath,
+    const managedStatusLine = managedCopilotStatusLine({
+        commandPath,
     });
-    const settings = await loadClaudeCodeSettings();
-    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
-    const scopedStatusLineBlockedReason = claudeCodeScopedStatusLineBlocker(scopedStatusLine, managedStatusLine);
+    const settings = await loadCopilotSettings(settingsPath);
     let settingsUpdate = null;
     let settingsBlockedReason = null;
     try {
-        settingsUpdate = resolveClaudeCodeSettingsUpdate({
+        settingsUpdate = resolveCopilotSettingsUpdate({
             settings,
             managedStatusLine,
             existingState,
@@ -1785,55 +3138,36 @@ export async function runClaudeCodeInstall(flags) {
         settingsBlockedReason =
             error instanceof Error ? error.message : String(error);
     }
-    if (scopedStatusLineBlockedReason && !dryRun) {
-        throw new Error(scopedStatusLineBlockedReason);
-    }
     const summary = {
         ok: true,
-        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        target: COPILOT_PUBLISHER_TARGET,
         mode: "statusline-command",
         install_id: installId,
-        publisher_target: CLAUDE_CODE_PUBLISHER_TARGET,
+        publisher_target: COPILOT_PUBLISHER_TARGET,
         state_path: statePath,
+        command_path: commandPath,
         runtime_path: runtimePath,
         cache_path: cachePath,
+        api_key_path: apiKeyPath,
         settings_path: settingsPath,
         settings_action: settingsUpdate?.action ?? "blocked",
         composed_existing_status_line: settingsUpdate?.composedExistingStatusLine ?? false,
-        note: "Installs WaitSpin through Claude Code's official statusLine.command surface.",
+        note: "Installs WaitSpin through GitHub Copilot CLI's statusLine.command surface.",
         next: "check_status",
-        next_command: "waitspin claude-code status",
+        next_command: "waitspin copilot status",
     };
     if (dryRun) {
-        const blockedReason = settingsBlockedReason ?? scopedStatusLineBlockedReason;
         const output = {
             ...summary,
             dry_run: true,
             publisher_registered: false,
             has_existing_status_line: Boolean(settings.statusLine),
-            ...(scopedStatusLine
-                ? {
-                    scoped_status_line: {
-                        scope: scopedStatusLine.scope,
-                        path: scopedStatusLine.path,
-                        overrides_user_settings: Boolean(scopedStatusLineBlockedReason),
-                    },
-                }
-                : {}),
-            ...(blockedReason
+            ...(settingsBlockedReason
                 ? {
                     would_fail: true,
-                    settings_blocked_reason: blockedReason,
-                    next: settingsBlockedReason
-                        ? "resolve_status_line_conflict"
-                        : "resolve_project_status_line_override",
-                    ...(settingsBlockedReason
-                        ? {
-                            next_command: "waitspin claude-code install --compose-existing",
-                        }
-                        : {
-                            human_message: "Current project/local Claude Code settings override user-level statusLine. Remove or compose that statusLine before installing WaitSpin for this project.",
-                        }),
+                    settings_blocked_reason: settingsBlockedReason,
+                    next: "resolve_status_line_conflict",
+                    next_command: "waitspin copilot install --compose-existing",
                 }
                 : {}),
         };
@@ -1841,36 +3175,41 @@ export async function runClaudeCodeInstall(flags) {
         return;
     }
     if (!settingsUpdate) {
-        throw new Error("Unable to resolve Claude Code settings update.");
+        throw new Error("Unable to resolve GitHub Copilot CLI settings update.");
     }
-    const claudeVersion = await assertSupportedClaudeCodeVersion();
+    const copilotVersion = await readCopilotVersion();
     const apiKey = requireApiKey(flags);
     const registration = await registerPublisherInstall({
         baseUrl,
         apiKey,
         installId,
-        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        target: COPILOT_PUBLISHER_TARGET,
     });
     const installedAt = new Date().toISOString();
     const installState = {
-        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        target: COPILOT_PUBLISHER_TARGET,
         install_id: registration.install_id,
         publisher_id: registration.publisher_id,
         publisher_target: registration.target,
         registered_at: installedAt,
         base_url: baseUrl,
-        api_key: apiKey,
+        api_key_path: apiKeyPath,
+        command_path: commandPath,
         runtime_path: runtimePath,
         cache_path: cachePath,
         settings_path: settingsPath,
         managed_status_line: managedStatusLine,
         previous_status_line: settingsUpdate.previousStatusLine,
+        previous_status_line_command_mode: settingsUpdate.previousStatusLine === undefined ? undefined : "exec-path",
+        had_previous_footer_show_custom: settingsUpdate.hadPreviousFooterShowCustom,
+        previous_footer_show_custom: settingsUpdate.previousFooterShowCustom,
         composed_existing_status_line: settingsUpdate.composedExistingStatusLine,
-        claude_version: claudeVersion,
+        copilot_version: copilotVersion,
         installed_at: installedAt,
     };
     try {
-        await writeClaudeCodeRuntime(runtimePath);
+        await writeCopilotRuntime({ runtimePath, commandPath, statePath });
+        await writeSecretFile(apiKeyPath, apiKey);
         await writeJsonObjectFile(statePath, installState, 0o600);
         await writeJsonObjectFile(settingsPath, settingsUpdate.nextSettings);
     }
@@ -1881,99 +3220,111 @@ export async function runClaudeCodeInstall(flags) {
         else {
             await Promise.resolve(rm(statePath, { force: true, recursive: true })).catch(() => { });
             await Promise.resolve(rm(runtimePath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(commandPath, { force: true, recursive: true })).catch(() => { });
+            await Promise.resolve(rm(apiKeyPath, { force: true, recursive: true })).catch(() => { });
         }
         throw error;
     }
     const output = {
         ...summary,
-        ...redactedClaudeCodeState(installState),
+        ...redactedCopilotState(installState),
         publisher_registered: true,
-        claude_version: claudeVersion,
-        next: "launch_claude_code",
-        next_command: "claude",
-        acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+        copilot_version: copilotVersion,
+        next: "launch_copilot",
+        next_command: COPILOT_DEFAULT_BIN,
+        verification_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
     };
     printCliOutput(flags, output, formatTargetInstallResult(output));
 }
-export async function runClaudeCodeStatus(flags = new Map()) {
-    const state = await loadClaudeCodeInstallState();
-    const settings = await loadClaudeCodeSettings();
+export async function runCopilotStatus(flags = new Map()) {
+    const state = await loadCopilotInstallState();
+    const settingsPath = state?.settings_path ?? copilotSettingsPath();
+    const settings = await loadCopilotSettings(settingsPath);
     const managedStatusLine = state?.managed_status_line ?? null;
     const currentStatusLine = settings.statusLine;
-    const statusLineConfigured = Boolean(managedStatusLine && statusLineEquals(currentStatusLine, managedStatusLine));
-    const scopedStatusLine = await findClaudeCodeScopedStatusLine();
-    const scopedStatusLineOverridden = Boolean(managedStatusLine &&
-        scopedStatusLine &&
-        !statusLineEquals(scopedStatusLine.statusLine, managedStatusLine));
-    const effectiveStatusLineConfigured = statusLineConfigured && !scopedStatusLineOverridden;
+    const statusLineConfigured = Boolean(managedStatusLine &&
+        copilotStatusLineEquals(currentStatusLine, managedStatusLine));
     const runtimeInstalled = state
-        ? await pathExists(assertSafeClaudeCodeManagedPath(state.runtime_path))
+        ? await pathAccessible(assertSafeCopilotManagedPath(state.runtime_path), fsConstants.R_OK)
         : false;
-    const installed = Boolean(state && runtimeInstalled && effectiveStatusLineConfigured);
+    const commandInstalled = state
+        ? await pathAccessible(assertSafeCopilotManagedPath(state.command_path), fsConstants.X_OK)
+        : false;
+    const apiKeyInstalled = state
+        ? await pathAccessible(assertSafeCopilotManagedPath(state.api_key_path), fsConstants.R_OK)
+        : false;
+    const footerCustomEnabled = isRecord(settings.footer)
+        ? settings.footer.showCustom === true
+        : false;
+    const installed = Boolean(state &&
+        runtimeInstalled &&
+        commandInstalled &&
+        apiKeyInstalled &&
+        statusLineConfigured &&
+        footerCustomEnabled);
     const output = {
         ok: true,
-        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        target: COPILOT_PUBLISHER_TARGET,
         mode: "statusline-command",
         installed,
         publisher_registered: Boolean(state?.publisher_id),
         install_id: state?.install_id ?? null,
         publisher_id: state?.publisher_id ?? null,
-        publisher_target: state?.publisher_target ?? CLAUDE_CODE_PUBLISHER_TARGET,
-        state_path: claudeCodeStatePath(),
-        runtime_path: state?.runtime_path ?? claudeCodeRuntimePath(),
-        cache_path: state?.cache_path ?? claudeCodeCachePath(),
-        settings_path: claudeCodeSettingsPath(),
+        publisher_target: state?.publisher_target ?? COPILOT_PUBLISHER_TARGET,
+        state_path: copilotStatePath(),
+        command_path: state?.command_path ?? copilotCommandPath(),
+        runtime_path: state?.runtime_path ?? copilotRuntimePath(),
+        cache_path: state?.cache_path ?? copilotCachePath(),
+        api_key_path: state?.api_key_path ?? copilotApiKeyPath(),
+        settings_path: settingsPath,
+        api_key_installed: apiKeyInstalled,
+        command_installed: commandInstalled,
         runtime_installed: runtimeInstalled,
         status_line_configured: statusLineConfigured,
-        effective_status_line_configured: effectiveStatusLineConfigured,
-        status_line_overridden: scopedStatusLineOverridden,
-        ...(scopedStatusLineOverridden && scopedStatusLine
-            ? {
-                status_line_override_scope: scopedStatusLine.scope,
-                status_line_override_path: scopedStatusLine.path,
-            }
-            : {}),
+        footer_custom_enabled: footerCustomEnabled,
         composed_existing_status_line: Boolean(state?.composed_existing_status_line),
         has_previous_status_line: Boolean(state?.previous_status_line),
-        claude_version: state?.claude_version ?? null,
+        copilot_version: state?.copilot_version ?? null,
         ...(installed
             ? {
-                next: "launch_claude_code",
-                next_command: "claude",
-                acceptance_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
+                next: "launch_copilot",
+                next_command: COPILOT_DEFAULT_BIN,
+                verification_hint: "Keep the sponsored line visible for at least 5 seconds, then verify an impression.",
             }
             : {
-                next: "install_claude_code",
-                next_command: "waitspin claude-code install --compose-existing",
-                human_message: scopedStatusLineOverridden
-                    ? "Claude Code WaitSpin support is installed in user settings, but a higher-priority project/local statusLine overrides it in this directory."
-                    : "Claude Code WaitSpin statusline support is not installed for this user.",
+                next: "install_copilot",
+                next_command: "waitspin copilot install",
+                human_message: "GitHub Copilot CLI WaitSpin statusline support is not installed for this user.",
             }),
     };
     printCliOutput(flags, output, formatTargetStatusResult(output));
 }
-export async function runClaudeCodeUninstall(flags) {
+export async function runCopilotUninstall(flags) {
     const dryRun = booleanFlag(flags, "dry-run");
-    const state = await loadClaudeCodeInstallState();
-    const settings = await loadClaudeCodeSettings();
+    const state = await loadCopilotInstallState();
+    const settingsPath = state?.settings_path ?? copilotSettingsPath();
+    const settings = await loadCopilotSettings(settingsPath);
     const declaredRemovePaths = state
         ? [
+            state.command_path,
             state.runtime_path,
             state.cache_path,
-            claudeCodeStatePath(),
+            state.api_key_path,
+            copilotStatePath(),
+            `${state.cache_path}.*.heartbeat`,
         ]
-        : [claudeCodeStatePath()];
+        : [copilotStatePath()];
     let nextSettings = null;
     let settingsAction = "not-managed";
     let settingsWarning = null;
     if (state?.managed_status_line) {
-        if (!statusLineEquals(settings.statusLine, state.managed_status_line)) {
+        if (!copilotStatusLineEquals(settings.statusLine, state.managed_status_line)) {
             settingsAction = "skip-user-settings";
             settingsWarning =
-                "Claude Code statusLine is no longer the WaitSpin managed command; leaving user settings unchanged while removing WaitSpin-managed files.";
+                "GitHub Copilot CLI statusLine is no longer the WaitSpin managed command; leaving user settings unchanged while removing WaitSpin-managed files.";
         }
         else {
-            nextSettings = { ...settings };
+            nextSettings = restoreCopilotFooterShowCustom(settings, state);
             if (state.previous_status_line !== undefined) {
                 nextSettings.statusLine = state.previous_status_line;
                 settingsAction = "restore-previous";
@@ -1987,7 +3338,7 @@ export async function runClaudeCodeUninstall(flags) {
     if (dryRun) {
         const output = {
             ok: true,
-            target: CLAUDE_CODE_PUBLISHER_TARGET,
+            target: COPILOT_PUBLISHER_TARGET,
             dry_run: true,
             installed: Boolean(state),
             settings_action: settingsAction,
@@ -2004,18 +3355,21 @@ export async function runClaudeCodeUninstall(flags) {
     }
     const removePaths = state
         ? [
-            assertSafeClaudeCodeManagedPath(state.runtime_path),
-            assertSafeClaudeCodeManagedPath(state.cache_path),
-            claudeCodeStatePath(),
+            assertSafeCopilotManagedPath(state.command_path),
+            assertSafeCopilotManagedPath(state.runtime_path),
+            assertSafeCopilotManagedPath(state.cache_path),
+            assertSafeCopilotManagedPath(state.api_key_path),
+            copilotStatePath(),
+            ...(await managedHeartbeatPaths(state.cache_path, assertSafeCopilotManagedPath)),
         ]
-        : [claudeCodeStatePath()];
+        : [copilotStatePath()];
     if (nextSettings) {
-        await writeJsonObjectFile(claudeCodeSettingsPath(), nextSettings);
+        await writeJsonObjectFile(settingsPath, nextSettings);
     }
     await Promise.all(removePaths.map((filePath) => rm(filePath, { force: true, recursive: true })));
     const output = {
         ok: true,
-        target: CLAUDE_CODE_PUBLISHER_TARGET,
+        target: COPILOT_PUBLISHER_TARGET,
         uninstalled: true,
         settings_action: settingsAction,
         removed: removePaths,
@@ -3243,6 +4597,12 @@ async function preflightMiMoCode() {
 async function preflightOpenCode() {
     return executableVersion(OPENCODE_BIN_ENV, OPENCODE_DEFAULT_BIN, "OpenCode");
 }
+async function preflightCopilot() {
+    return readCopilotVersion();
+}
+async function preflightAntigravity() {
+    return readAntigravityVersion();
+}
 function experimentalCliDeps() {
     return {
         booleanFlag,
@@ -3291,6 +4651,22 @@ function allInstallTargets(flags) {
             status: runOpencodeStatus,
         },
         experimentalInstallTarget("grok", experimentalDeps),
+        {
+            target: ANTIGRAVITY_PUBLISHER_TARGET,
+            command: "waitspin antigravity install --compose-existing",
+            statusCommand: "waitspin antigravity status",
+            preflight: preflightAntigravity,
+            install: runAntigravityInstall,
+            status: runAntigravityStatus,
+        },
+        {
+            target: COPILOT_PUBLISHER_TARGET,
+            command: "waitspin copilot install --compose-existing",
+            statusCommand: "waitspin copilot status",
+            preflight: preflightCopilot,
+            install: runCopilotInstall,
+            status: runCopilotStatus,
+        },
     ];
     if (booleanFlag(flags, "include-experimental")) {
         targets.push(...experimentalAllInstallTargets(experimentalDeps).filter((target) => target.target !== "grok"));
@@ -3307,7 +4683,7 @@ function isNotDetectedError(message) {
     if (/WaitSpin extension package not found|assets not found/i.test(message)) {
         return false;
     }
-    return /not detected|Unable to run Claude Code|Unsupported Claude Code version|ENOENT|spawn .*ENOENT|command not found|executable path/i.test(message);
+    return /not detected|Unable to run Claude Code|Unable to run GitHub Copilot CLI|Unable to run Antigravity CLI|Unsupported Claude Code version|ENOENT|spawn .*ENOENT|command not found|executable path/i.test(message);
 }
 function isConflictError(message) {
     return /statusLine|status line|conflict|override|already has|blocked/i.test(message);
@@ -3578,6 +4954,30 @@ export async function main(argv = process.argv.slice(2)) {
         await runOpencodeUninstall(flags);
         return;
     }
+    if (command === "copilot" && positionals[0] === "install") {
+        await runCopilotInstall(flags);
+        return;
+    }
+    if (command === "copilot" && positionals[0] === "status") {
+        await runCopilotStatus(flags);
+        return;
+    }
+    if (command === "copilot" && positionals[0] === "uninstall") {
+        await runCopilotUninstall(flags);
+        return;
+    }
+    if (command === "antigravity" && positionals[0] === "install") {
+        await runAntigravityInstall(flags);
+        return;
+    }
+    if (command === "antigravity" && positionals[0] === "status") {
+        await runAntigravityStatus(flags);
+        return;
+    }
+    if (command === "antigravity" && positionals[0] === "uninstall") {
+        await runAntigravityUninstall(flags);
+        return;
+    }
     if (isExperimentalCliTargetName(command) && positionals[0] === "install") {
         await runExperimentalCliTargetInstall(command, flags, experimentalCliDeps());
         return;