@jumboo/create-agent 0.1.0 → 0.1.1

package/README.md

@@ -14,7 +14,11 @@ It asks a few questions, then:
 - fills in the **network RPC, oracle URL, and Jumboo contract addresses**
 - scaffolds a working `POST /solve` backend built on
   [`@jumboo/agent-sdk`](https://www.npmjs.com/package/@jumboo/agent-sdk)
-- includes `npm run register` to mint the agent NFT on-chain
+
+You **register the agent in the Jumboo frontend** ([jumboo.xyz](https://jumboo.xyz)
+→ Create Agent) using the generated hot wallet — the frontend also drives
+Compete/Hire, which signs with your wallet, checks you own the agent, and calls
+your backend's `/solve`. This scaffold is just that backend.
 
 ## Prompts
 
@@ -23,9 +27,7 @@ It asks a few questions, then:
 | Project directory | `my-jumboo-agent` | also the package name |
 | Network | `sepolia` | `sepolia` (live Jumboo) or `localhost` |
 | Solver | `echo` | `echo` (test), `claude` / `codex` / `opencode` / `antigravity` (AI agents), or `custom` (write your own in src/solver.js) |
-| Skills | `javascript, bugfix` | written into the agent metadata |
 | Hire price (USDC) | `0.50` | quoted to task creators via x402 |
-| Public backend URL | — | where `/solve` will be hosted |
 
 ## What you get
 
@@ -42,8 +44,6 @@ my-agent/
     github.js          clone / issue / fork / PR helpers
     solver.js          pluggable drivers: echo, claude/codex/opencode/antigravity, custom
     job.js             clone → solve → PR → claim pipeline (uses the SDK)
-  scripts/
-    register.js        mint the agent NFT (npm run register)
 ```
 
 ## After scaffolding
@@ -51,11 +51,13 @@ my-agent/
 ```bash
 cd my-agent
 npm install
-# set OPERATOR_KEY in .env, fund it, then:
-npm run register       # prints AGENT_ID — copy it into .env
-npm start              # DRY_RUN=1 by default
+npm start              # boots now with echo + DRY_RUN; GET /health works
 ```
 
+To compete for real: register the agent at [jumboo.xyz](https://jumboo.xyz) with
+the generated hot wallet, paste the `AGENT_ID` into `.env`, pick a real `SOLVER`,
+fund the hot wallet, and set `DRY_RUN=0`.
+
 ## License
 
 MIT

package/bin/index.js

@@ -7,8 +7,7 @@
  *
  * Interactive in a terminal; also fully scriptable with flags + --yes:
  *   npx @jumboo/create-agent my-agent --yes \
- *     --network sepolia --solver echo --skills "javascript,bugfix" \
- *     --price 0.50 --backend https://my-agent.example.com
+ *     --network sepolia --solver echo --price 0.50
  *
  * Asks a few questions, generates a fresh hot wallet, fills in the network +
  * contract addresses, and writes a working /solve backend that uses
@@ -97,11 +96,9 @@ async function main() {
       solver = "echo";
     }
 
-    const skills = await resolve(args.skills, "Skills (comma-separated):", "javascript, bugfix");
     const hirePrice = await resolve(args.price, "Hire price in USDC (x402):", "0.50");
-    const backendUrl = await resolve(args.backend, "Public backend URL (where /solve will be hosted):", "https://your-agent.example.com");
 
-    // -- Generate a fresh hot wallet ---------------------------------------
+    // -- Generate a fresh master mnemonic (index-0 address = its fingerprint) --
     const wallet = ethers.Wallet.createRandom();
 
     // -- Scaffold the project ----------------------------------------------
@@ -110,22 +107,18 @@ async function main() {
     await copyTemplate(TEMPLATE_DIR, targetDir, { __PROJECT_NAME__: projectName });
 
     // -- Write the generated .env (never a template — it holds the key) -----
-    const skillsJson = JSON.stringify(skills.split(",").map((s) => s.trim()).filter(Boolean));
     const env = [
       `# ${projectName} — generated by @jumboo/create-agent. Never commit this file.`,
       "",
       "PORT=8917",
       `RPC_URL=${network.rpcUrl}`,
       "",
-      "# This agent's on-chain NFT id. Filled in by `npm run register`.",
-      "AGENT_ID=",
-      "",
-      "# Freshly generated hot wallet — signs task markers. Keep it secret.",
-      `AGENT_HOT_KEY=${wallet.privateKey}`,
-      "# Wallet that pays gas for the claim tx (defaults to the hot key).",
+      "# Freshly generated master mnemonic — ONE phrase runs ALL your agents.",
+      "# Each agent's hot wallet is HD-derived from it. Keep it secret.",
+      `AGENT_MASTER_MNEMONIC=${wallet.mnemonic.phrase}`,
+      "# Optional funded wallet that pays claim gas for every agent (else each",
+      "# agent's own derived hot wallet pays):",
       "AGENT_TX_KEY=",
-      "# Operator wallet that OWNS the agent NFT + runs `npm run register` (fund it first).",
-      "OPERATOR_KEY=",
       "",
       "# GitHub machine user (clone auth, issue fetch, fork, PR). Empty for DRY_RUN.",
       "GITHUB_TOKEN=",
@@ -149,11 +142,6 @@ async function main() {
             "# SOLVER_PROMPT_VIA=stdin   # stdin | arg",
           ]),
       "",
-      "# Agent identity metadata (used by `npm run register`).",
-      `AGENT_NAME=${projectName}`,
-      `AGENT_SKILLS=${skillsJson}`,
-      `BACKEND_URL=${backendUrl}`,
-      "",
       "# x402 hire price quoted to task creators.",
       `HIRE_PRICE_AMOUNT=${hirePrice}`,
       "HIRE_PRICE_ASSET=USDC",
@@ -170,9 +158,8 @@ async function main() {
     console.log(`
   ✓ Created ${projectName} (${network.label})
 
-  A fresh hot wallet was generated:
-    address: ${wallet.address}
-    (private key saved to .env — keep it secret, it is gitignored)
+  A fresh master mnemonic was generated (index-0 address ${wallet.address}).
+  Saved to .env — keep it secret (gitignored). All your agents derive from it.
 
   Get it running now:
     1. cd ${targetArg}
@@ -180,9 +167,10 @@ async function main() {
     3. npm start                       # echo solver + DRY_RUN — GET /health works
 
   To compete for real:
+    - register agents at https://jumboo.xyz (Create Agent) — the frontend derives
+      each agent's hot wallet from this master; this backend serves them all
     - pick a solver in .env (SOLVER=claude / codex / opencode / antigravity)
-    - set OPERATOR_KEY, fund it, then: npm run register   # writes AGENT_ID
-    - fund the hot wallet ${wallet.address} (claim gas), then set DRY_RUN=0
+    - fund the gas wallet, then set DRY_RUN=0
 
   Docs: https://docs.jumboo.xyz/#/build-a-jumboo-agent
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jumboo/create-agent",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Scaffold a ready-to-run Jumboo agent: npm create @jumboo/agent my-agent",
   "type": "module",
   "bin": {

package/templates/default/README.md

@@ -16,25 +16,29 @@ npm start
 
 That's it — open <http://localhost:8917/health> and the agent is running. Out of
 the box it uses the `echo` solver (no AI) with `DRY_RUN=1`, so the whole pipeline
-works with no keys and no registration. A fresh hot wallet was already generated
-into `.env`.
+works with no registration. A fresh **master mnemonic** was already generated
+into `.env` — every agent you register derives from it.
 
 ### Going live (to compete for real)
 
-1. Pick a real solver in `.env`: `SOLVER=claude` (or `codex` / `opencode` /
+1. **Register your agent(s)** at [jumboo.xyz](https://jumboo.xyz) → **Create
+   Agent**. Each agent's hot wallet is HD-derived from your `AGENT_MASTER_MNEMONIC`
+   (the frontend derives the address to register). This one backend then serves
+   **all** of them — nothing to paste per agent. Registration and the Compete/Hire
+   buttons all live in the frontend, which calls this backend's `/solve` with the
+   chosen `agentId`.
+2. Pick a real solver in `.env`: `SOLVER=claude` (or `codex` / `opencode` /
    `antigravity`) — that tool must be installed on the host.
-2. **Register the agent** (mints your NFT, prints `AGENT_ID`):
-   - Fund the OPERATOR wallet, set `OPERATOR_KEY` in `.env`, then `npm run register`.
-   - Copy the printed `AGENT_ID=...` into `.env`.
-3. Fund the hot wallet (shown at scaffold time) with a little ETH for claim gas.
+3. Fund the claim-gas wallet with a little ETH (`AGENT_TX_KEY`, or each agent's
+   own derived wallet).
 4. Set `DRY_RUN=0` and `npm start`.
 
 ## Endpoints
 
 | Method | Path | Description |
 |---|---|---|
-| `GET` | `/health` | Agent id, hot wallet, solver, job count |
-| `POST` | `/solve` | Body `{ "taskId": "0x<64 hex>" }` + auth headers → `202 { jobId }` |
+| `GET` | `/health` | Master fingerprint, solver, job count |
+| `POST` | `/solve` | Body `{ "taskId": "0x<64 hex>", "agentId": <n> }` + auth headers → `202 { jobId }` |
 | `GET` | `/jobs/:id` | Job status |
 
 `POST /solve` requires caller-auth headers (`X-Jumboo-Address`,

package/templates/default/_env.example

@@ -4,15 +4,14 @@
 PORT=8917
 RPC_URL=https://ethereum-sepolia-rpc.publicnode.com
 
-# This agent's on-chain NFT id (filled in by `npm run register`).
-AGENT_ID=
+# Master mnemonic — ONE phrase runs ALL your agents. Each agent's hot wallet is
+# HD-derived from it. Register agents in the Jumboo frontend using the derived
+# addresses; this backend then serves every one of them. Keep this secret.
+AGENT_MASTER_MNEMONIC=
 
-# The agent's registered hot wallet — signs task markers. Keep secret.
-AGENT_HOT_KEY=
-# Optional separate wallet that pays gas for the claim tx (defaults to hot key).
+# Optional funded wallet that pays claim gas for every agent. When blank, each
+# agent's own derived hot wallet pays (so fund those instead).
 AGENT_TX_KEY=
-# Operator wallet that owns the agent NFT + runs `npm run register`.
-OPERATOR_KEY=
 
 # GitHub machine user (clone auth, issue fetch, fork, PR). Empty for DRY_RUN.
 GITHUB_TOKEN=
@@ -30,7 +29,7 @@ WORKDIR=./workspace
 #   claude       Claude Code CLI          (needs `claude` installed + logged in)
 #   codex        OpenAI Codex CLI         (needs `codex`)
 #   opencode     opencode CLI             (needs `opencode`)
-#   antigravity  Antigravity CLI          (needs `antigravity`)
+#   antigravity  Antigravity CLI          (needs `agy`)
 #   custom       write your own driver — implement solve() in src/solver.js
 SOLVER=echo
 
@@ -40,11 +39,6 @@ SOLVER=echo
 # SOLVER_ARGS=-p --dangerously-skip-permissions
 # SOLVER_PROMPT_VIA=stdin   # "stdin" or "arg"
 
-# Agent identity metadata (used by `npm run register`).
-AGENT_NAME=__PROJECT_NAME__
-AGENT_SKILLS=["javascript","bugfix"]
-BACKEND_URL=https://your-agent.example.com
-
 # x402 hire price quoted to task creators.
 HIRE_PRICE_AMOUNT=0.50
 HIRE_PRICE_ASSET=USDC

package/templates/default/_package.json

@@ -6,11 +6,10 @@
   "type": "module",
   "scripts": {
     "start": "node src/index.js",
-    "dev": "node --watch src/index.js",
-    "register": "node scripts/register.js"
+    "dev": "node --watch src/index.js"
   },
   "dependencies": {
-    "@jumboo/agent-sdk": "^0.1.0",
+    "@jumboo/agent-sdk": "^0.2.0",
     "dotenv": "^16.4.5",
     "ethers": "^6.13.0",
     "express": "^4.19.2"

package/templates/default/src/auth.js

@@ -33,7 +33,7 @@ export function verifyCaller(req, taskId) {
 }
 
 /** The authoritative x402 payment requirements for one /solve attempt. */
-export function paymentRequirements({ taskId, operatorWallet }) {
+export function paymentRequirements({ taskId, agentId, operatorWallet }) {
   return {
     x402Version: 1,
     accepts: [
@@ -44,7 +44,7 @@ export function paymentRequirements({ taskId, operatorWallet }) {
         amount: config.hirePrice.amount,
         payTo: operatorWallet,
         resource: "/solve",
-        description: `Hire agent #${config.agentId} to attempt task ${taskId}`,
+        description: `Hire agent #${agentId} to attempt task ${taskId}`,
       },
     ],
   };
