@promptai.credit/cli 0.4.1 → 0.4.2

package/README.md

@@ -6,17 +6,36 @@ Cursor Agents Window are supported today; Codex CLI is next.
 
 ## How it works
 
-1. `promptai install claude` merges two hooks into `~/.claude/settings.json`:
+1. `promptai install claude` merges two hooks into `~/.claude/settings.json` and
+   installs the Claude Mods plugin into `~/.claude/skills/promptai/`:
    - **UserPromptSubmit**: baselines the session's transcript watermark and (if opted
      in, at most every 90s, never headless) opens the hosted rewarded-ad page
-     (`/watch`) in your browser. The ad plays while your agent works.
+     (`/watch`) in your browser — **unless** the Mods plugin is live (heartbeat in
+     `~/.promptai/native-plugin.json`), in which case the native AbovePrompt card
+     shows the ad instead.
    - **Stop** (async): reads the session transcript JSONL since the watermark, prices
      the turn with the shared model price table, and redeems one banked
      server-verified ad session against it via the API.
-2. The `/watch` page creates the ad session server-side on load, so SSV wall-clock
-   timing is enforced by the server; the browser countdown is cosmetic.
+   - **Mods plugin** (`product/claude-plugin`): on `prompt.submit` fetches an ad
+     session and renders a compact sponsored card via `ui.render` / `AbovePrompt`.
+2. The `/watch` page (and the native card) create the ad session server-side, so SSV
+   wall-clock timing is enforced by the server; countdowns are cosmetic.
 3. `promptai claim` pays out your verified balance as USDC on Base.
 
+### Claude Mods (native card)
+
+Native AbovePrompt ads need Claude Code function hooks (early access until GA).
+`promptai install claude` sets `env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1` in
+`~/.claude/settings.json` (an explicit value you already set is left alone, and
+`promptai uninstall claude` removes only what it added). This also enables any other
+function-hook plugins you use. Where Mods are unavailable, command hooks open `/watch`
+in the browser.
+Dev-load the plugin without installing:
+
+```bash
+CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude --plugin-dir product/claude-plugin
+```
+
 ## Cursor Agents Window (Glass)
 
 The Agents Window doesn't run VS Code extensions, so the promptai extension can't
@@ -45,7 +64,7 @@ State lives in `~/.promptai/` (`config.json`, `state.json`, `cli.log`).
 
 ```bash
 npm install -g @promptai.credit/cli
-promptai install claude      # Claude Code hooks
+promptai install claude      # Claude Code hooks + Mods plugin
 promptai install cursor      # Cursor Agents Window / classic IDE hooks
 ```
 
@@ -82,4 +101,4 @@ Developing from the repo instead: `pnpm --filter @promptai.credit/cli build`, th
 - Headless environments (CI, ssh without a display) never get browser tabs and
   simply skip crediting.
 - Uninstall with `promptai uninstall claude`; other hooks in your settings are
-  preserved.
+  preserved, and the Mods plugin under `~/.claude/skills/promptai/` is removed.

package/claude-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "promptai",
+  "version": "0.1.0",
+  "description": "Opt-in rewarded ads above the Claude Code prompt. Watch a short sponsored card while the agent works; verified watches fund prompt credits via promptai.credit.",
+  "author": {
+    "name": "PromptAI",
+    "url": "https://promptai.credit"
+  },
+  "homepage": "https://promptai.credit",
+  "keywords": ["ads", "credits", "promptai", "rewarded"]
+}

package/claude-plugin/README.md

@@ -0,0 +1,33 @@
+# PromptAI Claude Code plugin
+
+Native rewarded-ad card for Claude Code via **Claude Mods** (function hooks).
+
+While the agent works, a compact sponsored row renders above the prompt
+(`AbovePrompt`). After the server-verified watch window, the credit is banked
+the same way as the browser `/watch` path. Transcript pricing and redeem still
+run through the `promptai` CLI `Stop` command hook.
+
+## Requirements
+
+- Claude Code with function hooks enabled (early access). `promptai install claude`
+  sets `env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1` in `~/.claude/settings.json`; to enable
+  it by hand, use `CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude`.
+
+- `promptai install claude` (wires command hooks, enables the flag, copies this plugin)
+
+## Dev load (without install)
+
+```bash
+CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 claude --plugin-dir /path/to/product/claude-plugin
+```
+
+## Notes
+
+- If Mods are off or the module fails to load, the CLI falls back to opening
+  `/watch` in the browser (fail open).
+- The plugin writes `~/.promptai/native-plugin.json` on `session.start` so the
+  CLI can skip the browser tab while the native card is live.
+- The brand logo (PNG, favicon or SVG) is drawn as half-block cells, so it works in any
+  terminal. It is fetched with `curl` and converted with `sips` (macOS) or ImageMagick;
+  SVGs need `qlmanage` (macOS) or `rsvg-convert`. If any step is missing the card simply
+  draws without a logo. Results are cached under `~/.promptai/logos/`.

package/claude-plugin/hooks/ads.tsx

