@elisym/cli 0.20.0 → 0.21.0

package/dist/index.js

@@ -2,19 +2,22 @@
 import { ReadableStream } from 'node:stream/web';
 import { readFileSync, existsSync, readdirSync, statSync, renameSync, chmodSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve, basename, relative, sep } from 'node:path';
-import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, MediaService, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, POLICY_T_TAG, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, makeCensor, DEFAULT_REDACT_PATHS, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, LIMITS, calculateProtocolFee, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
-import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
+import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, ElisymClient, MediaService, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, POLICY_T_TAG, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, makeCensor, DEFAULT_REDACT_PATHS, createSlidingWindowLimiter, getProtocolProgramId, getProtocolConfig, utf8ByteLength, LIMITS, calculateProtocolFee, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, NATIVE_SOL } from '@elisym/sdk';
+import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, ensureGitignoreHasIrohEntry, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
 import { isAddress, createSolanaRpc, address } from '@solana/kit';
 import { generateSecretKey, getPublicKey, nip19, verifyEvent } from 'nostr-tools';
 import YAML from 'yaml';
 import { Command } from 'commander';
 import { createHash } from 'node:crypto';
 import { LlmHealthMonitor, startLlmRecovery, createFreeLlmLimiterSet, ScriptBillingExhaustedError, ScriptExecutionError, FREE_LLM_GLOBAL_KEY, freeLlmCustomerKey, LlmHealthError } from '@elisym/sdk/llm-health';
+import { createIrohTransport } from '@elisym/sdk/node';
 import { lookup } from 'node:dns/promises';
 import { Socket } from 'node:net';
 import pino from 'pino';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import pLimit from 'p-limit';
-import { parseSkillMd, validateSkillFrontmatter, resolveInsidePath, DEFAULT_SCRIPT_TIMEOUT_MS, StaticScriptSkill as StaticScriptSkill$1, DynamicScriptSkill as DynamicScriptSkill$1, StaticFileSkill as StaticFileSkill$1, ScriptSkill as ScriptSkill$1 } from '@elisym/sdk/skills';
+import { parseSkillMd, validateSkillFrontmatter, resolveInsidePath, DEFAULT_SCRIPT_TIMEOUT_MS, DynamicScriptSkill as DynamicScriptSkill$1, StaticScriptSkill as StaticScriptSkill$1, StaticFileSkill as StaticFileSkill$1, ScriptSkill as ScriptSkill$1 } from '@elisym/sdk/skills';
 import { fileURLToPath } from 'node:url';
 
 var __defProp = Object.defineProperty;
@@ -1847,6 +1850,20 @@ var JobLedger = class {
       this.flush();
     }
   }
