@synapsor/runner 1.4.0 → 1.4.12

package/dist/runner.mjs

@@ -3,7 +3,7 @@
 // apps/runner/src/cli.ts
 import fs5 from "node:fs/promises";
 import { spawn, spawnSync } from "node:child_process";
-import crypto8 from "node:crypto";
+import crypto9 from "node:crypto";
 import net from "node:net";
 import os from "node:os";
 import path5 from "node:path";
@@ -12,7 +12,42 @@ import readline from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // packages/protocol/src/index.ts
+import crypto2 from "node:crypto";
 import { z } from "zod";
+function canonicalJsonStringify(input) {
+  return JSON.stringify(canonicalJsonValue(input, /* @__PURE__ */ new Set()));
+}
+function canonicalJsonDigest(input) {
+  return `sha256:${crypto2.createHash("sha256").update(canonicalJsonStringify(input)).digest("hex")}`;
+}
+function canonicalJsonValue(input, ancestors) {
+  if (input === null || typeof input === "string" || typeof input === "boolean") return input;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) throw new TypeError("canonical JSON accepts only finite numbers");
+    return Object.is(input, -0) ? 0 : input;
+  }
+  if (Array.isArray(input)) {
+    if (ancestors.has(input)) throw new TypeError("canonical JSON does not accept circular values");
+    ancestors.add(input);
+    const output2 = input.map((item) => canonicalJsonValue(item, ancestors));
+    ancestors.delete(input);
+    return output2;
+  }
+  if (typeof input !== "object" || input === void 0) throw new TypeError("canonical JSON accepts only JSON values");
+  const record = input;
+  const prototype = Object.getPrototypeOf(record);
+  if (prototype !== Object.prototype && prototype !== null) throw new TypeError("canonical JSON accepts only plain objects");
+  if (ancestors.has(record)) throw new TypeError("canonical JSON does not accept circular values");
+  ancestors.add(record);
+  const output = {};
+  for (const key of Object.keys(record).sort()) {
+    const value = record[key];
+    if (value === void 0) throw new TypeError("canonical JSON does not accept undefined values");
+    output[key] = canonicalJsonValue(value, ancestors);
+  }
+  ancestors.delete(record);
+  return output;
+}
 var scalar = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 var scalarMap = z.record(scalar).refine((value) => Object.keys(value).length > 0, "object must not be empty");
 var boundedScalarRecord = z.record(scalar).refine((value) => Object.keys(value).length <= 256, "object exceeds 256 fields");
@@ -2755,7 +2790,7 @@ function isRecord(value) {
 }
 
 // packages/mcp-server/src/index.ts
-import crypto4 from "node:crypto";
+import crypto5 from "node:crypto";
 import fs2 from "node:fs";
 import { createServer } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
@@ -2766,11 +2801,11 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
 // packages/postgres/src/index.ts
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 import { Pool, types as pgTypes } from "pg";
 
 // packages/worker-core/src/index.ts
-import crypto2 from "node:crypto";
+import crypto3 from "node:crypto";
 
 // packages/worker-core/src/mcp-audit.ts
 var MCP_AUDIT_DISCLAIMER = "This is a static risk review, not proof that an MCP server is secure.";