@@ -87,7 +87,7 @@ export function verifyPayment(req, requirements) {
  * The full access decision for POST /solve.
  * Returns { allow: true, path } or { allow: false, status, body }.
  */
-export function authorizeSolve({ req, caller, agent, task, taskId }) {
+export function authorizeSolve({ req, caller, agent, task, taskId, agentId }) {
   // 1. Operator triggers its own agent → free (Compete).
   if (caller.toLowerCase() === agent.operatorWallet.toLowerCase()) {
     return { allow: true, path: "compete" };
@@ -95,7 +95,7 @@ export function authorizeSolve({ req, caller, agent, task, taskId }) {
 
   // 2. Task creator hires this agent → x402 handshake (Hire).
   if (caller.toLowerCase() === task.creator.toLowerCase()) {
-    const requirements = paymentRequirements({ taskId, operatorWallet: agent.operatorWallet });
+    const requirements = paymentRequirements({ taskId, agentId, operatorWallet: agent.operatorWallet });
     const payment = verifyPayment(req, requirements);
     if (!payment.ok) {
       return {

package/templates/default/src/chain.js

@@ -1,14 +1,19 @@
 /**
- * On-chain reads: load a task and the agent identity. The protocol-critical
- * writes (signing the marker, claiming the escrow) live in @jumboo/agent-sdk.
+ * On-chain reads + deriving the right hot wallet for an agent.
+ *
+ * This backend runs MANY agents from one master mnemonic (config.masterMnemonic).
+ * Each agent's hot wallet is HD-derived from the master at the per-agent index
+ * stored in its ERC-8004 metadata (`hotWalletIndex`). The marker signing + escrow
+ * claim themselves live in @jumboo/agent-sdk.
  */
 import { ethers } from "ethers";
+import { deriveHotWallet } from "@jumboo/agent-sdk";
 import { config } from "./config.js";
 
 export const provider = new ethers.JsonRpcProvider(config.rpcUrl);
 
-/** The agent's registered hot wallet — signs taskIds for PR markers. */
-export const hotWallet = new ethers.Wallet(config.agentHotKey);
+/** Address of the master's index-0 wallet — a public fingerprint, not a key. */
+export const masterFingerprint = deriveHotWallet(config.masterMnemonic, 0).address;
 
 // TaskState enum in JumbooTaskRegistry.sol
 export const TaskState = {
@@ -35,8 +40,8 @@ export async function getTask(taskId) {
   return task;
 }
 
-/** Loads this backend's agent identity; returns null when not registered. */
-export async function getAgent(agentId = config.agentId) {
+/** Loads an agent's identity; returns null when it does not exist. */
+export async function getAgent(agentId) {
   try {
     const [operatorWallet, agentWallet, agentURI, active] = await identityRegistry.getAgent(agentId);
     return { operatorWallet, agentWallet, agentURI, active };
@@ -44,3 +49,36 @@ export async function getAgent(agentId = config.agentId) {
     return null;
   }
 }
+
+/** Read the per-agent hot-wallet index out of the ERC-8004 data-URI metadata. */
+function hotWalletIndexFromUri(agentURI) {
+  try {
+    const m = String(agentURI).match(/^data:application\/json;base64,(.+)$/);
+    if (!m) return null;
+    const json = JSON.parse(Buffer.from(m[1], "base64").toString("utf8"));
+    return Number.isInteger(json.hotWalletIndex) ? json.hotWalletIndex : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load an agent AND derive its hot wallet from our master mnemonic.
+ *
+ * Returns { agent, index, hotWallet, ownedByUs } or null when the agent does not
+ * exist. `ownedByUs` is true only when the derived wallet matches the agent's
+ * registered `agentWallet` — i.e. this agent was registered from OUR master, so
+ * we're allowed to sign for it. This is the trustless ownership check.
+ */
+export async function getAgentWithSigner(agentId) {
+  const agent = await getAgent(agentId);
+  if (!agent) return null;
+  const index = hotWalletIndexFromUri(agent.agentURI);
+  let hotWallet = null;
+  let ownedByUs = false;
+  if (index !== null) {
+    hotWallet = deriveHotWallet(config.masterMnemonic, index);
+    ownedByUs = hotWallet.address.toLowerCase() === agent.agentWallet.toLowerCase();
+  }
+  return { agent, index, hotWallet, ownedByUs };
+}

package/templates/default/src/config.js

@@ -29,26 +29,24 @@ function intEnv(name, fallback) {
   return n;
 }
 
-// Optional so `npm start` works right after scaffolding, before you register.
-// Defaults to "0" (unregistered): the server boots and /health responds; you
-// need a real id (from `npm run register`) before the agent can win a task.
-const agentId = process.env.AGENT_ID || "0";
-if (!/^\d+$/.test(agentId)) throw new Error(`AGENT_ID must be a non-negative integer, got: ${agentId}`);
-
 const solver = process.env.SOLVER || "echo";
 if (!SOLVERS.includes(solver)) {
   throw new Error(`SOLVER must be one of ${SOLVERS.join(" | ")}, got: ${solver}`);
 }
 
-const hotKey = required("AGENT_HOT_KEY", "the agent's registered hot wallet private key");
-if (!/^0x[0-9a-fA-F]{64}$/.test(hotKey)) throw new Error("AGENT_HOT_KEY must be a 0x-prefixed 32-byte hex private key");
+// One master mnemonic runs ALL of this operator's agents: each agent's hot
+// wallet is HD-derived from it (see chain.js + @jumboo/agent-sdk). You never
+// paste a wallet per agent — register more agents in the frontend and this
+// backend serves them automatically.
+const masterMnemonic = required("AGENT_MASTER_MNEMONIC", "the operator's 12/24-word HD master phrase");
 
 export const config = {
   port: intEnv("PORT", 8917),
   rpcUrl: required("RPC_URL"),
-  agentId,
-  agentHotKey: hotKey,
-  agentTxKey: process.env.AGENT_TX_KEY || hotKey,
+  masterMnemonic,
+  // Optional funded wallet that pays the claim gas for every agent. When blank,
+  // each agent's own derived hot wallet pays (so it must hold a little ETH).
+  agentTxKey: process.env.AGENT_TX_KEY || "",
   githubToken: process.env.GITHUB_TOKEN || "",
   githubUsername: process.env.GITHUB_USERNAME || "jumboo-agent",
   oracleUrl: required("ORACLE_URL", "e.g. https://oracle.jumboo.xyz").replace(/\/+$/, ""),

package/templates/default/src/index.js

@@ -1,13 +1,17 @@
 /**
  * __PROJECT_NAME__ — a Jumboo agent backend.
  *
- * Receives POST /solve, enforces the Compete/Hire (x402) access policy, then
- * runs the full pipeline: clone repo → solve issue → open PR with the Jumboo
- * marker block → poll the oracle → auto-claim the escrow (via @jumboo/agent-sdk).
+ * Receives POST /solve { taskId, agentId }, enforces the Compete/Hire (x402)
+ * access policy, derives the agent's hot wallet from this backend's master
+ * mnemonic, then runs the pipeline: clone repo → solve issue → open PR with the
+ * Jumboo marker → poll the oracle → auto-claim the escrow (via @jumboo/agent-sdk).
+ *
+ * One backend serves every agent registered from its master — the frontend says
+ * which agentId to compete as; nothing to configure per agent.
  */
 import express from "express";
 import { config } from "./config.js";
-import { hotWallet, getAgent, getTask, TaskState } from "./chain.js";
+import { getTask, TaskState, getAgentWithSigner, masterFingerprint } from "./chain.js";
 import { verifyCaller, authorizeSolve } from "./auth.js";
 import { startJob, getJob, jobView, jobCount } from "./job.js";
 
@@ -17,8 +21,8 @@ app.use(express.json());
 app.get("/health", (_req, res) => {
   res.json({
     ok: true,
-    agentId: config.agentId,
-    wallet: hotWallet.address,
+    mode: "master",
+    master: masterFingerprint, // address of derivation index 0 (identifies the master)
     solver: config.solver,
     dryRun: config.dryRun,
     jobs: jobCount(),
@@ -27,11 +31,17 @@ app.get("/health", (_req, res) => {
 
 app.post("/solve", async (req, res) => {
   try {
+    // -- Request shape ------------------------------------------------------
     const taskId = req.body?.taskId;
     if (!/^0x[0-9a-fA-F]{64}$/.test(taskId || "")) {
-      return res.status(400).json({ error: "body must be { taskId: '0x<64 hex>' }" });
+      return res.status(400).json({ error: "body must include taskId: '0x<64 hex>'" });
+    }
+    const agentId = req.body?.agentId;
+    if (!/^\d+$/.test(String(agentId ?? ""))) {
+      return res.status(400).json({ error: "body must include agentId (the agent to compete as)" });
     }
 
+    // -- Caller authentication (EIP-191 over `jumboo-solve:<taskId>`) --------
     const caller = verifyCaller(req, taskId);
     if (!caller) {
       return res.status(401).json({
@@ -41,14 +51,23 @@ app.post("/solve", async (req, res) => {
       });
     }
 
-    const agent = await getAgent(config.agentId);
-    if (!agent) {
-      return res.status(500).json({ error: `agent #${config.agentId} is not registered on-chain` });
+    // -- Resolve the agent + derive its hot wallet from our master ------------
+    const resolved = await getAgentWithSigner(agentId);
+    if (!resolved) {
+      return res.status(404).json({ error: `agent #${agentId} is not registered on-chain` });
     }
+    const { agent, hotWallet, ownedByUs } = resolved;
     if (!agent.active) {
-      return res.status(409).json({ error: `agent #${config.agentId} is inactive` });
+      return res.status(409).json({ error: `agent #${agentId} is inactive` });
+    }
+    if (!hotWallet) {
+      return res.status(409).json({ error: `agent #${agentId} has no hotWalletIndex in its metadata` });
+    }
+    if (!ownedByUs) {
+      return res.status(403).json({ error: `agent #${agentId} was not registered from this backend's master mnemonic` });
     }
 
+    // -- On-chain task preconditions ----------------------------------------
     const task = await getTask(taskId);
     if (!task) {
       return res.status(404).json({ error: "task not found on-chain" });
@@ -57,12 +76,14 @@ app.post("/solve", async (req, res) => {
       return res.status(409).json({ error: `task is not open (state=${task.state})` });
     }
 
-    const decision = authorizeSolve({ req, caller, agent, task, taskId });
+    // -- Access policy: operator = free, creator = x402, others = 403 --------
+    const decision = authorizeSolve({ req, caller, agent, task, taskId, agentId });
     if (!decision.allow) {
       return res.status(decision.status).json(decision.body);
     }
 
-    const job = startJob({ taskId, task, caller, path: decision.path });
+    // -- Accepted: queue the async pipeline for this agent -------------------
+    const job = startJob({ taskId, agentId, task, caller, path: decision.path, hotWallet });
     return res.status(202).json({ jobId: job.id, status: "queued" });
   } catch (err) {
     console.error(`[solve] ${err.stack || err.message}`);
@@ -78,8 +99,7 @@ app.get("/jobs/:id", (req, res) => {
 
 app.listen(config.port, () => {
   console.log(`__PROJECT_NAME__ listening on :${config.port}`);
-  console.log(`  agent id:   #${config.agentId}`);
-  console.log(`  hot wallet: ${hotWallet.address}`);
-  console.log(`  solver:     ${config.solver}${config.dryRun ? " (DRY_RUN)" : ""}`);
-  console.log(`  oracle:     ${config.oracleUrl}`);
+  console.log(`  master:   ${masterFingerprint} (derivation index 0)`);
+  console.log(`  solver:   ${config.solver}${config.dryRun ? " (DRY_RUN)" : ""}`);
+  console.log(`  oracle:   ${config.oracleUrl}`);
 });

package/templates/default/src/job.js

@@ -18,7 +18,7 @@ import path from "node:path";
 import { ethers } from "ethers";
 import { buildMarker, claim, OUTCOME_NAME } from "@jumboo/agent-sdk";
 import { config } from "./config.js";
-import { provider, hotWallet } from "./chain.js";
+import { provider } from "./chain.js";
 import { getSolver } from "./solver.js";
 import {
   parseRepoUrl,
@@ -71,6 +71,7 @@ export function jobView(job) {
   return {
     jobId: job.id,
     taskId: job.taskId,
+    agentId: job.agentId ?? null,
     path: job.path,
     caller: job.caller,
     solver: job.solver,
@@ -88,10 +89,12 @@ export function jobView(job) {
 }
 
 /** Registers a queued job and kicks off the async pipeline. */
-export function startJob({ taskId, task, caller, path: accessPath }) {
+export function startJob({ taskId, agentId, task, caller, path: accessPath, hotWallet }) {
   const job = {
     id: randomBytes(8).toString("hex"),
     taskId,
+    agentId,
+    hotWallet, // the agent's derived hot wallet (never serialized in jobView)
     task,
     caller,
     path: accessPath, // "compete" | "hire"
@@ -113,7 +116,7 @@ export function startJob({ taskId, task, caller, path: accessPath }) {
 }
 
 async function runJob(job) {
-  const { task, taskId } = job;
+  const { task, taskId, agentId, hotWallet } = job;
   const parsed = parseRepoUrl(task.repoUrl);
   const repoDir = path.join(config.workdir, job.id);
   const branch = `jumboo/task-${taskId.slice(2, 10)}`;
@@ -148,7 +151,7 @@ async function runJob(job) {
       [
         "-c", `user.name=${user}`,
         "-c", `user.email=${user}@users.noreply.github.com`,
-        "commit", "-m", `Jumboo task ${taskId.slice(0, 10)}… (agent #${config.agentId})`,
+        "commit", "-m", `Jumboo task ${taskId.slice(0, 10)}… (agent #${agentId})`,
       ],
       { cwd: repoDir }
     );
@@ -168,7 +171,7 @@ async function runJob(job) {
     }
 
     // 5. Build the marker block (SDK signs the RAW taskId bytes for us) ------
-    const { marker } = await buildMarker({ taskId, agentId: config.agentId, hotWallet });
+    const { marker } = await buildMarker({ taskId, agentId, hotWallet });
     job.markerBlock = marker;
 
     // 6. Open the PR (or log the markers in DRY_RUN) -------------------------
@@ -187,7 +190,7 @@ async function runJob(job) {
     }
     const base = await getDefaultBranch(parsed.owner, parsed.repo);
     const pr = await createPullRequest(parsed.owner, parsed.repo, {
-      title: `Jumboo task ${taskId.slice(0, 10)}… (agent #${config.agentId})`,
+      title: `Jumboo task ${taskId.slice(0, 10)}… (agent #${agentId})`,
       head: prHead,
       base,
       body: `${(job.summary || "").trim()}\n\n---\n${marker}`,
@@ -198,12 +201,16 @@ async function runJob(job) {
     // 7. Wait for the oracle's attestation, then claim on-chain (SDK) --------
     step = "awaiting-merge";
     setStatus(job, "awaiting-merge", `polling ${config.oracleUrl} every ${config.attestationPollSec}s`);
-    const txWallet = new ethers.Wallet(config.agentTxKey, provider); // pays claim gas
+    // Gas payer: a shared funded wallet if AGENT_TX_KEY is set, else this agent's
+    // own derived hot wallet (which then needs a little ETH).
+    const txWallet = config.agentTxKey
+      ? new ethers.Wallet(config.agentTxKey, provider)
+      : hotWallet.connect(provider);
     const { attestation, receipt } = await claim({
       oracleUrl: config.oracleUrl,
       registryAddress: config.validationRegistryAddress,
       taskId,
-      agentId: config.agentId,
+      agentId,
       wallet: txWallet,
       intervalMs: config.attestationPollSec * 1000,
       onPoll: ({ error }) => {

package/templates/default/scripts/register.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-/**
- * Register this agent on-chain: mint the JumbooIdentityRegistry NFT to the
- * OPERATOR wallet, with the hot wallet as the registered signer.
- *
- *   npm run register
- *
- * Reads .env directly (it must run BEFORE AGENT_ID exists, so it does not use
- * src/config.js, which requires AGENT_ID). On success it prints the new agentId
- * and reminds you to write it into .env.
- */
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { config as loadEnv } from "dotenv";
-import { ethers } from "ethers";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-loadEnv({ path: path.join(__dirname, "..", ".env") });
-
-function required(name) {
-  const v = process.env[name];
-  if (!v) throw new Error(`Missing ${name} in .env`);
-  return v;
-}
-
-const rpcUrl = required("RPC_URL");
-const identityRegistry = required("IDENTITY_REGISTRY_ADDRESS");
-const operatorKey = required("OPERATOR_KEY"); // owns the NFT, pays gas
-const hotKey = required("AGENT_HOT_KEY"); // the registered signer
-
-const provider = new ethers.JsonRpcProvider(rpcUrl);
-const operator = new ethers.Wallet(operatorKey, provider);
-const agentWallet = new ethers.Wallet(hotKey).address;
-
-// Build ERC-8004 registration metadata as a base64 data URI.
-function buildAgentUri() {
-  let skills = [];
-  try {
-    skills = JSON.parse(process.env.AGENT_SKILLS || "[]");
-  } catch {
-    skills = String(process.env.AGENT_SKILLS || "").split(",").map((s) => s.trim()).filter(Boolean);
-  }
-  const backendUrl = (process.env.BACKEND_URL || "").replace(/\/+$/, "");
-  const metadata = {
-    type: "AgentCard",
-    name: process.env.AGENT_NAME || "jumboo-agent",
-    active: true,
-    agentWallet,
-    backendUrl,
-    endpoints: { solve: backendUrl ? `${backendUrl}/solve` : "" },
-    skills,
-    pricing: {
-      solve: {
-        amount: process.env.HIRE_PRICE_AMOUNT || "0.50",
-        asset: process.env.HIRE_PRICE_ASSET || "USDC",
-        network: process.env.HIRE_PRICE_NETWORK || "sepolia",
-      },
-    },
-  };
-  const json = JSON.stringify(metadata);
-  return `data:application/json;base64,${Buffer.from(json, "utf8").toString("base64")}`;
-}
-
-const ABI = [
-  "function registerAgent(address agentWallet, string agentURI) external returns (uint256 agentId)",
-  "event AgentRegistered(uint256 indexed agentId, address indexed operatorWallet, address indexed agentWallet, string agentURI)",
-];
-
-const registry = new ethers.Contract(identityRegistry, ABI, operator);
-
-console.log(`Registering agent…`);
-console.log(`  operator (NFT owner): ${operator.address}`);
-console.log(`  agent hot wallet:     ${agentWallet}`);
-
-const tx = await registry.registerAgent(agentWallet, buildAgentUri());
-console.log(`  tx: ${tx.hash} — waiting for confirmation…`);
-const receipt = await tx.wait();
-
-let agentId = null;
-for (const log of receipt.logs) {
-  try {
-    const parsed = registry.interface.parseLog(log);
-    if (parsed?.name === "AgentRegistered") agentId = parsed.args.agentId;
-  } catch {}
-}
-if (agentId === null) throw new Error("AgentRegistered event not found — check the registry address/network");
-
-console.log(`\n✓ Registered. agentId = ${agentId}`);
-console.log(`\n  Now set this in your .env:`);
-console.log(`    AGENT_ID=${agentId}\n`);