@synapsor/runner 0.1.9 → 0.1.10

package/dist/runner.mjs

@@ -444,8 +444,9 @@ function sleep(ms) {
 }
 
 // packages/config/src/index.ts
-var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "cloud", "strict", "result_format"]);
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["version", "mode", "storage", "sources", "trusted_context", "contexts", "executors", "capabilities", "contracts", "policies", "approvals", "cloud", "strict", "result_format"]);
 var STORAGE_KEYS = /* @__PURE__ */ new Set(["sqlite_path"]);
+var APPROVALS_KEYS = /* @__PURE__ */ new Set(["disable_auto_approval"]);
 var CLOUD_KEYS = /* @__PURE__ */ new Set(["base_url_env", "runner_token_env", "runner_id", "runner_version", "project_id", "adapter_id", "source_id", "engines", "capabilities", "session"]);
 var SOURCE_KEYS = /* @__PURE__ */ new Set([
   "engine",
@@ -489,7 +490,9 @@ var PATCH_BINDING_KEYS = /* @__PURE__ */ new Set(["fixed", "from_arg"]);
 var NUMERIC_BOUND_KEYS = /* @__PURE__ */ new Set(["minimum", "maximum"]);
 var TRANSITION_GUARD_KEYS = /* @__PURE__ */ new Set(["from_column", "allowed"]);
 var CONFLICT_GUARD_KEYS = /* @__PURE__ */ new Set(["column", "weak_guard_ack"]);
-var APPROVAL_KEYS = /* @__PURE__ */ new Set(["mode", "required_role"]);
+var APPROVAL_KEYS = /* @__PURE__ */ new Set(["mode", "required_role", "policy"]);
+var POLICY_KEYS = /* @__PURE__ */ new Set(["name", "kind", "mode", "rules"]);
+var APPROVAL_POLICY_RULE_KEYS = /* @__PURE__ */ new Set(["field", "max"]);
 var WRITEBACK_KEYS = /* @__PURE__ */ new Set(["mode", "executor"]);
 var WRITEBACK_MODES = /* @__PURE__ */ new Set(["direct_sql", "app_handler", "cloud_worker", "none"]);
 var MODEL_CONTROLLED_TRUST_FIELDS = /* @__PURE__ */ new Set([
@@ -562,17 +565,60 @@ function validateRunnerCapabilityConfig(input) {
     errors.push({ path: "$.mode", code: "INVALID_MODE", message: "mode must be read_only, shadow, review, or cloud." });
   }
   validateStorage(input.storage, strict, errors);
+  validateApprovals(input.approvals, strict, errors);
   const hasContracts = validateContracts(input.contracts, errors);
   validateCloud(input.cloud, input.mode, strict, errors);
   validateSources(input.sources, input.mode, strict, errors, warnings);
   validateContexts(input.contexts, strict, errors, warnings);
   validateTrustedContext(input.trusted_context, input.contexts, input.capabilities, input.mode, strict, errors, warnings, hasContracts);
   validateExecutors(input.executors, input.mode, strict, errors);
+  validatePolicies(input.policies, strict, errors);
   validateCapabilities(input.capabilities, input.sources, input.contexts, input.executors, input.mode, strict, errors, warnings, hasContracts);
+  validateApprovalPolicyReferences(input.capabilities, input.policies, errors);
   validateWritebackReadiness(input.sources, input.capabilities, input.mode, errors, warnings);
   scanForForbiddenFields(input, "$", errors);
   return { ok: errors.length === 0, errors, warnings };
 }
+function validateApprovalPolicyReferences(capabilities, policies, errors) {
+  if (!Array.isArray(capabilities)) return;
+  const policyByName = /* @__PURE__ */ new Map();
+  if (Array.isArray(policies)) {
+    policies.forEach((policy) => {
+      if (isRecord(policy) && typeof policy.name === "string") policyByName.set(policy.name, policy);
+    });
+  }
+  capabilities.forEach((capability, index) => {
+    if (!isRecord(capability) || capability.kind !== "proposal" || !isRecord(capability.approval)) return;
+    const approval = capability.approval;
+    const path4 = `$.capabilities[${index}].approval`;
+    if (approval.mode === "policy") {
+      if (!isNonEmptyString(approval.required_role)) {
+        errors.push({ path: `${path4}.required_role`, code: "APPROVAL_POLICY_ROLE_REQUIRED", message: "policy approval still requires required_role for human fallback." });
+      }
+      if (!isSafeName(approval.policy)) {
+        errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_REQUIRED", message: "approval.mode policy requires approval.policy." });
+        return;
+      }
+      const policy = policyByName.get(String(approval.policy));
+      if (!policy || policy.kind !== "approval") {
+        errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_UNRESOLVED", message: "approval.policy must reference a top-level approval policy." });
+      }
+    } else if (approval.policy !== void 0) {
+      errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_MODE_REQUIRED", message: "approval.policy can only be set when approval.mode is policy." });
+    }
+  });
+}
+function validateApprovals(value, strict, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push({ path: "$.approvals", code: "APPROVALS_NOT_OBJECT", message: "approvals must be an object." });
+    return;
+  }
+  if (strict) checkUnknownKeys(value, APPROVALS_KEYS, "$.approvals", errors);
+  if (value.disable_auto_approval !== void 0 && typeof value.disable_auto_approval !== "boolean") {
+    errors.push({ path: "$.approvals.disable_auto_approval", code: "INVALID_DISABLE_AUTO_APPROVAL", message: "disable_auto_approval must be true or false." });
+  }
+}
 function validateContracts(value, errors) {
   if (value === void 0) return false;
   if (!Array.isArray(value) || value.length === 0) {
@@ -873,6 +919,44 @@ function validateExecutors(value, mode, strict, errors) {
     }
   }
 }
+function validatePolicies(value, strict, errors) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    errors.push({ path: "$.policies", code: "POLICIES_NOT_ARRAY", message: "policies must be an array." });
+    return;
+  }
+  const names = /* @__PURE__ */ new Set();
+  value.forEach((policy, index) => {
+    const path4 = `$.policies[${index}]`;
+    if (!isRecord(policy)) {
+      errors.push({ path: path4, code: "POLICY_NOT_OBJECT", message: "policy must be an object." });
+      return;
+    }
+    if (strict) checkUnknownKeys(policy, POLICY_KEYS, path4, errors);
+    if (!isSafeName(policy.name)) errors.push({ path: `${path4}.name`, code: "INVALID_POLICY_NAME", message: "policy name must be a safe or qualified identifier." });
+    else if (names.has(String(policy.name))) errors.push({ path: `${path4}.name`, code: "DUPLICATE_POLICY_NAME", message: `Duplicate policy name: ${String(policy.name)}` });
+    else names.add(String(policy.name));
+    if (!["approval", "settlement", "scope", "custom"].includes(String(policy.kind))) {
+      errors.push({ path: `${path4}.kind`, code: "INVALID_POLICY_KIND", message: "policy.kind must be approval, settlement, scope, or custom." });
+    }
+    if (policy.rules !== void 0) {
+      if (!Array.isArray(policy.rules)) {
+        errors.push({ path: `${path4}.rules`, code: "POLICY_RULES_NOT_ARRAY", message: "policy.rules must be an array." });
+      } else if (policy.kind === "approval") {
+        policy.rules.forEach((rule, ruleIndex) => validateApprovalPolicyRule(rule, `${path4}.rules[${ruleIndex}]`, strict, errors));
+      }
+    }
+  });
+}
+function validateApprovalPolicyRule(value, path4, strict, errors) {
+  if (!isRecord(value)) {
+    errors.push({ path: path4, code: "APPROVAL_POLICY_RULE_NOT_OBJECT", message: "approval policy rules must be objects." });
+    return;
+  }
+  if (strict) checkUnknownKeys(value, APPROVAL_POLICY_RULE_KEYS, path4, errors);
+  if (!isSafeIdentifier(value.field)) errors.push({ path: `${path4}.field`, code: "INVALID_APPROVAL_POLICY_FIELD", message: "approval policy rule field must be a safe identifier." });
+  if (!Number.isInteger(value.max) || Number(value.max) < 0) errors.push({ path: `${path4}.max`, code: "INVALID_APPROVAL_POLICY_MAX", message: "approval policy rule max must be a non-negative integer." });
+}
 function validateExecutorAuth(value, path4, strict, errors) {
   if (value === void 0) return;
   if (!isRecord(value)) {
@@ -2823,10 +2907,10 @@ var PATCH_KEYS = /* @__PURE__ */ new Set(["fixed", "from_arg"]);
 var NUMERIC_BOUND_KEYS2 = /* @__PURE__ */ new Set(["minimum", "maximum"]);
 var TRANSITION_GUARD_KEYS2 = /* @__PURE__ */ new Set(["from_column", "allowed"]);
 var CONFLICT_GUARD_KEYS2 = /* @__PURE__ */ new Set(["column", "weak_guard_ack"]);
-var APPROVAL_KEYS2 = /* @__PURE__ */ new Set(["mode", "required_role"]);
+var APPROVAL_KEYS2 = /* @__PURE__ */ new Set(["mode", "required_role", "policy"]);
 var WRITEBACK_KEYS2 = /* @__PURE__ */ new Set(["mode", "executor", "idempotency_key"]);
 var WORKFLOW_KEYS = /* @__PURE__ */ new Set(["name", "description", "context", "allowed_capabilities", "required_evidence", "approval", "settlement", "replay"]);
-var POLICY_KEYS = /* @__PURE__ */ new Set(["name", "kind", "mode", "rules"]);
+var POLICY_KEYS2 = /* @__PURE__ */ new Set(["name", "kind", "mode", "rules"]);
 var EVIDENCE_RECORD_KEYS = /* @__PURE__ */ new Set(["handle", "capability", "query_fingerprint", "items"]);
 var PROPOSAL_RECORD_KEYS = /* @__PURE__ */ new Set(["id", "capability", "subject", "status", "diff", "evidence_handle"]);
 var RECEIPT_KEYS = /* @__PURE__ */ new Set(["id", "proposal_id", "status", "idempotency_key", "source_database_mutated", "rows_affected"]);
@@ -2868,9 +2952,12 @@ function validateContract(input) {
   validateMetadata(input.metadata, "$.metadata", errors);
   const resourceNames = validateResources(input.resources, errors, warnings);
   const contextNames = validateContexts2(input.contexts, errors, warnings);
+  const capabilities = Array.isArray(input.capabilities) ? input.capabilities : [];
+  const policies = Array.isArray(input.policies) ? input.policies : [];
   const capabilityNames = validateCapabilities2(input.capabilities, contextNames, resourceNames, errors, warnings);
   validateWorkflows(input.workflows, contextNames, capabilityNames, errors);
-  validatePolicies(input.policies, errors);
+  const policyByName = validatePolicies2(input.policies, errors);
+  validateCapabilityApprovalPolicies(capabilities, policies, policyByName, errors);
   validateEvidenceRecords(input.evidence, errors);
   validateProposalRecords(input.proposals, capabilityNames, errors);
   validateReceiptRecords(input.receipts, errors);
@@ -3248,10 +3335,135 @@ function validateWorkflows(value, contextNames, capabilityNames, errors) {
     }
   });
 }