@@ -3308,21 +3343,21 @@ function assertFrozenSetJobIntegrity(job) {
       if (member.before[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("SET_TENANT_GUARD_MISMATCH");
       const expectedAfter = { ...member.before, ...job.patch, [job.version_advance.column]: member.expected_version.value + 1 };
       if (!recordsEqual(member.after, expectedAfter)) throw new Error("SET_AFTER_STATE_MISMATCH");
-      if (member.before_digest !== reconciliationDigest({ primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
-      if (member.after_digest !== reconciliationDigest({ primary_key: member.primary_key.value, after: member.after })) throw new Error("SET_AFTER_DIGEST_MISMATCH");
+      if (!reviewedDigestMatches(member.before_digest, { primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
+      if (!reviewedDigestMatches(member.after_digest, { primary_key: member.primary_key.value, after: member.after })) throw new Error("SET_AFTER_DIGEST_MISMATCH");
     } else if (job.operation === "set_delete") {
       if (!member.expected_version || member.before[member.expected_version.column] !== member.expected_version.value) throw new Error("SET_VERSION_GUARD_MISMATCH");
       if (member.before[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("SET_TENANT_GUARD_MISMATCH");
       if (Object.keys(member.after).length !== 0) throw new Error("SET_DELETE_PATCH_FORBIDDEN");
-      if (member.before_digest !== reconciliationDigest({ primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
-      if (member.tombstone_digest !== reconciliationDigest({ primary_key: member.primary_key.value, expected_version: member.expected_version })) throw new Error("SET_TOMBSTONE_DIGEST_MISMATCH");
+      if (!reviewedDigestMatches(member.before_digest, { primary_key: member.primary_key.value, before: member.before })) throw new Error("SET_BEFORE_DIGEST_MISMATCH");
+      if (!reviewedDigestMatches(member.tombstone_digest, { primary_key: member.primary_key.value, expected_version: member.expected_version })) throw new Error("SET_TOMBSTONE_DIGEST_MISMATCH");
     } else {
       const components = member.deduplication?.components ?? [];
       const primary = components.find((component) => component.column === job.target.primary_key.column);
       const tenant = components.find((component) => component.column === job.target.tenant_guard.column);
       if (!primary || primary.value !== member.primary_key.value || !tenant || tenant.source !== "trusted_tenant" || tenant.value !== job.target.tenant_guard.value) throw new Error("BATCH_DEDUP_REQUIRED");
       if (member.after[job.target.primary_key.column] !== member.primary_key.value || member.after[job.target.tenant_guard.column] !== job.target.tenant_guard.value) throw new Error("BATCH_IDENTITY_MISMATCH");
-      if (member.after_digest !== reconciliationDigest({ primary_key: member.primary_key.value, after: member.after })) throw new Error("SET_AFTER_DIGEST_MISMATCH");
+      if (!reviewedDigestMatches(member.after_digest, { primary_key: member.primary_key.value, after: member.after })) throw new Error("SET_AFTER_DIGEST_MISMATCH");
     }
   }
   for (const bound of set.aggregate_bounds) {
@@ -3333,8 +3368,24 @@ function assertFrozenSetJobIntegrity(job) {
     }, 0);
     if (actual !== bound.actual || actual > bound.maximum) throw new Error("SET_AGGREGATE_BOUND_MISMATCH");
   }
-  const expectedSetDigest = reconciliationDigest({ operation: job.operation, members: set.members, aggregate_bounds: set.aggregate_bounds });
-  if (set.set_digest !== expectedSetDigest) throw new Error("SET_DIGEST_MISMATCH");
+  const setMaterial = { operation: job.operation, members: set.members, aggregate_bounds: set.aggregate_bounds };
+  const legacyContractMaterial = {
+    operation: job.operation,
+    members: set.members,
+    aggregate_bounds: set.aggregate_bounds.map((bound) => ({
+      column: bound.column,
+      maximum: bound.maximum,
+      measure: bound.measure,
+      actual: bound.actual
+    }))
+  };
+  if (!reviewedDigestMatches(set.set_digest, setMaterial, legacyContractMaterial)) throw new Error("SET_DIGEST_MISMATCH");
+}
+function reviewedDigestMatches(actual, current, legacyContract) {
+  if (!actual) return false;
+  const expected = /* @__PURE__ */ new Set([canonicalJsonDigest(current), reconciliationDigest(current)]);
+  if (legacyContract) expected.add(reconciliationDigest(legacyContract));
+  return expected.has(actual);
 }
 function recordValuesMatch(actual, expected, valuesEqual) {
   return Object.entries(expected).every(([column, value]) => valuesEqual(actual[column], value));
@@ -3352,7 +3403,7 @@ function asScalar(value) {
   return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : String(value);
 }
 function reconciliationDigest(value) {
-  return `sha256:${crypto2.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+  return `sha256:${crypto3.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
 }
 function loadConfig(env = process.env) {
   const engine = (env.SYNAPSOR_ENGINE || "postgres").toLowerCase();
@@ -3606,7 +3657,7 @@ function scalar2(value) {
   return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : String(value);
 }
 function digest(value) {
-  return `sha256:${crypto3.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+  return `sha256:${crypto4.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
 }
 function reconciliationProjection(job) {
   const columns = /* @__PURE__ */ new Set([job.target.primary_key.column, job.target.tenant_guard.column, ...job.allowed_columns]);
@@ -10897,7 +10948,7 @@ async function handleStreamableHttpMcpRequest(input) {
     }
     let session;
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => crypto4.randomUUID(),
+      sessionIdGenerator: () => crypto5.randomUUID(),
       onsessioninitialized: (newSessionId) => {
         if (session) {
           session.sessionId = newSessionId;
@@ -11038,7 +11089,7 @@ function validBearerToken(header, expected) {
   const actual = header.slice("Bearer ".length);
   const actualBuffer = Buffer.from(actual);
   const expectedBuffer = Buffer.from(expected);
-  return actualBuffer.length === expectedBuffer.length && crypto4.timingSafeEqual(actualBuffer, expectedBuffer);
+  return actualBuffer.length === expectedBuffer.length && crypto5.timingSafeEqual(actualBuffer, expectedBuffer);
 }
 function resolveMetricsEndpointAccess(config, env, host) {
   if (config.metrics?.enabled !== true) return { enabled: false };
@@ -11178,7 +11229,7 @@ async function checkRunnerReadiness(config, env = process.env, timeoutMs = 3e3)
         const table = `${quotePostgresIdentifier(shared.schema ?? "synapsor_runner")}.ledger_entries`;
         await client.query(
           `INSERT INTO ${table} (entry_key, kind, payload_json) VALUES ($1, 'readiness_probe', '{}'::jsonb)`,
-          [`readiness:${crypto4.randomUUID()}`]
+          [`readiness:${crypto5.randomUUID()}`]
         );
         await client.query("ROLLBACK");
       } catch (error) {
@@ -11274,7 +11325,7 @@ function bearerToken(header) {
   return token || void 0;
 }
 function tokenFingerprint(token) {
-  return `sha256:${crypto4.createHash("sha256").update(token).digest("hex")}`;
+  return `sha256:${crypto5.createHash("sha256").update(token).digest("hex")}`;
 }
 function safeSessionClaim(value) {
   if (typeof value !== "string") return void 0;
@@ -11338,7 +11389,7 @@ function toolNameExposureMap(canonicalNames, style) {
   return exposedByCanonical;
 }
 function shortToolHash(value) {
-  return crypto4.createHash("sha256").update(value).digest("hex").slice(0, 8);
+  return crypto5.createHash("sha256").update(value).digest("hex").slice(0, 8);
 }
 function setCorsHeaders(response, corsOrigin) {
   if (corsOrigin) {
@@ -12339,7 +12390,7 @@ function buildBoundedSetChangeSet(input) {
       primary_key: { column: input.capability.target.primary_key, value: primary.value },
       before: {},
       after,
-      after_digest: hashJson({ primary_key: primary.value, after }),
+      after_digest: canonicalJsonDigest({ primary_key: primary.value, after }),
       deduplication
     };
   }) : input.currentRows.map((rawRow) => {
@@ -12354,8 +12405,8 @@ function buildBoundedSetChangeSet(input) {
         expected_version: expectedVersion,
         before,
         after: {},
-        before_digest: hashJson({ primary_key: primaryValue, before }),
-        tombstone_digest: hashJson({ primary_key: primaryValue, expected_version: expectedVersion })
+        before_digest: canonicalJsonDigest({ primary_key: primaryValue, before }),
+        tombstone_digest: canonicalJsonDigest({ primary_key: primaryValue, expected_version: expectedVersion })
       };
     }
     const after = { ...before, ...input.patch };
@@ -12369,15 +12420,20 @@ function buildBoundedSetChangeSet(input) {
       expected_version: expectedVersion,
       before,
       after,
-      before_digest: hashJson({ primary_key: primaryValue, before }),
-      after_digest: hashJson({ primary_key: primaryValue, after })
+      before_digest: canonicalJsonDigest({ primary_key: primaryValue, before }),
+      after_digest: canonicalJsonDigest({ primary_key: primaryValue, after })
     };
   });
   const members = rawMembers.sort((left, right) => JSON.stringify(left.primary_key.value).localeCompare(JSON.stringify(right.primary_key.value)));
   if (new Set(members.map((member) => JSON.stringify(member.primary_key.value))).size !== members.length) {
     throw new McpRuntimeError("SET_IDENTITY_NOT_UNIQUE", "Every frozen set member must have a unique primary-key identity.");
   }
-  const aggregateBounds = operation.aggregate_bounds.map((bound) => ({ ...bound, actual: aggregateValue(members, bound) }));
+  const aggregateBounds = operation.aggregate_bounds.map((bound) => ({
+    column: bound.column,
+    measure: bound.measure,
+    maximum: bound.maximum,
+    actual: aggregateValue(members, bound)
+  }));
   for (const bound of aggregateBounds) {
     if (bound.actual > bound.maximum) throw new McpRuntimeError("SET_AGGREGATE_BOUND_EXCEEDED", `${bound.measure} aggregate for ${bound.column} exceeds the reviewed maximum ${bound.maximum}.`);
   }
@@ -12386,7 +12442,7 @@ function buildBoundedSetChangeSet(input) {
     row_count: members.length,
     aggregate_bounds: aggregateBounds,
     members,
-    set_digest: hashJson({ operation: kind, members, aggregate_bounds: aggregateBounds })
+    set_digest: canonicalJsonDigest({ operation: kind, members, aggregate_bounds: aggregateBounds })
   };
   const approvalMode = input.capability.approval?.mode === "operator" ? "operator" : "human";
   const proposalCore = {
@@ -12512,7 +12568,7 @@ var RuntimeRateLimiter = class {
     if (this.sharedPool && this.sharedSchema) {
       await this.migration;
       const table = `${quotePostgresIdentifier(this.sharedSchema)}.rate_limit_buckets`;
-      const bucketKey = crypto4.createHash("sha256").update(`${context.tenant_id}\0${capability}`).digest("hex");
+      const bucketKey = crypto5.createHash("sha256").update(`${context.tenant_id}\0${capability}`).digest("hex");
       const result = await this.sharedPool.query(
         `INSERT INTO ${table} AS bucket (bucket_key, window_start, request_count, rejected_count)
          VALUES ($1, $2, 1, 0)
@@ -13102,10 +13158,10 @@ function proposalAlreadyExists(existing) {
   );
 }
 function stableId(prefix, input) {
-  return `${prefix}_${crypto4.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 20)}`;
+  return `${prefix}_${crypto5.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 20)}`;
 }
 function hashJson(input) {
-  return `sha256:${crypto4.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
+  return `sha256:${crypto5.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
 }
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -13127,7 +13183,7 @@ function toolErrorPayload(error) {
 }
 
 // packages/mysql/src/index.ts
-import crypto5 from "node:crypto";
+import crypto6 from "node:crypto";
 import mysql2 from "mysql2/promise";
 var mysqlReceiptMigration = `CREATE TABLE IF NOT EXISTS synapsor_writeback_receipts (
   idempotency_key varchar(255) PRIMARY KEY,
@@ -13241,7 +13297,7 @@ function scalar4(value) {
   return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : String(value);
 }
 function digest2(value) {
-  return `sha256:${crypto5.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+  return `sha256:${crypto6.createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
 }
 function resultHash2(job, status, version) {
   return digest2({ job_id: job.job_id, status, version });
@@ -15621,7 +15677,7 @@ function parseList(value) {
 }
 function unsupported(item, blockKind) {
   if (/ROOT\s+EXTERNAL|JOIN\s+EXTERNAL|RETURN\s+ANSWER|AUTO\s+BRANCH|AUTO\s+MERGE/i.test(item.text)) {
-    throw dslError(item.line, 1, "UNSUPPORTED_PREVIEW_SYNTAX", `${blockKind} clause is not supported by @synapsor/dsl 0.1 preview: ${item.text}`);
+    throw dslError(item.line, 1, "UNSUPPORTED_PREVIEW_SYNTAX", `${blockKind} clause is not supported by the current @synapsor/dsl grammar: ${item.text}`);
   }
   throw dslError(item.line, 1, "UNSUPPORTED_DSL_CLAUSE", `unsupported ${blockKind} clause: ${item.text}`);
 }
@@ -15630,7 +15686,7 @@ function dslError(line, column, code, message2) {
 }
 
 // apps/runner/src/local-ui.ts
-import crypto6 from "node:crypto";
+import crypto7 from "node:crypto";
 import fs3 from "node:fs/promises";
 import { createServer as createServer2 } from "node:http";
 import path3 from "node:path";
@@ -15641,8 +15697,8 @@ async function startLocalUiServer(options = {}) {
   }
   const configPath = path3.resolve(options.configPath ?? "synapsor.runner.json");
   const storePath = path3.resolve(options.storePath ?? "./.synapsor/local.db");
-  const token = options.token ?? crypto6.randomBytes(24).toString("base64url");
-  const csrfToken = options.csrfToken ?? crypto6.randomBytes(24).toString("base64url");
+  const token = options.token ?? crypto7.randomBytes(24).toString("base64url");
+  const csrfToken = options.csrfToken ?? crypto7.randomBytes(24).toString("base64url");
   const storeAccess = options.storeAccess ?? localStoreAccess(storePath);
   const server = createServer2(async (request, response) => {
     try {
@@ -16606,7 +16662,7 @@ function stringOrDefault(value, fallback) {
 }
 
 // apps/runner/src/operator-identity.ts
-import crypto7 from "node:crypto";
+import crypto8 from "node:crypto";
 import fs4 from "node:fs/promises";
 import path4 from "node:path";
 async function resolveOperatorIdentity(input) {
@@ -16692,8 +16748,8 @@ async function resolveOperatorIdentity(input) {
   const decision = operatorDecision(input, subject);
   const canonical = stableJson(decision);
   const decisionHash = sha2562(canonical);
-  const signature = crypto7.sign("sha256", Buffer.from(canonical), privateKey).toString("base64url");
-  if (!crypto7.verify("sha256", Buffer.from(canonical), publicKey, Buffer.from(signature, "base64url"))) {
+  const signature = crypto8.sign("sha256", Buffer.from(canonical), privateKey).toString("base64url");
+  if (!crypto8.verify("sha256", Buffer.from(canonical), publicKey, Buffer.from(signature, "base64url"))) {
     throw new Error(`private key does not match the reviewed public key for operator ${subject}`);
   }
   const core = {
@@ -16717,7 +16773,7 @@ function verifyJwtOperatorProof(proof, attestationSecret) {
   const expected = hmacAttestation(unsigned, attestationSecret);
   const actualBuffer = Buffer.from(signature);
   const expectedBuffer = Buffer.from(expected);
-  if (actualBuffer.length !== expectedBuffer.length || !crypto7.timingSafeEqual(actualBuffer, expectedBuffer)) return false;
+  if (actualBuffer.length !== expectedBuffer.length || !crypto8.timingSafeEqual(actualBuffer, expectedBuffer)) return false;
   const core = { ...unsigned, signature };
   return proof.integrity_hash === sha2562(stableJson(core));
 }
@@ -16727,7 +16783,7 @@ function verifySignedOperatorProof(proof, publicKey) {
   if (proof.decision_hash !== sha2562(canonical)) return false;
   const { integrity_hash: _integrity, ...core } = proof;
   if (proof.integrity_hash !== sha2562(stableJson(core))) return false;
-  return crypto7.verify("sha256", Buffer.from(canonical), publicKey, Buffer.from(proof.signature, "base64url"));
+  return crypto8.verify("sha256", Buffer.from(canonical), publicKey, Buffer.from(proof.signature, "base64url"));
 }
 function operatorDecision(input, subject) {
   return {
@@ -16781,10 +16837,10 @@ function rolesFromClaim(value) {
   return [...new Set(roles)].sort();
 }
 function hmacAttestation(value, secret) {
-  return crypto7.createHmac("sha256", secret).update(stableJson(value)).digest("base64url");
+  return crypto8.createHmac("sha256", secret).update(stableJson(value)).digest("base64url");
 }
 function sha2562(value) {
-  return `sha256:${crypto7.createHash("sha256").update(value).digest("hex")}`;
+  return `sha256:${crypto8.createHash("sha256").update(value).digest("hex")}`;
 }
 function stableJson(value) {
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -16883,7 +16939,7 @@ function isRecord7(value) {
 // apps/runner/package.json
 var package_default = {
   name: "@synapsor/runner",
-  version: "1.4.0",
+  version: "1.4.12",
   description: "Stop giving AI agents execute_sql; expose reviewed Postgres/MySQL MCP actions with proposals, approval, writeback, and replay.",
   license: "Apache-2.0",
   type: "module",
@@ -16918,6 +16974,7 @@ var package_default = {
     "AGENTS.md",
     "CHANGELOG.md",
     "CONTRIBUTING.md",
+    "SECURITY.md",
     "LICENSE",
     "NOTICE",
     "THREAT_MODEL.md",
@@ -16972,8 +17029,8 @@ var package_default = {
 // packages/dsl/package.json
 var package_default2 = {
   name: "@synapsor/dsl",
-  version: "1.4.0",
-  description: "Preview SQL-like Synapsor authoring DSL compiler for canonical @synapsor/spec contracts.",
+  version: "1.4.1",
+  description: "SQL-like Synapsor authoring frontend for canonical @synapsor/spec contracts.",
   license: "Apache-2.0",
   type: "module",
   main: "dist/index.js",
@@ -17900,6 +17957,7 @@ async function runInitWizard(args, options = {}) {
 `);
     const smoke2 = await maybeRunGeneratedSmokeCall({
       config: generated.config,
+      configPath: outputPath,
       env: options.env ?? process2.env,
       input: { [lookupArg]: smokeObjectId },
       readUrlEnv: configDatabaseUrlEnv,
@@ -18342,14 +18400,18 @@ async function maybeRunGeneratedSmokeCall(input) {
       ""
     ].join("\n");
   }
-  const store = new ProposalStore(input.storePath);
-  const runtime = createMcpRuntime(input.config, { store, env: input.env, readRow: input.readRow });
+  const runtime = createMcpRuntime(input.config, { storePath: input.storePath, env: input.env, readRow: input.readRow });
   try {
     const result = await runtime.callTool(input.toolName, input.input);
     return [
-      "Smoke call ran successfully.",
+      result.ok === false ? "Smoke call attempted but did not pass." : "Smoke call ran successfully.",
       "",
-      formatSmokeCallResult(input.toolName, input.input, result, input.storePath)
+      formatSmokeCallResult(input.toolName, input.input, result, {
+        configPath: input.configPath,
+        storePath: input.storePath,
+        storeAuthority: "local_sqlite",
+        sharedPostgresSchema: "synapsor_runner"
+      })
     ].join("\n");
   } catch (error) {
     const message2 = error instanceof Error ? error.message : String(error);
@@ -20374,8 +20436,8 @@ function trustedCliContext(config, capability, env) {
   return { tenant_id: tenant, principal };
 }
 function createCompensationProposal(input) {
-  const proposalId = `wrp_revert_${crypto8.randomBytes(10).toString("hex")}`;
-  const evidenceId = `ev_revert_${crypto8.randomBytes(10).toString("hex")}`;
+  const proposalId = `wrp_revert_${crypto9.randomBytes(10).toString("hex")}`;
+  const evidenceId = `ev_revert_${crypto9.randomBytes(10).toString("hex")}`;
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const one = input.inverse.members.length === 1 ? input.inverse.members[0] : void 0;
   const before = one ? one.expected_state : { row_count: input.inverse.members.length };
@@ -20845,7 +20907,7 @@ function executorConfig(config, executorName) {
   throw new Error(`executor ${executorName} has unsupported type`);
 }
 function signHandlerRequestBody(body, secret) {
-  return `sha256=${crypto8.createHmac("sha256", secret).update(body).digest("hex")}`;
+  return `sha256=${crypto9.createHmac("sha256", secret).update(body).digest("hex")}`;
 }
 async function applyHttpHandlerProposal(input) {
   const duplicate = duplicateHandlerReceipt(input.store, input.proposalId);
@@ -21050,7 +21112,7 @@ function buildHandlerReceipt(input) {
   };
 }
 function hashReceipt(input) {
-  return `sha256:${crypto8.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
+  return `sha256:${crypto9.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
 }
 function formatApplyResult(job, result, dryRun, storePath) {
   const status = writebackResultStatus(result);
@@ -22113,7 +22175,7 @@ function reconciliationReceipt(intent, observation, outcome, runnerId, reason) {
     };
     return {
       ...base2,
-      receipt_hash: `sha256:${crypto8.createHash("sha256").update(JSON.stringify(base2)).digest("hex")}`
+      receipt_hash: `sha256:${crypto9.createHash("sha256").update(JSON.stringify(base2)).digest("hex")}`
     };
   }
   if (job.protocol_version !== protocolVersions.normalizedWritebackJobV2) throw new Error("single-row reconciliation requires a writeback-job v2");
@@ -22140,7 +22202,7 @@ function reconciliationReceipt(intent, observation, outcome, runnerId, reason) {
   };
   return {
     ...base,
-    receipt_hash: `sha256:${crypto8.createHash("sha256").update(JSON.stringify(base)).digest("hex")}`
+    receipt_hash: `sha256:${crypto9.createHash("sha256").update(JSON.stringify(base)).digest("hex")}`
   };
 }
 function publicWritebackIntent(intent) {
@@ -23429,8 +23491,7 @@ async function smokeCall(args) {
   const storePath = optionalArg(args, "--store") ?? process2.env.SYNAPSOR_LOCAL_STORE ?? defaultStorePath;
   const config = await readRuntimeConfig(configPath);
   const env = envWithDemoDefaults(config, configPath);
-  const store = new ProposalStore(storePath);
-  const runtime = createMcpRuntime(config, { store, env });
+  const runtime = createMcpRuntime(config, { storePath, env });
   try {
     const tools2 = runtime.listTools();
     const requestedTool = firstPositional(args);
@@ -23442,13 +23503,28 @@ async function smokeCall(args) {
     if (!capability && config.mode !== "cloud") throw new Error(`capability not found in ${configPath}: ${toolName}`);
     const input = capability ? await smokeToolInput(args, capability) : await smokeInputFromArgs(args);
     const result = await runtime.callTool(toolName, input);
+    const ok = result.ok !== false;
+    const storeAuthority = config.storage?.shared_postgres?.mode === "runtime_store" ? "shared_postgres" : "local_sqlite";
     if (args.includes("--json")) {
-      process2.stdout.write(`${JSON.stringify({ ok: true, tool: toolName, input, result, store_path: storePath }, null, 2)}
+      process2.stdout.write(`${JSON.stringify({
+        ok,
+        tool: toolName,
+        input,
+        result,
+        store_path: storePath,
+        store_authority: storeAuthority,
+        ...storeAuthority === "shared_postgres" ? { shared_postgres_schema: config.storage?.shared_postgres?.schema ?? "synapsor_runner" } : {}
+      }, null, 2)}
 `);
     } else {
-      process2.stdout.write(formatSmokeCallResult(toolName, input, result, storePath));
+      process2.stdout.write(formatSmokeCallResult(toolName, input, result, {
+        configPath,
+        storePath,
+        storeAuthority,
+        sharedPostgresSchema: config.storage?.shared_postgres?.schema ?? "synapsor_runner"
+      }));
     }
-    return 0;
+    return ok ? 0 : 1;
   } finally {
     await runtime.close();
   }
@@ -23665,13 +23741,25 @@ async function smokeInputFromArgs(args, capability) {
   if (sample) return {};
   return {};
 }
-function formatSmokeCallResult(toolName, input, result, storePath) {
-  const evidenceId = stringField(result, "evidence_bundle_id");
-  const proposalId = stringField(result, "proposal_id");
+function formatSmokeCallResult(toolName, input, result, topology) {
+  const proposal = isRecord8(result.proposal) ? result.proposal : void 0;
+  const evidence2 = isRecord8(result.evidence) ? result.evidence : void 0;
+  const error = isRecord8(result.error) ? result.error : void 0;
+  const evidenceId = stringField(result, "evidence_bundle_id") ?? (evidence2 ? stringField(evidence2, "bundle_id") : void 0);
+  const proposalId = stringField(result, "proposal_id") ?? (proposal ? stringField(proposal, "id") : void 0);
   const replayResource = stringField(result, "replay_resource");
   const sourceChanged = result.source_database_changed === true || result.source_database_mutated === true;
+  const ok = result.ok !== false;
+  const storeLines = topology.storeAuthority === "shared_postgres" ? [
+    "Authoritative ledger:",
+    `shared Postgres (${topology.sharedPostgresSchema})`,
+    "",
+    "Local --store path:",
+    `${topology.storePath} (compatibility path only; no authoritative smoke records are written here)`,
+    ""
+  ] : ["Local ledger:", topology.storePath, ""];
   const lines = [
-    "Synapsor smoke call: ok",
+    `Synapsor smoke call: ${ok ? "ok" : "failed"}`,
     "",
     "Tool:",
     toolName,
@@ -23684,20 +23772,32 @@ function formatSmokeCallResult(toolName, input, result, storePath) {
     "",
     "Evidence:",
     evidenceId || "(not returned)",
-    ""
+    "",
+    ...storeLines
   ];
+  if (!ok) {
+    lines.push("Error:", error ? stringField(error, "code") ?? "UNCLASSIFIED" : "UNCLASSIFIED");
+    if (error?.retryable === true) {
+      lines.push("Retryable:", "yes");
+      const retryAfter = error.retry_after_ms;
+      if (typeof retryAfter === "number") lines.push("Retry after:", `${retryAfter} ms`);
+    }
+    return `${lines.join("\n")}
+`;
+  }
   if (proposalId) {
     lines.push("Proposal:", proposalId, "", "Replay:", replayResource || `synapsor://replay/replay_${proposalId}`, "");
   }
+  const storeSuffix = topology.storeAuthority === "shared_postgres" ? ` --config ${topology.configPath} --store ${topology.storePath}` : ` --store ${topology.storePath}`;
   lines.push("Next:");
-  if (evidenceId) lines.push(`  ${cliCommandName()} evidence show ${evidenceId} --store ${storePath}`);
+  if (evidenceId) lines.push(`  ${cliCommandName()} evidence show ${evidenceId}${storeSuffix}`);
   if (proposalId) {
-    lines.push(`  ${cliCommandName()} proposals show ${proposalId} --store ${storePath}`);
-    lines.push(`  ${cliCommandName()} proposals approve ${proposalId} --store ${storePath}`);
-    lines.push(`  ${cliCommandName()} apply ${proposalId} --store ${storePath}`);
-    lines.push(`  ${cliCommandName()} replay show --proposal ${proposalId} --store ${storePath}`);
+    lines.push(`  ${cliCommandName()} proposals show ${proposalId}${storeSuffix}`);
+    lines.push(`  ${cliCommandName()} proposals approve ${proposalId}${storeSuffix}`);
+    lines.push(`  ${cliCommandName()} apply ${proposalId}${storeSuffix}`);
+    lines.push(`  ${cliCommandName()} replay show --proposal ${proposalId}${storeSuffix}`);
   } else if (evidenceId) {
-    lines.push(`  ${cliCommandName()} query-audit list --evidence ${evidenceId} --store ${storePath}`);
+    lines.push(`  ${cliCommandName()} query-audit list --evidence ${evidenceId}${storeSuffix}`);
   }
   return `${lines.join("\n")}
 `;
@@ -25616,7 +25716,7 @@ no rows deleted
         await pool.query(`DELETE FROM ${qualified} WHERE entry_key = ANY($1::text[])`, [archivedEntries.map((entry) => entry.entry_key)]);
       }
       const retentionEntry = {
-        entry_key: `retention:${crypto8.randomUUID()}`,
+        entry_key: `retention:${crypto9.randomUUID()}`,
         kind: "retention_event",
         payload: {
           cutoff,
@@ -27647,7 +27747,7 @@ function toExecutionReceipt(job, result, dryRun) {
   const affectedRows2 = result.affected_rows ?? 0;
   const terminalStatus = result.status === "applied" && !dryRun && affectedRows2 === 0 ? "already_applied" : result.status;
   const previousVersion = job.conflict_guard.kind === "version_column" ? job.conflict_guard.expected_value : void 0;
-  const receiptHash = typeof result.result_hash === "string" && result.result_hash.startsWith("sha256:") ? result.result_hash : `sha256:${crypto8.createHash("sha256").update(JSON.stringify({
+  const receiptHash = typeof result.result_hash === "string" && result.result_hash.startsWith("sha256:") ? result.result_hash : `sha256:${crypto9.createHash("sha256").update(JSON.stringify({
     job_id: job.job_id,
     status: terminalStatus,
     affected_rows: affectedRows2,

package/docs/README.md

@@ -24,6 +24,10 @@ no-database demo, wire your database, then read deeper concepts.
 ## 02 Why Raw SQL Is Dangerous
 
 - [Security Boundary](security-boundary.md): what the model can and cannot see.
+- [Why Synapsor Over Prompt And Application
+  Guardrails](why-synapsor-vs-app-guardrails.md): where SQL authority lives,
+  what a hand-built semantic tool already gets right, and when the shared
+  contract, approval, receipt, and replay layer is worth adopting.
 - [MCP Audit](mcp-audit.md): static review for risky database MCP tools such as
   `execute_sql`, broad query tools, model-controlled tenant filters, or
   model-facing approval/commit tools.

package/docs/benchmarks/bounded-set-local.md

@@ -0,0 +1,27 @@
+# Bounded Set Local Measurements
+
+These measurements are test evidence, not throughput claims or capacity
+guidance. They record one run of `corepack pnpm test:bounded-set` on 2026-07-13
+using synthetic rows and disposable local Docker databases.
+
+Environment:
+
+- Linux laptop, Intel Core i7-13800H, 20 logical CPUs, 30 GiB RAM;
+- Node.js 22.22.2 and pnpm 10.14.0;
+- Docker 29.5.2;
+- PostgreSQL 16 and MySQL 8 containers;
+- source-database receipt authority with an administrator-precreated receipt
+  table;
+- one sequential set UPDATE per measurement, including connection setup,
+  source receipt, lock/preflight, transaction, and exact receipt generation.
+
+| Engine | 1 row | 10 rows | 100 rows |
+| --- | ---: | ---: | ---: |
+| PostgreSQL | 30.42 ms | 53.88 ms | 154.90 ms |
+| MySQL | 25.30 ms | 53.91 ms | 163.20 ms |
+
+These figures are not portable across hardware, network topology, source
+indexes, lock contention, triggers, database configuration, or receipt mode.
+The claim supported by this gate is only that execution stays bounded and the
+hard 100-row ceiling is exercised on both adapters. Operators must benchmark
+their own reviewed contracts and database topology.