@synapsor/runner 0.1.15 → 0.1.16

package/dist/runner.mjs

@@ -1381,7 +1381,7 @@ function isRecord(value) {
 }
 
 // packages/mcp-server/src/index.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import fs from "node:fs";
 import { createServer } from "node:http";
 import path from "node:path";
@@ -1390,9 +1390,291 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 
+// packages/postgres/src/index.ts
+import crypto from "node:crypto";
+import { Pool, types as pgTypes } from "pg";
+var postgresReceiptMigration = `CREATE TABLE IF NOT EXISTS synapsor_writeback_receipts (
+  idempotency_key text PRIMARY KEY,
+  job_id text UNIQUE NOT NULL,
+  proposal_id text NOT NULL,
+  status text NOT NULL,
+  result_hash text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  completed_at timestamptz
+)`;
+var POSTGRES_TIMESTAMP_OIDS = /* @__PURE__ */ new Set([1114, 1184]);
+function postgresPoolConfig(connectionString) {
+  return {
+    connectionString,
+    types: {
+      getTypeParser(oid, format) {
+        if ((format ?? "text") === "text" && POSTGRES_TIMESTAMP_OIDS.has(oid)) {
+          return (value) => value;
+        }
+        return pgTypes.getTypeParser(oid, format);
+      }
+    }
+  };
+}
+function createPostgresPool(connectionString) {
+  return new Pool(postgresPoolConfig(connectionString));
+}
+function quotePostgresIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`unsafe postgres identifier: ${identifier}`);
+  }
+  return `"${identifier}"`;
+}
+function buildPostgresUpdate(job) {
+  validatePostgresPatch(job);
+  const values = [];
+  const setFragments = Object.entries(job.patch).map(([column, value]) => {
+    values.push(value);
+    return `${quotePostgresIdentifier(column)} = $${values.length}`;
+  });
+  values.push(job.target.primary_key.value);
+  const pkParam = `$${values.length}`;
+  values.push(job.target.tenant_guard.value);
+  const tenantParam = `$${values.length}`;
+  const where = [
+    `${quotePostgresIdentifier(job.target.primary_key.column)} = ${pkParam}`,
+    `${quotePostgresIdentifier(job.target.tenant_guard.column)} = ${tenantParam}`
+  ];
+  if (job.conflict_guard.kind === "version_column") {
+    values.push(job.conflict_guard.expected_value);
+    where.push(`${quotePostgresIdentifier(job.conflict_guard.column)} = $${values.length}`);
+  }
+  const sql = `UPDATE ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
+SET ${setFragments.join(", ")}
+WHERE ${where.join(" AND ")}`;
+  return { sql, values };
+}
+function validatePostgresPatch(job) {
+  const patchColumns = Object.keys(job.patch || {});
+  if (!patchColumns.length) {
+    throw new Error("postgres writeback patch must not be empty");
+  }
+  const allowedColumns = new Set(Array.isArray(job.allowed_columns) ? job.allowed_columns : []);
+  if (allowedColumns.has(job.target.primary_key.column)) {
+    throw new Error("postgres primary key column must not be patch-allowlisted");
+  }
+  if (allowedColumns.has(job.target.tenant_guard.column)) {
+    throw new Error("postgres tenant guard column must not be patch-allowlisted");
+  }
+  for (const column of patchColumns) {
+    if (!allowedColumns.has(column)) {
+      throw new Error(`postgres patch column not allowlisted: ${column}`);
+    }
+  }
+}
+function resultHash(job, status, version) {
+  return `sha256:${crypto.createHash("sha256").update(JSON.stringify({ job_id: job.job_id, status, version })).digest("hex")}`;
+}
+function normalizeVersionValue(value) {
+  if (value instanceof Date) return normalizeVersionValue(value.toISOString());
+  const text = String(value ?? "").trim();
+  const timestamp = text.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}(?::?\d{2})?)?$/i);
+  if (timestamp) {
+    const fraction = (timestamp[3] ?? "").padEnd(6, "0").slice(0, 6);
+    const offset = timestamp[4];
+    if (offset && offset.toUpperCase() !== "Z") {
+      const dateParts = timestamp[1].split("-");
+      const timeParts = timestamp[2].split(":");
+      const year = Number(dateParts[0]);
+      const month = Number(dateParts[1]);
+      const day = Number(dateParts[2]);
+      const hour = Number(timeParts[0]);
+      const minute = Number(timeParts[1]);
+      const second = Number(timeParts[2]);
+      const utc = new Date(Date.UTC(year, month - 1, day, hour, minute, second) - offsetMinutes(offset) * 6e4);
+      return `${utc.getUTCFullYear()}-${pad2(utc.getUTCMonth() + 1)}-${pad2(utc.getUTCDate())} ${pad2(utc.getUTCHours())}:${pad2(utc.getUTCMinutes())}:${pad2(utc.getUTCSeconds())}.${fraction}`;
+    }
+    return `${timestamp[1]} ${timestamp[2]}.${fraction}`;
+  }
+  return text;
+}
+function offsetMinutes(offset) {
+  const sign = offset.startsWith("-") ? -1 : 1;
+  const compact = offset.slice(1).replace(":", "");
+  const hours = Number(compact.slice(0, 2));
+  const minutes = Number(compact.slice(2, 4) || "0");
+  return sign * (hours * 60 + minutes);
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function versionValuesMatch(actual, expected) {
+  return normalizeVersionValue(actual) === normalizeVersionValue(expected);
+}
+async function withTransaction(client, fn) {
+  await client.query("BEGIN");
+  try {
+    const result = await fn();
+    await client.query("COMMIT");
+    return result;
+  } catch (error) {
+    await client.query("ROLLBACK").catch(() => void 0);
+    throw error;
+  }
+}
+async function applyPostgresJob(job, config) {
+  if (config.dryRun) {
+    buildPostgresUpdate(job);
+    return {
+      protocol_version: "1.0",
+      job_id: job.job_id,
+      runner_id: config.runnerId,
+      status: "applied",
+      affected_rows: 0,
+      result_hash: resultHash(job, "dry-run"),
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (!config.databaseUrl) {
+    return failed(job, config, "DATABASE_UNAVAILABLE");
+  }
+  const pool = createPostgresPool(config.databaseUrl);
+  const client = await pool.connect();
+  try {
+    return await applyPostgresJobWithClient(job, config, client);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "TRANSACTION_FAILED";
+    return failed(job, config, message.includes("MULTI_ROW") ? "MULTI_ROW_WRITE_BLOCKED" : message.includes("VERSION") ? "VERSION_CONFLICT" : "TRANSACTION_FAILED");
+  } finally {
+    client.release();
+    await pool.end();
+  }
+}
+async function applyPostgresJobWithClient(job, config, client) {
+  return await withTransaction(client, async () => {
+    const existing = await claimReceipt(client, job, config);
+    if (existing) return existing;
+    const conflictProjection = job.conflict_guard.kind === "version_column" ? `, ${quotePostgresIdentifier(job.conflict_guard.column)}::text AS "__synapsor_conflict_value"` : "";
+    const row = await client.query(
+      `SELECT *${conflictProjection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
+WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1
+  AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2
+FOR UPDATE`,
+      [job.target.primary_key.value, job.target.tenant_guard.value]
+    );
+    if (!row.rowCount) {
+      const hash2 = resultHash(job, "ROW_NOT_FOUND");
+      await recordReceipt(client, job, "conflict", hash2);
+      return conflict(job, config, "ROW_NOT_FOUND", hash2);
+    }
+    const currentVersion = row.rows[0]?.__synapsor_conflict_value ?? row.rows[0]?.[job.conflict_guard.kind === "version_column" ? job.conflict_guard.column : ""];
+    if (job.conflict_guard.kind === "version_column" && !versionValuesMatch(currentVersion, job.conflict_guard.expected_value)) {
+      const hash2 = resultHash(job, "VERSION_CONFLICT", currentVersion);
+      await recordReceipt(client, job, "conflict", hash2);
+      return conflict(job, config, "VERSION_CONFLICT", hash2);
+    }
+    const update = buildPostgresUpdate(job);
+    const applied = await client.query(update.sql, update.values);
+    if (applied.rowCount !== 1) {
+      throw new Error(applied.rowCount === 0 ? "VERSION_CONFLICT" : "MULTI_ROW_WRITE_BLOCKED");
+    }
+    const hash = resultHash(job, "applied", job.conflict_guard.kind === "version_column" ? job.conflict_guard.expected_value : void 0);
+    await recordReceipt(client, job, "applied", hash);
+    return {
+      protocol_version: "1.0",
+      job_id: job.job_id,
+      runner_id: config.runnerId,
+      status: "applied",
+      affected_rows: 1,
+      result_hash: hash,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  });
+}
+async function claimReceipt(client, job, config) {
+  const claimed = await client.query(
+    `INSERT INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash)
+VALUES ($1, $2, $3, 'in_progress', NULL)
+ON CONFLICT (idempotency_key) DO NOTHING
+RETURNING status, result_hash`,
+    [job.idempotency_key, job.job_id, job.proposal_id]
+  );
+  if (claimed.rowCount === 1) return void 0;
+  const receipt = await client.query(
+    "SELECT status, result_hash FROM synapsor_writeback_receipts WHERE idempotency_key = $1 FOR UPDATE",
+    [job.idempotency_key]
+  );
+  const row = receipt.rows[0];
+  if (!row) return failed(job, config, "IDEMPOTENCY_RECEIPT_UNAVAILABLE");
+  return resultFromExistingReceipt(job, config, row.status, row.result_hash);
+}
+function resultFromExistingReceipt(job, config, status, hash) {
+  const result_hash = typeof hash === "string" && hash ? hash : resultHash(job, "idempotent");
+  if (status === "applied" || status === "already_applied") {
+    return {
+      protocol_version: "1.0",
+      job_id: job.job_id,
+      runner_id: config.runnerId,
+      status: "already_applied",
+      affected_rows: 0,
+      result_hash,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (status === "conflict") return conflict(job, config, "IDEMPOTENT_CONFLICT", result_hash);
+  if (status === "failed") return failed(job, config, "IDEMPOTENT_FAILED");
+  return failed(job, config, "IDEMPOTENCY_RECEIPT_IN_PROGRESS");
+}
+async function recordReceipt(client, job, status, hash) {
+  const result = await client.query(
+    `UPDATE synapsor_writeback_receipts
+SET status = $2, result_hash = $3, completed_at = now()
+WHERE idempotency_key = $1`,
+    [job.idempotency_key, status, hash]
+  );
+  if (result.rowCount !== 1) throw new Error("IDEMPOTENCY_RECEIPT_UNAVAILABLE");
+}
+function conflict(job, config, code, result_hash) {
+  return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "conflict", affected_rows: 0, error_code: code, result_hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function failed(job, config, code) {
+  return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "failed", error_code: code, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+}
+var postgresAdapter = {
+  async doctor(config) {
+    if (!config.databaseUrl) return { ok: false, details: { error: "database URL required; local config apply reads source.write_url_env, legacy workers use SYNAPSOR_DATABASE_URL" } };
+    const pool = createPostgresPool(config.databaseUrl);
+    const client = await pool.connect();
+    try {
+      const result = await client.query("SELECT version()");
+      await client.query("BEGIN");
+      try {
+        const doctorId = `doctor-${Date.now()}`;
+        await client.query(
+          `INSERT INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash, completed_at)
+VALUES ($1, $2, $3, $4, $5, now())`,
+          [doctorId, doctorId, "doctor", "doctor", "sha256:doctor"]
+        );
+        await client.query("ROLLBACK");
+      } catch (error) {
+        await client.query("ROLLBACK").catch(() => void 0);
+        throw error;
+      }
+      return {
+        ok: true,
+        details: {
+          version: result.rows[0]?.version,
+          receipt_table: "ready",
+          write_permission_rollback: true,
+          dry_run: config.dryRun
+        }
+      };
+    } finally {
+      client.release();
+      await pool.end();
+    }
+  },
+  apply: applyPostgresJob
+};
+
 // packages/proposal-store/src/index.ts
 import { DatabaseSync } from "node:sqlite";
-import { mkdirSync } from "node:fs";
+import { chmodSync, mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 var ProposalStoreError = class extends Error {
   constructor(code, message) {
@@ -1408,9 +1690,17 @@ var ProposalStore = class {
   constructor(path4 = ":memory:") {
     this.path = path4;
     if (path4 !== ":memory:") {
-      mkdirSync(dirname(resolve(path4)), { recursive: true });
+      mkdirSync(dirname(resolve(path4)), { recursive: true, mode: 448 });
     }
     this.db = new DatabaseSync(path4);
+    if (path4 !== ":memory:" && process.platform !== "win32") {
+      try {
+        chmodSync(path4, 384);
+      } catch (error) {
+        process.stderr.write(`warning: unable to restrict Synapsor store permissions to 0600: ${error instanceof Error ? error.message : String(error)}
+`);
+      }
+    }
     this.migrate();
   }
   close() {
@@ -1802,6 +2092,18 @@ var ProposalStore = class {
       }
       return existing;
     }
+    const active = this.findActiveProposal({
+      tenant_id: changeSet.scope.tenant_id,
+      action: changeSet.action,
+      business_object: changeSet.scope.business_object,
+      object_id: changeSet.scope.object_id
+    });
+    if (active) {
+      throw new ProposalStoreError(
+        "PROPOSAL_ALREADY_EXISTS",
+        `active proposal ${active.proposal_id} is ${active.state} for ${active.business_object}:${active.object_id}`
+      );
+    }
     const state = stateFromChangeSet(changeSet);
     const now = changeSet.created_at || (/* @__PURE__ */ new Date()).toISOString();
     const insert = this.db.prepare(`
@@ -1867,6 +2169,19 @@ var ProposalStore = class {
     const row = this.db.prepare("SELECT * FROM proposals WHERE proposal_id = ?").get(proposalId);
     return rowToProposal(row);
   }
+  findActiveProposal(input) {
+    const row = this.db.prepare(`
+      SELECT * FROM proposals
+      WHERE tenant_id = ?
+        AND action = ?
+        AND business_object = ?
+        AND object_id = ?
+        AND state IN ('pending_review', 'approved', 'pending_worker')
+      ORDER BY created_at DESC
+      LIMIT 1
+    `).get(input.tenant_id, input.action, input.business_object, input.object_id);
+    return rowToProposal(row);
+  }
   listProposals(filters) {
     if (typeof filters === "string") filters = { state: filters };
     const query = buildProposalQuery(filters ?? {});
@@ -3635,7 +3950,6 @@ function sortJson(value) {
 
 // packages/mcp-server/src/index.ts
 import mysql from "mysql2/promise";
-import { Pool } from "pg";
 import { z as z2 } from "zod";
 var RESERVED_MODEL_ARGS = /* @__PURE__ */ new Set([
   "tenant_id",
@@ -4128,7 +4442,7 @@ async function handleStreamableHttpMcpRequest(input) {
     }
     let session;
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => crypto.randomUUID(),
+      sessionIdGenerator: () => crypto2.randomUUID(),
       onsessioninitialized: (newSessionId) => {
         if (session) {
           session.sessionId = newSessionId;
@@ -4253,7 +4567,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 && crypto.timingSafeEqual(actualBuffer, expectedBuffer);
+  return actualBuffer.length === expectedBuffer.length && crypto2.timingSafeEqual(actualBuffer, expectedBuffer);
 }
 function headerValue(value) {
   return Array.isArray(value) ? value[0] : value;
@@ -4311,7 +4625,7 @@ function toolNameExposureMap(canonicalNames, style) {
   return exposedByCanonical;
 }
 function shortToolHash(value) {
-  return crypto.createHash("sha256").update(value).digest("hex").slice(0, 8);
+  return crypto2.createHash("sha256").update(value).digest("hex").slice(0, 8);
 }
 function setCorsHeaders(response, corsOrigin) {
   if (corsOrigin) {
@@ -4611,7 +4925,28 @@ async function callConfiguredTool(input) {
     queryFingerprint,
     objectId
   });
-  const proposal = input.store.createProposal(changeSet);
+  const activeProposal = input.store.findActiveProposal({
+    tenant_id: context.tenant_id,
+    action: capability.name,
+    business_object: capability.target.table,
+    object_id: objectId
+  });
+  if (activeProposal) throw proposalAlreadyExists(activeProposal);
+  let proposal;
+  try {
+    proposal = input.store.createProposal(changeSet);
+  } catch (error) {
+    if (error instanceof ProposalStoreError && error.code === "PROPOSAL_ALREADY_EXISTS") {
+      const existing = input.store.findActiveProposal({
+        tenant_id: context.tenant_id,
+        action: capability.name,
+        business_object: capability.target.table,
+        object_id: objectId
+      });
+      if (existing) throw proposalAlreadyExists(existing);
+    }
+    throw error;
+  }
   const approvalResult = maybeAutoApproveProposal({
     config: input.config,
     capability,
@@ -4893,6 +5228,9 @@ function safeToolError(error) {
   if (runtimeCode === "PROPOSALS_DISABLED") {
     return { code: "APPROVAL_REQUIRED", message: "Proposal tools are disabled for this runner mode.", retryable: false };
   }
+  if (runtimeCode === "PROPOSAL_ALREADY_EXISTS") {
+    return { code: "PROPOSAL_ALREADY_EXISTS", message: error instanceof Error ? error.message : "An active proposal already exists.", retryable: false };
+  }
   if (runtimeCode && (runtimeCode.startsWith("ARGUMENT_") || runtimeCode === "LOOKUP_ARG_MISSING" || runtimeCode === "MODEL_CANNOT_OVERRIDE_BINDING" || runtimeCode === "TRUSTED_BINDING_MISSING" || runtimeCode === "TRUSTED_CONTEXT_MISSING")) {
     return { code: "INVALID_ARGUMENT", message: "The tool input or trusted context binding is invalid.", retryable: false };
   }
@@ -4920,6 +5258,7 @@ function buildChangeSet(input) {
   const writebackMode = capabilityWritebackMode2(input.capability);
   const changeSetWritebackMode = writebackMode === "none" ? "read_only" : "trusted_worker_required";
   const writebackExecutor = writebackMode === "none" ? "none" : writebackMode === "cloud_worker" ? "cloud_worker" : writebackMode === "direct_sql" ? "sql_update" : capabilityWritebackExecutor(input.capability);
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const proposalCore = {
     schema_version: protocolVersions.changeSet,
     proposal_id: stableId("wrp", {
@@ -4927,7 +5266,8 @@ function buildChangeSet(input) {
       tenant: input.context.tenant_id,
       object: input.objectId,
       before,
-      patch
+      patch,
+      created_at: createdAt
     }),
     proposal_version: 1,
     action: input.capability.name,
@@ -4973,7 +5313,7 @@ function buildChangeSet(input) {
       executor: writebackExecutor
     },
     source_database_mutated: false,
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
+    created_at: createdAt
   };
   return {
     ...proposalCore,
@@ -4995,7 +5335,7 @@ async function readCurrentRow(input) {
 async function readPostgresRow(input) {
   const connectionString = envValue(input.env, input.source.read_url_env);
   if (!connectionString) throw new McpRuntimeError("SOURCE_CREDENTIAL_MISSING", `${input.source.read_url_env} is not set.`);
-  const pool = new Pool({ connectionString });
+  const pool = createPostgresPool(connectionString);
   const client = await pool.connect();
   try {
     const query = buildSelect(input.capability, "$");
@@ -5279,309 +5619,94 @@ function scalar2(value) {
   if (typeof value === "bigint") return Number(value);
   return String(value);
 }
-function stableId(prefix, input) {
-  return `${prefix}_${crypto.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 20)}`;
-}
-function hashJson(input) {
-  return `sha256:${crypto.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toolErrorPayload(error) {
-  if (error instanceof McpRuntimeError) {
-    if (error.code === "LOCAL_STORE_UNAVAILABLE") {
-      return { ok: false, code: "TEMPORARILY_UNAVAILABLE", error: "The local runner store is temporarily unavailable. Restart the runner or recreate the store before retrying." };
-    }
-    return { ok: false, code: error.code, error: error.message };
-  }
-  return { ok: false, code: "MCP_TOOL_FAILED", error: error instanceof Error ? error.message : String(error) };
-}
-
-// packages/mysql/src/index.ts
-import crypto2 from "node:crypto";
-import mysql2 from "mysql2/promise";
-var mysqlReceiptMigration = `CREATE TABLE IF NOT EXISTS synapsor_writeback_receipts (
-  idempotency_key varchar(255) PRIMARY KEY,
-  job_id varchar(255) UNIQUE NOT NULL,
-  proposal_id varchar(512) NOT NULL,
-  status varchar(64) NOT NULL,
-  result_hash varchar(128),
-  created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  completed_at timestamp NULL
-)`;
-function quoteMysqlIdentifier(identifier) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
-    throw new Error(`unsafe mysql identifier: ${identifier}`);
-  }
-  return `\`${identifier}\``;
-}
-function buildMysqlUpdate(job) {
-  validateMysqlPatch(job);
-  const values = [];
-  const setFragments = Object.entries(job.patch).map(([column, value]) => {
-    values.push(value);
-    return `${quoteMysqlIdentifier(column)} = ?`;
-  });
-  values.push(job.target.primary_key.value, job.target.tenant_guard.value);
-  const where = [
-    `${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`,
-    `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`
-  ];
-  if (job.conflict_guard.kind === "version_column") {
-    values.push(job.conflict_guard.expected_value);
-    where.push(`${quoteMysqlIdentifier(job.conflict_guard.column)} = ?`);
-  }
-  const sql = `UPDATE ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-SET ${setFragments.join(", ")}
-WHERE ${where.join(" AND ")}`;
-  return { sql, values };
-}
-function validateMysqlPatch(job) {
-  const patchColumns = Object.keys(job.patch || {});
-  if (!patchColumns.length) {
-    throw new Error("mysql writeback patch must not be empty");
-  }
-  const allowedColumns = new Set(Array.isArray(job.allowed_columns) ? job.allowed_columns : []);
-  if (allowedColumns.has(job.target.primary_key.column)) {
-    throw new Error("mysql primary key column must not be patch-allowlisted");
-  }
-  if (allowedColumns.has(job.target.tenant_guard.column)) {
-    throw new Error("mysql tenant guard column must not be patch-allowlisted");
-  }
-  for (const column of patchColumns) {
-    if (!allowedColumns.has(column)) {
-      throw new Error(`mysql patch column not allowlisted: ${column}`);
-    }
-  }
-}
-function resultHash(job, status, version) {
-  return `sha256:${crypto2.createHash("sha256").update(JSON.stringify({ job_id: job.job_id, status, version })).digest("hex")}`;
-}
-function normalizeVersionValue(value) {
-  if (value instanceof Date) return normalizeVersionValue(value.toISOString());
-  const text = String(value ?? "").trim();
-  const timestamp = text.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}(?::?\d{2})?)?$/i);
-  if (timestamp) {
-    const fraction = (timestamp[3] ?? "").padEnd(6, "0").slice(0, 6);
-    const offset = timestamp[4];
-    if (offset && offset.toUpperCase() !== "Z") {
-      const dateParts = timestamp[1].split("-");
-      const timeParts = timestamp[2].split(":");
-      const year = Number(dateParts[0]);
-      const month = Number(dateParts[1]);
-      const day = Number(dateParts[2]);
-      const hour = Number(timeParts[0]);
-      const minute = Number(timeParts[1]);
-      const second = Number(timeParts[2]);
-      const utc = new Date(Date.UTC(year, month - 1, day, hour, minute, second) - offsetMinutes(offset) * 6e4);
-      return `${utc.getUTCFullYear()}-${pad2(utc.getUTCMonth() + 1)}-${pad2(utc.getUTCDate())} ${pad2(utc.getUTCHours())}:${pad2(utc.getUTCMinutes())}:${pad2(utc.getUTCSeconds())}.${fraction}`;
-    }
-    return `${timestamp[1]} ${timestamp[2]}.${fraction}`;
-  }
-  return text;
-}
-function offsetMinutes(offset) {
-  const sign = offset.startsWith("-") ? -1 : 1;
-  const compact = offset.slice(1).replace(":", "");
-  const hours = Number(compact.slice(0, 2));
-  const minutes = Number(compact.slice(2, 4) || "0");
-  return sign * (hours * 60 + minutes);
-}
-function pad2(value) {
-  return String(value).padStart(2, "0");
-}
-function versionValuesMatch(actual, expected) {
-  return normalizeVersionValue(actual) === normalizeVersionValue(expected);
-}
-async function applyMysqlJob(job, config) {
-  if (config.dryRun) {
-    buildMysqlUpdate(job);
-    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "applied", affected_rows: 0, result_hash: resultHash(job, "dry-run"), completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-  if (!config.databaseUrl) return failed(job, config, "DATABASE_UNAVAILABLE");
-  const connection = await mysql2.createConnection({ uri: config.databaseUrl, dateStrings: true });
-  try {
-    return await applyMysqlJobWithConnection(job, config, connection);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "TRANSACTION_FAILED";
-    return failed(job, config, message.includes("MULTI_ROW") ? "MULTI_ROW_WRITE_BLOCKED" : message.includes("VERSION") ? "VERSION_CONFLICT" : "TRANSACTION_FAILED");
-  } finally {
-    await connection.end();
-  }
-}
-async function applyMysqlJobWithConnection(job, config, connection) {
-  await connection.beginTransaction();
-  try {
-    await connection.query(mysqlReceiptMigration);
-    const existing = await claimReceipt(connection, job, config);
-    if (existing) {
-      await connection.commit();
-      return existing;
-    }
-    const [rows] = await connection.query(
-      `SELECT * FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
-WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ?
-  AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
-FOR UPDATE`,
-      [job.target.primary_key.value, job.target.tenant_guard.value]
-    );
-    if (!rows[0]) {
-      const hash2 = resultHash(job, "ROW_NOT_FOUND");
-      await recordReceipt(connection, job, "conflict", hash2);
-      await connection.commit();
-      return conflict(job, config, "ROW_NOT_FOUND", hash2);
-    }
-    if (job.conflict_guard.kind === "version_column" && !versionValuesMatch(rows[0][job.conflict_guard.column], job.conflict_guard.expected_value)) {
-      const hash2 = resultHash(job, "VERSION_CONFLICT", rows[0][job.conflict_guard.column]);
-      await recordReceipt(connection, job, "conflict", hash2);
-      await connection.commit();
-      return conflict(job, config, "VERSION_CONFLICT", hash2);
-    }
-    const update = buildMysqlUpdate(job);
-    const [result] = await connection.query(update.sql, update.values);
-    if (result.affectedRows !== 1) throw new Error(result.affectedRows === 0 ? "VERSION_CONFLICT" : "MULTI_ROW_WRITE_BLOCKED");
-    const hash = resultHash(job, "applied", job.conflict_guard.kind === "version_column" ? job.conflict_guard.expected_value : void 0);
-    await recordReceipt(connection, job, "applied", hash);
-    await connection.commit();
-    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "applied", affected_rows: 1, result_hash: hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  } catch (error) {
-    await connection.rollback().catch(() => void 0);
-    throw error;
-  }
-}
-async function claimReceipt(connection, job, config) {
-  const [claim] = await connection.query(
-    `INSERT IGNORE INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash)
-VALUES (?, ?, ?, 'in_progress', NULL)`,
-    [job.idempotency_key, job.job_id, job.proposal_id]
-  );
-  if (claim.affectedRows === 1) return void 0;
-  const [receiptRows] = await connection.query(
-    "SELECT status, result_hash FROM synapsor_writeback_receipts WHERE idempotency_key = ? FOR UPDATE",
-    [job.idempotency_key]
+function proposalAlreadyExists(existing) {
+  process.stderr.write(`${JSON.stringify({
+    level: "warn",
+    event: "proposal_already_exists",
+    proposal_id: existing.proposal_id,
+    state: existing.state,
+    capability: existing.action,
+    object_id: existing.object_id
+  })}
+`);
+  return new McpRuntimeError(
+    "PROPOSAL_ALREADY_EXISTS",
+    `Active proposal ${existing.proposal_id} is already ${existing.state} for this object. Inspect or resolve it before proposing again.`
   );
-  const row = receiptRows[0];
-  if (!row) return failed(job, config, "IDEMPOTENCY_RECEIPT_UNAVAILABLE");
-  return resultFromExistingReceipt(job, config, row.status, row.result_hash);
 }
-function resultFromExistingReceipt(job, config, status, hash) {
-  const result_hash = typeof hash === "string" && hash ? hash : resultHash(job, "idempotent");
-  if (status === "applied" || status === "already_applied") {
-    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "already_applied", affected_rows: 0, result_hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-  if (status === "conflict") return conflict(job, config, "IDEMPOTENT_CONFLICT", result_hash);
-  if (status === "failed") return failed(job, config, "IDEMPOTENT_FAILED");
-  return failed(job, config, "IDEMPOTENCY_RECEIPT_IN_PROGRESS");
-}
-async function recordReceipt(connection, job, status, hash) {
-  const [result] = await connection.query(
-    `UPDATE synapsor_writeback_receipts
-SET status = ?, result_hash = ?, completed_at = CURRENT_TIMESTAMP
-WHERE idempotency_key = ?`,
-    [status, hash, job.idempotency_key]
-  );
-  if (result.affectedRows !== 1) throw new Error("IDEMPOTENCY_RECEIPT_UNAVAILABLE");
+function stableId(prefix, input) {
+  return `${prefix}_${crypto2.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 20)}`;
 }
-function conflict(job, config, code, result_hash) {
-  return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "conflict", affected_rows: 0, error_code: code, result_hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+function hashJson(input) {
+  return `sha256:${crypto2.createHash("sha256").update(JSON.stringify(input)).digest("hex")}`;
 }
-function failed(job, config, code) {
-  return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "failed", error_code: code, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var mysqlAdapter = {
-  async doctor(config) {
-    if (!config.databaseUrl) return { ok: false, details: { error: "database URL required; local config apply reads source.write_url_env, legacy workers use SYNAPSOR_DATABASE_URL" } };
-    const connection = await mysql2.createConnection({ uri: config.databaseUrl, dateStrings: true });
-    try {
-      const [rows] = await connection.query("SELECT VERSION() AS version");
-      await connection.query(mysqlReceiptMigration);
-      await connection.beginTransaction();
-      try {
-        const doctorId = `doctor-${Date.now()}`;
-        await connection.query(
-          `INSERT INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash, completed_at)
-VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
-          [doctorId, doctorId, "doctor", "doctor", "sha256:doctor"]
-        );
-        await connection.rollback();
-      } catch (error) {
-        await connection.rollback().catch(() => void 0);
-        throw error;
-      }
-      return {
-        ok: true,
-        details: {
-          version: rows[0]?.version,
-          receipt_table: "ready",
-          write_permission_rollback: true,
-          dry_run: config.dryRun
-        }
-      };
-    } finally {
-      await connection.end();
+function toolErrorPayload(error) {
+  if (error instanceof McpRuntimeError) {
+    if (error.code === "LOCAL_STORE_UNAVAILABLE") {
+      return { ok: false, code: "TEMPORARILY_UNAVAILABLE", error: "The local runner store is temporarily unavailable. Restart the runner or recreate the store before retrying." };
     }
-  },
-  apply: applyMysqlJob
-};
+    return { ok: false, code: error.code, error: error.message };
+  }
+  return { ok: false, code: "MCP_TOOL_FAILED", error: error instanceof Error ? error.message : String(error) };
+}
 
-// packages/postgres/src/index.ts
+// packages/mysql/src/index.ts
 import crypto3 from "node:crypto";
-import { Pool as Pool2 } from "pg";
-var postgresReceiptMigration = `CREATE TABLE IF NOT EXISTS synapsor_writeback_receipts (
-  idempotency_key text PRIMARY KEY,
-  job_id text UNIQUE NOT NULL,
-  proposal_id text NOT NULL,
-  status text NOT NULL,
-  result_hash text,
-  created_at timestamptz NOT NULL DEFAULT now(),
-  completed_at timestamptz
+import mysql2 from "mysql2/promise";
+var mysqlReceiptMigration = `CREATE TABLE IF NOT EXISTS synapsor_writeback_receipts (
+  idempotency_key varchar(255) PRIMARY KEY,
+  job_id varchar(255) UNIQUE NOT NULL,
+  proposal_id varchar(512) NOT NULL,
+  status varchar(64) NOT NULL,
+  result_hash varchar(128),
+  created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  completed_at timestamp NULL
 )`;
-function quotePostgresIdentifier(identifier) {
+function quoteMysqlIdentifier(identifier) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
-    throw new Error(`unsafe postgres identifier: ${identifier}`);
+    throw new Error(`unsafe mysql identifier: ${identifier}`);
   }
-  return `"${identifier}"`;
+  return `\`${identifier}\``;
 }
-function buildPostgresUpdate(job) {
-  validatePostgresPatch(job);
+function buildMysqlUpdate(job) {
+  validateMysqlPatch(job);
   const values = [];
   const setFragments = Object.entries(job.patch).map(([column, value]) => {
     values.push(value);
-    return `${quotePostgresIdentifier(column)} = $${values.length}`;
+    return `${quoteMysqlIdentifier(column)} = ?`;
   });
-  values.push(job.target.primary_key.value);
-  const pkParam = `$${values.length}`;
-  values.push(job.target.tenant_guard.value);
-  const tenantParam = `$${values.length}`;
+  values.push(job.target.primary_key.value, job.target.tenant_guard.value);
   const where = [
-    `${quotePostgresIdentifier(job.target.primary_key.column)} = ${pkParam}`,
-    `${quotePostgresIdentifier(job.target.tenant_guard.column)} = ${tenantParam}`
+    `${quoteMysqlIdentifier(job.target.primary_key.column)} = ?`,
+    `${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?`
   ];
   if (job.conflict_guard.kind === "version_column") {
     values.push(job.conflict_guard.expected_value);
-    where.push(`${quotePostgresIdentifier(job.conflict_guard.column)} = $${values.length}`);
+    where.push(`${quoteMysqlIdentifier(job.conflict_guard.column)} = ?`);
   }
-  const sql = `UPDATE ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
+  const sql = `UPDATE ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
 SET ${setFragments.join(", ")}
 WHERE ${where.join(" AND ")}`;
   return { sql, values };
 }
-function validatePostgresPatch(job) {
+function validateMysqlPatch(job) {
   const patchColumns = Object.keys(job.patch || {});
   if (!patchColumns.length) {
-    throw new Error("postgres writeback patch must not be empty");
+    throw new Error("mysql writeback patch must not be empty");
   }
   const allowedColumns = new Set(Array.isArray(job.allowed_columns) ? job.allowed_columns : []);
   if (allowedColumns.has(job.target.primary_key.column)) {
-    throw new Error("postgres primary key column must not be patch-allowlisted");
+    throw new Error("mysql primary key column must not be patch-allowlisted");
   }
   if (allowedColumns.has(job.target.tenant_guard.column)) {
-    throw new Error("postgres tenant guard column must not be patch-allowlisted");
+    throw new Error("mysql tenant guard column must not be patch-allowlisted");
   }
   for (const column of patchColumns) {
     if (!allowedColumns.has(column)) {
-      throw new Error(`postgres patch column not allowlisted: ${column}`);
+      throw new Error(`mysql patch column not allowlisted: ${column}`);
     }
   }
 }
@@ -5624,129 +5749,93 @@ function pad22(value) {
 function versionValuesMatch2(actual, expected) {
   return normalizeVersionValue2(actual) === normalizeVersionValue2(expected);
 }
-async function withTransaction(client, fn) {
-  await client.query("BEGIN");
-  try {
-    const result = await fn();
-    await client.query("COMMIT");
-    return result;
-  } catch (error) {
-    await client.query("ROLLBACK").catch(() => void 0);
-    throw error;
-  }
-}
-async function applyPostgresJob(job, config) {
+async function applyMysqlJob(job, config) {
   if (config.dryRun) {
-    buildPostgresUpdate(job);
-    return {
-      protocol_version: "1.0",
-      job_id: job.job_id,
-      runner_id: config.runnerId,
-      status: "applied",
-      affected_rows: 0,
-      result_hash: resultHash2(job, "dry-run"),
-      completed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  if (!config.databaseUrl) {
-    return failed2(job, config, "DATABASE_UNAVAILABLE");
+    buildMysqlUpdate(job);
+    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "applied", affected_rows: 0, result_hash: resultHash2(job, "dry-run"), completed_at: (/* @__PURE__ */ new Date()).toISOString() };
   }
-  const pool = new Pool2({ connectionString: config.databaseUrl });
-  const client = await pool.connect();
+  if (!config.databaseUrl) return failed2(job, config, "DATABASE_UNAVAILABLE");
+  const connection = await mysql2.createConnection({ uri: config.databaseUrl, dateStrings: true });
   try {
-    return await applyPostgresJobWithClient(job, config, client);
+    return await applyMysqlJobWithConnection(job, config, connection);
   } catch (error) {
     const message = error instanceof Error ? error.message : "TRANSACTION_FAILED";
     return failed2(job, config, message.includes("MULTI_ROW") ? "MULTI_ROW_WRITE_BLOCKED" : message.includes("VERSION") ? "VERSION_CONFLICT" : "TRANSACTION_FAILED");
   } finally {
-    client.release();
-    await pool.end();
+    await connection.end();
   }
 }
-async function applyPostgresJobWithClient(job, config, client) {
-  return await withTransaction(client, async () => {
-    await client.query(postgresReceiptMigration);
-    const existing = await claimReceipt2(client, job, config);
-    if (existing) return existing;
-    const conflictProjection = job.conflict_guard.kind === "version_column" ? `, ${quotePostgresIdentifier(job.conflict_guard.column)}::text AS "__synapsor_conflict_value"` : "";
-    const row = await client.query(
-      `SELECT *${conflictProjection} FROM ${quotePostgresIdentifier(job.target.schema)}.${quotePostgresIdentifier(job.target.table)}
-WHERE ${quotePostgresIdentifier(job.target.primary_key.column)} = $1
-  AND ${quotePostgresIdentifier(job.target.tenant_guard.column)} = $2
+async function applyMysqlJobWithConnection(job, config, connection) {
+  await connection.beginTransaction();
+  try {
+    const existing = await claimReceipt2(connection, job, config);
+    if (existing) {
+      await connection.commit();
+      return existing;
+    }
+    const [rows] = await connection.query(
+      `SELECT * FROM ${quoteMysqlIdentifier(job.target.schema)}.${quoteMysqlIdentifier(job.target.table)}
+WHERE ${quoteMysqlIdentifier(job.target.primary_key.column)} = ?
+  AND ${quoteMysqlIdentifier(job.target.tenant_guard.column)} = ?
 FOR UPDATE`,
       [job.target.primary_key.value, job.target.tenant_guard.value]
     );
-    if (!row.rowCount) {
+    if (!rows[0]) {
       const hash2 = resultHash2(job, "ROW_NOT_FOUND");
-      await recordReceipt2(client, job, "conflict", hash2);
+      await recordReceipt2(connection, job, "conflict", hash2);
+      await connection.commit();
       return conflict2(job, config, "ROW_NOT_FOUND", hash2);
     }
-    const currentVersion = row.rows[0]?.__synapsor_conflict_value ?? row.rows[0]?.[job.conflict_guard.kind === "version_column" ? job.conflict_guard.column : ""];
-    if (job.conflict_guard.kind === "version_column" && !versionValuesMatch2(currentVersion, job.conflict_guard.expected_value)) {
-      const hash2 = resultHash2(job, "VERSION_CONFLICT", currentVersion);
-      await recordReceipt2(client, job, "conflict", hash2);
+    if (job.conflict_guard.kind === "version_column" && !versionValuesMatch2(rows[0][job.conflict_guard.column], job.conflict_guard.expected_value)) {
+      const hash2 = resultHash2(job, "VERSION_CONFLICT", rows[0][job.conflict_guard.column]);
+      await recordReceipt2(connection, job, "conflict", hash2);
+      await connection.commit();
       return conflict2(job, config, "VERSION_CONFLICT", hash2);
     }
-    const update = buildPostgresUpdate(job);
-    const applied = await client.query(update.sql, update.values);
-    if (applied.rowCount !== 1) {
-      throw new Error(applied.rowCount === 0 ? "VERSION_CONFLICT" : "MULTI_ROW_WRITE_BLOCKED");
-    }
+    const update = buildMysqlUpdate(job);
+    const [result] = await connection.query(update.sql, update.values);
+    if (result.affectedRows !== 1) throw new Error(result.affectedRows === 0 ? "VERSION_CONFLICT" : "MULTI_ROW_WRITE_BLOCKED");
     const hash = resultHash2(job, "applied", job.conflict_guard.kind === "version_column" ? job.conflict_guard.expected_value : void 0);
-    await recordReceipt2(client, job, "applied", hash);
-    return {
-      protocol_version: "1.0",
-      job_id: job.job_id,
-      runner_id: config.runnerId,
-      status: "applied",
-      affected_rows: 1,
-      result_hash: hash,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  });
+    await recordReceipt2(connection, job, "applied", hash);
+    await connection.commit();
+    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "applied", affected_rows: 1, result_hash: hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+  } catch (error) {
+    await connection.rollback().catch(() => void 0);
+    throw error;
+  }
 }
-async function claimReceipt2(client, job, config) {
-  const claimed = await client.query(
-    `INSERT INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash)
-VALUES ($1, $2, $3, 'in_progress', NULL)
-ON CONFLICT (idempotency_key) DO NOTHING
-RETURNING status, result_hash`,
+async function claimReceipt2(connection, job, config) {
+  const [claim] = await connection.query(
+    `INSERT IGNORE INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash)
+VALUES (?, ?, ?, 'in_progress', NULL)`,
     [job.idempotency_key, job.job_id, job.proposal_id]
   );
-  if (claimed.rowCount === 1) return void 0;
-  const receipt = await client.query(
-    "SELECT status, result_hash FROM synapsor_writeback_receipts WHERE idempotency_key = $1 FOR UPDATE",
+  if (claim.affectedRows === 1) return void 0;
+  const [receiptRows] = await connection.query(
+    "SELECT status, result_hash FROM synapsor_writeback_receipts WHERE idempotency_key = ? FOR UPDATE",
     [job.idempotency_key]
   );
-  const row = receipt.rows[0];
+  const row = receiptRows[0];
   if (!row) return failed2(job, config, "IDEMPOTENCY_RECEIPT_UNAVAILABLE");
   return resultFromExistingReceipt2(job, config, row.status, row.result_hash);
 }
 function resultFromExistingReceipt2(job, config, status, hash) {
   const result_hash = typeof hash === "string" && hash ? hash : resultHash2(job, "idempotent");
   if (status === "applied" || status === "already_applied") {
-    return {
-      protocol_version: "1.0",
-      job_id: job.job_id,
-      runner_id: config.runnerId,
-      status: "already_applied",
-      affected_rows: 0,
-      result_hash,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "already_applied", affected_rows: 0, result_hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
   }
   if (status === "conflict") return conflict2(job, config, "IDEMPOTENT_CONFLICT", result_hash);
   if (status === "failed") return failed2(job, config, "IDEMPOTENT_FAILED");
   return failed2(job, config, "IDEMPOTENCY_RECEIPT_IN_PROGRESS");
 }
-async function recordReceipt2(client, job, status, hash) {
-  const result = await client.query(
+async function recordReceipt2(connection, job, status, hash) {
+  const [result] = await connection.query(
     `UPDATE synapsor_writeback_receipts
-SET status = $2, result_hash = $3, completed_at = now()
-WHERE idempotency_key = $1`,
-    [job.idempotency_key, status, hash]
+SET status = ?, result_hash = ?, completed_at = CURRENT_TIMESTAMP
+WHERE idempotency_key = ?`,
+    [status, hash, job.idempotency_key]
   );
-  if (result.rowCount !== 1) throw new Error("IDEMPOTENCY_RECEIPT_UNAVAILABLE");
+  if (result.affectedRows !== 1) throw new Error("IDEMPOTENCY_RECEIPT_UNAVAILABLE");
 }
 function conflict2(job, config, code, result_hash) {
   return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "conflict", affected_rows: 0, error_code: code, result_hash, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
@@ -5754,47 +5843,44 @@ function conflict2(job, config, code, result_hash) {
 function failed2(job, config, code) {
   return { protocol_version: "1.0", job_id: job.job_id, runner_id: config.runnerId, status: "failed", error_code: code, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
 }
-var postgresAdapter = {
+var mysqlAdapter = {
   async doctor(config) {
     if (!config.databaseUrl) return { ok: false, details: { error: "database URL required; local config apply reads source.write_url_env, legacy workers use SYNAPSOR_DATABASE_URL" } };
-    const pool = new Pool2({ connectionString: config.databaseUrl });
-    const client = await pool.connect();
+    const connection = await mysql2.createConnection({ uri: config.databaseUrl, dateStrings: true });
     try {
-      const result = await client.query("SELECT version()");
-      await client.query(postgresReceiptMigration);
-      await client.query("BEGIN");
+      const [rows] = await connection.query("SELECT VERSION() AS version");
+      await connection.beginTransaction();
       try {
         const doctorId = `doctor-${Date.now()}`;
-        await client.query(
+        await connection.query(
           `INSERT INTO synapsor_writeback_receipts (idempotency_key, job_id, proposal_id, status, result_hash, completed_at)
-VALUES ($1, $2, $3, $4, $5, now())`,
+VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
           [doctorId, doctorId, "doctor", "doctor", "sha256:doctor"]
         );
-        await client.query("ROLLBACK");
+        await connection.rollback();
       } catch (error) {
-        await client.query("ROLLBACK").catch(() => void 0);
+        await connection.rollback().catch(() => void 0);
         throw error;
       }
       return {
         ok: true,
         details: {
-          version: result.rows[0]?.version,
+          version: rows[0]?.version,
           receipt_table: "ready",
           write_permission_rollback: true,
           dry_run: config.dryRun
         }
       };
     } finally {
-      client.release();
-      await pool.end();
+      await connection.end();
     }
   },
-  apply: applyPostgresJob
+  apply: applyMysqlJob
 };
 
 // packages/schema-inspector/src/index.ts
 import mysql3 from "mysql2/promise";
-import { Pool as Pool3 } from "pg";
+import { Pool as Pool2 } from "pg";
 var TENANT_COLUMNS = /* @__PURE__ */ new Set(["tenant_id", "account_id", "organization_id", "org_id", "workspace_id", "customer_id"]);
 var CONFLICT_COLUMNS = /* @__PURE__ */ new Set(["updated_at", "modified_at", "row_version", "version", "lock_version", "etag"]);
 var IMMUTABLE_COLUMNS = /* @__PURE__ */ new Set(["id", "uuid", "created_at", "created_by"]);
@@ -5977,7 +6063,7 @@ function summarizeInspection(inspection) {
 `;
 }
 async function inspectPostgres(options) {
-  const pool = new Pool3({ connectionString: options.url, connectionTimeoutMillis: options.statementTimeoutMs ?? 3e3 });
+  const pool = new Pool2({ connectionString: options.url, connectionTimeoutMillis: options.statementTimeoutMs ?? 3e3 });
   const client = await pool.connect();
   try {
     await client.query("BEGIN READ ONLY");
@@ -7220,8 +7306,7 @@ function parseCapabilityBlock(block) {
     }
     const lookup = item.text.match(/^LOOKUP\s+([A-Za-z_][A-Za-z0-9_]*)\s+BY\s+([A-Za-z_][A-Za-z0-9_]*)$/i);
     if (lookup?.[1] && lookup[2]) {
-      capability.lookup = { arg: lookup[1], column: lookup[2] };
-      capability.primaryKey = lookup[2];
+      capability.lookup = { arg: lookup[1], column: lookup[2], line: item.line };
       if (!capability.args[lookup[1]])
         capability.args[lookup[1]] = { type: "string", required: true, max_length: 128 };
       continue;
@@ -7317,6 +7402,9 @@ function parseCapabilityBlock(block) {
     throw dslError(block.line, 1, "CAPABILITY_SUBJECT_REQUIRED", `${block.name} requires ON schema.table`);
   if (!capability.tenantKey)
     throw dslError(block.line, 1, "CAPABILITY_TENANT_REQUIRED", `${block.name} requires TENANT KEY for 0.1 DSL`);
+  if (capability.lookup && capability.lookup.column !== capability.primaryKey) {
+    throw dslError(capability.lookup.line ?? block.line, 1, "LOOKUP_COLUMN_UNSUPPORTED", `${block.name} LOOKUP BY ${capability.lookup.column} cannot be represented by spec 0.1; use declared PRIMARY KEY ${capability.primaryKey}`);
+  }
   if (capability.visibleFields.length === 0)
     throw dslError(block.line, 1, "CAPABILITY_VISIBLE_FIELDS_REQUIRED", `${block.name} requires ALLOW READ`);
   if (Object.keys(capability.args).length === 0 && capability.lookup)
@@ -8439,7 +8527,7 @@ function stringOrDefault(value, fallback) {
 // apps/runner/package.json
 var package_default = {
   name: "@synapsor/runner",
-  version: "0.1.15",
+  version: "0.1.16",
   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",
@@ -8526,7 +8614,7 @@ var package_default = {
 // packages/dsl/package.json
 var package_default2 = {
   name: "@synapsor/dsl",
-  version: "0.1.5",
+  version: "0.1.6",
   description: "Preview SQL-like Synapsor authoring DSL compiler for canonical @synapsor/spec contracts.",
   license: "Apache-2.0",
   type: "module",
@@ -8538,6 +8626,7 @@ var package_default2 = {
   files: [
     "dist/**",
     "examples/**",
+    "fixtures/**",
     "README.md",
     "package.json"
   ],
@@ -9865,7 +9954,7 @@ function formatPostgresReceiptMigration(schema) {
   if (!schema) {
     return [
       "-- Synapsor Runner direct SQL writeback receipt table.",
-      "-- Run this as a database owner, or grant CREATE on the target schema to the trusted writer.",
+      "-- Run this once as a database owner before doctor/apply. The steady-state writer does not need schema CREATE.",
       `${postgresReceiptMigration};`,
       ""
     ].join("\n");
@@ -9874,7 +9963,7 @@ function formatPostgresReceiptMigration(schema) {
   const qualified = `${quotedSchema}.synapsor_writeback_receipts`;
   return [
     "-- Synapsor Runner direct SQL writeback receipt table.",
-    "-- If you use a dedicated schema, ensure the writer connection search_path includes it.",
+    "-- Run this once as a database owner. If you use a dedicated schema, ensure the writer connection search_path includes it.",
     `CREATE SCHEMA IF NOT EXISTS ${quotedSchema};`,
     `${postgresReceiptMigration.replace("synapsor_writeback_receipts", qualified)};`,
     "",
@@ -9901,9 +9990,6 @@ function formatPostgresReceiptGrants(schema, writerRole) {
     `GRANT USAGE ON SCHEMA ${quotedSchema} TO ${quotedRole};`,
     `GRANT SELECT, INSERT, UPDATE ON TABLE ${table} TO ${quotedRole};`,
     "",
-    "-- If you want Runner to create the receipt table itself, also grant CREATE on the schema:",
-    `-- GRANT CREATE ON SCHEMA ${quotedSchema} TO ${quotedRole};`,
-    "",
     "-- If the schema is not public, make sure the writer connection search_path includes it.",
     `-- ALTER ROLE ${quotedRole} SET search_path = ${schema}, public;`,
     ""
@@ -9915,9 +10001,6 @@ function formatMysqlReceiptGrants(database, writerRole) {
   return [
     "-- Least-privilege grants for a pre-created Synapsor Runner receipt table.",
     `GRANT SELECT, INSERT, UPDATE ON ${quotedDatabase}.synapsor_writeback_receipts TO ${account};`,
-    "",
-    "-- If you want Runner to create the receipt table itself, also grant CREATE on the database:",
-    `-- GRANT CREATE ON ${quotedDatabase}.* TO ${account};`,
     ""
   ].join("\n");
 }
@@ -10833,6 +10916,9 @@ async function doctor(args = []) {
   if (configPath || await fileExists("synapsor.runner.json")) {
     return localDoctor(args);
   }
+  if (!process2.env.SYNAPSOR_CONTROL_PLANE_URL) {
+    throw new Error(`Local doctor requires --config ./synapsor.runner.json. Cloud worker doctor requires SYNAPSOR_CONTROL_PLANE_URL and the scoped worker environment.`);
+  }
   const config = loadConfig();
   const logger = createLogger(config);
   const report = await doctorChecks(config, adapters[config.engine]);
@@ -11777,6 +11863,9 @@ function formatApplyResult(job, result, dryRun, storePath) {
       "",
       "Why:",
       errorCode === "VERSION_CONFLICT" ? "conflict/version guard did not match" : errorCode || "guarded writeback returned conflict",
+      "",
+      "Next:",
+      "Re-inspect the current source row and create a fresh proposal. The conflicted proposal and receipt remain in replay history.",
       ""
     );
   }
@@ -14242,7 +14331,7 @@ async function readMcpAuditTarget(target2, args, timeoutMs) {
   }
   const parsed = JSON.parse(await fs3.readFile(target2, "utf8"));
   if (isRunnerConfigLike(parsed)) {
-    const runtime = createMcpRuntime(parsed, { storePath: ":memory:" });
+    const runtime = createMcpRuntime(loadRuntimeConfigFromFile(target2), { storePath: ":memory:" });
     try {
       return { tools: runtime.listTools() };
     } finally {
@@ -16593,6 +16682,12 @@ function proposalNextCommands(proposal, proposalRef, storeSuffix) {
       `${cliCommandName()} replay show --proposal ${proposal.proposal_id}${storeSuffix}`
     ];
   }
+  if (proposal.state === "conflict") {
+    return [
+      `${cliCommandName()} propose ${proposal.action} --json '<fresh reviewed input>'${storeSuffix}`,
+      `${cliCommandName()} replay show --proposal ${proposal.proposal_id}${storeSuffix}`
+    ];
+  }
   return [
     `${cliCommandName()} replay show --proposal ${proposal.proposal_id}${storeSuffix}`
   ];
@@ -16818,6 +16913,7 @@ Commands:
   start        Start guided own-database setup, or no-arg legacy worker polling
   up           Bring up local review mode guidance/server
   init         Generate a Synapsor capability contract
+  config       Validate local synapsor.runner.json wiring
   mcp          Serve safe semantic tools over MCP
   contract     Validate and normalize canonical Synapsor contract files
   dsl          Compile SQL-like Synapsor authoring DSL to contract JSON
@@ -16847,6 +16943,7 @@ Examples:
   ${cmd} onboard db --from-env DATABASE_URL
   ${cmd} inspect --from-env DATABASE_URL
   ${cmd} init --wizard --from-env DATABASE_URL
+  ${cmd} config validate --config ./synapsor.runner.json
   ${cmd} contract validate ./synapsor.contract.json
   ${cmd} contract normalize ./synapsor.contract.json --out ./synapsor.contract.normalized.json
   ${cmd} dsl compile ./contract.synapsor.sql --out ./synapsor.contract.json
@@ -16857,6 +16954,14 @@ Examples:
   ${cmd} mcp serve --config ./synapsor.runner.json --store ./.synapsor/local.db
   ${cmd} propose billing.propose_late_fee_waiver --sample
   ${cmd} audit ./synapsor.runner.json
+`,
+    config: `Usage:
+  ${cmd} config validate --config ./synapsor.runner.json
+  ${cmd} config migrate --config ./synapsor.runner.json --out ./synapsor.runner.migrated.json
+
+Validate local Runner wiring before tools preview, doctor, smoke, or MCP serve.
+Contract paths are resolved relative to the config file. SQLite store paths are
+resolved by the Runner process working directory.
 `,
     contract: `Usage:
   ${cmd} contract validate ./synapsor.contract.json [--json]
@@ -17107,7 +17212,8 @@ Static MCP/database risk review only. This is not a security guarantee.
   ${cmd} doctor --first-run
 
 Validate local config, environment bindings, semantic tool boundary, source metadata when reachable, handler signing/reachability, direct SQL writeback readiness, and local store stats. Reports are redacted; do not paste secrets into issues.
-Use --check-writeback only after reviewing receipt-table DDL/grants; it connects with the trusted writer and can create the receipt table if the writer has permission.
+Use --check-writeback only after an administrator applies the receipt-table migration and grants. It verifies the pre-created table with the trusted writer inside a rolled-back transaction and does not require schema CREATE.
+Without --config, doctor is the legacy Cloud worker check and requires SYNAPSOR_CONTROL_PLANE_URL plus the scoped worker environment.
 `,
     proposals: `Usage:
 	  ${cmd} proposals list [--tenant acme] [--capability billing.propose_late_fee_waiver] [--object invoice:INV-3001] [--status applied]
@@ -17143,6 +17249,7 @@ Inspect local query fingerprints, table names, row counts, and redacted-paramete
 	Inspect guarded writeback receipts recorded by the trusted runner path. Use --details for idempotency keys, receipt hashes, and runner metadata.
 `,
     apply: `Usage:
+  ${cmd} apply <proposal-id> [--config ./synapsor.runner.json] [--store ./.synapsor/local.db]
   ${cmd} apply latest [--config ./synapsor.runner.json] [--store ./.synapsor/local.db]
   ${cmd} apply --job job.json --config ./synapsor.runner.json --store ./.synapsor/local.db
 
@@ -17152,9 +17259,9 @@ With --config, the writer connection comes from source.write_url_env, such as
 SYNAPSOR_DATABASE_WRITE_URL. SYNAPSOR_DATABASE_URL is only the legacy fallback
 for direct worker/apply flows without a local config.
 
-Direct SQL writeback creates or writes synapsor_writeback_receipts for
-idempotency and replay, so the trusted writer needs permission for that table
-or an administrator must pre-create and grant it.
+Direct SQL writeback writes the administrator-created
+synapsor_writeback_receipts table for idempotency and replay. The trusted writer
+needs SELECT/INSERT/UPDATE on that table, but does not need schema CREATE.
 `,
     replay: `Usage:
   ${cmd} replay list [--tenant acme] [--object invoice:INV-3001]