From 9432eb1ae36e100b05186d40c80d4135a7ce0f64 Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Wed, 3 Jun 2026 10:27:20 +0000
Subject: [PATCH 01/10] feat(compute): implement native acp compute apply flow
 for Venice credits

---
 src/commands/compute.ts | 137 ++++++++++++++++++++++++++++++++++++++++
 src/lib/api/agent.ts    |  54 ++++++++++++++++
 2 files changed, 191 insertions(+)

diff --git a/src/commands/compute.ts b/src/commands/compute.ts
index 306f7d6..487db6f 100644
--- a/src/commands/compute.ts
+++ b/src/commands/compute.ts
@@ -1,4 +1,6 @@
 import type { Command } from "commander";
+import { execSync } from "child_process";
+import * as readline from "readline";
 import { encodeFunctionData, erc20Abi, isAddress, parseUnits } from "viem";
 import { USDC_ADDRESSES, USDC_DECIMALS } from "@virtuals-protocol/acp-node-v2";
 import { isJson, outputResult, outputError, isTTY } from "../lib/output";
@@ -160,4 +162,139 @@ export function registerComputeCommands(program: Command): void {
         outputError(json, err instanceof Error ? err : String(err));
       }
     });
+
+  // Helper functions for apply
+  function execCommand(cmd: string): string {
+    try {
+      return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    } catch {
+      return "";
+    }
+  }
+
+  function askQuestion(query: string, defaultValue: string): Promise<string> {
+    const displayQuery = defaultValue ? `${query} [${defaultValue}]: ` : `${query}: `;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    return new Promise((resolve) => {
+      rl.question(displayQuery, (ans) => {
+        rl.close();
+        resolve(ans.trim() || defaultValue);
+      });
+    });
+  }
+
+  compute
+    .command("apply")
+    .description("Apply for Venice developer compute credits ($200 approved)")
+    .option("--github <handle>", "GitHub handle (auto-harvested if omitted)")
+    .option("--email <email>", "Developer Email address (auto-harvested if omitted)")
+    .option("--name <name>", "Full Name (auto-harvested if omitted)")
+    .option("--linkedin <url>", "LinkedIn Profile URL")
+    .option("--referral <code-or-referral>", "Referral code (Optional)")
+    .option("--motivation <text>", "What will you build? (Optional)")
+    .action(async (opts, cmd) => {
+      const json = isJson(cmd);
+      const tty = isTTY() && !json;
+
+      try {
+        const { agentApi } = await getClient();
+        const agentId = getActiveAgentId(json);
+        if (!agentId) return;
+
+        // Auto-harvest
+        const harvestedName = opts.name || execCommand("git config --global user.name") || "Developer";
+        const harvestedEmail = opts.email || execCommand("git config --global user.email") || "";
+        let harvestedGithub = opts.github || execCommand("git config --global github.user") || execCommand("git config --global credential.username");
+        if (!harvestedGithub) {
+          try {
+            harvestedGithub = execCommand("gh api user -q .login");
+          } catch {}
+        }
+
+        // Get GitHub token
+        const githubToken = process.env.GITHUB_TOKEN || execCommand("gh auth token");
+
+        let name = harvestedName;
+        let email = harvestedEmail;
+        let github = harvestedGithub;
+        let linkedin = opts.linkedin || "";
+        let referral = opts.referral || "";
+        let motivation = opts.motivation || "";
+
+        if (tty) {
+          console.log(`\n🚀 ${c.cyan("Venice-Virtuals Developer Inference Credit Campaign ($200 approved)")}`);
+          console.log(`${c.dim("----------------------------------------------------------------------")}`);
+          
+          name = await askQuestion("  [1/6] Full Name", name);
+          email = await askQuestion("  [2/6] Developer Email", email);
+          github = await askQuestion("  [3/6] GitHub Username", github);
+          linkedin = await askQuestion("  [4/6] LinkedIn Profile URL", linkedin);
+          referral = await askQuestion("  [5/6] Referral Code (Optional)", referral);
+          motivation = await askQuestion("  [6/6] Motivation (What will you build? / Optional)", motivation);
+        }
+
+        if (!github) {
+          throw new CliError(
+            "Missing GitHub Handle",
+            "VALIDATION_ERROR",
+            "Please provide a GitHub handle using --github or configure your Git globally."
+          );
+        }
+
+        if (!linkedin) {
+          throw new CliError(
+            "Missing LinkedIn URL",
+            "VALIDATION_ERROR",
+            "Please provide a LinkedIn profile URL using --linkedin."
+          );
+        }
+
+        if (!githubToken && tty) {
+          console.log(`\n⚠️  ${c.yellow("No active GitHub token detected.")}`);
+          console.log(`   Please run ${c.bold("gh auth login")} or set the ${c.bold("GITHUB_TOKEN")} environment variable.`);
+          console.log(`   We will attempt a public linking, but authenticated claims are recommended.\n`);
+        }
+
+        if (tty) {
+          console.log(`\n⌛ ${c.dim("Submitting your application to the Venice-Virtuals Audit Engine...")}`);
+        }
+
+        // First we link GitHub
+        await agentApi.linkDeveloperCampaignGithub(agentId, github, githubToken, undefined);
+        
+        // Then we enroll
+        const enrollRes = await agentApi.enrollDeveloperCampaign(agentId, github, githubToken, undefined);
+
+        if (json) {
+          outputResult(json, {
+            status: "success",
+            github,
+            email,
+            enrollment: enrollRes,
+          });
+          return;
+        }
+
+        console.log(`\n${c.green("✅ Application Submitted & Processed Successfully!")}`);
+        console.log(`\n${c.bold("📊 Venice-Virtuals Credit Claim Summary:")}`);
+        printTable([
+          ["Candidate Name", name],
+          ["Developer Email", email],
+          ["GitHub Handle", `@${github}`],
+          ["LinkedIn Profile", linkedin],
+          ["Referral Code", referral || "None"],
+          ["Evaluation Status", c.green(enrollRes?.status || "active")],
+          ["Weekly Credit Grant", `$${enrollRes?.weeklyCreditUsd || "200"}.00`],
+        ]);
+
+        console.log(`\nℹ️  ${c.dim("Your Venice compute credit has been fully linked and provisioned.")}`);
+        console.log(`   Open ${c.bold("app.virtuals.io")} on your browser to see your updated Compute Dashboard!`);
+
+      } catch (err) {
+        outputError(json, err instanceof Error ? err : String(err));
+      }
+    });
 }
diff --git a/src/lib/api/agent.ts b/src/lib/api/agent.ts
index 0b92594..7302370 100644
--- a/src/lib/api/agent.ts
+++ b/src/lib/api/agent.ts
@@ -1049,6 +1049,60 @@ export class AgentApi {
     );
   }
 
