arc402-cli 0.2.0 → 0.3.1

package/src/commands/agent.ts

@@ -181,6 +181,43 @@ export function registerAgentCommands(program: Command): void {
       await claimSubdomain(subdomain, walletAddress, opts.tunnelTarget);
     });
 
+  // ─── transfer-subdomain ──────────────────────────────────────────────────────
+
+  agent
+    .command("transfer-subdomain <subdomain>")
+    .description("Transfer a subdomain to a new wallet. Both wallets must share the same master key (owner EOA). Used during wallet migration.")
+    .requiredOption("--new-wallet <address>", "New wallet address to transfer the subdomain to")
+    .action(async (subdomain, opts) => {
+      const normalized = subdomain.toLowerCase();
+      let newWallet: string;
+      try {
+        newWallet = ethers.getAddress(opts.newWallet);
+      } catch {
+        console.error(chalk.red(`Invalid address: ${opts.newWallet}`));
+        process.exit(1);
+      }
+
+      console.log(`\nTransferring subdomain: ${normalized}.arc402.xyz`);
+      console.log(`  New wallet: ${newWallet}`);
+      console.log(`  Verifying master key ownership onchain...`);
+
+      const res = await fetch("https://api.arc402.xyz/transfer", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ subdomain: normalized, newWalletAddress: newWallet }),
+      });
+
+      const body = await res.json() as Record<string, unknown>;
+
+      if (!res.ok) {
+        console.error(chalk.red(`\n✗ Transfer failed (${res.status}): ${body["error"] ?? JSON.stringify(body)}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green(`\n✓ Subdomain transferred: ${body["subdomain"]}`));
+      console.log(`  New owner: ${body["newWalletAddress"]}`);
+    });
+
   // ─── set-metadata ───────────────────────────────────────────────────────────
 
   agent

package/src/commands/arena-handshake.ts

@@ -2,6 +2,26 @@ import { Command } from "commander";
 import { ethers } from "ethers";
 import { loadConfig, getUsdcAddress } from "../config";
 import { requireSigner } from "../client";
+import { AGENT_REGISTRY_ABI } from "../abis";
+
+const DEFAULT_REGISTRY_ADDRESS = "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865";
+
+async function pingHandshakeEndpoint(
+  agentAddress: string,
+  payload: Record<string, unknown>,
+  registryAddress: string,
+  provider: ethers.Provider
+): Promise<void> {
+  const registry = new ethers.Contract(registryAddress, AGENT_REGISTRY_ABI, provider);
+  const agentData = await registry.getAgent(agentAddress);
+  const endpoint = agentData.endpoint as string;
+  if (!endpoint) return;
+  await fetch(`${endpoint}/handshake`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+}
 
 // ─── Handshake Contract ABI (from Handshake.sol) ─────────────────────────────
 
@@ -114,6 +134,19 @@ export function registerArenaHandshakeCommands(program: Command): void {
         tx = await handshake.sendHandshake(agentAddress, hsType, opts.note, { value });
       }
 
+      // Notify recipient's HTTP endpoint (non-blocking)
+      const registryAddress = config.agentRegistryV2Address ?? config.agentRegistryAddress ?? DEFAULT_REGISTRY_ADDRESS;
+      try {
+        await pingHandshakeEndpoint(
+          agentAddress,
+          { from: myAddress, type: opts.type, note: opts.note, txHash: tx.hash },
+          registryAddress,
+          provider
+        );
+      } catch (err) {
+        console.warn(`Warning: could not notify recipient endpoint: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
       if (opts.json) {
         console.log(JSON.stringify({ tx: tx.hash, from: myAddress, to: agentAddress, type: opts.type, note: opts.note }));
       } else {

package/src/commands/deliver.ts

@@ -8,6 +8,7 @@ import { printSenderInfo, executeContractWriteViaWallet } from "../wallet-router
 import { SERVICE_AGREEMENT_ABI } from "../abis";
 import { readFile } from "fs/promises";
 import prompts from "prompts";
+import { resolveAgentEndpoint, notifyAgent, DEFAULT_REGISTRY_ADDRESS } from "../endpoint-notify";
 
 export function registerDeliverCommand(program: Command): void {
   program
@@ -24,6 +25,7 @@ export function registerDeliverCommand(program: Command): void {
       printSenderInfo(config);
 
       // Pre-flight: check deadline and legacyFulfillEnabled (J3-01, J3-02)
+      let clientAddress = "";
       {
         const { provider: prefProvider } = await getClient(config);
         const saAbi = [
@@ -42,6 +44,7 @@ export function registerDeliverCommand(program: Command): void {
             console.error(`Contact the client to open a new agreement.`);
             process.exit(1);
           }
+          clientAddress = String(ag.client ?? "");
         } catch (e) {
           // If it's a contract read failure, skip the check (let the tx reveal the error)
           if (e instanceof Error && !e.message.includes("CALL_EXCEPTION") && !e.message.includes("could not decode")) throw e;
@@ -112,5 +115,21 @@ export function registerDeliverCommand(program: Command): void {
         if (opts.fulfill) await client.fulfill(BigInt(id), hash); else await client.commitDeliverable(BigInt(id), hash);
       }
       console.log(`${opts.fulfill ? 'fulfilled' : 'committed'} ${id} hash=${hash}`);
+
+      // Notify client's HTTP endpoint (non-blocking)
+      if (clientAddress) {
+        try {
+          const notifyProvider = new ethers.JsonRpcProvider(config.rpcUrl);
+          const registryAddress = config.agentRegistryV2Address ?? config.agentRegistryAddress ?? DEFAULT_REGISTRY_ADDRESS;
+          const endpoint = await resolveAgentEndpoint(clientAddress, notifyProvider, registryAddress);
+          await notifyAgent(endpoint, "/delivery", {
+            agreementId: id,
+            deliverableHash: hash,
+            from: signerAddress,
+          });
+        } catch (err) {
+          console.warn(`Warning: could not notify client endpoint: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
     });
 }

package/src/commands/hire.ts

@@ -6,7 +6,9 @@ import { requireSigner } from "../client";
 import { hashFile, hashString } from "../utils/hash";
 import { parseDuration } from "../utils/time";
 import { printSenderInfo, executeContractWriteViaWallet } from "../wallet-router";
-import { SERVICE_AGREEMENT_ABI } from "../abis";
+import { AGENT_REGISTRY_ABI, SERVICE_AGREEMENT_ABI } from "../abis";
+
+const DEFAULT_REGISTRY_ADDRESS = "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865";
 
 const sessionManager = new SessionManager();
 
@@ -183,6 +185,34 @@ export function registerHireCommand(program: Command): void {
         agreementId = result.agreementId;
       }
 
+      // Notify provider's HTTP endpoint (non-blocking)
+      const hireRegistryAddress = config.agentRegistryV2Address ?? config.agentRegistryAddress ?? DEFAULT_REGISTRY_ADDRESS;
+      try {
+        const hireProvider = new ethers.JsonRpcProvider(config.rpcUrl);
+        const hireRegistry = new ethers.Contract(hireRegistryAddress, AGENT_REGISTRY_ABI, hireProvider);
+        const agentData = await hireRegistry.getAgent(opts.agent);
+        const endpoint = agentData.endpoint as string;
+        if (endpoint) {
+          await fetch(`${endpoint}/hire`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              agreementId: agreementId!.toString(),
+              from: address,
+              provider: opts.agent,
+              serviceType: opts.serviceType,
+              task: opts.task,
+              price: price.toString(),
+              token,
+              deadline: deadlineSeconds,
+              deliverablesHash,
+            }),
+          });
+        }
+      } catch (err) {
+        console.warn(`Warning: could not notify provider endpoint: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
       if (opts.session) {
         sessionManager.setOnChainId(opts.session, agreementId!.toString());
       }

package/src/commands/workroom.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import * as http from "http";
 import { spawnSync, execSync } from "child_process";
 import {
   ARC402_DIR,
@@ -9,6 +10,45 @@ import {
 } from "../openshell-runtime";
 import { DAEMON_LOG, DAEMON_TOML } from "../daemon/config";
 
+// ─── Daemon lifecycle notify ──────────────────────────────────────────────────
+
+function notifyDaemonWorkroomStatus(
+  event: "entered" | "exited" | "job_started" | "job_completed",
+  agentAddress?: string,
+  jobId?: string,
+  port = 4402
+): void {
+  try {
+    // Try to read port from daemon config
+    let daemonPort = port;
+    if (fs.existsSync(DAEMON_TOML)) {
+      try {
+        const { loadDaemonConfig } = require("../daemon/config") as typeof import("../daemon/config");
+        const cfg = loadDaemonConfig();
+        daemonPort = cfg.relay?.listen_port ?? port;
+      } catch { /* use default */ }
+    }
+
+    const payload = JSON.stringify({
+      event,
+      agentAddress: agentAddress ?? "",
+      jobId,
+      timestamp: Date.now(),
+    });
+
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: daemonPort,
+      path: "/workroom/status",
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) },
+    });
+    req.on("error", () => { /* non-fatal */ });
+    req.write(payload);
+    req.end();
+  } catch { /* non-fatal */ }
+}
+
 // ─── Constants ────────────────────────────────────────────────────────────────
 
 const WORKROOM_IMAGE = "arc402-workroom";
@@ -232,6 +272,8 @@ export function registerWorkroomCommands(program: Command): void {
         console.log(`  Policy hash: ${getPolicyHash()}`);
         console.log(`  Relay port: 4402`);
         console.log(`  Logs: arc402 workroom logs`);
+        // Notify local daemon of workroom entry
+        notifyDaemonWorkroomStatus("entered");
       } else {
         console.error("Workroom started but exited immediately. Check logs:");
         console.error("  docker logs arc402-workroom");
@@ -249,6 +291,8 @@ export function registerWorkroomCommands(program: Command): void {
         return;
       }
       console.log("Stopping ARC-402 Workroom...");
+      // Notify daemon before stopping (daemon may be inside container)
+      notifyDaemonWorkroomStatus("exited");
       runCmd("docker", ["stop", WORKROOM_CONTAINER]);
       console.log("✓ Workroom stopped");
     });

package/src/config.ts

@@ -71,7 +71,7 @@ export const configExists = () => fs.existsSync(CONFIG_PATH);
 
 // Public Base RPC — stale state, do not use for production. Alchemy recommended.
 export const PUBLIC_BASE_RPC = "https://mainnet.base.org";
-export const ALCHEMY_BASE_RPC = "https://base-mainnet.g.alchemy.com/v2/YIA2uRCsFI-j5pqH-aRzflrACSlV1Qrs";
+export const ALCHEMY_BASE_RPC = "https://mainnet.base.org";
 
 /**
  * Warn at runtime if the configured RPC is the public Base endpoint.

package/src/daemon/config.ts

@@ -123,7 +123,7 @@ function withDefaults(raw: Record<string, unknown>): DaemonConfig {
       machine_key: str(w.machine_key, "env:ARC402_MACHINE_KEY"),
     },
     network: {
-      rpc_url: str(n.rpc_url, "https://base-mainnet.g.alchemy.com/v2/YIA2uRCsFI-j5pqH-aRzflrACSlV1Qrs"),
+      rpc_url: str(n.rpc_url, "https://mainnet.base.org"),
       chain_id: num(n.chain_id, 8453),
       entry_point: str(n.entry_point, "0x0000000071727De22E5E9d8BAf0edAc6f37da032"),
     },
@@ -252,7 +252,7 @@ owner_address = ""           # Owner EOA address — for display and verificatio
 machine_key = "env:ARC402_MACHINE_KEY"  # Machine key loaded from environment. NEVER hardcode here.
 
 [network]
-rpc_url = "https://base-mainnet.g.alchemy.com/v2/YIA2uRCsFI-j5pqH-aRzflrACSlV1Qrs"  # Alchemy Base RPC (recommended)
+rpc_url = "https://mainnet.base.org"  # Public Base RPC (default)
 chain_id = 8453                          # Base mainnet. Use 84532 for Base Sepolia.
 entry_point = "0x0000000071727De22E5E9d8BAf0edAc6f37da032"  # ERC-4337 EntryPoint v0.7
 

package/src/daemon/index.ts

@@ -10,6 +10,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as net from "net";
+import * as http from "http";
 import { ethers } from "ethers";
 import Database from "better-sqlite3";
 
@@ -549,6 +550,350 @@ export async function runDaemon(foreground = false): Promise<void> {
   // ── Start IPC socket ─────────────────────────────────────────────────────
   const ipcServer = startIpcServer(ipcCtx, log);
 
+  // ── Start HTTP relay server (public endpoint) ────────────────────────────
+  const httpPort = config.relay.listen_port ?? 4402;
+
+  const httpServer = http.createServer(async (req, res) => {
+    // CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+    const url = new URL(req.url || "/", `http://localhost:${httpPort}`);
+    const pathname = url.pathname;
+
+    // Health / info
+    if (pathname === "/" || pathname === "/health") {
+      const info = {
+        protocol: "arc-402",
+        version: "0.3.0",
+        agent: config.wallet.contract_address,
+        status: "online",
+        capabilities: config.policy.allowed_capabilities,
+        uptime: Math.floor((Date.now() - ipcCtx.startTime) / 1000),
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(info));
+      return;
+    }
+
+    // Agent info
+    if (pathname === "/agent") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        wallet: config.wallet.contract_address,
+        owner: config.wallet.owner_address,
+        machineKey: machineKeyAddress,
+        chainId: config.network.chain_id,
+        bundlerMode: config.bundler.mode,
+        relay: config.relay.enabled,
+      }));
+      return;
+    }
+
+    // Receive hire proposal
+    if (pathname === "/hire" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+
+          // Feed into the hire listener's message handler
+          const proposal = {
+            messageId: String(msg.messageId ?? msg.id ?? `http_${Date.now()}`),
+            hirerAddress: String(msg.hirerAddress ?? msg.hirer_address ?? msg.from ?? ""),
+            capability: String(msg.capability ?? ""),
+            priceEth: String(msg.priceEth ?? msg.price_eth ?? "0"),
+            deadlineUnix: Number(msg.deadlineUnix ?? msg.deadline ?? 0),
+            specHash: String(msg.specHash ?? msg.spec_hash ?? ""),
+            agreementId: msg.agreementId ? String(msg.agreementId) : undefined,
+            signature: msg.signature ? String(msg.signature) : undefined,
+          };
+
+          // Dedup
+          const existing = db.getHireRequest(proposal.messageId);
+          if (existing) {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: existing.status, id: proposal.messageId }));
+            return;
+          }
+
+          // Policy check
+          const { evaluatePolicy } = await import("./hire-listener");
+          const activeCount = db.countActiveHireRequests();
+          const policyResult = evaluatePolicy(proposal, config, activeCount);
+
+          if (!policyResult.allowed) {
+            db.insertHireRequest({
+              id: proposal.messageId,
+              agreement_id: proposal.agreementId ?? null,
+              hirer_address: proposal.hirerAddress,
+              capability: proposal.capability,
+              price_eth: proposal.priceEth,
+              deadline_unix: proposal.deadlineUnix,
+              spec_hash: proposal.specHash,
+              status: "rejected",
+              reject_reason: policyResult.reason ?? "policy_violation",
+            });
+            log({ event: "http_hire_rejected", id: proposal.messageId, reason: policyResult.reason });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "rejected", reason: policyResult.reason, id: proposal.messageId }));
+            return;
+          }
+
+          const status = config.policy.auto_accept ? "accepted" : "pending_approval";
+          db.insertHireRequest({
+            id: proposal.messageId,
+            agreement_id: proposal.agreementId ?? null,
+            hirer_address: proposal.hirerAddress,
+            capability: proposal.capability,
+            price_eth: proposal.priceEth,
+            deadline_unix: proposal.deadlineUnix,
+            spec_hash: proposal.specHash,
+            status,
+            reject_reason: null,
+          });
+
+          log({ event: "http_hire_received", id: proposal.messageId, hirer: proposal.hirerAddress, status });
+
+          if (config.notifications.notify_on_hire_request) {
+            await notifier.notifyHireRequest(proposal.messageId, proposal.hirerAddress, proposal.priceEth, proposal.capability);
+          }
+
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status, id: proposal.messageId }));
+        } catch (err) {
+          log({ event: "http_hire_error", error: String(err) });
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // Handshake acknowledgment endpoint
+    if (pathname === "/handshake" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body);
+          log({ event: "handshake_received", from: msg.from, type: msg.type, note: msg.note });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /hire/accepted — provider accepted, client notified
+    if (pathname === "/hire/accepted" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "hire_accepted_inbound", agreementId, from });
+          if (config.notifications.notify_on_hire_accepted) {
+            await notifier.notifyHireAccepted(agreementId, agreementId);
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /message — off-chain negotiation message
+    if (pathname === "/message" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const from = String(msg.from ?? "");
+          const to = String(msg.to ?? "");
+          const content = String(msg.content ?? "");
+          const timestamp = Number(msg.timestamp ?? Date.now());
+          log({ event: "message_received", from, to, timestamp, content_len: content.length });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /delivery — provider committed a deliverable
+    if (pathname === "/delivery" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const deliverableHash = String(msg.deliverableHash ?? msg.deliverable_hash ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "delivery_received", agreementId, deliverableHash, from });
+          // Update DB: mark delivered
+          const active = db.listActiveHireRequests();
+          const found = active.find(r => r.agreement_id === agreementId);
+          if (found) db.updateHireRequestStatus(found.id, "delivered");
+          if (config.notifications.notify_on_delivery) {
+            await notifier.notifyDelivery(agreementId, deliverableHash, "");
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /delivery/accepted — client accepted delivery, payment releasing
+    if (pathname === "/delivery/accepted" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "delivery_accepted_inbound", agreementId, from });
+          // Update DB: mark complete
+          const all = db.listActiveHireRequests();
+          const found = all.find(r => r.agreement_id === agreementId);
+          if (found) db.updateHireRequestStatus(found.id, "complete");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /dispute — dispute raised against this agent
+    if (pathname === "/dispute" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const reason = String(msg.reason ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "dispute_received", agreementId, reason, from });
+          if (config.notifications.notify_on_dispute) {
+            await notifier.notifyDispute(agreementId, from);
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /dispute/resolved — dispute resolved by arbitrator
+    if (pathname === "/dispute/resolved" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const outcome = String(msg.outcome ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "dispute_resolved_inbound", agreementId, outcome, from });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /workroom/status — workroom lifecycle events
+    if (pathname === "/workroom/status" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const event = String(msg.event ?? "");
+          const agentAddress = String(msg.agentAddress ?? config.wallet.contract_address);
+          const jobId = msg.jobId ? String(msg.jobId) : undefined;
+          const timestamp = Number(msg.timestamp ?? Date.now());
+          log({ event: "workroom_lifecycle", workroom_event: event, agentAddress, jobId, timestamp });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // GET /capabilities — agent capabilities from config
+    if (pathname === "/capabilities" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        capabilities: config.policy.allowed_capabilities,
+        max_price_eth: config.policy.max_price_eth,
+        auto_accept: config.policy.auto_accept,
+        max_concurrent_agreements: config.relay.max_concurrent_agreements,
+      }));
+      return;
+    }
+
+    // GET /status — health with active agreement count
+    if (pathname === "/status" && req.method === "GET") {
+      const activeList = db.listActiveHireRequests();
+      const pendingList = db.listPendingHireRequests();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        protocol: "arc-402",
+        version: "0.3.0",
+        agent: config.wallet.contract_address,
+        status: "online",
+        uptime: Math.floor((Date.now() - ipcCtx.startTime) / 1000),
+        active_agreements: activeList.length,
+        pending_approval: pendingList.length,
+        capabilities: config.policy.allowed_capabilities,
+      }));
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not_found" }));
+  });
+
+  httpServer.listen(httpPort, "0.0.0.0", () => {
+    log({ event: "http_server_started", port: httpPort });
+  });
+
   // ── Step 12: Startup complete ────────────────────────────────────────────
   const subsystems = [];
   if (config.relay.enabled) subsystems.push("relay");
@@ -573,7 +918,8 @@ export async function runDaemon(foreground = false): Promise<void> {
     clearInterval(timeoutInterval);
     clearInterval(balanceInterval);
 
-    // Close IPC
+    // Close HTTP + IPC
+    httpServer.close();
     ipcServer.close();
     if (fs.existsSync(DAEMON_SOCK)) fs.unlinkSync(DAEMON_SOCK);