@@ -0,0 +1,557 @@
+/**
+ * PromptAI native rewarded-ad card for Claude Code (Mods / function hooks).
+ *
+ * Lifecycle:
+ *  1. session.start  — load ~/.promptai config; heartbeat so CLI skips /watch
+ *  2. prompt.submit  — fire-and-forget POST /ads/session (never await before next)
+ *  3. ui.render AbovePrompt — compact sponsored card + countdown
+ *  4. clock tick     — when minWatchMs elapsed, POST /ads/complete
+ *  5. CTA press      — beacon click, open destination in OS browser
+ *
+ * Stop / transcript pricing / credit redeem stay on the command-hook CLI path.
+ *
+ * Requires CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 until Mods are generally available.
+ */
+import type { EngineInterface as Engine, Register, Timer } from "claude-code";
+import { WORK_PX, bitmapToCells, decodeBase64, hashKey, parseBmp, type LogoCells } from "./logo.ts";
+
+const SOURCE = "claude-mods";
+/** Logo cell grid: half-blocks, so 12 columns × 6 rows is a square of 12×12 pixels. */
+const LOGO_COLS = 12;
+const LOGO_ROWS = 6;
+const HEARTBEAT_FILE = "native-plugin.json";
+/** How long the CLI treats a heartbeat as "plugin is live" before falling back to /watch. */
+const HEARTBEAT_FRESH_MS = 2 * 60 * 60 * 1000;
+
+interface AdCreative {
+  id: string;
+  brand: string;
+  tag: string;
+  tagline: string;
+  lines: Array<{ cmd: boolean; text: string }>;
+  ctaLabel: string;
+  ctaUrl: string;
+  destinationUrl?: string;
+  logoUrl?: string;
+  minWatchMs: number;
+}
+
+interface PromptaiConfig {
+  deviceId: string;
+  serverUrl: string;
+  adsOptIn: boolean;
+}
+
+type AdPhase = "idle" | "loading" | "showing" | "verified" | "failed";
+
+interface ActiveAd {
+  phase: AdPhase;
+  sessionId?: string;
+  ad?: AdCreative;
+  shownAt?: number;
+  error?: string;
+  tick?: Timer;
+  logo?: LogoCells;
+}
+
+const active: ActiveAd = { phase: "idle" };
+let config: PromptaiConfig | null = null;
+let homeDir = "";
+let startingSession = false;
+
+function configPath(): string {
+  return `${homeDir}/.promptai/config.json`;
+}
+
+function statePath(): string {
+  return `${homeDir}/.promptai/state.json`;
+}
+
+function heartbeatPath(): string {
+  return `${homeDir}/.promptai/${HEARTBEAT_FILE}`;
+}
+
+async function resolveHome($: Engine): Promise<string> {
+  try {
+    return ((await $.env.get("HOME")) ?? "").trim();
+  } catch {
+    return "";
+  }
+}
+
+async function readJson<T>($: Engine, path: string, fallback: T): Promise<T> {
+  try {
+    if (!(await $.fs.exists(path))) return fallback;
+    const raw = await $.fs.read(path);
+    return { ...fallback, ...(JSON.parse(raw) as T) };
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJson($: Engine, path: string, value: unknown): Promise<void> {
+  try {
+    await $.fs.write(path, `${JSON.stringify(value, null, 2)}\n`);
+  } catch {
+    // never break the session for local state
+  }
+}
+
+async function loadConfig($: Engine): Promise<PromptaiConfig | null> {
+  if (!homeDir) return null;
+  const cfg = await readJson<PromptaiConfig>($, configPath(), {
+    deviceId: "",
+    serverUrl: "https://api.promptai.credit",
+    adsOptIn: true,
+  });
+  if (!cfg.deviceId) return null;
+  if (!cfg.serverUrl) cfg.serverUrl = "https://api.promptai.credit";
+  return cfg;
+}
+
+async function bumpLastAdOpenedAt($: Engine, at: number): Promise<void> {
+  const state = await readJson<Record<string, unknown>>($, statePath(), {});
+  state.lastAdOpenedAt = at;
+  await writeJson($, statePath(), state);
+}
+
+async function writeHeartbeat($: Engine): Promise<void> {
+  await writeJson($, heartbeatPath(), {
+    active: true,
+    at: Date.now(),
+    source: SOURCE,
+    freshMs: HEARTBEAT_FRESH_MS,
+  });
+}
+
+// Same palette as the /watch page so the terminal card reads as one brand.
+const C = {
+  fg: "#fafafa",
+  soft: "#b9b9b9",
+  dim: "#8f8f8f",
+  faint: "#525252",
+  green: "#4ade80",
+  red: "#f87171",
+  amber: "#fbbf24",
+};
+
+function progressBar(elapsed: number, total: number, width = 20): { filled: string; empty: string } {
+  const ratio = Math.min(1, Math.max(0, elapsed / Math.max(1, total)));
+  const n = Math.round(ratio * width);
+  return { filled: "█".repeat(n), empty: "░".repeat(width - n) };
+}
+
+function clearTick(): void {
+  const tick = active.tick;
+  active.tick = undefined;
+  try {
+    tick?.cancel();
+  } catch {
+    // ignore
+  }
+}
+
+function resetAd(phase: AdPhase = "idle"): void {
+  clearTick();
+  active.phase = phase;
+  active.sessionId = undefined;
+  active.ad = undefined;
+  active.shownAt = undefined;
+  active.error = undefined;
+  active.logo = undefined;
+}
+
+function parseBody<T>(text: string): T {
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return {} as T;
+  }
+}
+
+/** True while /ads/complete is in flight, so a slow response is never asked twice. */
+let completing = false;
+
+async function completeAd($: Engine): Promise<void> {
+  if (completing || !config || !active.sessionId || active.phase !== "showing") return;
+  completing = true;
+  // Stop the countdown first: with the request in flight the phase is still
+  // "showing", and another tick would send a second complete ("already verified").
+  clearTick();
+  const sessionId = active.sessionId;
+  try {
+    const res = await $.http.fetch(`${config.serverUrl}/ads/complete`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sessionId, deviceId: config.deviceId }),
+    });
+    if (!res.ok) {
+      const body = parseBody<{ error?: string }>(res.text);
+      active.phase = "failed";
+      active.error = body.error ?? `complete ${res.status}`;
+      clearTick();
+      $.ui.invalidate("ui.render");
+      return;
+    }
+    active.phase = "verified";
+    clearTick();
+    $.ui.invalidate("ui.render");
+    // Auto-collapse the verified strip after a short beat.
+    $.clock.after(8_000, () => {
+      if (active.phase === "verified") {
+        resetAd("idle");
+        $.ui.invalidate("ui.render");
+      }
+    });
+  } catch (err) {
+    active.phase = "failed";
+    active.error = String(err);
+    clearTick();
+    $.ui.invalidate("ui.render");
+  } finally {
+    completing = false;
+  }
+}
+
+function startCountdown($: Engine): void {
+  clearTick();
+  active.tick = $.clock.every(1_000, () => {
+    if (active.phase !== "showing" || !active.ad || active.shownAt == null) return;
+    const elapsed = Date.now() - active.shownAt;
+    if (elapsed >= active.ad.minWatchMs) {
+      void completeAd($);
+      return;
+    }
+    $.ui.invalidate("ui.render");
+  });
+}
+
+async function openDestination($: Engine, url: string): Promise<void> {
+  const candidates: string[][] = [
+    ["xdg-open", url],
+    ["open", url],
+    ["cmd", "/c", "start", "", url],
+  ];
+  for (const argv of candidates) {
+    try {
+      const result = await $.process.run(argv, { timeoutMs: 5_000 });
+      if (result.exitCode === 0) return;
+    } catch {
+      // try next opener
+    }
+  }
+  $.ui.toast(`Open in browser: ${url}`);
+}
+
+async function onCtaPress($: Engine): Promise<void> {
+  if (!config || !active.sessionId || !active.ad) return;
+  const ad = active.ad;
+  const clickUrl = ad.ctaUrl.includes("/ads/click/")
+    ? ad.ctaUrl
+    : `${config.serverUrl}/ads/click/${active.sessionId}`;
+  try {
+    void $.http.fetch(clickUrl, { method: "GET" });
+  } catch {
+    // click is best-effort
+  }
+  const target =
+    ad.destinationUrl ||
+    (ad.ctaUrl.includes("/ads/click/") ? undefined : ad.ctaUrl);
+  if (target) await openDestination($, target);
+}
+
+// --- logo host pipeline (curl → svg→png → bmp; pure image code is in logo.ts) ---
+
+async function tryRun($: Engine, argv: string[], timeoutMs = 8_000): Promise<{ ok: boolean; stdout: string }> {
+  try {
+    const res = await $.process.run(argv, { timeoutMs });
+    return { ok: res.exitCode === 0, stdout: res.stdout };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+
+async function exists($: Engine, path: string): Promise<boolean> {
+  try {
+    return await $.fs.exists(path);
+  } catch {
+    return false;
+  }
+}
+
+async function svgToPng($: Engine, svg: string, dir: string, png: string): Promise<boolean> {
+  // macOS Quick Look thumbnailer: writes <dir>/<file>.png
+  const ql = await tryRun($, ["qlmanage", "-t", "-s", String(WORK_PX * 2), "-o", dir, svg]);
+  if (ql.ok && (await exists($, `${svg}.png`))) {
+    await tryRun($, ["mv", "-f", `${svg}.png`, png]);
+    if (await exists($, png)) return true;
+  }
+  const rsvg = await tryRun($, ["rsvg-convert", "-w", String(WORK_PX), "-h", String(WORK_PX), "-f", "png", "-o", png, svg]);
+  return rsvg.ok && (await exists($, png));
+}
+
+async function toBmp($: Engine, input: string, bmp: string): Promise<boolean> {
+  const attempts: string[][] = [
+    ["sips", "-s", "format", "bmp", "-Z", String(WORK_PX), input, "--out", bmp],
+    ["magick", input, "-background", "none", "-resize", `${WORK_PX}x${WORK_PX}`, `BMP3:${bmp}`],
+    ["convert", input, "-background", "none", "-resize", `${WORK_PX}x${WORK_PX}`, `BMP3:${bmp}`],
+  ];
+  for (const argv of attempts) {
+    const res = await tryRun($, argv);
+    if (res.ok && (await exists($, bmp))) return true;
+  }
+  return false;
+}
+
+const failedLogos = new Set<string>();
+
+/**
+ * Load `url` as terminal cells, caching the result under
+ * `<home>/.promptai/logos/`. Resolves null when anything is unavailable.
+ */
+async function loadLogoCells(
+  $: Engine,
+  opts: { url: string; home: string; columns: number; rows: number },
+): Promise<LogoCells | null> {
+  const { url, home, columns, rows } = opts;
+  if (!home || !/^https?:\/\//i.test(url)) return null;
+
+  const key = `${hashKey(url)}-${columns}x${rows}`;
+  if (failedLogos.has(key)) return null;
+
+  const dir = `${home}/.promptai/logos`;
+  const cacheFile = `${dir}/${key}.cells.json`;
+  try {
+    if (await exists($, cacheFile)) {
+      const cached = JSON.parse(await $.fs.read(cacheFile)) as LogoCells;
+      if (cached.cells && cached.columns === columns && cached.rows === rows) return cached;
+    }
+  } catch {
+    // rebuild below
+  }
+
+  const src = `${dir}/${key}.src`;
+  const png = `${dir}/${key}.png`;
+  const bmp = `${dir}/${key}.bmp`;
+  try {
+    const dl = await tryRun($, [
+      "curl", "-sSL", "--max-time", "5", "--max-filesize", "2000000", "--create-dirs",
+      "-o", src, "-w", "%{content_type}", url,
+    ]);
+    if (!dl.ok || !(await exists($, src))) throw new Error("download");
+
+    const isSvg = /svg/i.test(dl.stdout) || /\.svg(\?|$)/i.test(url);
+    let input = src;
+    if (isSvg) {
+      const svgFile = `${src}.svg`;
+      await tryRun($, ["mv", "-f", src, svgFile]);
+      if (!(await svgToPng($, svgFile, dir, png))) throw new Error("svg");
+      input = png;
+    }
+    if (!(await toBmp($, input, bmp))) throw new Error("bmp");
+
+    const { base64 } = await $.fs.read(bmp, { as: "bytes" });
+    const bitmap = parseBmp(decodeBase64(base64));
+    if (!bitmap) throw new Error("parse");
+
+    const logo = bitmapToCells(bitmap, columns, rows);
+    await $.fs.write(cacheFile, JSON.stringify(logo));
+    return logo;
+  } catch {
+    failedLogos.add(key);
+    return null;
+  } finally {
+    await tryRun($, ["rm", "-f", src, `${src}.svg`, png, bmp]);
+  }
+}
+
+/** Fire-and-forget: the card draws at once, the logo joins it when ready. */
+async function loadLogo($: Engine, ad: AdCreative): Promise<void> {
+  if (!ad.logoUrl) return;
+  const logo = await loadLogoCells($, { url: ad.logoUrl, home: homeDir, columns: LOGO_COLS, rows: LOGO_ROWS });
+  if (logo && active.ad?.id === ad.id) {
+    active.logo = logo;
+    $.ui.invalidate("ui.render");
+  }
+}
+
+async function beginAdSession($: Engine): Promise<void> {
+  if (!config || !config.adsOptIn || startingSession) return;
+  if (active.phase === "loading" || active.phase === "showing") return;
+
+  startingSession = true;
+  active.phase = "loading";
+  $.ui.invalidate("ui.render");
+
+  try {
+    const res = await $.http.fetch(`${config.serverUrl}/ads/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceId: config.deviceId, source: SOURCE }),
+    });
+    const body = parseBody<{
+      sessionId?: string;
+      ad?: AdCreative;
+      error?: string;
+    }>(res.text);
+    if (!res.ok || !body.sessionId || !body.ad) {
+      active.phase = "failed";
+      active.error = body.error ?? `session ${res.status}`;
+      $.ui.invalidate("ui.render");
+      $.clock.after(5_000, () => {
+        if (active.phase === "failed") {
+          resetAd("idle");
+          $.ui.invalidate("ui.render");
+        }
+      });
+      return;
+    }
+
+    const now = Date.now();
+    active.phase = "showing";
+    active.sessionId = body.sessionId;
+    active.ad = body.ad;
+    active.shownAt = now;
+    active.error = undefined;
+    await bumpLastAdOpenedAt($, now);
+    startCountdown($);
+    $.ui.invalidate("ui.render");
+    void loadLogo($, body.ad);
+  } catch (err) {
+    active.phase = "failed";
+    active.error = String(err);
+    $.ui.invalidate("ui.render");
+    $.clock.after(5_000, () => {
+      if (active.phase === "failed") {
+        resetAd("idle");
+        $.ui.invalidate("ui.render");
+      }
+    });
+  } finally {
+    startingSession = false;
+  }
+}
+
+function remainingSeconds($: Engine): number {
+  if (!active.ad || active.shownAt == null) return 0;
+  const left = active.ad.minWatchMs - (Date.now() - active.shownAt);
+  return Math.max(0, Math.ceil(left / 1000));
+}
+
+export const register: Register = (on) => {
+  on("session.start", async ($, e, next) => {
+    homeDir = await resolveHome($);
+    config = await loadConfig($);
+    if (config?.adsOptIn) {
+      await writeHeartbeat($);
+    }
+    return next(e);
+  });
+
+  // Fire-and-forget: never await the session fetch before next(e).
+  on("prompt.submit", ($, e, next) => {
+    if (config?.adsOptIn) {
+      void writeHeartbeat($);
+      void beginAdSession($);
+    }
+    return next(e);
+  });
+
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    if (!config?.adsOptIn || active.phase === "idle") {
+      return next(e);
+    }
+
+    const t = await $.ui.resolve(e);
+
+    if (active.phase === "loading") {
+      return (
+        <t.Box borderStyle="round" borderColor={C.faint} paddingX={1} gap={1}>
+          <t.Text color={C.amber}>●</t.Text>
+          <t.Text color={C.dim}>promptai · loading sponsored card…</t.Text>
+        </t.Box>
+      );
+    }
+
+    if (active.phase === "failed") {
+      return (
+        <t.Box borderStyle="round" borderColor={C.red} paddingX={1} gap={1}>
+          <t.Text color={C.red}>✕</t.Text>
+          <t.Text color={C.dim}>{`promptai · ad unavailable${active.error ? ` (${active.error})` : ""}`}</t.Text>
+        </t.Box>
+      );
+    }
+
+    if (active.phase === "verified") {
+      return (
+        <t.Box borderStyle="round" borderColor={C.green} paddingX={1} gap={1}>
+          <t.Text color={C.green} bold>✓ verified</t.Text>
+          <t.Text color={C.soft}>credit banked</t.Text>
+          <t.Text color={C.faint}>·</t.Text>
+          <t.Button
+            key="hide"
+            label="Hide"
+            plain
+            onPress={() => {
+              resetAd("idle");
+              $.ui.invalidate("ui.render");
+            }}
+          />
+        </t.Box>
+      );
+    }
+
+    if (active.phase !== "showing" || !active.ad || active.shownAt == null) {
+      return next(e);
+    }
+
+    const ad = active.ad;
+    const elapsed = Date.now() - active.shownAt;
+    const bar = progressBar(elapsed, ad.minWatchMs);
+    const secs = remainingSeconds($);
+    const shownLines = (ad.lines ?? []).slice(0, 4);
+
+    const Raster = "Raster" in t ? t.Raster : null;
+    const logo = active.logo;
+
+    const details = (
+      <t.Box flexDirection="column" flexGrow={1}>
+        <t.Box gap={1}>
+          <t.Text color={C.green}>◆</t.Text>
+          <t.Text color={C.fg} bold>{ad.brand}</t.Text>
+          {ad.tag ? <t.Text color={C.dim}>{`· ${ad.tag}`}</t.Text> : null}
+          <t.Text color={C.faint}>· sponsored</t.Text>
+        </t.Box>
+        <t.Text color={C.soft} wrap="truncate-end">{ad.tagline}</t.Text>
+        {shownLines.map((line, i) => (
+          <t.Box key={`line-${i}`} gap={1}>
+            {line.cmd ? <t.Text color={C.green}>$</t.Text> : <t.Text color={C.faint}>│</t.Text>}
+            <t.Text color={line.cmd ? C.fg : C.dim} wrap="truncate-end">{line.text}</t.Text>
+          </t.Box>
+        ))}
+      </t.Box>
+    );
+
+    return (
+      <t.Box flexDirection="column" borderStyle="round" borderColor={C.faint} paddingX={1}>
+        {Raster && logo ? (
+          <t.Box gap={2}>
+            <Raster key="logo" columns={logo.columns} rows={logo.rows} cells={logo.cells} />
+            {details}
+          </t.Box>
+        ) : (
+          details
+        )}
+        <t.Box gap={1}>
+          <t.Box>
+            <t.Text color={C.green}>{bar.filled}</t.Text>
+            <t.Text color={C.faint}>{bar.empty}</t.Text>
+          </t.Box>
+          <t.Text color={C.fg} bold>{`${secs}s`}</t.Text>
+          <t.Text color={C.faint}>opt-in rewarded ad</t.Text>
+        </t.Box>
+        <t.Button key="cta" label={`${ad.ctaLabel || "Learn more"} →`} onPress={() => void onCtaPress($)} />
+      </t.Box>
+    );
+  });
+};

package/claude-plugin/hooks/hooks.json

@@ -0,0 +1,4 @@
+{
+  "description": "PromptAI native rewarded-ad card (Claude Mods function hooks).",
+  "modules": ["./ads.tsx"]
+}

package/claude-plugin/hooks/logo.ts

@@ -0,0 +1,167 @@
+/**
+ * Brand logo → terminal cells for the AbovePrompt card.
+ *
+ * Works in any terminal (Apple Terminal included): the logo becomes a
+ * `Raster` of half-block glyphs, two pixels per cell. Everything here fails
+ * open — a missing converter, a slow CDN or an odd format just means the card
+ * draws without a logo.
+ *
+ * Pure image code only: the host pipeline (curl → svg→png → bmp) lives in
+ * ads.tsx, because every `$.noun.method()` call has to sit in the hooks module.
+ */
+export interface LogoCells {
+  columns: number;
+  rows: number;
+  /** Raster `cells`: base64 of little-endian u32 [codePoint, fg, bg] triplets. */
+  cells: string;
+}
+
+/** Working size handed to the converters; downscaled to the cell grid here. */
+export const WORK_PX = 64;
+const DEFAULT_COLOR = 0x01000000;
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+export function encodeBase64(bytes: Uint8Array): string {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += B64[a >> 2] + B64[((a & 3) << 4) | (b >> 4)];
+    out += i + 1 < bytes.length ? B64[((b & 15) << 2) | (c >> 6)] : "=";
+    out += i + 2 < bytes.length ? B64[c & 63] : "=";
+  }
+  return out;
+}
+
+export function decodeBase64(text: string): Uint8Array {
+  const bin = atob(text);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+export interface Bitmap {
+  width: number;
+  height: number;
+  /** RGBA, row-major, top-down. */
+  rgba: Uint8Array;
+}
+
+/** Uncompressed 24/32-bit BMP (what sips and ImageMagick's BMP3 write). */
+export function parseBmp(bytes: Uint8Array): Bitmap | null {
+  if (bytes.length < 54 || bytes[0] !== 0x42 || bytes[1] !== 0x4d) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dataOffset = view.getUint32(10, true);
+  const width = view.getInt32(18, true);
+  const rawHeight = view.getInt32(22, true);
+  const bpp = view.getUint16(28, true);
+  const compression = view.getUint32(30, true);
+  const height = Math.abs(rawHeight);
+  const topDown = rawHeight < 0;
+  if (width <= 0 || height <= 0 || width > 4096 || height > 4096) return null;
+  if ((bpp !== 24 && bpp !== 32) || (compression !== 0 && compression !== 3)) return null;
+
+  const bytesPerPx = bpp / 8;
+  const stride = ((width * bpp + 31) >> 5) << 2;
+  if (dataOffset + stride * height > bytes.length) return null;
+
+  const rgba = new Uint8Array(width * height * 4);
+  let anyAlpha = false;
+  for (let y = 0; y < height; y++) {
+    const srcRow = dataOffset + (topDown ? y : height - 1 - y) * stride;
+    for (let x = 0; x < width; x++) {
+      const s = srcRow + x * bytesPerPx;
+      const d = (y * width + x) * 4;
+      rgba[d] = bytes[s + 2];
+      rgba[d + 1] = bytes[s + 1];
+      rgba[d + 2] = bytes[s];
+      const a = bpp === 32 ? bytes[s + 3] : 255;
+      rgba[d + 3] = a;
+      if (a !== 0) anyAlpha = true;
+    }
+  }
+  // A 32-bit BMP whose alpha byte is all zero is XRGB padding, not "invisible".
+  if (!anyAlpha) for (let i = 3; i < rgba.length; i += 4) rgba[i] = 255;
+  return { width, height, rgba };
+}
+
+/**
+ * Fit `bmp` into columns × (rows*2) pixels (aspect kept, centred, area
+ * averaged) and pack half-block cells. Transparent pixels stay the terminal's
+ * own background, so the logo sits on the card, not on a colored square.
+ */
+export function bitmapToCells(bmp: Bitmap, columns: number, rows: number): LogoCells {
+  const W = columns;
+  const H = rows * 2;
+  const scale = Math.min(W / bmp.width, H / bmp.height);
+  const fitW = Math.max(1, Math.round(bmp.width * scale));
+  const fitH = Math.max(1, Math.round(bmp.height * scale));
+  const offX = Math.floor((W - fitW) / 2);
+  const offY = Math.floor((H - fitH) / 2);
+
+  // One RGB (or null for transparent) per target pixel.
+  const px: Array<number | null> = new Array(W * H).fill(null);
+  for (let ty = 0; ty < fitH; ty++) {
+    const y0 = Math.floor((ty * bmp.height) / fitH);
+    const y1 = Math.max(y0 + 1, Math.floor(((ty + 1) * bmp.height) / fitH));
+    for (let tx = 0; tx < fitW; tx++) {
+      const x0 = Math.floor((tx * bmp.width) / fitW);
+      const x1 = Math.max(x0 + 1, Math.floor(((tx + 1) * bmp.width) / fitW));
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let a = 0;
+      let n = 0;
+      for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+          const i = (y * bmp.width + x) * 4;
+          const alpha = bmp.rgba[i + 3];
+          r += bmp.rgba[i] * alpha;
+          g += bmp.rgba[i + 1] * alpha;
+          b += bmp.rgba[i + 2] * alpha;
+          a += alpha;
+          n++;
+        }
+      }
+      if (a / n < 90) continue; // mostly transparent
+      const R = Math.round(r / a);
+      const G = Math.round(g / a);
+      const B = Math.round(b / a);
+      px[(offY + ty) * W + (offX + tx)] = (R << 16) | (G << 8) | B;
+    }
+  }
+
+  const words = new Uint32Array(columns * rows * 3);
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < columns; col++) {
+      const top = px[row * 2 * W + col];
+      const bottom = px[(row * 2 + 1) * W + col];
+      let glyph = 0x20;
+      let fg = DEFAULT_COLOR;
+      let bg = DEFAULT_COLOR;
+      if (top !== null && bottom !== null) {
+        glyph = 0x2580; // ▀
+        fg = top;
+        bg = bottom;
+      } else if (top !== null) {
+        glyph = 0x2580;
+        fg = top;
+      } else if (bottom !== null) {
+        glyph = 0x2584; // ▄
+        fg = bottom;
+      }
+      const at = (row * columns + col) * 3;
+      words[at] = glyph;
+      words[at + 1] = fg;
+      words[at + 2] = bg;
+    }
+  }
+  return { columns, rows, cells: encodeBase64(new Uint8Array(words.buffer)) };
+}
+
+export function hashKey(text: string): string {
+  let h = 5381;
+  for (let i = 0; i < text.length; i++) h = ((h * 33) ^ text.charCodeAt(i)) >>> 0;
+  return h.toString(36);
+}

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 
 // src/claude.ts
 import * as crypto3 from "node:crypto";
-import * as fs5 from "node:fs";
-import * as os3 from "node:os";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as os4 from "node:os";
+import * as path5 from "node:path";
 
 // src/api.ts
 import * as crypto from "node:crypto";
@@ -246,15 +246,20 @@ function openInBrowser(url, side = "right") {
   const chrome = chromeBin();
   if (chrome) {
     const profile = path2.join(promptaiDir(), "ad-window");
+    const appUrl = `${url}${url.includes("?") ? "&" : "?"}_=${Date.now()}`;
     try {
       spawn(
         chrome,
         [
           `--user-data-dir=${profile}`,
-          `--app=${url}`,
+          `--app=${appUrl}`,
           `--window-position=${rect.x},${rect.y}`,
           `--window-size=${rect.w},${rect.h}`,
-          "--new-window"
+          "--new-window",
+          "--no-first-run",
+          "--no-default-browser-check",
+          "--disable-session-crashed-bubble",
+          "--hide-crash-restore-bubble"
         ],
         { detached: true, stdio: "ignore" }
       ).unref();
@@ -372,6 +377,113 @@ function resolveEmail(config) {
   return detected.email;
 }
 
+// src/plugin.ts
+import * as fs4 from "node:fs";
+import * as os3 from "node:os";
+import * as path4 from "node:path";
+import { fileURLToPath } from "node:url";
+var PLUGIN_NAME = "promptai";
+var HEARTBEAT_FILE = "native-plugin.json";
+var HEARTBEAT_FRESH_MS = 2 * 60 * 60 * 1e3;
+function claudePluginInstallDir() {
+  return path4.join(os3.homedir(), ".claude", "skills", PLUGIN_NAME);
+}
+function heartbeatPath() {
+  return path4.join(promptaiDir(), HEARTBEAT_FILE);
+}
+function pluginSourceDir() {
+  const here = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    // npm package / after build: claude-plugin/ next to dist/
+    path4.resolve(here, "..", "claude-plugin"),
+    // monorepo: product/cli/dist|src → product/claude-plugin
+    path4.resolve(here, "..", "..", "claude-plugin")
+  ];
+  for (const dir of candidates) {
+    if (fs4.existsSync(path4.join(dir, ".claude-plugin", "plugin.json"))) {
+      return dir;
+    }
+    if (fs4.existsSync(path4.join(dir, "hooks", "ads.tsx"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+function copyDirSync(src, dest) {
+  fs4.mkdirSync(dest, { recursive: true });
+  for (const entry of fs4.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const from = path4.join(src, entry.name);
+    const to = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(from, to);
+    } else if (entry.isFile()) {
+      fs4.copyFileSync(from, to);
+    }
+  }
+}
+function isClaudePluginInstalled() {
+  const dir = claudePluginInstallDir();
+  return fs4.existsSync(path4.join(dir, ".claude-plugin", "plugin.json")) || fs4.existsSync(path4.join(dir, "hooks", "ads.tsx"));
+}
+function isNativePluginActive(now = Date.now()) {
+  try {
+    const raw = fs4.readFileSync(heartbeatPath(), "utf8");
+    const data = JSON.parse(raw);
+    if (data.active !== true) return false;
+    const at = Number(data.at ?? 0);
+    const freshMs = Number(data.freshMs ?? HEARTBEAT_FRESH_MS);
+    if (!Number.isFinite(at) || at <= 0) return false;
+    return now - at < freshMs;
+  } catch {
+    return false;
+  }
+}
+function clearNativeHeartbeat() {
+  try {
+    fs4.unlinkSync(heartbeatPath());
+  } catch {
+  }
+}
+function installClaudePlugin() {
+  const source = pluginSourceDir();
+  const installPath = claudePluginInstallDir();
+  if (!source) {
+    return {
+      changed: false,
+      installPath,
+      sourcePath: null,
+      error: "Claude Mods plugin sources not found next to the CLI. Reinstall @promptai.credit/cli."
+    };
+  }
+  fs4.mkdirSync(path4.dirname(installPath), { recursive: true });
+  fs4.rmSync(installPath, { recursive: true, force: true });
+  copyDirSync(source, installPath);
+  fs4.writeFileSync(
+    heartbeatPath(),
+    JSON.stringify(
+      {
+        active: false,
+        installed: true,
+        installedAt: Date.now(),
+        installPath,
+        source,
+        note: "Becomes active when Claude Code loads the plugin (Mods / function hooks)."
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  return { changed: true, installPath, sourcePath: source };
+}
+function uninstallClaudePlugin() {
+  const installPath = claudePluginInstallDir();
+  const existed = fs4.existsSync(installPath);
+  fs4.rmSync(installPath, { recursive: true, force: true });
+  clearNativeHeartbeat();
+  return { changed: existed, installPath };
+}
+
 // src/pricing.ts
 var TABLE = [
   { match: ["fable"], inputPerMtok: 3, outputPerMtok: 15 },
@@ -402,9 +514,9 @@ function costUsd(model, inputTokens, outputTokens) {
 }
 
 // src/transcript.ts
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 function readTranscriptUsage(transcriptPath, watermark) {
-  const raw = fs4.readFileSync(transcriptPath, "utf8");
+  const raw = fs5.readFileSync(transcriptPath, "utf8");
   const byMessageId = /* @__PURE__ */ new Map();
   let parsedCount = 0;
   for (const line of raw.split("\n")) {
@@ -446,7 +558,7 @@ function readTranscriptUsage(transcriptPath, watermark) {
   };
 }
 function readGlassTranscriptUsage(transcriptPath, watermark) {
-  const raw = fs4.readFileSync(transcriptPath, "utf8");
+  const raw = fs5.readFileSync(transcriptPath, "utf8");
   const lines = raw.split("\n").filter((l) => l.trim());
   let inputChars = 0;
   let outputChars = 0;
@@ -481,13 +593,13 @@ var MAX_CREDIT_PER_AD_USD = 5;
 var AD_MIN_INTERVAL_MS = 9e4;
 var SETTLE_RETRIES = [400, 800, 1500];
 function claudeSettingsPath() {
-  return path4.join(os3.homedir(), ".claude", "settings.json");
+  return path5.join(os4.homedir(), ".claude", "settings.json");
 }
 function hookCommand() {
-  let script = path4.resolve(process.argv[1] ?? "");
+  let script = path5.resolve(process.argv[1] ?? "");
   if (script.endsWith(".ts")) {
-    const dist = path4.resolve(path4.dirname(script), "..", "dist", "index.js");
-    if (!fs5.existsSync(dist)) {
+    const dist = path5.resolve(path5.dirname(script), "..", "dist", "index.js");
+    if (!fs6.existsSync(dist)) {
       throw new Error(
         `Build the CLI first (pnpm --filter @promptai.credit/cli build); hooks cannot run ${script} directly.`
       );
@@ -496,21 +608,34 @@ function hookCommand() {
   }
   return `"${process.execPath}" "${script}" hook`;
 }
+var MODS_FLAG = "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS";
+var MODS_FLAG_MARKER = "mods-flag-added";
+function modsFlagMarkerPath() {
+  return path5.join(promptaiDir(), MODS_FLAG_MARKER);
+}
 function installClaudeHooks() {
   const settingsPath = claudeSettingsPath();
-  fs5.mkdirSync(path4.dirname(settingsPath), { recursive: true });
+  fs6.mkdirSync(path5.dirname(settingsPath), { recursive: true });
   let settings = {};
-  if (fs5.existsSync(settingsPath)) {
+  if (fs6.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs5.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs6.readFileSync(settingsPath, "utf8"));
     } catch {
-      fs5.copyFileSync(settingsPath, settingsPath + ".promptai-backup");
+      fs6.copyFileSync(settingsPath, settingsPath + ".promptai-backup");
       settings = {};
     }
   }
   settings.hooks = settings.hooks ?? {};
   const command2 = hookCommand();
   let changed = false;
+  settings.env = settings.env && typeof settings.env === "object" ? settings.env : {};
+  if (settings.env[MODS_FLAG] === void 0) {
+    settings.env[MODS_FLAG] = "1";
+    fs6.mkdirSync(promptaiDir(), { recursive: true });
+    fs6.writeFileSync(modsFlagMarkerPath(), `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+    changed = true;
+  }
   for (const event of ["UserPromptSubmit", "Stop"]) {
     const groups = Array.isArray(settings.hooks[event]) ? settings.hooks[event] : [];
     let ours = groups.flatMap((g) => g.hooks ?? []).find((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER));
@@ -524,23 +649,30 @@ function installClaudeHooks() {
       changed = true;
     }
   }
-  if (changed || !fs5.existsSync(settingsPath)) {
-    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (changed || !fs6.existsSync(settingsPath)) {
+    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   }
   return { changed, settingsPath };
 }
 function uninstallClaudeHooks() {
   const settingsPath = claudeSettingsPath();
-  if (!fs5.existsSync(settingsPath)) return { changed: false };
+  if (!fs6.existsSync(settingsPath)) return { changed: false };
   let settings;
   try {
-    settings = JSON.parse(fs5.readFileSync(settingsPath, "utf8"));
+    settings = JSON.parse(fs6.readFileSync(settingsPath, "utf8"));
   } catch {
     return { changed: false };
   }
-  if (!settings.hooks) return { changed: false };
   let changed = false;
-  for (const [event, groups] of Object.entries(settings.hooks)) {
+  if (fs6.existsSync(modsFlagMarkerPath())) {
+    if (settings.env?.[MODS_FLAG] === "1") {
+      delete settings.env[MODS_FLAG];
+      if (Object.keys(settings.env).length === 0) delete settings.env;
+      changed = true;
+    }
+    fs6.rmSync(modsFlagMarkerPath(), { force: true });
+  }
+  for (const [event, groups] of Object.entries(settings.hooks ?? {})) {
     if (!Array.isArray(groups)) continue;
     const kept = groups.map((g) => ({
       ...g,
@@ -554,7 +686,7 @@ function uninstallClaudeHooks() {
     }
   }
   if (changed) {
-    fs5.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs6.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   }
   return { changed };
 }
@@ -571,12 +703,16 @@ function handleUserPromptSubmit(payload) {
     }
   }
   if (config.adsOptIn && Date.now() - state.lastAdOpenedAt >= AD_MIN_INTERVAL_MS) {
-    const url = watchUrl(config.serverUrl, config.deviceId, SOURCE);
-    if (openInBrowser(url, config.adSide)) {
-      state.lastAdOpenedAt = Date.now();
-      log(`[claude] opened ad tab for session=${sessionId}`);
-    } else if (!hasDisplay()) {
-      log(`[claude] headless environment, skipped ad tab`);
+    if (isNativePluginActive()) {
+      log(`[claude] native Mods plugin active, skipped browser ad tab session=${sessionId}`);
+    } else {
+      const url = watchUrl(config.serverUrl, config.deviceId, SOURCE);
+      if (openInBrowser(url, config.adSide)) {
+        state.lastAdOpenedAt = Date.now();
+        log(`[claude] opened ad tab for session=${sessionId}`);
+      } else if (!hasDisplay()) {
+        log(`[claude] headless environment, skipped ad tab`);
+      }
     }
   }
   saveState(state);
@@ -656,9 +792,9 @@ async function redeemAgainstAd(serverUrl, deviceId, promptId, cost, email) {
 
 // src/cursor.ts
 import * as crypto4 from "node:crypto";
-import * as fs6 from "node:fs";
-import * as os4 from "node:os";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as os5 from "node:os";
+import * as path6 from "node:path";
 var CURSOR_SOURCE = "cursor-agents";
 var HOOK_MARKER2 = "promptai";
 var MAX_CREDIT_PER_AD_USD2 = 5;
@@ -668,17 +804,17 @@ function isCursorPayload(payload) {
   return typeof payload.cursor_version === "string" || typeof payload.conversation_id === "string";
 }
 function cursorHooksJsonPath() {
-  return path5.join(os4.homedir(), ".cursor", "hooks.json");
+  return path6.join(os5.homedir(), ".cursor", "hooks.json");
 }
 function installCursorHooks() {
   const hooksPath = cursorHooksJsonPath();
-  fs6.mkdirSync(path5.dirname(hooksPath), { recursive: true });
+  fs7.mkdirSync(path6.dirname(hooksPath), { recursive: true });
   let config = {};
-  if (fs6.existsSync(hooksPath)) {
+  if (fs7.existsSync(hooksPath)) {
     try {
-      config = JSON.parse(fs6.readFileSync(hooksPath, "utf8"));
+      config = JSON.parse(fs7.readFileSync(hooksPath, "utf8"));
     } catch {
-      fs6.copyFileSync(hooksPath, hooksPath + ".promptai-backup");
+      fs7.copyFileSync(hooksPath, hooksPath + ".promptai-backup");
       config = {};
     }
   }
@@ -700,17 +836,17 @@ function installCursorHooks() {
       changed = true;
     }
   }
-  if (changed || !fs6.existsSync(hooksPath)) {
-    fs6.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+  if (changed || !fs7.existsSync(hooksPath)) {
+    fs7.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
   }
   return { changed, hooksPath };
 }
 function uninstallCursorHooks() {
   const hooksPath = cursorHooksJsonPath();
-  if (!fs6.existsSync(hooksPath)) return { changed: false };
+  if (!fs7.existsSync(hooksPath)) return { changed: false };
   let config;
   try {
-    config = JSON.parse(fs6.readFileSync(hooksPath, "utf8"));
+    config = JSON.parse(fs7.readFileSync(hooksPath, "utf8"));
   } catch {
     return { changed: false };
   }
@@ -727,14 +863,14 @@ function uninstallCursorHooks() {
     }
   }
   if (changed) {
-    fs6.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+    fs7.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
   }
   return { changed };
 }
 function extensionIsActive() {
-  const infoPath = path5.join(os4.homedir(), ".cursor", "promptai-listener.json");
+  const infoPath = path6.join(os5.homedir(), ".cursor", "promptai-listener.json");
   try {
-    const info = JSON.parse(fs6.readFileSync(infoPath, "utf8"));
+    const info = JSON.parse(fs7.readFileSync(infoPath, "utf8"));
     if (typeof info.pid !== "number") return false;
     process.kill(info.pid, 0);
     return true;
@@ -743,18 +879,18 @@ function extensionIsActive() {
   }
 }
 function acquireOnceLock(key) {
-  const dir = path5.join(promptaiDir(), "locks");
-  fs6.mkdirSync(dir, { recursive: true });
+  const dir = path6.join(promptaiDir(), "locks");
+  fs7.mkdirSync(dir, { recursive: true });
   try {
     const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
-    for (const name of fs6.readdirSync(dir)) {
-      const p = path5.join(dir, name);
-      if (fs6.statSync(p).mtimeMs < cutoff) fs6.rmSync(p, { recursive: true, force: true });
+    for (const name of fs7.readdirSync(dir)) {
+      const p = path6.join(dir, name);
+      if (fs7.statSync(p).mtimeMs < cutoff) fs7.rmSync(p, { recursive: true, force: true });
     }
   } catch {
   }
   try {
-    fs6.mkdirSync(path5.join(dir, key.replace(/[^a-zA-Z0-9_-]/g, "_")));
+    fs7.mkdirSync(path6.join(dir, key.replace(/[^a-zA-Z0-9_-]/g, "_")));
     return true;
   } catch {
     return false;
@@ -898,12 +1034,12 @@ import * as readline from "node:readline";
 var EMAIL_RE2 = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
 var WALLET_RE = /^0x[0-9a-fA-F]{40}$/;
 function promptLine(question) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     process.stdout.write(question);
     const rl = readline.createInterface({ input: process.stdin });
     rl.once("line", (line) => {
       rl.close();
-      resolve2(line);
+      resolve3(line);
     });
   });
 }
@@ -988,9 +1124,9 @@ async function onboard(config) {
 var HELP = `promptai - ad-subsidized prompt credits for terminal agents
 
 Usage:
-  promptai install claude     Wire hooks into ~/.claude/settings.json
+  promptai install claude     Wire hooks + Claude Mods native ad plugin
   promptai install cursor     Wire hooks into ~/.cursor/hooks.json (Agents Window)
-  promptai uninstall <agent>  Remove our hooks (other hooks untouched)
+  promptai uninstall <agent>  Remove our hooks/plugin (other hooks untouched)
   promptai status             Device, balance, banked ad credits, recent prompts
   promptai watch              Open a rewarded ad in the browser now
   promptai claim [address]    Claim your verified balance as USDC (Base)
@@ -1002,10 +1138,10 @@ Usage:
   promptai hook               (internal) invoked by agent hooks, JSON on stdin
 `;
 function readStdin() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const chunks = [];
     process.stdin.on("data", (c) => chunks.push(c));
-    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
   });
 }
 async function cmdHook() {
@@ -1017,11 +1153,11 @@ async function cmdHook() {
     return;
   }
   const event = String(payload.hook_event_name ?? "");
-  if (process.env.PROMPTAI_DUMP === "1" || fs7.existsSync(path6.join(promptaiDir(), "debug"))) {
+  if (process.env.PROMPTAI_DUMP === "1" || fs8.existsSync(path7.join(promptaiDir(), "debug"))) {
     try {
-      const dir = path6.join(promptaiDir(), "dump");
-      fs7.mkdirSync(dir, { recursive: true });
-      fs7.writeFileSync(path6.join(dir, `${Date.now()}-${event || "unknown"}.json`), raw);
+      const dir = path7.join(promptaiDir(), "dump");
+      fs8.mkdirSync(dir, { recursive: true });
+      fs8.writeFileSync(path7.join(dir, `${Date.now()}-${event || "unknown"}.json`), raw);
     } catch {
     }
   }
@@ -1052,6 +1188,11 @@ async function cmdStatus() {
   console.log(`email    ${email || "(not detected - promptai set email you@example.com)"}`);
   console.log(`ads      ${config.adsOptIn ? "opted in" : "opted out"}`);
   console.log(`side     ${config.adSide}`);
+  const nativeInstalled = isClaudePluginInstalled();
+  const nativeActive = isNativePluginActive();
+  console.log(
+    `native   ${nativeActive ? "active (AbovePrompt)" : nativeInstalled ? "installed (waiting for Mods session)" : "not installed"}`
+  );
   console.log(`watch    ${watchUrl(config.serverUrl, config.deviceId, "manual")}`);
   try {
     const [balance, verified] = await Promise.all([
@@ -1165,13 +1306,30 @@ function printInstallNext() {
   console.log("You can toggle ads with promptai on / promptai off.");
   console.log("Try: promptai watch, then run a prompt.");
 }
+function printClaudeModsHint(installPath) {
+  console.log("");
+  console.log("Native AbovePrompt ads use Claude Mods (function hooks, early access).");
+  console.log("Enabled via env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 in your Claude settings;");
+  console.log("this also turns on any other function-hook plugins you have.");
+  console.log(`Plugin path: ${installPath}`);
+  console.log("Where Mods are unavailable, ads still open in the browser (/watch).");
+}
 async function cmdInstall(agent) {
   if (agent === "claude" || agent === "claude-code") {
     const { changed, settingsPath } = installClaudeHooks();
     console.log(
       changed ? `Hooks installed into ${settingsPath}.` : `Hooks already installed in ${settingsPath}.`
     );
-    console.log("Claude Code picks them up on its next session.");
+    const plugin = installClaudePlugin();
+    if (plugin.error) {
+      console.log(`Mods plugin: ${plugin.error}`);
+    } else {
+      console.log(
+        plugin.changed ? `Mods plugin installed into ${plugin.installPath}.` : `Mods plugin already at ${plugin.installPath}.`
+      );
+      printClaudeModsHint(plugin.installPath);
+    }
+    console.log("Claude Code picks hooks up on its next session.");
     await onboard(loadConfig());
     printInstallNext();
     return;
@@ -1195,6 +1353,10 @@ function cmdUninstall(agent) {
   if (agent === "claude" || agent === "claude-code") {
     const { changed } = uninstallClaudeHooks();
     console.log(changed ? "Hooks removed." : "No promptai hooks found.");
+    const plugin = uninstallClaudePlugin();
+    console.log(
+      plugin.changed ? `Mods plugin removed from ${plugin.installPath}.` : "No Mods plugin install found."
+    );
     return;
   }
   if (agent === "cursor" || agent === "cursor-agents") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptai.credit/cli",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "publishConfig": {
     "access": "public"
   },
@@ -22,11 +22,12 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "claude-plugin"
   ],
   "scripts": {
     "dev": "tsx src/index.ts",
-    "build": "esbuild src/index.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/index.js --banner:js=\"#!/usr/bin/env node\"",
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/index.js --banner:js=\"#!/usr/bin/env node\" && node scripts/copy-plugin.mjs",
     "prepublishOnly": "pnpm build",
     "typecheck": "tsc --noEmit"
   },