+  // ── Developer campaign methods ───────────────────────────────────
+
+  async evaluateDeveloperCampaign(
+    githubLogin: string,
+    githubToken?: string
+  ): Promise<any> {
+    const headers = githubToken ? { "x-github-token": githubToken } : {};
+    return this.client.post<any>(
+      "/developer-campaign/github/evaluate",
+      { githubLogin }
+    );
+  }
+
+  async linkDeveloperCampaignGithub(
+    agentId: string,
+    githubLogin: string,
+    githubToken: string,
+    repositoryName?: string
+  ): Promise<any> {
+    // Custom post because of headers override
+    const url = new URL(`/developer-campaign/agents/${agentId}/github-link`, this.client["baseUrl"]);
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.client["authHeaders"](),
+        "x-github-token": githubToken,
+      },
+      body: JSON.stringify({ githubLogin, repositoryName }),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return res.json();
+  }
+
+  async enrollDeveloperCampaign(
+    agentId: string,
+    githubLogin: string,
+    githubToken: string,
+    repositoryName?: string
+  ): Promise<any> {
+    const url = new URL("/developer-campaign/enroll", this.client["baseUrl"]);
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.client["authHeaders"](),
+        "x-github-token": githubToken,
+      },
+      body: JSON.stringify({ agentId, githubLogin, repositoryName }),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return res.json();
+  }
+
   async getAgentAssets(
     agentId: string,
     networks: string[]

From 0d7ff100365035c57ccad0315c43d94eaf73977e Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Thu, 4 Jun 2026 05:34:44 +0000
Subject: [PATCH 02/10] docs: add implementation plan for privy-linkedin
 verification

---
 .../2026-06-04-privy-linkedin-verification.md | 183 ++++++++++++++++++
 1 file changed, 183 insertions(+)
 create mode 100644 docs/plans/2026-06-04-privy-linkedin-verification.md

diff --git a/docs/plans/2026-06-04-privy-linkedin-verification.md b/docs/plans/2026-06-04-privy-linkedin-verification.md
new file mode 100644
index 0000000..7f88ec0
--- /dev/null
+++ b/docs/plans/2026-06-04-privy-linkedin-verification.md
@@ -0,0 +1,183 @@
+# Privy LinkedIn Verification Flow Implementation Plan
+
+> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
+
+**Goal:** Secure the `acp compute apply` credit application flow by integrating Privy-backed LinkedIn OAuth verification directly within the CLI to prevent Sybil attacks and verify real developers.
+
+**Architecture:** The CLI queries the backend to generate a temporary, secure Privy-backed LinkedIn authorization URL, opens the URL in the developer's default browser, and executes a non-blocking 3-minute polling loop to extract their cryptographically verified LinkedIn profile before completing the application.
+
+**Tech Stack:** TypeScript, Node.js, Commander.js, open (browser launcher), and Privy Node SDK.
+
+---
+
+### Task 1: Add LinkedIn Verification Endpoints to AgentApi
+
+**Objective:** Extend the `AgentApi` class with endpoints to request the Privy LinkedIn verification URL and poll the verification status.
+
+**Files:**
+- Modify: `src/lib/api/agent.ts`
+- Test: `src/lib/api/__tests__/agent.test.ts` (or equivalent test suite if exists)
+
+**Step 1: Write failing test / mock interface**
+Verify the endpoints match the desired payload and structures:
+
+```typescript
+// Test shape in src/lib/api/__tests__/agent.test.ts
+import { AgentApi } from "../agent";
+import { ApiClient } from "./client";
+
+describe("AgentApi - LinkedIn Verification", () => {
+  it("should request the correct verify url endpoint", async () => {
+    const mockClient = {
+      get: jest.fn().mockResolvedValue({
+        data: { verifyUrl: "https://auth.privy.io/verify", requestId: "req-123" }
+      })
+    } as unknown as ApiClient;
+    
+    const api = new AgentApi(mockClient);
+    const res = await api.getLinkedInVerifyUrl("agent-abc");
+    expect(mockClient.get).toHaveBeenCalledWith("/developer-campaign/agents/agent-abc/linkedin-verify-url");
+    expect(res).toEqual({ verifyUrl: "https://auth.privy.io/verify", requestId: "req-123" });
+  });
+});
+```
+
+**Step 2: Run test to verify failure**
+Run: `npm test` or verify build failure due to missing types.
+
+**Step 3: Write minimal implementation**
+Append the new methods inside `export class AgentApi` (around line 1250+ in `src/lib/api/agent.ts`):
+
+```typescript
+  /**
+   * Generates a temporary Privy authorization URL for the developer to authenticate their LinkedIn.
+   */
+  async getLinkedInVerifyUrl(agentId: string): Promise<{ verifyUrl: string; requestId: string }> {
+    const res = await this.client.get<{ data: { verifyUrl: string; requestId: string } }>(
+      `/developer-campaign/agents/${agentId}/linkedin-verify-url`
+    );
+    return res.data;
+  }
+
+  /**
+   * Polls the API to check if the developer has completed the LinkedIn handshake.
+   */
+  async checkLinkedInStatus(agentId: string, requestId: string): Promise<{ verified: boolean; url?: string }> {
+    const res = await this.client.get<{ data: { verified: boolean; url?: string } }>(
+      `/developer-campaign/agents/${agentId}/linkedin-status`,
+      { requestId }
+    );
+    return res.data;
+  }
+```
+
+**Step 4: Run test to verify pass**
+Run: `npm run build && npm run typecheck`
+Expected: PASS
+
+**Step 5: Commit**
+```bash
+git add src/lib/api/agent.ts
+git commit -m "feat: add linkedin verification endpoints to AgentApi"
+```
+
+---
+
+### Task 2: Implement Secure OAuth Polling & Fallback in compute.ts
+
+**Objective:** Integrate the browser open command and the non-blocking polling loop inside the interactive `acp compute apply` TTY flow.
+
+**Files:**
+- Modify: `src/commands/compute.ts`
+
+**Step 1: Write failing test**
+Examine how `apply` is structured and prepare the replacement logic for TTY prompt inputs.
+
+**Step 2: Run test to verify failure**
+Verify TypeScript compilation errors or manual CLI invocation throws on old manual entry.
+
+**Step 3: Write minimal implementation**
+Locate the `linkedin` question line around line 234 in `src/commands/compute.ts`:
+```typescript
+          linkedin = await askQuestion("  [4/6] LinkedIn Profile URL", linkedin);
+```
+Replace it with the dynamic Privy LinkedIn authentication and polling flow (including graceful fallback to manual entry if the API/OAuth is offline):
+
+```typescript
+          console.log(`\n  [4/6] ${c.bold("LinkedIn Authentication (Security Verification)")}`);
+          console.log(`        To protect credit pools, we use cryptographically verified LinkedIn profiles.`);
+          
+          try {
+            const { verifyUrl, requestId } = await agentApi.getLinkedInVerifyUrl(agentId);
+            
+            console.log(`\n  ${c.cyan("👉 Please authenticate and authorize at this link:")}`);
+            console.log(`     ${c.underline(verifyUrl)}\n`);
+            
+            // Open default system browser dynamically
+            const openModule = await import("open");
+            await openModule.default(verifyUrl);
+            
+            console.log(`  ${c.yellow("⌛ Waiting for LinkedIn verification... (3-minute timeout)")}`);
+            
+            let verifiedUrl: string | undefined;
+            const timeout = 180000; // 3 minutes
+            const startTime = Date.now();
+            
+            while (Date.now() - startTime < timeout) {
+              const status = await agentApi.checkLinkedInStatus(agentId, requestId);
+              if (status.verified && status.url) {
+                verifiedUrl = status.url;
+                break;
+              }
+              await new Promise((r) => setTimeout(r, 4000)); // Poll every 4 seconds
+            }
+            
+            if (!verifiedUrl) {
+              throw new Error("Verification timed out or was cancelled by user.");
+            }
+            
+            linkedin = verifiedUrl;
+            console.log(`  ✅ ${c.green("Successfully Verified LinkedIn!")} Profile: ${linkedin}`);
+            
+          } catch (err: any) {
+            console.log(`  ❌ ${c.red(`LinkedIn Auth Fallback: ${err.message}`)}`);
+            linkedin = await askQuestion("     Enter LinkedIn Profile URL (Manual Entry Fallback)", linkedin);
+          }
+```
+
+**Step 4: Run test to verify pass**
+Run: `npm run build && npm run typecheck`
+Expected: PASS with zero compile errors.
+
+**Step 5: Commit**
+```bash
+git add src/commands/compute.ts
+git commit -m "feat: integrate privy-linkedin verify and polling flow inside compute apply command"
+```
+
+---
+
+### Task 3: Verify Entire E2E Workflow
+
+**Objective:** Verify the new command options and ensure compiling compiles flawlessly.
+
+**Files:**
+- Create/Run: `scripts/verify-apply.ts` (throwaway verification script)
+
+**Step 1: Write failing test**
+Build and verify the local global executable:
+```bash
+npm run build
+```
+
+**Step 2: Run local test**
+Test the command structure output:
+```bash
+node dist/bin/acp.js compute apply --help
+```
+Expected output: Includes `--linkedin` and correct option bindings.
+
+**Step 3: Commit and push changes**
+```bash
+git push origin feat/acp-compute-apply
+```

From e3c99355040df6ec0f8f45d8e4eabdddb7ffc91f Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Thu, 4 Jun 2026 05:36:46 +0000
Subject: [PATCH 03/10] feat: add linkedin verification endpoints to AgentApi

---
 src/lib/api/agent.ts | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/lib/api/agent.ts b/src/lib/api/agent.ts
index 7302370..8e5344e 100644
--- a/src/lib/api/agent.ts
+++ b/src/lib/api/agent.ts
@@ -1284,6 +1284,33 @@ export class AgentApi {
       return null;
     }
   }
