spendos 0.1.0

package/acp-seller/src/seller/runtime/seller.test.ts

@@ -0,0 +1,823 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  AcpJobPhase,
+  MemoType,
+  type AcpJobEventData,
+  type AcpMemoData,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Mock external deps — seller.ts imports these directly
+// ---------------------------------------------------------------------------
+vi.mock("./sellerApi.js", () => ({
+  acceptOrRejectJob: vi.fn().mockResolvedValue(undefined),
+  requestPayment: vi.fn().mockResolvedValue(undefined),
+  deliverJob: vi.fn().mockResolvedValue(undefined),
+}));
+
+const mockExecuteJob = vi.fn().mockResolvedValue({
+  deliverable: { type: "guardian_scan_result", value: { success: true } },
+});
+const mockValidateReqs = vi.fn().mockReturnValue({ valid: true });
+
+vi.mock("./offerings.js", () => ({
+  loadOffering: vi.fn().mockResolvedValue({
+    config: {
+      name: "x402janus_forensic_intelligence",
+      description: "test",
+      jobFee: 1,
+      jobFeeType: "fixed",
+      requiredFunds: false,
+    },
+    handlers: {
+      executeJob: (...args: unknown[]) => mockExecuteJob(...args),
+      validateRequirements: (...args: unknown[]) => mockValidateReqs(...args),
+    },
+  }),
+  listOfferings: vi.fn().mockReturnValue([]),
+  logOfferingsStatus: vi.fn(),
+}));
+
+vi.mock("../../lib/wallet.js", () => ({
+  getMyAgentInfo: vi.fn().mockResolvedValue({
+    walletAddress: "0xSELLER",
+    name: "test-agent",
+  }),
+}));
+
+vi.mock("../../lib/config.js", () => ({
+  checkForExistingProcess: vi.fn(),
+  writePidToConfig: vi.fn(),
+  removePidFromConfig: vi.fn(),
+  sanitizeAgentName: vi.fn((name: string) => name),
+}));
+
+import { acceptOrRejectJob, requestPayment, deliverJob } from "./sellerApi.js";
+import { loadOffering } from "./offerings.js";
+import { __testing } from "./seller.js";
+
+const {
+  handleNewTask,
+  resetSeenEvents,
+  resetInFlightJobs,
+  setSellerWallet,
+  setAgentDirName,
+  setAvailableOfferings,
+} = __testing;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const VALID_WALLET = "0x1234567890abcdef1234567890abcdef12345678";
+const SELLER_ADDR = "0xseller";
+const X402_GUARDIAN_OFFERINGS = ["x402janus_forensic_intelligence"] as const;
+
+function makeNegotiationMemo(
+  content: Record<string, unknown>,
+  id = 100,
+): AcpMemoData {
+  return {
+    id,
+    memoType: MemoType.MESSAGE,
+    content: JSON.stringify(content),
+    nextPhase: AcpJobPhase.NEGOTIATION,
+  };
+}
+
+function makePaymentMemo(
+  txHash = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+): AcpMemoData {
+  return {
+    id: 200,
+    memoType: MemoType.PAYABLE_TRANSFER,
+    content: txHash,
+    nextPhase: AcpJobPhase.TRANSACTION,
+  };
+}
+
+function makeJobEvent(
+  overrides: Partial<AcpJobEventData> = {},
+): AcpJobEventData {
+  return {
+    id: 1,
+    phase: AcpJobPhase.REQUEST,
+    clientAddress: "0xclient",
+    providerAddress: SELLER_ADDR,
+    evaluatorAddress: "0xeval",
+    price: 10,
+    memos: [],
+    context: {},
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("seller runtime — handleNewTask", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetSeenEvents();
+    resetInFlightJobs();
+    setSellerWallet(SELLER_ADDR);
+    setAgentDirName("x402janus");
+    setAvailableOfferings([...X402_GUARDIAN_OFFERINGS]);
+    mockExecuteJob.mockResolvedValue({
+      deliverable: {
+        type: "guardian_scan_result",
+        value: { success: true, wallet: VALID_WALLET },
+      },
+    });
+    mockValidateReqs.mockReturnValue({ valid: true });
+  });
+
+  // =======================================================================
+  // 1. Idempotency guard
+  // =======================================================================
+  describe("idempotency guard", () => {
+    it("processes first event for a jobId+phase", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledTimes(1);
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+    });
+
+    it("ignores duplicate event for same jobId+phase", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+      expect(acceptOrRejectJob).toHaveBeenCalledTimes(1);
+
+      vi.clearAllMocks();
+      await handleNewTask(data); // duplicate
+
+      expect(acceptOrRejectJob).not.toHaveBeenCalled();
+      expect(requestPayment).not.toHaveBeenCalled();
+    });
+
+    it("processes same jobId with different phase separately", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+
+      // REQUEST phase
+      const requestData = makeJobEvent({
+        id: 42,
+        phase: AcpJobPhase.REQUEST,
+        memoToSign: 100,
+        memos: [memo],
+      });
+      await handleNewTask(requestData);
+      expect(acceptOrRejectJob).toHaveBeenCalledTimes(1);
+
+      vi.clearAllMocks();
+      // In production the socket callback's finally() clears inFlightJobs;
+      // in unit tests we must clear it manually between sequential calls.
+      resetInFlightJobs();
+
+      // TRANSACTION phase — same jobId, different phase
+      const txData = makeJobEvent({
+        id: 42,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+      await handleNewTask(txData);
+
+      // Should be processed (not skipped as duplicate)
+      expect(deliverJob).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  // =======================================================================
+  // 2. Provider guard
+  // =======================================================================
+  describe("provider guard", () => {
+    it("ignores jobs addressed to a different provider", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        providerAddress: "0xOTHER_SELLER",
+        memoToSign: 100,
+        memos: [memo],
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).not.toHaveBeenCalled();
+      expect(loadOffering).not.toHaveBeenCalled();
+    });
+
+    it("processes jobs when providerAddress matches (case-insensitive)", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        providerAddress: "0xSELLER", // uppercase
+        memoToSign: 100,
+        memos: [memo],
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+    });
+  });
+
+  // =======================================================================
+  // 3. REQUEST phase
+  // =======================================================================
+  describe("REQUEST phase", () => {
+    it("accepts job with valid offering and wallet", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("rejects scan job at REQUEST when wallet is missing", async () => {
+      mockValidateReqs.mockReturnValue({
+        valid: false,
+        reason: "wallet (or address) is required",
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        // no requirement.wallet
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: false,
+          reason: "wallet (or address) is required",
+        }),
+      );
+      expect(requestPayment).not.toHaveBeenCalled();
+    });
+
+    it.each(X402_GUARDIAN_OFFERINGS)(
+      "rejects %s at REQUEST when wallet is missing",
+      async (offeringName) => {
+        mockValidateReqs.mockReturnValue({
+          valid: false,
+          reason: "wallet (or address) is required",
+        });
+
+        const memo = makeNegotiationMemo({ name: offeringName });
+        const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+        await handleNewTask(data);
+
+        expect(acceptOrRejectJob).toHaveBeenCalledWith(
+          1,
+          expect.objectContaining({
+            accept: false,
+            reason: "wallet (or address) is required",
+          }),
+        );
+        expect(requestPayment).not.toHaveBeenCalled();
+      },
+    );
+
+    it("uses clientAddress fallback at REQUEST when wallet is omitted", async () => {
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        const requirement = req as Record<string, unknown>;
+        expect(requirement.walletAddress).toBe(VALID_WALLET);
+        return { valid: true };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+      });
+      const data = makeJobEvent({
+        memoToSign: 100,
+        memos: [memo],
+        clientAddress: VALID_WALLET,
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("uses clientAddress fallback at REQUEST when wallet is empty string", async () => {
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        const requirement = req as Record<string, unknown>;
+        expect(requirement.walletAddress).toBe(VALID_WALLET);
+        return { valid: true };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: "" },
+      });
+      const data = makeJobEvent({
+        memoToSign: 100,
+        memos: [memo],
+        clientAddress: VALID_WALLET,
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not hoist top-level wallet into flattened requirements when nested object omits wallet", async () => {
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        const requirement = req as Record<string, unknown>;
+        expect(requirement.walletAddress).toBeUndefined();
+        expect(requirement.wallet).toBeUndefined();
+        expect(requirement.target).toBe("0xabc");
+        return {
+          valid: false,
+          reason: "wallet (or address) is required",
+        };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirements: { target: "0xabc" },
+        wallet: VALID_WALLET,
+      });
+      const data = makeJobEvent({
+        memoToSign: 100,
+        memos: [memo],
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: false,
+          reason: "wallet (or address) is required",
+        }),
+      );
+      expect(requestPayment).not.toHaveBeenCalled();
+    });
+
+    it("injects clientAddress when nested requirements are present and top-level wallet is empty", async () => {
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        const requirement = req as Record<string, unknown>;
+        expect(requirement.walletAddress).toBe(VALID_WALLET);
+        expect(requirement.target).toBe("0xdef");
+        return { valid: true };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirements: { target: "0xdef" },
+        wallet: "",
+      });
+      const data = makeJobEvent({
+        memoToSign: 100,
+        memos: [memo],
+        clientAddress: VALID_WALLET,
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("preserves array requirements without coercing numeric keys into an object", async () => {
+      setAvailableOfferings(["array_offering"]);
+      const requirements = ["alpha", "beta"];
+
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        expect(Array.isArray(req)).toBe(true);
+        expect(req).toEqual(requirements);
+        return { valid: true };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "array_offering",
+        requirements,
+      });
+      const data = makeJobEvent({
+        memoToSign: 100,
+        memos: [memo],
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({ accept: true }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("rejects unknown offering cleanly with explicit reason", async () => {
+      const memo = makeNegotiationMemo({ name: "indigo" });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: false,
+          reason: "Offering unavailable",
+        }),
+      );
+      // loadOffering should NOT be called — rejected before loading
+      expect(loadOffering).not.toHaveBeenCalled();
+    });
+
+    it("rejects REQUEST when loadOffering throws", async () => {
+      vi.mocked(loadOffering).mockRejectedValueOnce(new Error("load failed"));
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledTimes(1);
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: false,
+          reason: "Internal error",
+        }),
+      );
+      expect(requestPayment).not.toHaveBeenCalled();
+    });
+
+    it("does not reject REQUEST when payment request fails after accept", async () => {
+      vi.mocked(requestPayment).mockRejectedValueOnce(
+        new Error("payment request failed"),
+      );
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledTimes(1);
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: true,
+          reason: "Job accepted",
+        }),
+      );
+      expect(requestPayment).toHaveBeenCalledTimes(1);
+    });
+
+    it("rejects when offering name is missing entirely", async () => {
+      const memo = makeNegotiationMemo({
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({ memoToSign: 100, memos: [memo] });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          accept: false,
+          reason: "Invalid offering name",
+        }),
+      );
+    });
+  });
+
+  // =======================================================================
+  // 4. TRANSACTION phase
+  // =======================================================================
+  describe("TRANSACTION phase", () => {
+    it("executes job when wallet present, offering valid, payment verified", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        id: 10,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      expect(mockValidateReqs).toHaveBeenCalled();
+      expect(mockExecuteJob).toHaveBeenCalled();
+      expect(deliverJob).toHaveBeenCalledWith(
+        10,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "guardian_scan_result",
+          }),
+        }),
+      );
+    });
+
+    it("refuses to execute when wallet is missing at TRANSACTION — delivers error", async () => {
+      mockValidateReqs.mockReturnValue({
+        valid: false,
+        reason: "wallet (or address) is required",
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        // no wallet in requirement
+      });
+      const data = makeJobEvent({
+        id: 11,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      // executeJob must NOT be called
+      expect(mockExecuteJob).not.toHaveBeenCalled();
+      // deliverJob should be called with an error deliverable
+      expect(deliverJob).toHaveBeenCalledWith(
+        11,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "guardian_scan_error",
+          }),
+        }),
+      );
+    });
+
+    it.each(["x402janus_forensic_intelligence"] as const)(
+      "refuses %s at TRANSACTION when wallet is missing — delivers error",
+      async (offeringName) => {
+        mockValidateReqs.mockReturnValue({
+          valid: false,
+          reason: "wallet (or address) is required",
+        });
+
+        const memo = makeNegotiationMemo({ name: offeringName });
+        const data = makeJobEvent({
+          id: 111,
+          phase: AcpJobPhase.TRANSACTION,
+          memos: [memo, makePaymentMemo()],
+        });
+
+        await handleNewTask(data);
+
+        expect(mockExecuteJob).not.toHaveBeenCalled();
+        expect(deliverJob).toHaveBeenCalledWith(
+          111,
+          expect.objectContaining({
+            deliverable: expect.objectContaining({
+              type: "guardian_scan_error",
+            }),
+          }),
+        );
+      },
+    );
+
+    it("refuses to execute when no payment proof exists", async () => {
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      // No payment memo
+      const data = makeJobEvent({
+        id: 12,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo],
+      });
+
+      await handleNewTask(data);
+
+      expect(mockExecuteJob).not.toHaveBeenCalled();
+      expect(deliverJob).toHaveBeenCalledWith(
+        12,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "guardian_scan_error",
+            value: expect.objectContaining({
+              success: false,
+              error: "Payment verification failed",
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("uses clientAddress fallback at TRANSACTION when wallet is omitted", async () => {
+      mockValidateReqs.mockImplementation((req: unknown) => {
+        const requirement = req as Record<string, unknown>;
+        expect(requirement.walletAddress).toBe(VALID_WALLET);
+        return { valid: true };
+      });
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+      });
+      const data = makeJobEvent({
+        id: 18,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+        clientAddress: VALID_WALLET,
+      });
+
+      await handleNewTask(data);
+
+      expect(mockExecuteJob).toHaveBeenCalledWith(
+        expect.objectContaining({ walletAddress: VALID_WALLET }),
+      );
+      expect(deliverJob).toHaveBeenCalledTimes(1);
+    });
+
+    it("refuses to execute for unavailable offering at TRANSACTION", async () => {
+      const memo = makeNegotiationMemo({ name: "indigo" });
+      const data = makeJobEvent({
+        id: 13,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      expect(mockExecuteJob).not.toHaveBeenCalled();
+      expect(deliverJob).toHaveBeenCalledWith(
+        13,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "execution_error",
+            value: expect.objectContaining({
+              success: false,
+              error: 'Offering "indigo" is not available',
+              reason: "OFFERING_UNAVAILABLE",
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("delivers TRANSACTION error when executeJob throws", async () => {
+      mockExecuteJob.mockRejectedValueOnce(new Error("boom"));
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        id: 14,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      expect(acceptOrRejectJob).not.toHaveBeenCalled();
+      expect(deliverJob).toHaveBeenCalledWith(
+        14,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "guardian_scan_error",
+            value: expect.objectContaining({
+              success: false,
+              error: "Job execution failed",
+              reason: "boom",
+              offering: "x402janus_forensic_intelligence",
+              wallet: VALID_WALLET,
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("uses walletAddress when wallet is blank in execution error deliverable", async () => {
+      mockExecuteJob.mockRejectedValueOnce(new Error("boom"));
+
+      const memo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+        requirement: { wallet: "", walletAddress: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        id: 140,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      expect(deliverJob).toHaveBeenCalledWith(
+        140,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            value: expect.objectContaining({
+              wallet: VALID_WALLET,
+            }),
+          }),
+        }),
+      );
+    });
+
+    it("uses generic execution_error type for non-guardian offerings", async () => {
+      setAvailableOfferings([...X402_GUARDIAN_OFFERINGS, "indigo"]);
+      mockExecuteJob.mockRejectedValueOnce(new Error("boom"));
+
+      const memo = makeNegotiationMemo({
+        name: "indigo",
+        requirement: { wallet: VALID_WALLET },
+      });
+      const data = makeJobEvent({
+        id: 141,
+        phase: AcpJobPhase.TRANSACTION,
+        memos: [memo, makePaymentMemo()],
+      });
+
+      await handleNewTask(data);
+
+      expect(deliverJob).toHaveBeenCalledWith(
+        141,
+        expect.objectContaining({
+          deliverable: expect.objectContaining({
+            type: "execution_error",
+          }),
+        }),
+      );
+    });
+  });
+
+  // =======================================================================
+  // 5. REQUEST-phase wallet validation guard
+  // =======================================================================
+  describe("REQUEST-phase wallet validation", () => {
+    it("rejects REQUEST with missing wallet so users are not charged", async () => {
+      mockValidateReqs.mockReturnValue({
+        valid: false,
+        reason: "wallet (or address) is required",
+      });
+
+      const requestMemo = makeNegotiationMemo({
+        name: "x402janus_forensic_intelligence",
+      });
+      const requestData = makeJobEvent({
+        id: 99,
+        phase: AcpJobPhase.REQUEST,
+        memoToSign: 100,
+        memos: [requestMemo],
+      });
+
+      await handleNewTask(requestData);
+      expect(acceptOrRejectJob).toHaveBeenCalledWith(
+        99,
+        expect.objectContaining({
+          accept: false,
+          reason: "wallet (or address) is required",
+        }),
+      );
+      expect(requestPayment).not.toHaveBeenCalled();
+    });
+  });
+});