@bnbagent/studio-cli 0.0.13 → 0.0.14-alpha.1

package/recipes/runtimes/agentcore/code/{{PKG}}/mcpMain.ts.tmpl

@@ -60,6 +60,7 @@ import {
   loadStudioToml,
   type TomlTable,
 } from "@bnbagent/studio-runtime/config";
+import { maskUrlSecrets } from "@bnbagent/studio-runtime/audit";
 import * as cr from "@bnbagent/studio-runtime/tools";
 import {
   ensureAltanaSessionLoaded,
@@ -84,13 +85,31 @@ import {
   limitCommerceOperation,
   requestLimitContext,
 } from "./requestLimits.js";
+import {
+  DeliveryTimeoutError,
+  deliveryTimeoutSeconds,
+  minimumDeliveryWindowSeconds,
+  withTimeout,
+} from "./deliveryPolicy.js";
 import * as signing from "./signing.js";
+import { READ_TOOL_CATALOG, type ReadToolName } from "./readToolCatalog.js";
 
 const APP_NAME = "agent";
+function safeLogText(value: unknown): string {
+  const text =
+    value instanceof Error
+      ? (value.stack ?? `${value.name}: ${value.message}`)
+      : String(value ?? "");
+  return maskUrlSecrets(text);
+}
+
 const log = {
-  info: (msg: string) => console.log(`[seller-agent.mcp] ${msg}`),
+  info: (msg: string) => console.log(`[seller-agent.mcp] ${safeLogText(msg)}`),
   error: (msg: string, e?: unknown) =>
-    console.error(`[seller-agent.mcp] ERROR ${msg}`, e ?? ""),
+    console.error(
+      `[seller-agent.mcp] ERROR ${safeLogText(msg)}`,
+      safeLogText(e),
+    ),
 };
 
 function protocolFailure(scope: string, error: unknown): never {
@@ -166,7 +185,8 @@ function generatorTag(): string {
 
 function hasErc8183Rail(cfg: TomlTable): boolean {
   const payments = asTable(cfg.payments);
-  return asTable(payments?.erc8183) !== null;
+  const rail = asTable(payments?.erc8183);
+  return rail !== null && rail.enabled !== false;
 }
 
 function asTable(value: unknown): TomlTable | null {
@@ -198,39 +218,46 @@ function flatQuery(query: Record<string, unknown>): Record<string, string> {
 // Deferred construction keeps negotiate and unpaid payment challenge paths from
 // building the model, and keeps this module importable without the provider
 // env until a deliverable is actually produced.
-type RunLlm = (prompt: string) => Promise<string>;
-let cachedRunLlm: RunLlm | null = null;
-
-async function runLlm(prompt: string): Promise<string> {
-  if (cachedRunLlm === null) {
-    const { buildModel } = await import("./model.js");
-    const { LLM_READ_TOOLS } = await import("./tools.js");
-    const model = buildModel(); // managed model w/ budget-gated LLM-credit auto-renew
-    cachedRunLlm = async (p: string) => {
-      const result = await generateText({
-        model,
-        system:
-          "You are a seller agent. The runtime has already authorized this task " +
-          "through its configured commerce rail. Complete the user's task now; " +
-          "do not ask for a job ID or additional payment. " +
-          "Be concrete and concise. Use the read-only chain tools when on-chain " +
-          "context helps. If a paid-data tool such as `buy_with_x402` is " +
-          "available to you, USE IT to fetch the data a task needs — those " +
-          "merchants (e.g. CoinMarketCap) charge via on-chain wallet payment, " +
-          "NOT an API key; never reply that you cannot complete the task for " +
-          "lack of an API key.",
-        prompt: p,
-        // READ-ONLY chain tools; signing is never an LLM tool. To add
-        // PAID x402 fetch tools (bag x402 trust + x402-buyer recipe):
-        //   import { X402_BUYER_TOOLS } from "./x402Buyer.js";
-        //   tools: { ...LLM_READ_TOOLS, ...X402_BUYER_TOOLS },
-        tools: LLM_READ_TOOLS,
-        stopWhen: stepCountIs(8),
-      });
-      return result.text.trim();
-    };
-  }
-  return cachedRunLlm(prompt);
+export type McpRunWork = (
+  prompt: string,
+  context: { sessionId: string; abortSignal?: AbortSignal },
+) => Promise<string>;
+
+/** The MCP delivery hook. Replace this builder for protocol-only projects. */
+export function buildRunWork(): McpRunWork {
+  let run: McpRunWork | null = null;
+  return async (prompt, context) => {
+    if (run === null) {
+      const { buildModel } = await import("./model.js");
+      const { LLM_READ_TOOLS } = await import("./tools.js");
+      const model = buildModel(); // managed model w/ budget-gated LLM-credit auto-renew
+      run = async (p, { abortSignal: signal }) => {
+        const result = await generateText({
+          model,
+          system:
+            "You are a seller agent. The runtime has already authorized this task " +
+            "through its configured commerce rail. Complete the user's task now; " +
+            "do not ask for a job ID or additional payment. " +
+            "Be concrete and concise. Use the read-only chain tools when on-chain " +
+            "context helps. If a paid-data tool such as `buy_with_x402` is " +
+            "available to you, USE IT to fetch the data a task needs — those " +
+            "merchants (e.g. CoinMarketCap) charge via on-chain wallet payment, " +
+            "NOT an API key; never reply that you cannot complete the task for " +
+            "lack of an API key.",
+          prompt: p,
+          // READ-ONLY chain tools; signing is never an LLM tool. To add
+          // PAID x402 fetch tools (bag x402 trust + x402-buyer recipe):
+          //   import { X402_BUYER_TOOLS } from "./x402Buyer.js";
+          //   tools: { ...LLM_READ_TOOLS, ...X402_BUYER_TOOLS },
+          tools: LLM_READ_TOOLS,
+          stopWhen: stepCountIs(8),
+          abortSignal: signal,
+        });
+        return result.text.trim();
+      };
+    }
+    return run(prompt, context);
+  };
 }
 
 // ── MCP server ────────────────────────────────────────────────────────────────
@@ -282,9 +309,10 @@ async function reportProgress(
 
 /** Build the seller MCP server, gating commerce tools on the ERC-8183 rail. */
 export function buildMcpServer(
-  opts: { commerceSkills?: boolean } = {},
+  opts: { commerceSkills?: boolean; runWork?: McpRunWork } = {},
 ): McpServer {
   const server = new McpServer({ name: "bnbagent-seller", version: "1.0.0" });
+  const runWork = opts.runWork ?? buildRunWork();
 
   // ── Commerce tools (signing is FIXED code in signing.ts) ──────────────────
   if (opts.commerceSkills !== false) {
@@ -366,6 +394,8 @@ export function buildMcpServer(
         });
       }
 
+      const deadlineMs = Date.now() + deliveryTimeoutSeconds() * 1000;
+
       // 1/4 — verify the funded job carries THIS agent's signed quote
       // (eth_calls). Honour the `permanent` flag: a permanent failure is
       // terminal ("rejected"); a transient one (chain read hiccup) is
@@ -373,7 +403,10 @@ export function buildMcpServer(
       await reportProgress(extra, 1, 4);
       let verdict: { ok: boolean; reason: string; permanent: boolean };
       try {
-        verdict = await signing.verifySignedJob(jid);
+        verdict = await withTimeout(
+          signing.verifySignedJob(jid, minimumDeliveryWindowSeconds()),
+          Math.max(0.001, (deadlineMs - Date.now()) / 1000),
+        );
       } catch (e) {
         // a failed verify is transient; tell the buyer to retry
         log.error(`verify of job ${jid} failed`, e);
@@ -393,37 +426,68 @@ export function buildMcpServer(
         });
       }
 
-      // 2/4 — produce the deliverable (THE ONLY LLM CALL; specialise the
-      // prompt here)
-      await reportProgress(extra, 2, 4);
-      let work: string;
-      try {
-        const spec = await signing.jobSpec(jid);
-        const task =
-          spec !== null
-            ? JSON.stringify({ task: spec.task, terms: spec.terms })
-            : `job ${jid}`;
-        const prompt =
-          "You accepted and were paid for the following job. Produce the deliverable " +
-          `now. Be complete and self-contained.\n\nJOB CONTEXT:\n${task}`;
-        work = await runLlm(prompt);
-      } catch (e) {
-        return protocolFailure(`delivery preparation for job ${jid} failed`, e);
-      }
-      // Unexpected LLM/RPC faults are logged in full, then surfaced through
-      // MCP's isError channel with a generic public message. Only the
-      // deterministic SubmitPermanentlyUnsupportedError is a classified
-      // "rejected" business result.
-      // 3/4 — sign + broadcast the on-chain submit (re-verifies FUNDED inside)
-      await reportProgress(extra, 3, 4);
+      // Bound only the cancellable work phase. Once submit starts, its
+      // broadcast outcome can be ambiguous: the request still has a total
+      // deadline, but a submit timeout is UNKNOWN and must be reconciled on
+      // chain rather than reported as safe to retry.
+      const controller = new AbortController();
+      let submitStarted = false;
       let res: { submitTx: string; deliverableUrl: string | null };
       try {
-        res = await signing.submitResult(jid, work, {
-          job_id: jid,
-          generator: generatorTag(),
-          built_with: "https://github.com/bnb-chain/bnbagent-studio",
-        });
+        const work = await withTimeout(
+          (async () => {
+            // 2/4 — produce the deliverable (THE ONLY LLM CALL).
+            await reportProgress(extra, 2, 4);
+            const spec = await signing.jobSpec(jid);
+            const task =
+              spec !== null
+                ? JSON.stringify({ task: spec.task, terms: spec.terms })
+                : `job ${jid}`;
+            const prompt =
+              "You accepted and were paid for the following job. Produce the deliverable " +
+              `now. Be complete and self-contained.\n\nJOB CONTEXT:\n${task}`;
+            return runWork(prompt, {
+              sessionId: String(jid),
+              abortSignal: controller.signal,
+            });
+          })(),
+          Math.max(0.001, (deadlineMs - Date.now()) / 1000),
+          controller,
+        );
+
+        // 3/4 — sign + broadcast submit (re-verifies FUNDED inside). Await
+        // the definitive result within the remaining request window. The
+        // opaque SDK operation cannot be cancelled after broadcast.
+        await reportProgress(extra, 3, 4);
+        const remainingSeconds = (deadlineMs - Date.now()) / 1000;
+        if (remainingSeconds <= 0) {
+          throw new DeliveryTimeoutError("delivery deadline reached");
+        }
+        submitStarted = true;
+        res = await withTimeout(
+          signing.submitResult(jid, work, {
+            job_id: jid,
+            generator: generatorTag(),
+            built_with: "https://github.com/bnb-chain/bnbagent-studio",
+          }),
+          remainingSeconds,
+        );
       } catch (e) {
+        if (e instanceof DeliveryTimeoutError) {
+          if (submitStarted) {
+            return toolResult({
+              status: "unknown",
+              job_id: jid,
+              reason:
+                "submit outcome is unknown; poll the job on-chain and do not retry until reconciled",
+            });
+          }
+          return toolResult({
+            status: "retry",
+            job_id: jid,
+            reason: `delivery timed out after ${deliveryTimeoutSeconds()}s`,
+          });
+        }
         if (
           e instanceof Error &&
           e.name === "SubmitPermanentlyUnsupportedError"
@@ -436,7 +500,7 @@ export function buildMcpServer(
             reason: "seller wallet does not support result submission",
           });
         }
-        return protocolFailure(`submit of job ${jid} failed`, e);
+        return protocolFailure(`delivery of job ${jid} failed`, e);
       }
 
       // 4/4 — done
@@ -452,95 +516,76 @@ export function buildMcpServer(
   }
 
   // ── Read-only chain tools ──────────────────────────────────────────────────
-  const network = z.string().optional().describe("studio network name");
-  const roConfig = (description: string, inputSchema: z.ZodRawShape) => ({
-    description,
-    inputSchema,
+  const roConfig = <Name extends ReadToolName>(name: Name) => ({
+    description: READ_TOOL_CATALOG[name].description,
+    inputSchema: READ_TOOL_CATALOG[name].inputSchema,
     annotations: READONLY_ANNOTATIONS,
   });
+  type ReadArgs<Name extends ReadToolName> = z.infer<
+    z.ZodObject<(typeof READ_TOOL_CATALOG)[Name]["inputSchema"]>
+  >;
 
   server.registerTool(
     "wallet_info",
-    roConfig("Active wallet summary.", {}),
+    roConfig("wallet_info"),
     async () => toolResult(await cr.walletInfo()),
   );
   server.registerTool(
     "wallet_list",
-    roConfig("All local wallet addresses.", {}),
+    roConfig("wallet_list"),
     async () => toolResult(await cr.walletList()),
   );
   server.registerTool(
     "wallet_address",
-    roConfig("The active wallet address.", {}),
+    roConfig("wallet_address"),
     async () => toolResult({ address: await cr.walletAddress() }),
   );
   server.registerTool(
     "balance_native",
-    roConfig("Native BNB balance (defaults to own wallet).", {
-      address: z.string().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("balance_native"),
+    async (a: ReadArgs<"balance_native">) =>
       toolResult(
         await cr.balanceNative(a.address ?? null, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "balance_u",
-    roConfig("$U payment-token balance (defaults to own wallet).", {
-      address: z.string().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("balance_u"),
+    async (a: ReadArgs<"balance_u">) =>
       toolResult(
         await cr.balanceU(a.address ?? null, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "pieverse_usage",
-    roConfig(
-      "Pieverse LLM usage/credit summary (SIWE personal_sign; no on-chain effect).",
-      { days: z.number().int().optional() },
-    ),
-    async (a) => toolResult(await cr.pieverseUsage(a.days ?? 7)),
+    roConfig("pieverse_usage"),
+    async (a: ReadArgs<"pieverse_usage">) =>
+      toolResult(await cr.pieverseUsage(a.days ?? 7)),
   );
   server.registerTool(
     "agent_info",
-    roConfig("ERC-8004 identity record for an agent id.", {
-      agent_id: z.number().int(),
-      network,
-    }),
-    async (a) =>
+    roConfig("agent_info"),
+    async (a: ReadArgs<"agent_info">) =>
       toolResult(await cr.agentInfo(a.agent_id, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "agent_by_address",
-    roConfig("ERC-8004 registration lookup by wallet address.", {
-      address: z.string(),
-      network,
-    }),
-    async (a) =>
+    roConfig("agent_by_address"),
+    async (a: ReadArgs<"agent_by_address">) =>
       toolResult(
         await cr.agentByAddress(a.address, a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "job_status",
-    roConfig("Read-only ERC-8183 job summary.", {
-      job_id: z.number().int(),
-      network,
-    }),
-    async (a) =>
+    roConfig("job_status"),
+    async (a: ReadArgs<"job_status">) =>
       toolResult(await cr.jobStatus(a.job_id, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "job_list",
-    roConfig("List recent ERC-8183 jobs.", {
-      limit: z.number().int().optional(),
-      mine: z.boolean().optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("job_list"),
+    async (a: ReadArgs<"job_list">) =>
       toolResult(
         await cr.jobList({
           limit: a.limit,
@@ -551,39 +596,28 @@ export function buildMcpServer(
   );
   server.registerTool(
     "job_count",
-    roConfig("Network-wide in-flight ERC-8183 job count.", { network }),
-    async (a) => toolResult(await cr.jobCount(a.network ?? defaultNetwork())),
+    roConfig("job_count"),
+    async (a: ReadArgs<"job_count">) =>
+      toolResult(await cr.jobCount(a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "tx_status",
-    roConfig("Transaction status + receipt summary.", {
-      tx_hash: z.string(),
-      network,
-    }),
-    async (a) =>
+    roConfig("tx_status"),
+    async (a: ReadArgs<"tx_status">) =>
       toolResult(await cr.txStatus(a.tx_hash, a.network ?? defaultNetwork())),
   );
   server.registerTool(
     "block_info",
-    roConfig(
-      'Block header summary ("latest"/"earliest"/"pending", decimal, or 0x hash).',
-      { block: z.string().optional(), network },
-    ),
-    async (a) =>
+    roConfig("block_info"),
+    async (a: ReadArgs<"block_info">) =>
       toolResult(
         await cr.blockInfo(a.block ?? "latest", a.network ?? defaultNetwork()),
       ),
   );
   server.registerTool(
     "contract_call_view",
-    roConfig("Call a read-only (view) contract function by signature.", {
-      address: z.string(),
-      function_signature: z.string(),
-      args: z.array(z.unknown()).optional(),
-      output_types: z.array(z.string()).optional(),
-      network,
-    }),
-    async (a) =>
+    roConfig("contract_call_view"),
+    async (a: ReadArgs<"contract_call_view">) =>
       toolResult(
         await cr.contractCallView(
           a.address,
@@ -596,8 +630,9 @@ export function buildMcpServer(
   );
   server.registerTool(
     "network_info",
-    roConfig("Chain id / RPC / token info for a studio network.", { network }),
-    async (a) => toolResult(await cr.networkInfo(a.network ?? defaultNetwork())),
+    roConfig("network_info"),
+    async (a: ReadArgs<"network_info">) =>
+      toolResult(await cr.networkInfo(a.network ?? defaultNetwork())),
   );
 
   return server;
@@ -628,9 +663,10 @@ async function main(): Promise<void> {
   const sellPath = b402SellPath(cfg);
   const host = process.env.AGENT_BIND_HOST || "0.0.0.0";
   const port = Number(process.env.AGENT_PORT || "8000");
+  const runWork = buildRunWork();
   const seller = await B402Seller.create({
     cfg,
-    runWork: ({ prompt }) => runLlm(prompt),
+    runWork: ({ prompt }) => runWork(prompt, { sessionId: "b402" }),
     walletAddress: getWallet().address,
     resourceUrl: `${
       process.env.AGENTCORE_RUNTIME_URL ?? `http://localhost:${port}`
@@ -690,7 +726,10 @@ async function main(): Promise<void> {
           delete transports[t.sessionId];
         }
       };
-      await buildMcpServer({ commerceSkills: rails.erc8183 }).connect(t);
+      await buildMcpServer({
+        commerceSkills: rails.erc8183,
+        runWork,
+      }).connect(t);
       transport = t;
     }
     await transport.handleRequest(req, res, req.body);

package/recipes/runtimes/agentcore/code/{{PKG}}/model.ts.tmpl

@@ -57,6 +57,13 @@ import {
 export function buildModel(): LanguageModel {
   const cfg = loadStudioToml();
   const llmCfg = (cfg.llm ?? {}) as TomlTable;
+  if (String(llmCfg.provider ?? "openrouter") === "none") {
+    throw new Error(
+      "Protocol-only scaffold: no LLM provider is configured. " +
+        "Implement the generated work hook before accepting funded jobs, " +
+        "or set [llm].provider and [llm].model in studio.toml.",
+    );
+  }
   const inner = resolveModel(llmCfg);
 
   if (String(llmCfg.provider ?? "openrouter") !== "pieverse-llm") {

package/recipes/runtimes/agentcore/code/{{PKG}}/sellerCore.ts.tmpl

@@ -38,24 +38,38 @@
  */
 
 import { ERC8183JobOps } from "@bnbagent/sdk/erc8183";
+import { maskUrlSecrets } from "@bnbagent/studio-runtime/audit";
 import { SubmitPermanentlyUnsupportedError } from "@bnbagent/studio-runtime/erc8183";
 import { getWallet } from "@bnbagent/studio-runtime/wallet";
+import {
+  DeliveryTimeoutError,
+  deliveryTimeoutSeconds,
+  envSeconds,
+  minimumDeliveryWindowSeconds,
+  withTimeout,
+} from "./deliveryPolicy.js";
 import { limitCommerceOperation } from "./requestLimits.js";
 import * as defaultSigning from "./signing.js";
 
+function safeLogText(value: unknown): string {
+  const text =
+    value instanceof Error
+      ? (value.stack ?? `${value.name}: ${value.message}`)
+      : String(value ?? "");
+  return maskUrlSecrets(text);
+}
+
 const log = {
-  info: (msg: string) => console.log(`[seller-agent.core] ${msg}`),
-  warn: (msg: string) => console.warn(`[seller-agent.core] WARNING ${msg}`),
+  info: (msg: string) => console.log(`[seller-agent.core] ${safeLogText(msg)}`),
+  warn: (msg: string) =>
+    console.warn(`[seller-agent.core] WARNING ${safeLogText(msg)}`),
   error: (msg: string, e?: unknown) =>
-    console.error(`[seller-agent.core] ERROR ${msg}`, e ?? ""),
+    console.error(
+      `[seller-agent.core] ERROR ${safeLogText(msg)}`,
+      safeLogText(e),
+    ),
 };
 
-/** Read a positive timeout (seconds) from the env, falling back to `dflt`. */
-function envSeconds(name: string, dflt: number): number {
-  const v = Number(process.env[name] || dflt);
-  return Number.isFinite(v) && v > 0 ? v : dflt;
-}
-
 // Background-task ceilings. notifyFunded ACKs immediately and delivers in a
 // BACKGROUND task; AgentCore keeps the scale-to-zero microVM warm
 // (HEALTHY_BUSY) while isBusy() is true. A delivery (LLM text + on-chain
@@ -65,43 +79,10 @@ function envSeconds(name: string, dflt: number): number {
 // billing memory the whole time. A timed-out job is treated as TRANSIENT
 // (not dropped): the funded job stays on-chain and a later sweep re-delivers
 // it idempotently. (Read lazily so tests can tune them via the env.)
-const jobDeliveryTimeoutSeconds = () =>
-  envSeconds("NOTIFY_DELIVERY_TIMEOUT_SECONDS", 600);
 const sweepTimeoutSeconds = () => envSeconds("NOTIFY_SWEEP_TIMEOUT_SECONDS", 60);
 const preverifyTimeoutSeconds = () =>
   envSeconds("NOTIFY_PREVERIFY_TIMEOUT_SECONDS", 30);
 
-/** Rejection raised by {@link withTimeout} when the deadline fires. */
-export class DeliveryTimeoutError extends Error {}
-
-/**
- * Race `work` against a deadline, aborting `controller` when it fires.
- *
- * JS cannot hard-cancel an arbitrary promise the way asyncio.wait_for
- * cancels a coroutine: the abort signal stops the LLM call (the AI SDK
- * honours it), and the on-chain layers are idempotent — `verifySignedJob`
- * returns non-OK for an already-SUBMITTED job and `submitResult` re-verifies
- * FUNDED — so an orphaned straggler can never double-deliver.
- */
-async function withTimeout<T>(
-  work: Promise<T>,
-  seconds: number,
-  controller?: AbortController,
-): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const deadline = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => {
-      controller?.abort();
-      reject(new DeliveryTimeoutError(`timed out after ${seconds}s`));
-    }, seconds * 1000);
-  });
-  try {
-    return await Promise.race([work, deadline]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 /**
  * The LLM work hook: produce the deliverable text for a prompt.
  *
@@ -125,6 +106,7 @@ export interface SigningApi {
   ): Promise<Record<string, unknown>>;
   verifySignedJob(
     jobId: number,
+    minimumRemainingSeconds?: number,
   ): Promise<{ ok: boolean; reason: string; permanent: boolean }>;
   jobSpec(
     jobId: number,
@@ -284,7 +266,7 @@ export class SellerCore {
       // Time-bounded: a hung RPC must not stall the ack path. On timeout we
       // fall through to accept-and-re-verify below.
       const v = await withTimeout(
-        this.signing.verifySignedJob(jobId),
+        this.signing.verifySignedJob(jobId, minimumDeliveryWindowSeconds()),
         preverifyTimeoutSeconds(),
       );
       if (!v.ok && v.permanent) {
@@ -351,7 +333,7 @@ export class SellerCore {
         verified
           ? this.doWorkAndSubmit(jobId, controller.signal)
           : this.fulfillJob(jobId, controller.signal),
-        jobDeliveryTimeoutSeconds(),
+        deliveryTimeoutSeconds(),
         controller,
       );
       log.info(`notify_funded job ${jobId} → ${JSON.stringify(result)}`);
@@ -367,7 +349,7 @@ export class SellerCore {
       if (e instanceof DeliveryTimeoutError) {
         // Transient by design — leave terminal false so a later sweep retries.
         log.warn(
-          `background delivery of job ${jobId} timed out after ${jobDeliveryTimeoutSeconds()}s; will retry`,
+          `background delivery of job ${jobId} timed out after ${deliveryTimeoutSeconds()}s; will retry`,
         );
       } else {
         log.error(`background delivery of job ${jobId} failed`, e);
@@ -399,7 +381,10 @@ export class SellerCore {
     jobId: number,
     abortSignal: AbortSignal,
   ): Promise<Record<string, unknown>> {
-    const v = await this.signing.verifySignedJob(jobId);
+    const v = await this.signing.verifySignedJob(
+      jobId,
+      minimumDeliveryWindowSeconds(),
+    );
     if (!v.ok) {
       return { ok: false, job_id: jobId, skip: v.permanent, reason: v.reason };
     }