@elisym/cli 0.23.1 → 0.24.0

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S node --no-deprecation
 import { ReadableStream } from 'node:stream/web';
-import { readFileSync, existsSync, readdirSync, statSync, renameSync, chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFileSync, existsSync, readdirSync, statSync, renameSync, chmodSync, mkdirSync, writeFileSync, appendFileSync, unlinkSync, rmdirSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve, basename, extname, relative, sep } from 'node:path';
-import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, signerFromSecretKeyBase58, ElisymClient, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, createBlossomTransport, generateSolanaWallet, getProtocolConfig, getProtocolProgramId, calculateProtocolFee, LIMITS, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, createSlidingWindowLimiter, utf8ByteLength, readAcceptedTransports, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, encodeSecretKeyBase58, NATIVE_SOL } from '@elisym/sdk';
-import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, ensureGitignoreHasIrohEntry, ensureGitignoreHasX402Entries, lookupCachedUrl, newCacheEntry, writeMediaCache } from '@elisym/sdk/agent-store';
+import { SolanaPaymentStrategy, validateAgentName, RELAYS, ElisymIdentity, formatSol, formatAssetAmount, USDC_SOLANA_DEVNET, signerFromSecretKeyBase58, ElisymClient, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, createBlossomTransport, generateSolanaWallet, getProtocolConfig, getProtocolProgramId, calculateProtocolFee, LIMITS, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, SESSION_ID_REGEX, createSlidingWindowLimiter, utf8ByteLength, readAcceptedTransports, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, encodeSecretKeyBase58, NATIVE_SOL } from '@elisym/sdk';
+import { ElisymYamlSchema, resolveInHome, resolveInProject, createAgentDir, writeYamlInitial, writeExampleSkillTemplate, writeSecrets, listAgents, loadAgent, writeYaml, agentPaths, readMediaCache, loadPoliciesFromDir, ensureGitignoreHasIrohEntry, ensureGitignoreHasX402Entries, ensureGitignoreHasSessionsEntry, 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';
@@ -17,7 +17,7 @@ import pino from 'pino';
 import { mkdir, writeFile, readFile, mkdtemp, rm, rename, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import pLimit from 'p-limit';
-import { parseSkillMd, validateSkillFrontmatter, DEFAULT_X402_MAX_INPUT_BYTES, 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 { parseSkillMd, validateSkillFrontmatter, DEFAULT_X402_MAX_INPUT_BYTES, resolveInsidePathReal, 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 { x402Client, wrapFetchWithPayment } from '@x402/fetch';
 import { ExactSvmScheme } from '@x402/svm';
 import { decodePaymentRequiredHeader } from '@x402/core/http';
@@ -126,6 +126,16 @@ async function fetchWithTimeout(url, init, signal) {
     headers: response.headers
   });
 }
+function sanitizeErrorBody(body, maxLength = 500) {
+  let scrubbed = body;
+  for (const pattern of SECRET_BODY_PATTERNS) {
+    scrubbed = scrubbed.replace(
+      pattern,
+      (_match, prefix) => typeof prefix === "string" ? `${prefix}[REDACTED]` : "[REDACTED]"
+    );
+  }
+  return scrubbed.slice(0, maxLength);
+}
 async function fetchWithRetry(url, init, signal) {
   for (let attempt = 0; ; attempt++) {
     let response;
@@ -148,13 +158,20 @@ async function fetchWithRetry(url, init, signal) {
     await sleepWithSignal(delay, signal);
   }
 }
-var DEFAULT_LLM_TIMEOUT_MS, LLM_TIMEOUT_MS, MAX_RETRIES, RETRYABLE_STATUSES;
+var DEFAULT_LLM_TIMEOUT_MS, LLM_TIMEOUT_MS, MAX_RETRIES, RETRYABLE_STATUSES, SECRET_BODY_PATTERNS;
 var init_http = __esm({
   "src/llm/providers/http.ts"() {
     DEFAULT_LLM_TIMEOUT_MS = 6e5;
     LLM_TIMEOUT_MS = resolveLlmTimeoutMs();
     MAX_RETRIES = 2;
     RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+    SECRET_BODY_PATTERNS = [
+      /sk-[A-Za-z0-9_-]{8,}/g,
+      /xai-[A-Za-z0-9_-]{8,}/g,
+      /AIza[A-Za-z0-9_-]{16,}/g,
+      /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi,
+      /(x-api-key["':\s=]+)[A-Za-z0-9._~+/=-]{8,}/gi
+    ];
   }
 });
 
@@ -193,7 +210,7 @@ async function verifyKey(apiKey, signal) {
       await response.body?.cancel().catch(() => void 0);
       return { ok: true };
     }
-    const body = (await response.text().catch(() => "")).slice(0, 500);
+    const body = sanitizeErrorBody(await response.text().catch(() => ""));
     if (response.status === 401 || response.status === 403) {
       return { ok: false, reason: "invalid", status: response.status, body };
     }
@@ -234,7 +251,7 @@ async function verifyKeyDeep(apiKey, model, signal) {
       await response.body?.cancel().catch(() => void 0);
       return { ok: true };
     }
-    const body = (await response.text().catch(() => "")).slice(0, 500);
+    const body = sanitizeErrorBody(await response.text().catch(() => ""));
     if (response.status === 401 || response.status === 403) {
       return { ok: false, reason: "invalid", status: response.status, body };
     }
@@ -280,7 +297,7 @@ var init_anthropic = __esm({
           `  [LLM] ${this.config.model} tokens: in=${inputTokens} out=${outputTokens} (total: in=${this.totalIn} out=${this.totalOut})`
         );
       }
-      async complete(systemPrompt, userInput, signal) {
+      async complete(systemPrompt, userInput, signal, history) {
         const response = await fetchWithRetry(
           "https://api.anthropic.com/v1/messages",
           {
@@ -294,13 +311,15 @@ var init_anthropic = __esm({
               model: this.config.model,
               max_tokens: this.config.maxTokens,
               system: systemPrompt,
-              messages: [{ role: "user", content: userInput }]
+              messages: [...history ?? [], { role: "user", content: userInput }]
             })
           },
           signal
         );
         if (!response.ok) {
-          throw new Error(`Anthropic API error: ${response.status} ${await response.text()}`);
+          throw new Error(
+            `Anthropic API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
+          );
         }
         const data = await response.json();
         this.logTokens(data.usage);
@@ -342,7 +361,9 @@ var init_anthropic = __esm({
           signal
         );
         if (!response.ok) {
-          throw new Error(`Anthropic API error: ${response.status} ${await response.text()}`);
+          throw new Error(
+            `Anthropic API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
+          );
         }
         const data = await response.json();
         this.logTokens(data.usage);
@@ -438,7 +459,7 @@ function createOpenAICompatibleProvider(config) {
         await response.body?.cancel().catch(() => void 0);
         return { ok: true };
       }
-      const body = (await response.text().catch(() => "")).slice(0, 500);
+      const body = sanitizeErrorBody(await response.text().catch(() => ""));
       if (response.status === 401 || response.status === 403) {
         return { ok: false, reason: "invalid", status: response.status, body };
       }
@@ -483,7 +504,7 @@ function createOpenAICompatibleProvider(config) {
         await response.body?.cancel().catch(() => void 0);
         return { ok: true };
       }
-      const body = (await response.text().catch(() => "")).slice(0, 500);
+      const body = sanitizeErrorBody(await response.text().catch(() => ""));
       if (response.status === 401 || response.status === 403) {
         return { ok: false, reason: "invalid", status: response.status, body };
       }
@@ -550,7 +571,7 @@ var init_openai_compatible = __esm({
           `  [LLM] ${this.config.model} tokens: in=${inputTokens} out=${outputTokens} (total: in=${this.totalIn} out=${this.totalOut})`
         );
       }
-      async complete(systemPrompt, userInput, signal) {
+      async complete(systemPrompt, userInput, signal, history) {
         const response = await fetchWithRetry(
           `${this.config.baseUrl}/chat/completions`,
           {
@@ -564,6 +585,7 @@ var init_openai_compatible = __esm({
               max_tokens: this.config.maxTokens,
               messages: [
                 { role: "system", content: systemPrompt },
+                ...history ?? [],
                 { role: "user", content: userInput }
               ]
             })
@@ -572,7 +594,7 @@ var init_openai_compatible = __esm({
         );
         if (!response.ok) {
           throw new Error(
-            `${this.config.providerLabel} API error: ${response.status} ${await response.text()}`
+            `${this.config.providerLabel} API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
           );
         }
         const data = await response.json();
@@ -616,7 +638,7 @@ var init_openai_compatible = __esm({
         );
         if (!response.ok) {
           throw new Error(
-            `${this.config.providerLabel} API error: ${response.status} ${await response.text()}`
+            `${this.config.providerLabel} API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
           );
         }
         const data = await response.json();
@@ -730,7 +752,7 @@ async function verifyKey2(apiKey, signal) {
       await response.body?.cancel().catch(() => void 0);
       return { ok: true };
     }
-    const body = (await response.text().catch(() => "")).slice(0, 500);
+    const body = sanitizeErrorBody(await response.text().catch(() => ""));
     if (response.status === 401 || response.status === 403) {
       return { ok: false, reason: "invalid", status: response.status, body };
     }
@@ -781,7 +803,7 @@ async function verifyKeyDeep2(apiKey, model, signal) {
       await response.body?.cancel().catch(() => void 0);
       return { ok: true };
     }
-    const body = (await response.text().catch(() => "")).slice(0, 500);
+    const body = sanitizeErrorBody(await response.text().catch(() => ""));
     if (response.status === 401 || response.status === 403) {
       return { ok: false, reason: "invalid", status: response.status, body };
     }
@@ -833,7 +855,7 @@ var init_openai = __esm({
           `  [LLM] ${this.config.model} tokens: in=${inputTokens} out=${outputTokens} (total: in=${this.totalIn} out=${this.totalOut})`
         );
       }
-      async complete(systemPrompt, userInput, signal) {
+      async complete(systemPrompt, userInput, signal, history) {
         const reasoning = this.isReasoningModel();
         const response = await fetchWithRetry(
           "https://api.openai.com/v1/chat/completions",
@@ -848,6 +870,7 @@ var init_openai = __esm({
               ...reasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
               messages: [
                 { role: reasoning ? "developer" : "system", content: systemPrompt },
+                ...history ?? [],
                 { role: "user", content: userInput }
               ]
             })
@@ -855,7 +878,9 @@ var init_openai = __esm({
           signal
         );
         if (!response.ok) {
-          throw new Error(`OpenAI API error: ${response.status} ${await response.text()}`);
+          throw new Error(
+            `OpenAI API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
+          );
         }
         const data = await response.json();
         this.logTokens(data.usage);
@@ -901,7 +926,9 @@ var init_openai = __esm({
           signal
         );
         if (!response.ok) {
-          throw new Error(`OpenAI API error: ${response.status} ${await response.text()}`);
+          throw new Error(
+            `OpenAI API error: ${response.status} ${sanitizeErrorBody(await response.text(), 200)}`
+          );
         }
         const data = await response.json();
         this.logTokens(data.usage);
@@ -2071,6 +2098,735 @@ var MIME_BY_EXT = {
 function mimeFromPath(path) {
   return MIME_BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
 }
+var SESSIONS_DIR_NAME = ".sessions";
+var SESSION_MAX_CONCURRENT_JOBS = 2;
+var SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var SESSION_MAX_PER_CUSTOMER = 64;
+var SESSION_MAX_TURN_BYTES = 256 * 1024;
+var SESSION_MAX_FILE_BYTES = 8 * 1024 * 1024;
+var SESSION_GLOBAL_MAX_BYTES = 512 * 1024 * 1024;
+var SESSION_GLOBAL_EVICT_TO_BYTES = Math.floor(SESSION_GLOBAL_MAX_BYTES * 0.9);
+var SESSION_COMPACTION_TRIGGER_CHARS = 12e4;
+var SESSION_COMPACTION_KEEP_CHARS = Math.floor(SESSION_COMPACTION_TRIGGER_CHARS / 2);
+var SESSION_COMPACTION_MAX_STRIKES = 2;
+var SESSION_SUMMARY_PREFIX = "[Conversation summary]";
+var SESSION_CONTEXT_UNAVAILABLE = "[earlier context unavailable]";
+var TRUNCATION_MARKER = "\n[truncated]";
+var CUSTOMER_PUBKEY_REGEX = /^[0-9a-f]{64}$/;
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var SessionStore = class {
+  root;
+  log;
+  ttlMs;
+  maxPerCustomer;
+  maxTurnBytes;
+  maxFileBytes;
+  globalMaxBytes;
+  globalEvictToBytes;
+  compactionTriggerChars;
+  compactionKeepChars;
+  /** Session-key -> release promise. Entry present = mutex held. */
+  locks = /* @__PURE__ */ new Map();
+  /** Session-key -> admitted-job counts (live intake + jobId-keyed recovery). */
+  admitted = /* @__PURE__ */ new Map();
+  /** Recovery registration index: jobId -> session key (for the release sweep). */
+  recoveryByJob = /* @__PURE__ */ new Map();
+  /** Session-key -> consecutive compaction failures (in-process, reset on restart). */
+  compactionStrikes = /* @__PURE__ */ new Map();
+  /** Running total of session-file bytes (established by `init()`'s scan). */
+  globalBytes = 0;
+  constructor(agentDir, logger, tuning) {
+    this.root = join(agentDir, SESSIONS_DIR_NAME);
+    this.log = logger ?? (() => {
+    });
+    this.ttlMs = tuning?.ttlMs ?? SESSION_TTL_MS;
+    this.maxPerCustomer = tuning?.maxPerCustomer ?? SESSION_MAX_PER_CUSTOMER;
+    this.maxTurnBytes = tuning?.maxTurnBytes ?? SESSION_MAX_TURN_BYTES;
+    this.maxFileBytes = tuning?.maxFileBytes ?? SESSION_MAX_FILE_BYTES;
+    this.globalMaxBytes = tuning?.globalMaxBytes ?? SESSION_GLOBAL_MAX_BYTES;
+    this.globalEvictToBytes = tuning?.globalEvictToBytes ?? (tuning?.globalMaxBytes !== void 0 ? Math.floor(tuning.globalMaxBytes * 0.9) : SESSION_GLOBAL_EVICT_TO_BYTES);
+    this.compactionTriggerChars = tuning?.compactionTriggerChars ?? SESSION_COMPACTION_TRIGGER_CHARS;
+    this.compactionKeepChars = tuning?.compactionKeepChars ?? (tuning?.compactionTriggerChars !== void 0 ? Math.floor(tuning.compactionTriggerChars / 2) : SESSION_COMPACTION_KEEP_CHARS);
+  }
+  /**
+   * Startup: establish the global byte counter (excluding `.corrupt.*`
+   * sidecars) and run a GC sweep. Call BEFORE `recoverPendingJobs` (mirrors
+   * the ledger prune-before-recovery ordering).
+   */
+  init() {
+    this.globalBytes = 0;
+    for (const file of this.listSessionFiles()) {
+      this.globalBytes += file.size;
+    }
+    this.gc();
+  }
+  /**
+   * TTL sweep: delete sessions idle past the TTL and `.corrupt.*` sidecars
+   * older than the TTL, then rmdir emptied customer dirs. A victim is deleted
+   * only while holding its try-acquired mutex with a zero admitted count -
+   * check and unlink are synchronous, so nothing can interleave.
+   */
+  gc() {
+    const cutoff = Date.now() - this.ttlMs;
+    for (const file of this.listSessionFiles()) {
+      if (file.mtimeMs >= cutoff) {
+        continue;
+      }
+      this.deleteIfIdle(file.customerId, file.sessionId);
+    }
+    this.pruneSidecars(cutoff);
+    this.pruneEmptyCustomerDirs();
+  }
+  // ── Mutex ──────────────────────────────────────────────────────────────
+  /**
+   * Acquire the session mutex. Lock order invariant (runtime-enforced): the
+   * caller already holds its `pLimit` slot - a mutex holder never waits for a
+   * slot, so no lock-order inversion is possible.
+   */
+  async acquire(customerId, sessionId) {
+    const key = sessionKey(customerId, sessionId);
+    for (; ; ) {
+      const current = this.locks.get(key);
+      if (current === void 0) {
+        return this.installLock(key);
+      }
+      await current.promise;
+    }
+  }
+  /** Non-blocking acquire for GC/eviction. Returns a release fn or null. */
+  tryAcquireSync(key) {
+    if (this.locks.has(key)) {
+      return null;
+    }
+    return this.installLock(key);
+  }
+  installLock(key) {
+    let release;
+    const promise = new Promise((resolve3) => {
+      release = resolve3;
+    });
+    const entry = { promise, release };
+    this.locks.set(key, entry);
+    return () => {
+      if (this.locks.get(key) === entry) {
+        this.locks.delete(key);
+      }
+      entry.release();
+    };
+  }
+  // ── Admitted-job counter ───────────────────────────────────────────────
+  admittedCount(customerId, sessionId) {
+    const entry = this.admitted.get(sessionKey(customerId, sessionId));
+    return entry === void 0 ? 0 : entry.live + entry.recovery.size;
+  }
+  /** Live-intake registration. Pair with `releaseLive` in the job's finally. */
+  admitLive(customerId, sessionId) {
+    const entry = this.admittedEntry(sessionKey(customerId, sessionId));
+    entry.live++;
+  }
+  releaseLive(customerId, sessionId) {
+    const key = sessionKey(customerId, sessionId);
+    const entry = this.admitted.get(key);
+    if (entry === void 0) {
+      return;
+    }
+    entry.live = Math.max(0, entry.live - 1);
+    this.dropAdmittedIfEmpty(key, entry);
+  }
+  /**
+   * Recovery pre-pass: register the sessions of pending `paid` entries (jobId-
+   * keyed, idempotent across ticks) and release registrations whose ledger
+   * entry has left `paid` (status predicate, re-checked every tick). Runs at
+   * the top of every recovery tick, BEFORE its empty-pending early return -
+   * releases are needed precisely when entries have left the pending set.
+   */
+  syncRecoveryRegistrations(refs, isStillPaid) {
+    for (const ref of refs) {
+      if (this.recoveryByJob.has(ref.jobId)) {
+        continue;
+      }
+      const key = sessionKey(ref.customerId, ref.sessionId);
+      this.recoveryByJob.set(ref.jobId, key);
+      this.admittedEntry(key).recovery.add(ref.jobId);
+    }
+    for (const [jobId, key] of this.recoveryByJob) {
+      if (isStillPaid(jobId)) {
+        continue;
+      }
+      this.recoveryByJob.delete(jobId);
+      const entry = this.admitted.get(key);
+      if (entry !== void 0) {
+        entry.recovery.delete(jobId);
+        this.dropAdmittedIfEmpty(key, entry);
+      }
+    }
+  }
+  // ── Open / append / compaction (call with the session mutex held) ──────
+  /**
+   * Load the session for a job. Applies the load-time TTL check (expired file
+   * is deleted BEFORE recording - expiry is a hard reset, never a resurrection),
+   * the global byte cap (at-cap global LRU eviction, excluding this session),
+   * and the per-customer LRU cap. `excludeJobId` (crash recovery) removes the
+   * recovering job's own turns from the replayed history and reports which of
+   * its roles are already recorded.
+   */
+  open(customerId, sessionId, excludeJobId) {
+    validateKeys(customerId, sessionId);
+    const path = this.sessionPath(customerId, sessionId);
+    const stateless = {
+      stateless: true,
+      known: false,
+      messages: [],
+      compactionNeeded: false,
+      recordedRoles: /* @__PURE__ */ new Set()
+    };
+    let exists = existsSync(path);
+    if (exists) {
+      const stat2 = statSync(path);
+      if (Date.now() - stat2.mtimeMs > this.ttlMs) {
+        this.deleteSessionFile(customerId, sessionId);
+        exists = false;
+        this.log(`[sessions] ${sessionId.slice(0, 8)} expired; starting fresh`);
+      }
+    }
+    if (this.globalBytes >= this.globalMaxBytes) {
+      this.evictGlobal(sessionKey(customerId, sessionId));
+      if (this.globalBytes >= this.globalMaxBytes) {
+        this.log(
+          "[sessions] global byte cap reached and no evictable victim; processing stateless"
+        );
+        return stateless;
+      }
+    }
+    if (!exists && !this.ensureCustomerCapacity(customerId, sessionId)) {
+      this.log(
+        `[sessions] customer session cap reached with no evictable victim; processing stateless`
+      );
+      return stateless;
+    }
+    if (!exists) {
+      return {
+        stateless: false,
+        known: false,
+        messages: [],
+        compactionNeeded: false,
+        recordedRoles: /* @__PURE__ */ new Set()
+      };
+    }
+    const lines = this.readSessionLines(customerId, sessionId);
+    if (lines === null) {
+      return {
+        stateless: false,
+        known: false,
+        messages: [],
+        compactionNeeded: false,
+        recordedRoles: /* @__PURE__ */ new Set()
+      };
+    }
+    const recordedRoles = /* @__PURE__ */ new Set();
+    if (excludeJobId !== void 0) {
+      for (const line of lines) {
+        if (line.type === "turn" && line.jobId === excludeJobId) {
+          recordedRoles.add(line.role);
+        }
+      }
+    }
+    const messages = assembleReplay(lines, excludeJobId);
+    const replayedChars = messages.reduce((sum, message) => sum + message.content.length, 0);
+    const compactionNeeded = replayedChars > this.compactionTriggerChars;
+    return {
+      stateless: false,
+      known: true,
+      messages,
+      compactionNeeded,
+      summarizeText: compactionNeeded ? buildSummarizeText(lines, this.keptTailStart(lines)) : void 0,
+      recordedRoles
+    };
+  }
+  /**
+   * Record a completed exchange. Called after execution success, BEFORE the
+   * ledger's `markExecuted` flush and before result seeding (§2 append timing).
+   * Both turns go in one write; dedupe is `(jobId, role)` via `skipRoles`.
+   */
+  appendExchange(customerId, sessionId, exchange) {
+    validateKeys(customerId, sessionId);
+    const ts = Math.floor(Date.now() / 1e3);
+    const lines = [];
+    if (!exchange.skipRoles?.has("user")) {
+      lines.push({
+        type: "turn",
+        role: "user",
+        content: truncateTurn(exchange.userContent, this.maxTurnBytes),
+        jobId: exchange.jobId,
+        capability: exchange.capability,
+        ts
+      });
+    }
+    if (!exchange.skipRoles?.has("assistant")) {
+      lines.push({
+        type: "turn",
+        role: "assistant",
+        content: truncateTurn(exchange.assistantContent, this.maxTurnBytes),
+        jobId: exchange.jobId,
+        ts
+      });
+    }
+    if (lines.length === 0) {
+      return;
+    }
+    const payload = lines.map((line) => JSON.stringify(line)).join("\n") + "\n";
+    const path = this.sessionPath(customerId, sessionId);
+    try {
+      appendFileSync(path, payload, { mode: FILE_MODE });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      mkdirSync(join(this.root, customerId), { recursive: true, mode: DIR_MODE });
+      appendFileSync(path, payload, { mode: FILE_MODE });
+    }
+    this.globalBytes += Buffer.byteLength(payload);
+  }
+  /**
+   * Compaction rewrite: `[summary line, ...kept tail]`, atomic (temp + rename).
+   * Returns the fresh replayed history. Throws on an empty summary - the
+   * caller must treat that as a compaction failure, not rewrite on it (an
+   * empty summary line is skipped at replay, silently vaporizing everything
+   * it summarized).
+   */
+  compact(customerId, sessionId, summary) {
+    if (summary.trim().length === 0) {
+      throw new Error("empty summary");
+    }
+    const rewritten = this.rewriteWithSummary(customerId, sessionId, summary);
+    this.compactionStrikes.delete(sessionKey(customerId, sessionId));
+    return rewritten;
+  }
+  /**
+   * Record a compaction failure (summarize error or empty summary). After
+   * `SESSION_COMPACTION_MAX_STRIKES` consecutive failures, force-truncate
+   * without a summarize call - same canonical `[summary, ...kept tail]` shape
+   * with the fixed `[earlier context unavailable]` content - so a small-window
+   * model can never permanently brick a session into paid-job failures.
+   */
+  compactionFailed(customerId, sessionId) {
+    const key = sessionKey(customerId, sessionId);
+    const strikes = (this.compactionStrikes.get(key) ?? 0) + 1;
+    if (strikes < SESSION_COMPACTION_MAX_STRIKES) {
+      this.compactionStrikes.set(key, strikes);
+      return { forced: false };
+    }
+    this.compactionStrikes.delete(key);
+    const messages = this.rewriteWithSummary(customerId, sessionId, SESSION_CONTEXT_UNAVAILABLE);
+    this.log(
+      `[sessions] ${sessionId.slice(0, 8)} force-truncated after repeated compaction failures`
+    );
+    return { forced: true, messages };
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  admittedEntry(key) {
+    let entry = this.admitted.get(key);
+    if (entry === void 0) {
+      entry = { live: 0, recovery: /* @__PURE__ */ new Set() };
+      this.admitted.set(key, entry);
+    }
+    return entry;
+  }
+  dropAdmittedIfEmpty(key, entry) {
+    if (entry.live === 0 && entry.recovery.size === 0) {
+      this.admitted.delete(key);
+    }
+  }
+  sessionPath(customerId, sessionId) {
+    return join(this.root, customerId, `${sessionId}.jsonl`);
+  }
+  /**
+   * Parse the transcript. A torn LAST line (crash mid-append) is dropped AND
+   * repaired away: the file is atomically rewritten without it, because a
+   * later `appendFileSync` would otherwise glue its first line onto the torn
+   * fragment (the fragment has no trailing newline), corrupting a mid-file
+   * line. Any other malformed line - or a file over the backstop - is treated
+   * as corruption: the file is renamed to a `.corrupt.<ts>` sidecar (outside
+   * the byte counter, pruned by the TTL sweep) and the session starts fresh.
+   * Callers hold the session mutex, so the repair cannot race an append.
+   */
+  readSessionLines(customerId, sessionId) {
+    const path = this.sessionPath(customerId, sessionId);
+    let raw;
+    let size;
+    try {
+      size = statSync(path).size;
+      raw = readFileSync(path, "utf-8");
+    } catch {
+      return null;
+    }
+    if (size > this.maxFileBytes) {
+      this.quarantine(customerId, sessionId, size);
+      return null;
+    }
+    const rawLines = raw.split("\n");
+    const lines = [];
+    let torn = false;
+    for (let index = 0; index < rawLines.length; index++) {
+      const text = rawLines[index].trim();
+      if (text.length === 0) {
+        continue;
+      }
+      const parsed = parseSessionLine(text);
+      if (parsed === null) {
+        const isLastNonEmpty = rawLines.slice(index + 1).every((rest) => rest.trim().length === 0);
+        if (isLastNonEmpty) {
+          torn = true;
+          break;
+        }
+        this.quarantine(customerId, sessionId, size);
+        return null;
+      }
+      lines.push(parsed);
+    }
+    if (torn) {
+      const payload = lines.map((line) => JSON.stringify(line)).join("\n") + (lines.length > 0 ? "\n" : "");
+      const tempPath = `${path}.tmp`;
+      writeFileSync(tempPath, payload, { mode: FILE_MODE });
+      renameSync(tempPath, path);
+      this.globalBytes = Math.max(0, this.globalBytes - size + Buffer.byteLength(payload));
+    }
+    return lines;
+  }
+  quarantine(customerId, sessionId, size) {
+    const path = this.sessionPath(customerId, sessionId);
+    try {
+      renameSync(path, `${path}.corrupt.${Date.now()}`);
+      this.globalBytes = Math.max(0, this.globalBytes - size);
+      this.compactionStrikes.delete(sessionKey(customerId, sessionId));
+      this.log(`[sessions] ${sessionId.slice(0, 8)} corrupt; quarantined and reset`);
+    } catch {
+    }
+  }
+  /**
+   * Kept-tail start index: the longest suffix of TURN lines whose combined
+   * stored size stays within the keep budget, floored at the most recent turn.
+   */
+  keptTailStart(lines) {
+    let budget = this.compactionKeepChars;
+    let start = lines.length;
+    for (let index = lines.length - 1; index >= 0; index--) {
+      const line = lines[index];
+      if (line.type !== "turn") {
+        break;
+      }
+      const cost = line.content.length;
+      if (cost > budget && start < lines.length) {
+        break;
+      }
+      budget -= cost;
+      start = index;
+      if (budget <= 0) {
+        break;
+      }
+    }
+    if (start === lines.length && lines.length > 0) {
+      start = lines.length - 1;
+    }
+    return start;
+  }
+  rewriteWithSummary(customerId, sessionId, summary) {
+    validateKeys(customerId, sessionId);
+    const lines = this.readSessionLines(customerId, sessionId) ?? [];
+    const tailStart = this.keptTailStart(lines);
+    const tail = lines.slice(tailStart).flatMap((line) => {
+      if (line.type !== "turn") {
+        return [];
+      }
+      if (line.content.length > this.compactionKeepChars) {
+        return [
+          {
+            ...line,
+            content: line.content.slice(0, this.compactionKeepChars) + TRUNCATION_MARKER
+          }
+        ];
+      }
+      return [line];
+    });
+    const summaryLine = {
+      type: "summary",
+      content: summary,
+      ts: Math.floor(Date.now() / 1e3)
+    };
+    const rewritten = [summaryLine, ...tail];
+    const payload = rewritten.map((line) => JSON.stringify(line)).join("\n") + "\n";
+    const path = this.sessionPath(customerId, sessionId);
+    const oldSize = existsSync(path) ? statSync(path).size : 0;
+    const tempPath = `${path}.tmp`;
+    mkdirSync(join(this.root, customerId), { recursive: true, mode: DIR_MODE });
+    writeFileSync(tempPath, payload, { mode: FILE_MODE });
+    renameSync(tempPath, path);
+    this.globalBytes = Math.max(0, this.globalBytes - oldSize + Buffer.byteLength(payload));
+    return assembleReplay(rewritten, void 0);
+  }
+  /** New-session admission under the per-customer cap: LRU-evict an idle victim. */
+  ensureCustomerCapacity(customerId, sessionId) {
+    const dir = join(this.root, customerId);
+    let entries;
+    try {
+      entries = readdirSync(dir).filter((name) => name.endsWith(".jsonl"));
+    } catch {
+      return true;
+    }
+    if (entries.length < this.maxPerCustomer) {
+      return true;
+    }
+    const candidates = entries.map((name) => {
+      const candidateSessionId = name.slice(0, -".jsonl".length);
+      const path = join(dir, name);
+      try {
+        return { sessionId: candidateSessionId, mtimeMs: statSync(path).mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter(
+      (candidate) => candidate !== null
+    ).sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const candidate of candidates) {
+      if (candidate.sessionId === sessionId) {
+        continue;
+      }
+      if (this.deleteIfIdle(customerId, candidate.sessionId)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Global LRU eviction down to the high-water mark. Excludes `selfKey` (the
+   * arriving job's own session must not be its own victim).
+   */
+  evictGlobal(selfKey) {
+    const files = this.listSessionFiles().sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const file of files) {
+      if (this.globalBytes <= this.globalEvictToBytes) {
+        return;
+      }
+      if (sessionKey(file.customerId, file.sessionId) === selfKey) {
+        continue;
+      }
+      this.deleteIfIdle(file.customerId, file.sessionId);
+    }
+  }
+  /**
+   * Delete a session iff idle: try-acquired mutex AND zero admitted count.
+   * The mutex alone is not an in-flight guard - an admitted job spends its
+   * whole payment phase before the mutex. Check and unlink are synchronous.
+   */
+  deleteIfIdle(customerId, sessionId) {
+    const key = sessionKey(customerId, sessionId);
+    const release = this.tryAcquireSync(key);
+    if (release === null) {
+      return false;
+    }
+    try {
+      if (this.admittedCount(customerId, sessionId) > 0) {
+        return false;
+      }
+      this.deleteSessionFile(customerId, sessionId);
+      return true;
+    } finally {
+      release();
+    }
+  }
+  deleteSessionFile(customerId, sessionId) {
+    const path = this.sessionPath(customerId, sessionId);
+    let size = 0;
+    try {
+      size = statSync(path).size;
+      unlinkSync(path);
+    } catch {
+      return;
+    }
+    this.globalBytes = Math.max(0, this.globalBytes - size);
+    this.compactionStrikes.delete(sessionKey(customerId, sessionId));
+  }
+  listSessionFiles() {
+    const out = [];
+    let customers;
+    try {
+      customers = readdirSync(this.root);
+    } catch {
+      return out;
+    }
+    for (const customerId of customers) {
+      if (!CUSTOMER_PUBKEY_REGEX.test(customerId)) {
+        continue;
+      }
+      let names;
+      try {
+        names = readdirSync(join(this.root, customerId));
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (!name.endsWith(".jsonl")) {
+          continue;
+        }
+        const sessionId = name.slice(0, -".jsonl".length);
+        if (!SESSION_ID_REGEX.test(sessionId)) {
+          continue;
+        }
+        try {
+          const stat2 = statSync(join(this.root, customerId, name));
+          out.push({ customerId, sessionId, size: stat2.size, mtimeMs: stat2.mtimeMs });
+        } catch {
+        }
+      }
+    }
+    return out;
+  }
+  pruneSidecars(cutoffMs) {
+    let customers;
+    try {
+      customers = readdirSync(this.root);
+    } catch {
+      return;
+    }
+    for (const customerId of customers) {
+      const dir = join(this.root, customerId);
+      let names;
+      try {
+        names = readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (!name.includes(".corrupt.")) {
+          continue;
+        }
+        const path = join(dir, name);
+        try {
+          if (statSync(path).mtimeMs < cutoffMs) {
+            unlinkSync(path);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  pruneEmptyCustomerDirs() {
+    let customers;
+    try {
+      customers = readdirSync(this.root);
+    } catch {
+      return;
+    }
+    for (const customerId of customers) {
+      const dir = join(this.root, customerId);
+      try {
+        if (readdirSync(dir).length === 0) {
+          rmdirSync(dir);
+        }
+      } catch {
+      }
+    }
+  }
+};
+function sessionKey(customerId, sessionId) {
+  return `${customerId}/${sessionId}`;
+}
+function validateKeys(customerId, sessionId) {
+  if (!CUSTOMER_PUBKEY_REGEX.test(customerId)) {
+    throw new Error("SessionStore: invalid customer pubkey");
+  }
+  if (!SESSION_ID_REGEX.test(sessionId)) {
+    throw new Error("SessionStore: invalid session id");
+  }
+}
+function parseSessionLine(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const record = value;
+  if (record.type === "summary") {
+    if (typeof record.content !== "string" || typeof record.ts !== "number") {
+      return null;
+    }
+    return { type: "summary", content: record.content, ts: record.ts };
+  }
+  if (record.type === "turn") {
+    if (record.role !== "user" && record.role !== "assistant" || typeof record.content !== "string" || typeof record.jobId !== "string" || typeof record.ts !== "number") {
+      return null;
+    }
+    return {
+      type: "turn",
+      role: record.role,
+      content: record.content,
+      jobId: record.jobId,
+      capability: typeof record.capability === "string" ? record.capability : void 0,
+      ts: record.ts
+    };
+  }
+  return null;
+}
+function assembleReplay(lines, excludeJobId) {
+  const raw = [];
+  for (const line of lines) {
+    if (line.type === "summary") {
+      raw.push({ role: "user", content: `${SESSION_SUMMARY_PREFIX}
+${line.content}` });
+    } else if (line.jobId !== excludeJobId) {
+      raw.push({ role: line.role, content: line.content });
+    }
+  }
+  const nonEmpty = raw.filter((message) => message.content.trim().length > 0);
+  let start = 0;
+  while (start < nonEmpty.length && nonEmpty[start].role === "assistant") {
+    start++;
+  }
+  let end = nonEmpty.length;
+  while (end > start && nonEmpty[end - 1].role === "user") {
+    end--;
+  }
+  const bounded = nonEmpty.slice(start, end);
+  const merged = [];
+  for (const message of bounded) {
+    const previous = merged[merged.length - 1];
+    if (previous !== void 0 && previous.role === message.role) {
+      previous.content = `${previous.content}
+
+${message.content}`;
+    } else {
+      merged.push({ ...message });
+    }
+  }
+  return merged;
+}
+function buildSummarizeText(lines, tailStart) {
+  const parts = [];
+  for (const line of lines.slice(0, tailStart)) {
+    if (line.type === "summary") {
+      parts.push(`Summary of earlier conversation:
+${line.content}`);
+    } else {
+      parts.push(`${line.role === "user" ? "User" : "Assistant"}: ${line.content}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function truncateTurn(content, maxBytes) {
+  if (Buffer.byteLength(content) <= maxBytes) {
+    return content;
+  }
+  let sliced = content.slice(0, maxBytes - TRUNCATION_MARKER.length);
+  while (Buffer.byteLength(sliced) > maxBytes - TRUNCATION_MARKER.length) {
+    sliced = sliced.slice(0, Math.floor(sliced.length * 0.9));
+  }
+  return sliced + TRUNCATION_MARKER;
+}
 
 // src/x402/errors.ts
 var X402PreflightError = class extends Error {
@@ -2113,6 +2869,29 @@ var LEDGER_GC_INTERVAL_MS = 60 * 60 * 1e3;
 var LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var MAX_PAID_AGE_MS = 24 * 60 * 60 * 1e3;
 var SIG_PATH_TIMEOUT_MS = 60 * 1e3;
+var SESSION_SUMMARIZE_SYSTEM = "Summarize the following conversation between a user and an assistant so the conversation can continue with your summary standing in for the older turns. Preserve facts, decisions, names, numbers, constraints, and open questions. Reply with the summary only.";
+function buildUserRecord(data, fileName) {
+  if (fileName === void 0) {
+    return data;
+  }
+  const placeholder = `[file input: ${fileName}]`;
+  return data.length > 0 ? `${data}
+${placeholder}` : placeholder;
+}
+function buildAssistantRecord(output) {
+  let filePaths = [];
+  if (output.filePaths !== void 0 && output.filePaths.length > 0) {
+    filePaths = output.filePaths;
+  } else if (output.filePath !== void 0) {
+    filePaths = [output.filePath];
+  }
+  if (filePaths.length === 0) {
+    return output.data;
+  }
+  const placeholders = filePaths.map((path) => `[file result: ${basename(path)}]`).join("\n");
+  return output.data.length > 0 ? `${output.data}
+${placeholders}` : placeholders;
+}
 function resolveJobPrice(tags, skills) {
   const skill = skills.route(tags);
   return skill?.priceSubunits ?? 0;
@@ -2229,7 +3008,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, irohTransport, identity, blossomTransport) {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}, healthMonitor, irohTransport, identity, blossomTransport, sessionStore) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
@@ -2240,6 +3019,7 @@ var AgentRuntime = class {
     this.irohTransport = irohTransport;
     this.identity = identity;
     this.blossomTransport = blossomTransport;
+    this.sessionStore = sessionStore;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -2287,6 +3067,102 @@ var AgentRuntime = class {
    * the operator's API key.
    */
   freeLlmLimiters = createFreeLlmLimiterSet();
+  /**
+   * Whether a job takes the session path: session ref present (transport only
+   * populates it for NIP-44-encrypted requests) AND the matched skill opted in
+   * (`context: true` - llm or dynamic-script mode) AND a session store is
+   * wired. Everything else processes stateless - deterministically, never
+   * implicitly per-pubkey.
+   */
+  resolveJobSession(job, skill) {
+    if (job.session === void 0 || this.sessionStore === void 0 || skill === null || skill === void 0 || skill.mode !== "llm" && skill.mode !== "dynamic-script" || skill.context !== true) {
+      return null;
+    }
+    return {
+      store: this.sessionStore,
+      customerId: job.customerId,
+      sessionId: job.session.id,
+      skill
+    };
+  }
+  /**
+   * Run a session-path execution: history load -> execute -> append, under the
+   * session mutex. Lock-order invariant: callers already hold their `pLimit`
+   * slot (live and recovery paths alike), so a mutex holder never waits for a
+   * slot. The mutex is released after the append, BEFORE result seeding and
+   * delivery - it never spans that network I/O (the execute callback's own LLM
+   * call, and the compaction summarize below, are bounded by the LLM HTTP
+   * timeout). Appends only happen on execution success; a failed job leaves
+   * the transcript untouched.
+   */
+  async runSessionExchange(params) {
+    const { store, customerId, sessionId, skill } = params.session;
+    const release = await store.acquire(customerId, sessionId);
+    try {
+      const opened = store.open(
+        customerId,
+        sessionId,
+        params.excludeOwnTurns === true ? params.jobId : void 0
+      );
+      let messages = opened.messages;
+      if (!opened.stateless && opened.compactionNeeded && opened.summarizeText !== void 0) {
+        messages = await this.compactSession({
+          store,
+          customerId,
+          sessionId,
+          skill,
+          summarizeText: opened.summarizeText,
+          fallbackMessages: messages,
+          signal: params.signal,
+          log: params.log,
+          jobId: params.jobId
+        });
+      }
+      const history = opened.stateless || messages.length === 0 ? void 0 : messages;
+      const output = await params.execute(history);
+      if (!opened.stateless) {
+        store.appendExchange(customerId, sessionId, {
+          jobId: params.jobId,
+          capability: skill.name,
+          userContent: params.userRecord,
+          assistantContent: buildAssistantRecord(output),
+          skipRoles: opened.recordedRoles
+        });
+      }
+      return output;
+    } finally {
+      release();
+    }
+  }
+  /**
+   * Compaction: one summarize call on the invoked skill's own resolved LLM,
+   * then an atomic rewrite to `[summary, ...kept tail]`. Any failure - thrown
+   * error, missing client, or an empty-string summary (rewriting on it would
+   * silently vaporize the summarized context, since empty messages are skipped
+   * at replay) - counts a strike and processes this job with the uncompacted
+   * history; after 2 consecutive strikes the store force-truncates without a
+   * summary so a small-window model can never permanently brick a session.
+   */
+  async compactSession(params) {
+    const { store, customerId, sessionId, skill } = params;
+    try {
+      const llm = this.skillCtx.getLlm?.(skill.llmOverride) ?? this.skillCtx.llm;
+      if (llm === void 0) {
+        throw new Error("no LLM client available for session compaction");
+      }
+      const summary = await llm.complete(
+        SESSION_SUMMARIZE_SYSTEM,
+        params.summarizeText,
+        params.signal
+      );
+      return store.compact(customerId, sessionId, summary);
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      params.log(`[${params.jobId.slice(0, 8)}] Session compaction failed: ${detail}`);
+      const outcome = store.compactionFailed(customerId, sessionId);
+      return outcome.forced && outcome.messages !== void 0 ? outcome.messages : params.fallbackMessages;
+    }
+  }
   /**
    * Inspect an error thrown by `skill.execute()` and, when it carries a
    * billing/invalid signal from the LLM provider, flip the matching
@@ -2431,6 +3307,7 @@ var AgentRuntime = class {
   async run() {
     const log = this.callbacks.onLog ?? console.log;
     this.ledger.pruneOldEntries(LEDGER_RETENTION_MS);
+    this.sessionStore?.init();
     await this.recoverPendingJobs();
     this.recoveryInterval = setInterval(
       () => this.recoverPendingJobs().catch((e) => log(`Recovery error: ${e}`)),
@@ -2442,6 +3319,11 @@ var AgentRuntime = class {
       } catch (e) {
         log(`GC error: ${e.message}`);
       }
+      try {
+        this.sessionStore?.gc();
+      } catch (e) {
+        log(`Session GC error: ${e.message}`);
+      }
       this.cleanupRateLimits();
       if (!this.transport.isHealthy()) {
         log("Warning: no events received in 30+ minutes. Check relay connectivity.");
@@ -2466,6 +3348,15 @@ var AgentRuntime = class {
       const isPaid = matched ? matched.priceSubunits > 0 : false;
       const customerLimiter = isPaid ? this.paidCustomerLimiter : this.freeCustomerLimiter;
       const globalLimiter = isPaid ? this.paidGlobalLimiter : this.freeGlobalLimiter;
+      const jobSession = this.resolveJobSession(job, matched);
+      if (jobSession && jobSession.store.admittedCount(jobSession.customerId, jobSession.sessionId) >= SESSION_MAX_CONCURRENT_JOBS) {
+        this.transport.sendFeedback(job, {
+          type: "error",
+          message: "Session busy - wait for the previous message to finish, then retry."
+        }).catch(() => {
+        });
+        return;
+      }
       if (!customerLimiter.peek(job.customerId).allowed) {
         this.transport.sendFeedback(job, { type: "error", message: "Rate limited, try again later" }).catch(() => {
         });
@@ -2505,11 +3396,17 @@ var AgentRuntime = class {
       this.callbacks.onJobReceived?.(job);
       this.inFlight.add(job.jobId);
       this.pending++;
+      if (jobSession) {
+        jobSession.store.admitLive(jobSession.customerId, jobSession.sessionId);
+      }
       this.limit(() => this.processJob(job)).catch((e) => {
         this.callbacks.onJobError?.(job.jobId, e.message);
       }).finally(() => {
         this.inFlight.delete(job.jobId);
         this.pending--;
+        if (jobSession) {
+          jobSession.store.releaseLive(jobSession.customerId, jobSession.sessionId);
+        }
       });
     });
     log("Agent runtime started. Listening for jobs...");
@@ -2704,68 +3601,82 @@ var AgentRuntime = class {
       throw new Error("No skill matched for tags: " + job.tags.join(", "));
     }
     log(`[${job.jobId.slice(0, 8)}] Executing skill: ${skill.name}`);
-    let output;
     const budgetMs = this.resolveExecutionBudgetMs(skill);
-    let budgetExceeded = false;
-    const execAbort = new AbortController();
-    const onOuterAbort = () => execAbort.abort();
-    if (signal) {
-      if (signal.aborted) {
-        execAbort.abort();
-      } else {
-        signal.addEventListener("abort", onOuterAbort);
-      }
-    }
-    let budgetTimer;
-    try {
-      const execPromise = skill.execute(
-        {
-          data: inputFile?.inlineText ?? job.input,
-          inputType: job.inputType,
-          tags: job.tags,
-          jobId: job.jobId,
-          filePath: inputFile?.filePath
-        },
-        { ...this.skillCtx, signal: execAbort.signal }
-      );
-      execPromise.catch(() => {
-      });
-      if (budgetMs > 0) {
-        output = await Promise.race([
-          execPromise,
-          new Promise((_resolve, reject) => {
-            budgetTimer = setTimeout(() => {
-              budgetExceeded = true;
-              execAbort.abort();
-              reject(new ExecutionBudgetExceededError(budgetMs));
-            }, budgetMs);
-          })
-        ]);
-      } else {
-        output = await execPromise;
-      }
-    } catch (err) {
-      if (budgetExceeded) {
-        log(`[${job.jobId.slice(0, 8)}] Execution exceeded budget (${budgetMs / 1e3}s)`);
-        throw new ExecutionBudgetExceededError(budgetMs);
-      }
-      const flippedToUnhealthy = this.markHealthFromExecuteError(skill, err, log, job.jobId);
-      if (flippedToUnhealthy) {
-        throw new AgentUnavailableError();
-      }
-      throw err;
-    } finally {
-      if (budgetTimer) {
-        clearTimeout(budgetTimer);
-      }
+    const jobSession = this.resolveJobSession(job, skill);
+    const runExecution = async (history) => {
+      let budgetExceeded = false;
+      const execAbort = new AbortController();
+      const onOuterAbort = () => execAbort.abort();
       if (signal) {
-        signal.removeEventListener("abort", onOuterAbort);
+        if (signal.aborted) {
+          execAbort.abort();
+        } else {
+          signal.addEventListener("abort", onOuterAbort);
+        }
       }
-      if (inputFile) {
-        await inputFile.cleanup().catch(() => {
+      let budgetTimer;
+      try {
+        const execPromise = skill.execute(
+          {
+            data: inputFile?.inlineText ?? job.input,
+            inputType: job.inputType,
+            tags: job.tags,
+            jobId: job.jobId,
+            filePath: inputFile?.filePath,
+            history,
+            ...jobSession !== null ? { sessionId: jobSession.sessionId } : {}
+          },
+          { ...this.skillCtx, signal: execAbort.signal }
+        );
+        execPromise.catch(() => {
         });
+        if (budgetMs > 0) {
+          return await Promise.race([
+            execPromise,
+            new Promise((_resolve, reject) => {
+              budgetTimer = setTimeout(() => {
+                budgetExceeded = true;
+                execAbort.abort();
+                reject(new ExecutionBudgetExceededError(budgetMs));
+              }, budgetMs);
+            })
+          ]);
+        }
+        return await execPromise;
+      } catch (err) {
+        if (budgetExceeded) {
+          log(`[${job.jobId.slice(0, 8)}] Execution exceeded budget (${budgetMs / 1e3}s)`);
+          throw new ExecutionBudgetExceededError(budgetMs);
+        }
+        const flippedToUnhealthy = this.markHealthFromExecuteError(skill, err, log, job.jobId);
+        if (flippedToUnhealthy) {
+          throw new AgentUnavailableError();
+        }
+        throw err;
+      } finally {
+        if (budgetTimer) {
+          clearTimeout(budgetTimer);
+        }
+        if (signal) {
+          signal.removeEventListener("abort", onOuterAbort);
+        }
+        if (inputFile) {
+          await inputFile.cleanup().catch(() => {
+          });
+        }
       }
-    }
+    };
+    const output = jobSession === null ? await runExecution() : await this.runSessionExchange({
+      session: jobSession,
+      jobId: job.jobId,
+      userRecord: buildUserRecord(
+        inputFile?.inlineText ?? job.input,
+        inputFile?.filePath !== void 0 ? job.attachment?.name ?? "attachment" : void 0
+      ),
+      signal,
+      log,
+      execute: runExecution
+    });
     const { attachments, deliveredContent } = await this.buildResultAttachment(
       job.jobId,
       output,
@@ -3272,8 +4183,52 @@ var AgentRuntime = class {
     }
     throw new PaymentTimeoutError();
   }
+  /**
+   * Session refs of pending `paid` entries, for the recovery pre-pass. `paid`
+   * only: `executed` entries do no session work and the status-predicate
+   * release would drop them at the first re-check anyway. Applies the same
+   * session-path scope as live intake (encrypted-only decode + routed skill
+   * with `context: true`, llm or dynamic-script mode) - a context-off or x402
+   * entry parked for hours must not pin session slots for a job that never
+   * touches the transcript.
+   */
+  collectRecoverySessionRefs(pending) {
+    const refs = [];
+    for (const entry of pending) {
+      if (entry.status !== "paid" || entry.raw_event_json === void 0) {
+        continue;
+      }
+      const skill = this.skills.route(entry.tags);
+      if (!skill || skill.mode !== "llm" && skill.mode !== "dynamic-script" || skill.context !== true) {
+        continue;
+      }
+      try {
+        const rawEvent = JSON.parse(entry.raw_event_json);
+        const encrypted = rawEvent.tags?.some((tag) => tag[0] === "encrypted" && tag[1] === "nip44") === true;
+        if (!encrypted || typeof rawEvent.content !== "string") {
+          continue;
+        }
+        const session = decodeJobPayload(rawEvent.content).session;
+        if (session !== void 0) {
+          refs.push({
+            jobId: entry.job_id,
+            customerId: entry.customer_id,
+            sessionId: session.id
+          });
+        }
+      } catch {
+      }
+    }
+    return refs;
+  }
   async recoverPendingJobs() {
     const pending = this.ledger.pendingJobs().filter((e) => !this.inFlight.has(e.job_id));
+    if (this.sessionStore !== void 0) {
+      this.sessionStore.syncRecoveryRegistrations(
+        this.collectRecoverySessionRefs(pending),
+        (jobId) => this.ledger.getStatus(jobId) === "paid"
+      );
+    }
     if (pending.length === 0) {
       return;
     }
@@ -3304,7 +4259,7 @@ var AgentRuntime = class {
     for (const entry of pending) {
       const ageMs = (Math.floor(Date.now() / 1e3) - entry.created_at) * 1e3;
       const expired = ageMs > MAX_PAID_AGE_MS;
-      const exhaustedRetries = entry.retry_count >= this.config.recoveryMaxRetries;
+      const exhaustedRetries = entry.status === "paid" && entry.retry_count >= this.config.recoveryMaxRetries;
       if (expired || exhaustedRetries) {
         this.ledger.markFailed(entry.job_id);
         const reason = expired ? "Job permanently failed: agent did not recover within 24 hours" : "Job permanently failed after maximum retries";
@@ -3444,14 +4399,17 @@ var AgentRuntime = class {
           }
         }
         let recoveryInputFile;
+        let recoverySession;
         try {
           const encrypted = rawEvent.tags?.some(
             (tag) => tag[0] === "encrypted" && tag[1] === "nip44"
           );
           const iTag = rawEvent.tags?.find((tag) => tag[0] === "i");
           const rawInput = encrypted ? rawEvent.content : iTag?.[1] ?? rawEvent.content;
+          const decodedPayload = decodeJobPayload(rawInput);
+          recoverySession = encrypted ? decodedPayload.session : void 0;
           recoveryInputFile = await this.resolveInputFile(
-            decodeJobPayload(rawInput).attachment,
+            decodedPayload.attachment,
             entry.customer_id,
             recoveryAbort.signal
           );
@@ -3461,46 +4419,64 @@ var AgentRuntime = class {
           return;
         }
         const recoveryBudgetMs = this.resolveExecutionBudgetMs(skill);
-        let budgetTimer;
-        let output;
-        try {
-          const execPromise = skill.execute(
-            {
-              data: recoveryInputFile?.inlineText ?? entry.input,
-              inputType: entry.input_type,
-              tags: entry.tags,
-              jobId: entry.job_id,
-              filePath: recoveryInputFile?.filePath
-            },
-            { ...this.skillCtx, signal: recoveryAbort.signal }
-          );
-          execPromise.catch(() => {
-          });
-          if (recoveryBudgetMs > 0) {
-            output = await Promise.race([
-              execPromise,
-              new Promise((_resolve, reject) => {
-                budgetTimer = setTimeout(() => {
-                  recoveryAbort.abort();
-                  reject(new ExecutionBudgetExceededError(recoveryBudgetMs));
-                }, recoveryBudgetMs);
-              })
-            ]);
-          } else {
-            output = await execPromise;
-          }
-        } catch (err) {
-          this.markHealthFromExecuteError(skill, err, log, entry.job_id);
-          throw err;
-        } finally {
-          if (budgetTimer) {
-            clearTimeout(budgetTimer);
-          }
-          if (recoveryInputFile) {
-            await recoveryInputFile.cleanup().catch(() => {
+        const recoveryJobSession = this.resolveJobSession(
+          { session: recoverySession, customerId: entry.customer_id },
+          skill
+        );
+        const runRecoveryExecution = async (history) => {
+          let budgetTimer;
+          try {
+            const execPromise = skill.execute(
+              {
+                data: recoveryInputFile?.inlineText ?? entry.input,
+                inputType: entry.input_type,
+                tags: entry.tags,
+                jobId: entry.job_id,
+                filePath: recoveryInputFile?.filePath,
+                history,
+                ...recoveryJobSession !== null ? { sessionId: recoveryJobSession.sessionId } : {}
+              },
+              { ...this.skillCtx, signal: recoveryAbort.signal }
+            );
+            execPromise.catch(() => {
             });
+            if (recoveryBudgetMs > 0) {
+              return await Promise.race([
+                execPromise,
+                new Promise((_resolve, reject) => {
+                  budgetTimer = setTimeout(() => {
+                    recoveryAbort.abort();
+                    reject(new ExecutionBudgetExceededError(recoveryBudgetMs));
+                  }, recoveryBudgetMs);
+                })
+              ]);
+            }
+            return await execPromise;
+          } catch (err) {
+            this.markHealthFromExecuteError(skill, err, log, entry.job_id);
+            throw err;
+          } finally {
+            if (budgetTimer) {
+              clearTimeout(budgetTimer);
+            }
+            if (recoveryInputFile) {
+              await recoveryInputFile.cleanup().catch(() => {
+              });
+            }
           }
-        }
+        };
+        const output = recoveryJobSession === null ? await runRecoveryExecution() : await this.runSessionExchange({
+          session: recoveryJobSession,
+          jobId: entry.job_id,
+          userRecord: buildUserRecord(
+            recoveryInputFile?.inlineText ?? entry.input,
+            recoveryInputFile?.filePath !== void 0 ? "attachment" : void 0
+          ),
+          signal: recoveryAbort.signal,
+          log,
+          execute: runRecoveryExecution,
+          excludeOwnTurns: true
+        });
         const { attachments: resultAttachments, deliveredContent } = await this.buildResultAttachment(
           entry.job_id,
           output,
@@ -3615,6 +4591,9 @@ var SkillRegistry = class {
     return this.skills;
   }
 };
+
+// src/skill/loader.ts
+init_llm();
 var StaticFileSkill = class {
   name;
   description;
@@ -3644,6 +4623,7 @@ var StaticFileSkill = class {
       priceSubunits: BigInt(Math.round(params.priceSubunits)),
       asset: params.asset,
       outputFilePath: params.outputFilePath,
+      skillDir: params.dir,
       image: params.image,
       imageFile: params.imageFile
     });
@@ -3709,6 +4689,7 @@ var DynamicScriptSkill = class {
   inputMime;
   inputText;
   outputMime;
+  context;
   inner;
   constructor(params) {
     this.name = params.name;
@@ -3720,6 +4701,7 @@ var DynamicScriptSkill = class {
     this.imageFile = params.imageFile;
     this.dir = params.dir;
     this.llmOverride = params.llmOverride;
+    this.context = params.context;
     this.inputMime = params.inputMime;
     this.inputText = params.inputText;
     this.outputMime = params.outputMime;
@@ -3735,7 +4717,8 @@ var DynamicScriptSkill = class {
       scriptEnv: params.scriptEnv,
       image: params.image,
       imageFile: params.imageFile,
-      outputMime: params.outputMime
+      outputMime: params.outputMime,
+      context: params.context
     });
   }
   async execute(input, ctx) {
@@ -3750,11 +4733,12 @@ var ScriptSkill = class {
   asset;
   mode = "llm";
   llmOverride;
+  context;
   image;
   imageFile;
   dir;
   inner;
-  constructor(name, description, capabilities, priceSubunits, assetOrImage, imageOrImageFile, imageFileOrDir, dirOrPrompt, promptOrTools, toolsOrRounds, rounds, llmOverride) {
+  constructor(name, description, capabilities, priceSubunits, assetOrImage, imageOrImageFile, imageFileOrDir, dirOrPrompt, promptOrTools, toolsOrRounds, rounds, llmOverride, context) {
     let asset;
     let image;
     let imageFile;
@@ -3785,6 +4769,7 @@ var ScriptSkill = class {
     this.priceSubunits = priceSubunits;
     this.asset = asset;
     this.llmOverride = llmOverride;
+    this.context = context;
     this.image = image;
     this.imageFile = imageFile;
     this.dir = skillDir;
@@ -3799,6 +4784,7 @@ var ScriptSkill = class {
       tools,
       maxToolRounds,
       llmOverride,
+      context,
       image,
       imageFile
     });
@@ -3859,11 +4845,23 @@ var X402Skill = class {
 };
 
 // src/skill/loader.ts
+function scopeLlmKeys(scriptEnv, declaredProvider) {
+  if (scriptEnv === void 0) {
+    return void 0;
+  }
+  const env = { ...scriptEnv };
+  for (const descriptor of listLlmProviders()) {
+    if (descriptor.id !== declaredProvider) {
+      delete env[descriptor.envVar];
+    }
+  }
+  return env;
+}
 function buildCliSkill(parsed, entryPath, scriptEnv) {
   let safeImageFile = parsed.imageFile;
-  if (safeImageFile !== void 0 && resolveInsidePath(entryPath, safeImageFile) === null) {
+  if (safeImageFile !== void 0 && resolveInsidePathReal(entryPath, safeImageFile) === null) {
     console.warn(
-      `SKILL.md "${parsed.name}": ignoring "image_file" that resolves outside the skill directory: ${safeImageFile}`
+      `SKILL.md "${parsed.name}": ignoring "image_file" that resolves outside the skill directory (directly or via symlink): ${safeImageFile}`
     );
     safeImageFile = void 0;
   }
@@ -3882,7 +4880,8 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         parsed.systemPrompt,
         parsed.tools,
         parsed.maxToolRounds,
-        parsed.llmOverride
+        parsed.llmOverride,
+        parsed.context
       );
       break;
     case "static-file": {
@@ -3891,7 +4890,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
           `SKILL.md "${parsed.name}": internal error - outputFile missing for mode 'static-file'`
         );
       }
-      const outputFilePath = resolveInsidePath(entryPath, parsed.outputFile);
+      const outputFilePath = resolveInsidePathReal(entryPath, parsed.outputFile);
       if (!outputFilePath) {
         throw new Error(
           `SKILL.md "${parsed.name}": "output_file" must stay inside the skill directory`
@@ -3918,7 +4917,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
           `SKILL.md "${parsed.name}": internal error - script missing for mode '${parsed.mode}'`
         );
       }
-      const scriptPath = resolveInsidePath(entryPath, parsed.script);
+      const scriptPath = resolveInsidePathReal(entryPath, parsed.script);
       if (!scriptPath) {
         throw new Error(`SKILL.md "${parsed.name}": "script" must stay inside the skill directory`);
       }
@@ -3931,7 +4930,7 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         scriptPath,
         scriptArgs: parsed.scriptArgs,
         scriptTimeoutMs: parsed.scriptTimeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS,
-        scriptEnv,
+        scriptEnv: scopeLlmKeys(scriptEnv, parsed.llmOverride?.provider),
         image: parsed.image,
         imageFile: safeImageFile,
         dir: entryPath,
@@ -3941,7 +4940,8 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         ...scriptParams,
         outputMime: parsed.outputMime,
         inputMime: parsed.inputMime,
-        inputText: parsed.inputText
+        inputText: parsed.inputText,
+        context: parsed.context
       }) : new StaticScriptSkill(scriptParams);
       break;
     }
@@ -4059,10 +5059,12 @@ var NostrTransport = class {
         const rawInput = encrypted ? event.content : iTag?.[1] ?? event.content;
         let input;
         let attachment;
+        let session;
         try {
           const decoded = decodeJobPayload(rawInput);
           input = decoded.text ?? "";
           attachment = decoded.attachment;
+          session = encrypted ? decoded.session : void 0;
         } catch {
           return;
         }
@@ -4075,7 +5077,8 @@ var NostrTransport = class {
           bid: parseBidTag(bidTag?.[1]),
           encrypted,
           rawEvent: event,
-          attachment
+          attachment,
+          session
         });
       }
     );
@@ -5158,6 +6161,9 @@ async function cmdStart(nameArg, options = {}) {
   }
   const scriptEnv = { ...process.env };
   delete scriptEnv.ELISYM_PASSPHRASE;
+  if (scriptEnv.SOLANA_RPC_URL !== void 0 && !isPublicSolanaRpcUrl(scriptEnv.SOLANA_RPC_URL)) {
+    delete scriptEnv.SOLANA_RPC_URL;
+  }
   const llmKeys = loaded.secrets.llm_api_keys ?? {};
   for (const descriptor of listLlmProviders()) {
     const secretValue = llmKeys[descriptor.id];
@@ -5456,6 +6462,7 @@ async function cmdStart(nameArg, options = {}) {
     const url = await uploadOrReuse(
       cacheKey,
       absPath,
+      skillRoot,
       mediaCache,
       client.blossom,
       identity,
@@ -5546,12 +6553,12 @@ async function cmdStart(nameArg, options = {}) {
       continue;
     }
     const type = event.tags.find((tag) => tag[0] === "policy_type")?.[1];
-    if (!type) {
+    if (!type || dTag !== `${POLICY_D_TAG_PREFIX}${type}`) {
       continue;
     }
     try {
       await client.policies.deletePolicy(identity, type);
-      console.log(`  Removed stale policy: ${type}`);
+      console.log(`  Removed stale policy: ${sanitizeForTerminal(type)}`);
     } catch {
     }
   }
@@ -5569,6 +6576,9 @@ async function cmdStart(nameArg, options = {}) {
       ...skill.inputMime ? { inputMime: skill.inputMime } : {},
       ...skill.inputText ? { inputText: skill.inputText } : {},
       ...skill.outputMime ? { outputMime: skill.outputMime } : {},
+      // Conversation-context flag: clients gate chat affordances (session-carrying
+      // sends) on it. Strict true only - the read side coerces anything else away.
+      ...skill.context === true ? { context: true } : {},
       payment: solanaAddress ? {
         chain: "solana",
         network: walletNetwork,
@@ -5638,9 +6648,9 @@ async function cmdStart(nameArg, options = {}) {
       }
       try {
         const card = JSON.parse(ev.content);
-        if (card.name) {
+        if (card.name && toDTag(card.name) === dTag) {
           await client.discovery.deleteCapability(identity, card.name);
-          console.log(`  Removed stale capability: ${card.name}`);
+          console.log(`  Removed stale capability: ${sanitizeForTerminal(card.name)}`);
         }
       } catch {
       }
@@ -5665,6 +6675,10 @@ async function cmdStart(nameArg, options = {}) {
   if (x402Skills.length > 0) {
     await ensureGitignoreHasX402Entries(dirname(loaded.dir));
   }
+  const hasContextSkills = registry.all().some((skill) => skill.context === true);
+  if (hasContextSkills) {
+    await ensureGitignoreHasSessionsEntry(dirname(loaded.dir));
+  }
   const runtimeConfig = {
     paymentTimeoutSecs: DEFAULTS.PAYMENT_EXPIRY_SECS,
     maxConcurrentJobs: MAX_CONCURRENT_JOBS,
@@ -5710,6 +6724,10 @@ async function cmdStart(nameArg, options = {}) {
     diagLog("LLM health monitor armed (lazy recovery, 5min interval).");
   }
   const blossomTransport = createBlossomTransport({ blossom: client.blossom, identity });
+  const sessionStore = hasContextSkills ? new SessionStore(loaded.dir, diagLog) : void 0;
+  if (sessionStore) {
+    diagLog("Conversation sessions enabled (context: true skills present).");
+  }
   const runtime = new AgentRuntime(
     transport,
     registry,
@@ -5743,7 +6761,8 @@ async function cmdStart(nameArg, options = {}) {
     healthMonitor,
     irohTransport,
     identity,
-    blossomTransport
+    blossomTransport,
+    sessionStore
   );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();
@@ -5768,6 +6787,14 @@ function stripRpcSecrets(raw) {
     return "[unparseable RPC URL]";
   }
 }
+function isPublicSolanaRpcUrl(raw) {
+  try {
+    const parsed = new URL(raw);
+    return PUBLIC_SOLANA_RPC_HOSTS.has(parsed.hostname) && !parsed.username && !parsed.password && !parsed.search && (parsed.pathname === "" || parsed.pathname === "/");
+  } catch {
+    return false;
+  }
+}
 function redactRpcUrlsInText(text) {
   return text.replace(/https?:\/\/[^\s)'"]+/g, (url) => stripRpcSecrets(url));
 }
@@ -5783,7 +6810,15 @@ async function resolveMediaField(value, agentDir, cache, blossom, identity, onCa
     console.warn(`  ! Skipping media field "${value}": path must stay inside the agent directory.`);
     return void 0;
   }
-  return uploadOrReuse(value, absPath, cache, blossom, identity, () => onCacheUpdate(true));
+  return uploadOrReuse(
+    value,
+    absPath,
+    agentDir,
+    cache,
+    blossom,
+    identity,
+    () => onCacheUpdate(true)
+  );
 }
 function resolveInsideAgentDir(value, agentDir) {
   const agentRoot = resolve(agentDir);
@@ -5794,14 +6829,34 @@ function resolveInsideAgentDir(value, agentDir) {
   }
   return candidate;
 }
-async function uploadOrReuse(cacheKey, absPath, cache, blossom, identity, onCacheUpdate) {
+function realpathInsideDir(absPath, rootDir) {
+  try {
+    const realRoot = realpathSync(resolve(rootDir));
+    const realCandidate = realpathSync(absPath);
+    const rel = relative(realRoot, realCandidate);
+    if (rel === "" || rel.startsWith("..") || rel.includes(`..${sep}`)) {
+      return null;
+    }
+    return realCandidate;
+  } catch {
+    return null;
+  }
+}
+async function uploadOrReuse(cacheKey, absPath, containRoot, cache, blossom, identity, onCacheUpdate) {
+  const realPath = realpathInsideDir(absPath, containRoot);
+  if (realPath === null) {
+    console.warn(
+      `  ! Skipping upload of ${basename(absPath)}: unreadable or escapes its directory.`
+    );
+    return void 0;
+  }
   try {
-    const cached = await lookupCachedUrl(cache, cacheKey, absPath);
+    const cached = await lookupCachedUrl(cache, cacheKey, realPath);
     if (cached) {
       return cached;
     }
-    console.log(`  Uploading ${basename(absPath)}...`);
-    const data = readFileSync(absPath);
+    console.log(`  Uploading ${basename(realPath)}...`);
+    const data = readFileSync(realPath);
     const sha256 = createHash("sha256").update(data).digest("hex");
     const blob = new Blob([data], { type: mimeFromPath(absPath) });
     const descriptor = await blossom.upload(identity, blob);