@elisym/cli 0.23.2 → 0.25.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, KIND_EXTERNAL_IDENTITIES, POLICY_D_TAG_PREFIX, KIND_LONG_FORM_ARTICLE, jobRequestKind, DEFAULT_KIND_OFFSET, toDTag, DEFAULTS, createBlossomTransport, verifyAgentIdentities, generateSolanaWallet, getProtocolConfig, getProtocolProgramId, calculateProtocolFee, LIMITS, makeCensor, DEFAULT_REDACT_PATHS, POLICY_T_TAG, SESSION_ID_REGEX, createSlidingWindowLimiter, utf8ByteLength, readAcceptedTransports, decodeJobPayload, BoundedSet, KIND_JOB_FEEDBACK, GITHUB_USERNAME_REGEX, X_USERNAME_REGEX, normalizeNip05Identifier, splitNip05Identifier, encodeSecretKeyBase58, NATIVE_SOL, GIST_ID_REGEX, TWEET_ID_REGEX } 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';
@@ -52,9 +52,9 @@ function sleepWithSignal(ms, signal) {
     return Promise.reject(createAbortError());
   }
   if (!signal) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+    return new Promise((resolve4) => setTimeout(resolve4, ms));
   }
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const cleanup = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", onAbort);
@@ -65,7 +65,7 @@ function sleepWithSignal(ms, signal) {
     };
     const timer = setTimeout(() => {
       cleanup();
-      resolve3();
+      resolve4();
     }, ms);
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -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);
@@ -1415,6 +1442,538 @@ var init_init = __esm({
     init_llm();
   }
 });
