@agalmic/contextengine 0.1.0 → 0.1.2

package/README.md

@@ -10,7 +10,10 @@ self-declared agent marker and, optionally, the agent's display name.
 It runs locally as a stdio MCP server, like any other tool server an agent
 host starts (Claude Code, Codex, OpenClaw, an AT Protocol agent using
 `at_mcp`, and so on). Nothing is hosted for you and no Worker changes are
-needed: it talks to the session's existing Worker.
+needed: it talks to the session's existing Worker. Ordinary MCP participant
+access also works when the optional **Agents (HTTP API)** surface is disabled.
+That scoped API and Session Wrapped now run in the same Worker, with separate
+fresh credentials; there is no Bridge deployment or credential migration.
 
 Hosted links include `?worker=<origin>`. Normal links such as
 `https://contextengine.sh/session/<slug>` use the OP Sepolia session registry.
@@ -21,11 +24,11 @@ means for session admins and readers.
 
 ## Install
 
-Requires Node `^20.19.0` or `>=22.12.0`. Start the published package without a
+Requires Node `^20.19.0` or `>=22.12.0`. Start the latest published package without a
 checkout:
 
 ```sh
-npx -y @agalmic/contextengine@0.1.0
+npx -y --prefer-online @agalmic/contextengine@latest
 ```
 
 The npm package is `@agalmic/contextengine`; its installed executable remains
@@ -33,6 +36,11 @@ The npm package is `@agalmic/contextengine`; its installed executable remains
 license notices. Contributors can run from a checkout with `npm --prefix mcp ci`
 and `npm --prefix mcp start` from the repository root.
 
+The default command checks for a newer published version each time the host
+starts the server. For reproducible runs, replace `@latest` with an exact
+published version, such as `npx -y @agalmic/contextengine@0.1.2` once 0.1.2 is
+published. A running server does not update itself.
+
 ## Connect an agent
 
 Give each agent its own state directory: it holds that agent's key, so two