+  /**
+   * Record the JSON-serialized file-result descriptor. Survives later
+   * `markDelivered`/`markFailed` (which only null `result`).
+   */
+  recordAttachment(jobId, fields) {
+    const entry = this.entries.get(jobId);
+    if (!entry) {
+      return;
+    }
+    if (fields.resultAttachment !== void 0) {
+      entry.result_attachment = fields.resultAttachment;
+    }
+    this.flush();
+  }
   markDelivered(jobId) {
     const entry = this.transition(jobId, "delivered");
     if (entry) {
@@ -1981,6 +1998,9 @@ function resolveProviderApiKey(input) {
     error: `Provider "${provider}" needs an API key (required by skill(s): ${skillList}). Set secrets.llm_api_keys.${provider} via 'npx @elisym/cli profile <agent>' or export ${descriptor.envVar}.`
   };
 }
+function sanitizeForTerminal(value) {
+  return value.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
 function resolveLevel(options) {
   if (options.level) {
     return options.level;
@@ -2019,7 +2039,7 @@ function createLogger(options = {}) {
     logger = pino(baseOptions, pino.destination(2));
   }
   function logWithIndent(line) {
-    process.stdout.write(`  ${line}
+    process.stdout.write(`  ${sanitizeForTerminal(line)}
 `);
   }
   return {
@@ -2117,7 +2137,7 @@ var PAID_GLOBAL_MAX_JOBS_PER_WINDOW = 2e3;
 var MAX_TRACKED_CUSTOMERS = 1e3;
 var GLOBAL_LIMITER_KEY = "__global__";
 var AgentRuntime = class {
-  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor) {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
@@ -2125,6 +2145,7 @@ var AgentRuntime = class {
     this.ledger = ledger;
     this.callbacks = callbacks;
     this.healthMonitor = healthMonitor;
+    this.irohTransport = irohTransport;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -2361,7 +2382,7 @@ var AgentRuntime = class {
         });
         return;
       }
-      const isFreeLlm = matched?.mode === "llm" && matched.priceSubunits === 0;
+      const isFreeLlm = matched?.priceSubunits === 0 && (matched.mode === "llm" || resolveHealthPair(matched) !== null);
       let perCustomerLimiter;
       let perSkillKey;
       if (isFreeLlm && matched) {
@@ -2408,6 +2429,11 @@ var AgentRuntime = class {
         shuttingDown = true;
         log("Shutting down...");
         this.stop();
+        const shutdownNode = this.irohTransport?.shutdown() ?? Promise.resolve();
+        void shutdownNode.then(
+          () => process.exit(0),
+          () => process.exit(0)
+        );
         setTimeout(() => process.exit(0), 3e3).unref();
       };
       process.on("SIGINT", onSignal);
@@ -2493,8 +2519,9 @@ var AgentRuntime = class {
   /** Core job processing logic - payment, skill execution, result delivery. */
   async executeJob(job, signal) {
     const log = this.callbacks.onLog ?? console.log;
-    if (job.input.length > LIMITS.MAX_INPUT_LENGTH) {
-      throw new Error(`Input too long: ${job.input.length} chars (max ${LIMITS.MAX_INPUT_LENGTH})`);
+    const inputBytes = utf8ByteLength(job.input);
+    if (inputBytes > LIMITS.MAX_INPUT_LENGTH) {
+      throw new Error(`Input too long: ${inputBytes} bytes (max ${LIMITS.MAX_INPUT_LENGTH})`);
     }
     const matched = this.skills.route(job.tags);
     const healthPair = resolveHealthPair(matched);
@@ -2512,6 +2539,12 @@ var AgentRuntime = class {
         return;
       }
     }
+    if (job.attachment !== void 0 && resolveJobPrice(job.tags, this.skills) === 0) {
+      log(`[${job.jobId.slice(0, 8)}] Rejecting file input on a free skill`);
+      await this.transport.sendFeedback(job, { type: "error", message: "File inputs require a paid skill." }).catch(() => {
+      });
+      return;
+    }
     const jobPrice = resolveJobPrice(job.tags, this.skills);
     const jobAsset = resolveJobAsset(job.tags, this.skills);
     let netAmount;
@@ -2540,6 +2573,7 @@ var AgentRuntime = class {
       );
       this.callbacks.onPaymentReceived?.(job.jobId, netAmount);
     }
+    const inputFile = await this.resolveInputFile(job.attachment);
     await this.transport.sendFeedback(job, { type: "processing" }).catch(() => {
     });
     const skill = this.skills.route(job.tags);
@@ -2563,10 +2597,11 @@ var AgentRuntime = class {
     try {
       const execPromise = skill.execute(
         {
-          data: job.input,
+          data: inputFile?.inlineText ?? job.input,
           inputType: job.inputType,
           tags: job.tags,
-          jobId: job.jobId
+          jobId: job.jobId,
+          filePath: inputFile?.filePath
         },
         { ...this.skillCtx, signal: execAbort.signal }
       );
@@ -2603,14 +2638,145 @@ var AgentRuntime = class {
       if (signal) {
         signal.removeEventListener("abort", onOuterAbort);
       }
+      if (inputFile) {
+        await inputFile.cleanup().catch(() => {
+        });
+      }
     }
-    this.ledger.markExecuted(job.jobId, output.data);
+    const { attachment, deliveredContent } = await this.buildResultAttachment(job.jobId, output);
+    this.ledger.markExecuted(job.jobId, deliveredContent);
     log(`[${job.jobId.slice(0, 8)}] Skill completed, delivering result`);
-    const eventId = await this.transport.deliverResult(job, output.data, netAmount);
+    const eventId = await this.transport.deliverResult(
+      job,
+      deliveredContent,
+      netAmount,
+      attachment
+    );
     this.ledger.markDelivered(job.jobId);
     log(`[${job.jobId.slice(0, 8)}] Delivered: ${eventId.slice(0, 16)}...`);
     this.callbacks.onJobCompleted?.(job.jobId, output.data);
   }
+  /**
+   * Decide how a skill's result travels: inline text, a seeded file, or seeded
+   * large text. Returns the attachment descriptor (if any) PLUS the content to
+   * deliver on the wire - which is the EMPTY string whenever the payload was
+   * spilled to iroh (file or large text), so the encrypted result event carries
+   * only the ticket and never re-trips the NIP-44 byte cap. The single
+   * `deliveredContent` value must drive `markExecuted`, `deliverResult`, and the
+   * recovery re-delivery alike (so a crash-recovered spill re-delivers empty too).
+   * Persists the descriptor so recovery can re-share + re-deliver.
+   *
+   * Must run BEFORE `markExecuted` so a seed failure leaves the job `paid` and
+   * recovery re-executes (rather than re-delivering a dead ticket). Runs after the
+   * `skill.execute` budget window, so a slow seed never trips `max_execution_secs`.
+   */
+  async buildResultAttachment(jobId, output) {
+    if (output.filePath !== void 0) {
+      try {
+        if (!this.irohTransport) {
+          throw new Error("Skill produced a file result but iroh transport is unavailable.");
+        }
+        const seeded = await this.irohTransport.seedPath(output.filePath);
+        const attachment = {
+          name: basename(output.filePath),
+          size: seeded.size,
+          mime: output.outputMime ?? "application/octet-stream",
+          transports: [{ kind: "iroh", ticket: seeded.ticket }]
+        };
+        this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
+        return { attachment, deliveredContent: output.data };
+      } finally {
+        await output.cleanup?.().catch(() => {
+        });
+      }
+    }
+    if (utf8ByteLength(output.data) > LIMITS.MAX_ENCRYPTED_INLINE_BYTES) {
+      if (!this.irohTransport) {
+        throw new Error("Result is too large to deliver inline and iroh transport is unavailable.");
+      }
+      const seeded = await this.irohTransport.seedBytes(Buffer.from(output.data, "utf8"));
+      const attachment = {
+        name: "result.txt",
+        size: seeded.size,
+        mime: "text/plain",
+        transports: [{ kind: "iroh", ticket: seeded.ticket }]
+      };
+      this.ledger.recordAttachment(jobId, { resultAttachment: JSON.stringify(attachment) });
+      return { attachment, deliveredContent: "" };
+    }
+    return { attachment: void 0, deliveredContent: output.data };
+  }
+  /**
+   * Rebuild a file-result attachment for crash-recovery re-delivery: re-share the
+   * blob from the persistent store to mint a fresh ticket (the original ticket's
+   * direct addresses go stale across a restart). Returns undefined for a text
+   * result; throws if the blob is gone (caller marks the job failed).
+   */
+  async reShareResultAttachment(resultAttachmentJson) {
+    if (resultAttachmentJson === void 0) {
+      return void 0;
+    }
+    if (!this.irohTransport) {
+      throw new Error("Cannot recover a file result: iroh transport is unavailable.");
+    }
+    const stored = JSON.parse(resultAttachmentJson);
+    const irohTransport = stored.transports.find((transport) => transport.kind === "iroh");
+    if (!irohTransport) {
+      throw new Error("Stored result attachment has no iroh transport.");
+    }
+    const freshTicket = await this.irohTransport.reShare(irohTransport.ticket);
+    return { ...stored, transports: [{ kind: "iroh", ticket: freshTicket }] };
+  }
+  /**
+   * Resolve a job's file/large-text input (when it carries an attachment) via iroh.
+   * Only called post-payment - free + attachment is rejected in the `executeJob`
+   * preflight. Two outcomes, both with a `cleanup` callback:
+   *   - `text/*` within `MAX_REINLINE_TEXT_BYTES`: fetched into memory and returned
+   *     as `inlineText`, transparently re-inlined into `SkillInput.data` so skills
+   *     are unchanged (cleanup is a no-op - nothing on disk).
+   *   - binary, or text over the ceiling: streamed to a fixed `input` name inside a
+   *     unique `mkdtemp` dir (the untrusted attachment `name` never touches the path),
+   *     returned as `filePath`.
+   * `fetchToBytes`/`fetchToPath` enforce the real cap on the BLAKE3-verified size, so
+   * an incorrect declared `size` cannot exceed the in-memory ceiling.
+   */
+  async resolveInputFile(attachment) {
+    if (attachment === void 0) {
+      return void 0;
+    }
+    if (!this.irohTransport) {
+      throw new Error("Job carries a file input but iroh transport is unavailable.");
+    }
+    const irohTransport = attachment.transports.find((transport) => transport.kind === "iroh");
+    if (!irohTransport) {
+      throw new Error("File input has no iroh transport.");
+    }
+    if (attachment.mime.startsWith("text/") && attachment.size <= LIMITS.MAX_REINLINE_TEXT_BYTES) {
+      const bytes = await this.irohTransport.fetchToBytes(irohTransport.ticket, {
+        maxBytes: LIMITS.MAX_REINLINE_TEXT_BYTES
+      });
+      return {
+        inlineText: Buffer.from(bytes).toString("utf8"),
+        cleanup: async () => {
+        }
+      };
+    }
+    const dir = await mkdtemp(join(tmpdir(), "elisym-job-"));
+    const filePath = join(dir, "input");
+    try {
+      await this.irohTransport.fetchToPath(irohTransport.ticket, filePath);
+    } catch (error) {
+      await rm(dir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
+    }
+    return {
+      filePath,
+      cleanup: async () => {
+        await rm(dir, { recursive: true, force: true });
+      }
+    };
+  }
   /**
    * Collect payment for a job. Creates payment request, sends PaymentRequired feedback,
    * polls for on-chain confirmation. Aborts if signal fires.
@@ -2851,6 +3017,9 @@ var AgentRuntime = class {
     const recoveryAbort = new AbortController();
     this.jobAbortControllers.add(recoveryAbort);
     try {
+      if (entry.raw_event_json === void 0) {
+        return;
+      }
       const rawEvent = JSON.parse(entry.raw_event_json);
       const fakeJob = {
         jobId: entry.job_id,
@@ -2863,7 +3032,15 @@ var AgentRuntime = class {
       };
       if (entry.status === "executed" && entry.result !== void 0) {
         this.ledger.incrementRetry(entry.job_id);
-        await this.transport.deliverResult(fakeJob, entry.result, entry.net_amount);
+        let attachment;
+        try {
+          attachment = await this.reShareResultAttachment(entry.result_attachment);
+        } catch {
+          log(`[${entry.job_id.slice(0, 8)}] Recovery: result blob unavailable, marking failed`);
+          this.ledger.markFailed(entry.job_id);
+          return;
+        }
+        await this.transport.deliverResult(fakeJob, entry.result, entry.net_amount, attachment);
         this.ledger.markDelivered(entry.job_id);
         log(`[${entry.job_id.slice(0, 8)}] Recovery: re-delivered`);
       } else if (entry.status === "paid") {
@@ -2906,16 +3083,27 @@ var AgentRuntime = class {
             return;
           }
         }
+        let recoveryInputFile;
+        try {
+          recoveryInputFile = await this.resolveInputFile(
+            decodeJobPayload(rawEvent.content).attachment
+          );
+        } catch {
+          log(`[${entry.job_id.slice(0, 8)}] Recovery: input file unavailable, marking failed`);
+          this.ledger.markFailed(entry.job_id);
+          return;
+        }
         const recoveryBudgetMs = this.resolveExecutionBudgetMs(skill);
         let budgetTimer;
         let output;
         try {
           const execPromise = skill.execute(
             {
-              data: entry.input,
+              data: recoveryInputFile?.inlineText ?? entry.input,
               inputType: entry.input_type,
               tags: entry.tags,
-              jobId: entry.job_id
+              jobId: entry.job_id,
+              filePath: recoveryInputFile?.filePath
             },
             { ...this.skillCtx, signal: recoveryAbort.signal }
           );
@@ -2938,9 +3126,22 @@ var AgentRuntime = class {
           if (budgetTimer) {
             clearTimeout(budgetTimer);
           }
+          if (recoveryInputFile) {
+            await recoveryInputFile.cleanup().catch(() => {
+            });
+          }
         }
-        this.ledger.markExecuted(entry.job_id, output.data);
-        await this.transport.deliverResult(fakeJob, output.data, entry.net_amount);
+        const { attachment: resultAttachment, deliveredContent } = await this.buildResultAttachment(
+          entry.job_id,
+          output
+        );
+        this.ledger.markExecuted(entry.job_id, deliveredContent);
+        await this.transport.deliverResult(
+          fakeJob,
+          deliveredContent,
+          entry.net_amount,
+          resultAttachment
+        );
         this.ledger.markDelivered(entry.job_id);
         log(`[${entry.job_id.slice(0, 8)}] Recovery: re-executed and delivered`);
       }
@@ -3130,6 +3331,11 @@ var DynamicScriptSkill = class {
   imageFile;
   dir;
   llmOverride;
+  // Discovery hints surfaced in the published capability card (buildCard).
+  // `outputMime` is also forwarded to the inner SDK runner (it labels the file
+  // result); `inputMime` is publish-time metadata only.
+  inputMime;
+  outputMime;
   inner;
   constructor(params) {
     this.name = params.name;
@@ -3141,6 +3347,8 @@ var DynamicScriptSkill = class {
     this.imageFile = params.imageFile;
     this.dir = params.dir;
     this.llmOverride = params.llmOverride;
+    this.inputMime = params.inputMime;
+    this.outputMime = params.outputMime;
     this.inner = new DynamicScriptSkill$1({
       name: params.name,
       description: params.description,
@@ -3152,7 +3360,8 @@ var DynamicScriptSkill = class {
       scriptTimeoutMs: params.scriptTimeoutMs,
       scriptEnv: params.scriptEnv,
       image: params.image,
-      imageFile: params.imageFile
+      imageFile: params.imageFile,
+      outputMime: params.outputMime
     });
   }
   async execute(input, ctx) {
@@ -3227,6 +3436,13 @@ var ScriptSkill = class {
 
 // src/skill/loader.ts
 function buildCliSkill(parsed, entryPath, scriptEnv) {
+  let safeImageFile = parsed.imageFile;
+  if (safeImageFile !== void 0 && resolveInsidePath(entryPath, safeImageFile) === null) {
+    console.warn(
+      `SKILL.md "${parsed.name}": ignoring "image_file" that resolves outside the skill directory: ${safeImageFile}`
+    );
+    safeImageFile = void 0;
+  }
   let skill;
   switch (parsed.mode) {
     case "llm":
@@ -3237,7 +3453,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         Number(parsed.priceSubunits),
         parsed.asset,
         parsed.image,
-        parsed.imageFile,
+        safeImageFile,
         entryPath,
         parsed.systemPrompt,
         parsed.tools,
@@ -3265,7 +3481,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         asset: parsed.asset,
         outputFilePath,
         image: parsed.image,
-        imageFile: parsed.imageFile,
+        imageFile: safeImageFile,
         dir: entryPath,
         llmOverride: parsed.llmOverride
       });
@@ -3282,8 +3498,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
       if (!scriptPath) {
         throw new Error(`SKILL.md "${parsed.name}": "script" must stay inside the skill directory`);
       }
-      const Ctor = parsed.mode === "static-script" ? StaticScriptSkill : DynamicScriptSkill;
-      skill = new Ctor({
+      const scriptParams = {
         name: parsed.name,
         description: parsed.description,
         capabilities: parsed.capabilities,
@@ -3294,10 +3509,15 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         scriptTimeoutMs: parsed.scriptTimeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS,
         scriptEnv,
         image: parsed.image,
-        imageFile: parsed.imageFile,
+        imageFile: safeImageFile,
         dir: entryPath,
         llmOverride: parsed.llmOverride
-      });
+      };
+      skill = parsed.mode === "dynamic-script" ? new DynamicScriptSkill({
+        ...scriptParams,
+        outputMime: parsed.outputMime,
+        inputMime: parsed.inputMime
+      }) : new StaticScriptSkill(scriptParams);
       break;
     }
   }
@@ -3344,6 +3564,13 @@ function loadSkillsFromDir(skillsDir, options = {}) {
 function isEncrypted(event) {
   return event.tags.some((t) => t[0] === "encrypted" && t[1] === "nip44");
 }
+function parseBidTag(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
 var HEALTH_CHECK_IDLE_MS = 30 * 60 * 1e3;
 var NostrTransport = class {
   constructor(client, identity, kindOffsets) {
@@ -3373,7 +3600,7 @@ var NostrTransport = class {
         if (!hasElisym) {
           return;
         }
-        const tags = event.tags.filter((t) => t[0] === "t").map((t) => t[1]);
+        const tags = event.tags.filter((tag) => tag[0] === "t").map((tag) => tag[1]).filter((value) => typeof value === "string");
         const bidTag = event.tags.find((t) => t[0] === "bid");
         const encrypted = isEncrypted(event);
         const iTag = event.tags.find((t) => t[0] === "i");
@@ -3381,16 +3608,26 @@ var NostrTransport = class {
         if (iTag?.[2]) {
           inputType = iTag[2];
         }
-        const input = encrypted ? event.content : iTag?.[1] ?? event.content;
+        const rawInput = encrypted ? event.content : iTag?.[1] ?? event.content;
+        let input;
+        let attachment;
+        try {
+          const decoded = decodeJobPayload(rawInput);
+          input = decoded.text ?? "";
+          attachment = decoded.attachment;
+        } catch {
+          return;
+        }
         onJob({
           jobId: event.id,
           input,
           inputType,
           tags,
           customerId: event.pubkey,
-          bid: bidTag?.[1] ? parseInt(bidTag[1], 10) : void 0,
+          bid: parseBidTag(bidTag?.[1]),
           encrypted,
-          rawEvent: event
+          rawEvent: event,
+          attachment
         });
       }
     );
@@ -3441,6 +3678,9 @@ var NostrTransport = class {
         if (!verifyEvent(event)) {
           return;
         }
+        if (event.pubkey !== customerPubkey) {
+          return;
+        }
         const status = event.tags.find((t) => t[0] === "status")?.[1];
         if (status !== "payment-completed") {
           return;
@@ -3485,13 +3725,15 @@ var NostrTransport = class {
     }
   }
   /** Deliver result to customer. Retries with exponential backoff via SDK. */
-  async deliverResult(job, content, amount, retries = 3) {
+  async deliverResult(job, content, amount, attachment, retries = 3) {
     return this.client.marketplace.submitJobResultWithRetry(
       this.identity,
       job.rawEvent,
       content,
       amount,
-      retries
+      retries,
+      void 0,
+      attachment
     );
   }
   /** Returns true if an event was received within the given idle window. */
@@ -4013,6 +4255,10 @@ async function cmdStart(nameArg, options = {}) {
       capabilities: skill.capabilities,
       image: skill.image,
       ...isStatic ? { static: true } : {},
+      // File-exchange hints (dynamic-script only). `inputMime` lets clients that
+      // cannot send files (the web app) gate the Buy button before payment.
+      ...skill.inputMime ? { inputMime: skill.inputMime } : {},
+      ...skill.outputMime ? { outputMime: skill.outputMime } : {},
       payment: solanaAddress ? {
         chain: "solana",
         network: walletNetwork,
@@ -4078,6 +4324,8 @@ async function cmdStart(nameArg, options = {}) {
   };
   const transport = new NostrTransport(client, identity, [DEFAULT_KIND_OFFSET]);
   const ledger = new JobLedger(paths.jobs);
+  const irohTransport = createIrohTransport({ storePath: join(loaded.dir, ".iroh") });
+  await ensureGitignoreHasIrohEntry(dirname(loaded.dir));
   const runtimeConfig = {
     paymentTimeoutSecs: DEFAULTS.PAYMENT_EXPIRY_SECS,
     maxConcurrentJobs: MAX_CONCURRENT_JOBS,
@@ -4130,7 +4378,7 @@ async function cmdStart(nameArg, options = {}) {
     ledger,
     {
       onJobReceived: (job) => {
-        const cap = job.tags.find((t) => t !== "elisym") ?? "unknown";
+        const cap = sanitizeForTerminal(job.tags.find((t) => t !== "elisym") ?? "unknown");
         process.stdout.write(`  [job] ${job.jobId.slice(0, 16)} | cap=${cap}
 `);
         logger.info({ event: "job_received", jobId: job.jobId, capability: cap });
@@ -4141,9 +4389,10 @@ async function cmdStart(nameArg, options = {}) {
         logger.info({ event: "job_delivered", jobId });
       },
       onJobError: (jobId, error) => {
-        process.stderr.write(`  [job] ${jobId.slice(0, 16)} | error: ${error}
+        const safeError = sanitizeForTerminal(error);
+        process.stderr.write(`  [job] ${jobId.slice(0, 16)} | error: ${safeError}
 `);
-        logger.error({ event: "job_error", jobId, error });
+        logger.error({ event: "job_error", jobId, error: safeError });
       },
       onLog: diagLog,
       onStop: () => {
@@ -4151,7 +4400,8 @@ async function cmdStart(nameArg, options = {}) {
         llmHeartbeat?.stop();
       }
     },
-    healthMonitor
+    healthMonitor,
+    irohTransport
   );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();