@elisym/mcp 0.8.19 → 0.9.0

package/README.md

@@ -5,7 +5,6 @@
 [![Docker](https://img.shields.io/badge/ghcr.io-elisymlabs%2Fmcp-blue)](https://github.com/elisymlabs/elisym/pkgs/container/mcp)
 [![MCP Registry](https://img.shields.io/badge/MCP-Registry-5865F2)](https://registry.modelcontextprotocol.io/v0/servers?search=elisym)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](../../LICENSE)
-[![elisym MCP server](https://glama.ai/mcp/servers/elisymlabs/elisym/badges/score.svg)](https://glama.ai/mcp/servers/elisymlabs/elisym)
 
 MCP (Model Context Protocol) server for the elisym agent network - open infrastructure for AI agents to discover, hire, and pay each other. No platform, no middleman.
 
@@ -159,6 +158,32 @@ curl -o ~/.hermes/skills/elisym-provider/SKILL.md \
   https://raw.githubusercontent.com/elisymlabs/elisym/main/skills/elisym-provider/SKILL.md
 ```
 
+## Cost-aware job submission
+
+Three tools submit a job and wait for the result. They are behaviorally identical from the provider's perspective - same Nostr event, same payment flow, same history record - but differ in where the job's `input` comes from. Pick based on whether the calling LLM should pay output tokens to "type" the payload into the tool call.
+
+| Tool                           | `input` source             | When to use                                                                                                                                                                 |
+| ------------------------------ | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `submit_and_pay_job`           | inline string from the LLM | Default. Small / generated payloads where the LLM is the natural author of the input. Easiest to audit but the LLM pays output tokens for the whole input.                  |
+| `submit_and_pay_job_from_file` | file on disk, read by MCP  | Large pre-existing inputs (logs, captured output, generated docs). The LLM only emits a short tool call with `input_path`; the file content never enters its output tokens. |
+| `submit_diff_review`           | `git diff` run by MCP      | Code review jobs. The MCP server runs `git diff` itself. Auto-detects the range (working tree vs `${main}...HEAD`); pass `base` to override.                                |
+
+Examples:
+
+```
+# inline (current default - LLM pays output tokens for the input)
+Submit a job to <npub> with input "Summarize: ..."
+
+# file-handle (cheap for large inputs)
+git diff > /tmp/review.patch
+Then ask: submit a job from /tmp/review.patch to <npub> capability "code-review"
+
+# diff-specific (cheapest for code review - no temp file, no inline payload)
+Ask <npub> with capability "review" to review the diff in this repo
+```
+
+The file-handle and diff-specific variants only affect tool-call output tokens on the customer side. Provider-side compute and on-chain payment are unchanged.
+
 ## Security
 
 `withdraw` and `switch_agent` are gated behind opt-in flags that must be explicitly enabled per-agent:

package/dist/index.js

@@ -5,9 +5,9 @@ import { loadGlobalConfig, writeGlobalConfig } from '@elisym/sdk/node';
 import { getBase58Encoder, getBase58Decoder, generateKeyPairSigner, createSolanaRpc, address, createSolanaRpcSubscriptions, sendAndConfirmTransactionFactory, getSignatureFromTransaction, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, createKeyPairSignerFromBytes, isAddress } from '@solana/kit';
 import { Command } from 'commander';
 import { generateSecretKey, nip19, getPublicKey } from 'nostr-tools';
-import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { stat, readFile, writeFile, rename, unlink } from 'node:fs/promises';
 import { homedir, platform } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, isAbsolute, resolve } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -16,6 +16,8 @@ import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSche
 import { z, ZodError } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import pino from 'pino';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { randomBytes } from 'node:crypto';
 import { getTransferSolInstruction } from '@solana-program/system';
 import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS, getCreateAssociatedTokenIdempotentInstruction, ASSOCIATED_TOKEN_PROGRAM_ADDRESS, getTransferCheckedInstruction } from '@solana-program/token';
@@ -1001,6 +1003,129 @@ Solana: ${solanaSigner.address}
     }
   })
 ];
+var execFileP = promisify(execFile);
+var MAX_INPUT_PATH_LEN = 4096;
+var GIT_TIMEOUT_MS = 3e4;
+var GIT_MAX_BUFFER = MAX_INPUT_LEN * 2;
+async function readJobInputFile(inputPath) {
+  if (inputPath.length > MAX_INPUT_PATH_LEN) {
+    throw new Error(`input_path too long: ${inputPath.length} chars (max ${MAX_INPUT_PATH_LEN}).`);
+  }
+  const absPath = isAbsolute(inputPath) ? inputPath : resolve(process.cwd(), inputPath);
+  let stats;
+  try {
+    stats = await stat(absPath);
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") {
+      throw new Error(`input_path does not exist: ${absPath}`);
+    }
+    throw new Error(`Cannot stat input_path "${absPath}": ${e.message}`);
+  }
+  if (!stats.isFile()) {
+    throw new Error(`input_path is not a regular file: ${absPath}`);
+  }
+  if (stats.size > MAX_INPUT_LEN) {
+    throw new Error(
+      `input_path too large: ${stats.size} bytes (max ${MAX_INPUT_LEN}). Trim the file or split the job.`
+    );
+  }
+  const content = await readFile(absPath, "utf-8");
+  if (content.length > MAX_INPUT_LEN) {
+    throw new Error(
+      `input_path content too long after decoding: ${content.length} chars (max ${MAX_INPUT_LEN}).`
+    );
+  }
+  return content;
+}
+async function execGit(repoPath, args) {
+  try {
+    const { stdout } = await execFileP("git", args, {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    return stdout;
+  } catch (e) {
+    const err = e;
+    if (err.code === "ENOENT") {
+      throw new Error("git executable not found in PATH on the MCP server.");
+    }
+    if (err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+      throw new Error(
+        `git ${args.join(" ")} output exceeded ${GIT_MAX_BUFFER} bytes; narrow the range.`
+      );
+    }
+    const stderr = (err.stderr ?? "").trim();
+    throw new Error(`git ${args.join(" ")} failed: ${stderr || err.message}`);
+  }
+}
+async function isDirty(repoPath) {
+  const out = await execGit(repoPath, ["status", "--porcelain"]);
+  return out.trim().length > 0;
+}
+async function detectDefaultBase(repoPath) {
+  for (const candidate of ["main", "master"]) {
+    try {
+      await execGit(repoPath, ["rev-parse", "--verify", "--quiet", candidate]);
+      return candidate;
+    } catch {
+    }
+  }
+  try {
+    const out = await execGit(repoPath, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    const ref = out.trim();
+    return ref.length > 0 ? ref : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function assertGitRepo(repoPath) {
+  try {
+    await execGit(repoPath, ["rev-parse", "--is-inside-work-tree"]);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    throw new Error(`"${repoPath}" is not inside a git work tree: ${message}`);
+  }
+}
+async function computeGitDiff(repoPath, base) {
+  if (repoPath.length > MAX_INPUT_PATH_LEN) {
+    throw new Error(`repo_path too long: ${repoPath.length} chars (max ${MAX_INPUT_PATH_LEN}).`);
+  }
+  const absRepo = isAbsolute(repoPath) ? repoPath : resolve(process.cwd(), repoPath);
+  await assertGitRepo(absRepo);
+  let args;
+  let describedRange;
+  if (base) {
+    args = ["diff", `${base}...HEAD`];
+    describedRange = `${base}...HEAD`;
+  } else if (await isDirty(absRepo)) {
+    args = ["diff", "HEAD"];
+    describedRange = "HEAD (working tree, uncommitted changes)";
+  } else {
+    const detected = await detectDefaultBase(absRepo);
+    if (detected) {
+      args = ["diff", `${detected}...HEAD`];
+      describedRange = `${detected}...HEAD`;
+    } else {
+      args = ["diff", "HEAD"];
+      describedRange = "HEAD (no main/master detected)";
+    }
+  }
+  const diff = await execGit(absRepo, args);
+  if (diff.trim().length === 0) {
+    throw new Error(
+      `No changes in range ${describedRange}. Nothing to review - commit work, pass an explicit "base", or check the repo path.`
+    );
+  }
+  if (diff.length > MAX_INPUT_LEN) {
+    throw new Error(
+      `Diff for range ${describedRange} is ${diff.length} chars (max ${MAX_INPUT_LEN}). Pass a narrower "base" or split the review.`
+    );
+  }
+  return { diff, describedRange };
+}
 
 // src/sanitize.ts
 var MAX_LINE_LEN = 1e4;
@@ -1349,6 +1474,28 @@ var BuyCapabilitySchema = z.object({
   max_price_lamports: z.number().int().optional(),
   timeout_secs: z.number().int().min(1).max(600).default(120)
 });
+var SubmitAndPayJobFromFileSchema = z.object({
+  input_path: z.string().min(1).max(4096).describe(
+    "Path to a regular file whose contents become the job input. Absolute or relative to the MCP server's working directory."
+  ),
+  provider_npub: z.string(),
+  capability: z.string().min(1).max(64).default("general"),
+  kind_offset: z.number().int().min(0).max(999).default(DEFAULT_KIND_OFFSET),
+  timeout_secs: z.number().int().min(1).max(600).default(300),
+  max_price_lamports: z.number().int().optional()
+});
+var SubmitDiffReviewSchema = z.object({
+  provider_npub: z.string(),
+  capability: z.string().min(1).max(64).default("review").describe('Capability tag advertised by the reviewer. Override if not "review".'),
+  repo_path: z.string().min(1).max(4096).default(".").describe("Path to the git repo. Absolute or relative to the MCP server's working directory."),
+  base: z.string().max(200).optional().describe(
+    "Optional base ref (branch, tag, SHA). When set, diffs ${base}...HEAD. When omitted, auto-detects working-tree vs main/master/origin-HEAD."
+  ),
+  prompt: z.string().max(MAX_INPUT_LEN).default("").describe('Optional instructions prepended above the diff (e.g. "focus on auth flow").'),
+  kind_offset: z.number().int().min(0).max(999).default(DEFAULT_KIND_OFFSET),
+  timeout_secs: z.number().int().min(1).max(600).default(300),
+  max_price_lamports: z.number().int().optional()
+});
 function providerSolanaAddress(provider, dTag) {
   const cards = provider.cards ?? [];
   const candidates = dTag ? cards.filter(
@@ -1571,6 +1718,129 @@ Payment request: ${paymentRequest}`
   };
   return { onFeedback, onResultReceived };
 }
+async function executeSubmitAndPay(ctx, agent, params) {
+  const ping = await agent.client.ping.pingAgent(params.providerPubkey, PRE_PING_TIMEOUT_MS);
+  if (!ping.online) {
+    return errorResult(
+      `Provider ${params.providerNpub} is offline. Run search_agents to find currently-online providers.`
+    );
+  }
+  const providers = await agent.client.discovery.fetchAgents(agent.network);
+  const provider = providers.find((a) => a.npub === params.providerNpub);
+  if (!provider) {
+    return errorResult(
+      `Provider ${params.providerNpub} not found on ${agent.network}. Refresh discovery (e.g. search_agents) or verify the npub is correct.`
+    );
+  }
+  const expectedRecipient = providerSolanaAddress(provider, params.dTag);
+  if (agent.solanaKeypair && !expectedRecipient) {
+    return errorResult(
+      `Provider "${params.providerNpub}" has no Solana payment address for capability "${params.capability}". Cannot verify payment recipient - refusing to proceed. Ask the provider to publish a capability card with a payment address.`
+    );
+  }
+  const buyerWallet = agent.solanaKeypair?.publicKey;
+  if (buyerWallet && expectedRecipient && buyerWallet === expectedRecipient) {
+    return errorResult(
+      `Cannot buy from yourself - your agent's Solana wallet (${buyerWallet}) matches the provider's payment address. Use a different agent or provider.`
+    );
+  }
+  const submittedAt = Date.now();
+  const jobId = await agent.client.marketplace.submitJobRequest(agent.identity, {
+    input: params.input,
+    capability: params.dTag,
+    providerPubkey: params.providerPubkey,
+    kindOffset: params.kindOffset
+  });
+  let paymentSig;
+  let paidAmountSubunits;
+  let paidAssetKey;
+  let paymentWarnings = [];
+  try {
+    const result = await awaitJobResult(
+      agent,
+      {},
+      ({ resolve, reject }) => {
+        const payHandler = makePaymentFeedbackHandler({
+          ctx,
+          agent,
+          jobId,
+          providerPubkey: params.providerPubkey,
+          expectedRecipient,
+          maxPriceLamports: params.maxPriceLamports,
+          resolveNoWallet: resolve,
+          resolveResult: resolve,
+          rejectPayment: reject,
+          onPaid: (sig, warnings, amount, assetKey5) => {
+            paymentSig = sig;
+            paidAmountSubunits = amount;
+            paidAssetKey = assetKey5;
+            paymentWarnings = warnings;
+            for (const line of warnings) {
+              logger.warn({ event: "session_spend_threshold", agent: agent.name }, line);
+            }
+          }
+        });
+        return {
+          jobEventId: jobId,
+          providerPubkey: params.providerPubkey,
+          customerPublicKey: agent.identity.publicKey,
+          callbacks: {
+            onResult(content) {
+              const kind = isLikelyBase64(content) ? "binary" : "text";
+              const sanitized = sanitizeUntrusted(content, kind);
+              payHandler.onResultReceived(`Job completed.
+
+${sanitized.text}`);
+            },
+            onFeedback: payHandler.onFeedback,
+            onError(error) {
+              reject(new Error(`Job error: ${error}`));
+            }
+          },
+          timeoutMs: params.timeoutMs,
+          customerSecretKey: agent.identity.secretKey
+        };
+      },
+      params.timeoutMs + 5e3
+    );
+    await recordJobOutcome(agent, {
+      jobEventId: jobId,
+      capability: params.dTag,
+      providerPubkey: params.providerPubkey,
+      providerName: clipProviderName(provider.name),
+      paidAmountSubunits: paidAmountSubunits?.toString(),
+      assetKey: paidAssetKey,
+      status: "completed",
+      submittedAt,
+      completedAt: Date.now(),
+      resultPreview: result.slice(0, RESULT_PREVIEW_MAX_LEN),
+      paymentSig
+    });
+    const warningBlock = paymentWarnings.length > 0 ? `${paymentWarnings.join("\n")}
+` : "";
+    const tip = buildJobCompletionTip(jobId, params.providerNpub);
+    return textResult(`${warningBlock}event_id=${jobId}
+${result}${tip}`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    await recordJobOutcome(agent, {
+      jobEventId: jobId,
+      capability: params.dTag,
+      providerPubkey: params.providerPubkey,
+      providerName: clipProviderName(provider.name),
+      paidAmountSubunits: paidAmountSubunits?.toString(),
+      assetKey: paidAssetKey,
+      status: classifyJobFailure(msg),
+      submittedAt,
+      completedAt: Date.now(),
+      paymentSig
+    });
+    const paid = paymentSig ? ` Payment already sent (sig=${paymentSig}) - use get_job_result with event_id="${jobId}" to retrieve once ready.` : "";
+    const warningBlock = paymentWarnings.length > 0 ? `${paymentWarnings.join("\n")}
+` : "";
+    return errorResult(`${warningBlock}Job ${jobId} failed: ${msg}.${paid}`);
+  }
+}
 function awaitJobResult(agent, options, fn, safetyTimeoutMs) {
   return new Promise((resolve, reject) => {
     let closeFn = null;
@@ -1628,9 +1898,10 @@ var customerTools = [
       checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
       const agent = ctx.active();
       const providerPubkey = decodeNpub(input.provider_npub);
+      const dTag = toDTag(input.capability);
       const jobId = await agent.client.marketplace.submitJobRequest(agent.identity, {
         input: input.input,
-        capability: input.capability,
+        capability: dTag,
         providerPubkey,
         kindOffset: input.kind_offset
       });
@@ -1639,7 +1910,7 @@ var customerTools = [
           {
             event_id: jobId,
             created_at: Math.floor(Date.now() / 1e3),
-            capability: input.capability,
+            capability: dTag,
             provider_npub: input.provider_npub
           },
           null,
@@ -1804,136 +2075,89 @@ ${wrapped}`);
   }),
   defineTool({
     name: "submit_and_pay_job",
-    description: "Full customer flow: submit job -> auto-pay -> wait for result. Validates that the payment recipient matches the provider card. On timeout after submission, the job event ID is returned so the caller can follow up with get_job_result. Handles both free and paid providers automatically. If max_price_lamports is not set and provider requests payment, the job is rejected with the price - set max_price_lamports to auto-approve payments up to that limit.",
+    description: "Full customer flow: submit job -> auto-pay -> wait for result. Validates that the payment recipient matches the provider card. On timeout after submission, the job event ID is returned so the caller can follow up with get_job_result. Handles both free and paid providers automatically. If max_price_lamports is not set and provider requests payment, the job is rejected with the price - set max_price_lamports to auto-approve payments up to that limit. COST: input is sent inline in the tool call, so a large input pays output tokens on the calling LLM. For files or git diffs, prefer submit_and_pay_job_from_file or submit_diff_review respectively.",
     schema: SubmitAndPayJobSchema,
     async handler(ctx, input) {
       ctx.toolRateLimiter.check();
       checkLen("input", input.input, MAX_INPUT_LEN);
       checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
-      const timeout = Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3;
       const agent = ctx.active();
-      const providerPubkey = decodeNpub(input.provider_npub);
-      const ping = await agent.client.ping.pingAgent(providerPubkey, PRE_PING_TIMEOUT_MS);
-      if (!ping.online) {
-        return errorResult(
-          `Provider ${input.provider_npub} is offline. Run search_agents to find currently-online providers.`
-        );
-      }
-      const providers = await agent.client.discovery.fetchAgents(agent.network);
-      const provider = providers.find((a) => a.npub === input.provider_npub);
-      if (!provider) {
-        return errorResult(
-          `Provider ${input.provider_npub} not found on ${agent.network}. Refresh discovery (e.g. search_agents) or verify the npub is correct.`
-        );
-      }
-      const expectedRecipient = providerSolanaAddress(provider, toDTag(input.capability));
-      if (agent.solanaKeypair && !expectedRecipient) {
-        return errorResult(
-          `Provider "${input.provider_npub}" has no Solana payment address for capability "${input.capability}". Cannot verify payment recipient - refusing to proceed. Ask the provider to publish a capability card with a payment address.`
-        );
-      }
-      const buyerWallet = agent.solanaKeypair?.publicKey;
-      if (buyerWallet && expectedRecipient && buyerWallet === expectedRecipient) {
-        return errorResult(
-          `Cannot buy from yourself - your agent's Solana wallet (${buyerWallet}) matches the provider's payment address. Use a different agent or provider.`
-        );
-      }
-      const submittedAt = Date.now();
-      const jobId = await agent.client.marketplace.submitJobRequest(agent.identity, {
+      return executeSubmitAndPay(ctx, agent, {
         input: input.input,
+        providerNpub: input.provider_npub,
+        providerPubkey: decodeNpub(input.provider_npub),
         capability: input.capability,
-        providerPubkey,
-        kindOffset: input.kind_offset
+        // Normalize to canonical d-tag form so the published `t` tag matches what
+        // CLI/App publish on capability cards. Without this, names like
+        // "Opus 4.7" would publish as raw text and the provider's router (which
+        // compares against `toDTag(skill.name)`) would silently drop the job.
+        dTag: toDTag(input.capability),
+        kindOffset: input.kind_offset,
+        timeoutMs: Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3,
+        maxPriceLamports: input.max_price_lamports
       });
-      let paymentSig;
-      let paidAmountSubunits;
-      let paidAssetKey;
-      let paymentWarnings = [];
+    }
+  }),
+  defineTool({
+    name: "submit_and_pay_job_from_file",
+    description: "Same as submit_and_pay_job, but the job input is read from a file on disk by the MCP server instead of being passed inline by the LLM. Use this when the input is large (logs, generated content, captured output) and the LLM only needs to forward it - the file content never enters the model's output tokens. input_path may be absolute or relative to the MCP server's working directory. Max file size matches the inline limit.",
+    schema: SubmitAndPayJobFromFileSchema,
+    async handler(ctx, input) {
+      ctx.toolRateLimiter.check();
+      checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
+      let payload;
       try {
-        const result = await awaitJobResult(
-          agent,
-          {},
-          ({ resolve, reject }) => {
-            const payHandler = makePaymentFeedbackHandler({
-              ctx,
-              agent,
-              jobId,
-              providerPubkey,
-              expectedRecipient,
-              maxPriceLamports: input.max_price_lamports,
-              resolveNoWallet: resolve,
-              resolveResult: resolve,
-              rejectPayment: reject,
-              onPaid: (sig, warnings, amount, assetKey5) => {
-                paymentSig = sig;
-                paidAmountSubunits = amount;
-                paidAssetKey = assetKey5;
-                paymentWarnings = warnings;
-                for (const line of warnings) {
-                  logger.warn({ event: "session_spend_threshold", agent: agent.name }, line);
-                }
-              }
-            });
-            return {
-              jobEventId: jobId,
-              providerPubkey,
-              customerPublicKey: agent.identity.publicKey,
-              callbacks: {
-                onResult(content) {
-                  const kind = isLikelyBase64(content) ? "binary" : "text";
-                  const sanitized = sanitizeUntrusted(content, kind);
-                  payHandler.onResultReceived(`Job completed.
-
-${sanitized.text}`);
-                },
-                onFeedback: payHandler.onFeedback,
-                onError(error) {
-                  reject(new Error(`Job error: ${error}`));
-                }
-              },
-              timeoutMs: timeout,
-              customerSecretKey: agent.identity.secretKey
-            };
-          },
-          timeout + 5e3
-        );
-        await recordJobOutcome(agent, {
-          jobEventId: jobId,
-          capability: input.capability,
-          providerPubkey,
-          providerName: clipProviderName(provider.name),
-          paidAmountSubunits: paidAmountSubunits?.toString(),
-          assetKey: paidAssetKey,
-          status: "completed",
-          submittedAt,
-          completedAt: Date.now(),
-          resultPreview: result.slice(0, RESULT_PREVIEW_MAX_LEN),
-          paymentSig
-        });
-        const warningBlock = paymentWarnings.length > 0 ? `${paymentWarnings.join("\n")}
-` : "";
-        const tip = buildJobCompletionTip(jobId, input.provider_npub);
-        return textResult(`${warningBlock}event_id=${jobId}
-${result}${tip}`);
+        payload = await readJobInputFile(input.input_path);
       } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        await recordJobOutcome(agent, {
-          jobEventId: jobId,
-          capability: input.capability,
-          providerPubkey,
-          providerName: clipProviderName(provider.name),
-          paidAmountSubunits: paidAmountSubunits?.toString(),
-          assetKey: paidAssetKey,
-          status: classifyJobFailure(msg),
-          submittedAt,
-          completedAt: Date.now(),
-          paymentSig
-        });
-        const paid = paymentSig ? ` Payment already sent (sig=${paymentSig}) - use get_job_result with event_id="${jobId}" to retrieve once ready.` : "";
-        const warningBlock = paymentWarnings.length > 0 ? `${paymentWarnings.join("\n")}
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+      const agent = ctx.active();
+      return executeSubmitAndPay(ctx, agent, {
+        input: payload,
+        providerNpub: input.provider_npub,
+        providerPubkey: decodeNpub(input.provider_npub),
+        capability: input.capability,
+        dTag: toDTag(input.capability),
+        kindOffset: input.kind_offset,
+        timeoutMs: Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3,
+        maxPriceLamports: input.max_price_lamports
+      });
+    }
+  }),
+  defineTool({
+    name: "submit_diff_review",
+    description: 'Send a code-review job: the MCP server runs `git diff` inside repo_path and forwards the diff to the chosen provider. The diff content never appears in the LLM\'s output tokens, only the short tool call does. When base is omitted, auto-detects: dirty working tree -> diff against HEAD; clean tree with main/master/origin-HEAD found -> ${detected}...HEAD; otherwise falls back to diff against HEAD. Pass base explicitly (e.g. "main", a tag, or a SHA) to force a `${base}...HEAD` PR-style range. Optional `prompt` is prepended above the diff so reviewers can scope the review. Default capability is "review" - override if the provider advertises a different tag.',
+    schema: SubmitDiffReviewSchema,
+    async handler(ctx, input) {
+      ctx.toolRateLimiter.check();
+      checkLen("provider_npub", input.provider_npub, MAX_NPUB_LEN);
+      let diffResult;
+      try {
+        diffResult = await computeGitDiff(input.repo_path, input.base);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+      const promptBlock = input.prompt.trim().length > 0 ? `${input.prompt.trim()}
+
 ` : "";
-        return errorResult(`${warningBlock}Job ${jobId} failed: ${msg}.${paid}`);
+      const payload = `${promptBlock}--- git diff (${diffResult.describedRange}) ---
+${diffResult.diff}`;
+      if (payload.length > MAX_INPUT_LEN) {
+        return errorResult(
+          `Combined prompt + diff is ${payload.length} chars (max ${MAX_INPUT_LEN}). Shorten the prompt or pass a narrower base.`
+        );
       }
+      const agent = ctx.active();
+      return executeSubmitAndPay(ctx, agent, {
+        input: payload,
+        providerNpub: input.provider_npub,
+        providerPubkey: decodeNpub(input.provider_npub),
+        capability: input.capability,
+        dTag: toDTag(input.capability),
+        kindOffset: input.kind_offset,
+        timeoutMs: Math.min(input.timeout_secs, MAX_TIMEOUT_SECS) * 1e3,
+        maxPriceLamports: input.max_price_lamports
+      });
     }
   }),
   defineTool({