-function validatePolicies(value, errors) {
+function validatePolicies2(value, errors) {
+  const names = /* @__PURE__ */ new Map();
   if (value === void 0)
+    return names;
+  if (!Array.isArray(value)) {
+    errors.push({ path: "$.policies", code: "POLICIES_NOT_ARRAY", message: "$.policies must be an array." });
+    return names;
+  }
+  value.forEach((policy, index) => {
+    const path4 = `$.policies[${index}]`;
+    if (!isRecord3(policy)) {
+      errors.push({ path: path4, code: "POLICY_NOT_OBJECT", message: "policy entry must be an object." });
+      return;
+    }
+    checkUnknownKeys2(policy, POLICY_KEYS2, path4, errors);
+    if (!isQualifiedOrSafeName(policy.name))
+      errors.push({ path: `${path4}.name`, code: "INVALID_POLICY_NAME", message: "policy name must be a safe identifier or qualified name." });
+    else {
+      if (names.has(String(policy.name)))
+        errors.push({ path: `${path4}.name`, code: "DUPLICATE_POLICY_NAME", message: `Duplicate name: ${String(policy.name)}` });
+      names.set(String(policy.name), policy);
+    }
+    if (!["approval", "settlement", "scope", "custom"].includes(String(policy.kind)))
+      errors.push({ path: `${path4}.kind`, code: "INVALID_POLICY_KIND", message: "policy.kind must be approval, settlement, scope, or custom." });
+    if (policy.mode !== void 0 && !["green", "yellow", "red", "manual", "block"].includes(String(policy.mode)))
+      errors.push({ path: `${path4}.mode`, code: "INVALID_POLICY_MODE", message: "policy.mode must be green, yellow, red, manual, or block." });
+    if (policy.rules !== void 0) {
+      if (!Array.isArray(policy.rules)) {
+        errors.push({ path: `${path4}.rules`, code: "POLICY_RULES_NOT_ARRAY", message: "policy.rules must be an array." });
+      } else if (policy.kind === "approval") {
+        policy.rules.forEach((rule, ruleIndex) => validateApprovalPolicyRuleShape(rule, `${path4}.rules[${ruleIndex}]`, errors));
+      }
+    }
+  });
+  return names;
+}
+function validateApprovalPolicyRuleShape(rule, path4, errors) {
+  if (!isRecord3(rule)) {
+    errors.push({ path: path4, code: "APPROVAL_POLICY_RULE_NOT_OBJECT", message: "approval policy rules must be objects." });
+    return;
+  }
+  const keys = /* @__PURE__ */ new Set(["field", "max"]);
+  checkUnknownKeys2(rule, keys, path4, errors);
+  if (!isSafeIdentifier2(rule.field))
+    errors.push({ path: `${path4}.field`, code: "INVALID_APPROVAL_POLICY_FIELD", message: "approval policy rule field must be a safe identifier." });
+  if (!Number.isInteger(rule.max) || Number(rule.max) < 0)
+    errors.push({ path: `${path4}.max`, code: "INVALID_APPROVAL_POLICY_MAX", message: "approval policy rule max must be a non-negative integer." });
+}
+function validateCapabilityApprovalPolicies(capabilities, policies, policyByName, errors) {
+  const policyIndexByName = /* @__PURE__ */ new Map();
+  policies.forEach((policy, index) => {
+    if (isRecord3(policy) && typeof policy.name === "string")
+      policyIndexByName.set(policy.name, index);
+  });
+  capabilities.forEach((capability, index) => {
+    if (!isRecord3(capability) || !isRecord3(capability.proposal))
+      return;
+    const proposal = capability.proposal;
+    const approval = proposal.approval;
+    if (!isRecord3(approval))
+      return;
+    const path4 = `$.capabilities[${index}].proposal.approval`;
+    const mode = approval.mode;
+    const policyName = approval.policy;
+    if (mode === "policy") {
+      if (!isNonEmptyString2(approval.required_role)) {
+        errors.push({ path: `${path4}.required_role`, code: "APPROVAL_POLICY_ROLE_REQUIRED", message: "approval.mode policy still requires required_role for human fallback." });
+      }
+      if (!isQualifiedOrSafeName(policyName)) {
+        errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_REQUIRED", message: "approval.mode policy requires approval.policy." });
+        return;
+      }
+      const policy = policyByName.get(policyName);
+      if (!policy) {
+        errors.push({ path: `${path4}.policy`, code: "UNKNOWN_APPROVAL_POLICY", message: `approval.policy must reference an existing approval policy: ${policyName}` });
+        return;
+      }
+      if (policy.kind !== "approval") {
+        errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_KIND_REQUIRED", message: "approval.policy must reference a policy with kind approval." });
+        return;
+      }
+      validateApprovalPolicyRulesAgainstCapability(policy, policyIndexByName.get(policyName) ?? 0, capability, index, errors);
+    } else if (policyName !== void 0) {
+      errors.push({ path: `${path4}.policy`, code: "APPROVAL_POLICY_MODE_REQUIRED", message: "approval.policy can only be set when approval.mode is policy." });
+    }
+  });
+}
+function validateApprovalPolicyRulesAgainstCapability(policy, policyIndex, capability, capabilityIndex, errors) {
+  if (!Array.isArray(policy.rules))
     return;
-  validateArrayRecords(value, "$.policies", POLICY_KEYS, "POLICY", errors);
+  const proposal = capability.proposal;
+  if (!proposal)
+    return;
+  policy.rules.forEach((rule, ruleIndex) => {
+    if (!isRecord3(rule))
+      return;
+    const field = rule.field;
+    const max = rule.max;
+    const rulePath = `$.policies[${policyIndex}].rules[${ruleIndex}]`;
+    if (!isSafeIdentifier2(field) || !Number.isInteger(max))
+      return;
+    if (!isNumericProposalField(proposal, capability.args, field)) {
+      errors.push({
+        path: `${rulePath}.field`,
+        code: "APPROVAL_POLICY_FIELD_NOT_NUMERIC",
+        message: `approval policy field ${field} must be numeric for capability ${capability.name}.`
+      });
+    }
+    const bound = proposal.numeric_bounds?.[field];
+    if (bound?.maximum !== void 0 && Number(max) > Number(bound.maximum)) {
+      errors.push({
+        path: `${rulePath}.max`,
+        code: "APPROVAL_POLICY_MAX_EXCEEDS_BOUND",
+        message: `approval policy max for ${field} must be <= numeric_bounds maximum on $.capabilities[${capabilityIndex}].proposal.numeric_bounds.${field}.maximum.`
+      });
+    }
+  });
+}
+function isNumericProposalField(proposal, args, field) {
+  if (proposal.numeric_bounds?.[field] !== void 0)
+    return true;
+  const patch = proposal.patch?.[field];
+  if (!patch)
+    return false;
+  if (typeof patch.fixed === "number" && Number.isInteger(patch.fixed))
+    return true;
+  if (patch.from_arg && args[patch.from_arg]?.type === "number")
+    return true;
+  return false;
 }
 function validateEvidenceRecords(value, errors) {
   if (value === void 0)
@@ -3455,18 +3667,23 @@ function loadRuntimeConfigFromFile(configPath = process.env.SYNAPSOR_MCP_CONFIG
 function resolveRuntimeConfig(config, baseDir = process.cwd()) {
   if (!Array.isArray(config.contracts) || config.contracts.length === 0) return config;
   const seenCapabilities = /* @__PURE__ */ new Map();
+  const seenPolicies = /* @__PURE__ */ new Map();
   for (const [index, capability] of (config.capabilities ?? []).entries()) {
     rememberCapabilityName(seenCapabilities, capability.name, `embedded capabilities[${index}]`);
   }
+  for (const [index, policy] of (config.policies ?? []).entries()) {
+    rememberPolicyName(seenPolicies, policy.name, `embedded policies[${index}]`);
+  }
   const resolved = {
     ...config,
     contexts: { ...config.contexts ?? {} },
-    capabilities: [...config.capabilities ?? []]
+    capabilities: [...config.capabilities ?? []],
+    policies: [...config.policies ?? []]
   };
   for (const [contractIndex, contractPath] of config.contracts.entries()) {
     const fullPath = path.resolve(baseDir, contractPath);
     const contract = normalizeContract(JSON.parse(fs.readFileSync(fullPath, "utf8")));
-    mergeContractIntoRuntimeConfig(resolved, contract, `contracts[${contractIndex}] ${contractPath}`, seenCapabilities);
+    mergeContractIntoRuntimeConfig(resolved, contract, `contracts[${contractIndex}] ${contractPath}`, seenCapabilities, seenPolicies);
   }
   delete resolved.contracts;
   return resolved;
@@ -3478,7 +3695,14 @@ function rememberCapabilityName(seen, name, origin) {
   }
   seen.set(name, origin);
 }
-function mergeContractIntoRuntimeConfig(config, contract, origin, seenCapabilities) {
+function rememberPolicyName(seen, name, origin) {
+  const previous = seen.get(name);
+  if (previous) {
+    throw new Error(`Duplicate policy ${name}: ${origin} conflicts with ${previous}. Policy names must be unique across embedded runner config and referenced contracts.`);
+  }
+  seen.set(name, origin);
+}
+function mergeContractIntoRuntimeConfig(config, contract, origin, seenCapabilities, seenPolicies) {
   const resources = new Map((contract.resources ?? []).map((resource) => [resource.name, resource]));
   for (const context of contract.contexts) {
     if (!config.contexts) config.contexts = {};
@@ -3493,6 +3717,13 @@ function mergeContractIntoRuntimeConfig(config, contract, origin, seenCapabiliti
     rememberCapabilityName(seenCapabilities, capability.name, `${origin} capabilities[${capabilityIndex}]`);
     config.capabilities.push(runtimeCapabilityFromSpec(capability, resources, config));
   }
+  if (contract.policies?.length) {
+    if (!config.policies) config.policies = [];
+    for (const [policyIndex, policy] of contract.policies.entries()) {
+      rememberPolicyName(seenPolicies, policy.name, `${origin} policies[${policyIndex}]`);
+      config.policies.push(policy);
+    }
+  }
 }
 function runtimeContextFromSpec(context) {
   const tenantBinding = context.bindings.find((binding) => binding.name === context.tenant_binding) ?? context.bindings.find((binding) => binding.name === "tenant_id");
@@ -4285,6 +4516,7 @@ async function callConfiguredTool(input) {
   }
   if (capability.kind === "proposal" && input.config.mode === "review") {
     assertProposalWritebackResolvable(input.config, capability);
+    assertApprovalPolicyResolvable(input.config, capability);
   }
   const source = input.config.sources?.[capability.source];
   if (!source) throw new McpRuntimeError("SOURCE_NOT_FOUND", `Unknown source: ${capability.source}`);
@@ -4380,6 +4612,13 @@ async function callConfiguredTool(input) {
     objectId
   });
   const proposal = input.store.createProposal(changeSet);
+  const approvalResult = maybeAutoApproveProposal({
+    config: input.config,
+    capability,
+    store: input.store,
+    proposal,
+    patch: changeSet.patch
+  });
   input.store.recordEvidenceBundle({
     evidence_bundle_id: evidenceBundleId,
     proposal_id: proposal.proposal_id,
@@ -4388,7 +4627,7 @@ async function callConfiguredTool(input) {
       capability: capability.name,
       proposal_id: proposal.proposal_id,
       source_database_changed: false,
-      approval_status: changeSet.approval.status
+      approval_status: approvalResult.proposal.state === "approved" ? "approved" : changeSet.approval.status
     },
     items: [
       {
@@ -4413,11 +4652,11 @@ async function callConfiguredTool(input) {
     }
   });
   return {
-    status: input.config.mode === "shadow" ? "shadow_proposal_created" : "review_required",
+    status: input.config.mode === "shadow" ? "shadow_proposal_created" : approvalResult.proposal.state === "approved" ? "approved" : "review_required",
     action: capability.name,
-    proposal_id: proposal.proposal_id,
-    proposal_version: proposal.proposal_version,
-    proposal_hash: proposal.proposal_hash,
+    proposal_id: approvalResult.proposal.proposal_id,
+    proposal_version: approvalResult.proposal.proposal_version,
+    proposal_hash: approvalResult.proposal.proposal_hash,
     target: {
       type: capability.target.table,
       id: objectId,
@@ -4428,7 +4667,12 @@ async function callConfiguredTool(input) {
     evidence_resource: `synapsor://evidence/${evidenceBundleId}`,
     proposal_resource: `synapsor://proposals/${proposal.proposal_id}`,
     replay_resource: `synapsor://replay/replay_${proposal.proposal_id}`,
-    approval_required: true,
+    approval: approvalResult.approved ? { mode: "policy", policy: approvalResult.policy } : {
+      mode: capability.approval?.mode ?? "human",
+      ...capability.approval?.policy ? { policy: capability.approval.policy } : {},
+      ...capability.approval?.required_role ? { required_role: capability.approval.required_role } : {}
+    },
+    approval_required: approvalResult.proposal.state === "pending_review",
     writeback: changeSet.writeback,
     source_database_changed: false,
     source_database_mutated: false
@@ -4454,6 +4698,9 @@ function resultEnvelopeFromLegacy(legacy, capability, canonicalName) {
     const proposalId = typeof legacy.proposal_id === "string" ? legacy.proposal_id : "wrp_unknown";
     const targetType = typeof target2?.type === "string" ? target2.type : capability?.target.table ?? "object";
     const targetId = target2?.id !== void 0 ? String(target2.id) : "unknown";
+    const approval = isRecord4(legacy.approval) ? legacy.approval : void 0;
+    const state = typeof legacy.status === "string" ? legacy.status : "review_required";
+    const approvalRequired = legacy.approval_required !== false;
     const executor = writebackExecutorName(legacy.writeback);
     const writebackMode = executor === "read_only" || executor === "none" ? "proposal_only" : executor && executor !== "sql_update" && executor !== "trusted_worker_required" ? "app_handler" : "direct_update";
     return {
@@ -4464,15 +4711,16 @@ function resultEnvelopeFromLegacy(legacy, capability, canonicalName) {
       data: null,
       proposal: {
         id: proposalId,
-        state: typeof legacy.status === "string" ? legacy.status : "review_required",
+        state,
         target: `${targetType}:${targetId}`,
         diff: isRecord4(legacy.diff) ? legacy.diff : {},
-        approval_required: legacy.approval_required !== false,
+        approval_required: approvalRequired,
+        ...approval ? { approval } : {},
         writeback: {
           mode: writebackMode,
           applied: false
         },
-        next: "A human must approve outside this model-facing tool surface; nothing is committed yet."
+        next: approvalRequired ? "A human must approve outside this model-facing tool surface; nothing is committed yet." : "The proposal is approved outside the model-facing tool surface; trusted writeback/apply is still separate."
       },
       error: null,
       evidence: evidenceBundleId ? evidenceHandle(evidenceBundleId) : null,
@@ -4548,6 +4796,68 @@ function assertProposalWritebackResolvable(config, capability) {
     throw new McpRuntimeError("WRITEBACK_UNRESOLVED", `capability ${capability.name} declares HANDLER writeback but executor ${executorName} is not an app-owned handler.`);
   }
 }
+function assertApprovalPolicyResolvable(config, capability) {
+  if (capability.kind !== "proposal" || capability.approval?.mode !== "policy") return;
+  const policyName = capability.approval.policy;
+  if (!policyName) {
+    throw new McpRuntimeError("APPROVAL_POLICY_UNRESOLVED", `capability ${capability.name} uses policy approval but does not name approval.policy.`);
+  }
+  const policy = approvalPolicyByName(config, policyName);
+  if (!policy) {
+    throw new McpRuntimeError("APPROVAL_POLICY_UNRESOLVED", `capability ${capability.name} references missing approval policy ${policyName}.`);
+  }
+}
+function maybeAutoApproveProposal(input) {
+  if (input.config.mode !== "review") return { proposal: input.proposal, approved: false };
+  if (input.config.approvals?.disable_auto_approval === true) return { proposal: input.proposal, approved: false };
+  if (input.capability.approval?.mode !== "policy" || !input.capability.approval.policy) return { proposal: input.proposal, approved: false };
+  if (input.proposal.state === "approved") return { proposal: input.proposal, approved: true, policy: input.capability.approval.policy };
+  if (input.proposal.state !== "pending_review") return { proposal: input.proposal, approved: false };
+  const policyName = input.capability.approval.policy;
+  const policy = approvalPolicyByName(input.config, policyName);
+  if (!policy) throw new McpRuntimeError("APPROVAL_POLICY_UNRESOLVED", `capability ${input.capability.name} references missing approval policy ${policyName}.`);
+  const evaluation = evaluateApprovalPolicy(input.capability, policy, input.patch);
+  if (!evaluation.qualifies) return { proposal: input.proposal, approved: false, policy: policyName };
+  const updated = input.store.approveProposal(input.proposal.proposal_id, {
+    approver: `policy:${policyName}`,
+    proposal_hash: input.proposal.proposal_hash,
+    proposal_version: input.proposal.proposal_version,
+    reason: `auto-approved by policy ${policyName}: ${evaluation.reason}`
+  });
+  return { proposal: updated, approved: true, policy: policyName };
+}
+function approvalPolicyByName(config, policyName) {
+  return (config.policies ?? []).find((policy) => policy.kind === "approval" && policy.name === policyName);
+}
+function evaluateApprovalPolicy(capability, policy, patch) {
+  const ruleByField = /* @__PURE__ */ new Map();
+  for (const rule of policy.rules ?? []) {
+    const field = typeof rule.field === "string" ? rule.field : void 0;
+    const max = typeof rule.max === "number" && Number.isInteger(rule.max) ? rule.max : void 0;
+    if (field && max !== void 0) ruleByField.set(field, max);
+  }
+  const numericFields = Object.keys(patch).filter((field) => isNumericRuntimeProposalField(capability, field));
+  if (numericFields.length === 0) return { qualifies: false, reason: "no numeric patch fields covered by policy" };
+  const reasons = [];
+  for (const field of numericFields) {
+    const max = ruleByField.get(field);
+    const value = patch[field];
+    if (max === void 0) return { qualifies: false, reason: `${field} has no matching policy rule` };
+    if (typeof value !== "number" || !Number.isInteger(value)) return { qualifies: false, reason: `${field} is not an integer` };
+    if (value > max) return { qualifies: false, reason: `${field} ${value} > ${max}` };
+    reasons.push(`${field} ${value} <= ${max}`);
+  }
+  return { qualifies: true, reason: reasons.join(", ") };
+}
+function isNumericRuntimeProposalField(capability, field) {
+  const proposal = {
+    action: capability.name,
+    allowed_fields: capability.allowed_columns ?? Object.keys(capability.patch ?? {}),
+    patch: capability.patch ?? {},
+    ...capability.numeric_bounds ? { numeric_bounds: capability.numeric_bounds } : {}
+  };
+  return isNumericProposalField(proposal, capability.args, field);
+}
 function evidenceHandle(bundleId) {
   return {
     bundle_id: bundleId,
@@ -4653,6 +4963,8 @@ function buildChangeSet(input) {
     },
     approval: {
       status: "pending",
+      ...input.capability.approval?.mode ? { mode: input.capability.approval.mode } : {},
+      ...input.capability.approval?.policy ? { policy: input.capability.approval.policy } : {},
       required_role: input.capability.approval?.required_role
     },
     writeback: {
@@ -6693,6 +7005,7 @@ function compileAgentDslWithWarnings(source) {
     ...context.tenantBinding ? { tenant_binding: context.tenantBinding } : {},
     ...context.principalBinding ? { principal_binding: context.principalBinding } : {}
   }));
+  const policies = [];
   const capabilities = ast.capabilities.map((capability) => {
     const spec = {
       name: capability.name,
@@ -6716,6 +7029,15 @@ function compileAgentDslWithWarnings(source) {
       ...capability.maxRows ? { max_rows: capability.maxRows } : {}
     };
     if (capability.kind === "proposal" && capability.proposal) {
+      const autoApprovalPolicyName = capability.proposal.autoApprovalRules?.length ? autoApprovalPolicyNameForCapability(capability.name) : void 0;
+      if (autoApprovalPolicyName) {
+        policies.push({
+          name: autoApprovalPolicyName,
+          kind: "approval",
+          mode: "green",
+          rules: capability.proposal.autoApprovalRules?.map((rule) => ({ field: rule.field, max: rule.max }))
+        });
+      }
       spec.proposal = {
         action: capability.proposal.action,
         allowed_fields: capability.proposal.allowedFields,
@@ -6723,7 +7045,7 @@ function compileAgentDslWithWarnings(source) {
         ...capability.proposal.numericBounds ? { numeric_bounds: capability.proposal.numericBounds } : {},
         ...capability.proposal.transitionGuards ? { transition_guards: capability.proposal.transitionGuards } : {},
         conflict_guard: capability.conflictKey ? { column: capability.conflictKey } : { weak_guard_ack: true },
-        approval: { mode: "human", required_role: capability.proposal.approvalRole ?? "local_reviewer" },
+        approval: autoApprovalPolicyName ? { mode: "policy", required_role: capability.proposal.approvalRole ?? "local_reviewer", policy: autoApprovalPolicyName } : { mode: "human", required_role: capability.proposal.approvalRole ?? "local_reviewer" },
         writeback: {
           mode: capability.proposal.writebackMode ?? "direct_sql",
           ...capability.proposal.executor ? { executor: capability.proposal.executor } : {}
@@ -6745,7 +7067,8 @@ function compileAgentDslWithWarnings(source) {
     kind: "SynapsorContract",
     contexts,
     capabilities,
-    ...workflows.length ? { workflows } : {}
+    ...workflows.length ? { workflows } : {},
+    ...policies.length ? { policies } : {}
   };
   assertValidContract(contract);
   return { contract: normalizeContract(contract), warnings: collectDslWarnings(ast) };
@@ -6972,6 +7295,12 @@ function parseCapabilityBlock(block) {
       capability.proposal.approvalRole = approval[1];
       continue;
     }
+    const autoApproval = item.text.match(/^AUTO\s+APPROVE\s+WHEN\s+(.+)$/i);
+    if (autoApproval?.[1]) {
+      ensureProposal(capability, item);
+      parseAutoApprovalClause(capability, autoApproval[1], item.line);
+      continue;
+    }
     const writeback2 = item.text.match(/^WRITEBACK\s+(DIRECT\s+SQL|APP\s+HANDLER|CLOUD\s+WORKER|NONE)(?:\s+EXECUTOR\s+([A-Za-z_][A-Za-z0-9_.-]*))?$/i);
     if (writeback2?.[1]) {
       ensureProposal(capability, item);
@@ -7032,6 +7361,52 @@ function collectDslWarnings(ast) {
   }
   return warnings;
 }
+function parseAutoApprovalClause(capability, rawCondition, line) {
+  if (!capability.proposal.approvalRole) {
+    throw dslError(line, 1, "AUTO_APPROVE_APPROVAL_ROLE_REQUIRED", "AUTO APPROVE WHEN requires an explicit APPROVAL ROLE before it");
+  }
+  const condition = rawCondition.trim();
+  const match = condition.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*(<=)\s*(.+)$/);
+  if (!match?.[1] || !match[3]) {
+    throw dslError(line, 1, "AUTO_APPROVE_UNSUPPORTED", "AUTO APPROVE WHEN supports only: <field> <= <integer>");
+  }
+  const field = match[1];
+  const rawMax = match[3].trim();
+  if (!/^\d+$/.test(rawMax)) {
+    throw dslError(line, 1, "AUTO_APPROVE_MAX_INVALID", "AUTO APPROVE WHEN max must be a non-negative integer");
+  }
+  const max = Number(rawMax);
+  if (!Number.isSafeInteger(max)) {
+    throw dslError(line, 1, "AUTO_APPROVE_MAX_INVALID", "AUTO APPROVE WHEN max must be a safe non-negative integer");
+  }
+  if (!Object.prototype.hasOwnProperty.call(capability.proposal.patch, field)) {
+    throw dslError(line, 1, "AUTO_APPROVE_FIELD_NOT_PATCHED", `AUTO APPROVE WHEN field ${field} must be in the PATCH list`);
+  }
+  if (!isNumericDslProposalField(capability, field)) {
+    throw dslError(line, 1, "AUTO_APPROVE_FIELD_NOT_NUMERIC", `AUTO APPROVE WHEN field ${field} must be numeric by BOUND, NUMBER arg patch, or integer literal patch`);
+  }
+  const boundMax = capability.proposal.numericBounds?.[field]?.maximum;
+  if (boundMax !== void 0 && max > boundMax) {
+    throw dslError(line, 1, "AUTO_APPROVE_MAX_EXCEEDS_BOUND", `AUTO APPROVE WHEN max for ${field} must be <= BOUND maximum ${boundMax}`);
+  }
+  capability.proposal.autoApprovalRules ??= [];
+  if (capability.proposal.autoApprovalRules.some((rule) => rule.field === field)) {
+    throw dslError(line, 1, "AUTO_APPROVE_DUPLICATE_FIELD", `AUTO APPROVE WHEN already defines a rule for ${field}`);
+  }
+  capability.proposal.autoApprovalRules.push({ field, max, line });
+}
+function isNumericDslProposalField(capability, field) {
+  if (capability.proposal.numericBounds?.[field] !== void 0)
+    return true;
+  const patch = capability.proposal.patch[field];
+  if (!patch)
+    return false;
+  if (typeof patch.fixed === "number" && Number.isInteger(patch.fixed))
+    return true;
+  if (patch.from_arg && capability.args[patch.from_arg]?.type === "number")
+    return true;
+  return false;
+}
 function parseWorkflowBlock(block) {
   const workflow = { name: block.name, context: "", allowedCapabilities: [] };
   for (const item of block.body) {
@@ -7191,6 +7566,9 @@ function normalizeWritebackMode(mode) {
     return "cloud_worker";
   return "none";
 }
+function autoApprovalPolicyNameForCapability(name) {
+  return `${name.replace(/[^A-Za-z0-9_]/g, "_")}_auto_approval`;
+}
 function parseList(value) {
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
@@ -9894,6 +10272,32 @@ function proposalWritebackResolutionDoctorCheck(config, capability) {
     };
   }
 }
+function proposalApprovalPolicyResolutionDoctorCheck(config, capability) {
+  if (capability.approval?.mode !== "policy") {
+    return {
+      name: `capability:${capability.name}:approval-policy-resolution`,
+      ok: true,
+      level: "pass",
+      message: "Capability does not use policy auto-approval."
+    };
+  }
+  try {
+    assertApprovalPolicyResolvable(config, capability);
+    return {
+      name: `capability:${capability.name}:approval-policy-resolution`,
+      ok: true,
+      level: "pass",
+      message: `Approval policy ${capability.approval.policy} resolves from the reviewed contract/config.`
+    };
+  } catch (error) {
+    return {
+      name: `capability:${capability.name}:approval-policy-resolution`,
+      ok: false,
+      level: "fail",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 async function httpHandlerReachabilityCheck(executorName, rawUrl, timeoutMs) {
   try {
     const url = new URL(rawUrl);
@@ -10401,6 +10805,7 @@ async function localDoctor(args) {
   if (parsed.mode === "review") {
     for (const capability of (parsed.capabilities ?? []).filter((item) => item.kind === "proposal")) {
       checks.push(proposalWritebackResolutionDoctorCheck(parsed, capability));
+      checks.push(proposalApprovalPolicyResolutionDoctorCheck(parsed, capability));
     }
   }
   for (const [sourceName, source] of Object.entries(sources)) {
@@ -11581,6 +11986,8 @@ async function cloudPush(args) {
     process2.stdout.write(`Workflows: ${payload.summary.workflows}
 `);
     process2.stdout.write(`Proposal capabilities: ${payload.summary.proposal_capabilities}
+`);
+    process2.stdout.write(`Approval policies: ${payload.summary.approval_policies}
 `);
     process2.stdout.write(`Kept-out fields: ${payload.summary.kept_out_fields}
 `);
@@ -11628,12 +12035,17 @@ async function cloudPush(args) {
   return 0;
 }
 function contractSummary(contract) {
+  const keptOutFields = /* @__PURE__ */ new Set();
+  for (const capability of contract.capabilities) {
+    for (const field of capability.kept_out_fields ?? []) keptOutFields.add(field);
+  }
   return {
     contexts: contract.contexts.length,
     capabilities: contract.capabilities.length,
     workflows: contract.workflows?.length ?? 0,
     proposal_capabilities: contract.capabilities.filter((capability) => capability.kind === "proposal").length,
-    kept_out_fields: contract.capabilities.reduce((count, capability) => count + (capability.kept_out_fields?.length ?? 0), 0)
+    approval_policies: contract.policies?.filter((policy) => policy.kind === "approval").length ?? 0,
+    kept_out_fields: keptOutFields.size
   };
 }
 async function postCloudContractPush(input) {
@@ -12802,8 +13214,11 @@ function formatProposeResult(capabilityName, result, storePath) {
   const proposalId = String(result.proposal_id ?? "");
   const evidenceId = String(result.evidence_bundle_id ?? "");
   const sourceChanged = result.source_database_changed === true || result.source_database_mutated === true;
+  const status = String(result.status ?? "review_required");
+  const approval = isRecord7(result.approval) ? result.approval : void 0;
+  const autoApproved = status === "approved" && approval?.mode === "policy";
   const lines = [
-    "Proposal created.",
+    autoApproved ? "Proposal created and policy-approved." : "Proposal created.",
     "",
     "Capability:",
     capabilityName,
@@ -12817,9 +13232,12 @@ function formatProposeResult(capabilityName, result, storePath) {
     "Source DB changed:",
     sourceChanged ? "yes" : "no",
     "",
+    "Approval:",
+    autoApproved ? `approved by policy ${String(approval?.policy ?? "")}` : "required outside MCP",
+    "",
     "Review:",
     `${cliCommandName()} proposals show ${proposalId || "latest"} --store ${storePath}`,
-    `${cliCommandName()} proposals approve ${proposalId || "latest"} --store ${storePath}`,
+    ...autoApproved ? [] : [`${cliCommandName()} proposals approve ${proposalId || "latest"} --store ${storePath}`],
     `${cliCommandName()} apply ${proposalId || "latest"} --store ${storePath}`,
     `${cliCommandName()} replay ${proposalId || "latest"} --store ${storePath}`,
     ""
@@ -13037,6 +13455,7 @@ async function toolsPreview(args) {
       config_path: boundary.configPath,
       store_path: boundary.storePath,
       alias_mode: boundary.aliasMode,
+      auto_approval: boundary.autoApprovalDisabled ? "disabled" : "enabled",
       exposed_to_mcp: boundary.names,
       alias_mappings: boundary.exposures,
       not_exposed_to_mcp: defaultBlockedToolSurface(),
@@ -13065,6 +13484,7 @@ Run ${cliCommandName()} onboard db --from-env DATABASE_URL, or pass --config <pa
   const runtime = createMcpRuntime(parsed, { storePath });
   try {
     const tools2 = runtime.listTools();
+    const autoApprovalDisabled = parsed.approvals?.disable_auto_approval === true;
     const exposures = toolNameExposures(tools2.map((tool) => tool.name), aliasMode);
     const names = exposures.map((item) => item.exposedName);
     const serialized = JSON.stringify(tools2);
@@ -13077,7 +13497,7 @@ Run ${cliCommandName()} onboard db --from-env DATABASE_URL, or pass --config <pa
       { name: "write credentials absent", ok: !/(password|secret|bearer|private[_-]?key|token)/i.test(serialized), detail: "MCP tools do not include write credentials" }
     ];
     const ok = checks.every((check) => check.ok);
-    return { ok, configPath, storePath, aliasMode, names, exposures, checks };
+    return { ok, configPath, storePath, aliasMode, names, exposures, autoApprovalDisabled, checks };
   } finally {
     runtime.close();
   }
@@ -13100,6 +13520,7 @@ function formatToolsPreview(input) {
     `Config: ${input.configPath}`,
     `Store: ${input.storePath}`,
     `Alias mode: ${input.aliasMode}`,
+    `auto-approval: ${input.autoApprovalDisabled ? "disabled" : "enabled"}`,
     "",
     "Exposed to MCP:",
     ...exposedLines,
@@ -15894,11 +16315,14 @@ function formatReceiptId(receiptId) {
   return `rct_${String(receiptId).padStart(6, "0")}`;
 }
 function approvalBoundary(proposal) {
+  const approval = proposal.change_set.approval;
+  const policy = typeof approval.policy === "string" ? approval.policy : void 0;
+  const policyActor = policy ? `policy:${policy}` : void 0;
   if (proposal.state === "pending_review") return "required outside MCP";
-  if (proposal.state === "approved" || proposal.state === "pending_worker") return "approved outside MCP; waiting for trusted worker";
-  if (proposal.state === "applied") return "approved outside MCP; writeback applied";
-  if (proposal.state === "conflict") return "approved outside MCP; writeback blocked by conflict guard";
-  if (proposal.state === "failed") return "approved outside MCP; writeback failed safely";
+  if (proposal.state === "approved" || proposal.state === "pending_worker") return `${policyActor ? `approved by ${policyActor}` : "approved outside MCP"}; waiting for trusted worker`;
+  if (proposal.state === "applied") return `${policyActor ? `approved by ${policyActor}` : "approved outside MCP"}; writeback applied`;
+  if (proposal.state === "conflict") return `${policyActor ? `approved by ${policyActor}` : "approved outside MCP"}; writeback blocked by conflict guard`;
+  if (proposal.state === "failed") return `${policyActor ? `approved by ${policyActor}` : "approved outside MCP"}; writeback failed safely`;
   if (proposal.state === "rejected") return "rejected outside MCP";
   return humanStatus(proposal.state);
 }