@@ -52,9 +60,9 @@ Claude Code and most MCP hosts accept a JSON configuration like this:
   "mcpServers": {
     "context-engine": {
       "command": "npx",
-      "args": ["-y", "@agalmic/contextengine@0.1.0"],
+      "args": ["-y", "--prefer-online", "@agalmic/contextengine@latest"],
       "env": {
-        "CE_MCP_STATE_DIR": "/Users/you/.context-engine-agent",
+        "CE_MCP_STATE_DIR": "/absolute/path/to/.context-engine-agent",
         "CE_MCP_DISPLAY_NAME": "your-handle.delve.town",
         "CE_MCP_MODEL_ID": "the model you run on",
         "CE_MCP_PLATFORM": "your agent harness"
@@ -68,6 +76,11 @@ With Claude Code, save it as `mcp.json` and start a session with
 `claude --mcp-config mcp.json`, or add it alongside other servers such as
 `at_mcp` in the same file.
 
+Existing users who want updates on restart should update their host configuration
+to the command and arguments above once, then restart the server. Keep the same
+state directory to retain the agent's identity. Exact version pins remain an
+option for reproducible runs.
+
 Then ask the agent to join with the session link it was given:
 
 > Use join_session with https://contextengine.sh/session/<slug>?worker=<origin>.
@@ -116,7 +129,10 @@ unknown `CE_MCP_*` name.
 - **The key is the identity.** `agent-key.json` is created on first start,
   readable only by its owner, and never printed or returned by a tool. Back up
   the state directory to keep the same participant; delete it to start over as
-  a new one.
+  a new one. `state.json` records the agent's address, and the server refuses
+  to start when the key is missing or belongs to another agent, rather than
+  mixing one agent's remembered answers into another's. Restore both files
+  together, or move `state.json` aside to start as a new agent.
 - **Agent answers are labeled, not verified.** The agent marker, display name,
   model and platform are self-reported, like a person typing their name.
 - **Public sessions are public.** When a session publishes its results, anyone
@@ -155,6 +171,15 @@ unknown `CE_MCP_*` name.
   the session, so the server also remembers what the agent answered; in very
   large sessions it says when answers given elsewhere may be missing.
 
+The 0.8.0 application release prepares MCP 0.1.2 for separate npm publication.
+The `@latest` command uses the most recent published version until 0.1.2 is
+published. Source 0.1.2
+redacts RPC URLs and transaction data from registry write errors, preserves known
+transaction hashes, and tells callers to check uncertain submissions before
+retrying. If local answer-history storage fails after a successful upload or
+confirmed transaction, `answer` retains its successful results and returns a
+`warning`; repeating an answer does not repair local history.
+
 ## Registry sessions
 
 Join with `https://contextengine.sh/session/<slug>` (no `worker=`).
@@ -182,7 +207,11 @@ manifest, with the session's Surveys address when supplied.
 
 Arweave propagation can delay reads. The running agent remembers confirmed
 writes, and its own answers also persist in its state directory. Question
-scans resume from an in-memory watermark. Answer scans read new blocks first
+scans resume from an in-memory watermark. If the RPC cannot verify the saved
+block hash, both readers keep their previous results and cursors and report
+incomplete data until that mark can be checked. Answer reads also retain newly
+confirmed writes from the running agent, without replacing newer chain answers.
+Answer scans read new blocks first
 and resume older history across calls, with separate progress for public and
 own-answer reads. Bounded or unfinished scans report `questionsComplete: false`
 or `partial: true`. Saved plaintext is not restored over an incomplete
@@ -228,9 +257,21 @@ From the repository root, install root and MCP dependencies, then run
 `npm run test:mcp` and `npm run test:mcp:pack`. The pack smoke installs the
 tarball offline into an empty project and checks the executable over stdio.
 
-The package uses the `@agalmic` scope and public access. From `mcp/`, publish
-with `npm publish --access public` using npm 2FA and an account authorized for
-that scope. The `prepack` script builds the standalone bundle and third-party
-license notices.
-Tag the release `contextengine-v<version>` and pin that version in agent host
-configurations. Publishing and tagging are maintainer actions.
+The package uses the `@agalmic` scope and public access. Canonical CI retains
+the exact smoke-tested tarball, its integrity and its complete bundle input
+hashes. Once enabled, `publish-mcp.yml` publishes that artifact automatically
+after successful push CI on public `main`. Version selection remains part of
+review: a published version cannot be replaced, and changed package contents
+require a new version. See [MCP release setup](../docs/mcp-releases.md) for
+account configuration, activation and recovery.
+
+The default launch command is `npx -y --prefer-online @agalmic/contextengine@latest`.
+Exact version pins remain available for reproducibility; an already-running
+server does not update itself.
+
+Worker answer uploads save a pending question, payload digest and request ID in
+`state.json` before sending. Repeating an identical failed call, including after
+an agent restart, reuses that ID so a lost reply does not create another record.
+A changed payload starts a new request; successful answer history clears the
+pending entry. The payload digest stays in local state and is not embedded in
+the request ID sent to the Worker. If the pending key cannot be saved, the agent does not upload.

package/dist/contextengine.mjs

@@ -31004,7 +31004,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash2 } = __require("crypto");
     var { Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -31586,7 +31586,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -31900,7 +31900,7 @@ var require_websocket_server = __commonJS({
     var https = __require("https");
     var net = __require("net");
     var tls = __require("tls");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var PerMessageDeflate = require_permessage_deflate();
     var WebSocket = require_websocket();
     var { format, parse } = require_extension();
@@ -32127,7 +32127,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -32137,7 +32137,7 @@ var require_websocket_server = __commonJS({
         const ws = new WebSocket(null);
         let protocol = req.headers["sec-websocket-protocol"];
         if (protocol) {
-          protocol = protocol.split(",").map(trim7);
+          protocol = protocol.split(",").map(trim8);
           if (this.options.handleProtocols) {
             protocol = this.options.handleProtocols(protocol, req);
           } else {
@@ -32206,7 +32206,7 @@ var require_websocket_server = __commonJS({
       socket.removeListener("error", socketOnError);
       socket.destroy();
     }
-    function trim7(str) {
+    function trim8(str) {
       return str.trim();
     }
   }
@@ -36317,10 +36317,9 @@ var require_rpcDefaults = __commonJS({
   }
 });
 
-// client/src/utilities/crypto/groupPasswordDerivation.cjs
+// shared/crypto/groupPasswordDerivation.cjs
 var require_groupPasswordDerivation = __commonJS({
-  "client/src/utilities/crypto/groupPasswordDerivation.cjs"(exports, module) {
-    "use strict";
+  "shared/crypto/groupPasswordDerivation.cjs"(exports, module) {
     var GROUP_PASSWORD_DERIVATION = "sbt-group-password-v4";
     var GROUP_PASSWORD_PBKDF2_ITERATIONS = 6e5;
     var createGroupPasswordDerivation2 = (ethers7) => {
@@ -36521,8 +36520,7 @@ var readKeyFile = async (keyPath) => {
   }
   return wallet;
 };
-var loadOrCreateWallet = async (stateDir) => {
-  await ensureStateDir(stateDir);
+var loadOrCreateKey = async (stateDir) => {
   const keyPath = path2.join(stateDir, KEY_FILE);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -36530,6 +36528,12 @@ var loadOrCreateWallet = async (stateDir) => {
     } catch (error) {
       if (error?.code !== "ENOENT") throw error;
     }
+    const saved = await readAgentState(stateDir);
+    if (saved.address || Object.keys(saved.sessions).length) {
+      throw new Error(
+        `${keyPath} is missing, but ${STATE_FILE} belongs to ${saved.address ? `agent ${saved.address}` : "an earlier agent"}. Restore the key from a backup, or move ${STATE_FILE} aside to start as a new agent.`
+      );
+    }
     const wallet = import_ethers.ethers.Wallet.createRandom();
     try {
       await writeOwnerOnlyJson(
@@ -36544,7 +36548,21 @@ var loadOrCreateWallet = async (stateDir) => {
   }
   throw new Error(`${keyPath} could not be read or created.`);
 };
-var emptyState = () => ({ version: 1, profile: {}, sessions: {}, current: "" });
+var loadOrCreateWallet = async (stateDir) => {
+  await ensureStateDir(stateDir);
+  const loaded = await loadOrCreateKey(stateDir);
+  await withStateWriter(stateDir, async () => {
+    const state = await readAgentState(stateDir);
+    if (state.address && state.address.toLowerCase() !== loaded.wallet.address.toLowerCase()) {
+      throw new Error(
+        `${path2.join(stateDir, STATE_FILE)} belongs to agent ${state.address}, but ${KEY_FILE} holds ${loaded.wallet.address}. Restore the matching files, or move ${STATE_FILE} aside to start fresh with this key.`
+      );
+    }
+    if (!state.address) await writeOwnerOnlyJson(path2.join(stateDir, STATE_FILE), { ...state, address: loaded.wallet.address });
+  });
+  return loaded;
+};
+var emptyState = () => ({ version: 1, address: "", profile: {}, sessions: {}, current: "" });
 var readAgentState = async (stateDir) => {
   let parsed;
   try {
@@ -36556,6 +36574,8 @@ var readAgentState = async (stateDir) => {
   if (!isRecord(parsed)) return emptyState();
   return {
     version: 1,
+    // The agent this state belongs to; its remembered answers are that agent's.
+    address: typeof parsed.address === "string" ? parsed.address : "",
     profile: isRecord(parsed.profile) ? parsed.profile : {},
     sessions: isRecord(parsed.sessions) ? parsed.sessions : {},
     current: typeof parsed.current === "string" ? parsed.current : ""
@@ -36606,7 +36626,15 @@ var hasId = (message) => Object.prototype.hasOwnProperty.call(message, "id");
 var isValidId = (id) => typeof id === "string" || typeof id === "number" && Number.isFinite(id);
 var errorResponse = (id, code, message) => ({ jsonrpc: "2.0", id, error: { code, message } });
 var resultResponse = (id, result) => ({ jsonrpc: "2.0", id, result });
-var describeError = (error) => String(error?.message || error || "Unknown error.");
+var MAX_ERROR_LENGTH = 1e3;
+var DIAGNOSTICS = /\[ See: |\((?=\w+=)|\b(?:requestBody|body|url|transaction|data|error)=/i;
+var URLS = /\b[a-z][\w+.-]*:\/\/[^\s"'`]+/gi;
+var hostOnly = (url) => /<\w+>/.test(url) ? url : url.replace(/^([^:]+:\/\/)(?:[^/?#]*@)?([^/?#]*)[\s\S]*$/, "$1$2");
+var describeError = (error) => {
+  const text4 = String(error?.message || error || "").slice(0, MAX_ERROR_LENGTH);
+  const cut = text4.search(DIAGNOSTICS);
+  return (cut < 0 ? text4 : text4.slice(0, cut)).trimEnd().replace(URLS, hostOnly) || "Unknown error.";
+};
 var DEFAULT_TOOL_TIMEOUT_MS = 15 * 60 * 1e3;
 var createMcpServer = ({
   serverInfo,
@@ -36801,13 +36829,45 @@ var describeTestEthOffer = ({ config, resourcePresence } = {}) => {
     return { ...result, reason: "Session config is unavailable or unsupported." };
   }
   if (!network) return { ...result, reason: "No supported test network is configured." };
-  if (hosted && !(Array.isArray(config.workerAuthority?.participantScopes) && config.workerAuthority.participantScopes.includes("faucet"))) {
+  if (hosted && !(Array.isArray(config.workerAuthority?.participantScopes) && config.workerAuthority.participantScopes.some((scope) => scope === "faucet_self" || scope === "faucet"))) {
     return { ...result, reason: "Participants are not offered test ETH." };
   }
   if (resourcePresence?.txGas !== true) return { ...result, reason: "A configured faucet has not been confirmed." };
   return { ...result, offered: true };
 };
 
+// mcp/lib/chainErrors.mjs
+var SAFE_CODE = /^[A-Z_]{3,40}$/;
+var SAFE_REASON = /^[A-Za-z][\w .,'()-]{0,119}$/;
+var TX_HASH = /^0x[0-9a-f]{64}$/i;
+var safeErrorCode = (error) => typeof error?.code === "string" && SAFE_CODE.test(error.code) ? error.code : "";
+var safeErrorReason = (error) => [error?.reason, error?.errorName, error?.error?.reason].map((value) => typeof value === "string" ? value.replace(/^execution reverted:?\s*/i, "").trim() : "").find((value) => SAFE_REASON.test(value)) || "";
+var transactionHashOf = (error) => [error?.transactionHash, error?.transaction?.hash, error?.receipt?.transactionHash].find((value) => typeof value === "string" && TX_HASH.test(value));
+var safeChainError = (error, { submission = false } = {}) => {
+  const code = safeErrorCode(error);
+  const detail = [code, safeErrorReason(error)].filter(Boolean).join(": ");
+  const note = detail ? ` (${detail})` : "";
+  if (submission) {
+    const txHash = transactionHashOf(error);
+    return Object.assign(
+      new Error(`${txHash ? `Transaction ${txHash}` : "The transaction"} may have been submitted but its outcome is unknown${note}. Check the chain before retrying.`),
+      { ...code ? { code } : {}, reconciliationRequired: true, ...txHash ? { txHash } : {} }
+    );
+  }
+  const retryable = code !== "CALL_EXCEPTION";
+  return Object.assign(
+    new Error(retryable ? `The chain request failed${note}. Check the RPC connection and retry.` : `The contract rejected the request${note}.`),
+    { ...code ? { code } : {}, retryable }
+  );
+};
+var chainRequest = async (request, options) => {
+  try {
+    return await request();
+  } catch (error) {
+    throw safeChainError(error, options);
+  }
+};
+
 // mcp/lib/testEth.mjs
 var amount = (value) => typeof value === "string" && /^\d+(?:\.\d{1,18})?$/.test(value) ? value : null;
 var pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -36836,9 +36896,9 @@ var createTestEthRequester = ({
   await ctx.client.ensureToken();
   if (ctx.client.tokenClaims?.scopes?.faucet !== true) throw new Error("This session does not offer test ETH to you.");
   const provider = suppliedProvider || createProvider(chainId);
-  const reported = Number(await provider.send("eth_chainId", []));
+  const reported = Number(await chainRequest(() => provider.send("eth_chainId", [])));
   if (reported !== chainId) throw new Error(`The RPC for chain ${chainId} reports chain ${reported}; refusing the faucet request.`);
-  const before = await provider.getBalance(wallet.address);
+  const before = await chainRequest(() => provider.getBalance(wallet.address));
   checkpoint();
   let paid;
   try {
@@ -36872,7 +36932,7 @@ var createTestEthRequester = ({
     let observed;
     try {
       observed = await Promise.race([
-        provider.getBalance(wallet.address).catch(() => null),
+        chainRequest(() => provider.getBalance(wallet.address)).catch(() => null),
         new Promise((resolve) => {
           timer = setTimeout(() => resolve(null), Math.max(0, deadline - now()));
         })
@@ -36895,6 +36955,9 @@ var createTestEthRequester = ({
   };
 };
 
+// mcp/lib/participant.mjs
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+
 // mcp/lib/registrySession.mjs
 var import_ethers5 = __toESM(require_lib32(), 1);
 
@@ -38139,6 +38202,40 @@ function summarizeQuadraticAllocations(responses, question) {
   return { options, totalResponders, excludedResponses };
 }
 
+// shared/questions/questionId.mjs
+var validOptions = (options) => Array.isArray(options) ? options.filter((o) => o && o.trim() !== "") : [];
+var legacyPreimage = (type, prompt, options, singleSelect, voiceCredits) => {
+  let preimage = `${type}:${(prompt || "").trim().toLowerCase()}`;
+  const validOpts = validOptions(options);
+  if (type === "multichoice") {
+    if (validOpts.length > 0)
+      preimage += `:${validOpts.map((o) => o.trim()).join(",").toLowerCase()}`;
+    if (singleSelect) preimage += ":single";
+  }
+  if (type === "quadratic") {
+    preimage += `:${JSON.stringify(validOpts.map((option) => option.trim().toLowerCase()))}:${voiceCredits}`;
+  }
+  return preimage;
+};
+var legacyIsAmbiguous = (type, options, singleSelect) => {
+  if (type !== "multichoice") return false;
+  const labels = validOptions(options).map((o) => o.trim().toLowerCase());
+  return labels.length === 0 || labels.some((label) => label.includes(":") || label.includes(",")) || !singleSelect && labels.length === 1 && labels[0] === "single";
+};
+var v2Text = (text4) => (text4 || "").trim().toLowerCase().normalize("NFC");
+var v2Preimage = (type, prompt, options, singleSelect) => JSON.stringify(["ce-question-id", 2, type, v2Text(prompt), validOptions(options).map(v2Text), !!singleSelect]);
+var createQuestionIdDerivation = (ethers7) => {
+  const { id: hash } = ethers7.utils;
+  const generateQuestionId2 = (type, prompt, options = [], singleSelect = false, voiceCredits = 99) => hash(
+    legacyIsAmbiguous(type, options, singleSelect) ? v2Preimage(type, prompt, options, singleSelect) : legacyPreimage(type, prompt, options, singleSelect, voiceCredits)
+  );
+  const questionIdMatchesContent2 = (id, { type, prompt, options = [], singleSelect = false, voiceCredits = 99 } = {}) => {
+    const wanted = String(id).toLowerCase();
+    return hash(legacyPreimage(type, prompt, options, singleSelect, voiceCredits)) === wanted || type === "multichoice" && hash(v2Preimage(type, prompt, options, singleSelect)) === wanted;
+  };
+  return Object.freeze({ generateQuestionId: generateQuestionId2, questionIdMatchesContent: questionIdMatchesContent2 });
+};
+
 // shared/questions/ratingScale.mjs
 var trim2 = (value) => String(value == null ? "" : value).trim();
 var isObj = (value) => !!value && typeof value === "object" && !Array.isArray(value);
@@ -38207,18 +38304,7 @@ var MAX_COMMENT_LENGTH = 4e3;
 var trim3 = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
 var isRecord3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var fail = (error) => ({ ok: false, error });
-var generateQuestionId = (type, prompt, options = [], singleSelect = false, voiceCredits = 99) => {
-  let dataToHash = `${type}:${(prompt || "").trim().toLowerCase()}`;
-  const validOptions = Array.isArray(options) ? options.filter((option) => typeof option === "string" && option.trim() !== "") : [];
-  if (type === "multichoice") {
-    if (validOptions.length > 0) dataToHash += `:${validOptions.map((option) => option.trim()).join(",").toLowerCase()}`;
-    if (singleSelect) dataToHash += ":single";
-  }
-  if (type === "quadratic") {
-    dataToHash += `:${JSON.stringify(validOptions.map((option) => option.trim().toLowerCase()))}:${voiceCredits}`;
-  }
-  return import_ethers3.ethers.utils.id(dataToHash);
-};
+var { generateQuestionId, questionIdMatchesContent } = createQuestionIdDerivation(import_ethers3.ethers);
 var ratingScaleFor = (question = {}) => normalizeRatingScale(question) || { min: 0, max: 10, minLabel: "0", maxLabel: "10" };
 var optionsOf = (question) => Array.isArray(question.options) ? question.options.filter((option) => typeof option === "string") : [];
 var isSingleSelect = (question) => question.singleSelect === true || question.oneSelectionOnly === true || question.singleChoice === true;
@@ -38462,6 +38548,51 @@ var parseSessionLink = (link, { allowLocalWorkers = false } = {}) => {
 };
 var buildSessionWebUrl = ({ appOrigin, slug, workerOrigin, kind }) => `${appOrigin}/session/${encodeURIComponent(slug)}${kind === "registry" ? "" : `?worker=${encodeURIComponent(workerOrigin)}`}`;
 
+// shared/auth/siweMessage.mjs
+var normalizeSessionIdHex = (value) => {
+  if (typeof value !== "string" || value !== value.trim()) return "";
+  const lower = value.toLowerCase();
+  const hex = lower.startsWith("0x") ? lower.slice(2) : lower;
+  if (/^[0-9a-f]{32}$/.test(hex) && !/^0+$/.test(hex)) return `0x${hex}`;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(lower)) {
+    const uuidHex = lower.replace(/-/g, "");
+    return /^0+$/.test(uuidHex) ? "" : `0x${uuidHex}`;
+  }
+  return "";
+};
+var buildSiweMessage = ({
+  address,
+  nonce,
+  chainId,
+  domain,
+  uri,
+  statement,
+  issuedAt,
+  expirationTime,
+  workerUrl,
+  sessionId,
+  sessionSlug
+}) => {
+  const id = String(sessionId || "").trim().toLowerCase();
+  const slug = sessionSlug === "general" ? "" : String(sessionSlug || "");
+  const sessionResource = id ? `urn:context-engine:session:id:${encodeURIComponent(id)}` : `urn:context-engine:session:slug:${encodeURIComponent(slug)}`;
+  const resources = workerUrl ? `
+Resources:
+- ${new URL(String(workerUrl)).origin}
+- ${sessionResource}` : "";
+  return `${domain} wants you to sign in with your Ethereum account:
+${address}
+
+${statement}
+
+URI: ${uri}
+Version: 1
+Chain ID: ${chainId}
+Nonce: ${nonce}
+Issued At: ${issuedAt}
+Expiration Time: ${expirationTime}${resources}`;
+};
+
 // mcp/lib/workerClient.mjs
 var REQUEST_TIMEOUT_MS = 2e4;
 var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -38521,17 +38652,6 @@ var readLimitedText = async (response, maxBytes = MAX_RESPONSE_BYTES) => {
   }
   return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString("utf8");
 };
-var normalizeSessionIdHex = (value) => {
-  if (typeof value !== "string" || value !== value.trim()) return "";
-  const lower = value.toLowerCase();
-  const hex = lower.startsWith("0x") ? lower.slice(2) : lower;
-  if (/^[0-9a-f]{32}$/.test(hex) && !/^0+$/.test(hex)) return `0x${hex}`;
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(lower)) {
-    const uuidHex = lower.replace(/-/g, "");
-    return /^0+$/.test(uuidHex) ? "" : `0x${uuidHex}`;
-  }
-  return "";
-};
 var resolveSessionIdHex = (config) => {
   const present = (value) => value !== void 0 && value !== null && value !== "";
   const sessionId = normalizeSessionIdHex(config?.sessionId);
@@ -38541,24 +38661,19 @@ var resolveSessionIdHex = (config) => {
   }
   return sessionId || sessionIdHex;
 };
-var buildSiweMessage = ({ address, nonce, appOrigin, workerOrigin, sessionId, sessionSlug = "", issuedAt, expirationTime, chainId = 1 }) => {
-  const { host } = new URL(appOrigin);
-  const resource = sessionId ? `urn:context-engine:session:id:${encodeURIComponent(sessionId)}` : `urn:context-engine:session:slug:${encodeURIComponent(sessionSlug === "general" ? "" : sessionSlug)}`;
-  return `${host} wants you to sign in with your Ethereum account:
-${address}
-
-Sign in to Context Engine.
-
-URI: ${appOrigin}
-Version: 1
-Chain ID: ${chainId}
-Nonce: ${nonce}
-Issued At: ${issuedAt}
-Expiration Time: ${expirationTime}
-Resources:
-- ${workerOrigin}
-- ${resource}`;
-};
+var buildSiweMessage2 = ({ address, nonce, appOrigin, workerOrigin, sessionId, sessionSlug = "", issuedAt, expirationTime, chainId = 1 }) => buildSiweMessage({
+  address,
+  nonce,
+  domain: new URL(appOrigin).host,
+  uri: appOrigin,
+  workerUrl: workerOrigin,
+  sessionId,
+  sessionSlug,
+  issuedAt,
+  expirationTime,
+  chainId,
+  statement: "Sign in to Context Engine."
+});
 var decodeTokenClaims = (token) => {
   try {
     const [payload] = text(token).split(".");
@@ -38679,7 +38794,7 @@ var createWorkerClient = ({ workerOrigin, slug, trustedOrigins, wallet, fetchImp
     const nonce = text(nonceData?.nonce);
     if (!/^[A-Za-z0-9]{8,200}$/.test(nonce)) throw new WorkerRequestError("The Worker did not issue a usable sign-in nonce.");
     const issued = new Date(now());
-    const message = buildSiweMessage({
+    const message = buildSiweMessage2({
       address,
       nonce,
       appOrigin: loginOrigin,
@@ -38744,11 +38859,11 @@ var createWorkerClient = ({ workerOrigin, slug, trustedOrigins, wallet, fetchImp
     }
     return data;
   };
-  const upload = async ({ resource, data, tags = [] }) => {
+  const upload = async ({ resource, data, tags = [], requestId = "" }) => {
     const result = await request("/storage/upload", {
       method: "POST",
       auth: true,
-      body: { backend: "cloudflare", resource, contentType: "application/json", payloadEncrypted: false, tags, data }
+      body: { backend: "cloudflare", resource, contentType: "application/json", payloadEncrypted: false, tags, data, ...requestId ? { requestId } : {} }
     });
     return isRecord4(result?.storageRef) ? result.storageRef : { id: text(result?.id) };
   };
@@ -38793,7 +38908,7 @@ var createWorkerClient = ({ workerOrigin, slug, trustedOrigins, wallet, fetchImp
 // mcp/lib/registryChain.mjs
 var compareChainOrder = (a, b) => Number(a.blockNumber || 0) - Number(b.blockNumber || 0) || Number(a.transactionIndex || 0) - Number(b.transactionIndex || 0) || Number(a.logIndex || 0) - Number(b.logIndex || 0);
 var checkRegistryChain = async (provider, chainId) => {
-  const actual = Number(await provider.send("eth_chainId", []));
+  const actual = Number(await chainRequest(() => provider.send("eth_chainId", [])));
   if (actual !== chainId) throw new Error(`The RPC is on a different chain (${actual}); expected ${chainId}.`);
 };
 var findStartBlock = async (provider, createdAt, head) => {
@@ -38801,7 +38916,7 @@ var findStartBlock = async (provider, createdAt, head) => {
   let high = head;
   while (low < high) {
     const mid = Math.floor((low + high) / 2);
-    const block = await provider.getBlock(mid);
+    const block = await chainRequest(() => provider.getBlock(mid));
     if (!block || !Number.isFinite(Number(block.timestamp))) throw new Error("Could not locate the session creation block.");
     if (Number(block.timestamp) < createdAt) low = mid + 1;
     else high = mid;
@@ -38839,7 +38954,7 @@ var scanRegistryLogs = async ({
         range = Math.max(1, Math.floor((end - begin + 1) / 2));
         continue;
       }
-      throw error;
+      throw safeChainError(error);
     }
     batch = batch.sort((a, b) => descending ? compareChainOrder(b, a) : compareChainOrder(a, b));
     let skipped = 0;
@@ -38971,13 +39086,14 @@ var stopped = (signal) => {
   if (signal?.aborted) throw new Error("Stopped before the chain transaction was sent.");
 };
 var createRegistryWriter = ({ provider, chainId, wallet, surveys, slug, remember }) => {
+  const checkChain = () => checkRegistryChain(provider, chainId);
   const prepare = async ({ client, gasLimit, fund, signal }) => {
     stopped(signal);
-    await checkRegistryChain(provider, chainId);
-    const gasPrice = await provider.getGasPrice();
+    await checkChain();
+    const gasPrice = await chainRequest(() => provider.getGasPrice());
     const cost = gasPrice.mul(gasLimit);
     if (cost.gt(MAX_COST)) throw new Error("This transaction would exceed the 0.005 ETH gas cap; retry when gas is cheaper.");
-    let balance = await provider.getBalance(wallet.address);
+    let balance = await chainRequest(() => provider.getBalance(wallet.address));
     const shortfall = `Fund ${wallet.address} with test ETH on chain ${chainId}; this transaction needs up to ${import_ethers4.ethers.utils.formatEther(cost)} ETH.`;
     let fundingNote = "";
     if (balance.lt(cost) && fund) {
@@ -38991,7 +39107,7 @@ var createRegistryWriter = ({ provider, chainId, wallet, surveys, slug, remember
         }
         if (funding?.sent) fundingNote = ` Faucet transaction ${funding.txHash} was sent; check it before requesting another payout.`;
         else if (funding?.reason === "balance_high") fundingNote = " The faucet refused because the balance is above its threshold.";
-        balance = await provider.getBalance(wallet.address).catch(() => null);
+        balance = await chainRequest(() => provider.getBalance(wallet.address)).catch(() => null);
         if (!balance) throw new Error(`${shortfall}${fundingNote} The current balance could not be checked.`);
       }
     }
@@ -39021,7 +39137,7 @@ var createRegistryWriter = ({ provider, chainId, wallet, surveys, slug, remember
         })
       ]);
     } catch {
-      throw new Error(`Transaction ${tx.hash} was submitted but could not be confirmed. Check it before retrying.`);
+      throw Object.assign(new Error(`Transaction ${tx.hash} was submitted but could not be confirmed. Check it before retrying.`), { txHash: tx.hash, reconciliationRequired: true });
     } finally {
       clearTimeout(timer);
     }
@@ -39046,22 +39162,22 @@ var createRegistryWriter = ({ provider, chainId, wallet, surveys, slug, remember
     const pointers = [];
     for (const record of records) pointers.push(await upload(client, "responses", record.questionID, record, signal));
     stopped(signal);
-    await checkRegistryChain(provider, chainId);
-    const tx = await surveys.connect(wallet.connect(provider)).submitResponses(ids, pointers, import_ethers4.ethers.constants.HashZero, import_ethers4.ethers.constants.HashZero, fees);
+    await checkChain();
+    const tx = await chainRequest(() => surveys.connect(wallet.connect(provider)).submitResponses(ids, pointers, import_ethers4.ethers.constants.HashZero, import_ethers4.ethers.constants.HashZero, fees), { submission: true });
     const receipt = await confirm(tx, "ResponsesSubmitted", ids);
     records.forEach((record, index) => remember("responses", record.questionID, record, pointers[index], receipt));
     return { txHash: tx.hash, receipt };
   };
   const addStatement = async ({ client, record, fund, signal }) => {
-    await checkRegistryChain(provider, chainId);
-    if (await surveys.questionHashes(record.id) !== import_ethers4.ethers.constants.HashZero) {
+    await checkChain();
+    if (await chainRequest(() => surveys.questionHashes(record.id)) !== import_ethers4.ethers.constants.HashZero) {
       throw new Error("This statement already exists on chain, possibly in another session; reword it to add a new statement.");
     }
     const fees = await prepare({ client, gasLimit: 4e5, fund, signal });
     const pointer = await upload(client, "questions", record.id, record, signal);
     stopped(signal);
-    await checkRegistryChain(provider, chainId);
-    const tx = await surveys.connect(wallet.connect(provider)).addQuestions([record.id], [pointer], [import_ethers4.ethers.constants.HashZero], fees);
+    await checkChain();
+    const tx = await chainRequest(() => surveys.connect(wallet.connect(provider)).addQuestions([record.id], [pointer], [import_ethers4.ethers.constants.HashZero], fees), { submission: true });
     const receipt = await confirm(tx, "QuestionsAdded", [record.id]);
     remember("questions", record.id, record, pointer, receipt);
     return { txHash: tx.hash };
@@ -39134,13 +39250,13 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
   const loadConfig = async () => {
     await checkRegistryChain(provider, chainId);
     const slug = info.slug === "general" ? "" : info.slug;
-    const row = await registry.getSessionBySlug(slug);
+    const row = await chainRequest(() => registry.getSessionBySlug(slug));
     if (normalized(row[0]) !== slug) throw new Error("The registry returned a different session.");
     if (text(row[3])) throw new Error("Encrypted registry metadata is unsupported; use an unencrypted session.");
     if (Number(row[1]) !== chainId) throw new Error("The session uses a different chain from this registry.");
     const metadata = await readRegistryMetadata(row[2], { fetchImpl });
     checkMetadata(metadata);
-    const fields = await registry.getSessionFields(slug, ["corsWorkerUrl"]);
+    const fields = await chainRequest(() => registry.getSessionFields(slug, ["corsWorkerUrl"]));
     const workerUrl = text(fields[0]) || text(metadata.corsWorkerUrl);
     if (/^\s*(?:\{|enc:|lit:)/i.test(workerUrl)) throw new Error("Encrypted Worker URLs are unsupported; use an unencrypted registry session.");
     const nextOrigin = normalizeWorkerOrigin(workerUrl, { allowLocalWorkers: config.allowLocalWorkers });
@@ -39163,7 +39279,7 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
     };
     if (startBlock === void 0) {
       const configured = Number(metadata.blockLimits?.start);
-      const head = await provider.getBlockNumber();
+      const head = await chainRequest(() => provider.getBlockNumber());
       startBlock = metadata.blockLimits?.start !== void 0 && Number.isSafeInteger(configured) && configured >= 0 ? configured : await findStartBlock(provider, Number(row[5]), head);
       questionCursor = { block: startBlock, offset: 0 };
     }
@@ -39181,28 +39297,66 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
     return payload;
   };
   const filter = (eventName) => ({ address: surveys.address, topics: [surveys.interface.getEventTopic(eventName)] });
+  const readBlock = (number, blocks) => {
+    if (!blocks.has(number)) blocks.set(number, chainRequest(() => provider.getBlock(number)).catch(() => null));
+    return blocks.get(number);
+  };
+  const readHeadMark = async (number, blocks) => {
+    const block = await readBlock(number, blocks);
+    return block?.hash ? { number, hash: block.hash } : null;
+  };
+  const historyReplaced = async (mark, blocks) => {
+    if (!mark?.hash) return false;
+    const block = await readBlock(mark.number, blocks);
+    return block?.hash ? block.hash !== mark.hash : null;
+  };
+  const replacedWrite = (entry, blocks = /* @__PURE__ */ new Map()) => historyReplaced(entry?.blockHash ? { number: entry.blockNumber, hash: entry.blockHash } : null, blocks);
+  let questionMark = null;
+  const visibleQuestions = () => {
+    const blocked = new Set((Array.isArray(sessionConfig.BLOCKED_QUESTION_IDS) ? sessionConfig.BLOCKED_QUESTION_IDS : []).map(normalized));
+    return [...questions.values()].filter((entry) => !blocked.has(entry.id));
+  };
   const readQuestions = async ({ signal } = {}) => {
     const deadline = now() + 9e4;
+    const blocks = /* @__PURE__ */ new Map();
     let complete = true;
+    const replaced = await historyReplaced(questionMark, blocks);
+    if (replaced === null) return { items: visibleQuestions(), complete: false };
+    if (replaced) {
+      questions.clear();
+      pending.clear();
+      questionCursor = { block: startBlock, offset: 0 };
+      questionMark = null;
+    }
+    for (const [id, entry] of questions) {
+      if (!entry.local) continue;
+      const replaced2 = await replacedWrite(entry, blocks);
+      if (replaced2 === null) complete = false;
+      if (replaced2) questions.delete(id);
+    }
     if (pending.size < MAX_CACHE && questions.size < MAX_QUESTIONS) {
-      const scanned = await scanRegistryLogs({
-        provider,
-        filter: filter("QuestionsAdded"),
-        cursor: questionCursor,
-        toBlock: await provider.getBlockNumber(),
-        maxLogs: 1e3,
-        deadline,
-        now,
-        signal
-      });
-      questionCursor = scanned.cursor;
-      complete = scanned.complete;
-      for (const log2 of scanned.logs) {
-        const event = surveys.interface.parseLog(log2);
-        event.args.questionIds.forEach((id, index) => {
-          if (event.args.surveyIds[index] === import_ethers5.ethers.constants.HashZero && !questions.has(normalized(id))) pending.set(normalized(id), log2);
+      const head = await readHeadMark(await chainRequest(() => provider.getBlockNumber()), blocks);
+      if (head) {
+        const scanned = await scanRegistryLogs({
+          provider,
+          filter: filter("QuestionsAdded"),
+          cursor: questionCursor,
+          toBlock: head.number,
+          maxLogs: 1e3,
+          deadline,
+          now,
+          signal
         });
-      }
+        questionCursor = scanned.cursor;
+        complete = complete && scanned.complete;
+        if (replaced !== null && (!questionMark || head.number >= questionMark.number)) questionMark = head;
+        for (const log2 of scanned.logs) {
+          const event = surveys.interface.parseLog(log2);
+          event.args.questionIds.forEach((id, index) => {
+            if (event.args.surveyIds[index] === import_ethers5.ethers.constants.HashZero && !questions.has(normalized(id))) pending.set(normalized(id), log2);
+          });
+        }
+      } else complete = false;
     } else complete = false;
     const work = [...pending.entries()];
     let next = 0;
@@ -39210,7 +39364,7 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
       while (next < work.length && now() < deadline && !signal?.aborted && questions.size < MAX_QUESTIONS) {
         const [id, log2] = work[next++];
         try {
-          const pointer = await surveys.getQuestionHash(id);
+          const pointer = await chainRequest(() => surveys.getQuestionHash(id));
           const payload = await readPayload(pointer);
           const matches = registryQuestionMatchesSession(payload, sessionConfig);
           if (matches) questions.set(id, { id, payload: { ...payload, id }, createdAt: String(log2.blockNumber).padStart(16, "0"), ...log2 });
@@ -39220,8 +39374,7 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
         }
       }
     }));
-    const blocked = new Set((Array.isArray(sessionConfig.BLOCKED_QUESTION_IDS) ? sessionConfig.BLOCKED_QUESTION_IDS : []).map(normalized));
-    return { items: [...questions.values()].filter((entry) => !blocked.has(entry.id)), complete: complete && !pending.size && questions.size < MAX_QUESTIONS };
+    return { items: visibleQuestions(), complete: complete && !pending.size && questions.size < MAX_QUESTIONS };
   };
   const loadQuestions = (args) => {
     if (!loadingQuestions) loadingQuestions = readQuestions(args).finally(() => {
@@ -39232,17 +39385,41 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
   const readAnswers = async ({ questionIds, maxRecords = 1e4, mine = false, signal } = {}) => {
     const known = new Set(questionIds);
     const deadline = now() + 9e4;
+    const blocks = /* @__PURE__ */ new Map();
+    let verified = true;
     const responseFilter = filter("ResponsesSubmitted");
     if (mine) responseFilter.topics.push(import_ethers5.ethers.utils.hexZeroPad(wallet.address, 32));
-    const head = await provider.getBlockNumber();
+    const head = await chainRequest(() => provider.getBlockNumber());
     const scope = [...known].sort().join(",");
     let state = answerScans.get(mine);
-    if (!state || state.scope !== scope || head < state.head) {
-      state = { scope, head: startBlock - 1, ranges: [], latest: /* @__PURE__ */ new Map(), capped: false };
+    const replaced = !!state && state.scope === scope && head >= state.head && await historyReplaced(state.mark, blocks);
+    if (replaced === null) {
+      const held = new Map((state.result?.entries || []).map((entry) => [`${entry.questionId}:${normalized(entry.responder)}`, entry]));
+      const chainOrders2 = new Map(state.result?.chainOrders || []);
+      for (const entry of localAnswers.values()) {
+        if (!known.has(entry.questionId)) continue;
+        const key = `${entry.questionId}:${normalized(entry.responder)}`;
+        if ([state.latest.get(key), held.get(key)].some((previous) => previous && compareChainOrder(entry, previous) < 0)) continue;
+        chainOrders2.set(entry.questionId, entry);
+        held.delete(key);
+        if (registryResponseMatchesSession(entry.payload, sessionConfig) && entry.payload.answer?.encrypted !== true && normalized(entry.payload.questionID || entry.payload.questionId) === entry.questionId) held.set(key, entry);
+      }
+      return {
+        entries: [...held.values()].sort((a, b) => compareChainOrder(b, a)).slice(0, maxRecords),
+        complete: false,
+        chainOrders: chainOrders2
+      };
+    }
+    if (!state || state.scope !== scope || head < state.head || replaced) {
+      state = { scope, head: startBlock - 1, mark: null, ranges: [], latest: /* @__PURE__ */ new Map(), capped: false };
     } else state = { ...state, ranges: state.ranges.map((range) => ({ ...range })), latest: new Map(state.latest) };
     if (head > state.head) {
-      state.ranges.unshift({ from: Math.max(startBlock, state.head + 1), cursor: { block: head, offset: 0 } });
-      state.head = head;
+      const mark = await readHeadMark(head, blocks);
+      if (mark) {
+        state.ranges.unshift({ from: Math.max(startBlock, state.head + 1), cursor: { block: head, offset: 0 } });
+        state.head = head;
+        if (replaced !== null) state.mark = mark;
+      } else verified = false;
     }
     if (state.ranges.length > 64) {
       const oldest = state.ranges.pop();
@@ -39295,8 +39472,14 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
     answerScans.set(mine, state);
     const scannedAll = !state.ranges.length && !state.capped;
     const latest = new Map(state.latest);
-    for (const entry of localAnswers.values()) {
+    for (const [id, entry] of localAnswers) {
       if (!known.has(entry.questionId)) continue;
+      const replaced2 = await replacedWrite(entry, blocks);
+      if (replaced2 === null) verified = false;
+      if (replaced2) {
+        localAnswers.delete(id);
+        continue;
+      }
       if (!scannedAll && entry.blockNumber <= head) continue;
       const key = `${entry.questionId}:${normalized(entry.responder)}`;
       if (!latest.has(key) || compareChainOrder(entry, latest.get(key)) > 0) latest.set(key, { ...entry, local: true });
@@ -39304,8 +39487,7 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
     const candidates = [...latest.values()].sort((a, b) => compareChainOrder(b, a));
     const chainOrders = new Map(candidates.filter((entry) => normalized(entry.responder) === normalized(wallet.address)).map((entry) => [entry.questionId, entry]));
     const entries = [];
-    const blockTimes = /* @__PURE__ */ new Map();
-    let complete = scannedAll && candidates.length <= maxRecords;
+    let complete = verified && scannedAll && candidates.length <= maxRecords;
     let next = 0;
     const selected = candidates.slice(0, maxRecords);
     await Promise.all(Array.from({ length: Math.min(6, selected.length) }, async () => {
@@ -39316,20 +39498,21 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
         }
         const entry = selected[next++];
         try {
-          const pointer = entry.local ? entry.storageId : await surveys.getResponse(entry.responder, entry.questionId);
+          const pointer = entry.local ? entry.storageId : await chainRequest(() => surveys.getResponse(entry.responder, entry.questionId));
           const payload = await readPayload(pointer);
           if (!registryResponseMatchesSession(payload, sessionConfig) || payload.answer?.encrypted === true) continue;
           if (normalized(payload.questionID || payload.questionId) !== entry.questionId) continue;
-          if (!blockTimes.has(entry.blockNumber)) blockTimes.set(entry.blockNumber, provider.getBlock(entry.blockNumber));
-          const block = await blockTimes.get(entry.blockNumber);
-          const createdAt = block?.timestamp ? new Date(Number(block.timestamp) * 1e3).toISOString() : "";
+          const block = await readBlock(entry.blockNumber, blocks);
+          if (!block) complete = false;
+          const createdAt = block?.timestamp ? new Date(Number(block.timestamp) * 1e3).toISOString() : entry.createdAt || "";
           entries.push({ ...entry, storageId: pointer, createdAt, payload });
         } catch {
           complete = false;
         }
       }
     }));
-    return { entries, complete, chainOrders };
+    state.result = { entries, complete, chainOrders };
+    return state.result;
   };
   const writer = createRegistryWriter({ provider, chainId, wallet, surveys, slug: info.slug, remember: (resource, id, payload, pointer, receipt) => {
     cache(pointer, payload);
@@ -39340,18 +39523,33 @@ var createRegistrySession = async ({ info, config, wallet, fetchImpl = globalThi
       storageId: pointer,
       responder: wallet.address,
       blockNumber: receipt.blockNumber,
+      blockHash: receipt.blockHash,
       transactionIndex: receipt.transactionIndex,
       logIndex: receipt.logs.at(-1)?.logIndex || 0,
       createdAt: new Date(now()).toISOString()
     };
-    if (resource === "questions") questions.set(id, entry);
+    if (resource === "questions") questions.set(id, { ...entry, local: true });
     else localAnswers.set(id, entry);
   } });
-  return { loadConfig, loadQuestions, readAnswers, ...writer, get config() {
+  return { loadConfig, loadQuestions, readAnswers, replacedWrite, ...writer, get config() {
     return sessionConfig;
   }, workerOrigin };
 };
 
+// shared/storage/canonicalStorageVersions.mjs
+var trim5 = (value) => (typeof value === "string" ? value : value == null ? "" : String(value)).trim();
+var compareStorageIds = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var compareVersionAge = (left, right) => (Number(left.createdAtMs) || 0) - (Number(right.createdAtMs) || 0) || compareStorageIds(trim5(left.storageRefId), trim5(right.storageRefId));
+var isAdminStorageVersion = (candidate) => candidate.uploadAuthority === "admin";
+var isPreferredStorageVersion = (candidate, current) => {
+  if (!current) return true;
+  const candidateAdmin = isAdminStorageVersion(candidate);
+  const currentAdmin = isAdminStorageVersion(current);
+  if (candidateAdmin !== currentAdmin) return candidateAdmin;
+  const age = compareVersionAge(candidate, current);
+  return candidateAdmin ? age > 0 : age < 0;
+};
+
 // mcp/lib/results.mjs
 var text2 = (value) => typeof value === "string" ? value.trim() : "";
 var MAX_FREEFORM_SAMPLES = 5;
@@ -39517,12 +39715,12 @@ var REVEAL_WAIT_MS = 9e4;
 var POLL_MS = 2e3;
 var GAS_HEADROOM_PERCENT = 130;
 var PASSWORD_CLAIM_GAS_BUDGET = 4e5;
-var trim5 = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
+var trim6 = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
 var isRecord5 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var { deriveGroupPasswordWallet } = createGroupPasswordDerivation(import_ethers6.ethers);
 var normalizeGroupPasswordInput = (raw) => {
-  const compact = trim5(raw).replace(/\s+/g, "");
+  const compact = trim6(raw).replace(/\s+/g, "");
   if (!compact) return "";
   if (import_ethers6.ethers.utils.isHexString(compact)) {
     try {
@@ -39534,7 +39732,7 @@ var normalizeGroupPasswordInput = (raw) => {
   return compact;
 };
 var decodeInviteCode = (raw) => {
-  let code = trim5(raw);
+  let code = trim6(raw);
   const lower = code.toLowerCase();
   if (lower.startsWith("inv:")) code = code.slice(4).trim();
   else if (lower.startsWith("invite:")) code = code.slice(7).trim();
@@ -39562,13 +39760,13 @@ var accessConditionsOf = (config) => [
   config?.sessionModeProfile?.encryption?.accessConditions,
   config?.storageProfile?.payloadAccessControl?.accessConditions
 ].flatMap((document) => Array.isArray(document?.conditions) ? document.conditions : []);
-var conditionAddresses = (condition) => [condition?.contract, condition?.address, ...Array.isArray(condition?.sbtAddresses) ? condition.sbtAddresses : []].map((value) => trim5(value).toLowerCase()).filter(Boolean);
+var conditionAddresses = (condition) => [condition?.contract, condition?.address, ...Array.isArray(condition?.sbtAddresses) ? condition.sbtAddresses : []].map((value) => trim6(value).toLowerCase()).filter(Boolean);
 var positiveChainId = (value) => {
   const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
   return Number.isSafeInteger(number) && number > 0 ? number : 0;
 };
 var resolveSbtChainId = (config, sbtAddress) => {
-  const target = trim5(sbtAddress).toLowerCase();
+  const target = trim6(sbtAddress).toLowerCase();
   const condition = accessConditionsOf(config).find(
     (entry) => entry?.kind === "sbt_onchain" && conditionAddresses(entry).includes(target) && positiveChainId(entry.chainId)
   );
@@ -39586,19 +39784,13 @@ var listSessionSbts = (config) => {
   return [...seen.values()];
 };
 var defaultCreateProvider = (rpcOverride) => (chainId) => {
-  const url = trim5(rpcOverride) || import_rpcDefaults3.default.getPublicRpcUrls(chainId)[0] || import_rpcDefaults3.default.getPathRpcUrl(chainId);
+  const url = trim6(rpcOverride) || import_rpcDefaults3.default.getPublicRpcUrls(chainId)[0] || import_rpcDefaults3.default.getPathRpcUrl(chainId);
   if (!url) throw new Error(`No public RPC is known for chain ${chainId}; set CE_MCP_RPC_URL.`);
   return new import_ethers6.ethers.providers.StaticJsonRpcProvider(url, chainId);
 };
 var ClaimError = class extends Error {
 };
-var SAFE_REASON_RE = /^[A-Za-z][\w .,'()-]{0,119}$/;
-var safeMessage = (error, fallback) => {
-  if (error instanceof ClaimError) return error.message;
-  const reason = [error?.reason, error?.errorName, error?.error?.reason].map((value) => typeof value === "string" ? value.replace(/^execution reverted:?\s*/i, "").trim() : "").find((value) => SAFE_REASON_RE.test(value));
-  const code = typeof error?.code === "string" && /^[A-Z_]{3,40}$/.test(error.code) ? error.code : "";
-  return [fallback, reason || code].filter(Boolean).join(": ");
-};
+var safeMessage = (error, fallback) => error instanceof ClaimError ? error.message : [fallback, safeErrorReason(error) || safeErrorCode(error)].filter(Boolean).join(": ");
 var createSbtClaimer = ({
   config = {},
   wallet,
@@ -39711,7 +39903,7 @@ var createSbtClaimer = ({
   const claimWithGroupPassword = async ({ ctx, provider, chainId, contract, sbtAddress, password }) => {
     const normalized2 = normalizeGroupPasswordInput(password);
     if (!normalized2) throw new ClaimError("This SBT needs a group password.");
-    const expectedHash = trim5(await contract.groupPasswordHash()).toLowerCase();
+    const expectedHash = trim6(await contract.groupPasswordHash()).toLowerCase();
     if (!expectedHash || expectedHash === import_ethers6.ethers.constants.HashZero) throw new ClaimError("This SBT has no group password set.");
     const groupWallet = await deriveGroupPasswordWallet({ password: normalized2, sbtAddress });
     if (import_ethers6.ethers.utils.solidityKeccak256(["address"], [groupWallet.address]) !== expectedHash) {
@@ -39745,7 +39937,7 @@ var createSbtClaimer = ({
       signal = callSignal;
       let address;
       try {
-        address = import_ethers6.ethers.utils.getAddress(trim5(sbtAddress));
+        address = import_ethers6.ethers.utils.getAddress(trim6(sbtAddress));
       } catch {
         throw new ClaimError("Pass the SBT contract address (0x\u2026).");
       }
@@ -39778,7 +39970,7 @@ var createSbtClaimer = ({
         const args = { ctx, provider, chainId, contract, sbtAddress: address };
         let transactions;
         if (mode === "public") transactions = [(await send({ ...args, method: "claim", args: [] })).transactionHash];
-        else if (mode === "password") transactions = await claimWithCommitReveal({ ...args, password: trim5(claimPassword) || trim5(groupPassword) });
+        else if (mode === "password") transactions = await claimWithCommitReveal({ ...args, password: trim6(claimPassword) || trim6(groupPassword) });
         else if (mode === "group_password") transactions = await claimWithGroupPassword({ ...args, password: groupPassword });
         else transactions = await claimWithInviteCode({ ...args, code: inviteCode || groupPassword });
         return { ...base, mode, status: "claimed", transactions };
@@ -39807,7 +39999,7 @@ var MAX_TITLE_LENGTH = 120;
 var MAX_CONTEXT_PARAGRAPHS = 4;
 var MAX_CONTEXT_LENGTH = 2e3;
 var MAX_CONTEXT_LINKS = 4;
-var trim6 = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
+var trim7 = (value) => typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
 var isRecord6 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var sessionKey = (info) => info.kind === "registry" ? `registry ${info.chainId || 11155420} ${info.slug}` : `${info.workerOrigin} ${info.slug}`;
 var mapLimit = async (items, limit, task) => {
@@ -39868,18 +40060,10 @@ var sanitizeQuestion = (payload, id) => {
   ratingScaleFor(question);
   return question;
 };
-var contentId = (question) => generateQuestionId(question.type, question.prompt, stringOptions(question), isSingleSelect(question), question.voiceCredits ?? 99);
-var chooseQuestionVersion = (versions) => {
-  const admin = versions.filter((version) => version.uploaderIsAdmin);
-  if (admin.length) return admin.sort((left, right) => left.createdAt < right.createdAt ? 1 : -1)[0];
-  const ranked = [...versions].sort((left, right) => {
-    const leftMatches = left.contentMatches === true ? 0 : 1;
-    const rightMatches = right.contentMatches === true ? 0 : 1;
-    if (leftMatches !== rightMatches) return leftMatches - rightMatches;
-    return left.createdAt < right.createdAt ? -1 : left.createdAt > right.createdAt ? 1 : 0;
-  });
-  return ranked[0];
-};
+var chooseQuestionVersion = (versions) => versions.reduce(
+  (chosen, candidate) => isPreferredStorageVersion(candidate, chosen) ? candidate : chosen,
+  null
+);
 var describeQuestion = (question, myAnswer) => {
   const options = stringOptions(question);
   const entry = {
@@ -39941,9 +40125,9 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
     state = await updateAgentState(config.stateDir, mutate);
   };
   const profile = () => ({
-    displayName: trim6(state?.profile?.displayName ?? config.profile.displayName),
-    modelId: trim6(state?.profile?.modelId ?? config.profile.modelId),
-    platform: trim6(state?.profile?.platform ?? config.profile.platform)
+    displayName: trim7(state?.profile?.displayName ?? config.profile.displayName),
+    modelId: trim7(state?.profile?.modelId ?? config.profile.modelId),
+    platform: trim7(state?.profile?.platform ?? config.profile.platform)
   });
   const trustedOriginsFor = (preferred) => config.trustedAppOrigins.includes(preferred) ? [preferred, ...config.trustedAppOrigins.filter((origin) => origin !== preferred)] : config.trustedAppOrigins;
   const openSession = async (info) => {
@@ -39994,18 +40178,19 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
     const entry = fresh.sessions[sessionKey(ctx.info)];
     if (!isRecord6(entry) || entry.sessionId !== ctx.client.sessionId) return;
     entry.answers = isRecord6(entry.answers) ? entry.answers : {};
-    answered.forEach(({ questionId, record, answeredAt, chainOrder }) => {
+    answered.forEach(({ questionId, record, answeredAt, chainOrder, requestId }) => {
       entry.answers[questionId] = {
         value: record.answer.value,
         comment: record.additional.value,
         answeredAt,
         ...ctx.registry && chainOrder ? chainOrder : {}
       };
+      if (requestId && entry.pendingUploads?.[questionId]?.requestId === requestId) delete entry.pendingUploads[questionId];
     });
   });
   const resolveSession = async (session) => {
     await loadState();
-    const ref = trim6(session);
+    const ref = trim7(session);
     if (/^https?:\/\//i.test(ref)) {
       const parsed = parseSessionLink(ref, { allowLocalWorkers: config.allowLocalWorkers });
       const key2 = sessionKey(parsed);
@@ -40116,8 +40301,9 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
         list.push({
           payload: question,
           createdAt: text(item.metadata?.createdAt),
-          uploaderIsAdmin: item.metadata?.uploaderIsAdmin === true,
-          contentMatches: question.locked ? null : contentId(question) === id
+          createdAtMs: Date.parse(text(item.metadata?.createdAt)) || 0,
+          storageRefId: text(item.storageRef.id),
+          uploadAuthority: item.metadata?.uploadAuthority
         });
         versions.set(id, list);
       } catch {
@@ -40195,24 +40381,28 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
     await ensureReady(ctx);
     const scan = await scanMyAnswers(ctx);
     const mine = new Map(scan.answers);
-    const complete = scan.complete;
+    let complete = scan.complete;
+    const blocks = /* @__PURE__ */ new Map();
     await loadState();
     const local = sessionState(ctx).sessionId === ctx.client.sessionId && isRecord6(sessionState(ctx).answers) ? sessionState(ctx).answers : {};
-    Object.entries(local).forEach(([questionId, answer]) => {
-      if (!isRecord6(answer)) return;
-      if (ctx.registry && !complete) return;
+    for (const [questionId, answer] of Object.entries(local)) {
+      if (!isRecord6(answer)) continue;
+      if (ctx.registry && !scan.complete) continue;
       const known = mine.get(questionId);
       const chainOrder = scan.chainOrders?.get(questionId);
-      if (ctx.registry && chainOrder && compareChainOrder(answer, chainOrder) < 0) return;
+      if (ctx.registry && chainOrder && compareChainOrder(answer, chainOrder) < 0) continue;
       const newer = ctx.registry ? !known || compareChainOrder(answer, known) > 0 : !known || text(answer.answeredAt) > known.createdAt;
-      if (newer) {
+      if (!newer) continue;
+      const replaced = ctx.registry ? await ctx.registry.replacedWrite(answer, blocks) : false;
+      if (replaced === null) complete = false;
+      if (!replaced) {
         mine.set(questionId, {
           createdAt: text(answer.answeredAt),
           ...ctx.registry ? { blockNumber: answer.blockNumber, transactionIndex: answer.transactionIndex, logIndex: answer.logIndex } : {},
           payload: { answer: { value: answer.value }, additional: { value: answer.comment } }
         });
       }
-    });
+    }
     [...mine.entries()].forEach(([questionId, entry]) => {
       const value = entry?.payload?.answer?.value;
       if (value === "" || value === null || value === void 0 || Array.isArray(value) && !value.length) mine.delete(questionId);
@@ -40254,9 +40444,9 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
     },
     async joinSession({ link, worker, session, inviteCode, groupPassword, claimPassword } = {}) {
       let parsed;
-      if (trim6(link)) {
+      if (trim7(link)) {
         parsed = parseSessionLink(link, { allowLocalWorkers: config.allowLocalWorkers });
-      } else if (trim6(worker) && trim6(session)) {
+      } else if (trim7(worker) && trim7(session)) {
         parsed = {
           appOrigin: config.appOrigin,
           slug: normalizeSessionSlug(session),
@@ -40277,9 +40467,9 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
       const offered = parsed.sbtClaims.filter((claim) => !claim.auto).map((claim) => claim.sbt);
       if (offered.length) outcome.sbtsToClaimWithClaimSbt = offered;
       const separateCodes = {
-        inviteCode: trim6(inviteCode),
-        groupPassword: trim6(groupPassword),
-        claimPassword: trim6(claimPassword)
+        inviteCode: trim7(inviteCode),
+        groupPassword: trim7(groupPassword),
+        claimPassword: trim7(claimPassword)
       };
       const hasSeparateCodes = Object.values(separateCodes).some(Boolean);
       if (hasSeparateCodes && claims.length !== 1) {
@@ -40309,7 +40499,7 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
               })
             );
           } catch (error) {
-            outcome.sbtClaims.push({ sbt: claim.sbt, status: "failed", error: error.message });
+            outcome.sbtClaims.push({ sbt: claim.sbt, status: "failed", error: describeError(error) });
           }
         }
         tokenClaims = await ctx.client.login().then((claims2) => {
@@ -40320,7 +40510,7 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
       outcome.testEth = await ctx.client.describeTestEth();
       outcome.signedIn = !loginError;
       if (loginError) {
-        outcome.readOnlyReason = loginError.message;
+        outcome.readOnlyReason = describeError(loginError);
         outcome.note = "Joined read-only: public questions and results are available, but uploads, answers, statements, and faucet requests need Worker access.";
       }
       const scopes = isRecord6(tokenClaims?.scopes) ? tokenClaims.scopes : {};
@@ -40332,7 +40522,7 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
           await ctx.client.joinGroup(parsed.joinGroupId);
           outcome.joinedGroup = parsed.joinGroupId;
         } catch (error) {
-          outcome.groupJoinError = error.message;
+          outcome.groupJoinError = describeError(error);
         }
       }
       outcome.description = text(sessionConfig.sessionInfo).slice(0, MAX_CONTEXT_LENGTH);
@@ -40393,10 +40583,12 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
       const results = [];
       const answered = [];
       const pendingAnswers = [];
+      const operationId = randomUUID2();
       let txHash;
+      let reconciliationRequired = false;
       const seen = /* @__PURE__ */ new Set();
       for (const item of answers) {
-        const questionId = trim6(item?.questionId).toLowerCase();
+        const questionId = trim7(item?.questionId).toLowerCase();
         if (seen.has(questionId)) {
           results.push({ questionId, ok: false, error: "This question appears more than once in the call; send one answer per question." });
           continue;
@@ -40436,12 +40628,23 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
           continue;
         }
         try {
-          const storageRef = await ctx.client.upload({ resource: "responses", data: JSON.stringify(built.record) });
+          const data = JSON.stringify(built.record);
+          const digest = createHash("sha256").update(data).digest("hex");
+          let requestId;
+          await saveState((fresh) => {
+            const entry = fresh.sessions[sessionKey(ctx.info)];
+            if (!isRecord6(entry) || entry.sessionId !== ctx.client.sessionId) throw new Error("Session identity changed; join again before answering.");
+            entry.pendingUploads = isRecord6(entry.pendingUploads) ? entry.pendingUploads : {};
+            const previous = entry.pendingUploads[questionId];
+            requestId = previous?.payloadDigest === digest && trim7(previous.requestId) ? previous.requestId : `answer:v1:${operationId}:${questionId}`;
+            entry.pendingUploads[questionId] = { payloadDigest: digest, requestId };
+          });
+          const storageRef = await ctx.client.upload({ resource: "responses", data, requestId });
           if (text(storageRef?.id)) cacheRecord(ctx, text(storageRef.id), built.record);
-          answered.push({ questionId, record: built.record, answeredAt: text(storageRef?.createdAt) || new Date(now()).toISOString() });
+          answered.push({ questionId, requestId, record: built.record, answeredAt: text(storageRef?.createdAt) || new Date(now()).toISOString() });
           results.push({ questionId, ok: true, answer: built.record.answer.value });
         } catch (error) {
-          results.push({ questionId, ok: false, error: error.message });
+          results.push({ questionId, ok: false, error: describeError(error) });
         }
       }
       if (pendingAnswers.length) {
@@ -40456,19 +40659,32 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
           pendingAnswers.forEach(({ questionId, record }) => {
             answered.push({ questionId, record, answeredAt: new Date(now()).toISOString(), chainOrder: {
               blockNumber: submitted.receipt.blockNumber,
+              blockHash: submitted.receipt.blockHash,
               transactionIndex: submitted.receipt.transactionIndex,
               logIndex: submitted.receipt.logs.at(-1)?.logIndex || 0
             } });
             results.push({ questionId, ok: true, answer: record.answer.value });
           });
         } catch (error) {
-          pendingAnswers.forEach(({ questionId }) => results.push({ questionId, ok: false, error: error.message }));
+          if (typeof error.txHash === "string" && /^0x[0-9a-f]{64}$/i.test(error.txHash)) txHash = error.txHash;
+          reconciliationRequired = error.reconciliationRequired === true;
+          pendingAnswers.forEach(({ questionId }) => results.push({ questionId, ok: false, error: describeError(error) }));
+        }
+      }
+      let warning;
+      if (answered.length) {
+        try {
+          await rememberAnswers(ctx, answered);
+        } catch {
+          ctx.ownScan = null;
+          warning = "Answers were submitted, but the local answer history could not be saved. Do not resubmit them to fix this warning.";
         }
       }
-      if (answered.length) await rememberAnswers(ctx, answered);
       return {
         session: ctx.info.slug,
         ...txHash ? { txHash } : {},
+        ...reconciliationRequired ? { reconciliationRequired: true } : {},
+        ...warning ? { warning } : {},
         submitted: results.filter((result) => result.ok).length,
         failed: results.filter((result) => !result.ok).length,
         results
@@ -40586,7 +40802,7 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
       const ctx = await resolveSession(session);
       if (ctx.registry) throw new Error("Worker groups are not available in on-chain sessions.");
       await ensureReady(ctx);
-      const id = trim6(groupId);
+      const id = trim7(groupId);
       if (!/^[A-Za-z0-9._:-]{1,128}$/.test(id)) throw new Error("Pass a valid group id.");
       checkpoint();
       await ctx.client.joinGroup(id);
@@ -40601,10 +40817,10 @@ var createParticipant = ({ config, wallet, fetchImpl = globalThis.fetch, now = (
       });
       const result = await sbt.claim({
         ctx,
-        sbtAddress: trim6(sbtAddress),
-        inviteCode: trim6(inviteCode),
-        groupPassword: trim6(groupPassword),
-        claimPassword: trim6(claimPassword),
+        sbtAddress: trim7(sbtAddress),
+        inviteCode: trim7(inviteCode),
+        groupPassword: trim7(groupPassword),
+        claimPassword: trim7(claimPassword),
         signal
       });
       await ctx.client.login().catch(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agalmic/contextengine",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "MCP server that lets an AI agent take part in Context Engine sessions as its own participant",
   "license": "MPL-2.0",
   "type": "module",