+var IDENTITY_PLATFORMS = ["github", "x", "website"];
+var X_PROOF_URL_HOSTS = /* @__PURE__ */ new Set([
+  "x.com",
+  "www.x.com",
+  "mobile.x.com",
+  "twitter.com",
+  "www.twitter.com",
+  "mobile.twitter.com"
+]);
+function githubProofText(npub) {
+  return `Verifying that I control the following Nostr public key: ${npub}`;
+}
+function xProofText(npub) {
+  return `Verifying my account on nostr My Public Key: "${npub}"`;
+}
+function websiteNostrJson(local, pubkeyHex) {
+  return JSON.stringify({ names: { [local]: pubkeyHex } }, null, 2);
+}
+function parseIdentityPlatform(raw) {
+  const lowered = raw.trim().toLowerCase();
+  const match = IDENTITY_PLATFORMS.find((platform) => platform === lowered);
+  if (match === void 0) {
+    throw new Error(`Unknown platform "${raw}". Expected github, x, or website.`);
+  }
+  return match;
+}
+function parseGithubProofInput(raw) {
+  const trimmed = raw.trim();
+  const bareId = trimmed.toLowerCase();
+  if (GIST_ID_REGEX.test(bareId)) {
+    return { proofId: bareId };
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" || url.hostname.toLowerCase() !== "gist.github.com") {
+    return null;
+  }
+  const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
+  const [userSegment, gistSegment] = segments;
+  if (userSegment === void 0 || gistSegment === void 0) {
+    return null;
+  }
+  const username = userSegment.toLowerCase();
+  const gistId = gistSegment.toLowerCase();
+  if (!GITHUB_USERNAME_REGEX.test(username) || !GIST_ID_REGEX.test(gistId)) {
+    return null;
+  }
+  return { proofId: gistId, username };
+}
+function parseXProofInput(raw) {
+  const trimmed = raw.trim();
+  if (TWEET_ID_REGEX.test(trimmed)) {
+    return { proofId: trimmed };
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" || !X_PROOF_URL_HOSTS.has(url.hostname.toLowerCase())) {
+    return null;
+  }
+  const segments = url.pathname.split("/").filter((segment) => segment.length > 0);
+  const [userSegment, statusLiteral, idSegment] = segments;
+  if (userSegment === void 0 || statusLiteral !== "status" || idSegment === void 0) {
+    return null;
+  }
+  const username = userSegment.toLowerCase();
+  if (!X_USERNAME_REGEX.test(username) || !TWEET_ID_REGEX.test(idSegment)) {
+    return null;
+  }
+  return { proofId: idSegment, username };
+}
+function buildIdentityClaimInputs(identities) {
+  const claims = [];
+  if (identities?.github !== void 0) {
+    claims.push({
+      platform: "github",
+      handle: identities.github.username,
+      proofId: identities.github.gist
+    });
+  }
+  if (identities?.x !== void 0) {
+    claims.push({ platform: "x", handle: identities.x.username, proofId: identities.x.tweet });
+  }
+  return claims;
+}
+function identitiesFromYaml(identities) {
+  const claims = [];
+  if (identities === void 0) {
+    return claims;
+  }
+  if (identities.github !== void 0) {
+    claims.push({
+      platform: "github",
+      handle: identities.github.username,
+      proofUrl: `https://gist.github.com/${encodeURIComponent(identities.github.username)}/${encodeURIComponent(identities.github.gist)}`
+    });
+  }
+  if (identities.x !== void 0) {
+    claims.push({
+      platform: "x",
+      handle: identities.x.username,
+      proofUrl: `https://x.com/${encodeURIComponent(identities.x.username)}/status/${encodeURIComponent(identities.x.tweet)}`
+    });
+  }
+  if (identities.website !== void 0) {
+    const identifier = normalizeNip05Identifier(identities.website);
+    if (identifier !== null) {
+      const { domain } = splitNip05Identifier(identifier);
+      claims.push({ platform: "website", handle: identifier, proofUrl: `https://${domain}` });
+    }
+  }
+  return claims;
+}
+async function createInquirerPrompter() {
+  const { default: inquirer } = await import('inquirer');
+  return {
+    async input(message) {
+      const { value } = await inquirer.prompt([{ type: "input", name: "value", message }]);
+      return String(value);
+    },
+    async confirm(message, defaultValue) {
+      const { value } = await inquirer.prompt([
+        { type: "confirm", name: "value", message, default: defaultValue }
+      ]);
+      return Boolean(value);
+    },
+    async select(message, choices) {
+      const { value } = await inquirer.prompt([{ type: "list", name: "value", message, choices }]);
+      return String(value);
+    }
+  };
+}
+function createDefaultPublisher(relays) {
+  const client = new ElisymClient({ relays });
+  return {
+    fetchExternalIdentityClaims: (pubkey) => client.discovery.fetchExternalIdentityClaims(pubkey),
+    publishExternalIdentities: (identity2, claims) => client.discovery.publishExternalIdentities(identity2, claims),
+    publishProfile: (identity2, name, about, picture, banner, nip05) => client.discovery.publishProfile(identity2, name, about, picture, banner, nip05),
+    close: () => client.close()
+  };
+}
+async function resolveAndLoadAgent(nameArg, cwd, prompter) {
+  let name = nameArg;
+  if (!name) {
+    const agents = await listAgents(cwd);
+    if (agents.length === 0) {
+      throw new Error("No agents found. Run `npx @elisym/cli init` first.");
+    }
+    name = await prompter.select(
+      "Select agent:",
+      agents.map((agent) => ({ name: `${agent.name} (${agent.source})`, value: agent.name }))
+    );
+  }
+  const passphrase = process.env.ELISYM_PASSPHRASE;
+  const loaded = await loadAgent(name, cwd, passphrase);
+  return { name, loaded };
+}
+function relaysFor(yaml) {
+  return yaml.relays.length > 0 ? yaml.relays : [...RELAYS];
+}
+async function resolvePreservedMediaUrl(configured, agentDir, cache, publishedUrl) {
+  if (!configured) {
+    return void 0;
+  }
+  if (/^https?:\/\//i.test(configured)) {
+    return configured;
+  }
+  const agentRoot = resolve(agentDir);
+  const candidate = resolve(agentRoot, configured);
+  const rel = relative(agentRoot, candidate);
+  if (rel === "" || rel.startsWith("..") || rel.includes(`..${sep}`)) {
+    return publishedUrl;
+  }
+  const cached = await lookupCachedUrl(cache, configured, candidate);
+  return cached ?? publishedUrl;
+}
+async function republishAgentProfile(publisher, identity2, agentName, agentDir, yaml) {
+  let publishedProfile;
+  try {
+    const published = await publisher.fetchExternalIdentityClaims(identity2.publicKey);
+    publishedProfile = published.profile;
+  } catch {
+  }
+  const mediaCache = await readMediaCache(agentDir);
+  const picture = await resolvePreservedMediaUrl(
+    yaml.picture,
+    agentDir,
+    mediaCache,
+    publishedProfile?.picture
+  );
+  const banner = await resolvePreservedMediaUrl(
+    yaml.banner,
+    agentDir,
+    mediaCache,
+    publishedProfile?.banner
+  );
+  const unresolved = [];
+  if (yaml.picture && picture === void 0) {
+    unresolved.push("picture");
+  }
+  if (yaml.banner && banner === void 0) {
+    unresolved.push("banner");
+  }
+  if (unresolved.length > 0) {
+    throw new Error(
+      `${unresolved.join(" and ")} carry-over unavailable (no media cache entry and no currently-published URL - the relay read may have failed), so republishing kind 0 would wipe it from the profile`
+    );
+  }
+  await publisher.publishProfile(
+    identity2,
+    yaml.display_name ?? agentName,
+    yaml.description ?? "",
+    picture,
+    banner,
+    yaml.identities?.website
+  );
+}
+async function sweepStaleIdentityClaims(discovery, identity2) {
+  try {
+    const published = await discovery.fetchExternalIdentityClaims(identity2.publicKey);
+    const staleClaims = published.identities.filter((claim) => claim.platform !== "website");
+    if (staleClaims.length === 0) {
+      return false;
+    }
+    await discovery.publishExternalIdentities(identity2, []);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promptGithubLink(loaded, npub, prompter) {
+  console.log(
+    "\n  1. Create a PUBLIC gist (https://gist.github.com/new) containing ONLY this\n     single line (the proof statement - a standard NIP-39 text that any\n     Nostr client can verify; do not paste these instructions):"
+  );
+  console.log(`
+     ${githubProofText(npub)}
+`);
+  console.log("  2. Paste the gist URL (or its id) below.\n");
+  const rawProof = await prompter.input("Gist URL or id:");
+  const parsed = parseGithubProofInput(rawProof);
+  if (parsed === null) {
+    throw new Error("Expected a gist URL (https://gist.github.com/<user>/<id>) or a hex gist id.");
+  }
+  let username = parsed.username;
+  if (username === void 0) {
+    const rawUsername = await prompter.input("GitHub username:");
+    username = rawUsername.trim().toLowerCase();
+  }
+  if (!GITHUB_USERNAME_REGEX.test(username)) {
+    throw new Error(`Invalid GitHub username: "${username}" (alphanumeric or hyphen, 1-39 chars).`);
+  }
+  return {
+    nextIdentities: {
+      ...loaded.yaml.identities,
+      github: { username, gist: parsed.proofId }
+    }
+  };
+}
+async function promptXLink(loaded, npub, prompter) {
+  console.log(
+    "\n  1. Post a tweet whose text is ONLY this line, including the double quotes\n     (the proof statement - a standard NIP-39 text; the account you post\n     from becomes the linked identity):"
+  );
+  console.log(`
+     ${xProofText(npub)}
+`);
+  console.log("  2. Paste the tweet URL (or its status id) below.\n");
+  const rawProof = await prompter.input("Tweet URL or id:");
+  const parsed = parseXProofInput(rawProof);
+  if (parsed === null) {
+    throw new Error(
+      "Expected a tweet URL (https://x.com/<user>/status/<id>) or a numeric status id."
+    );
+  }
+  let username = parsed.username;
+  if (username === void 0) {
+    const rawUsername = await prompter.input("X username (without @):");
+    username = rawUsername.trim().replace(/^@/, "").toLowerCase();
+  }
+  if (!X_USERNAME_REGEX.test(username)) {
+    throw new Error(`Invalid X username: "${username}" (alphanumeric or underscore, 1-15 chars).`);
+  }
+  return {
+    nextIdentities: {
+      ...loaded.yaml.identities,
+      x: { username, tweet: parsed.proofId }
+    }
+  };
+}
+async function promptWebsiteLink(loaded, pubkeyHex, prompter) {
+  const rawIdentifier = await prompter.input("NIP-05 identifier (name@domain or bare domain):");
+  const identifier = normalizeNip05Identifier(rawIdentifier.trim());
+  if (identifier === null) {
+    throw new Error(
+      `Invalid NIP-05 identifier: "${rawIdentifier.trim()}". Expected name@domain or a bare domain (ASCII hostname labels, no IP literals).`
+    );
+  }
+  const { local, domain } = splitNip05Identifier(identifier);
+  console.log(`
+  Serve this JSON at https://${domain}/.well-known/nostr.json :
+`);
+  for (const line of websiteNostrJson(local, pubkeyHex).split("\n")) {
+    console.log(`     ${line}`);
+  }
+  console.log(
+    `
+  It must answer https://${domain}/.well-known/nostr.json?name=${local} over https,`
+  );
+  console.log("  without redirects - NIP-05 forbids following them. The verifier consults only");
+  console.log(`  this exact host (no www/apex twin fallback), so the file must live at ${domain}.`);
+  console.log("  Sending `Access-Control-Allow-Origin: *` is recommended (NIP-05), so browser");
+  console.log("  clients can verify it too.\n");
+  const live = await prompter.confirm("Is the file deployed and reachable? Verify now", true);
+  if (!live) {
+    throw new Error(
+      "aborted - deploy the file, then re-run `npx @elisym/cli identity link website`. Nothing was written."
+    );
+  }
+  return {
+    nextIdentities: {
+      ...loaded.yaml.identities,
+      website: identifier
+    }
+  };
+}
+function describeBrokenProof(platform, claim) {
+  switch (platform) {
+    case "github":
+      return `the gist at ${claim.proofUrl} is missing, belongs to another user, or does not contain the exact proof text with this agent's npub`;
+    case "x":
+      return `the tweet at ${claim.proofUrl} is deleted, belongs to another account, or does not contain the exact proof text with this agent's npub`;
+    case "website":
+      return `${claim.proofUrl}/.well-known/nostr.json does not map "${claim.handle}" to this agent's pubkey`;
+  }
+}
+async function cmdIdentityLink(platformArg, agentName, deps = {}) {
+  const platform = parseIdentityPlatform(platformArg);
+  const cwd = deps.cwd ?? process.cwd();
+  const prompter = deps.prompter ?? await createInquirerPrompter();
+  const verify = deps.verify ?? verifyAgentIdentities;
+  const { name, loaded } = await resolveAndLoadAgent(agentName, cwd, prompter);
+  const identity2 = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
+  console.log(`
+  Linking ${platform} to agent "${name}" (${identity2.npub}).`);
+  let prompted;
+  if (platform === "github") {
+    prompted = await promptGithubLink(loaded, identity2.npub, prompter);
+  } else if (platform === "x") {
+    prompted = await promptXLink(loaded, identity2.npub, prompter);
+  } else {
+    prompted = await promptWebsiteLink(loaded, identity2.publicKey, prompter);
+  }
+  const claim = identitiesFromYaml(prompted.nextIdentities).find(
+    (candidate) => candidate.platform === platform
+  );
+  if (claim === void 0) {
+    throw new Error("Internal: failed to build the identity claim from the prompt input.");
+  }
+  console.log("\n  Verifying the proof (live, cache bypassed)...");
+  const results = await verify(identity2.publicKey, [claim], { bypassCache: true });
+  const result = results[0];
+  if (result === void 0) {
+    throw new Error("Internal: the verifier returned no result.");
+  }
+  if (result.status === "broken") {
+    throw new Error(
+      `proof check failed: ${describeBrokenProof(platform, claim)}. Nothing was written.`
+    );
+  }
+  if (result.status === "unverifiable") {
+    console.warn(
+      "  ! Could not check the proof (network error, rate limit, or the proof is not reachable yet)."
+    );
+    console.warn("  ! This is neutral - the proof may be fine - but it was NOT verified.");
+    const proceed = await prompter.confirm(
+      "Link anyway (write elisym.yaml and publish the unverified claim)?",
+      false
+    );
+    if (!proceed) {
+      throw new Error("aborted - nothing was written.");
+    }
+  } else {
+    console.log("  Proof verified.");
+  }
+  const nextYaml = { ...loaded.yaml, identities: prompted.nextIdentities };
+  await writeYaml(loaded.dir, nextYaml);
+  console.log(`  Wrote identities.${platform} to elisym.yaml.`);
+  const createPublisher = deps.createPublisher ?? createDefaultPublisher;
+  const publisher = createPublisher(relaysFor(loaded.yaml));
+  try {
+    const claims = buildIdentityClaimInputs(prompted.nextIdentities);
+    try {
+      await publisher.publishExternalIdentities(identity2, claims);
+      console.log(`  Published identity claims (kind 10011, ${claims.length} tag(s)).`);
+      if (platform === "website") {
+        await republishAgentProfile(publisher, identity2, name, loaded.dir, nextYaml);
+        console.log("  Republished profile (kind 0) with nip05.");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `linked locally, but publishing failed: ${message}. Run \`npx @elisym/cli start ${name}\` to publish, or re-run this command.`
+      );
+    }
+  } finally {
+    publisher.close();
+  }
+  console.log(`
+  Linked ${platform} to agent "${name}".
+`);
+}
+function removeIdentityEntry(identities, platform) {
+  const next = { ...identities };
+  delete next[platform];
+  const hasEntries = next.github !== void 0 || next.x !== void 0 || next.website !== void 0;
+  return hasEntries ? next : void 0;
+}
+async function cmdIdentityUnlink(platformArg, agentName, deps = {}) {
+  const platform = parseIdentityPlatform(platformArg);
+  const cwd = deps.cwd ?? process.cwd();
+  const prompter = deps.prompter ?? await createInquirerPrompter();
+  const { name, loaded } = await resolveAndLoadAgent(agentName, cwd, prompter);
+  const identity2 = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
+  const current = loaded.yaml.identities;
+  if (current === void 0 || current[platform] === void 0) {
+    console.log(`
+  ${platform} is not linked for agent "${name}" - nothing to unlink.
+`);
+    return;
+  }
+  const nextIdentities = removeIdentityEntry(current, platform);
+  const nextYaml = { ...loaded.yaml };
+  if (nextIdentities === void 0) {
+    delete nextYaml.identities;
+  } else {
+    nextYaml.identities = nextIdentities;
+  }
+  await writeYaml(loaded.dir, nextYaml);
+  console.log(`
+  Removed identities.${platform} from elisym.yaml.`);
+  const createPublisher = deps.createPublisher ?? createDefaultPublisher;
+  const publisher = createPublisher(relaysFor(loaded.yaml));
+  try {
+    const remaining = buildIdentityClaimInputs(nextIdentities);
+    try {
+      await publisher.publishExternalIdentities(identity2, remaining);
+      console.log(
+        `  Republished identity claims (kind 10011, ${remaining.length} tag(s) remaining).`
+      );
+      if (platform === "website") {
+        await republishAgentProfile(publisher, identity2, name, loaded.dir, nextYaml);
+        console.log("  Republished profile (kind 0) without nip05.");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `unlinked locally, but publishing the retraction failed: ${message}. Run \`npx @elisym/cli start ${name}\` to propagate it.`
+      );
+    }
+  } finally {
+    publisher.close();
+  }
+  console.log(`
+  Unlinked ${platform} from agent "${name}".
+`);
+}
+function sameClaim(left, right) {
+  return left.platform === right.platform && left.handle.toLowerCase() === right.handle.toLowerCase() && left.proofUrl.toLowerCase() === right.proofUrl.toLowerCase();
+}
+function buildStatusRows(results, publishedClaims) {
+  return results.map((result) => ({
+    platform: result.identity.platform,
+    handle: result.identity.handle,
+    proofUrl: result.identity.proofUrl,
+    status: result.status,
+    published: publishedClaims === void 0 ? void 0 : publishedClaims.some((claim) => sameClaim(claim, result.identity))
+  }));
+}
+async function cmdIdentityStatus(agentName, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const prompter = deps.prompter ?? await createInquirerPrompter();
+  const verify = deps.verify ?? verifyAgentIdentities;
+  const { name, loaded } = await resolveAndLoadAgent(agentName, cwd, prompter);
+  const identity2 = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
+  const localClaims = identitiesFromYaml(loaded.yaml.identities);
+  const createPublisher = deps.createPublisher ?? createDefaultPublisher;
+  const publisher = createPublisher(relaysFor(loaded.yaml));
+  let published;
+  try {
+    published = await publisher.fetchExternalIdentityClaims(identity2.publicKey);
+  } catch {
+    console.warn("  ! Could not query the relays for published claims - drift check skipped.");
+  } finally {
+    publisher.close();
+  }
+  if (localClaims.length === 0) {
+    console.log(`
+  No identities linked in elisym.yaml for agent "${name}".`);
+    console.log("  Link one: npx @elisym/cli identity link <github|x|website>\n");
+    if (published !== void 0 && published.identities.length > 0) {
+      console.log(
+        `  ! The relays still hold published identity claims - run \`npx @elisym/cli start ${name}\` to retract them.
+`
+      );
+    }
+    return;
+  }
+  console.log(`
+  Verifying ${localClaims.length} proof(s) (live, cache bypassed)...
+`);
+  const results = await verify(identity2.publicKey, localClaims, { bypassCache: true });
+  const rows = buildStatusRows(results, published?.identities);
+  console.log(`  Identities for agent "${name}" (${identity2.npub}):
+`);
+  for (const row of rows) {
+    const displayHandle = row.handle.startsWith("_@") ? row.handle.slice(2) : row.handle;
+    console.log(`  ${row.platform.padEnd(8)} ${row.status.padEnd(13)} ${displayHandle}`);
+    console.log(`           proof: ${row.proofUrl}`);
+    if (row.published === false) {
+      console.log(
+        `           ! linked locally but not published - run \`npx @elisym/cli start ${name}\` to publish`
+      );
+    }
+  }
+  console.log();
+}
 
 // src/index.ts
 init_init();
@@ -1669,7 +2228,7 @@ function parseRelayUrl(url) {
   }
 }
 async function tcpProbe(host, port, timeoutMs) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const started = Date.now();
     const socket = new Socket();
     let settled = false;
@@ -1679,7 +2238,7 @@ async function tcpProbe(host, port, timeoutMs) {
       }
       settled = true;
       socket.destroy();
-      resolve3(result);
+      resolve4(result);
     };
     const timer = setTimeout(() => finish({ error: "timeout" }), timeoutMs);
     socket.once("connect", () => {
@@ -1996,80 +2555,809 @@ function resolveProviderApiKey(input) {
       error: `Provider "${provider}" is not registered (required by skill(s): ${skillList2}).`
     };
   }
-  const perProviderValue = secrets.llm_api_keys?.[provider];
-  if (typeof perProviderValue === "string" && perProviderValue.length > 0) {
-    return { apiKey: perProviderValue, origin: "secrets-per-provider" };
+  const perProviderValue = secrets.llm_api_keys?.[provider];
+  if (typeof perProviderValue === "string" && perProviderValue.length > 0) {
+    return { apiKey: perProviderValue, origin: "secrets-per-provider" };
+  }
+  const envValue = process.env[descriptor.envVar];
+  if (envValue) {
+    return { apiKey: envValue, origin: "env" };
+  }
+  const skillList = dependentSkills.length > 0 ? dependentSkills.join(", ") : "<none>";
+  return {
+    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;
+  }
+  if (options.verbose) {
+    return "debug";
+  }
+  const envLevel = process.env.LOG_LEVEL;
+  if (envLevel) {
+    return envLevel;
+  }
+  return "info";
+}
+function createLogger(options = {}) {
+  const level = resolveLevel(options);
+  const baseOptions = {
+    name: "elisym-cli",
+    level,
+    redact: {
+      paths: DEFAULT_REDACT_PATHS,
+      censor: makeCensor()
+    }
+  };
+  let logger;
+  if (options.destination) {
+    logger = pino(baseOptions, options.destination);
+  } else if (options.tty === true) {
+    logger = pino({
+      ...baseOptions,
+      transport: {
+        target: "pino-pretty",
+        options: { destination: 2, colorize: true, translateTime: "HH:MM:ss" }
+      }
+    });
+  } else {
+    logger = pino(baseOptions, pino.destination(2));
+  }
+  function logWithIndent(line) {
+    process.stdout.write(`  ${sanitizeForTerminal(line)}
+`);
+  }
+  return {
+    logger,
+    logWithIndent,
+    bannerLog: logWithIndent
+  };
+}
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif"
+};
+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((resolve4) => {
+      release = resolve4;
+    });
+    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");
   }