+
+  /**
+   * Generates a temporary Privy authorization URL for the developer to authenticate their LinkedIn.
+   */
+  async getLinkedInVerifyUrl(
+    agentId: string
+  ): Promise<{ verifyUrl: string; requestId: string }> {
+    const res = await this.client.get<{
+      data: { verifyUrl: string; requestId: string };
+    }>(`/developer-campaign/agents/${agentId}/linkedin-verify-url`);
+    return res.data;
+  }
+
+  /**
+   * Polls the API to check if the developer has completed the LinkedIn handshake.
+   */
+  async checkLinkedInStatus(
+    agentId: string,
+    requestId: string
+  ): Promise<{ verified: boolean; url?: string }> {
+    const res = await this.client.get<{
+      data: { verified: boolean; url?: string };
+    }>(`/developer-campaign/agents/${agentId}/linkedin-status`, {
+      requestId,
+    });
+    return res.data;
+  }
 }
 
 export interface PrepareLaunchResponse {

From d68fb340cc0b6e22b24be128b2b12edc902b114e Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Thu, 4 Jun 2026 05:38:12 +0000
Subject: [PATCH 04/10] feat: integrate privy-linkedin verify and polling flow
 inside compute apply command

---
 src/commands/compute.ts | 40 +++++++++++++++++++++++++++++++++++++++-
 src/lib/color.ts        |  1 +
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/src/commands/compute.ts b/src/commands/compute.ts
index 487db6f..f09d1d8 100644
--- a/src/commands/compute.ts
+++ b/src/commands/compute.ts
@@ -11,6 +11,7 @@ import { getActiveAgentId } from "../lib/activeAgent";
 import { createProviderAdapter, getWalletAddress } from "../lib/agentFactory";
 import { formatChainId, formatChainIds } from "../lib/chains";
 import { CliError } from "../lib/errors";
+import { openBrowser } from "../lib/browser";
 
 // ── Registration ────────────────────────────────────────────────────
 
@@ -231,7 +232,44 @@ export function registerComputeCommands(program: Command): void {
           name = await askQuestion("  [1/6] Full Name", name);
           email = await askQuestion("  [2/6] Developer Email", email);
           github = await askQuestion("  [3/6] GitHub Username", github);
-          linkedin = await askQuestion("  [4/6] LinkedIn Profile URL", linkedin);
+          console.log(`\n  [4/6] ${c.bold("LinkedIn Authentication (Security Verification)")}`);
+          console.log(`        To protect credit pools, we use cryptographically verified LinkedIn profiles.`);
+          
+          try {
+            const { verifyUrl, requestId } = await agentApi.getLinkedInVerifyUrl(agentId);
+            
+            console.log(`\n  ${c.cyan("👉 Please authenticate and authorize at this link:")}`);
+            console.log(`     ${c.underline(verifyUrl)}\n`);
+            
+            // Open default system browser dynamically
+            openBrowser(verifyUrl);
+            
+            console.log(`  ${c.yellow("⌛ Waiting for LinkedIn verification... (3-minute timeout)")}`);
+            
+            let verifiedUrl: string | undefined;
+            const timeout = 180000; // 3 minutes
+            const startTime = Date.now();
+            
+            while (Date.now() - startTime < timeout) {
+              const status = await agentApi.checkLinkedInStatus(agentId, requestId);
+              if (status.verified && status.url) {
+                verifiedUrl = status.url;
+                break;
+              }
+              await new Promise((r) => setTimeout(r, 4000)); // Poll every 4 seconds
+            }
+            
+            if (!verifiedUrl) {
+              throw new Error("Verification timed out or was cancelled by user.");
+            }
+            
+            linkedin = verifiedUrl;
+            console.log(`  ✅ ${c.green("Successfully Verified LinkedIn!")} Profile: ${linkedin}`);
+            
+          } catch (err: any) {
+            console.log(`  ❌ ${c.red(`LinkedIn Auth Fallback: ${err.message}`)}`);
+            linkedin = await askQuestion("     Enter LinkedIn Profile URL (Manual Entry Fallback)", linkedin);
+          }
           referral = await askQuestion("  [5/6] Referral Code (Optional)", referral);
           motivation = await askQuestion("  [6/6] Motivation (What will you build? / Optional)", motivation);
         }
diff --git a/src/lib/color.ts b/src/lib/color.ts
index ddf7225..8677d7f 100644
--- a/src/lib/color.ts
+++ b/src/lib/color.ts
@@ -8,6 +8,7 @@ export const c = {
   red: pc.red,
   cyan: pc.cyan,
   magenta: pc.magenta,
+  underline: pc.underline,
   status: (status: string) => {
     switch (status) {
       case "completed":

From 26760670aa3ddeff4ef95aec9295f7ac2579abb9 Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Thu, 4 Jun 2026 06:08:38 +0000
Subject: [PATCH 05/10] docs: document acp compute apply subcommand inside
 SKILL.md for autonomous agent use

---
 SKILL.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/SKILL.md b/SKILL.md
index b09be6a..eaea723 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -155,6 +155,7 @@ Pay for the agent's own LLM-inference workloads from a USDC-funded compute accou
 |---|---|---|
 | `acp compute status --json` | Show the compute account balance, usage, and limit | `{limit, limitRemaining, usage, ...}` |
 | `acp compute top-up --amount <usdc 1–1000> [--chain-id <id>] --json` | Transfer USDC (+ a processing fee) from the agent's wallet to the ACP fee wallet to credit the compute account | `{amount, totalAmount, chainId, feeWallet, txnHash}` |
+| `acp compute apply [--github <username>] [--email <email>] [--name <name>] [--linkedin <url>] [--referral <referral_code>] [--motivation <text>]` | Apply for Venice developer compute credits ($200 approved) | `{success, recommendation, score, reasoning, ...}` |
 
 The credited balance updates shortly after the transfer confirms — re-probe with `compute status`.
 
@@ -523,7 +524,7 @@ src/
     chain.ts                Chain info
     email.ts                Agent email
     card.ts                 Agent virtual cards
-    compute.ts              Agent compute account (status, top-up)
+    compute.ts              Agent compute account (status, top-up, apply)
     skill.ts                Inspect/verify the bundled SKILL.md (path, print, check)
   lib/
     config.ts               Load/save config.json at ~/.config/acp/ (override with ACP_CONFIG_DIR)

From 0b0d72a06341958f994a6c8a07fc4a30bc657ff8 Mon Sep 17 00:00:00 2001
From: Yang <yang@virtuals.io>
Date: Thu, 4 Jun 2026 06:11:41 +0000
Subject: [PATCH 06/10] chore: remove superpowers plan artifact and add
 plans/hermes to .gitignore

---
 .gitignore                                    |   6 +-
 .../2026-06-04-privy-linkedin-verification.md | 183 ------------------
 2 files changed, 5 insertions(+), 184 deletions(-)
 delete mode 100644 docs/plans/2026-06-04-privy-linkedin-verification.md

diff --git a/.gitignore b/.gitignore
index 6a874e7..1b557ee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,8 @@ dist/
 *.js.map
 *config*.json
 acp-cli-signer/acp-cli-signer
-.DS_Store
\ No newline at end of file
+.DS_Store
+
+# Superpowers/Hermes Agent artifacts
+.hermes/
+docs/plans/
diff --git a/docs/plans/2026-06-04-privy-linkedin-verification.md b/docs/plans/2026-06-04-privy-linkedin-verification.md
deleted file mode 100644
index 7f88ec0..0000000
--- a/docs/plans/2026-06-04-privy-linkedin-verification.md
+++ /dev/null
@@ -1,183 +0,0 @@
-# Privy LinkedIn Verification Flow Implementation Plan
-
-> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
-
-**Goal:** Secure the `acp compute apply` credit application flow by integrating Privy-backed LinkedIn OAuth verification directly within the CLI to prevent Sybil attacks and verify real developers.
-
-**Architecture:** The CLI queries the backend to generate a temporary, secure Privy-backed LinkedIn authorization URL, opens the URL in the developer's default browser, and executes a non-blocking 3-minute polling loop to extract their cryptographically verified LinkedIn profile before completing the application.
-
-**Tech Stack:** TypeScript, Node.js, Commander.js, open (browser launcher), and Privy Node SDK.
-
----
-
-### Task 1: Add LinkedIn Verification Endpoints to AgentApi
-
-**Objective:** Extend the `AgentApi` class with endpoints to request the Privy LinkedIn verification URL and poll the verification status.
-
-**Files:**
-- Modify: `src/lib/api/agent.ts`
-- Test: `src/lib/api/__tests__/agent.test.ts` (or equivalent test suite if exists)
-
-**Step 1: Write failing test / mock interface**
-Verify the endpoints match the desired payload and structures:
-
-```typescript
-// Test shape in src/lib/api/__tests__/agent.test.ts
-import { AgentApi } from "../agent";
-import { ApiClient } from "./client";
-
-describe("AgentApi - LinkedIn Verification", () => {
-  it("should request the correct verify url endpoint", async () => {
-    const mockClient = {
-      get: jest.fn().mockResolvedValue({
-        data: { verifyUrl: "https://auth.privy.io/verify", requestId: "req-123" }
-      })
-    } as unknown as ApiClient;
-    
-    const api = new AgentApi(mockClient);
-    const res = await api.getLinkedInVerifyUrl("agent-abc");
-    expect(mockClient.get).toHaveBeenCalledWith("/developer-campaign/agents/agent-abc/linkedin-verify-url");
-    expect(res).toEqual({ verifyUrl: "https://auth.privy.io/verify", requestId: "req-123" });
-  });
-});
-```
-
-**Step 2: Run test to verify failure**
-Run: `npm test` or verify build failure due to missing types.
-
-**Step 3: Write minimal implementation**
-Append the new methods inside `export class AgentApi` (around line 1250+ in `src/lib/api/agent.ts`):
-
-```typescript
-  /**
-   * Generates a temporary Privy authorization URL for the developer to authenticate their LinkedIn.
-   */
-  async getLinkedInVerifyUrl(agentId: string): Promise<{ verifyUrl: string; requestId: string }> {
-    const res = await this.client.get<{ data: { verifyUrl: string; requestId: string } }>(
-      `/developer-campaign/agents/${agentId}/linkedin-verify-url`
-    );
-    return res.data;
-  }
-
-  /**
-   * Polls the API to check if the developer has completed the LinkedIn handshake.
-   */
-  async checkLinkedInStatus(agentId: string, requestId: string): Promise<{ verified: boolean; url?: string }> {
-    const res = await this.client.get<{ data: { verified: boolean; url?: string } }>(
-      `/developer-campaign/agents/${agentId}/linkedin-status`,
-      { requestId }
-    );
-    return res.data;
-  }
-```
-
-**Step 4: Run test to verify pass**
-Run: `npm run build && npm run typecheck`
-Expected: PASS
-
-**Step 5: Commit**
-```bash
-git add src/lib/api/agent.ts
-git commit -m "feat: add linkedin verification endpoints to AgentApi"
-```
-
----
-
-### Task 2: Implement Secure OAuth Polling & Fallback in compute.ts
-
-**Objective:** Integrate the browser open command and the non-blocking polling loop inside the interactive `acp compute apply` TTY flow.
-
-**Files:**
-- Modify: `src/commands/compute.ts`
-
-**Step 1: Write failing test**
-Examine how `apply` is structured and prepare the replacement logic for TTY prompt inputs.
-
-**Step 2: Run test to verify failure**
-Verify TypeScript compilation errors or manual CLI invocation throws on old manual entry.
-
-**Step 3: Write minimal implementation**
-Locate the `linkedin` question line around line 234 in `src/commands/compute.ts`:
-```typescript
-          linkedin = await askQuestion("  [4/6] LinkedIn Profile URL", linkedin);
-```
-Replace it with the dynamic Privy LinkedIn authentication and polling flow (including graceful fallback to manual entry if the API/OAuth is offline):
-
-```typescript
-          console.log(`\n  [4/6] ${c.bold("LinkedIn Authentication (Security Verification)")}`);
-          console.log(`        To protect credit pools, we use cryptographically verified LinkedIn profiles.`);
-          
-          try {
-            const { verifyUrl, requestId } = await agentApi.getLinkedInVerifyUrl(agentId);
-            
-            console.log(`\n  ${c.cyan("👉 Please authenticate and authorize at this link:")}`);
-            console.log(`     ${c.underline(verifyUrl)}\n`);
-            
-            // Open default system browser dynamically
-            const openModule = await import("open");
-            await openModule.default(verifyUrl);
-            
-            console.log(`  ${c.yellow("⌛ Waiting for LinkedIn verification... (3-minute timeout)")}`);
-            
-            let verifiedUrl: string | undefined;
-            const timeout = 180000; // 3 minutes
-            const startTime = Date.now();
-            
-            while (Date.now() - startTime < timeout) {
-              const status = await agentApi.checkLinkedInStatus(agentId, requestId);
-              if (status.verified && status.url) {
-                verifiedUrl = status.url;
-                break;
-              }
-              await new Promise((r) => setTimeout(r, 4000)); // Poll every 4 seconds
-            }
-            
-            if (!verifiedUrl) {
-              throw new Error("Verification timed out or was cancelled by user.");
-            }
-            
-            linkedin = verifiedUrl;
-            console.log(`  ✅ ${c.green("Successfully Verified LinkedIn!")} Profile: ${linkedin}`);
-            
-          } catch (err: any) {
-            console.log(`  ❌ ${c.red(`LinkedIn Auth Fallback: ${err.message}`)}`);
-            linkedin = await askQuestion("     Enter LinkedIn Profile URL (Manual Entry Fallback)", linkedin);
-          }
-```
-
-**Step 4: Run test to verify pass**
-Run: `npm run build && npm run typecheck`
-Expected: PASS with zero compile errors.
-
-**Step 5: Commit**
-```bash
-git add src/commands/compute.ts
-git commit -m "feat: integrate privy-linkedin verify and polling flow inside compute apply command"
-```
-
----
-
-### Task 3: Verify Entire E2E Workflow
-
-**Objective:** Verify the new command options and ensure compiling compiles flawlessly.
-
-**Files:**
-- Create/Run: `scripts/verify-apply.ts` (throwaway verification script)
-
-**Step 1: Write failing test**
-Build and verify the local global executable:
-```bash
-npm run build
-```
-
-**Step 2: Run local test**
-Test the command structure output:
-```bash
-node dist/bin/acp.js compute apply --help
-```
-Expected output: Includes `--linkedin` and correct option bindings.
-
-**Step 3: Commit and push changes**
-```bash
-git push origin feat/acp-compute-apply
-```

From 8eca4c8efcd0dcf68cc60d1ca1b1b23cc05ed529 Mon Sep 17 00:00:00 2001
From: Ang Weoy Yang <weoyyang00@gmail.com>
Date: Thu, 4 Jun 2026 14:23:39 +0800
Subject: [PATCH 07/10] fix: acp-cli hotfixes for keyring, campaign routing,
 and 204 parsing in config.ts

---
 src/lib/config.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/lib/config.ts b/src/lib/config.ts
index 863aced..53f4efb 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -73,7 +73,12 @@ function isKeychainUnavailable(err: unknown): boolean {
 
 async function withKeyringFallback<T>(op: () => Promise<T>): Promise<T> {
   try {
-    return await op();
+    const res = await op();
+    if (res === null) {
+      await useBackend("file");
+      return await op();
+    }
+    return res;
   } catch (err) {
     if (!isKeychainUnavailable(err)) throw err;
     await useBackend("file");

From 20749ea5c226c912331f2452081db27508c9858f Mon Sep 17 00:00:00 2001
From: Ang Weoy Yang <weoyyang00@gmail.com>
Date: Thu, 4 Jun 2026 14:23:42 +0800
Subject: [PATCH 08/10] fix: acp-cli hotfixes for keyring, campaign routing,
 and 204 parsing in agent.ts

---
 src/lib/api/agent.ts | 71 +++++++++++++++++++++++++++++++++-----------
 1 file changed, 54 insertions(+), 17 deletions(-)

diff --git a/src/lib/api/agent.ts b/src/lib/api/agent.ts
index 8e5344e..1a5d492 100644
--- a/src/lib/api/agent.ts
+++ b/src/lib/api/agent.ts
@@ -1051,15 +1051,32 @@ export class AgentApi {
 
   // ── Developer campaign methods ───────────────────────────────────
 
+  private getCampaignBaseUrl(): string {
+    const base = this.client["baseUrl"];
+    const isTestnet = base.includes("api-dev") || base.includes("testnet") || base.includes("dev") || base.includes("acp-dev");
+    return isTestnet ? "https://api-dev.virtuals.io/acp" : "https://api.virtuals.io/acp";
+  }
+
   async evaluateDeveloperCampaign(
     githubLogin: string,
     githubToken?: string
   ): Promise<any> {
-    const headers = githubToken ? { "x-github-token": githubToken } : {};
-    return this.client.post<any>(
-      "/developer-campaign/github/evaluate",
-      { githubLogin }
-    );
+    const baseUrl = this.getCampaignBaseUrl();
+    const url = new URL("/developer-campaign/github/evaluate", baseUrl);
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      ...this.client["authHeaders"](),
+    };
+    if (githubToken) {
+      headers["x-github-token"] = githubToken;
+    }
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ githubLogin }),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    return res.json();
   }
 
   async linkDeveloperCampaignGithub(
@@ -1068,8 +1085,8 @@ export class AgentApi {
     githubToken: string,
     repositoryName?: string
   ): Promise<any> {
-    // Custom post because of headers override
-    const url = new URL(`/developer-campaign/agents/${agentId}/github-link`, this.client["baseUrl"]);
+    const baseUrl = this.getCampaignBaseUrl();
+    const url = new URL(`/developer-campaign/agents/${agentId}/github-link`, baseUrl);
     const res = await fetch(url.toString(), {
       method: "POST",
       headers: {
@@ -1080,6 +1097,7 @@ export class AgentApi {
       body: JSON.stringify({ githubLogin, repositoryName }),
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    if (res.status === 204) return { status: "success" };
     return res.json();
   }
 
@@ -1089,7 +1107,8 @@ export class AgentApi {
     githubToken: string,
     repositoryName?: string
   ): Promise<any> {
-    const url = new URL("/developer-campaign/enroll", this.client["baseUrl"]);
+    const baseUrl = this.getCampaignBaseUrl();
+    const url = new URL("/developer-campaign/enroll", baseUrl);
     const res = await fetch(url.toString(), {
       method: "POST",
       headers: {
@@ -1100,6 +1119,7 @@ export class AgentApi {
       body: JSON.stringify({ agentId, githubLogin, repositoryName }),
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    if (res.status === 204) return { status: "success" };
     return res.json();
   }
 
@@ -1291,10 +1311,19 @@ export class AgentApi {
   async getLinkedInVerifyUrl(
     agentId: string
   ): Promise<{ verifyUrl: string; requestId: string }> {
-    const res = await this.client.get<{
-      data: { verifyUrl: string; requestId: string };
-    }>(`/developer-campaign/agents/${agentId}/linkedin-verify-url`);
-    return res.data;
+    const baseUrl = this.getCampaignBaseUrl();
+    const url = new URL(`/developer-campaign/agents/${agentId}/linkedin-verify-url`, baseUrl);
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.client["authHeaders"](),
+      },
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    if (res.status === 204) return { verifyUrl: "", requestId: "" };
+    const body = await res.json();
+    return body.data;
   }
 
   /**
@@ -1304,12 +1333,20 @@ export class AgentApi {
     agentId: string,
     requestId: string
   ): Promise<{ verified: boolean; url?: string }> {
-    const res = await this.client.get<{
-      data: { verified: boolean; url?: string };
-    }>(`/developer-campaign/agents/${agentId}/linkedin-status`, {
-      requestId,
+    const baseUrl = this.getCampaignBaseUrl();
+    const url = new URL(`/developer-campaign/agents/${agentId}/linkedin-status`, baseUrl);
+    url.searchParams.set("requestId", requestId);
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.client["authHeaders"](),
+      },
     });
-    return res.data;
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    if (res.status === 204) return { verified: true };
+    const body = await res.json();
+    return body.data;
   }
 }
 

From 1dc48ad8cbb78f63d417361729769b5279a7abbb Mon Sep 17 00:00:00 2001
From: Ang Weoy Yang <weoyyang00@gmail.com>
Date: Thu, 4 Jun 2026 16:12:43 +0800
Subject: [PATCH 09/10] feat: replace privy linkedin auth with validated
 profile-url input in compute apply

The privy-backed linkedin-verify-url endpoint returns 204 (no URL), so the
verify flow printed a blank link and hung for 3 minutes before falling back.
Drop the auth/polling flow entirely: the [4/6] step now prompts for a LinkedIn
profile URL, validates it (linkedin.com/in/<slug>, re-prompts on invalid, 'q'
to cancel), and passes it straight to enrollment. The --linkedin flag is also
validated for non-interactive use.

- add isValidLinkedInProfileUrl to validation.ts
- remove dead getLinkedInVerifyUrl/checkLinkedInStatus from AgentApi
- drop now-unused openBrowser import from compute.ts

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/commands/compute.ts | 67 +++++++++++++++++++----------------------
 src/lib/api/agent.ts    | 44 ---------------------------
 src/lib/validation.ts   | 19 ++++++++++++
 3 files changed, 50 insertions(+), 80 deletions(-)

diff --git a/src/commands/compute.ts b/src/commands/compute.ts
index f09d1d8..1af85e1 100644
--- a/src/commands/compute.ts
+++ b/src/commands/compute.ts
@@ -11,7 +11,7 @@ import { getActiveAgentId } from "../lib/activeAgent";
 import { createProviderAdapter, getWalletAddress } from "../lib/agentFactory";
 import { formatChainId, formatChainIds } from "../lib/chains";
 import { CliError } from "../lib/errors";
-import { openBrowser } from "../lib/browser";
+import { isValidLinkedInProfileUrl } from "../lib/validation";
 
 // ── Registration ────────────────────────────────────────────────────
 
@@ -232,43 +232,30 @@ export function registerComputeCommands(program: Command): void {
           name = await askQuestion("  [1/6] Full Name", name);
           email = await askQuestion("  [2/6] Developer Email", email);
           github = await askQuestion("  [3/6] GitHub Username", github);
-          console.log(`\n  [4/6] ${c.bold("LinkedIn Authentication (Security Verification)")}`);
-          console.log(`        To protect credit pools, we use cryptographically verified LinkedIn profiles.`);
-          
-          try {
-            const { verifyUrl, requestId } = await agentApi.getLinkedInVerifyUrl(agentId);
-            
-            console.log(`\n  ${c.cyan("👉 Please authenticate and authorize at this link:")}`);
-            console.log(`     ${c.underline(verifyUrl)}\n`);
-            
-            // Open default system browser dynamically
-            openBrowser(verifyUrl);
-            
-            console.log(`  ${c.yellow("⌛ Waiting for LinkedIn verification... (3-minute timeout)")}`);
-            
-            let verifiedUrl: string | undefined;
-            const timeout = 180000; // 3 minutes
-            const startTime = Date.now();
-            
-            while (Date.now() - startTime < timeout) {
-              const status = await agentApi.checkLinkedInStatus(agentId, requestId);
-              if (status.verified && status.url) {
-                verifiedUrl = status.url;
-                break;
-              }
-              await new Promise((r) => setTimeout(r, 4000)); // Poll every 4 seconds
+          console.log(`\n  [4/6] ${c.bold("LinkedIn Profile")}`);
+          // LinkedIn Privy auth was removed; take a profile URL directly and validate its format.
+          while (true) {
+            const answer = await askQuestion(
+              "        Profile URL (https://www.linkedin.com/in/… — 'q' to cancel)",
+              linkedin
+            );
+            const normalized = answer.toLowerCase();
+            if (
+              normalized === "q" ||
+              normalized === "quit" ||
+              normalized === "cancel" ||
+              normalized === "skip"
+            ) {
+              console.log(`\n${c.dim("Application cancelled.")}`);
+              return;
             }
-            
-            if (!verifiedUrl) {
-              throw new Error("Verification timed out or was cancelled by user.");
+            if (isValidLinkedInProfileUrl(answer)) {
+              linkedin = answer;
+              break;
             }
-            
-            linkedin = verifiedUrl;
-            console.log(`  ✅ ${c.green("Successfully Verified LinkedIn!")} Profile: ${linkedin}`);
-            
-          } catch (err: any) {
-            console.log(`  ❌ ${c.red(`LinkedIn Auth Fallback: ${err.message}`)}`);
-            linkedin = await askQuestion("     Enter LinkedIn Profile URL (Manual Entry Fallback)", linkedin);
+            console.log(
+              `  ${c.red("✗ Not a valid LinkedIn profile URL.")} ${c.dim("Expected e.g. https://www.linkedin.com/in/your-handle")}`
+            );
           }
           referral = await askQuestion("  [5/6] Referral Code (Optional)", referral);
           motivation = await askQuestion("  [6/6] Motivation (What will you build? / Optional)", motivation);
@@ -290,6 +277,14 @@ export function registerComputeCommands(program: Command): void {
           );
         }
 
+        if (!isValidLinkedInProfileUrl(linkedin)) {
+          throw new CliError(
+            "Invalid LinkedIn URL",
+            "VALIDATION_ERROR",
+            "Provide a valid LinkedIn profile URL like https://www.linkedin.com/in/your-handle."
+          );
+        }
+
         if (!githubToken && tty) {
           console.log(`\n⚠️  ${c.yellow("No active GitHub token detected.")}`);
           console.log(`   Please run ${c.bold("gh auth login")} or set the ${c.bold("GITHUB_TOKEN")} environment variable.`);
diff --git a/src/lib/api/agent.ts b/src/lib/api/agent.ts
index 1a5d492..930fddf 100644
--- a/src/lib/api/agent.ts
+++ b/src/lib/api/agent.ts
@@ -1304,50 +1304,6 @@ export class AgentApi {
       return null;
     }
   }
-
-  /**
-   * Generates a temporary Privy authorization URL for the developer to authenticate their LinkedIn.
-   */
-  async getLinkedInVerifyUrl(
-    agentId: string
-  ): Promise<{ verifyUrl: string; requestId: string }> {
-    const baseUrl = this.getCampaignBaseUrl();
-    const url = new URL(`/developer-campaign/agents/${agentId}/linkedin-verify-url`, baseUrl);
-    const res = await fetch(url.toString(), {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.client["authHeaders"](),
-      },
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
-    if (res.status === 204) return { verifyUrl: "", requestId: "" };
-    const body = await res.json();
-    return body.data;
-  }
-
-  /**
-   * Polls the API to check if the developer has completed the LinkedIn handshake.
-   */
-  async checkLinkedInStatus(
-    agentId: string,
-    requestId: string
-  ): Promise<{ verified: boolean; url?: string }> {
-    const baseUrl = this.getCampaignBaseUrl();
-    const url = new URL(`/developer-campaign/agents/${agentId}/linkedin-status`, baseUrl);
-    url.searchParams.set("requestId", requestId);
-    const res = await fetch(url.toString(), {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.client["authHeaders"](),
-      },
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
-    if (res.status === 204) return { verified: true };
-    const body = await res.json();
-    return body.data;
-  }
 }
 
 export interface PrepareLaunchResponse {
diff --git a/src/lib/validation.ts b/src/lib/validation.ts
index ad5533e..a0c31a9 100644
--- a/src/lib/validation.ts
+++ b/src/lib/validation.ts
@@ -20,3 +20,22 @@ export function validateJsonSchema(input: string): Record<string, unknown> {
   }
   return parsed;
 }
+
+/**
+ * Returns true if `input` is an http(s) LinkedIn personal-profile URL of the
+ * form `linkedin.com/in/<slug>` (country subdomains like `sg.linkedin.com`,
+ * optional `www.`, and a trailing slash are allowed; query/hash are ignored).
+ * Company pages, the bare domain, and non-LinkedIn URLs are rejected.
+ */
+export function isValidLinkedInProfileUrl(input: string): boolean {
+  let url: URL;
+  try {
+    url = new URL(input.trim());
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  const host = url.hostname.toLowerCase();
+  if (host !== "linkedin.com" && !host.endsWith(".linkedin.com")) return false;
+  return /^\/in\/[^/\s]+\/?$/.test(url.pathname);
+}

From 31a4e4399f16224eabf76670b08f65616b71c52b Mon Sep 17 00:00:00 2001
From: Ang Weoy Yang <weoyyang00@gmail.com>
Date: Fri, 5 Jun 2026 16:15:40 +0800
Subject: [PATCH 10/10] feat: compute apply deep-links to the
 developer-campaign GitHub page (?action=link-github)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Open app.virtuals.io/acp/agents/<id>?tab=compute&action=link-github so the dev
connects GitHub + claims on the web app — which now auto-fires GitHub linking
from the action param — instead of the CLI's interactive form. The campaign
backend (clawd) needs a Privy session the CLI can't produce, so we hand off to
the web app. --json returns {status:"redirect", url, agentId}.

- remove now-dead campaign code: isValidLinkedInProfileUrl + the
  link/enroll/evaluate developer-campaign POSTs (CLI can't auth to clawd)
- gitignore docs/superpowers/ planning artifacts

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .gitignore              |   1 +
 SKILL.md                |   2 +-
 src/commands/compute.ts | 187 ++++++++--------------------------------
 src/lib/api/agent.ts    |  75 ++--------------
 src/lib/validation.ts   |  19 ----
 5 files changed, 48 insertions(+), 236 deletions(-)

diff --git a/.gitignore b/.gitignore
index 1b557ee..8132279 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ acp-cli-signer/acp-cli-signer
 # Superpowers/Hermes Agent artifacts
 .hermes/
 docs/plans/
+docs/superpowers/
diff --git a/SKILL.md b/SKILL.md
index eaea723..600a606 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -155,7 +155,7 @@ Pay for the agent's own LLM-inference workloads from a USDC-funded compute accou
 |---|---|---|
 | `acp compute status --json` | Show the compute account balance, usage, and limit | `{limit, limitRemaining, usage, ...}` |
 | `acp compute top-up --amount <usdc 1–1000> [--chain-id <id>] --json` | Transfer USDC (+ a processing fee) from the agent's wallet to the ACP fee wallet to credit the compute account | `{amount, totalAmount, chainId, feeWallet, txnHash}` |
-| `acp compute apply [--github <username>] [--email <email>] [--name <name>] [--linkedin <url>] [--referral <referral_code>] [--motivation <text>]` | Apply for Venice developer compute credits ($200 approved) | `{success, recommendation, score, reasoning, ...}` |
+| `acp compute apply` | Opens the agent's web compute page (`app.virtuals.io/acp/agents/<id>?tab=compute&action=link-github`) where the developer connects GitHub (Privy OAuth) and claims the credit — the CLI can't auth to the campaign backend | `--json` returns `{status:"redirect", url, agentId}` |
 
 The credited balance updates shortly after the transfer confirms — re-probe with `compute status`.
 
diff --git a/src/commands/compute.ts b/src/commands/compute.ts
index 1af85e1..bfd3f22 100644
--- a/src/commands/compute.ts
+++ b/src/commands/compute.ts
@@ -1,6 +1,4 @@
 import type { Command } from "commander";
-import { execSync } from "child_process";
-import * as readline from "readline";
 import { encodeFunctionData, erc20Abi, isAddress, parseUnits } from "viem";
 import { USDC_ADDRESSES, USDC_DECIMALS } from "@virtuals-protocol/acp-node-v2";
 import { isJson, outputResult, outputError, isTTY } from "../lib/output";
@@ -11,7 +9,7 @@ import { getActiveAgentId } from "../lib/activeAgent";
 import { createProviderAdapter, getWalletAddress } from "../lib/agentFactory";
 import { formatChainId, formatChainIds } from "../lib/chains";
 import { CliError } from "../lib/errors";
-import { isValidLinkedInProfileUrl } from "../lib/validation";
+import { openBrowser } from "../lib/browser";
 
 // ── Registration ────────────────────────────────────────────────────
 
@@ -164,168 +162,57 @@ export function registerComputeCommands(program: Command): void {
       }
     });
 
-  // Helper functions for apply
-  function execCommand(cmd: string): string {
-    try {
-      return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-    } catch {
-      return "";
-    }
-  }
-
-  function askQuestion(query: string, defaultValue: string): Promise<string> {
-    const displayQuery = defaultValue ? `${query} [${defaultValue}]: ` : `${query}: `;
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    return new Promise((resolve) => {
-      rl.question(displayQuery, (ans) => {
-        rl.close();
-        resolve(ans.trim() || defaultValue);
-      });
-    });
-  }
-
   compute
     .command("apply")
     .description("Apply for Venice developer compute credits ($200 approved)")
-    .option("--github <handle>", "GitHub handle (auto-harvested if omitted)")
-    .option("--email <email>", "Developer Email address (auto-harvested if omitted)")
-    .option("--name <name>", "Full Name (auto-harvested if omitted)")
-    .option("--linkedin <url>", "LinkedIn Profile URL")
-    .option("--referral <code-or-referral>", "Referral code (Optional)")
-    .option("--motivation <text>", "What will you build? (Optional)")
-    .action(async (opts, cmd) => {
+    .action(async (_opts, cmd) => {
       const json = isJson(cmd);
-      const tty = isTTY() && !json;
-
       try {
         const { agentApi } = await getClient();
         const agentId = getActiveAgentId(json);
         if (!agentId) return;
 
-        // Auto-harvest
-        const harvestedName = opts.name || execCommand("git config --global user.name") || "Developer";
-        const harvestedEmail = opts.email || execCommand("git config --global user.email") || "";
-        let harvestedGithub = opts.github || execCommand("git config --global github.user") || execCommand("git config --global credential.username");
-        if (!harvestedGithub) {
-          try {
-            harvestedGithub = execCommand("gh api user -q .login");
-          } catch {}
-        }
-
-        // Get GitHub token
-        const githubToken = process.env.GITHUB_TOKEN || execCommand("gh auth token");
-
-        let name = harvestedName;
-        let email = harvestedEmail;
-        let github = harvestedGithub;
-        let linkedin = opts.linkedin || "";
-        let referral = opts.referral || "";
-        let motivation = opts.motivation || "";
-
-        if (tty) {
-          console.log(`\n🚀 ${c.cyan("Venice-Virtuals Developer Inference Credit Campaign ($200 approved)")}`);
-          console.log(`${c.dim("----------------------------------------------------------------------")}`);
-          
-          name = await askQuestion("  [1/6] Full Name", name);
-          email = await askQuestion("  [2/6] Developer Email", email);
-          github = await askQuestion("  [3/6] GitHub Username", github);
-          console.log(`\n  [4/6] ${c.bold("LinkedIn Profile")}`);
-          // LinkedIn Privy auth was removed; take a profile URL directly and validate its format.
-          while (true) {
-            const answer = await askQuestion(
-              "        Profile URL (https://www.linkedin.com/in/… — 'q' to cancel)",
-              linkedin
-            );
-            const normalized = answer.toLowerCase();
-            if (
-              normalized === "q" ||
-              normalized === "quit" ||
-              normalized === "cancel" ||
-              normalized === "skip"
-            ) {
-              console.log(`\n${c.dim("Application cancelled.")}`);
-              return;
-            }
-            if (isValidLinkedInProfileUrl(answer)) {
-              linkedin = answer;
-              break;
-            }
-            console.log(
-              `  ${c.red("✗ Not a valid LinkedIn profile URL.")} ${c.dim("Expected e.g. https://www.linkedin.com/in/your-handle")}`
-            );
-          }
-          referral = await askQuestion("  [5/6] Referral Code (Optional)", referral);
-          motivation = await askQuestion("  [6/6] Motivation (What will you build? / Optional)", motivation);
-        }
+        // GitHub linking + enrollment for this campaign run on the web app's
+        // Privy-authenticated session, which the CLI can't reproduce. So the CLI
+        // just sends the user to the agent's compute page, where the GitHub-linking
+        // UI lives, and they complete the connect + claim there.
+        const webUrl = agentApi.getDeveloperCampaignWebUrl(agentId);
 
-        if (!github) {
-          throw new CliError(
-            "Missing GitHub Handle",
-            "VALIDATION_ERROR",
-            "Please provide a GitHub handle using --github or configure your Git globally."
-          );
+        if (json) {
+          outputResult(json, { status: "redirect", url: webUrl, agentId });
+          return;
         }
 
-        if (!linkedin) {
-          throw new CliError(
-            "Missing LinkedIn URL",
-            "VALIDATION_ERROR",
-            "Please provide a LinkedIn profile URL using --linkedin."
+        console.log(
+          `\n🚀 ${c.cyan(
+            "Venice-Virtuals Developer Inference Credit Campaign ($200 approved)"
+          )}`
+        );
+        console.log(
+          `${c.dim(
+            "----------------------------------------------------------------------"
+          )}`
+        );
+        console.log(`\nApply by connecting your GitHub on this agent's compute page:`);
+        console.log(`\n  ${c.underline(webUrl)}\n`);
+        console.log(`  ${c.dim("1.")} Log in if prompted`);
+        console.log(`  ${c.dim("2.")} Connect GitHub — verifies your eligible repositories`);
+        console.log(`  ${c.dim("3.")} Claim your $200 weekly compute credit`);
+
+        if (isTTY()) {
+          openBrowser(webUrl);
+          console.log(
+            `\nℹ️  ${c.dim("Opened in your browser. Run")} ${c.bold(
+              "acp compute status"
+            )} ${c.dim("afterward to see your credit.")}`
           );
-        }
-
-        if (!isValidLinkedInProfileUrl(linkedin)) {
-          throw new CliError(
-            "Invalid LinkedIn URL",
-            "VALIDATION_ERROR",
-            "Provide a valid LinkedIn profile URL like https://www.linkedin.com/in/your-handle."
+        } else {
+          console.log(
+            `\nℹ️  ${c.dim("Open the link above, then run")} ${c.bold(
+              "acp compute status"
+            )} ${c.dim("to see your credit.")}`
           );
         }
-
-        if (!githubToken && tty) {
-          console.log(`\n⚠️  ${c.yellow("No active GitHub token detected.")}`);
-          console.log(`   Please run ${c.bold("gh auth login")} or set the ${c.bold("GITHUB_TOKEN")} environment variable.`);
-          console.log(`   We will attempt a public linking, but authenticated claims are recommended.\n`);
-        }
-
-        if (tty) {
-          console.log(`\n⌛ ${c.dim("Submitting your application to the Venice-Virtuals Audit Engine...")}`);
-        }
-
-        // First we link GitHub
-        await agentApi.linkDeveloperCampaignGithub(agentId, github, githubToken, undefined);
-        
-        // Then we enroll
-        const enrollRes = await agentApi.enrollDeveloperCampaign(agentId, github, githubToken, undefined);
-
-        if (json) {
-          outputResult(json, {
-            status: "success",
-            github,
-            email,
-            enrollment: enrollRes,
-          });
-          return;
-        }
-
-        console.log(`\n${c.green("✅ Application Submitted & Processed Successfully!")}`);
-        console.log(`\n${c.bold("📊 Venice-Virtuals Credit Claim Summary:")}`);
-        printTable([
-          ["Candidate Name", name],
-          ["Developer Email", email],
-          ["GitHub Handle", `@${github}`],
-          ["LinkedIn Profile", linkedin],
-          ["Referral Code", referral || "None"],
-          ["Evaluation Status", c.green(enrollRes?.status || "active")],
-          ["Weekly Credit Grant", `$${enrollRes?.weeklyCreditUsd || "200"}.00`],
-        ]);
-
-        console.log(`\nℹ️  ${c.dim("Your Venice compute credit has been fully linked and provisioned.")}`);
-        console.log(`   Open ${c.bold("app.virtuals.io")} on your browser to see your updated Compute Dashboard!`);
-
       } catch (err) {
         outputError(json, err instanceof Error ? err : String(err));
       }
diff --git a/src/lib/api/agent.ts b/src/lib/api/agent.ts
index 930fddf..6a3b6cc 100644
--- a/src/lib/api/agent.ts
+++ b/src/lib/api/agent.ts
@@ -1051,76 +1051,19 @@ export class AgentApi {
 
   // ── Developer campaign methods ───────────────────────────────────
 
-  private getCampaignBaseUrl(): string {
+  private getWebBaseUrl(): string {
     const base = this.client["baseUrl"];
     const isTestnet = base.includes("api-dev") || base.includes("testnet") || base.includes("dev") || base.includes("acp-dev");
-    return isTestnet ? "https://api-dev.virtuals.io/acp" : "https://api.virtuals.io/acp";
+    return isTestnet ? "https://app-dev.virtuals.io" : "https://app.virtuals.io";
   }
 
-  async evaluateDeveloperCampaign(
-    githubLogin: string,
-    githubToken?: string
-  ): Promise<any> {
-    const baseUrl = this.getCampaignBaseUrl();
-    const url = new URL("/developer-campaign/github/evaluate", baseUrl);
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      ...this.client["authHeaders"](),
-    };
-    if (githubToken) {
-      headers["x-github-token"] = githubToken;
-    }
-    const res = await fetch(url.toString(), {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ githubLogin }),
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
-    return res.json();
-  }
-
-  async linkDeveloperCampaignGithub(
-    agentId: string,
-    githubLogin: string,
-    githubToken: string,
-    repositoryName?: string
-  ): Promise<any> {
-    const baseUrl = this.getCampaignBaseUrl();
-    const url = new URL(`/developer-campaign/agents/${agentId}/github-link`, baseUrl);
-    const res = await fetch(url.toString(), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.client["authHeaders"](),
-        "x-github-token": githubToken,
-      },
-      body: JSON.stringify({ githubLogin, repositoryName }),
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
-    if (res.status === 204) return { status: "success" };
-    return res.json();
-  }
-
-  async enrollDeveloperCampaign(
-    agentId: string,
-    githubLogin: string,
-    githubToken: string,
-    repositoryName?: string
-  ): Promise<any> {
-    const baseUrl = this.getCampaignBaseUrl();
-    const url = new URL("/developer-campaign/enroll", baseUrl);
-    const res = await fetch(url.toString(), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.client["authHeaders"](),
-        "x-github-token": githubToken,
-      },
-      body: JSON.stringify({ agentId, githubLogin, repositoryName }),
-    });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
-    if (res.status === 204) return { status: "success" };
-    return res.json();
+  /**
+   * Web URL of an agent's compute / developer-campaign page, where the user can
+   * connect GitHub via the app's Privy OAuth flow (used as the headless-CLI
+   * fallback when no local GitHub token is available).
+   */
+  getDeveloperCampaignWebUrl(agentId: string): string {
+    return `${this.getWebBaseUrl()}/acp/agents/${agentId}?tab=compute&action=link-github`;
   }
 
   async getAgentAssets(
diff --git a/src/lib/validation.ts b/src/lib/validation.ts
index a0c31a9..ad5533e 100644
--- a/src/lib/validation.ts
+++ b/src/lib/validation.ts
@@ -20,22 +20,3 @@ export function validateJsonSchema(input: string): Record<string, unknown> {
   }
   return parsed;
 }
-
-/**
- * Returns true if `input` is an http(s) LinkedIn personal-profile URL of the
- * form `linkedin.com/in/<slug>` (country subdomains like `sg.linkedin.com`,
- * optional `www.`, and a trailing slash are allowed; query/hash are ignored).
- * Company pages, the bare domain, and non-LinkedIn URLs are rejected.
- */
-export function isValidLinkedInProfileUrl(input: string): boolean {
-  let url: URL;
-  try {
-    url = new URL(input.trim());
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-  const host = url.hostname.toLowerCase();
-  if (host !== "linkedin.com" && !host.endsWith(".linkedin.com")) return false;
-  return /^\/in\/[^/\s]+\/?$/.test(url.pathname);
-}