-  const envValue = process.env[descriptor.envVar];
-  if (envValue) {
-    return { apiKey: envValue, origin: "env" };
+  if (!SESSION_ID_REGEX.test(sessionId)) {
+    throw new Error("SessionStore: invalid session id");
   }
-  const skillList = dependentSkills.length > 0 ? dependentSkills.join(", ") : "<none>";
-  return {
-    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;
+function parseSessionLine(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
   }
-  if (options.verbose) {
-    return "debug";
+  if (typeof value !== "object" || value === null) {
+    return null;
   }
-  const envLevel = process.env.LOG_LEVEL;
-  if (envLevel) {
-    return envLevel;
+  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 };
   }
-  return "info";
+  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 createLogger(options = {}) {
-  const level = resolveLevel(options);
-  const baseOptions = {
-    name: "elisym-cli",
-    level,
-    redact: {
-      paths: DEFAULT_REDACT_PATHS,
-      censor: makeCensor()
+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 });
     }
-  };
-  let logger;
-  if (options.destination) {
-    logger = pino(baseOptions, options.destination);
-  } else if (options.tty === true) {
-    logger = pino({
-      ...baseOptions,
-      transport: {
-        target: "pino-pretty",
-        options: { destination: 2, colorize: true, translateTime: "HH:MM:ss" }
-      }
-    });
-  } else {
-    logger = pino(baseOptions, pino.destination(2));
   }
-  function logWithIndent(line) {
-    process.stdout.write(`  ${sanitizeForTerminal(line)}
-`);
+  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 {
-    logger,
-    logWithIndent,
-    bannerLog: logWithIndent
-  };
+  return parts.join("\n\n");
 }
-var MIME_BY_EXT = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".avif": "image/avif"
-};
-function mimeFromPath(path) {
-  return MIME_BY_EXT[extname(path).toLowerCase()] ?? "application/octet-stream";
+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
@@ -2113,6 +3401,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 +3540,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, identity2, blossomTransport, sessionStore) {
     this.transport = transport;
     this.skills = skills;
     this.skillCtx = skillCtx;
@@ -2238,8 +3549,9 @@ var AgentRuntime = class {
     this.callbacks = callbacks;
     this.healthMonitor = healthMonitor;
     this.irohTransport = irohTransport;
-    this.identity = identity;
+    this.identity = identity2;
     this.blossomTransport = blossomTransport;
+    this.sessionStore = sessionStore;
     this.limit = pLimit(config.maxConcurrentJobs);
     this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
   }
@@ -2287,6 +3599,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 +3839,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 +3851,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 +3880,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,16 +3928,22 @@ 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...");
-    await new Promise((resolve3) => {
-      this.abortController.signal.addEventListener("abort", () => resolve3(), { once: true });
+    await new Promise((resolve4) => {
+      this.abortController.signal.addEventListener("abort", () => resolve4(), { once: true });
       let shuttingDown = false;
       const onSignal = () => {
         if (shuttingDown) {
@@ -2704,68 +4133,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,
@@ -3144,7 +4587,7 @@ var AgentRuntime = class {
     let refOutcome;
     let result;
     try {
-      result = await new Promise((resolve3, reject) => {
+      result = await new Promise((resolve4, reject) => {
         let settled = false;
         let pending = 2;
         let lastResult = { verified: false };
@@ -3154,7 +4597,7 @@ var AgentRuntime = class {
           }
           settled = true;
           clearTimeout(deadline);
-          resolve3(verified);
+          resolve4(verified);
         };
         const lose = (verified, reason) => {
           if (settled) {
@@ -3166,7 +4609,7 @@ var AgentRuntime = class {
           if (pending === 0) {
             settled = true;
             clearTimeout(deadline);
-            resolve3(lastResult);
+            resolve4(lastResult);
           }
         };
         this.transport.waitForPaymentSignature(job.jobId, job.customerId, verifyAbort.signal, sigPathTimeoutMs).then(async (sig) => {
@@ -3219,7 +4662,7 @@ var AgentRuntime = class {
           }
           settled = true;
           log(`[${job.jobId.slice(0, 8)}] verify deadline (${deadlineMs}ms) hit`);
-          resolve3(lastResult);
+          resolve4(lastResult);
         }, deadlineMs);
         if (signal?.aborted) {
           settled = true;
@@ -3272,8 +4715,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 +4791,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 +4931,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 +4951,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 +5123,9 @@ var SkillRegistry = class {
     return this.skills;
   }
 };
+
+// src/skill/loader.ts
+init_llm();
 var StaticFileSkill = class {
   name;
   description;
@@ -3644,6 +5155,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 +5221,7 @@ var DynamicScriptSkill = class {
   inputMime;
   inputText;
   outputMime;
+  context;
   inner;
   constructor(params) {
     this.name = params.name;
@@ -3720,6 +5233,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 +5249,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 +5265,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 +5301,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 +5316,7 @@ var ScriptSkill = class {
       tools,
       maxToolRounds,
       llmOverride,
+      context,
       image,
       imageFile
     });
@@ -3859,11 +5377,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 +5412,8 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
         parsed.systemPrompt,
         parsed.tools,
         parsed.maxToolRounds,
-        parsed.llmOverride
+        parsed.llmOverride,
+        parsed.context
       );
       break;
     case "static-file": {
@@ -3891,7 +5422,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 +5449,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 +5462,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 +5472,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;
     }
@@ -4021,9 +5553,9 @@ function parseBidTag(value) {
 }
 var HEALTH_CHECK_IDLE_MS = 30 * 60 * 1e3;
 var NostrTransport = class {
-  constructor(client, identity, kindOffsets) {
+  constructor(client, identity2, kindOffsets) {
     this.client = client;
-    this.identity = identity;
+    this.identity = identity2;
     this.kindOffsets = kindOffsets;
   }
   sub = null;
@@ -4059,10 +5591,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 +5609,8 @@ var NostrTransport = class {
           bid: parseBidTag(bidTag?.[1]),
           encrypted,
           rawEvent: event,
-          attachment
+          attachment,
+          session
         });
       }
     );
@@ -4098,7 +5633,7 @@ var NostrTransport = class {
    * expiry window - without it this path waits forever on the relay.
    */
   waitForPaymentSignature(jobId, customerPubkey, signal, timeoutMs) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       let settled = false;
       const filter = {
         kinds: [KIND_JOB_FEEDBACK],
@@ -4117,7 +5652,7 @@ var NostrTransport = class {
         }
         signal.removeEventListener("abort", onAbort);
         sub.close();
-        resolve3(sig);
+        resolve4(sig);
       };
       const sub = this.client.pool.subscribe(filter, (event) => {
         if (settled) {
@@ -4211,7 +5746,7 @@ var NostrTransport = class {
 function startWatchdog(deps) {
   const {
     client,
-    identity,
+    identity: identity2,
     transport,
     onPing,
     log,
@@ -4222,7 +5757,7 @@ function startWatchdog(deps) {
     selfPingTimeoutMs = WATCHDOG_SELF_PING_TIMEOUT_MS,
     now = Date.now
   } = deps;
-  let pingSub = client.ping.subscribeToPings(identity, onPing);
+  let pingSub = client.ping.subscribeToPings(identity2, onPing);
   let stopped = false;
   let probeBusy = false;
   let selfPingBusy = false;
@@ -4231,7 +5766,7 @@ function startWatchdog(deps) {
   const resetPoolAndResubscribe = () => {
     transport.stop();
     client.pool.reset();
-    pingSub = client.ping.subscribeToPings(identity, onPing);
+    pingSub = client.ping.subscribeToPings(identity2, onPing);
     transport.restart();
   };
   const detectAndHandleSleep = () => {
@@ -4287,7 +5822,7 @@ function startWatchdog(deps) {
     }
     selfPingBusy = true;
     try {
-      const result = await client.ping.pingAgent(identity.publicKey, selfPingTimeoutMs);
+      const result = await client.ping.pingAgent(identity2.publicKey, selfPingTimeoutMs);
       if (stopped || result.online) {
         return;
       }
@@ -4775,18 +6310,18 @@ async function capChallengeResponse(response) {
   });
 }
 function abortableDelay(ms, signal) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (signal?.aborted) {
-      resolve3(false);
+      resolve4(false);
       return;
     }
     const onAbort = () => {
       clearTimeout(timer);
-      resolve3(false);
+      resolve4(false);
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve3(true);
+      resolve4(true);
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -5158,6 +6693,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];
@@ -5412,7 +6950,7 @@ async function cmdStart(nameArg, options = {}) {
     });
   }
   console.log("  Connecting to relays and publishing capabilities...");
-  const identity = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
+  const identity2 = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
   const relays = loaded.yaml.relays.length > 0 ? loaded.yaml.relays : [...RELAYS];
   const client = new ElisymClient({ relays });
   if (process.env.ELISYM_NET_DIAG === "1") {
@@ -5434,7 +6972,7 @@ async function cmdStart(nameArg, options = {}) {
     loaded.dir,
     mediaCache,
     client.blossom,
-    identity,
+    identity2,
     (updated) => mediaCacheDirty = mediaCacheDirty || updated
   );
   const bannerUrl = await resolveMediaField(
@@ -5442,7 +6980,7 @@ async function cmdStart(nameArg, options = {}) {
     loaded.dir,
     mediaCache,
     client.blossom,
-    identity,
+    identity2,
     (updated) => mediaCacheDirty = mediaCacheDirty || updated
   );
   for (const skill of allSkills) {
@@ -5456,9 +6994,10 @@ async function cmdStart(nameArg, options = {}) {
     const url = await uploadOrReuse(
       cacheKey,
       absPath,
+      skillRoot,
       mediaCache,
       client.blossom,
-      identity,
+      identity2,
       () => mediaCacheDirty = true
     );
     if (url) {
@@ -5471,11 +7010,12 @@ async function cmdStart(nameArg, options = {}) {
   let profilePublished = false;
   try {
     await client.discovery.publishProfile(
-      identity,
+      identity2,
       loaded.yaml.display_name ?? agentName,
       loaded.yaml.description ?? "",
       pictureUrl,
-      bannerUrl
+      bannerUrl,
+      loaded.yaml.identities?.website
     );
     profilePublished = true;
     logger.debug({ event: "publish_ack", kind: 0 }, "profile published");
@@ -5483,6 +7023,32 @@ async function cmdStart(nameArg, options = {}) {
     console.warn(`  ! Failed to publish profile: ${e.message}`);
     logger.warn({ event: "publish_failed", kind: 0, error: e.message }, "profile publish failed");
   }
+  if (loaded.yaml.identities !== void 0) {
+    const identityClaims = buildIdentityClaimInputs(loaded.yaml.identities);
+    try {
+      await client.discovery.publishExternalIdentities(identity2, identityClaims);
+      const summaryParts = identityClaims.map((claim) => `${claim.platform}:${claim.handle}`);
+      if (loaded.yaml.identities.website !== void 0) {
+        summaryParts.push(`website:${loaded.yaml.identities.website}`);
+      }
+      console.log(`  * Identities: ${summaryParts.join(", ") || "none"}`);
+      logger.debug(
+        { event: "publish_ack", kind: KIND_EXTERNAL_IDENTITIES, claims: identityClaims.length },
+        "identity claims published"
+      );
+    } catch (e) {
+      console.warn(`  ! Failed to publish identity claims: ${e.message}`);
+      logger.warn(
+        { event: "publish_failed", kind: KIND_EXTERNAL_IDENTITIES, error: e.message },
+        "identity claims publish failed"
+      );
+    }
+  } else {
+    const sweptIdentities = await sweepStaleIdentityClaims(client.discovery, identity2);
+    if (sweptIdentities) {
+      console.log("  Removed stale identity claims (no identities in elisym.yaml).");
+    }
+  }
   const policies = existsSync(paths.policies) ? loadPoliciesFromDir(paths.policies) : [];
   const localPolicyDTags = new Set(
     policies.map((policy) => `${POLICY_D_TAG_PREFIX}${policy.type}`)
@@ -5491,7 +7057,7 @@ async function cmdStart(nameArg, options = {}) {
     try {
       return await client.pool.querySync({
         kinds: [KIND_LONG_FORM_ARTICLE],
-        authors: [identity.publicKey],
+        authors: [identity2.publicKey],
         "#t": [POLICY_T_TAG]
       });
     } catch {
@@ -5518,7 +7084,7 @@ async function cmdStart(nameArg, options = {}) {
       continue;
     }
     try {
-      const { naddr } = await client.policies.publishPolicy(identity, policy);
+      const { naddr } = await client.policies.publishPolicy(identity2, policy);
       console.log(`  * Policy: ${policy.type}@${policy.version} -> ${naddr}`);
       logger.debug(
         { event: "publish_ack", kind: KIND_LONG_FORM_ARTICLE, policy: policy.type, naddr },
@@ -5546,12 +7112,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}`);
+      await client.policies.deletePolicy(identity2, type);
+      console.log(`  Removed stale policy: ${sanitizeForTerminal(type)}`);
     } catch {
     }
   }
@@ -5569,6 +7135,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,
@@ -5610,7 +7179,7 @@ async function cmdStart(nameArg, options = {}) {
       continue;
     }
     try {
-      await client.discovery.publishCapability(identity, buildCard(skill), kinds);
+      await client.discovery.publishCapability(identity2, buildCard(skill), kinds);
       cardsPublished += 1;
       logger.debug(
         { event: "publish_ack", kind: 31990, skill: skill.name },
@@ -5627,7 +7196,7 @@ async function cmdStart(nameArg, options = {}) {
   try {
     const existingEvents = await client.pool.querySync({
       kinds: [31990],
-      authors: [identity.publicKey],
+      authors: [identity2.publicKey],
       "#t": ["elisym"]
     });
     const skillDTags = new Set(allSkills.map((s) => toDTag(s.name)));
@@ -5638,9 +7207,9 @@ async function cmdStart(nameArg, options = {}) {
       }
       try {
         const card = JSON.parse(ev.content);
-        if (card.name) {
-          await client.discovery.deleteCapability(identity, card.name);
-          console.log(`  Removed stale capability: ${card.name}`);
+        if (card.name && toDTag(card.name) === dTag) {
+          await client.discovery.deleteCapability(identity2, card.name);
+          console.log(`  Removed stale capability: ${sanitizeForTerminal(card.name)}`);
         }
       } catch {
       }
@@ -5655,16 +7224,20 @@ async function cmdStart(nameArg, options = {}) {
     console.log(`  [debug] Relays: ${relays.length} configured (${relays.join(", ")})`);
   }
   const onPing = (senderPubkey, nonce) => {
-    client.ping.sendPong(identity, senderPubkey, nonce).catch(() => {
+    client.ping.sendPong(identity2, senderPubkey, nonce).catch(() => {
     });
   };
-  const transport = new NostrTransport(client, identity, [DEFAULT_KIND_OFFSET]);
+  const transport = new NostrTransport(client, identity2, [DEFAULT_KIND_OFFSET]);
   const ledger = new JobLedger(paths.jobs);
   const irohTransport = createIrohTransport({ storePath: join(loaded.dir, ".iroh") });
   await ensureGitignoreHasIrohEntry(dirname(loaded.dir));
   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,
@@ -5695,7 +7268,7 @@ async function cmdStart(nameArg, options = {}) {
   };
   const watchdog = startWatchdog({
     client,
-    identity,
+    identity: identity2,
     transport,
     onPing,
     log: diagLog,
@@ -5709,7 +7282,11 @@ async function cmdStart(nameArg, options = {}) {
     });
     diagLog("LLM health monitor armed (lazy recovery, 5min interval).");
   }
-  const blossomTransport = createBlossomTransport({ blossom: client.blossom, identity });
+  const blossomTransport = createBlossomTransport({ blossom: client.blossom, identity: identity2 });
+  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,
@@ -5742,8 +7319,9 @@ async function cmdStart(nameArg, options = {}) {
     },
     healthMonitor,
     irohTransport,
-    identity,
-    blossomTransport
+    identity2,
+    blossomTransport,
+    sessionStore
   );
   console.log("  * Running. Press Ctrl+C to stop.\n");
   await runtime.run();
@@ -5768,10 +7346,18 @@ 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));
 }
-async function resolveMediaField(value, agentDir, cache, blossom, identity, onCacheUpdate) {
+async function resolveMediaField(value, agentDir, cache, blossom, identity2, onCacheUpdate) {
   if (!value) {
     return void 0;
   }
@@ -5783,7 +7369,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,
+    identity2,
+    () => onCacheUpdate(true)
+  );
 }
 function resolveInsideAgentDir(value, agentDir) {
   const agentRoot = resolve(agentDir);
@@ -5794,17 +7388,37 @@ 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, identity2, 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);
+    const descriptor = await blossom.upload(identity2, blob);
     cache[cacheKey] = newCacheEntry(descriptor.url, sha256);
     onCacheUpdate();
     console.log(`  Uploaded: ${descriptor.url}`);
@@ -6411,8 +8025,8 @@ program.command("list").description("List all agents (project-local and home-glo
     for (const agent of agents) {
       try {
         const loaded = await loadAgent(agent.name, cwd);
-        const identity = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
-        const npub = nip19.npubEncode(identity.publicKey);
+        const identity2 = ElisymIdentity.fromHex(loaded.secrets.nostr_secret_key);
+        const npub = nip19.npubEncode(identity2.publicKey);
         const solAddr = loaded.yaml.payments[0]?.address ? ` | Solana: ${loaded.yaml.payments[0].address}` : "";
         const shadow = agent.shadowsGlobal ? " [shadows global]" : "";
         console.log(`  ${agent.name} (${agent.source})${shadow} | ${npub}${solAddr}`);
@@ -6425,6 +8039,29 @@ program.command("list").description("List all agents (project-local and home-glo
   })
 );
 program.command("wallet [name]").description("Show wallet balance").action(safe(cmdWallet));
+var identity = program.command("identity").description("Link, verify, and unlink external identities (GitHub, X, website)");
+identity.command("link <platform> [agent]").description(
+  "Link a github|x|website identity: prints the NIP-39 proof template, verifies the proof live, writes elisym.yaml, and publishes the claim (kind 10011 / kind-0 nip05)"
+).action(
+  safe(async (platform, agent) => {
+    await cmdIdentityLink(platform, agent);
+    process.exit(0);
+  })
+);
+identity.command("status [agent]").description(
+  "List linked identities with live proof verification and published-claim drift check"
+).action(
+  safe(async (agent) => {
+    await cmdIdentityStatus(agent);
+    process.exit(0);
+  })
+);
+identity.command("unlink <platform> [agent]").description("Remove a github|x|website identity and retract the published claim").action(
+  safe(async (platform, agent) => {
+    await cmdIdentityUnlink(platform, agent);
+    process.exit(0);
+  })
+);
 var x402 = program.command("x402").description("Bridge x402-paid HTTP services into elisym skills");
 x402.command("add <url> [agent]").description("Generate a bridge skill from a live x402 endpoint (probes its 402 challenge)").option("--method <method>", "HTTP method for the upstream call: GET or POST (default POST)").option(
   "--query-param <name>",